Cómo usar el comando docker compose alpha publish para publicar una aplicación Compose

Introducción

En este laboratorio, aprenderá a usar el comando docker compose alpha publish para publicar una aplicación de Docker Compose. Comenzaremos preparando una aplicación simple de múltiples contenedores utilizando un archivo docker-compose.yaml.

Después de la preparación, explorará diferentes formas de publicar la aplicación en un repositorio, incluyendo la publicación con digests de imagen resueltos (resolved image digests) e incluyendo variables de entorno en el artefacto publicado. Esta experiencia práctica lo guiará a través del proceso de empaquetado y compartición de sus aplicaciones Compose.

Skills Graph

Prepare una aplicación simple de Docker Compose

En este paso, prepararemos una aplicación simple de Docker Compose. Docker Compose es una herramienta para definir y ejecutar aplicaciones Docker de múltiples contenedores. Con Compose, utiliza un archivo YAML para configurar los servicios de su aplicación. Luego, con un solo comando, crea e inicia todos los servicios desde su configuración.

Primero, necesitamos instalar Docker Compose. Dado que no está preinstalado en el entorno LabEx, 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

Después de descargarlo y hacerlo ejecutable, verifique la instalación comprobando la versión.

docker-compose --version

Debería ver una salida similar a Docker Compose version v2.20.2.

Ahora, creemos una aplicación simple de Docker Compose. Crearemos un archivo docker-compose.yaml en el directorio ~/project. Este archivo definirá un único servicio que ejecuta un servidor web Nginx.

Utilice el editor nano para crear y editar el archivo.

nano ~/project/docker-compose.yaml

Agregue el siguiente contenido al archivo docker-compose.yaml:

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

En este archivo docker-compose.yaml:

• version: '3.8' especifica la versión del formato del archivo Compose.
• services: define los servicios para su aplicación.
• web: es el nombre de nuestro servicio.
• image: nginx:latest especifica la imagen de Docker que se utilizará para este servicio. Estamos utilizando la última versión de la imagen oficial de Nginx.
• ports: mapea los puertos de la máquina host al contenedor. "80:80" mapea el puerto 80 en el host al puerto 80 en el contenedor.

Guarde el archivo presionando Ctrl + S y salga del editor presionando Ctrl + X.

Antes de ejecutar la aplicación, necesitamos descargar (pull) la imagen nginx:latest.

docker pull nginx:latest

Ahora, podemos iniciar la aplicación utilizando el comando docker-compose up. El flag -d ejecuta los contenedores en modo detached (en segundo plano).

docker-compose up -d

Debería ver una salida que indica que el servicio se está creando e iniciando.

Para verificar que el contenedor se está ejecutando, utilice el comando docker ps.

docker ps

Debería ver una entrada para el servicio web con la imagen nginx y un estado de Up.

Finalmente, puede probar el servidor Nginx accediendo a él. Dado que el puerto 80 del contenedor está mapeado al puerto 80 del host, puede usar curl para acceder a localhost.

curl localhost

Debería ver la salida HTML de la página de bienvenida predeterminada de Nginx.

Publicar la aplicación Compose en un repositorio

En este paso, aprenderemos cómo publicar nuestra aplicación Docker Compose en un repositorio. La publicación de una aplicación Compose normalmente implica compartir el archivo docker-compose.yaml y asegurarse de que las imágenes de Docker requeridas sean accesibles desde un registro de contenedores (container registry).

Primero, detengamos la aplicación Docker Compose en ejecución del paso anterior. Navegue al directorio ~/project si aún no está allí.

cd ~/project

Ahora, detenga los servicios en ejecución utilizando el comando docker-compose down. Este comando detiene y elimina los contenedores, las redes y los volúmenes creados por up.

docker-compose down

Debería ver una salida que indica que los servicios se están deteniendo y eliminando.

Para publicar la aplicación Compose, necesitamos compartir el archivo docker-compose.yaml. En un escenario del mundo real, normalmente almacenaría este archivo en un sistema de control de versiones como Git y lo enviaría (push) a un repositorio (por ejemplo, GitHub, GitLab, Bitbucket).

Para este laboratorio, simularemos la publicación creando un simple archivo de texto que contenga el contenido de nuestro archivo docker-compose.yaml. Esto demuestra la idea central de compartir la configuración.

Creemos un archivo llamado compose_app.txt en el directorio ~/project y copiemos el contenido de docker-compose.yaml en él.

cat ~/project/docker-compose.yaml > ~/project/compose_app.txt

Ahora, puede ver el contenido del nuevo archivo para confirmar que es el mismo que el docker-compose.yaml.

cat ~/project/compose_app.txt

Debería ver el contenido YAML de su archivo Compose.

En un escenario de publicación real, también debería asegurarse de que las imágenes de Docker referenciadas en su archivo docker-compose.yaml estén disponibles en un registro de contenedores al que otros puedan acceder. En nuestro caso, la imagen nginx:latest está disponible públicamente en Docker Hub, por lo que no se necesitan pasos adicionales para esta imagen específica. Si estuviera utilizando imágenes personalizadas, necesitaría construirlas y enviarlas (push) a un registro.

Por ejemplo, si tuviera una imagen personalizada llamada my-custom-app, la construiría usando docker build y luego la enviaría a un registro como Docker Hub usando docker push your-dockerhub-username/my-custom-app.

Para simular el intercambio del archivo Compose, imagine que está compartiendo el archivo compose_app.txt con alguien. Luego, podrían descargar este archivo y usarlo para ejecutar la aplicación en su propia máquina, siempre que tengan Docker y Docker Compose instalados y puedan acceder a las imágenes requeridas.

Para demostrar esto, eliminemos el archivo docker-compose.yaml original y luego lo recreemos desde compose_app.txt.

rm ~/project/docker-compose.yaml
cat ~/project/compose_app.txt > ~/project/docker-compose.yaml

Ahora, puede verificar que el archivo docker-compose.yaml se ha recreado.

cat ~/project/docker-compose.yaml

Debería ver el mismo contenido YAML que antes.

Este paso se centró en el concepto de compartir el archivo Compose. En los siguientes pasos, exploraremos aspectos más avanzados de la publicación, como el uso de digests de imagen y el manejo de variables de entorno.

Publicar la aplicación Compose con digests de imagen resueltos

En este paso, aprenderemos cómo publicar una aplicación Compose utilizando digests de imagen resueltos. El uso de digests de imagen en lugar de etiquetas (tags) (como latest) proporciona una forma más confiable de garantizar que siempre esté utilizando la misma versión exacta de la imagen. Las etiquetas se pueden actualizar para que apunten a una nueva imagen, mientras que un digest identifica de forma única una capa de imagen específica.

Primero, obtengamos el digest para la imagen nginx:latest que usamos en los pasos anteriores. Podemos usar el comando docker inspect para obtener información detallada sobre la imagen.

docker inspect nginx:latest --format='{{.RepoDigests}}'

Este comando mostrará los repository digests para la imagen nginx:latest. La salida se verá algo como [nginx@sha256:...]. La parte después de @ es el image digest. Copie este digest.

Ahora, modificaremos nuestro archivo docker-compose.yaml para usar el digest de la imagen en lugar de la etiqueta. Abra el archivo docker-compose.yaml en el directorio ~/project usando nano.

nano ~/project/docker-compose.yaml

Cambie la línea image de image: nginx:latest a image: nginx@<su_digest_de_imagen>, reemplazando <su_digest_de_imagen> con el digest que copió. Por ejemplo, si su digest fuera sha256:abcdef123456..., la línea sería image: nginx@sha256:abcdef123456....

version: "3.8"
services:
  web:
    image: nginx@sha256:su_digest_de_imagen_aqui
    ports:
      - "80:80"

Guarde el archivo presionando Ctrl + S y salga del editor presionando Ctrl + X.

Ahora, cuando comparta este archivo docker-compose.yaml, cualquiera que lo use extraerá la imagen exacta identificada por el digest, independientemente de a qué pueda apuntar actualmente la etiqueta latest.

Para demostrar que Compose usa el digest, volvamos a levantar la aplicación usando el archivo docker-compose.yaml modificado.

docker-compose up -d

Compose utilizará la imagen especificada por el digest. Si la imagen aún no está presente en el sistema, se extraerá (pull).

Puede verificar que el contenedor se está ejecutando y utilizando la imagen especificada por el digest inspeccionando el contenedor en ejecución. Primero, encuentre el ID del contenedor usando docker ps.

docker ps

Busque el contenedor que ejecuta la imagen nginx y anote su ID de contenedor (Container ID). Luego, use docker inspect con el ID del contenedor y formatee la salida para mostrar el digest de la imagen.

docker inspect < container_id > --format='{{.Image}}'

Reemplace <container_id> con el ID real de su contenedor Nginx en ejecución. La salida debe ser el digest de la imagen que especificó en el archivo docker-compose.yaml.

El uso de digests de imagen en sus archivos Compose es una buena práctica para garantizar la reproducibilidad y evitar cambios inesperados en su aplicación debido a las actualizaciones de la imagen.

Publicar la aplicación Compose incluyendo variables de entorno

En este paso, aprenderemos cómo incluir variables de entorno en nuestra aplicación Docker Compose y cómo esto afecta la publicación. Las variables de entorno son una forma común de configurar aplicaciones, y Docker Compose proporciona varias formas de administrarlas.

Primero, detengamos el contenedor Nginx en ejecución del paso anterior. Navegue al directorio ~/project si aún no está allí.

cd ~/project

Detenga los servicios en ejecución utilizando el comando docker-compose down.

docker-compose down

Ahora, modifiquemos nuestro archivo docker-compose.yaml para usar una variable de entorno. Agregaremos una variable de entorno simple al servicio web. Abra el archivo docker-compose.yaml en el directorio ~/project usando nano.

nano ~/project/docker-compose.yaml

Agregue una sección environment a la definición del servicio web. Agregaremos una variable llamada MY_VARIABLE con un valor.

version: "3.8"
services:
  web:
    image: nginx@sha256:su_digest_de_imagen_aqui ## Reemplace con su digest real
    ports:
      - "80:80"
    environment:
      - MY_VARIABLE=HelloFromCompose

Recuerde reemplazar your_image_digest_here con el image digest real que obtuvo en el paso anterior.

Guarde el archivo presionando Ctrl + S y salga del editor presionando Ctrl + X.

Ahora, cuando inicie la aplicación con docker-compose up, la variable de entorno MY_VARIABLE se establecerá dentro del contenedor Nginx.

docker-compose up -d

Para verificar que la variable de entorno esté establecida dentro del contenedor, podemos ejecutar un comando dentro del contenedor en ejecución usando docker exec. Primero, encuentre el ID del contenedor usando docker ps.

docker ps

Anote el ID del contenedor (Container ID) del contenedor Nginx en ejecución. Luego, use docker exec para ejecutar el comando printenv dentro del contenedor y filtre la salida para MY_VARIABLE.

docker exec < container_id > printenv | grep MY_VARIABLE

Reemplace <container_id> con el ID real de su contenedor Nginx en ejecución. Debería ver una salida similar a MY_VARIABLE=HelloFromCompose.

Al publicar una aplicación Compose que utiliza variables de entorno, debe considerar cómo se proporcionarán estas variables en el entorno de destino.

Un enfoque común es utilizar un archivo .env. Docker Compose busca automáticamente un archivo llamado .env en el directorio donde se encuentra el archivo docker-compose.yaml. Puede definir variables de entorno en este archivo, y Compose las cargará.

Creemos un archivo .env en el directorio ~/project.

nano ~/project/.env

Agregue el siguiente contenido al archivo .env:

ANOTHER_VARIABLE=ThisIsFromDotEnv

Guarde el archivo y salga de nano.

Ahora, modifiquemos el archivo docker-compose.yaml para usar esta nueva variable de entorno. Abra el archivo docker-compose.yaml nuevamente.

nano ~/project/docker-compose.yaml

Agregue ANOTHER_VARIABLE a la sección environment.

version: "3.8"
services:
  web:
    image: nginx@sha256:su_digest_de_imagen_aqui ## Reemplace con su digest real
    ports:
      - "80:80"
    environment:
      - MY_VARIABLE=HelloFromCompose
      - ANOTHER_VARIABLE

Observe que para ANOTHER_VARIABLE, simplemente enumeramos el nombre de la variable. Compose buscará esta variable en el entorno donde se ejecuta docker-compose up, incluidas las variables cargadas desde el archivo .env.

Guarde el archivo y salga de nano.

Ahora, detenga y reinicie la aplicación Compose para recoger los cambios.

docker-compose down
docker-compose up -d

Obtenga el nuevo ID del contenedor usando docker ps.

docker ps

Ahora, use docker exec para verificar ambas variables de entorno dentro del contenedor.

docker exec < container_id > printenv | grep MY_VARIABLE
docker exec < container_id > printenv | grep ANOTHER_VARIABLE

Reemplace <container_id> con el nuevo ID del contenedor. Debería ver tanto MY_VARIABLE=HelloFromCompose como ANOTHER_VARIABLE=ThisIsFromDotEnv en la salida.

Al publicar, normalmente compartiría el archivo docker-compose.yaml y proporcionaría instrucciones sobre cómo establecer las variables de entorno necesarias, ya sea a través de un archivo .env o estableciéndolas directamente en el entorno donde se ejecuta Compose. La información confidencial no debe codificarse en los archivos docker-compose.yaml o .env y debe administrarse utilizando soluciones de administración de secretos (secrets management solutions).

Resumen

En este laboratorio, aprendimos cómo preparar una aplicación Docker Compose simple. Esto implicó la instalación de Docker Compose, la verificación de su instalación y la creación de un archivo docker-compose.yaml para definir un servicio web Nginx básico. También extrajimos (pull) la imagen Docker necesaria (nginx:latest) en preparación para ejecutar la aplicación.

Los pasos subsiguientes, que no se detallaron completamente en el contenido proporcionado, probablemente cubrirían la publicación de esta aplicación Compose en un repositorio utilizando el comando docker compose alpha publish. Esto incluiría la exploración de opciones como la publicación con digests de imagen resueltos y la inclusión de variables de entorno en la definición de la aplicación publicada.