En este tema introduciremos la orquestación de contenedores y aprenderemos a usar Docker Swarm, el orquestador nativo de Docker. Cuando una aplicación pasa de unos pocos contenedores en una máquina a decenas de réplicas distribuidas en varios servidores, gestionar todo a mano se vuelve inviable. La orquestación automatiza el despliegue, el escalado, la recuperación ante fallos y las actualizaciones de los contenedores, y Docker Swarm ofrece una forma sencilla de empezar usando herramientas que ya conoces.

• Entender qué es la orquestación de contenedores y qué problemas resuelve.
• Conocer los conceptos fundamentales de Swarm: nodos, servicios y tareas.
• Inicializar un clúster con docker swarm init y unir nodos con docker swarm join.
• Desplegar aplicaciones con docker stack deploy usando ficheros Compose.
• Gestionar réplicas y realizar actualizaciones progresivas (rolling updates).

La orquestación es la gestión automatizada del ciclo de vida de los contenedores en uno o varios servidores. Un orquestador se encarga de:

• Programar (scheduling): decidir en qué servidor se ejecuta cada contenedor.
• Escalar: aumentar o reducir el número de réplicas según la demanda.
• Auto-reparar: reiniciar contenedores que fallan y redistribuirlos si un servidor cae.
• Balancear carga: repartir el tráfico entre las réplicas de un servicio.
• Actualizar sin cortes: desplegar nuevas versiones de forma progresiva.

Docker Swarm convierte un grupo de máquinas con Docker en un único clúster lógico al que das órdenes como si fuera un solo Docker.

Antes de los comandos, es importante dominar la terminología de Swarm:

La relación jerárquica es: un servicio se descompone en varias tareas, y cada tarea se ejecuta como un contenedor en un nodo.

• Los managers mantienen el estado deseado del clúster mediante un registro distribuido (basado en el algoritmo de consenso Raft). Para alta disponibilidad se recomienda un número impar de managers (1, 3 o 5).
• Los workers se limitan a ejecutar tareas. Un nodo puede ser a la vez manager y worker (lo habitual en clústeres pequeños).

Para convertir una máquina en el primer manager del clúster, usa:

Explicación:

• docker swarm init: inicializa el modo Swarm en esta máquina y la convierte en manager.
• --advertise-addr 192.168.1.10: indica la dirección IP por la que los demás nodos contactarán con este manager (usa una IP ficticia de tu red).

El comando devuelve un token y una instrucción docker swarm join para añadir más nodos. Por ejemplo:

Este comando se ejecuta en cada nodo worker que quieras unir al clúster:

• --token SWMTKN-1-...: token de seguridad (ficticio) que autoriza la unión.
• 192.168.1.10:2377: dirección y puerto del manager (2377 es el puerto estándar de gestión de Swarm).

Para ver los nodos del clúster, desde un manager ejecuta:

Este comando lista todos los nodos, su rol (manager/worker) y su estado.

La forma más directa de lanzar un servicio es con docker service create:

Explicación:

• docker service create: crea un nuevo servicio en el clúster.
• --name web: nombre del servicio.
• --replicas 3: pide tres instancias (tareas) del contenedor; Swarm las repartirá entre los nodos.
• -p 80:80: publica el puerto 80 en todo el clúster mediante la malla de enrutado (routing mesh).
• nginx:latest: imagen a ejecutar.

Para ver las tareas de un servicio:

En la práctica, las aplicaciones se definen en un fichero Compose y se despliegan como un stack. Esto reutiliza el formato Compose que ya conoces, añadiendo la sección deploy específica de Swarm.

Explicación detallada:

• version: "3.8": versión del formato Compose compatible con las opciones de Swarm.
• services: define los servicios web y api.
• image: imagen de cada servicio.
• ports: publica el puerto 80 del servicio web.
• deploy: bloque específico de Swarm que controla cómo se despliega el servicio.
  • replicas: número de tareas deseadas.
  • update_config: cómo se realizan las actualizaciones.
    • parallelism: 1: actualiza una réplica a la vez.
    • delay: 10s: espera 10 segundos entre cada réplica actualizada.
  • restart_policy.condition: on-failure: reinicia la tarea solo si falla.

Para desplegar este stack:

Explicación:

• docker stack deploy: despliega un conjunto de servicios como un stack.
• -c docker-compose.yml: indica el fichero Compose a usar.
• miapp: nombre del stack; los servicios se llamarán miapp_web y miapp_api.

Para listar los stacks y sus servicios:

Puedes ajustar el número de réplicas de un servicio en cualquier momento:

Este comando lleva el servicio miapp_web a cinco réplicas. Swarm crea o elimina tareas automáticamente para alcanzar el estado deseado y las distribuye entre los nodos disponibles.

Si un nodo cae, Swarm vuelve a programar las tareas perdidas en los nodos sanos, manteniendo siempre el número de réplicas solicitado. Esta es la base de la auto-reparación.

Una de las grandes ventajas de Swarm es actualizar la versión de una imagen sin cortar el servicio. Para actualizar la imagen de un servicio:

Explicación:

• docker service update: modifica un servicio en ejecución.
• --image miorg/miapi:1.1.0: nueva versión de la imagen a desplegar.
• miapp_api: servicio a actualizar.

Swarm reemplaza las réplicas una a una (según update_config), de modo que siempre haya instancias atendiendo peticiones. Si algo va mal, puedes deshacer el cambio:

Este comando revierte el servicio a la configuración anterior.

• Un solo manager en producción: si ese nodo cae, pierdes el control del clúster. Usa un número impar de managers (3 o 5) para alta disponibilidad.
• Confundir docker-compose up con docker stack deploy: docker-compose up ejecuta contenedores en una sola máquina; en Swarm debes usar docker stack deploy.
• Olvidar la sección deploy: las opciones como replicas o update_config solo se aplican en modo Swarm dentro del bloque deploy.
• Publicar puertos en conflicto: la routing mesh expone el puerto en todos los nodos; evita colisiones con servicios que ya usen ese puerto.
• No verificar el estado: usa docker service ps y docker node ls para confirmar que las tareas se ejecutan donde esperas.
• Tokens de join expuestos: trata los tokens de unión como secretos; quien los tenga puede unir nodos a tu clúster.

Inicializa un clúster Swarm en una máquina y crea un servicio llamado web con la imagen nginx:latest y 3 réplicas, publicando el puerto 80.

Escribe un fichero Compose para desplegar como stack un servicio api con la imagen miorg/miapi:1.0.0 y 4 réplicas, configurado para actualizar una réplica cada vez con 5 segundos de espera.

A partir del servicio del ejercicio anterior, explica los comandos para escalarlo a 6 réplicas y para actualizar su imagen a la versión 1.1.0.

Solución al Ejercicio 1:

Primero se inicializa el clúster (la máquina pasa a ser manager), luego se crea el servicio con 3 réplicas y el puerto publicado, y finalmente se verifican las tareas.

Solución al Ejercicio 2:

Se despliega con:

El bloque deploy define 4 réplicas y una actualización progresiva de una réplica cada 5 segundos.

Solución al Ejercicio 3:

El primer comando escala el servicio a 6 réplicas; el segundo actualiza la imagen de forma progresiva respetando la configuración update_config.

En este tema hemos aprendido qué es la orquestación y cómo Docker Swarm convierte un grupo de máquinas en un clúster gestionable con comandos familiares. Hemos visto los conceptos de nodos, servicios y tareas, inicializado un clúster, desplegado aplicaciones con docker stack deploy y realizado escalado y actualizaciones progresivas. Swarm es una excelente puerta de entrada a la orquestación, pero el estándar de la industria para entornos a gran escala es Kubernetes. En el próximo tema, Introducción a Kubernetes, conoceremos su arquitectura y sus conceptos fundamentales.