Este guia aborda a configuração de rede no Docker, focando em diferentes modos de rede e como expor contêineres para acesso externo. Além disso, detalha o processo de empacotamento de projetos Spring Cloud e sua implantação em contêineres Docker.

Modos de Rede Docker

O Docker oferece quatro modos de rede principais ao criar contêineres:

• Bridge (Ponte): Este é o modo padrão. Cada contêiner obtém um namespace de rede isolado, mas todos os contêineres na mesma máquina host compartilham o mesmo segmento de rede e podem se comunicar entre si. Para especificar este modo, não é necessário usar o parâmetro --net; se for usado, será ignorado. A atribuição de IPs específicos aos contêineres neste modo é limitada.
• Host: Ao usar --net=host, o contêiner não virtualiza seu próprio IP ou portas. Em vez disso, ele compartilha diretamente o IP e as portas da máquina host. Parâmetros como -p (mapeamento de porta) e regras de roteamento personalizadas não são aplicáveis, pois são herdados do host. A ativação do encaminhamento de IP na máquina host (echo 1 > /proc/sys/net/ipv4/ip_forward) é crucial para a conectividade de rede do contêiner.
• Container: (Não detalhado neste guia)
• None: (Não detalhado neste guia)

Comunicação Entre Hosts

Para cenários em que contêineres precisam se comunicar através de diferentes máquinas host, várias estratégias podem ser empregadas, incluindo:

• Configuração de rotas de rede.
• Utilização de Open vSwitch (OVS).
• Implementação de redes com Flannel.
• Uso de Quagga para aprendizado automático de rotas.

Acesso Externo a Contêineres Docker

Modo Bridge

Para tornar um contêiner acessível externamente no modo bridge, utilize o parâmetro -p para mapear portas do host para as portas do contêiner. Este parâmetro pode ser especificado múltiplas vezes para mapear várias portas.

docker run -itd -p 7101:7101 seu_imagem_id
docker run -itd -p 8080:8080 -p 8088:8088 seu_imagem_id

Exemplo com um contêiner Tomcat:

docker run -it --name meu-tomcat-02 -p 8081:8080 sua_imagem_tomcat

Acesse via:

http://<IP_DA_MAQUINA_HOST>:8081/

Modo Host

No modo host, o contêiner utiliza diretamente o IP e as portas da máquina host, dispensando o mapeamento de portas explícito. A adição do parâmetro -p resultará em um aviso indicando que as portas publicadas são descartadas.

docker run -itd --net=host seu_imagem_id

Acesse diretamente pelo IP da máquina host:

http://<IP_DA_MAQUINA_HOST>:<PORTA_DO_CONTÊINER>/

Certifique-se de que o encaminhamento de IP esteja habilitado no host.

Ferramentas Úteis

Para gerenciar e inspecionar redes bridge, a ferramenta bridge-utils pode ser instalaad e utilizada:

sudo apt install bridge-utils
brctl show

Implantação de Projetos Spring Cloud em Docker

Este segmento descreve como preparar e implantar um projeto Spring Cloud em contêineres Docker.

Empacotamento de Projetos Spring Cloud

Para empacotar o projeto Spring Cloud como um executável JAR:

Modificações no POM Principal (Módulo Raiz)

Altere o elemento packaging de jar para pom e remova a seção <build></build>.

<version>0.0.1-SNAPSHOT</version>
<packaging>pom</packaging>
<!-- <build></build> -->

Adição de Plugin nos POMs dos Submódulos

Em cada POM de submódulo, adicione o plugin spring-boot-maven-plugin, especificando o mainClass e habilitando o repackage.

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <configuration>
                <mainClass>com.seu.pacote.SuaClasseDeAplicacao</mainClass>
            </configuration>
            <executions>
                <execution>
                    <goals>
                        <goal>repackage</goal>
                    </goals>
                </execution>
            </executions>
        </plugin>
    </plugins>
</build>

Após as modificações, execute as tarefas clean e install no Maven (via Idea) para gerar os JARs nos diretórios target de cada submódulo.

Execução Manual dos JARs (Teste Local)

Copie os JARs gerados para um diretório específico e execute-os usando o comando java -jar, especificando o perfil Spring ativo.

java -jar nome-do-seu-jar.jar --spring.profiles.active=seu_perfil

Imlpantação em Contêineres Docker

1. Crie um diretório (ex: apps) para armazenar os arquivos JAR.
2. Copie os JARs empacotados para este diretório.
3. Execute um contêiner com uma imagem JRE (ex: jre:8) no modo host, montando o diretório apps como um volume e nomeando o contêiner.

   docker run -d \
          -it \
          --net=host \
          --name nome-do-seu-container \
          --mount type=bind,source=/caminho/no/host/apps,target=/caminho/no/container/apps \
          sua_imagem_jre
   

5. Modifique o arquivo /etc/hosts na máquina host para incluir mapeamentos de domínio para 127.0.0.1, se necessário para a comunicação interna dos serviços.

   sudo vim /etc/hosts
   # Adicionar linhas como:
   127.0.0.1  meu-servico.dominio.com
   

7. Acesse o contêiner e execute o comando Java para iniciar o microserviço, passando os perfis Spring necessários.

   docker exec -it nome-do-seu-container /bin/sh
   java -jar /caminho/no/container/apps/nome-do-seu-jar.jar --spring.profiles.active=seu_perfil
   

Acesso e Verificação

Acesse os serviços através do IP da máquina host e das portas expostas (ou diretamente no modo host). Se o acesso falhar, verifique se o firewall da máquina host está desativado.

systemctl status firewalld
# Se ativo, desativar:
sudo systemctl stop firewalld.service
sudo systemctl disable firewalld.service

Acesse os serviços via navegador:

http://<IP_DA_MAQUINA_HOST>:<PORTA_DO_SERVICO>/