Como usar o comando docker network create para gerenciar redes de contêineres

Introdução

Neste laboratório, você aprenderá como gerenciar redes de contêineres de forma eficaz usando o comando docker network create. Exploraremos diferentes tipos e configurações de rede para entender como os contêineres se comunicam entre si e com o mundo exterior.

Especificamente, você terá experiência prática na criação de redes bridge básicas, personalizando redes bridge com sub-redes e gateways específicos, e configurando redes overlay (sobreposição) anexáveis e internas para cenários de comunicação multi-host. Ao final deste laboratório, você terá uma sólida compreensão de como projetar e implementar várias topologias de rede para seus contêineres Docker.

Criar uma rede bridge básica

Nesta etapa, aprenderemos como criar uma rede bridge básica no Docker. Uma rede bridge é o tipo de rede padrão para contêineres. Contêineres conectados à mesma rede bridge podem se comunicar entre si, enquanto são isolados de contêineres em outras redes bridge e da rede da máquina host.

Primeiro, vamos listar as redes Docker existentes para ver as redes padrão.

docker network ls

Você deve ver algumas redes padrão como bridge, host e none. A rede bridge é aquela com a qual trabalharemos.

Agora, vamos criar uma nova rede bridge. Vamos chamá-la de my-bridge-network.

docker network create my-bridge-network

Este comando cria uma nova rede bridge com as configurações padrão. O Docker atribui automaticamente uma sub-rede e um gateway a esta rede.

Para verificar se a rede foi criada com sucesso, liste as redes Docker novamente.

docker network ls

Você deve ver agora my-bridge-network na lista.

Em seguida, vamos inspecionar a rede recém-criada para ver seus detalhes, incluindo a sub-rede e o gateway atribuídos pelo Docker.

docker network inspect my-bridge-network

A saída deste comando fornecerá informações detalhadas sobre a rede, como seu ID, driver (que deve ser bridge) e a sub-rede e o gateway na seção IPAM.

Agora, vamos executar um contêiner e conectá-lo à nossa nova rede. Usaremos a imagem alpine para este exemplo. Se você não tiver a imagem alpine localmente, o Docker a puxará automaticamente.

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

Este comando executa um contêiner chamado container1 em modo detached (-d), conecta-o a my-bridge-network (--network my-bridge-network) e o mantém em execução executando o comando sleep infinity.

Para verificar se o contêiner está em execução e conectado à rede correta, você pode inspecionar o contêiner.

docker inspect container1

Na saída, procure a seção Networks. Você deve ver my-bridge-network listado, juntamente com o endereço IP atribuído ao contêiner dentro dessa rede.

Finalmente, vamos executar outro contêiner e conectá-lo à mesma rede para demonstrar a comunicação entre eles.

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

Agora, tanto container1 quanto container2 estão conectados a my-bridge-network. Eles devem ser capazes de se comunicar entre si usando seus nomes de contêiner ou endereços IP dentro da rede.

Para testar a comunicação, podemos executar um comando dentro do container1 para fazer ping no container2. Primeiro, precisamos instalar o pacote iputils nos contêineres alpine para usar o comando ping.

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

Agora, faça ping no container2 a partir do container1.

docker exec container1 ping -c 3 container2

Você deve ver respostas de ping bem-sucedidas, indicando que os dois contêineres na mesma rede bridge podem se comunicar.

Criar uma rede bridge com subnet e gateway personalizados

Na etapa anterior, criamos uma rede bridge com as configurações padrão. O Docker atribuiu automaticamente uma sub-rede e um gateway. Nesta etapa, aprenderemos como criar uma rede bridge e especificar nossa própria sub-rede e gateway. Isso oferece mais controle sobre a configuração da rede para seus contêineres.

Primeiro, vamos remover os contêineres e a rede criados na etapa anterior para começar do zero.

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

Agora, vamos criar uma nova rede bridge chamada custom-bridge-network e especificar uma sub-rede e gateway personalizados usando as flags --subnet e --gateway. Usaremos a sub-rede 172.20.0.0/16 e o gateway 172.20.0.1.

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

A flag --driver bridge especifica explicitamente o driver bridge, embora seja o padrão. A flag --subnet define o intervalo de endereços IP para a rede, e a flag --gateway define o endereço IP do gateway para contêineres conectados a esta rede.

Para verificar se a rede foi criada com a sub-rede e o gateway especificados, inspecione a rede.

docker network inspect custom-bridge-network

Na saída, procure na seção IPAM. Você deve ver os campos Subnet e Gateway correspondendo aos valores que você forneceu (172.20.0.0/16 e 172.20.0.1).

Agora, vamos executar um contêiner e conectá-lo à nossa nova rede. Usaremos a imagem alpine novamente.

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

Este comando executa um contêiner chamado custom-container1 e o conecta a custom-bridge-network. O Docker atribuirá um endereço IP a este contêiner da sub-rede especificada (172.20.0.0/16).

Para verificar o endereço IP do contêiner dentro da rede personalizada, inspecione o contêiner.

docker inspect custom-container1

Na saída, na seção Networks para custom-bridge-network, você deve ver um IpAddress que se enquadra no intervalo 172.20.0.0/16.

Vamos executar outro contêiner na mesma rede.

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

Agora, tanto custom-container1 quanto custom-container2 estão na custom-bridge-network e devem ser capazes de se comunicar.

Como na etapa anterior, precisamos de iputils para fazer ping.

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

Teste a comunicação fazendo ping em custom-container2 a partir de custom-container1.

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

Você deve ver respostas de ping bem-sucedidas, confirmando a comunicação dentro da rede bridge personalizada.

Criar uma rede overlay anexável para comunicação multi-host

As redes bridge são adequadas para comunicação entre contêineres no mesmo host Docker. No entanto, para comunicação entre contêineres em execução em diferentes hosts Docker, você precisa de uma rede overlay. As redes overlay são criadas e gerenciadas pelo Docker Swarm.

Nesta etapa, criaremos uma rede overlay anexável. Uma rede overlay anexável permite que contêineres autônomos (não parte de um serviço Swarm) se conectem a ela e se comuniquem em diferentes hosts Docker.

Primeiro, precisamos inicializar o Docker Swarm neste host. Isso é necessário para criar e gerenciar redes overlay.

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

Este comando inicializa o Swarm e define o endereço de anúncio para o endereço IP do host. A saída mostrará que o nó atual agora é um gerenciador Swarm.

Agora que o Swarm está inicializado, podemos criar uma rede overlay anexável. Vamos chamá-la de my-overlay-network. A flag --attachable é crucial para permitir que contêineres autônomos se conectem.

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

A flag --driver overlay especifica que estamos criando uma rede overlay. A flag --attachable torna a rede disponível para contêineres autônomos.

Para verificar se a rede overlay foi criada, liste as redes Docker.

docker network ls

Você deve ver my-overlay-network na lista, e seu driver deve ser overlay.

Agora, vamos executar um contêiner autônomo e conectá-lo à nossa nova rede overlay. Usaremos a imagem alpine.

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

Este comando executa um contêiner chamado overlay-container1 e o conecta a my-overlay-network.

Para verificar se o contêiner está conectado à rede overlay, inspecione o contêiner.

docker inspect overlay-container1

Na saída, procure a seção Networks. Você deve ver my-overlay-network listado.

Como este é um ambiente de host único, não podemos demonstrar totalmente a comunicação multi-host. No entanto, a rede está configurada para permiti-la se você tiver vários nós Swarm.

Vamos executar outro contêiner na mesma rede overlay neste único host.

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

Agora, tanto overlay-container1 quanto overlay-container2 estão na my-overlay-network e devem ser capazes de se comunicar.

Instale iputils nos contêineres para ping.

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

Teste a comunicação fazendo ping em overlay-container2 a partir de overlay-container1.

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

Você deve ver respostas de ping bem-sucedidas, confirmando a comunicação dentro da rede overlay neste único host.

Criar uma rede overlay interna

Na etapa anterior, criamos uma rede overlay anexável que permite que contêineres autônomos se conectem. Nesta etapa, criaremos uma rede overlay interna. Redes internas são isoladas de redes externas, o que significa que contêineres em uma rede interna não podem se comunicar com o mundo exterior (incluindo a rede do host Docker), a menos que explicitamente permitido. Isso é útil para criar redes de serviço isoladas dentro de um Swarm.

Primeiro, vamos limpar os contêineres e a rede da etapa anterior.

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

Agora, vamos criar uma rede overlay interna chamada my-internal-network. Usamos a flag --internal para isso.

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

A flag --internal garante que os contêineres conectados a esta rede não possam se comunicar com redes externas.

Para verificar se a rede overlay interna foi criada, liste as redes Docker.

docker network ls

Você deve ver my-internal-network na lista com o driver overlay.

Agora, vamos executar um contêiner e conectá-lo à nossa nova rede interna. Usaremos a imagem alpine.

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

Este comando executa um contêiner chamado internal-container1 e o conecta a my-internal-network.

Para verificar se o contêiner está conectado à rede interna, inspecione o contêiner.

docker inspect internal-container1

Na saída, procure a seção Networks. Você deve ver my-internal-network listado.

Vamos executar outro contêiner na mesma rede interna.

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

Agora, tanto internal-container1 quanto internal-container2 estão na my-internal-network. Eles devem ser capazes de se comunicar entre si, mas não com o mundo exterior.

Instale iputils nos contêineres para ping.

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

Teste a comunicação fazendo ping em internal-container2 a partir de internal-container1.

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

Você deve ver respostas de ping bem-sucedidas, confirmando a comunicação dentro da rede overlay interna.

Agora, vamos tentar fazer ping em um endereço externo, como google.com, a partir de internal-container1.

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

Este ping deve falhar porque a rede interna é isolada de redes externas.

Resumo

Neste laboratório, aprendemos como usar o comando docker network create para gerenciar redes de contêineres. Começamos criando uma rede bridge básica, que é o tipo de rede padrão para contêineres, e verificamos sua criação e detalhes usando docker network ls e docker network inspect. Em seguida, demonstramos como conectar um contêiner a esta rede recém-criada.

Com base na rede bridge básica, exploramos a criação de uma rede bridge com uma sub-rede e gateway personalizados para ter mais controle sobre o endereçamento IP da rede. Finalmente, nos aprofundamos na criação de redes overlay, especificamente uma rede overlay anexável para comunicação multi-host e uma rede overlay interna para comunicação isolada dentro de um swarm, demonstrando a versatilidade do Docker networking para diferentes cenários de implantação.