Cómo usar el comando docker network create para administrar redes de contenedores

Introducción

En este laboratorio, aprenderá cómo gestionar eficazmente las redes de contenedores utilizando el comando docker network create. Exploraremos diferentes tipos y configuraciones de redes para comprender cómo se comunican los contenedores entre sí y con el mundo exterior.

Específicamente, obtendrá experiencia práctica en la creación de redes bridge (puente) básicas, la personalización de redes bridge con subredes y puertas de enlace específicas, y la configuración de redes overlay (superpuestas) adjuntables e internas para escenarios de comunicación multi-host. Al final de este laboratorio, tendrá una comprensión sólida de cómo diseñar e implementar diversas topologías de red para sus contenedores Docker.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL docker(("Docker")) -.-> docker/ContainerOperationsGroup(["Container Operations"]) docker(("Docker")) -.-> docker/NetworkOperationsGroup(["Network Operations"]) docker/ContainerOperationsGroup -.-> docker/ls("List Containers") docker/ContainerOperationsGroup -.-> docker/rm("Remove Container") docker/ContainerOperationsGroup -.-> docker/exec("Execute Command in Container") docker/ContainerOperationsGroup -.-> docker/inspect("Inspect Container") docker/NetworkOperationsGroup -.-> docker/network("Manage Networks") subgraph Lab Skills docker/ls -.-> lab-555174{{"Cómo usar el comando docker network create para administrar redes de contenedores"}} docker/rm -.-> lab-555174{{"Cómo usar el comando docker network create para administrar redes de contenedores"}} docker/exec -.-> lab-555174{{"Cómo usar el comando docker network create para administrar redes de contenedores"}} docker/inspect -.-> lab-555174{{"Cómo usar el comando docker network create para administrar redes de contenedores"}} docker/network -.-> lab-555174{{"Cómo usar el comando docker network create para administrar redes de contenedores"}} end

Crear una red bridge (puente) básica

En este paso, aprenderemos cómo crear una red bridge básica en Docker. Una red bridge es el tipo de red predeterminado para los contenedores. Los contenedores conectados a la misma red bridge pueden comunicarse entre sí, mientras que están aislados de los contenedores en otras redes bridge y de la red de la máquina host.

Primero, listemos las redes Docker existentes para ver las predeterminadas.

docker network ls

Debería ver algunas redes predeterminadas como bridge, host y none. La red bridge es con la que trabajaremos.

Ahora, creemos una nueva red bridge. La llamaremos my-bridge-network.

docker network create my-bridge-network

Este comando crea una nueva red bridge con la configuración predeterminada. Docker asigna automáticamente una subred y una puerta de enlace a esta red.

Para verificar que la red se haya creado correctamente, liste las redes Docker nuevamente.

docker network ls

Ahora debería ver my-bridge-network en la lista.

A continuación, inspeccionemos la red recién creada para ver sus detalles, incluyendo la subred y la puerta de enlace asignadas por Docker.

docker network inspect my-bridge-network

La salida de este comando proporcionará información detallada sobre la red, como su ID, el controlador (que debería ser bridge) y la subred y la puerta de enlace en la sección IPAM.

Ahora, ejecutemos un contenedor y conectémoslo a nuestra nueva red. Usaremos la imagen alpine para este ejemplo. Si no tiene la imagen alpine localmente, Docker la descargará automáticamente.

docker run -d --name container1 --network my-bridge-network alpine sleep infinity

Este comando ejecuta un contenedor llamado container1 en modo desatendido (-d), lo conecta a my-bridge-network (--network my-bridge-network) y lo mantiene en ejecución ejecutando el comando sleep infinity.

Para verificar que el contenedor está en ejecución y conectado a la red correcta, puede inspeccionar el contenedor.

docker inspect container1

En la salida, busque la sección Networks. Debería ver my-bridge-network enumerado, junto con la dirección IP asignada al contenedor dentro de esa red.

Finalmente, ejecutemos otro contenedor y conectémoslo a la misma red para demostrar la comunicación entre ellos.

docker run -d --name container2 --network my-bridge-network alpine sleep infinity

Ahora, tanto container1 como container2 están conectados a my-bridge-network. Deben poder comunicarse entre sí utilizando sus nombres de contenedor o direcciones IP dentro de la red.

Para probar la comunicación, podemos ejecutar un comando dentro de container1 para hacer ping a container2. Primero, necesitamos instalar el paquete iputils en los contenedores alpine para usar el comando ping.

docker exec container1 apk add --no-cache iputils
docker exec container2 apk add --no-cache iputils

Ahora, haga ping a container2 desde container1.

docker exec container1 ping -c 3 container2

Debería ver respuestas de ping exitosas, lo que indica que los dos contenedores en la misma red bridge pueden comunicarse.

Crear una red bridge (puente) con subred y puerta de enlace personalizadas

En el paso anterior, creamos una red bridge con la configuración predeterminada. Docker asignó automáticamente una subred y una puerta de enlace. En este paso, aprenderemos cómo crear una red bridge y especificar nuestra propia subred y puerta de enlace. Esto le da más control sobre la configuración de red de sus contenedores.

Primero, eliminemos los contenedores y la red creados en el paso anterior para comenzar de nuevo.

docker stop container1 container2
docker rm container1 container2
docker network rm my-bridge-network

Ahora, creemos una nueva red bridge llamada custom-bridge-network y especifiquemos una subred y una puerta de enlace personalizadas utilizando las opciones --subnet y --gateway. Usaremos la subred 172.20.0.0/16 y la puerta de enlace 172.20.0.1.

docker network create \
  --driver bridge \
  --subnet 172.20.0.0/16 \
  --gateway 172.20.0.1 \
  custom-bridge-network

La opción --driver bridge especifica explícitamente el controlador bridge, aunque es el predeterminado. La opción --subnet define el rango de direcciones IP para la red, y la opción --gateway establece la dirección IP de la puerta de enlace para los contenedores conectados a esta red.

Para verificar que la red se haya creado con la subred y la puerta de enlace especificadas, inspeccione la red.

docker network inspect custom-bridge-network

En la salida, busque en la sección IPAM. Debería ver que los campos Subnet y Gateway coinciden con los valores que proporcionó (172.20.0.0/16 y 172.20.0.1).

Ahora, ejecutemos un contenedor y conectémoslo a nuestra nueva red. Usaremos la imagen alpine nuevamente.

docker run -d --name custom-container1 --network custom-bridge-network alpine sleep infinity

Este comando ejecuta un contenedor llamado custom-container1 y lo conecta a custom-bridge-network. Docker asignará una dirección IP a este contenedor de la subred especificada (172.20.0.0/16).

Para verificar la dirección IP del contenedor dentro de la red personalizada, inspeccione el contenedor.

docker inspect custom-container1

En la salida, en la sección Networks para custom-bridge-network, debería ver una IpAddress que esté dentro del rango 172.20.0.0/16.

Ejecutemos otro contenedor en la misma red.

docker run -d --name custom-container2 --network custom-bridge-network alpine sleep infinity

Ahora, tanto custom-container1 como custom-container2 están en custom-bridge-network y deberían poder comunicarse.

Como en el paso anterior, necesitamos iputils para hacer ping.

docker exec custom-container1 apk add --no-cache iputils
docker exec custom-container2 apk add --no-cache iputils

Pruebe la comunicación haciendo ping a custom-container2 desde custom-container1.

docker exec custom-container1 ping -c 3 custom-container2

Debería ver respuestas de ping exitosas, lo que confirma la comunicación dentro de la red bridge personalizada.

Crear una red overlay (superpuesta) con posibilidad de conexión para comunicación entre múltiples hosts

Las redes bridge (puente) son adecuadas para la comunicación entre contenedores en el mismo host de Docker. Sin embargo, para la comunicación entre contenedores que se ejecutan en diferentes hosts de Docker, se necesita una red overlay. Las redes overlay son creadas y administradas por Docker Swarm.

En este paso, crearemos una red overlay con posibilidad de conexión. Una red overlay con posibilidad de conexión permite que contenedores independientes (no parte de un servicio de Swarm) se conecten a ella y se comuniquen a través de diferentes hosts de Docker.

Primero, necesitamos inicializar Docker Swarm en este host. Esto es necesario para crear y administrar redes overlay.

docker swarm init --advertise-addr $(hostname -I | awk '{print $1}')

Este comando inicializa el Swarm y establece la dirección de anunciación en la dirección IP del host. La salida mostrará que el nodo actual es ahora un administrador de Swarm.

Ahora que Swarm está inicializado, podemos crear una red overlay con posibilidad de conexión. La llamaremos my-overlay-network. La opción --attachable es crucial para permitir que los contenedores independientes se conecten.

docker network create \
  --driver overlay \
  --attachable \
  my-overlay-network

La opción --driver overlay especifica que estamos creando una red overlay. La opción --attachable hace que la red esté disponible para contenedores independientes.

Para verificar que la red overlay se haya creado, liste las redes Docker.

docker network ls

Debería ver my-overlay-network en la lista, y su controlador debería ser overlay.

Ahora, ejecutemos un contenedor independiente y conectémoslo a nuestra nueva red overlay. Usaremos la imagen alpine.

docker run -d --name overlay-container1 --network my-overlay-network alpine sleep infinity

Este comando ejecuta un contenedor llamado overlay-container1 y lo conecta a my-overlay-network.

Para verificar que el contenedor está conectado a la red overlay, inspeccione el contenedor.

docker inspect overlay-container1

En la salida, busque la sección Networks. Debería ver my-overlay-network enumerado.

Dado que este es un entorno de un solo host, no podemos demostrar completamente la comunicación entre múltiples hosts. Sin embargo, la red está configurada para permitirla si tuviera múltiples nodos de Swarm.

Ejecutemos otro contenedor en la misma red overlay en este host único.

docker run -d --name overlay-container2 --network my-overlay-network alpine sleep infinity

Ahora, tanto overlay-container1 como overlay-container2 están en my-overlay-network y deberían poder comunicarse.

Instale iputils en los contenedores para hacer ping.

docker exec overlay-container1 apk add --no-cache iputils
docker exec overlay-container2 apk add --no-cache iputils

Pruebe la comunicación haciendo ping a overlay-container2 desde overlay-container1.

docker exec overlay-container1 ping -c 3 overlay-container2

Debería ver respuestas de ping exitosas, lo que confirma la comunicación dentro de la red overlay en este host único.

Crear una red overlay (superpuesta) interna

En el paso anterior, creamos una red overlay con posibilidad de conexión que permite que los contenedores independientes se conecten. En este paso, crearemos una red overlay interna. Las redes internas están aisladas de las redes externas, lo que significa que los contenedores en una red interna no pueden comunicarse con el mundo exterior (incluida la red del host de Docker) a menos que se permita explícitamente. Esto es útil para crear redes de servicios aislados dentro de un Swarm.

Primero, limpiemos los contenedores y la red del paso anterior.

docker stop overlay-container1 overlay-container2
docker rm overlay-container1 overlay-container2
docker network rm my-overlay-network

Ahora, creemos una red overlay interna llamada my-internal-network. Usamos la opción --internal para esto.

docker network create \
  --driver overlay \
  --internal \
  my-internal-network

La opción --internal asegura que los contenedores conectados a esta red no puedan comunicarse con redes externas.

Para verificar que la red overlay interna se haya creado, liste las redes Docker.

docker network ls

Debería ver my-internal-network en la lista con el controlador overlay.

Ahora, ejecutemos un contenedor y conectémoslo a nuestra nueva red interna. Usaremos la imagen alpine.

docker run -d --name internal-container1 --network my-internal-network alpine sleep infinity

Este comando ejecuta un contenedor llamado internal-container1 y lo conecta a my-internal-network.

Para verificar que el contenedor está conectado a la red interna, inspeccione el contenedor.

docker inspect internal-container1

En la salida, busque la sección Networks. Debería ver my-internal-network enumerado.

Ejecutemos otro contenedor en la misma red interna.

docker run -d --name internal-container2 --network my-internal-network alpine sleep infinity

Ahora, tanto internal-container1 como internal-container2 están en my-internal-network. Deben poder comunicarse entre sí, pero no con el mundo exterior.

Instale iputils en los contenedores para hacer ping.

docker exec internal-container1 apk add --no-cache iputils
docker exec internal-container2 apk add --no-cache iputils

Pruebe la comunicación haciendo ping a internal-container2 desde internal-container1.

docker exec internal-container1 ping -c 3 internal-container2

Debería ver respuestas de ping exitosas, lo que confirma la comunicación dentro de la red overlay interna.

Ahora, intentemos hacer ping a una dirección externa, como google.com, desde internal-container1.

docker exec internal-container1 ping -c 3 google.com

Este ping debería fallar porque la red interna está aislada de las redes externas.

Resumen

En este laboratorio, aprendimos cómo usar el comando docker network create para administrar redes de contenedores. Comenzamos creando una red bridge (puente) básica, que es el tipo de red predeterminado para los contenedores, y verificamos su creación y detalles utilizando docker network ls y docker network inspect. Luego demostramos cómo conectar un contenedor a esta red recién creada.

Basándonos en la red bridge básica, exploramos la creación de una red bridge con una subred y una puerta de enlace personalizadas para tener más control sobre la asignación de direcciones IP de la red. Finalmente, profundizamos en la creación de redes overlay (superpuestas), específicamente una red overlay con posibilidad de conexión para la comunicación entre múltiples hosts y una red overlay interna para la comunicación aislada dentro de un swarm, mostrando la versatilidad de la red de Docker para diferentes escenarios de implementación.