Uso efectivo del comando Docker Compose Down

Introducción

El comando Docker Compose Down es una herramienta esencial en la gestión de contenedores Docker. Este laboratorio te guiará a través del uso efectivo de docker-compose down para detener y limpiar correctamente contenedores, redes, volúmenes e imágenes de Docker. Al dominar este comando, podrás mantener un entorno de Docker limpio y optimizar tu flujo de trabajo de desarrollo.

Instalación de Docker Compose y creación de un proyecto de muestra

En este paso, nos aseguraremos de que Docker Compose esté instalado correctamente y crearemos un proyecto de Docker Compose de muestra con el que trabajar.

Verificación de la instalación de Docker Compose

Primero, verifiquemos si Docker Compose se instaló correctamente durante la configuración:

docker-compose version

Deberías ver una salida similar a esta (los detalles exactos de la compilación pueden variar):

docker-compose version 1.29.2, build unknown

Creación de un archivo Docker Compose simple

Ahora, creemos un archivo Docker Compose simple que usaremos a lo largo de este laboratorio. Crearemos un archivo llamado docker-compose.yml en el directorio actual con un servicio web básico basado en Nginx.

Usa el editor nano para crear el archivo:

cd ~/project/docker-compose-demo
nano docker-compose.yml

Copia y pega el siguiente contenido en el editor:

version: "3"
services:
  web:
    image: nginx:latest
    ports:
      - "8080:80"
    volumes:
      - web_data:/usr/share/nginx/html

  db:
    image: redis:latest
    volumes:
      - db_data:/data

volumes:
  web_data:
  db_data:

Guarda el archivo presionando Ctrl+O, luego Enter, y sal con Ctrl+X.

Este archivo Docker Compose define:

• Un servicio web que utiliza la imagen de Nginx
• Un servicio de base de datos que utiliza Redis
• Dos volúmenes con nombre para el almacenamiento persistente de datos

Inicio de los servicios de Docker Compose

Iniciemos los servicios definidos en nuestro archivo Docker Compose:

docker-compose up -d

El indicador -d ejecuta los contenedores en modo "detached" (en segundo plano). Deberías ver una salida similar a:

Creating network "docker-compose-demo_default" with the default driver
Creating volume "docker-compose-demo_web_data" with default driver
Creating volume "docker-compose-demo_db_data" with default driver
Creating docker-compose-demo_web_1 ... done
Creating docker-compose-demo_db_1  ... done

Verificación de los contenedores en ejecución

Comprobemos que nuestros contenedores se están ejecutando:

docker-compose ps

Deberías ver una salida que muestra que ambos servicios están activos y en funcionamiento:

        Name                       Command               State          Ports
-----------------------------------------------------------------------------------
docker-compose-demo_db_1    docker-entrypoint.sh redis ...   Up      6379/tcp
docker-compose-demo_web_1   /docker-entrypoint.sh ngin ...   Up      0.0.0.0:8080->80/tcp

También puedes verificar que el servidor web Nginx sea accesible usando curl:

curl http://localhost:8080

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

Ahora que tenemos nuestros servicios en funcionamiento, estamos listos para aprender sobre el comando docker-compose down en el siguiente paso.

Entendiendo y usando Docker Compose Down

En este paso, ahora que nuestros servicios de Docker Compose están en ejecución, aprenderemos sobre el comando docker-compose down y cómo usarlo de manera efectiva.

¿Qué es Docker Compose Down?

El comando docker-compose down se utiliza para detener y eliminar contenedores, redes, volúmenes e imágenes creados por docker-compose up. Este comando es esencial para limpiar recursos cuando ya no los necesitas o cuando deseas restablecer tu entorno.

Uso básico de Docker Compose Down

La forma más sencilla del comando es:

docker-compose down

Ejecutemos este comando y observemos qué sucede:

cd ~/project/docker-compose-demo
docker-compose down

Deberías ver una salida similar a:

Stopping docker-compose-demo_web_1 ... done
Stopping docker-compose-demo_db_1  ... done
Removing docker-compose-demo_web_1 ... done
Removing docker-compose-demo_db_1  ... done
Removing network docker-compose-demo_default

Observa que el comando:

• Detiene todos los contenedores en ejecución definidos en tu archivo Docker Compose
• Elimina todos los contenedores
• Elimina la red creada por Docker Compose

Sin embargo, no elimina los volúmenes de forma predeterminada. Este es un punto importante a entender: los volúmenes persisten más allá del ciclo de vida de los contenedores para preservar tus datos.

Verificación de que los recursos fueron eliminados

Confirmemos que los contenedores y la red han sido eliminados:

docker-compose ps

Deberías ver una lista vacía, lo que indica que no hay contenedores en ejecución de este proyecto de Docker Compose.

Comprobemos si los volúmenes aún existen:

docker volume ls | grep docker-compose-demo

Deberías ver que los volúmenes aún existen:

local     docker-compose-demo_db_data
local     docker-compose-demo_web_data

Este comportamiento predeterminado es importante porque preserva tus datos durante los reinicios de los contenedores. Si quisieras eliminar estos volúmenes también, necesitarías usar opciones adicionales, las cuales cubriremos en el siguiente paso.

Reinicio de los servicios

Iniciemos nuestros servicios nuevamente, ya que los necesitaremos para el siguiente paso:

docker-compose up -d

Deberías ver:

Creating network "docker-compose-demo_default" with the default driver
Creating docker-compose-demo_web_1 ... done
Creating docker-compose-demo_db_1  ... done

Observa que Docker Compose no necesitó recrear los volúmenes ya que estos ya existen.

Ahora entiendes el uso básico de docker-compose down. En el siguiente paso, exploraremos opciones más avanzadas para controlar exactamente qué recursos se eliminan.

Uso de Docker Compose Down con opciones avanzadas

El comando básico docker-compose down es útil, pero Docker Compose proporciona opciones adicionales para darte más control sobre qué recursos se eliminan. En este paso, exploraremos estas opciones.

Eliminación de volúmenes

Como observamos en el paso anterior, docker-compose down no elimina los volúmenes de forma predeterminada. Esta es una característica de seguridad para evitar la pérdida accidental de datos. Sin embargo, hay momentos en los que también deseas eliminar volúmenes, como cuando realizas una limpieza completa o cuando deseas restablecer los datos de tu aplicación.

Para eliminar volúmenes junto con contenedores y redes, usa el indicador --volumes:

docker-compose down --volumes

Probémoslo:

cd ~/project/docker-compose-demo
docker-compose down --volumes

Deberías ver una salida similar a:

Stopping docker-compose-demo_web_1 ... done
Stopping docker-compose-demo_db_1  ... done
Removing docker-compose-demo_web_1 ... done
Removing docker-compose-demo_db_1  ... done
Removing network docker-compose-demo_default
Removing volume docker-compose-demo_web_data
Removing volume docker-compose-demo_db_data

Observa que esta vez, los volúmenes también se eliminan.

Verifiquemos que los volúmenes hayan sido eliminados:

docker volume ls | grep docker-compose-demo

No deberías ver ninguna salida, lo que confirma que los volúmenes han sido eliminados.

Eliminación de imágenes

Otra opción útil es eliminar las imágenes al cerrar tu entorno de Docker Compose. Esto se puede hacer con el indicador --rmi, que acepta diferentes valores:

• --rmi all: Elimina todas las imágenes utilizadas por cualquier servicio
• --rmi local: Elimina solo las imágenes que no tienen una etiqueta personalizada

Iniciemos nuestros servicios nuevamente y luego usemos el indicador --rmi:

docker-compose up -d

Espera a que los servicios se inicien, luego ciérralos con el indicador --rmi:

docker-compose down --rmi local

Deberías ver una salida similar a:

Stopping docker-compose-demo_web_1 ... done
Stopping docker-compose-demo_db_1  ... done
Removing docker-compose-demo_web_1 ... done
Removing docker-compose-demo_db_1  ... done
Removing network docker-compose-demo_default
Removing image redis:latest
Removing image nginx:latest

Esta vez, las imágenes también se eliminan.

Eliminación de contenedores huérfanos

A veces, puedes tener contenedores que fueron creados por Docker Compose pero que ya no están definidos en tu archivo docker-compose.yml actual. Estos se denominan "contenedores huérfanos".

Para demostrar esto, modifiquemos nuestro archivo Docker Compose para eliminar el servicio db:

nano docker-compose.yml

Edita el archivo para eliminar el servicio db y su volumen:

version: "3"
services:
  web:
    image: nginx:latest
    ports:
      - "8080:80"
    volumes:
      - web_data:/usr/share/nginx/html

volumes:
  web_data:

Guarda y sal del editor (Ctrl+O, Enter, Ctrl+X).

Ahora, iniciemos nuestros servicios nuevamente con el archivo actualizado:

docker-compose up -d

Si tuviéramos un contenedor anterior ejecutándose para el servicio db que no se detuvo correctamente, ahora se consideraría un huérfano. Podemos eliminar dichos huérfanos usando el indicador --remove-orphans:

docker-compose down --remove-orphans

Esto asegura que cualquier contenedor que haya sido creado por una versión anterior de tu archivo Docker Compose pero que ya no esté definido, también sea eliminado.

Combinación de opciones

También puedes combinar estas opciones para una limpieza completa:

docker-compose down --volumes --rmi all --remove-orphans

Este comando hará lo siguiente:

• Detendrá y eliminará todos los contenedores
• Eliminará todos los volúmenes con nombre
• Eliminará todas las imágenes utilizadas por cualquier servicio
• Eliminará cualquier contenedor huérfano

Esto es particularmente útil cuando deseas restablecer completamente tu entorno o cuando te preparas para realizar cambios significativos en tu configuración de Docker Compose.

Exploración de opciones adicionales

Puedes ver todas las opciones disponibles para el comando docker-compose down usando el indicador de ayuda:

docker-compose down --help

Tómate un momento para revisar las opciones disponibles y sus descripciones.

Ahora tienes una buena comprensión de cómo usar docker-compose down con varias opciones para controlar qué recursos se eliminan al cerrar tu entorno de Docker Compose.

Mejores prácticas y escenarios del mundo real

En este paso, ahora que entiendes el comando docker-compose down y sus opciones, exploraremos las mejores prácticas y escenarios del mundo real para usar este comando de manera efectiva.

Creación de un entorno de Docker Compose más complejo

Para demostrar mejor el uso en el mundo real, creemos un entorno de Docker Compose más complejo. Configuraremos una aplicación web simple con un frontend, un backend y una base de datos.

cd ~/project/docker-compose-demo
nano docker-compose.yml

Reemplaza el contenido con:

version: "3"

services:
  frontend:
    image: nginx:alpine
    ports:
      - "8080:80"
    volumes:
      - frontend_data:/usr/share/nginx/html
    networks:
      - app_network

  backend:
    image: node:14-alpine
    command: sh -c "echo 'Backend service running' && sleep infinity"
    volumes:
      - backend_data:/app
    networks:
      - app_network
      - db_network

  database:
    image: postgres:13-alpine
    environment:
      POSTGRES_PASSWORD: example
      POSTGRES_USER: user
      POSTGRES_DB: appdb
    volumes:
      - db_data:/var/lib/postgresql/data
    networks:
      - db_network

networks:
  app_network:
  db_network:

volumes:
  frontend_data:
  backend_data:
  db_data:

Guarda y sal del editor.

Iniciemos este entorno más complejo:

docker-compose up -d

Deberías ver una salida que muestra la creación de redes, volúmenes y contenedores para los tres servicios.

Mejor práctica: Uso de entornos

En escenarios del mundo real, es posible que tengas diferentes entornos como desarrollo, pruebas y producción. Docker Compose te permite usar diferentes archivos de configuración para diferentes entornos.

Crea un archivo para el entorno de desarrollo:

nano docker-compose.dev.yml

Agrega el siguiente contenido:

version: "3"

services:
  frontend:
    ports:
      - "8081:80"
    environment:
      NODE_ENV: development

  backend:
    environment:
      NODE_ENV: development
      DEBUG: "true"

  database:
    ports:
      - "5432:5432"

Guarda y sal del editor.

Para usar este archivo en combinación con el archivo base, puedes usar el indicador -f:

docker-compose -f docker-compose.yml -f docker-compose.dev.yml up -d

Esto fusionará las configuraciones, aplicando los ajustes específicos de desarrollo.

Para cerrar este entorno, usarías:

docker-compose -f docker-compose.yml -f docker-compose.dev.yml down

Mejor práctica: Uso de un script de limpieza

En los flujos de trabajo de integración/despliegue continuo (CI/CD) o de desarrollo, a menudo es útil tener un script de limpieza que elimine todos los recursos de Docker. Creemos un script de limpieza simple:

nano cleanup.sh

Agrega el siguiente contenido:

#!/bin/bash

echo "Cleaning up Docker environment..."

## Stop and remove containers, networks, volumes, and images
docker-compose down --volumes --rmi all --remove-orphans

## Remove dangling volumes
echo "Removing dangling volumes..."
docker volume prune -f

## Remove dangling images
echo "Removing dangling images..."
docker image prune -f

echo "Cleanup complete!"

Guarda y sal del editor.

Haz que el script sea ejecutable:

chmod +x cleanup.sh

Ahora puedes ejecutar este script siempre que necesites realizar una limpieza completa:

./cleanup.sh

Mejor práctica: Eliminación selectiva de recursos

A veces, es posible que desees eliminar solo recursos específicos. Por ejemplo, es posible que desees conservar tus volúmenes (para preservar los datos) pero eliminar contenedores, redes e imágenes.

Aquí te mostramos cómo abordar diferentes escenarios:

Eliminar solo contenedores y redes (conservar volúmenes e imágenes):

docker-compose down

Eliminar contenedores, redes e imágenes (conservar volúmenes):

docker-compose down --rmi all

Eliminar contenedores, redes y volúmenes (conservar imágenes):

docker-compose down --volumes

Eliminar solo imágenes locales (no extraídas de un registro):

docker-compose down --rmi local

Al eliminar recursos de forma selectiva, puedes optimizar tu flujo de trabajo según tus necesidades específicas.

Mejor práctica: Monitoreo del uso de recursos

Antes y después de ejecutar docker-compose down, a menudo es útil monitorear el uso de tus recursos de Docker. Esto puede ayudarte a identificar cualquier recurso que no se esté limpiando correctamente.

Aquí hay algunos comandos útiles:

Listar todos los contenedores (incluidos los detenidos):

docker ps -a

Listar todas las redes:

docker network ls

Listar todos los volúmenes:

docker volume ls

Listar todas las imágenes:

docker image ls

Obtener información de todo el sistema:

docker system df

Probemos el último comando para ver nuestro uso actual de recursos:

docker system df

Verás un resumen del uso de tus recursos de Docker, incluido el número de contenedores, imágenes, volúmenes y la cantidad total de espacio utilizado.

Cierre de nuestro entorno complejo

Ahora, cerremos nuestro entorno complejo y eliminemos todos los recursos asociados:

docker-compose down --volumes --rmi all --remove-orphans

Esto detendrá y eliminará todos los contenedores, redes, volúmenes e imágenes asociados con nuestro proyecto de Docker Compose.

Al seguir estas mejores prácticas, puedes gestionar eficazmente tus entornos de Docker y garantizar un uso óptimo de los recursos.

Resumen

En este laboratorio, has aprendido cómo usar eficazmente el comando docker-compose down para gestionar tus contenedores y recursos de Docker. Aquí tienes un resumen de lo que has logrado:

1. Instalaste Docker Compose y creaste un entorno de Docker Compose simple
2. Aprendiste los conceptos básicos de docker-compose down y cómo elimina contenedores y redes de forma predeterminada
3. Exploraste opciones avanzadas como --volumes, --rmi y --remove-orphans para controlar exactamente qué recursos se eliminan
4. Implementaste mejores prácticas para usar Docker Compose en escenarios del mundo real, incluyendo:
   • Uso de archivos de configuración específicos del entorno
   • Creación de scripts de limpieza
   • Eliminación selectiva de recursos
   • Monitoreo del uso de recursos

Al dominar el comando docker-compose down, ahora tienes el conocimiento para mantener un entorno de Docker limpio, evitar fugas de recursos y optimizar tu flujo de trabajo de desarrollo.

Recuerda estos puntos clave:

• El comando básico docker-compose down elimina contenedores y redes, pero conserva los volúmenes
• Usa --volumes para eliminar volúmenes cuando desees restablecer tus datos
• Usa --rmi para eliminar imágenes cuando necesites liberar espacio en disco
• Usa --remove-orphans para limpiar contenedores que ya no están definidos en tu archivo Compose
• Combina estas opciones para una limpieza completa cuando sea necesario

Con estas habilidades, ahora estás mejor equipado para gestionar entornos de Docker Compose de manera eficiente en tus proyectos.