anúncios

Mostrando postagens com marcador Docker Compose. Mostrar todas as postagens
Mostrando postagens com marcador Docker Compose. Mostrar todas as postagens

sexta-feira, 9 de janeiro de 2026

Guia prático de redes Docker

Entenda o essencial e pare de sofrer

Por que redes Docker importam?

Contêineres são processos isolados. Para que conversem entre si e com o mundo externo, precisam de rede.

Quando você ignora esse ponto, surgem sintomas típicos:

  • "O container sobe, mas o app não conecta ao banco."
  • "Funciona no meu computador, mas não no servidor."
  • "Consigo acessar localhost, mas o container não."

Quase sempre, a raiz do problema é como a rede foi criada ou usada.

  1. O mapa mental das redes Docker (o que realmente existe)
  2. Quando você instala Docker, ele cria automaticamente três redes:

    Rede Descrição Quando usar Observações importantes
    bridge Rede padrão criada pelo Docker para comunicação entre contêineres no mesmo host. Desenvolvimento local e aplicações simples com múltiplos contêineres. Possui DNS interno; contêineres se comunicam pelo nome. É a base da maioria dos projetos com Docker Compose.
    host Remove o isolamento de rede; o contêiner utiliza diretamente a rede do host. Casos específicos de performance ou necessidade de acesso direto à rede do host. Elimina o mapeamento de portas. Reduz isolamento e aumenta riscos se usado sem critério.
    none Contêiner sem qualquer interface de rede configurada. Jobs isolados, processamento offline ou tarefas batch. Não permite comunicação externa ou interna. Uso pouco comum em aplicações web.

    Na maioria dos projetos, você vai trabalhar quase sempre com "bridge", normalmente criada com docker network create.

  3. Conceito-chave: DNS interno do Docker
  4. Este é o ponto mais ignorado, e o que mais causa problemas.

    Dentro de uma rede Docker:

    • Você não usa localhost para falar com outro contêiner.
    • Você usa o nome do serviço (ou nome do contêiner).

    Exemplo no docker-compose.yml:

    
    services:
      api:
        image: minhaapi
        depends_on:
          - db
      db:
        image: postgres:16
    
    

    A aplicação "api" deve conectar no banco usando:

    DB_HOST=db

    e não:

    DB_HOST=localhost

    Regra mental simples: no Docker, serviços conversam pelo nome.

  5. Portas: interna x externa (a confusão clássica)
  6. Quando você publica uma porta, faz um mapeamento:

    -p 8080:8080

    Leia assim:

    porta_do_host : porta_do_container

    -O contêiner continua ouvindo dentro dele (porta interna).

    -O host expõe a porta para fora.

    Se você esquecer o -p, o serviço funciona entre containers, mas não de fora para dentro, e parece "quebrado".

  7. Criando redes do jeito certo
  8. Crie explicitamente uma rede para seu projeto:

    docker network create minha-rede

    Quando subir containers:

    docker run -d --name api --network minha-rede minhaapi

    docker run -d --name db --network minha-rede postgres:16

    Agora ambos:

    Estão isolados de outros projetos.

    Podem se resolver por nome.

    Não "vazam" comunicação desnecessária.

  9. Compose: onde tudo fica mais limpo
  10. No docker-compose.yml, usar rede é natural:

    
    services:
      api:
        image: minhaapi
        ports:
          - "8080:8080"
        depends_on:
          - db
        networks:
          - appnet
    
      db:
        image: postgres:16
        networks:
          - appnet
    
    networks:
      appnet:
        driver: bridge
    
    

    Você ganha:

    • Organização
    • Reprodutibilidade
    • Zero dor com comandos longos
  11. Comunicação: quem enxerga quem?
  12. Contêineres na mesma rede -> conversam entre si.

    Contêineres em redes diferentes -> não conversam (a menos que você conecte).

    Host acessa container exposto via localhost:porta_publicada.

    Quer conectar um container a outra rede?

    docker network connect outra-rede api

  13. Banco de dados e "localhost": por que sempre falha
  14. Cenário comum:

    App Java no container

    Banco PostgreSQL no container

    Conexão configurada para localhost

    Resultado: erro.

    Explicação curta: "localhost" dentro do container aponta para ele mesmo, não para outro container.

    Use:

    jdbc:postgresql://db:5432/meubanco

    Simples assim.

  15. Debug rápido (checklist)
  16. Quando algo "não comunica", verifique:

    O container está na mesma rede?

    Estou usando nome do serviço, não localhost?

    A porta está publicada (-p) quando preciso acessar do host?

    O container de destino realmente está ouvindo na porta esperada?

    Compose não está criando uma rede automática diferente?

    Ferramentas úteis:

    docker network ls

    docker network inspect <nome>

    docker container inspect <nome>

  17. Boas práticas arquiteturais
  18. Uma rede por sistema (ou domínio lógico).

    Não expose banco de dados para fora sem necessidade.

    Use nomes estáveis de serviços.

    Documente portas e dependências.

    Prefira docker compose ao invés de comandos manuais.

  19. Mentalidade correta para redes Docker
  20. Ao desenhar um ambiente, pergunte:

    • Quem precisa falar com quem?
    • Essa comunicação é interna ou externa?
    • Existe risco se alguém fora enxergar este serviço?
    • Preciso compartilhar a rede com outros projetos?

    Responder isso antes evita retrabalho depois.

Considerações finais

Docker Networks não são complicadas, apenas exigem um modelo mental correto:

  • containers conversam por nomes
  • redes definem fronteiras
  • portas definem exposição
  • compose organiza tudo

Dominar estes fundamentos elimina a maior parte dos problemas de conectividade e devolve tempo para o que realmente importa: entregar software.

Feito!

terça-feira, 22 de abril de 2025

Guia completo de deploy com Docker e Docker Compose

Como containerizar aplicações e orquestrar múltiplos serviços de forma simples e escalável

O que é Docker?

Docker é uma plataforma que permite empacotar sua aplicação e todas as suas dependências em containers. Com ele, conseguimos criar ambientes portáveis, previsíveis e fáceis de replicar em qualquer lugar, seja na máquina do dev, no servidor ou na nuvem.

Pensa no container como uma mini máquina virtual superleve e isolada, rodando apenas o necessário para sua aplicação funcionar.

Por que usar Docker?

Elimina o "na minha máquina funciona"

Padroniza ambientes de desenvolvimento, staging e produção

Facilita o CI/CD

Escala horizontalmente de forma controlada

Dockerizando sua aplicação

Vamos usar um exemplo básico de uma API Node.js + Express.

Pode usar a sua API que você desenvolveu em Node.js com Express

  1. Estrutura de diretórios
  2. /meu-projeto
    │
    ├── Dockerfile
    ├── docker-compose.yml
    ├── package.json
    └── src/
        └── index.js
    
  3. Dockerfile
  4. 
    # Usa uma imagem base
    FROM node:18-alpine
    
    # Cria um diretório de trabalho
    WORKDIR /app
    
    # Copia os arquivos
    COPY package*.json ./
    RUN npm install
    
    COPY . .
    
    # Expõe a porta da aplicação
    EXPOSE 3000
    
    # Comando para iniciar o app
    CMD ["node", "src/index.js"]
    
    
  5. Docker Compose com MongoDB
  6. 
    version: '3.8'
    services:
      app:
        build: .
        ports:
          - "3000:3000"
        volumes:
          - .:/app
        depends_on:
          - mongo
        environment:
          - MONGO_URL=mongodb://mongo:27017/meubanco
    
      mongo:
        image: mongo:6
        container_name: mongodb
        ports:
          - "27017:27017"
        volumes:
          - mongo-data:/data/db
      
      mongo-express:
        image: mongo-express
        container_name: mongo-express
        ports:
          - "8081:8081"
        environment:
          ME_CONFIG_MONGODB_SERVER: mongo
          ME_CONFIG_BASICAUTH_USERNAME: admin
          ME_CONFIG_BASICAUTH_PASSWORD: admin
    
    volumes:
      mongo-data:
    
    
  7. Subindo os serviços
  8. No terminal, dentro do diretório do projeto:

    docker-compose up -d --build

Pronto! Sua API e o Mongo estão executando em containers separados, mas se comunicando em rede.

Testando

Acesse: http://localhost:3000 no Postman ou Insonmia para testar os endpoints da sua API REST com Node.js e Express

e http://localhost:8081 para acessar o Mongo Express, que é o cliente do MongoDB

Dicas de produção

  • Crie um .dockerignore para ignorar node_modules, .git, etc.
  • Use variáveis de ambiente no docker-compose.yml com arquivos .env
  • Utilize healthchecks para garantir que os serviços estejam realmente prontos
  • Adicione nginx como proxy reverso e certbot para HTTPS
  • Faça uso de volumes persistentes para bancos de dados
  • Considere usar Docker Swarm ou Kubernetes em ambientes que exigem alta escalabilidade
.dockerignore
node_modules
npm-debug.log
.git
.env
Dockerfile*
docker-compose*
Dockerfile (Produção)

# Etapa de build
FROM node:18-alpine as builder

WORKDIR /app
COPY package*.json ./
RUN npm install --production

COPY . .

# Etapa final
FROM node:18-alpine

WORKDIR /app

# Copia apenas o que foi instalado/built na etapa anterior
COPY --from=builder /app /app

# Define variáveis de ambiente
ENV NODE_ENV=production

EXPOSE 3000
CMD ["node", "src/index.js"]

docker-compose.prod.yml

version: '3.8'

services:
  app:
    build:
      context: .
      dockerfile: Dockerfile
    ports:
      - "80:3000"
    env_file:
      - .env
    depends_on:
      - mongo
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3000"]
      interval: 30s
      timeout: 10s
      retries: 3
    restart: always
    volumes:
      - .:/app
      - /app/node_modules # evita conflito com o host

  mongo:
    image: mongo:6
    container_name: mongodb
    restart: always
    ports:
      - "27017:27017"
    volumes:
      - mongo-data:/data/db
    healthcheck:
      test: ["CMD", "mongosh", "--eval", 
             "db.adminCommand('ping')"]
      interval: 30s
      timeout: 10s
      retries: 5

volumes:
  mongo-data:

.env
MONGO_URL=mongodb://mongo:27017/meubanco
PORT=3000
NODE_ENV=production

Considerações finais

Docker e Docker Compose transformaram a forma como lidamos com deploys. Com uma configuração simples, conseguimos orquestrar múltiplos serviços, versionar ambientes, simular produção localmente e escalar nossas aplicações com segurança.

Quer começar? Pegue um projeto seu e faça o primeiro Dockerfile. Depois adicione um banco com docker-compose. Em pouco tempo, isso torna-se parte do seu workflow natural.

Feito!

domingo, 6 de outubro de 2019

Configurando ambiente de desenvolvimento PHP no Docker

O objetivo deste howto é apresentar a configuração do ambiente de desenvolvimento PHP no Docker

Com o Docker e Docker compose instalados, adicione o docker-compose.yml na raiz do diretório onde desejar ter o ambiente PHP que ficará os projetos.

A imagem saitam10/apache2-php7.3 inclui o Apache2, PHP 7.3, os módulos usuais, extensões aos SGBD MySQL, PostgreSQL e OCI8 (Oracle) e gerenciador composer

A estrutura do ambiente PHP é essa
ambiente-docker
 apache2-php7.3
      mysql
       data
      php
        Dockerfile
        vhost.conf
      www
      docker-compose.yml

O volume no HOST é www que é mapeado no container PHP /var/www/html

docker-compose.yml



No diretório php, inclui os arquivos Dockerfile e vhost.conf
Dockerfile



vhost.conf



Build do ambiente
Executar docker-compose up -d no diretório raiz do ambiente PHP

Após o build com sucesso, acessar o container PHP docker exec -it apache2-php7.3 bash e instalar o framework PHP de sua preferência, nesse howto é utilizado o Framework Laravel

composer create-project --prefer-dist laravel/laravel projeto

Por fim, adicione no arquivo hosts, no Linux é /etc/hosts, no Windows é c:\windows\system32\drivers\etc\hosts
127.0.0.1 projeto.local
No browser http://projeto.local

Feito!

sexta-feira, 4 de outubro de 2019

Instalando o Docker no Windows

Na postagem anterior foi apresentado a instalação do Docker e Docker Compose no Linux, mas caso use Windows 10 e seu hardware atenda os requisitos necessários, pode instalar e usar o Docker no Windows 10 também.

Os pré-requisitos são:
  • Windows 10 64 bits. Pro/Enterprise/Education
  • Pelo menos 4GB de RAM
  • Suporte de virtualização habilitado na BIOS
Atendendo os pré-requisitos listados, então habilite o Hyper-V e faça o download Docker for Windows e proceda com Next>Next>Finish.

O instalador inclui o Docker e Docker Compose, os comandos são reconhecidos no PowerShell.

Feito!

quinta-feira, 3 de outubro de 2019

Instalando Docker e Docker Compose no Linux

O objetivo deste howto é de apresentar os procedimentos de instalação do Docker e Docker Compose no Linux (Debian, Ubuntu).

Qualquer distro Linux
Recomendado se quer obter a versão mais recente do Docker. Após a instalação do Docker por esse procedimento, vá para a etapa de instalação do Docker Compose.

$ curl -fsSL https://get.docker.com -o get-docker.sh
$ sudo sh get-docker.sh


Caso prefira instalar o Docker pelo repositório da distro mesmo sendo a versão inferior da atual, então segue os procedimentos seguintes:

$ sudo apt update

Instalação de pacotes para permitir que o APT use HTTPS

$ sudo apt install \
apt-transport-https \
ca-certificates \
curl \
gnupg2 \
software-properties-common


Adiciona a chave GPG
$ curl -fsSL https://download.docker.com/linux/debian/gpg | sudo apt-key add -
$ sudo apt-key fingerprint 0EBFCD88
Debian
$ sudo add-apt-repository \
"deb [arch=amd64] https://download.docker.com/linux/debian \
$(lsb_release -cs) \
stable"

Ubuntu
$ sudo add-apt-repository \
"deb [arch=amd64] https://download.docker.com/linux/ubuntu \
$(lsb_release -cs) \
stable"


Atualize o repositório
$ sudo apt update

Instalação do Docker via APT
$ sudo apt install docker-ce

Testes
Verificar se o serviço Docker esta ativo via SystemD
$ sudo systemctl status docker
Se retornar algo semelhante como abaixo, então está OK.
docker.service - Docker Application Container Engine
   Loaded: loaded (/lib/systemd/system/docker.service; enabled; vendor preset: e
   Active: active (running) 
Container Hello World para testar
$ sudo docker run hello-world

Adicionar o usuário logado no grupo docker
Para que possa ser executados comandos Docker com usuário regular, é necessário adicionar no grupo docker.
sudo usermod -aG docker $(whoami)

Instalação do Docker Compose
sudo curl -L "https://github.com/docker/compose/releases/download/1.24.1/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

sudo chmod +x /usr/local/bin/docker-compose

Feito!