Controlador de red Overlay

El controlador de red overlay crea una red distribuida entre múltiples hosts del daemon de Docker. Esta red se sitúa por encima de (se superpone a) las redes específicas del host, lo que permite que los contenedores conectados a ella se comuniquen de forma segura cuando el cifrado está habilitado. Docker gestiona de manera transparente el enrutamiento de cada paquete hacia y desde el host del daemon de Docker correcto y el contenedor de destino correcto.

Puedes crear redes overlay definidas por el usuario utilizando docker network create, de la misma manera que puedes crear redes bridge definidas por el usuario. Los servicios o contenedores se pueden conectar a más de una red a la vez. Los servicios o contenedores solo pueden comunicarse a través de las redes a las que están conectados.

Las redes overlay se utilizan a menudo para crear una conexión entre servicios de Swarm, pero también puedes utilizarlas para conectar contenedores independientes que se ejecutan en diferentes hosts. Al utilizar contenedores independientes, sigue siendo necesario utilizar el modo Swarm para establecer una conexión entre los hosts.

Esta página describe las redes overlay en general y cuando se utilizan con contenedores independientes. Para obtener información sobre overlay para servicios de Swarm, consulta Gestionar redes de servicios de Swarm.

Requisitos

Los hosts de Docker deben formar parte de un swarm para utilizar redes overlay, incluso al conectar contenedores independientes. Los siguientes puertos deben estar abiertos entre los hosts participantes:

• 2377/tcp: Plano de control de Swarm (configurable)
• 4789/udp: Tráfico overlay (configurable)
• 7946/tcp y 7946/udp: Comunicación entre nodos (no configurable)

Crear una red overlay

La siguiente tabla enumera los puertos que deben estar abiertos para cada host que participe en una red overlay:

Para crear una red overlay a la que se puedan conectar contenedores de otros hosts de Docker, ejecuta el siguiente comando:

$ docker network create -d overlay --attachable mi-overlay-conectable

La opción --attachable permite que tanto los contenedores independientes como los servicios de Swarm se conecten a la red overlay. Sin la opción --attachable, solo los servicios de Swarm podrán conectarse a la red.

Puedes especificar el rango de direcciones IP, la subred, la puerta de enlace y otras opciones. Consulta docker network create --help para obtener más detalles.

Cifrar el tráfico en una red overlay

Utiliza el flag --opt encrypted para cifrar los datos de la aplicación transmitidos a través de la red overlay:

$ docker network create \
  --opt encrypted \
  --driver overlay \
  --attachable \
  mi-red-multi-host-conectable

Esto habilita el cifrado IPsec a nivel de la red de área local extensible virtual (VXLAN). Este cifrado conlleva una penalización de rendimiento no despreciable, por lo que debes probar esta opción antes de utilizarla en producción.

Warning

No conectes contenedores Windows a redes overlay cifradas.

El cifrado de redes overlay no es compatible con Windows. Swarm no informa de ningún error cuando un host de Windows intenta conectarse a una red overlay cifrada, pero la red para los contenedores Windows se verá afectada de la siguiente manera:

• Los contenedores Windows no pueden comunicarse con contenedores Linux en la red.
• El tráfico de datos entre contenedores Windows en la red no se cifra.

Conectar un contenedor a una red overlay

Añadir contenedores a una red overlay les otorga la capacidad de comunicarse con otros contenedores sin tener que configurar el enrutamiento en los hosts individuales del daemon de Docker. Un requisito previo para hacer esto es que los hosts se hayan unido al mismo Swarm.

Para unirte a una red overlay llamada multi-host-network con un contenedor busybox:

$ docker run --network multi-host-network busybox sh

Note

Esto solo funciona si la red overlay es conectable (creada con el flag --attachable).

Descubrimiento de contenedores

La publicación de puertos de un contenedor en una red overlay abre los puertos a otros contenedores en la misma red. Los contenedores se pueden descubrir realizando una búsqueda DNS utilizando el nombre del contenedor.

Límite de conexiones para redes overlay

Debido a las limitaciones establecidas por el kernel de Linux, las redes overlay se vuelven inestables y las comunicaciones entre contenedores pueden interrumpirse cuando se ubican 1000 contenedores en el mismo host.

Para obtener más información sobre esta limitación, consulta moby/moby#44973.

Ejemplos de uso

Esta sección proporciona ejemplos prácticos para trabajar con redes overlay. Estos ejemplos abarcan servicios de swarm y contenedores independientes en múltiples hosts de Docker.

Requisitos previos

Todos los ejemplos requieren al menos un swarm de un solo nodo. Inicializa uno ejecutando docker swarm init en el host. También puedes ejecutar estos ejemplos en swarms de múltiples nodos.

Utilizar la red overlay predeterminada

Este ejemplo muestra cómo funciona la red overlay predeterminada con los servicios de swarm. Crearás un servicio nginx y examinarás la red desde la perspectiva de los contenedores del servicio.

Requisitos previos para la configuración de múltiples nodos

Esta guía paso a paso requiere tres hosts de Docker que puedan comunicarse entre sí en la misma red sin que ningún cortafuegos bloquee el tráfico entre ellos:

• manager: Funciona como manager y worker.
• worker-1: Funciona solo como worker.
• worker-2: Funciona solo como worker.

Si no tienes tres hosts disponibles, puedes configurar tres máquinas virtuales en un proveedor de la nube con Docker instalado.

Crear el swarm

1. En el manager, inicializa el swarm. Si el host tiene una sola interfaz de red, el flag --advertise-addr es opcional:

   $ docker swarm init --advertise-addr=<IP-DEL-MANAGER>
   

   Guarda el token de unión que se muestra para utilizarlo con los workers.

2. En el worker-1, únete al swarm:

   $ docker swarm join --token <TOKEN> \
     --advertise-addr <IP-DEL-WORKER-1> \
     <IP-DEL-MANAGER>:2377
   

3. En el worker-2, únete al swarm:

   $ docker swarm join --token <TOKEN> \
     --advertise-addr <IP-DEL-WORKER-2> \
     <IP-DEL-MANAGER>:2377
   

4. En el manager, enumera todos los nodos:

   $ docker node ls
   
   ID                            HOSTNAME            STATUS              AVAILABILITY        MANAGER STATUS
   d68ace5iraw6whp7llvgjpu48 *   ip-172-31-34-146    Ready               Active              Leader
   nvp5rwavvb8lhdggo8fcf7plg     ip-172-31-35-151    Ready               Active
   ouvx2l7qfcxisoyms8mtkgahw     ip-172-31-36-89     Ready               Active
   

   Filtra por rol si es necesario:

   $ docker node ls --filter role=manager
   $ docker node ls --filter role=worker
   

5. Enumera las redes de Docker en todos los hosts. Cada uno tiene ahora una red overlay llamada ingress y una red bridge llamada docker_gwbridge:

   $ docker network ls
   
   NETWORK ID          NAME                DRIVER              SCOPE
   495c570066be        bridge              bridge              local
   961c6cae9945        docker_gwbridge     bridge              local
   ff35ceda3643        host                host                local
   trtnl4tqnc3n        ingress             overlay             swarm
   c8357deec9cb        none                null                local
   

La red docker_gwbridge conecta la red ingress a la interfaz de red del host de Docker. Si creas servicios sin especificar una red, estos se conectarán a ingress. Se recomienda utilizar redes overlay independientes para cada aplicación o grupo de aplicaciones relacionadas.

Crear los servicios

1. En el manager, crea una nueva red overlay:

   $ docker network create -d overlay nginx-net
   

   La red overlay se crea automáticamente en los nodos worker cuando ejecutan tareas de servicio que la necesitan.

2. En el manager, crea un servicio Nginx con 5 réplicas conectado a nginx-net:

   Note

   Los servicios solo se pueden crear en un manager.

   $ docker service create \
     --name mi-nginx \
     --publish target=80,published=80 \
     --replicas=5 \
     --network nginx-net \
     nginx
   

   El modo de publicación ingress predeterminado significa que puedes navegar al puerto 80 en cualquier nodo y conectarte a una de las 5 tareas de servicio, incluso si no se ejecutan tareas en ese nodo.

3. Supervisa el progreso de la creación del servicio:

   $ docker service ls
   

4. Inspecciona la red nginx-net en todos los hosts. La sección Containers enumera todas las tareas de servicio conectadas a la red overlay desde ese host.

5. Desde el manager, inspecciona el servicio:

   $ docker service inspect mi-nginx
   

   Observa la información sobre puertos y puntos de conexión (endpoints).

6. Crea una segunda red y actualiza el servicio para que la utilice:

   $ docker network create -d overlay nginx-net-2
   $ docker service update \
     --network-add nginx-net-2 \
     --network-rm nginx-net \
     mi-nginx
   

7. Verifica que la actualización haya finalizado:

   $ docker service ls
   

   Inspecciona ambas redes para verificar que los contenedores se movieron de nginx-net a nginx-net-2.

   Note

   Las redes overlay se crean automáticamente en los nodos worker del swarm según sea necesario, pero no se eliminan automáticamente.

8. Limpiar:

   $ docker service rm mi-nginx
   $ docker network rm nginx-net nginx-net-2
   

Utilizar una red overlay definida por el usuario

Este ejemplo muestra el enfoque recomendado para los servicios de producción utilizando redes overlay personalizadas.

Requisitos previos

Se asume que el swarm ya está configurado y que te encuentras en un nodo manager.

Pasos

1. Crea una red overlay definida por el usuario:

   $ docker network create -d overlay mi-overlay
   

2. Inicia un servicio utilizando la red overlay, publicando el puerto 80 en el puerto 8080:

   $ docker service create \
     --name mi-nginx \
     --network mi-overlay \
     --replicas 1 \
     --publish published=8080,target=80 \
     nginx:latest
   

3. Verifica que la tarea del servicio esté conectada a la red:

   $ docker network inspect mi-overlay
   

   Comprueba la sección Containers para ver la tarea del servicio mi-nginx.

4. Limpiar:

   $ docker service rm mi-nginx
   $ docker network rm mi-overlay
   

Utilizar una red overlay para contenedores independientes

Este ejemplo demuestra el descubrimiento de contenedores mediante DNS entre contenedores independientes en diferentes hosts de Docker utilizando una red overlay.

Requisitos previos

Necesitas dos hosts de Docker que puedan comunicarse entre sí con los siguientes puertos abiertos entre ellos:

• Puerto TCP 2377
• Puerto TCP y UDP 7946
• Puerto UDP 4789

Este ejemplo se refiere a los hosts como host1 y host2.

Pasos

1. Configurar el swarm:

   En host1, inicializa un swarm:

   $ docker swarm init
   Swarm initialized: current node (vz1mm9am11qcmo979tlrlox42) is now a manager.
   
   To add a worker to this swarm, run the following command:
   
       docker swarm join --token SWMTKN-1-5g90q48weqrtqryq4kj6ow0e8xm9wmv9o6vgqc5j320ymybd5c-8ex8j0bc40s6hgvy5ui5gl4gy 172.31.47.252:2377
   

   En host2, únete al swarm utilizando el token de la salida anterior:

   $ docker swarm join --token <tu_token> <tu_direccion_ip>:2377
   This node joined a swarm as a worker.
   

   Si la unión falla, ejecuta docker swarm leave --force en host2, verifica la configuración de red y del cortafuegos, e inténtalo de nuevo.

2. En host1, crea una red overlay conectable:

   $ docker network create --driver=overlay --attachable test-net
   uqsof8phj3ak0rq9k86zta6ht
   

   Toma nota del ID de red devuelto.

3. En host1, inicia un contenedor interactivo que se conecte a test-net:

   $ docker run -it --name alpine1 --network test-net alpine
   / #
   

4. En host2, enumera las redes disponibles. Observa que test-net aún no existe:

   $ docker network ls
   NETWORK ID          NAME                DRIVER              SCOPE
   ec299350b504        bridge              bridge              local
   66e77d0d0e9a        docker_gwbridge     bridge              local
   9f6ae26ccb82        host                host                local
   omvdxqrda80z        ingress             overlay             swarm
   b65c952a4b2b        none                null                local
   

5. En host2, inicia un contenedor interactivo en segundo plano (detached) que se conecte a test-net:

   $ docker run -dit --name alpine2 --network test-net alpine
   fb635f5ece59563e7b8b99556f816d24e6949a5f6a5b1fbd92ca244db17a4342
   

   Note

   El descubrimiento automático de contenedores mediante DNS solo funciona con nombres de contenedor únicos.

6. En host2, verifica que test-net se haya creado con el mismo ID de red que en host1:

   $ docker network ls
   NETWORK ID          NAME                DRIVER              SCOPE
   ...
   uqsof8phj3ak        test-net            overlay             swarm
   

7. En host1, haz ping a alpine2 desde dentro de alpine1:

   / # ping -c 2 alpine2
   PING alpine2 (10.0.0.5): 56 data bytes
   64 bytes from 10.0.0.5: seq=0 ttl=64 time=0.600 ms
   64 bytes from 10.0.0.5: seq=1 ttl=64 time=0.555 ms
   
   --- alpine2 ping statistics ---
   2 packets transmitted, 2 packets received, 0% packet loss
   round-trip min/avg/max = 0.555/0.577/0.600 ms
   

   Los dos contenedores se comunican a través de la red overlay que conecta los dos hosts. También puedes ejecutar otro contenedor en host2 y hacer ping a alpine1:

   $ docker run -it --rm --name alpine3 --network test-net alpine
   / # ping -c 2 alpine1
   / # exit
   

8. En host1, cierra la sesión de alpine1 (lo que detiene el contenedor):

   / # exit
   

9. Limpiar. Debes detener y eliminar los contenedores en cada host de forma independiente:

   En host2:

   $ docker container stop alpine2
   $ docker network ls
   $ docker container rm alpine2
   

   Al detener alpine2, test-net desaparece de host2.

   En host1:

   $ docker container rm alpine1
   $ docker network rm test-net
   

Siguientes pasos

• Aprende sobre la red desde el punto de vista del contenedor
• Aprende sobre las redes bridge independientes
• Aprende sobre las redes Macvlan