Cómo usar el comando docker compose alpha dry-run para probar configuraciones

Introducción

En este laboratorio, aprenderás a utilizar el comando docker compose alpha dry-run para probar cambios en tu configuración de Docker Compose sin ejecutarlos realmente. Esta es una herramienta valiosa para verificar tu archivo docker-compose.yaml y comprender el impacto potencial de los comandos antes de aplicarlos.

Comenzarás preparando un archivo docker-compose.yaml simple. Luego, usarás la bandera dry-run con comandos básicos de Docker Compose para observar la salida simulada y entender cómo se comportaría el comando. Finalmente, aplicarás dry-run a un comando que normalmente realizaría cambios, permitiéndote ver las acciones previstas sin alterar tu sistema.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL docker(("Docker")) -.-> docker/ContainerOperationsGroup(["Container Operations"]) docker(("Docker")) -.-> docker/ImageOperationsGroup(["Image Operations"]) docker(("Docker")) -.-> docker/SystemManagementGroup(["System Management"]) docker(("Docker")) -.-> docker/NetworkOperationsGroup(["Network Operations"]) docker/ContainerOperationsGroup -.-> docker/ls("List Containers") docker/ContainerOperationsGroup -.-> docker/ps("List Running Containers") docker/ContainerOperationsGroup -.-> docker/create("Create Container") docker/ImageOperationsGroup -.-> docker/pull("Pull Image from Repository") docker/ImageOperationsGroup -.-> docker/images("List Images") docker/SystemManagementGroup -.-> docker/info("Display System-Wide Information") docker/SystemManagementGroup -.-> docker/version("Show Docker Version") docker/NetworkOperationsGroup -.-> docker/network("Manage Networks") subgraph Lab Skills docker/ls -.-> lab-555069{{"Cómo usar el comando docker compose alpha dry-run para probar cambios"}} docker/ps -.-> lab-555069{{"Cómo usar el comando docker compose alpha dry-run para probar cambios"}} docker/create -.-> lab-555069{{"Cómo usar el comando docker compose alpha dry-run para probar cambios"}} docker/pull -.-> lab-555069{{"Cómo usar el comando docker compose alpha dry-run para probar cambios"}} docker/images -.-> lab-555069{{"Cómo usar el comando docker compose alpha dry-run para probar cambios"}} docker/info -.-> lab-555069{{"Cómo usar el comando docker compose alpha dry-run para probar cambios"}} docker/version -.-> lab-555069{{"Cómo usar el comando docker compose alpha dry-run para probar cambios"}} docker/network -.-> lab-555069{{"Cómo usar el comando docker compose alpha dry-run para probar cambios"}} end

Preparar un archivo docker-compose.yaml simple

En este paso, prepararemos un archivo docker-compose.yaml simple. Este archivo definirá un servicio básico que podremos utilizar para demostrar la funcionalidad dry-run de Docker Compose.

Primero, necesitamos instalar Docker Compose. Como no está preinstalado en este entorno, descargaremos el binario y lo 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

Este comando descarga el binario de Docker Compose para la arquitectura de tu sistema y lo guarda en /usr/local/bin/docker-compose. El comando chmod +x hace que el archivo sea ejecutable.

Ahora, verifiquemos que Docker Compose esté instalado correctamente comprobando su versión.

docker-compose version

Deberías ver una salida que indique la versión instalada de Docker Compose.

A continuación, crearemos un directorio para nuestro proyecto y navegaremos hasta él.

mkdir ~/project/my-compose-app
cd ~/project/my-compose-app

Ahora estamos en el directorio ~/project/my-compose-app, donde crearemos nuestro archivo docker-compose.yaml.

Ahora, creemos el archivo docker-compose.yaml usando el editor nano.

nano docker-compose.yaml

Dentro del editor nano, pega el siguiente contenido:

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

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

Guarda el archivo presionando Ctrl + O, luego presiona Enter, y sale del editor presionando Ctrl + X.

Ahora hemos creado exitosamente un archivo docker-compose.yaml simple.

Usar dry-run con un comando básico de compose

En este paso, utilizaremos la bandera dry-run con un comando básico de Docker Compose para ver cómo funciona. La bandera dry-run te permite ver qué acciones realizaría Docker Compose sin ejecutarlas realmente. Esto es útil para comprender el impacto potencial de un comando antes de ejecutarlo.

Usaremos el comando docker-compose config con la bandera dry-run. El comando config valida y muestra la configuración del archivo Compose. Agregar dry-run a este comando no cambia significativamente su comportamiento, ya que config es inherentemente un comando no destructivo, pero es un buen punto de partida para entender la sintaxis de la bandera.

Primero, asegúrate de estar en el directorio que contiene tu archivo docker-compose.yaml.

cd ~/project/my-compose-app

Ahora, ejecuta el comando docker-compose config --dry-run.

docker-compose config --dry-run

Deberías ver la configuración analizada de tu archivo docker-compose.yaml impresa en la consola. En este caso, la salida es la misma que al ejecutar docker-compose config sin la bandera dry-run, porque config es intrínsecamente una operación de prueba.

La salida confirma que Docker Compose analizó correctamente tu archivo docker-compose.yaml y comprende los servicios y configuraciones definidos en él.

Analizar la salida del comando dry-run

En este paso, examinaremos detenidamente la salida del comando docker-compose config --dry-run que ejecutamos anteriormente. Comprender esta salida es crucial para ver cómo Docker Compose interpreta tu archivo docker-compose.yaml.

La salida que viste es la configuración validada en formato YAML. Representa cómo Docker Compose entiende los servicios, redes y volúmenes definidos en tu archivo.

Analicemos las partes clave de la salida basándonos en nuestro simple docker-compose.yaml:

services:
  web:
    build:
      context: /home/labex/project/my-compose-app
    container_name: my-compose-app-web-1
    image: nginx:latest
    ports:
      - published: 80
        target: 80
    restart: "no"

Verás la sección services, y dentro de ella, el servicio web.

image: nginx:latest: Confirma que Docker Compose identificó correctamente la imagen a usar para el servicio web.
ports:: Esta sección muestra el mapeo de puertos. published: 80 indica el puerto del host y target: 80 el puerto del contenedor, coincidiendo con lo definido en nuestro docker-compose.yaml.
container_name: my-compose-app-web-1: Docker Compose genera automáticamente un nombre de contenedor basado en el directorio del proyecto y el nombre del servicio.
build:: Aunque especificamos una image, Docker Compose incluye una sección build con el contexto establecido al directorio actual. Esto es parte de la representación interna y no significa que construirá una imagen si solo especificaste una image.
restart: 'no': Docker Compose establece por defecto la política de reinicio como no si no se especifica.

Esta salida representa la configuración final que Docker Compose usaría si ejecutaras un comando como docker-compose up. La bandera dry-run, cuando se usa con comandos que harían cambios (lo que veremos en el siguiente paso), mostraría las acciones que realizaría, no solo la configuración.

Para el comando config, la bandera dry-run sirve principalmente para validar la sintaxis y estructura de tu archivo docker-compose.yaml. Si hubiera errores de sintaxis, el comando config (con o sin dry-run) los reportaría.

Usar dry-run con un comando que realizaría cambios

En este paso, utilizaremos la bandera dry-run con un comando de Docker Compose que normalmente realizaría cambios en tu sistema, como docker-compose up. Esto demostrará cómo dry-run puede mostrarte las acciones previstas sin crear realmente contenedores o redes.

El comando docker-compose up, sin dry-run, descargaría las imágenes especificadas (si no están presentes), crearía redes e iniciaría contenedores basados en tu archivo docker-compose.yaml. Al agregar la bandera dry-run, podemos ver los pasos que realizaría sin ejecutarlos.

Primero, asegúrate de estar en el directorio correcto:

cd ~/project/my-compose-app

Ahora, ejecuta el comando docker-compose up --dry-run.

docker-compose up --dry-run

Verás una salida que indica las acciones que Docker Compose realizaría. Para nuestro simple docker-compose.yaml, la salida podría verse así:

Would create network "my-compose-app_default"
Would create service "web"
  Would pull image "nginx:latest"
  Would create container "my-compose-app-web-1"

Esta salida muestra claramente que Docker Compose tiene la intención de:

Crear una red predeterminada llamada my-compose-app_default.
Crear un servicio llamado web.
Descargar la imagen nginx:latest (si no está disponible localmente).
Crear un contenedor llamado my-compose-app-web-1 para el servicio web.

Observa que ninguna de estas acciones se realiza realmente. No se crea ninguna red, no se descarga ninguna imagen y no se inicia ningún contenedor. La bandera dry-run evita cualquier cambio real en tu entorno Docker.

Esto es increíblemente útil para:

Previsualizar cambios: Antes de implementar una aplicación compleja, puedes usar dry-run para ver exactamente qué hará Docker Compose.
Solución de problemas: Si un comando docker-compose up falla, dry-run puede ayudarte a entender los pasos iniciales e identificar posibles problemas en tu configuración.
Aprendizaje: Te permite experimentar con diferentes configuraciones de docker-compose.yaml y ver su impacto sin afectar tu sistema.

También puedes usar la bandera dry-run con otros comandos de Docker Compose, como down, start, stop y rm, para ver qué recursos se verían afectados.

Resumen

En este laboratorio, aprendimos cómo preparar un archivo docker-compose.yaml simple, comenzando con la instalación de Docker Compose y luego creando un directorio y el archivo YAML con una definición básica de servicio Nginx. Posteriormente, exploramos el uso de la bandera dry-run con comandos de Docker Compose.

Observamos cómo la bandera dry-run nos permite previsualizar las acciones que un comando ejecutaría sin realizar cambios reales en el sistema. Esta es una herramienta valiosa para probar modificaciones en nuestro archivo docker-compose.yaml y comprender el impacto potencial de los comandos antes de su ejecución.