Cómo usar el comando docker stack deploy para gestionar servicios de Swarm

Introducción

En este laboratorio, aprenderá cómo gestionar eficazmente los servicios de Docker Swarm utilizando el comando docker stack deploy. Comenzaremos preparando un sencillo archivo docker-compose.yml, que servirá como el plano de nuestro stack de aplicaciones.

Después de la preparación, desplegará este stack en su Docker Swarm, verificará que los servicios definidos se hayan desplegado correctamente y luego explorará cómo actualizar el stack modificando el archivo de composición. Finalmente, aprenderá cómo eliminar los servicios que ya no se mencionan en la configuración actualizada, asegurando que su Swarm permanezca limpio y eficiente.

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/ContainerOperationsGroup -.-> docker/ls("List Containers") docker/ContainerOperationsGroup -.-> docker/ps("List Running Containers") docker/ContainerOperationsGroup -.-> docker/rm("Remove Container") docker/ContainerOperationsGroup -.-> docker/inspect("Inspect Container") docker/ImageOperationsGroup -.-> docker/pull("Pull Image from Repository") docker/SystemManagementGroup -.-> docker/system("Manage Docker") subgraph Lab Skills docker/ls -.-> lab-555234{{"Cómo usar el comando docker stack deploy para gestionar servicios de Swarm"}} docker/ps -.-> lab-555234{{"Cómo usar el comando docker stack deploy para gestionar servicios de Swarm"}} docker/rm -.-> lab-555234{{"Cómo usar el comando docker stack deploy para gestionar servicios de Swarm"}} docker/inspect -.-> lab-555234{{"Cómo usar el comando docker stack deploy para gestionar servicios de Swarm"}} docker/pull -.-> lab-555234{{"Cómo usar el comando docker stack deploy para gestionar servicios de Swarm"}} docker/system -.-> lab-555234{{"Cómo usar el comando docker stack deploy para gestionar servicios de Swarm"}} end

Preparar un sencillo archivo docker-compose para el despliegue en Swarm

En este paso, prepararemos un sencillo archivo docker-compose.yml que utilizaremos para desplegar un stack en un Docker Swarm. Antes de poder usar docker-compose, necesitamos instalarlo.

Primero, instalemos docker-compose. 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 desde la página oficial de lanzamientos de GitHub y lo guarda en /usr/local/bin/docker-compose. Las partes $(uname -s) y $(uname -m) detectan automáticamente tu sistema operativo y arquitectura. El comando chmod +x hace que el archivo descargado sea ejecutable.

Ahora, verifiquemos la instalación comprobando la versión.

docker-compose --version

Deberías ver la versión instalada de docker-compose impresa en la consola.

A continuación, crearemos un sencillo archivo docker-compose.yml en el directorio ~/project. Este archivo definirá un solo servicio utilizando la imagen nginx.

nano ~/project/docker-compose.yml

Pega el siguiente contenido en el editor nano:

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

Desglosemos este archivo docker-compose.yml:

version: '3.8' especifica la versión del formato del archivo Compose. La versión 3.8 es adecuada para despliegues en Swarm.
services: define los servicios que componen tu aplicación.
web: es el nombre de nuestro servicio. Puedes elegir cualquier nombre que desees.
image: nginx:latest especifica la imagen de Docker a utilizar para este servicio. Estamos utilizando la última versión de la imagen oficial de nginx.
ports: mapea puertos entre el host y el contenedor. "80:80" mapea el puerto 80 del host al puerto 80 del contenedor.

Guarda el archivo presionando Ctrl + X, luego Y y luego Enter.

Antes de poder desplegar este servicio, debemos asegurarnos de que la imagen nginx:latest esté disponible localmente. Podemos descargar la imagen utilizando el comando docker pull.

docker pull nginx:latest

Este comando descarga la imagen nginx:latest de Docker Hub a tu máquina local.

Ahora tienes un sencillo archivo docker-compose.yml listo para el despliegue y la imagen necesaria descargada.

Desplegar un stack en el Swarm utilizando el archivo de composición

En este paso, desplegaremos el stack definido en nuestro archivo docker-compose.yml en un Docker Swarm. Antes de poder desplegar un stack, necesitamos inicializar un Docker Swarm.

Primero, inicialicemos el Swarm. Dado que estamos utilizando una sola máquina virtual (VM), lo inicializaremos como un Swarm de un solo nodo.

docker swarm init

Este comando inicializa un nuevo Swarm y convierte el nodo actual en un nodo administrador. Deberías ver una salida que indique que el Swarm se ha inicializado.

Ahora que el Swarm está inicializado, podemos desplegar nuestro stack utilizando el comando docker stack deploy. Le daremos un nombre a nuestro stack, por ejemplo, mywebstack.

docker stack deploy -c ~/project/docker-compose.yml mywebstack

Desglosemos este comando:

docker stack deploy es el comando utilizado para desplegar un stack en un Swarm.
-c ~/project/docker-compose.yml especifica el archivo de composición a utilizar para el despliegue. Estamos utilizando el archivo que creamos en el paso anterior.
mywebstack es el nombre que le estamos dando a nuestro stack. Este nombre se utilizará para identificar los servicios y contenedores pertenecientes a este stack dentro del Swarm.

Después de ejecutar este comando, Docker Swarm creará los servicios definidos en el archivo docker-compose.yml. Deberías ver una salida que indique que los servicios se están creando o actualizando.

Para verificar que el stack se ha desplegado, podemos listar los stacks en ejecución.

docker stack ls

Este comando mostrará una lista de todos los stacks desplegados en tu Swarm. Deberías ver mywebstack en la lista.

También podemos listar los servicios que se están ejecutando dentro de nuestro stack.

docker stack services mywebstack

Este comando mostrará los servicios asociados con el stack mywebstack. Deberías ver el servicio mywebstack_web en la lista, junto con información sobre sus réplicas e imagen.

Finalmente, comprobemos el estado de las tareas del servicio.

docker service ps mywebstack_web

Este comando muestra las tareas (contenedores en ejecución) para el servicio mywebstack_web. Deberías ver al menos una tarea con un estado de Running.

Ahora has inicializado con éxito un Docker Swarm y desplegado un stack utilizando un archivo docker-compose.yml.

Verificar los servicios desplegados

En este paso, verificaremos que los servicios desplegados en el paso anterior estén funcionando correctamente y sean accesibles. Desplegamos un servidor web Nginx, que debería estar escuchando en el puerto 80.

Primero, usemos el comando docker service ls para ver la lista de servicios que se están ejecutando en el Swarm.

docker service ls

Deberías ver el servicio mywebstack_web en la lista con 1/1 réplicas, lo que indica que una instancia del servicio está en ejecución.

A continuación, podemos usar curl para acceder al servidor web Nginx que se está ejecutando dentro del contenedor. Dado que mapeamos el puerto 80 del host al puerto 80 del contenedor, podemos acceder a él a través de localhost en el puerto 80.

curl localhost:80

Este comando envía una solicitud HTTP a localhost en el puerto 80. Si el servidor Nginx está funcionando correctamente, deberías recibir el HTML de la página de bienvenida predeterminada de Nginx como salida. Esto confirma que el servicio está en ejecución y es accesible desde la máquina host.

Para inspeccionar más detenidamente el contenedor en ejecución del servicio web, podemos usar el comando docker ps.

docker ps

Este comando lista todos los contenedores en ejecución. Deberías ver un contenedor ejecutando la imagen nginx, con un nombre similar a mywebstack_web.1.<task_id>. La columna PORTS debería mostrar 0.0.0.0:80->80/tcp, lo que confirma el mapeo de puertos.

También podemos inspeccionar los detalles del servicio utilizando el comando docker service inspect.

docker service inspect mywebstack_web

Este comando proporciona información detallada sobre el servicio mywebstack_web, incluyendo su configuración, tareas y configuración de red. Puedes desplazarte por la salida para ver varios detalles sobre el servicio.

Al realizar estas comprobaciones, hemos verificado que nuestro servicio Nginx desplegado está funcionando como se esperaba y es accesible.

Actualizar el stack con un archivo de composición modificado

En este paso, modificaremos nuestro archivo docker-compose.yml para actualizar el stack desplegado. Cambiaremos la versión de la imagen de Nginx y agregaremos un segundo servicio.

Primero, editemos el archivo docker-compose.yml.

nano ~/project/docker-compose.yml

Modifica el archivo para incluir un segundo servicio, por ejemplo, un servicio alpine, y cambia la versión de la imagen de Nginx a 1.21.6. El archivo actualizado debería verse así:

version: "3.8"
services:
  web:
    image: nginx:1.21.6
    ports:
      - "80:80"
  alpine:
    image: alpine:latest
    command: ["sleep", "infinity"]

Veamos los cambios:

Cambiamos la image del servicio web de nginx:latest a nginx:1.21.6.
Agregamos un nuevo servicio llamado alpine.
El servicio alpine utiliza la imagen alpine:latest.
El comando command: ["sleep", "infinity"] mantiene el contenedor alpine en ejecución indefinidamente.

Guarda el archivo modificado presionando Ctrl + X, luego Y y luego Enter.

Antes de desplegar el stack actualizado, necesitamos descargar las nuevas imágenes nginx:1.21.6 y alpine:latest.

docker pull nginx:1.21.6
docker pull alpine:latest

Ahora, podemos desplegar el stack actualizado utilizando el mismo comando docker stack deploy y el mismo nombre de stack. Docker Swarm detectará los cambios en el archivo docker-compose.yml y actualizará el stack existente.

docker stack deploy -c ~/project/docker-compose.yml mywebstack

Docker Swarm realizará una actualización gradual para el servicio web, reemplazando el antiguo contenedor nginx:latest con uno nuevo que utilice nginx:1.21.6. También creará el nuevo servicio alpine y su contenedor correspondiente. Deberías ver una salida que indique que los servicios se están actualizando o creando.

Para verificar la actualización, listemos nuevamente los servicios en el stack.

docker stack services mywebstack

Ahora deberías ver listados tanto el servicio mywebstack_web como el servicio mywebstack_alpine. El servicio mywebstack_web debería mostrar la imagen actualizada nginx:1.21.6.

Has actualizado con éxito tu stack desplegado modificando el archivo docker-compose.yml y volviéndolo a desplegar.

Eliminar servicios que ya no se referencian en el archivo de composición

En este paso, modificaremos nuevamente nuestro archivo docker-compose.yml, esta vez eliminando un servicio. Cuando volvamos a desplegar el stack, Docker Swarm detectará que un servicio ya no está definido en el archivo de composición y lo eliminará. Este proceso a veces se denomina "eliminar" (pruning) servicios.

Primero, editemos el archivo docker-compose.yml para eliminar el servicio alpine.

nano ~/project/docker-compose.yml

Elimina toda la sección alpine: del archivo. El archivo debería volver a su estado original, definiendo solo el servicio web:

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

Guarda el archivo modificado presionando Ctrl + X, luego Y y luego Enter.

Ahora, despleguemos el stack nuevamente utilizando el archivo docker-compose.yml modificado.

docker stack deploy -c ~/project/docker-compose.yml mywebstack

Docker Swarm comparará el estado actual del stack mywebstack con la definición en el archivo docker-compose.yml actualizado. Notará que el servicio alpine ya no está presente en el archivo y eliminará el servicio correspondiente y sus tareas del Swarm. Deberías ver una salida que indique que el servicio alpine se está eliminando.

Para verificar que el servicio alpine se ha eliminado, lista los servicios en el stack nuevamente.

docker stack services mywebstack

Ahora solo deberías ver el servicio mywebstack_web en la lista. El servicio mywebstack_alpine debería haber desaparecido.

Finalmente, para limpiar el entorno de Swarm, podemos eliminar el stack completo.

docker stack rm mywebstack

Este comando elimina el stack mywebstack, incluyendo todos sus servicios y tareas. Deberías ver una salida que confirme la eliminación.

Para verificar que el stack se ha eliminado, lista los stacks nuevamente.

docker stack ls

El mywebstack ya no debería aparecer en la lista.

Has eliminado con éxito un servicio de tu stack eliminándolo del archivo docker-compose.yml y volviéndolo a desplegar, y luego has limpiado el entorno eliminando el stack completo.

Resumen

En este laboratorio, aprendimos cómo usar el comando docker stack deploy para gestionar servicios de Docker Swarm. Comenzamos preparando un simple archivo docker-compose.yml, que es la forma estándar de definir aplicaciones de múltiples servicios para Docker. Esto implicó instalar docker-compose y crear un archivo YAML básico que define un solo servicio de Nginx con mapeo de puertos.

Después de la preparación, desplegamos este stack en un Docker Swarm utilizando docker stack deploy, verificamos el éxito del despliegue del servicio y luego practicamos la actualización del stack modificando el archivo docker-compose.yml y volviéndolo a desplegar. Finalmente, aprendimos cómo eliminar (pruning) servicios que ya no están definidos en el archivo de composición actualizado, asegurándonos de que nuestro entorno de Swarm permanezca limpio y refleje la definición actual de la aplicación.