Cómo usar el comando docker compose watch para reconstruir servicios automáticamente

DockerDockerBeginner
Practicar Ahora

💡 Este tutorial está traducido por IA desde la versión en inglés. Para ver la versión original, puedes hacer clic aquí

Introducción

En este laboratorio, aprenderás a utilizar el comando docker compose watch para reconstruir y actualizar automáticamente tus servicios de Docker en respuesta a cambios en los archivos. Comenzaremos configurando un proyecto simple de Docker Compose con un contexto de compilación (build context), que incluirá un archivo de aplicación básico, un Dockerfile y un archivo docker-compose.yaml.

Después de configurar el proyecto, explorarás la funcionalidad principal de docker compose watch para monitorear modificaciones en los archivos y activar reconstrucciones automáticas. También examinaremos la opción --no-up para observar cambios sin un inicio inicial del servicio y la opción --quiet para suprimir la salida de compilación, lo que te permitirá observar el comportamiento de watch de manera más clara.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL docker(("Docker")) -.-> docker/ContainerOperationsGroup(["Container Operations"]) docker(("Docker")) -.-> docker/DockerfileGroup(["Dockerfile"]) docker/ContainerOperationsGroup -.-> docker/run("Run a Container") docker/DockerfileGroup -.-> docker/build("Build Image from Dockerfile") subgraph Lab Skills docker/run -.-> lab-555098{{"Cómo usar el comando docker compose watch para reconstruir servicios automáticamente"}} docker/build -.-> lab-555098{{"Cómo usar el comando docker compose watch para reconstruir servicios automáticamente"}} end

Preparar un proyecto simple de Docker Compose con un contexto de compilación

En este paso, prepararemos un proyecto simple de Docker Compose que incluya un contexto de compilación (build context). Un contexto de compilación es el conjunto de archivos en una ubicación especificada (PATH o URL) que se envían al daemon de Docker para construir una imagen de Docker. Esto es importante porque el Dockerfile y cualquier archivo que necesite (como el código de la aplicación) deben estar dentro del contexto de compilación.

Primero, creemos un directorio para nuestro proyecto. Lo llamaremos my-watch-app.

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

Ahora, necesitamos crear un archivo de aplicación simple. Usaremos un script básico de Python que imprime un mensaje.

nano app.py

Agrega el siguiente contenido a app.py:

print("Hello from the Docker container!")

Guarda y cierra el archivo (Ctrl+X, Y, Enter).

A continuación, necesitamos crear un Dockerfile que construirá una imagen para nuestra aplicación. El Dockerfile copiará nuestro script de Python en la imagen y luego lo ejecutará.

nano Dockerfile

Agrega el siguiente contenido al Dockerfile:

FROM python:3.9-slim

WORKDIR /app

COPY app.py .

CMD ["python", "app.py"]

Este Dockerfile utiliza una imagen ligera de Python 3.9 como base, establece el directorio de trabajo en /app, copia app.py en el directorio /app y finalmente establece el comando para ejecutar el script de Python cuando el contenedor se inicie.

Finalmente, necesitamos crear un archivo docker-compose.yaml para definir nuestro servicio. Este archivo le indicará a Docker Compose cómo construir y ejecutar nuestra aplicación.

nano docker-compose.yaml

Agrega el siguiente contenido a docker-compose.yaml:

version: "3.8"

services:
  myapp:
    build: .
    volumes:
      - .:/app

Este archivo docker-compose.yaml define un servicio llamado myapp. La instrucción build: . le indica a Docker Compose que construya la imagen usando el Dockerfile en el directorio actual (que es nuestro contexto de compilación). La línea volumes: - .:/app monta el directorio actual (.) en la máquina host en el directorio /app dentro del contenedor. Esto es crucial para docker compose watch, ya que permite que los cambios en el host se reflejen en el contenedor.

Ahora, construyamos y ejecutemos nuestro servicio usando Docker Compose para asegurarnos de que todo esté configurado correctamente. Como Docker Compose no está preinstalado, primero debemos instalarlo.

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 podemos usar docker-compose.

docker-compose up --build

Deberías ver una salida que indica que la imagen se está construyendo y el contenedor se está ejecutando, mostrando "Hello from the Docker container!". Presiona Ctrl+C para detener el contenedor.

Usar docker compose watch para monitorear cambios y reconstruir

En este paso, utilizaremos el comando docker compose watch para reconstruir y reiniciar automáticamente nuestro servicio cuando realicemos cambios en el código de la aplicación. Esta es una función poderosa para flujos de trabajo de desarrollo, permitiendo iteraciones rápidas.

El comando docker compose watch monitorea los archivos en tu contexto de compilación (build context) y, cuando detecta cambios, puede reconstruir automáticamente la imagen y reiniciar el servicio.

Asegúrate de estar en el directorio ~/project/my-watch-app.

cd ~/project/my-watch-app

Ahora, ejecuta el comando docker compose watch.

docker-compose watch

Verás una salida que indica que Docker Compose está iniciando el servicio y monitoreando cambios en los archivos. La salida inicial será similar a ejecutar docker-compose up.

Mientras docker compose watch se ejecuta en tu terminal, abre otra terminal o pestaña. Navega al directorio del proyecto en la nueva terminal.

cd ~/project/my-watch-app

Ahora, modifiquemos el archivo app.py.

nano app.py

Cambia el contenido a:

print("Hello again from the updated Docker container!")

Guarda y cierra el archivo (Ctrl+X, Y, Enter).

Regresa a la terminal donde se está ejecutando docker compose watch. Deberías ver una salida que indica que se detectó un cambio, la imagen se está reconstruyendo y el contenedor se está reiniciando. Después del reinicio, se imprimirá el nuevo mensaje "Hello again from the updated Docker container!".

Esto demuestra cómo docker compose watch maneja automáticamente el proceso de construcción y reinicio cuando tu código cambia.

Presiona Ctrl+C en la terminal que ejecuta docker compose watch para detener el proceso.

Explorar la opción --no-up para monitorear sin compilación inicial

En este paso, exploraremos la opción --no-up con docker compose watch. Por defecto, docker compose watch construirá e iniciará los servicios definidos en tu archivo docker-compose.yaml antes de comenzar a monitorear cambios en los archivos. La opción --no-up evita esta compilación e inicio inicial. Esto es útil si deseas comenzar a monitorear cambios sin levantar inmediatamente los servicios, quizás porque planeas iniciarlos manualmente más tarde o ya están en ejecución.

Asegúrate de estar en el directorio ~/project/my-watch-app.

cd ~/project/my-watch-app

Ahora, ejecuta el comando docker compose watch con la opción --no-up.

docker-compose watch --no-up

Notarás que la salida es diferente al paso anterior. Docker Compose comenzará a monitorear cambios en los archivos pero no construirá la imagen ni iniciará el contenedor inicialmente. La salida indicará que está monitoreando las rutas especificadas.

Mientras docker compose watch --no-up se ejecuta en tu terminal, abre otra terminal o pestaña. Navega al directorio del proyecto en la nueva terminal.

cd ~/project/my-watch-app

Ahora, modifiquemos nuevamente el archivo app.py.

nano app.py

Cambia el contenido a:

print("Watching without initial up!")

Guarda y cierra el archivo (Ctrl+X, Y, Enter).

Regresa a la terminal donde se ejecuta docker compose watch --no-up. Deberías ver una salida que indica que se detectó un cambio y la imagen se está reconstruyendo. Sin embargo, el contenedor no se reiniciará automáticamente porque usamos la opción --no-up.

Para ver el efecto del cambio, necesitarás levantar manualmente el servicio en otra terminal después de que se complete la reconstrucción.

docker-compose up

Verás el nuevo mensaje "Watching without initial up!" impreso por el contenedor.

Presiona Ctrl+C en la terminal que ejecuta docker compose watch --no-up para detener el proceso de monitoreo. Presiona Ctrl+C en la terminal que ejecuta docker-compose up para detener el contenedor.

Observar la opción --quiet para ocultar la salida de compilación

En este paso, observaremos el efecto de la opción --quiet con docker compose watch. Por defecto, cuando docker compose watch detecta un cambio y reconstruye una imagen, muestra toda la salida del proceso de compilación. La opción --quiet suprime esta salida detallada, mostrando solo información esencial sobre el proceso de monitoreo y reinicios de servicios. Esto puede hacer que la salida sea más limpia, especialmente para cambios pequeños frecuentes.

Asegúrate de estar en el directorio ~/project/my-watch-app.

cd ~/project/my-watch-app

Ahora, ejecuta el comando docker compose watch con la opción --quiet. También incluiremos nuevamente la opción --no-up para que solo veamos la salida relacionada con el proceso de monitoreo y reconstrucción, no con el inicio inicial del servicio.

docker-compose watch --quiet --no-up

Verás una salida que indica que Docker Compose está monitoreando cambios en los archivos, pero no habrá una salida detallada de compilación inicialmente.

Mientras docker compose watch --quiet --no-up se ejecuta en tu terminal, abre otra terminal o pestaña. Navega al directorio del proyecto en la nueva terminal.

cd ~/project/my-watch-app

Ahora, modifiquemos el archivo app.py una última vez.

nano app.py

Cambia el contenido a:

print("Quietly watching changes!")

Guarda y cierra el archivo (Ctrl+X, Y, Enter).

Regresa a la terminal donde se ejecuta docker compose watch --quiet --no-up. Deberías ver una salida que indica que se detectó un cambio y la imagen se está reconstruyendo, pero los pasos detallados del proceso de compilación de Docker estarán ocultos. Solo verás un mensaje conciso sobre la reconstrucción.

Esto demuestra cómo la opción --quiet reduce la verbosidad de la salida durante la fase de compilación activada por docker compose watch.

Presiona Ctrl+C en la terminal que ejecuta docker compose watch --quiet --no-up para detener el proceso de monitoreo.

Resumen

En este laboratorio, aprendimos cómo preparar un proyecto simple con Docker Compose que incluye un contexto de compilación (build context), lo cual es esencial para construir imágenes Docker a partir de archivos locales. Creamos un directorio de proyecto, un archivo básico de aplicación Python (app.py), un Dockerfile para construir la imagen de la aplicación, y un archivo docker-compose.yaml para definir el servicio y su contexto de compilación.

Luego exploramos el comando docker compose watch, que nos permite monitorear automáticamente los cambios en los archivos dentro del contexto de compilación y activar reconstrucciones del servicio asociado. Aprendimos a usar este comando para observar este proceso de reconstrucción automática, y también exploramos la opción --no-up para monitorear sin una compilación inicial y la opción --quiet para suprimir la salida de compilación, proporcionando un flujo de trabajo optimizado para desarrollo.