Redes Docker: Bridge, Host, Overlay - Guía Completa

Las redes Docker permiten la comunicación entre contenedores, con el host y a través de múltiples hosts. Comprender los controladores de red de Docker—bridge, host, overlay y otros—es esencial para construir aplicaciones contenerizadas escalables y seguras. Esta guía completa cubre todos los modos de red de Docker con ejemplos prácticos y mejores prácticas para producción.

Tabla de Contenidos

Introducción a las Redes Docker

Las redes Docker proporcionan entornos de red aislados para contenedores, permitiendo patrones de comunicación seguros mientras mantienen flexibilidad. Cada controlador de red ofrece diferentes capacidades adecuadas para casos de uso específicos, desde desarrollo en un solo host hasta clústeres de producción multi-host.

Controladores de Red Docker

  • Bridge: Red predeterminada para comunicación de contenedores en un solo host
  • Host: Elimina el aislamiento de red, usa la red del host directamente
  • Overlay: Habilita redes multi-host para Swarm y Kubernetes
  • Macvlan: Asigna direcciones MAC a contenedores para integración con aplicaciones legacy
  • None: Desactiva completamente las redes
  • Custom: Plugins de red de terceros (Weave, Calico, etc.)

Por Qué Importa la Red Docker

  • Aislamiento: Espacios de nombres de red separados para seguridad
  • Descubrimiento de Servicios: Resolución DNS automática entre contenedores
  • Balanceo de Carga: Balanceo de carga integrado entre réplicas
  • Escalabilidad: Red a través de múltiples hosts
  • Seguridad: Control de acceso a nivel de red

Requisitos Previos

Antes de adentrarte en las redes Docker, asegúrate de tener:

  • Docker Engine instalado (versión 19.03 o superior)
  • Acceso root o sudo
  • Comprensión básica de conceptos de red (IP, subred, gateway)
  • Múltiples contenedores o servicios para pruebas
  • Para redes overlay: Docker Swarm inicializado

Verificar instalación de Docker:

docker --version
docker network ls

Arquitectura de Red Docker

Espacio de Nombres de Red

Cada red Docker opera en su propio espacio de nombres de red, proporcionando aislamiento:

# Ver espacios de nombres de red
sudo ip netns list

# Docker crea espacios de nombres en /var/run/docker/netns/
sudo ls /var/run/docker/netns/

Interfaz de Red de Contenedores (CNI)

Docker usa varias interfaces de red:

  • veth pairs: Conexiones ethernet virtuales
  • docker0 bridge: Interfaz bridge predeterminada
  • Network namespaces: Mecanismo de aislamiento

Inspeccionar Redes Predeterminadas

# Listar todas las redes
docker network ls

# Inspeccionar bridge predeterminado
docker network inspect bridge

Red Bridge

La red bridge es el controlador de red predeterminado para contenedores en un solo host. Docker crea un bridge virtual (docker0) y conecta contenedores a él mediante pares ethernet virtuales.

Red Bridge Predeterminada

Cuando ejecutas un contenedor sin especificar una red, se conecta al bridge predeterminado:

# Ejecutar contenedor en bridge predeterminado
docker run -d --name web1 nginx

# Inspeccionar red del contenedor
docker inspect web1 | grep IPAddress

Limitaciones del Bridge Predeterminado:

  • Los contenedores se comunican solo mediante direcciones IP
  • Sin resolución DNS automática por nombre de contenedor
  • Todos los contenedores comparten el mismo bridge (menor aislamiento)

Redes Bridge Definidas por el Usuario

Las redes bridge personalizadas proporcionan mejor aislamiento y características:

# Crear red bridge personalizada
docker network create my-bridge

# Crear con subred personalizada
docker network create \
  --driver bridge \
  --subnet 172.18.0.0/16 \
  --gateway 172.18.0.1 \
  my-custom-bridge

# Ejecutar contenedores en bridge personalizado
docker run -d --name web --network my-bridge nginx
docker run -d --name api --network my-bridge node:18-alpine

Ventajas:

  • Resolución DNS automática por nombre de contenedor
  • Mejor aislamiento entre aplicaciones
  • Gestión de direcciones IP personalizada
  • Conexiones/desconexiones de contenedores en tiempo real

Configuración de Red Bridge

# Crear bridge con opciones avanzadas
docker network create \
  --driver bridge \
  --subnet 10.10.0.0/16 \
  --ip-range 10.10.10.0/24 \
  --gateway 10.10.0.1 \
  --opt "com.docker.network.bridge.name"="my-bridge" \
  --opt "com.docker.network.bridge.enable_icc"="true" \
  --opt "com.docker.network.bridge.enable_ip_masquerade"="true" \
  --opt "com.docker.network.driver.mtu"="1500" \
  advanced-bridge

Comunicación de Contenedores en Bridge

# Crear red y contenedores
docker network create app-network
docker run -d --name database --network app-network postgres:15-alpine
docker run -d --name backend --network app-network node:18-alpine

# Probar conectividad desde backend a database
docker exec backend ping database
docker exec backend nslookup database

Publicación de Puertos

Exponer puertos de contenedor al host:

# Publicar a puerto aleatorio del host
docker run -d -P nginx

# Publicar a puerto específico
docker run -d -p 8080:80 nginx

# Vincular a interfaz específica
docker run -d -p 127.0.0.1:8080:80 nginx

# Publicar múltiples puertos
docker run -d -p 8080:80 -p 8443:443 nginx

# Publicar puerto UDP
docker run -d -p 53:53/udp dns-server

Asignación de IP Estática

# Crear red con subred
docker network create --subnet 172.20.0.0/16 static-net

# Ejecutar contenedor con IP estática
docker run -d \
  --name web \
  --network static-net \
  --ip 172.20.0.10 \
  nginx

Ejemplo de Red Bridge

Ejemplo completo con múltiples servicios:

# Crear red
docker network create \
  --driver bridge \
  --subnet 172.25.0.0/16 \
  --gateway 172.25.0.1 \
  web-app-net

# Contenedor de base de datos
docker run -d \
  --name postgres \
  --network web-app-net \
  --ip 172.25.0.10 \
  -e POSTGRES_PASSWORD=secret \
  postgres:15-alpine

# Caché Redis
docker run -d \
  --name redis \
  --network web-app-net \
  --ip 172.25.0.11 \
  redis:alpine

# API Backend
docker run -d \
  --name api \
  --network web-app-net \
  --ip 172.25.0.20 \
  -e DATABASE_URL=postgres://[email protected]:5432/app \
  -e REDIS_URL=redis://172.25.0.11:6379 \
  my-api:latest

# Frontend (con publicación de puerto)
docker run -d \
  --name frontend \
  --network web-app-net \
  -p 8080:80 \
  my-frontend:latest

Red Host

El modo de red host elimina el aislamiento de red entre contenedor y host. El contenedor usa la pila de red del host directamente.

Usando Red Host

# Ejecutar contenedor con red host
docker run -d --network host nginx

# El contenedor usa los puertos del host directamente
# No se necesita la bandera -p

Cuándo Usar Red Host

Ventajas:

  • Máximo rendimiento de red (sin overhead de NAT)
  • No se requiere mapeo de puertos
  • Acceso directo a interfaces de red del host

Desventajas:

  • Sin aislamiento de red
  • Conflictos de puerto con servicios del host
  • Seguridad reducida
  • No portable entre hosts

Casos de Uso

# Herramienta de monitoreo de red
docker run -d --network host --name monitor netdata/netdata

# Aplicaciones de alto rendimiento
docker run -d --network host redis:alpine

# Herramientas que requieren acceso a red del host
docker run -it --network host nicolaka/netshoot

Ejemplo de Red Host

# Ejecutar aplicación en red host
docker run -d \
  --name web-server \
  --network host \
  -e PORT=8080 \
  my-app:latest

# Acceder directamente en host:8080
curl http://localhost:8080

Importante: La red host solo está disponible en Linux. En Mac/Windows, se comporta de manera diferente debido a la arquitectura VM de Docker Desktop.

Red Overlay

Las redes overlay permiten la comunicación entre contenedores a través de múltiples hosts Docker. Se usan principalmente con Docker Swarm para orquestación.

Requisitos Previos para Overlay

  1. Docker Swarm debe estar inicializado
  2. Puertos abiertos entre hosts:
    • TCP 2377 (gestión de clúster)
    • TCP/UDP 7946 (comunicación de nodos)
    • UDP 4789 (tráfico de red overlay)

Inicializar Docker Swarm

# En nodo manager
docker swarm init --advertise-addr <MANAGER-IP>

# En nodos worker (usar token de salida de init)
docker swarm join --token <TOKEN> <MANAGER-IP>:2377

Crear Red Overlay

# Crear red overlay
docker network create \
  --driver overlay \
  --subnet 10.0.0.0/24 \
  --gateway 10.0.0.1 \
  my-overlay

# Crear overlay con encriptación
docker network create \
  --driver overlay \
  --opt encrypted \
  secure-overlay

# Overlay adjuntable (para contenedores standalone)
docker network create \
  --driver overlay \
  --attachable \
  app-overlay

Desplegar Servicios en Overlay

# Crear servicio en red overlay
docker service create \
  --name web \
  --network my-overlay \
  --replicas 3 \
  nginx

# Crear aplicación multi-tier
docker service create \
  --name database \
  --network my-overlay \
  postgres:15-alpine

docker service create \
  --name api \
  --network my-overlay \
  --replicas 5 \
  my-api:latest

Red Overlay con Docker Compose

version: '3.8'

services:
  web:
    image: nginx
    deploy:
      replicas: 3
    networks:
      - overlay-net

  api:
    image: my-api:latest
    deploy:
      replicas: 5
    networks:
      - overlay-net

  database:
    image: postgres:15-alpine
    networks:
      - overlay-net

networks:
  overlay-net:
    driver: overlay
    attachable: true

Desplegar stack:

docker stack deploy -c docker-compose.yml myapp

Ejemplo de Red Overlay

Configuración completa multi-host:

# En manager de Swarm
docker network create \
  --driver overlay \
  --subnet 10.1.0.0/16 \
  --opt encrypted=true \
  production-overlay

# Desplegar tier web (3 réplicas entre nodos)
docker service create \
  --name web \
  --network production-overlay \
  --replicas 3 \
  --publish published=80,target=80 \
  nginx

# Desplegar tier API (5 réplicas)
docker service create \
  --name api \
  --network production-overlay \
  --replicas 5 \
  my-api:latest

# Desplegar base de datos (réplica única en manager)
docker service create \
  --name postgres \
  --network production-overlay \
  --constraint node.role==manager \
  --mount type=volume,source=db-data,target=/var/lib/postgresql/data \
  postgres:15-alpine

Red Macvlan

Macvlan asigna direcciones MAC a contenedores, haciéndolos aparecer como dispositivos físicos en la red. Útil para aplicaciones legacy que esperan estar en red física.

Crear Red Macvlan

# Crear red macvlan
docker network create \
  --driver macvlan \
  --subnet 192.168.1.0/24 \
  --gateway 192.168.1.1 \
  --opt parent=eth0 \
  macvlan-net

Ejecutar Contenedor en Macvlan

# Ejecutar con MAC e IP específicas
docker run -d \
  --name legacy-app \
  --network macvlan-net \
  --ip 192.168.1.100 \
  legacy-image:latest

Trunking VLAN 802.1Q

# Crear macvlan con etiquetado VLAN
docker network create \
  --driver macvlan \
  --subnet 192.168.10.0/24 \
  --gateway 192.168.10.1 \
  --opt parent=eth0.10 \
  macvlan-vlan10

Casos de Uso de Macvlan

  • Aplicaciones legacy que requieren conectividad de capa 2
  • Herramientas de monitoreo y seguridad de red
  • Aplicaciones que necesitan acceso directo a la red
  • Integración con infraestructura de red existente

Limitaciones:

  • No puede comunicarse con el host (por diseño)
  • Requiere modo promiscuo en algunas redes
  • Proveedores de nube a menudo bloquean macvlan

Red None

Desactiva completamente las redes. El contenedor solo tiene interfaz loopback.

Usando Red None

# Ejecutar contenedor sin red
docker run -d --network none alpine

# Verificar que no hay interfaces de red
docker exec <container> ip addr show

Casos de Uso

  • Máximo aislamiento para cargas de trabajo sensibles a seguridad
  • Contenedores de procesamiento por lotes que no necesitan red
  • Prueba de escenarios sin red

Redes de Contenedores

Conectar Contenedor a Múltiples Redes

# Crear dos redes
docker network create frontend
docker network create backend

# Ejecutar contenedor en frontend
docker run -d --name app --network frontend nginx

# Conectar mismo contenedor a backend
docker network connect backend app

# Verificar conexiones
docker inspect app | grep Networks -A 20

Desconectar Contenedor de Red

# Desconectar de red
docker network disconnect backend app

Alias de Red de Contenedores

# Crear red
docker network create app-net

# Ejecutar con alias de red
docker run -d \
  --name web1 \
  --network app-net \
  --network-alias webapp \
  nginx

docker run -d \
  --name web2 \
  --network app-net \
  --network-alias webapp \
  nginx

# Ambos contenedores accesibles vía 'webapp' (DNS round-robin)
docker run --rm --network app-net alpine nslookup webapp

Comandos de Red

Comandos Esenciales de Red

# Listar redes
docker network ls

# Crear red
docker network create my-network

# Inspeccionar red
docker network inspect my-network

# Conectar contenedor a red
docker network connect my-network container-name

# Desconectar contenedor
docker network disconnect my-network container-name

# Eliminar red
docker network rm my-network

# Eliminar redes no usadas
docker network prune

Inspección Avanzada

# Obtener ID de red
docker network ls -q -f name=my-network

# Formatear salida
docker network inspect --format='{{range .Containers}}{{.Name}} {{end}}' my-network

# Obtener IP de contenedor en red
docker inspect \
  --format='{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' \
  container-name

Información de Red

# Ver redes del contenedor
docker inspect container-name | grep Networks -A 20

# Ver todos los contenedores en red
docker network inspect my-network

# Obtener gateway
docker network inspect --format='{{.IPAM.Config}}' my-network

DNS y Descubrimiento de Servicios

Resolución DNS Automática

Los contenedores en redes definidas por usuario pueden resolverse entre sí por nombre:

# Crear red y contenedores
docker network create app-net
docker run -d --name db --network app-net postgres:15-alpine
docker run -d --name api --network app-net my-api:latest

# API puede conectarse a base de datos usando hostname 'db'
docker exec api ping db
docker exec api nslookup db

Configuración DNS Personalizada

# Ejecutar contenedor con DNS personalizado
docker run -d \
  --name web \
  --dns 8.8.8.8 \
  --dns 8.8.4.4 \
  --dns-search example.com \
  nginx

# Configurar DNS en daemon.json
sudo nano /etc/docker/daemon.json

Agregar:

{
  "dns": ["8.8.8.8", "8.8.4.4"],
  "dns-search": ["example.com"]
}

DNS Round Robin

# Crear múltiples contenedores con mismo alias de red
docker network create lb-net

docker run -d --name web1 --network lb-net --network-alias web nginx
docker run -d --name web2 --network lb-net --network-alias web nginx
docker run -d --name web3 --network lb-net --network-alias web nginx

# Consultas DNS hacen round-robin entre contenedores
docker run --rm --network lb-net alpine nslookup web

Seguridad de Red

Aislamiento de Red

# Crear redes aisladas para diferentes aplicaciones
docker network create app1-net
docker network create app2-net

# Contenedores App1
docker run -d --name app1-web --network app1-net nginx
docker run -d --name app1-db --network app1-net postgres

# Contenedores App2 (aislados de app1)
docker run -d --name app2-web --network app2-net nginx
docker run -d --name app2-db --network app2-net postgres

Encriptación de Red

# Crear red overlay encriptada
docker network create \
  --driver overlay \
  --opt encrypted=true \
  secure-overlay

Desactivar Comunicación Entre Contenedores

# Crear red con ICC desactivado
docker network create \
  --driver bridge \
  --opt com.docker.network.bridge.enable_icc=false \
  isolated-bridge

Reglas de Firewall con iptables

Docker gestiona iptables automáticamente, pero puedes agregar reglas personalizadas:

# Ver reglas iptables de Docker
sudo iptables -t nat -L -n

# Agregar regla personalizada (ejemplo)
sudo iptables -I DOCKER-USER -i ext_if ! -s 192.168.1.0/24 -j DROP

Mejores Prácticas para Producción

Usar Redes Definidas por Usuario

# No usar bridge predeterminado
# Crear redes específicas de aplicación
docker network create \
  --driver bridge \
  --subnet 172.28.0.0/16 \
  production-app

Convención de Nombres de Red

# Usar nombres descriptivos
docker network create prod-frontend
docker network create prod-backend
docker network create prod-database

Limitar Exposición de Red

# Publicar solo puertos necesarios
docker run -d \
  -p 127.0.0.1:5432:5432 \
  --name database \
  --network backend \
  postgres

Usar Alias de Red para Descubrimiento de Servicios

version: '3.8'

services:
  web:
    image: nginx
    networks:
      frontend:
        aliases:
          - webserver
          - www

Monitorear Tráfico de Red

# Instalar herramientas de monitoreo de red
docker run -d \
  --name monitor \
  --network host \
  --cap-add NET_ADMIN \
  nicolaka/netshoot

# Usar tcpdump en contenedor
docker exec -it monitor tcpdump -i eth0

Documentar Arquitectura de Red

# docker-compose.yml con estructura de red clara
version: '3.8'

networks:
  frontend:
    driver: bridge
    ipam:
      config:
        - subnet: 172.28.1.0/24
  backend:
    driver: bridge
    ipam:
      config:
        - subnet: 172.28.2.0/24
  database:
    driver: bridge
    internal: true  # Sin acceso externo
    ipam:
      config:
        - subnet: 172.28.3.0/24

Resolución de Problemas

El Contenedor No Puede Conectarse

# Verificar que el contenedor está en la red correcta
docker inspect container-name | grep Networks -A 10

# Verificar conectividad de red
docker exec container-name ping target-container

# Verificar resolución DNS
docker exec container-name nslookup target-container

# Verificar configuración de red
docker network inspect network-name

Conflicto de Puerto

# Encontrar proceso usando puerto
sudo netstat -tulpn | grep :8080
sudo lsof -i :8080

# Verificar mapeos de puerto Docker
docker ps --format "table {{.Names}}\t{{.Ports}}"

Red No Encontrada

# Listar todas las redes
docker network ls

# Recrear red
docker network rm old-network
docker network create new-network

No Se Puede Eliminar Red

# Encontrar contenedores usando red
docker network inspect network-name | grep Name

# Detener y eliminar contenedores
docker stop $(docker ps -q --filter network=network-name)
docker rm $(docker ps -aq --filter network=network-name)

# Eliminar red
docker network rm network-name

Problemas de Resolución DNS

# Verificar configuración DNS
docker exec container-name cat /etc/resolv.conf

# Probar DNS
docker exec container-name nslookup google.com

# Usar DNS personalizado
docker run --dns 8.8.8.8 --dns 8.8.4.4 image-name

Problemas de Rendimiento de Red

# Verificar configuración MTU
docker network inspect network-name | grep MTU

# Ajustar MTU
docker network create --opt com.docker.network.driver.mtu=1450 my-net

# Probar ancho de banda
docker run -it --rm networkstatic/iperf3 iperf3 -c server-ip

Depurar Red

# Usar netshoot para depuración
docker run -it --rm --network container:target-container nicolaka/netshoot

# Dentro de netshoot, usar herramientas:
ip addr show
ip route
netstat -tulpn
tcpdump -i eth0

Conclusión

Las redes Docker proporcionan entornos de red flexibles y aislados para contenedores. Comprender los modos bridge, host, overlay y otros es esencial para construir aplicaciones escalables y seguras.

Puntos Clave

  • Redes Bridge: Predeterminadas para un solo host, usar bridges definidos por usuario para DNS
  • Red Host: Máximo rendimiento pero sin aislamiento
  • Redes Overlay: Comunicación multi-host para clústeres Swarm
  • Aislamiento de Red: Usar redes separadas para seguridad
  • Descubrimiento de Servicios: Resolución DNS automática en redes definidas por usuario
  • Listo para Producción: Usar encriptación, monitoreo y aislamiento adecuado

Referencia Rápida

# Gestión de Redes
docker network create my-net                    # Crear red
docker network ls                               # Listar redes
docker network inspect my-net                   # Inspeccionar red
docker network rm my-net                        # Eliminar red
docker network prune                            # Eliminar no usadas

# Redes de Contenedores
docker run --network my-net nginx               # Ejecutar en red
docker network connect my-net container         # Conectar a red
docker network disconnect my-net container      # Desconectar
docker run -p 8080:80 nginx                     # Publicar puerto

# Tipos de Red
docker network create --driver bridge my-bridge # Red bridge
docker run --network host nginx                 # Red host
docker network create --driver overlay my-overlay # Red overlay

Próximos Pasos

  1. Practicar: Crear diferentes topologías de red
  2. Asegurar: Implementar estrategias de aislamiento de red
  3. Monitorear: Configurar monitoreo de tráfico de red
  4. Escalar: Desplegar redes overlay con Swarm
  5. Optimizar: Ajustar rendimiento de red para tu carga de trabajo
  6. Documentar: Mantener diagramas de arquitectura de red
  7. Probar: Implementar pruebas de caos en red

Las redes Docker son fundamentales para la orquestación de contenedores. Domina estos conceptos para construir aplicaciones contenerizadas robustas y escalables.