Admin-Sistemas ·

Implementación de Overlay Networks con Docker Swarm e IP‑IP tunneling

Introducción

En entornos multi‑tenant es fundamental garantizar que el tráfico de cada inquilino (tenant) quede aislado, evitando interferencias y mejorando la seguridad. Docker Swarm brinda una solución nativa para crear redes de superposición (overlay networks) que abstraen la capa de red sobre la infraestructura física. Sin embargo, cuando los nodos del clúster están distribuidos en diferentes subredes o incluso en distintas nubes, el tráfico overlay necesita un mecanismo de transporte fiable. Aquí es donde entra el túnel IP‑IP, que encapsula los paquetes overlay dentro de IP y permite su paso a través de firewalls y routers sin requerir configuraciones complejas.

Este artículo muestra cómo combinar Docker Swarm y IP‑IP tunneling para crear una red overlay segura y aislada por tenant, con ejemplos reales, comandos y buenas prácticas.

1. Preparación del entorno

1.1 Requisitos previos

  • Al menos 3 máquinas (nodos) con Ubuntu 22.04 LTS o similar.
  • Docker Engine 24.x instalado en todos los nodos.
  • Acceso root o sudo a cada nodo.
  • Conectividad de red entre nodos (puertos 2377, 7946, 4789 TCP/UDP).
  • Paquete iproute2 y iputils-ping instalados.

1.2 Instalación de Docker Engine

# En cada nodo
sudo apt-get update
sudo apt-get install -y ca-certificates curl gnupg lsb-release
sudo mkdir -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg \
  | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] \
  https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" \
  | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt-get update
sudo apt-get install -y docker-ce docker-ce-cli containerd.io
sudo usermod -aG docker $USER

Reinicie su sesión para aplicar el cambio de grupo.

1.3 Inicializar el Swarm

En el nodo que será manager:

docker swarm init --advertise-addr IP_MANAGER

Copie el token de unión que muestra el comando y úselos en los workers:

# En cada worker
docker swarm join --token SWMTKN-1:... IP_MANAGER:2377

2. Creación de redes overlay por tenant

2.1 Definición de subredes lógicas

Asignaremos a cada tenant una subred /16 dentro del rango 10.0.0.0/8. Por ejemplo:

  • Tenant A: 10.10.0.0/16
  • Tenant B: 10.20.0.0/16

2.2 Creación de la overlay network

Docker Swarm permite especificar la subred y el controlador de encriptado (opcional).

# Network para Tenant A
docker network create -d overlay \
  --subnet=10.10.0.0/16 \
  --attachable \
  tenant_a_net

Network para Tenant B

docker network create -d overlay
—subnet=10.20.0.0/16
—attachable
tenant_b_net

La opción --attachable permite que contenedores fuera de services también se conecten a la red.

2.3 Verificación de la red overlay

docker network ls
docker network inspect tenant_a_net

3. Configuración de túneles IP‑IP entre nodos

3.1 Por qué usar IP‑IP

El driver overlay de Docker utiliza VXLAN por defecto, que encapsula paquetes en UDP. En entornos donde el tráfico UDP está bloqueado o donde se desea una sobrecarga mínima, se puede sustituir por IP‑IP, que encapsula directamente en IP y funciona a nivel de capa 3.

3.2 Creación de interfaces túnel

Supongamos que los nodos están en subredes distintas: 192.168.10.0/24 (nodo1) y 192.168.20.0/24 (nodo2).

# En nodo1
sudo ip tunnel add tun0 mode ipip remote 192.168.20.5 local 192.168.10.5 ttl 255
sudo ip link set tun0 up
sudo ip addr add 10.255.0.1/30 dev tun0

En nodo2

sudo ip tunnel add tun0 mode ipip remote 192.168.10.5 local 192.168.20.5 ttl 255 sudo ip link set tun0 up sudo ip addr add 10.255.0.2/30 dev tun0

El bloque 10.255.0.0/30 es solo para el túnel; no debe solaparse con ninguna subnet de los tenants.

3.3 Enrutamiento de tráfico overlay a través del túnel

Indicamos a Docker que utilice la interfaz tun0 como ruta predeterminada para la red overlay:

# En cada nodo, añadir ruta para subredes de tenants
sudo ip route add 10.10.0.0/16 dev tun0
sudo ip route add 10.20.0.0/16 dev tun0

Con esto, cualquier paquete destinado a la red overlay será enviado por el túnel IP‑IP.

3.4 Persistencia de la configuración

Para que el túnel sobreviva a reinicios, añada las siguientes líneas a /etc/network/interfaces (Debian/Ubuntu) o cree un systemd-networkd .network file.

# /etc/network/interfaces (ejemplo)
auto tun0
iface tun0 inet static
    address 10.255.0.1
    netmask 255.255.255.252
    pre-up ip tunnel add tun0 mode ipip remote 192.168.20.5 local 192.168.10.5 ttl 255
    post-down ip tunnel del tun0

4. Despliegue de microservicios aislados por tenant

4.1 Definir servicios en stack files

Utilizaremos docker stack deploy con archivos docker-compose.yml específicos para cada tenant.

# tenant_a.yml
version: "3.8"
services:
  web:
    image: nginx:alpine
    networks:
      - tenant_a_net
    deploy:
      replicas: 3
      restart_policy:
        condition: on-failure

networks: tenant_a_net: external: true

# tenant_b.yml
version: "3.8"
services:
  api:
    image: myorg/api:latest
    networks:
      - tenant_b_net
    deploy:
      replicas: 2
      resources:
        limits:
          cpus: "0.5"
          memory: 256M

networks:
  tenant_b_net:
    external: true

4.2 Despliegue

# En el manager
docker stack deploy -c tenant_a.yml tenant_a
docker stack deploy -c tenant_b.yml tenant_b

4.3 Verificación del aislamiento

Ejecute ping entre contenedores de distintos tenants para confirmar que no hay conectividad.

# Obtener ID del contenedor del tenant A
docker ps -q --filter "name=tenant_a_web"

Entrar al contenedor

docker exec -it container_id /bin/sh

Intentar ping a la IP del tenant B (ej: 10.20.0.2)

ping -c 3 10.20.0.2

El ping debe fallar, mientras que los contenedores dentro del mismo tenant deben responder.

5. Troubleshooting y errores comunes

5.1 El overlay no se crea o queda en estado Pending

  • Síntoma: docker network ls muestra la red pero los servicios no pueden comunicarse.
  • Causa típica: Falta de conectividad entre los nodos en los puertos 7946 (TCP/UDP) y 4789 (UDP).
  • Solución:
    sudo ufw allow 7946/tcp
    sudo ufw allow 7946/udp
    sudo ufw allow 4789/udp
    sudo ufw reload
    

5.2 Paquetes atrapados en el túnel IP‑IP

  • Síntoma: Tráfico entre contenedores no llega a destino, pero tcpdump -i tun0 muestra paquetes.
  • Causa: Falta de rutas en algún nodo.
  • Solución: Verificar rutas con ip route show y añadir las que falten.

5.3 Conflicto de subredes

  • Síntoma: Al crear una overlay, Docker devuelve “subnet overlaps with existing network”.
  • Acción: Revisar todas las redes con docker network inspect y elegir una subred que no se solape con la red del túnel ni con otras overlays.

5.4 Contenedores no pueden resolver DNS interno

  • Síntoma: curl http://service_name:port falla dentro del contenedor.
  • Causa: Docker Swarm usa su propio DNS; si la red overlay está mal configurada, el DNS no funciona.
  • Solución: Asegurarse de que el contenedor está conectado a la red overlay correcta y que el servicio está despleado con un nombre DNS válido.

Conclusión

Combinar Docker Swarm overlay networks con túneles IP‑IP permite construir entornos multi‑tenant donde cada inquilino dispone de su propio segmento de red aislado, incluso cuando los nodos están dispersos en distintas subredes o nubes. La clave está en:

  • Planificar cuidadosamente las subredes de los tenants.
  • Configurar y mantener los túneles IP‑IP como transporte fiable.
  • Utilizar archivos de stack para desplegar servicios de forma reproducible.
  • Monitorear rutas y puertos críticos para evitar interrupciones.

Con los pasos y ejemplos presentados, cualquier sysadmin podrá implementar una arquitectura segura, escalable y fácil de gestionar para microservicios críticos en entornos multi‑tenant.