Docker Compose - Folha de Dicas com os Comandos Mais Úteis e Exemplos

Aqui está uma
Docker Compose cheatsheet
com exemplos anotados para ajudá-lo a dominar os arquivos e comandos do Compose rapidamente.

Referência do Arquivo Compose: docker-compose.yml

Estrutura principal:

version: '3'       # Versão do formato do arquivo Compose

services:
  web:
    image: nginx:latest
    ports:
      - "8080:80"   # Porta do host 8080: Porta do container 80
  db:
    image: postgres
    environment:            # Variáveis de ambiente
      POSTGRES_PASSWORD: example
    volumes:
      - db_data:/var/lib/postgresql/data

networks:          # Rede personalizada
  appnet:
    driver: bridge

volumes:           # Volume nomeado
  db_data:

• services: Cada container em sua aplicação com vários containers. No exemplo acima, temos dois serviços: web e db.
• networks & volumes: Definem redes isoladas e armazenamento persistente - temos a rede appnet e o volume db_data aqui.

Exemplos

Único serviço com mapeamento de porta

services:
  app:
    build: .
    ports:
      - "8000:80"   # Porta do host 8000: Porta do container 80

Exibe o app na porta 8000 do host e constrói a partir do Dockerfile no diretório atual.

Múltiplos serviços com volume compartilhado e rede personalizada

version: '3'
services:
  web:
    build: .
    ports:
      - "5000:5000"
    volumes:
      - type: bind
        source: ./app
        target: /app
    networks:
      - mynet
  db:
    image: postgres
    volumes:
      - db_data:/var/lib/postgresql/data
    networks:
      - mynet

networks:
  mynet:

volumes:
  db_data:

Web e DB na mesma rede; DB usa volume nomeado persistente - db_data.

Usando contexto de construção e caminho do Dockerfile

Você pode construir imagem docker sob demanda a partir do especificado no docker-compose.yml Dockerfile.

services:
  app:
    build:
      context: .
      dockerfile: docker/MyDockerfile

Compartilhando dados entre serviços

services:
  web:
    image: nginx
    volumes:
      - shared_data:/usr/share/nginx/html
  worker:
    image: myworker
    volumes:
      - shared_data:/usr/src/app/data

volumes:
  shared_data:

Ambos os serviços acessam o mesmo volume (para arquivos estáticos ou troca de dados) - shared_data.

Opções Avançadas do Arquivo Compose

• environment: Defina variáveis de ambiente para os containers.
• depends_on: Controle a ordem de inicialização dos serviços.
• deploy.replicas: Escalamento de serviço no modo Swarm.

Exemplo:

services:
  web:
    image: nginx
    deploy:
      replicas: 3
    depends_on:
      - db

Inicia 3 instâncias do web; controla apenas a ordem de inicialização (não a prontidão).

Comandos Essenciais do Docker Compose

Padrões Comuns do Compose

• Bancos de dados com dados persistentes

  services:
    mysql:
      image: mysql
      environment:
        MYSQL_ROOT_PASSWORD: password
      volumes:
        - mysql_data:/var/lib/mysql
  
  volumes:
    mysql_data:
  

  Os dados do DB persistem no volume mysql_data durante reinícios do container.

• Montagem de código para desenvolvimento

  services:
    app:
      build: .
      volumes:
        - .:/app
  

  Edite o código no host em tempo real, refletido automaticamente no container.

Flags Úteis

• -d: Modo detach (executar em segundo plano).
• --build: Forçar reconstrução de imagens antes de iniciar.
• --force-recreate: Recriar containers mesmo que não tenham mudado.
• --remove-orphans: Remover containers não definidos no arquivo Compose.

Definindo e Personalizando Serviços

Você pode definir e personalizar serviços, redes e volumes no Docker Compose aproveitando o arquivo docker-compose.yml, que centraliza todas as necessidades de configuração e orquestração da sua aplicação.

• Serviços são definidos sob a chave services.
• Cada serviço representa uma configuração de container, onde você pode definir:
  • Image: Selecione uma imagem do Docker Hub ou outro repositório.
  • Ports: Mapeie portas do container para portas do host.
  • Variáveis de ambiente: Passe valores de configuração.
  • Volumes: Persistir dados ou compartilhar arquivos/pastas com o host ou outros serviços.
  • Redes: Controlar quais redes o serviço pode acessar.

Exemplo:

services:
  web:
    image: nginx:latest
    ports:
      - "8080:80"   # Porta do host 8080: Porta do container 80
    environment:
      - NGINX_HOST=localhost
    volumes:
      - web_data:/usr/share/nginx/html
    networks:
      - frontend

  db:
    image: postgres:13
    environment:
      POSTGRES_USER: admin
      POSTGRES_PASSWORD: secret
    volumes:
      - db_data:/var/lib/postgresql/data
    networks:
      - backend

• Aqui, o serviço web usa a imagem nginx, define uma variável de ambiente, anexa um volume, abre a porta 80 como 8080 no host e conecta-se à rede frontend. O serviço db faz algo semelhante para PostgreSQL.

Personalizando Redes

• Redes controlam quais serviços podem se comunicar. O Compose cria uma rede padrão, mas você pode definir mais, especificar drivers personalizados, definir opções e determinar quais serviços se conectam a quais redes para isolação detalhada.
• Defina redes no nível superior sob networks, e liste quais redes um serviço deve se conectar com a chave networks no nível do serviço.

Exemplo:

networks:
  frontend:
    driver: bridge
  backend:
    driver: bridge
    driver_opts:
      com.docker.network.bridge.host_binding_ipv4: "127.0.0.1"

• Conecte redes aos serviços:

services:
  app:
    networks:
      - frontend
      - backend
  db:
    networks:
      - backend

• Esta configuração permite que o serviço app acesse usuários nas redes frontend e backend, enquanto db é acessível apenas dentro da backend.

Personalizando Volumes

• Volumes são definidos sob a chave volumes no nível superior. Monte-os em containers usando a chave volumes sob um serviço.
• Volumes podem ser nomeados, usar drivers personalizados e ser compartilhados entre múltiplos serviços para persistência de dados e compartilhamento.

Exemplo:

volumes:
  web_data:                # Volume nomeado para conteúdo web
  db_data:                 # Volume nomeado para banco de dados

services:
  web:
    volumes:
      - web_data:/usr/share/nginx/html

  db:
    volumes:
      - db_data:/var/lib/postgresql/data

• Neste exemplo, web_data é persistido e disponível para qualquer container que o monte. db_data garante que os dados do banco nunca sejam perdidos ao reconstruir o container.
• Você pode definir montagens de bind com opções de driver personalizadas para casos avançados:

volumes:
  db_data:
    driver: local
    driver_opts:
      type: none
      device: /data/db_data
      o: bind

• Esta configuração define uma montagem de bind do caminho do host /data/db_data para dentro do container.

Resumo das melhores práticas:

• Use o nome do serviço como um hostname DNS para comunicação entre serviços.
• Conecte serviços a múltiplas redes conforme necessário para controlar o acesso.
• Use volumes nomeados para armazenamento persistente e compartilhamento de dados.
• Defina tudo usando YAML, permitindo controle de versão e scripts de implantação fáceis.

Múltiplos arquivos compose

Para organizar configurações complexas de múltiplos serviços no Docker Compose, você pode usar vários arquivos compose e arquivos de substituição, permitindo configurações modulares, específicas de ambiente e escaláveis. Aqui está como isso funciona:

1. Estrutura de Arquivo Base e Substituição

• Crie um arquivo base (compose.yaml ou docker-compose.yml) contendo todas as definições de serviço comuns e padrão.
• Adicione arquivos de substituição específicos do ambiente (por exemplo, docker-compose.override.yml, docker-compose.dev.yml, docker-compose.prod.yml).

Exemplo da estrutura de arquivos:

/diretório-do-projeto
|-- docker-compose.yml           # Configuração base
|-- docker-compose.override.yml  # Sobrescritas locais/dev (carregadas automaticamente)
|-- docker-compose.prod.yml      # Sobrescritas de produção
|-- docker-compose.test.yml      # Sobrescritas de teste (se necessário)

O arquivo de configuração base define serviços principais, enquanto cada substituição personaliza configurações para um ambiente ou caso específico.

2. Como as Sobrescritas de Arquivo Funcionam

• Mesclagem: Quando você executa docker compose up, o Docker Compose mescla o base com quaisquer substituições na ordem especificada; arquivos posteriores sobrescrevem, estendem ou adicionam configurações de arquivos anteriores.
• Sobrescrita de Campos: Se um serviço ou campo é definido em múltiplos arquivos, o valor do último arquivo especificado é usado. Novos campos são adicionados.

Exemplo de mesclagem:

• docker-compose.yml:

  services:
    web:
      image: myapp
      ports:
        - "8000:80"
  

• docker-compose.override.yml:

  services:
    web:
      environment:
        - DEBUG=true
  

• Resultado: O serviço web usa a imagem e a porta do base, mais a variável de ambiente DEBUG sobrescrita.

3. Uso de Comando para Múltiplos Arquivos

• Comportamento padrão: Se presente, o Docker Compose carrega automaticamente docker-compose.override.yml junto com docker-compose.yml ao executar qualquer comando.
• Especificar arquivos manualmente: Use flags -f para controlar quais arquivos são mesclados e em que ordem:

  docker compose -f docker-compose.yml -f docker-compose.prod.yml up -d
  

  • Isso ignora a substituição padrão e usa as configurações específicas de produção.

4. Estratégias de Organização Práticas

• Separação por ambiente: Use uma substituição por ambiente: dev, test, prod, etc.
• Microserviços e equipes: Divida a configuração em arquivos separados para diferentes serviços ou equipes, combinando conforme necessário.
• Toggle de recursos: Arquivos adicionais podem introduzir ou remover serviços ou configurações opcionais para necessidades temporárias (por exemplo, um compose.debug.yml para logs extras).

5. Benefícios

• Clareza: Mantém arquivos individuais pequenos e focados.
• Escalabilidade: Adicione facilmente novos serviços, ambientes ou configurações.
• Manutenibilidade: Altere ou revise apenas as seções relevantes para uma implantação específica.

6. Exemplo: Trocando Ambientes

Desenvolvimento:

docker compose -f docker-compose.yml -f docker-compose.dev.yml up

Produção:

docker compose -f docker-compose.yml -f docker-compose.prod.yml up -d

Cada ambiente obtém apenas a configuração necessária para ele, com todas as configurações compartilhadas no arquivo base.

Organizar configurações complexas de Compose com múltiplos arquivos - e aproveitar o sistema de substituição/mesclagem - garante modularidade, personalização específica do ambiente e escalabilidade fácil para grandes aplicações Docker com múltiplos serviços.

Links Úteis

• https://docs.docker.com/compose/
• Docker Cheatsheet
• Kubernetes Cheatsheet
• Dockerising Flutter Web app com build dockerizado do Flutter e Nginx
• Instalar Portainer no Linux