Cómo usar el comando docker compose up para gestionar contenedores

Introducción

En este laboratorio, aprenderás a gestionar contenedores de manera efectiva utilizando el comando docker compose up. Cubriremos el uso fundamental de docker compose up para iniciar servicios definidos en un archivo docker-compose.yml, incluyendo la ejecución de servicios en primer plano y en modo desatendido (detached mode).

Además, explorarás opciones avanzadas de docker compose up, como forzar la recreación de contenedores con force-recreate, evitar recreaciones innecesarias con no-recreate, y construir imágenes automáticamente antes de iniciar los contenedores. Al finalizar este laboratorio, serás competente en el uso de docker compose up para diversos escenarios de gestión de contenedores.

Skills Graph

Iniciar servicios con docker compose up

En este paso, aprenderás cómo iniciar servicios definidos en un archivo docker-compose.yml usando el comando docker compose up. Antes de comenzar, necesitamos instalar Docker Compose ya que no viene preinstalado en este entorno.

Primero, instalemos Docker Compose. Descargaremos la última versión estable y la haremos ejecutable.

sudo curl -L "https://github.com/docker/compose/releases/download/v2.20.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose

Ahora que Docker Compose está instalado, creemos un archivo simple docker-compose.yml para definir un servicio. Crearemos un archivo llamado docker-compose.yml en tu directorio ~/project.

nano ~/project/docker-compose.yml

Agrega el siguiente contenido al archivo:

version: "3.8"
services:
  web:
    image: nginx:latest
    ports:
      - "80:80"

Este archivo docker-compose.yml define un único servicio llamado web. Utiliza la imagen nginx:latest y mapea el puerto 80 del host al puerto 80 del contenedor.

Ahora, usemos docker compose up para iniciar el servicio. Navega al directorio ~/project y ejecuta el comando.

cd ~/project
docker compose up

Verás una salida que indica que Docker Compose está creando e iniciando el contenedor web. Por defecto, docker compose up se ejecuta en primer plano, mostrando los logs de los servicios en ejecución.

Para verificar que el contenedor Nginx está funcionando, puedes abrir una nueva terminal o usar curl para acceder al servidor web.

curl http://localhost

Deberías ver el HTML de la página de bienvenida predeterminada de Nginx. Esto confirma que el servicio web está en ejecución y accesible.

Para detener los servicios, presiona Ctrl+C en la terminal donde se está ejecutando docker compose up. Esto detendrá y eliminará los contenedores.

Ejecutar servicios en modo desatendido (detached mode)

En el paso anterior, iniciaste los servicios usando docker compose up, que se ejecutó en primer plano. Esto es útil para depuración, pero para ejecutar servicios en producción o en segundo plano, querrás usar el modo desatendido.

El modo desatendido significa que Docker Compose iniciará los contenedores y luego saldrá, dejando los contenedores ejecutándose en segundo plano. Esto te permite continuar usando tu terminal para otras tareas.

Para ejecutar los servicios en modo desatendido, simplemente añade el flag -d al comando docker compose up. Asegúrate de estar en el directorio ~/project donde se encuentra tu archivo docker-compose.yml.

cd ~/project
docker compose up -d

Verás una salida indicando que los contenedores están siendo creados e iniciados, pero el comando te devolverá al prompt de la terminal una vez que los servicios estén en ejecución.

Para verificar que el contenedor está ejecutándose en segundo plano, puedes usar el comando docker ps para listar los contenedores en ejecución.

docker ps

Deberías ver una entrada para el contenedor project-web-1 (el nombre típicamente sigue el formato [nombre_directorio]-[nombre_servicio]-[número_instancia]).

Aún puedes acceder al servidor web Nginx usando curl para confirmar que está funcionando.

curl http://localhost

Deberías ver nuevamente el HTML de la página de bienvenida predeterminada de Nginx.

Para detener los servicios que fueron iniciados en modo desatendido, puedes usar el comando docker compose down en el mismo directorio donde se encuentra tu archivo docker-compose.yml.

docker compose down

Este comando detendrá y eliminará los contenedores, redes y volúmenes creados por docker compose up.

Recrear contenedores con force-recreate

En el paso anterior, aprendiste cómo ejecutar servicios en modo desatendido. Por defecto, cuando ejecutas docker compose up nuevamente con el mismo archivo docker-compose.yml y los contenedores ya están en ejecución, Docker Compose no recreará los contenedores a menos que haya cambios en la definición del servicio (como la imagen o los puertos).

En ocasiones, es posible que desees forzar a Docker Compose a detener y recrear los contenedores incluso cuando no hay cambios en la definición del servicio. Esto puede ser útil para aplicar actualizaciones que no involucren modificar el archivo docker-compose.yml, o simplemente para garantizar un inicio limpio del contenedor.

Para forzar la recreación de contenedores, puedes usar el flag --force-recreate con el comando docker compose up.

Primero, asegúrate de que tu servicio web esté ejecutándose en modo desatendido desde el paso anterior. Si no es así, ejecuta:

cd ~/project
docker compose up -d

Ahora, ejecutemos docker compose up nuevamente con el flag --force-recreate.

cd ~/project
docker compose up -d --force-recreate

Verás una salida indicando que Docker Compose está deteniendo y luego recreando el contenedor web. Aunque el archivo docker-compose.yml no ha cambiado, el flag --force-recreate indica a Docker Compose que elimine el contenedor existente y cree uno nuevo basado en la configuración actual.

Puedes verificar que el contenedor fue recreado revisando el ID del contenedor usando docker ps. El ID del contenedor debería ser diferente al que viste antes de ejecutar el comando con --force-recreate.

docker ps

Observa el ID del contenedor en la salida.

Para limpiar, detén los servicios en ejecución:

cd ~/project
docker compose down

Prevenir la recreación con no-recreate

En el paso anterior, aprendiste cómo forzar la recreación de contenedores usando el flag --force-recreate. Ahora, veamos el escenario opuesto: prevenir la recreación.

Como se mencionó anteriormente, por defecto docker compose up no recreará contenedores si ya están en ejecución y su configuración en el archivo docker-compose.yml no ha cambiado. Sin embargo, pueden existir situaciones donde quieras asegurar explícitamente que los contenedores existentes no sean recreados, incluso si hubo cambios menores que normalmente podrían activar una recreación.

Para prevenir la recreación de contenedores, puedes usar el flag --no-recreate con el comando docker compose up.

Primero, asegúrate de que tu servicio web esté detenido. Si está en ejecución, detenlo usando:

cd ~/project
docker compose down

Ahora, iniciemos el servicio usando docker compose up -d:

cd ~/project
docker compose up -d

Verifica que el contenedor esté en ejecución:

docker ps

Anota el ID del contenedor.

Ahora, ejecutemos docker compose up nuevamente con el flag --no-recreate:

cd ~/project
docker compose up -d --no-recreate

Verás una salida indicando que el servicio está actualizado y el contenedor no está siendo recreado. Si revisas docker ps nuevamente, verás que el ID del contenedor es el mismo que antes.

docker ps

Esto demuestra que el flag --no-recreate previno exitosamente que Docker Compose recreara el contenedor existente.

Para limpiar, detén los servicios en ejecución:

cd ~/project
docker compose down

Construir imágenes antes de iniciar contenedores

En los pasos anteriores, utilizamos imágenes Docker preconstruidas de Docker Hub (como nginx:latest). Sin embargo, frecuentemente necesitarás construir tus propias imágenes Docker personalizadas para tus aplicaciones.

Docker Compose puede construir automáticamente las imágenes definidas en tu archivo docker-compose.yml antes de iniciar los servicios. Esto se hace típicamente especificando un contexto de build en lugar de un nombre de image para un servicio.

Modifiquemos nuestro archivo docker-compose.yml para construir una imagen personalizada simple de Nginx.

Primero, crea un nuevo directorio llamado nginx_custom dentro de ~/project:

cd ~/project
mkdir nginx_custom

Ahora, crea un Dockerfile dentro del directorio nginx_custom:

nano ~/project/nginx_custom/Dockerfile

Agrega el siguiente contenido al Dockerfile:

FROM nginx:latest
RUN echo '<h1>Hello from Custom Nginx!</h1>' >/usr/share/nginx/html/index.html

Este Dockerfile parte de la imagen oficial nginx:latest y luego reemplaza el archivo index.html predeterminado con uno personalizado.

A continuación, modifica tu archivo ~/project/docker-compose.yml para usar este Dockerfile y construir la imagen del servicio web. Abre el archivo para editar:

nano ~/project/docker-compose.yml

Cambia la definición del servicio web para usar build en lugar de image:

version: "3.8"
services:
  web:
    build: ./nginx_custom
    ports:
      - "80:80"

Ahora, cuando ejecutes docker compose up, Docker Compose primero construirá la imagen definida por el Dockerfile en el directorio ./nginx_custom y luego iniciará un contenedor usando esa imagen recién construida.

Asegúrate de estar en el directorio ~/project y ejecuta:

cd ~/project
docker compose up -d

Verás una salida que indica que Docker Compose está construyendo la imagen y luego creando e iniciando el contenedor.

Para verificar que se está sirviendo la página personalizada de Nginx, usa curl:

curl http://localhost

Deberías ver la salida <h1>Hello from Custom Nginx!</h1>, confirmando que la imagen fue construida y el contenedor se está ejecutando con el contenido personalizado.

Para limpiar, detén los servicios en ejecución:

cd ~/project
docker compose down

Resumen

En este laboratorio, aprendiste a utilizar el comando docker compose up para gestionar contenedores. Comenzaste instalando Docker Compose y creando un archivo docker-compose.yml simple para definir un servicio web utilizando la imagen de Nginx. Luego usaste docker compose up para iniciar el servicio, observando que por defecto se ejecuta en primer plano y muestra los logs del contenedor. Verificaste el servicio en ejecución accediendo a la página de bienvenida de Nginx.

El laboratorio también presentó la ejecución de servicios en modo desacoplado usando el flag -d, permitiendo que el comando finalice mientras los contenedores continúan ejecutándose en segundo plano. Aprendiste a forzar la recreación de contenedores incluso si su configuración no ha cambiado usando el flag --force-recreate, y cómo prevenir la recreación de contenedores existentes con el flag --no-recreate. Finalmente, exploraste el flag --build para construir o reconstruir imágenes antes de iniciar contenedores, asegurando que se utilice la imagen más reciente.