Guia do Docker Compose: Simplifique o desenvolvimento de vários contêineres

O Docker Compose simplifica o gerenciamento de aplicativos Docker com vários contêineres, permitindo que os desenvolvedores escrevam e executem aplicativos complexos sem esforço.

Os engenheiros de DevOps intermediários, os desenvolvedores de back-end e os desenvolvedores nativos da nuvem, especialmente aqueles que trabalham com microsserviços ou arquiteturas multisserviços, muitas vezes enfrentam o desafio de gerenciar vários contêineres interconectados. O Docker Compose aborda essas complexidades, simplificando os fluxos de trabalho de desenvolvimento e teste. 

Neste artigo, você aprenderá tudo o que precisa para usar o Docker Compose. Confira nosso Guia do Docker para iniciantes se você estiver começando a usar o Docker. 

O que é o Docker Compose?

O Docker Compose é uma ferramenta projetada para definir e orquestrar aplicativos do Docker com vários contêineres por meio de um único arquivo de configuração YAML. 

Com o Compose, você pode especificar facilmente serviços, redes, volumes, configurações de ambiente e dependências. Ele é ideal para desenvolvimento local, configurações de teste, prototipagem rápida e ambientes de produção menores.

Os casos de uso comuns do Docker Compose incluem a criação de ambientes locais que refletem sistemas do mundo real, como arquiteturas de microsserviços. Ao definir claramente as interações entre os componentes, o Compose proporciona consistência, facilidade de uso e ciclos de iteração mais rápidos.

Você pode estar se perguntando por que não usar apenas o Kubernetes. Primeiro, é um exagero para pequenos projetos e testes locais. Como você descobrirá em nosso Kubernetes vs. Kubernetes. Docker tutorial, o Kubernetes é mais adequado para gerenciar vários contêineres em clusters. Em nosso curso Containerization and Virtualization with Docker and Kubernetes, você se aprofunda em como criar e implementar aplicativos com o Docker e o Kubernetes. 

Por que usar o Docker Compose em vez de usar o Docker Compose? Comandos manuais do Docker?

O gerenciamento individual de vários contêineres pode se tornar caótico rapidamente devido a:

• Ordens de dependência complexas, 
• Ambientes inconsistentes e 
• Problemas de escalabilidade. 

Com comandos manuais, você corre o risco de erros humanos, desvios de configuração e fluxos de trabalho ineficientes. 

O Docker Compose ajuda a resolver esses problemas, definindo todos os serviços e dependências de aplicativos em um arquivo YAML. Isso traz consistência, escalabilidade e facilidade de gerenciamento de dependências, reduzindo significativamente os erros e aumentando a produtividade.

O Compose é mais rápido do que criar os contêineres manualmente e conectá-los. Além disso, o compose cria uma rede padrão para a comunicação entre todos os contêineres. Além disso, ele gerencia os volumes, garantindo sua reconexão automática após a substituição ou reinicialização do serviço. 

Você pode aprender a conteinerizar aplicativos de machine learning com o Docker e o Kubernetes em nosso tutorial Como conteinerizar um aplicativo usando o Docker . 

Qual é a diferença entre o Docker e o Docker Compose?

Enquanto o Docker é a plataforma para criar, executar e gerenciar contêineres, o Docker Compose é a ferramenta que facilita a definição e o gerenciamento de vários contêineres usando um arquivo YAML, principalmente docker-compose.yml. 

O Docker lida com contêineres individuais, mas o Docker Compose permite que você os empilhe em um único serviço. Por exemplo, um aplicativo com backend, frontend, banco de dados, cache e assim por diante. 

Você pode criar e executar seus contêineres sem o Docker Compose. No entanto, o encapsulamento de tudo em um único arquivo docker-compose.yml facilita o gerenciamento de vários contêineres. Ele também possibilita que você ative seu aplicativo em qualquer ambiente com um único comando. 

Entender o Docker e o Docker Compose é fundamental para que você seja bem-sucedido em suas próximas entrevistas. Certifique-se de que você está preparado explorando as 26 principais perguntas e respostas da entrevista sobre o Docker para 2025. 

Fundamentos do Docker Compose

Antes de se aprofundar nos detalhes práticos, é essencial que você entenda os princípios básicos e a sintaxe do Docker Compose. Antes de usar o compose, verifique se você tem o Docker instalado seguindo as instruções em . Instale o Docker no Ubuntu: Da configuração ao primeiro contêiner guide. 

Estrutura conceitual

O Docker Compose abstrai a complexidade da orquestração de contêineres para desenvolvimento local e implementações mais simples. Com um arquivo de composição formatado em YAML, você declara quais serviços eles precisam, define suas dependências, especifica redes, volumes, variáveis de ambiente e muito mais. O Compose gerencia com eficiência a inicialização, a interrupção, o dimensionamento e a interconexão desses serviços.

Sintaxe do Core Compose

O Docker Compose gira em torno de uma sintaxe YAML simples. Os componentes principais incluem:

• services para definir aplicativos em contêineres
• images ou build contextos para especificar contêineres
• ports para expor serviços
• volumes para armazenamento persistente de dados
• networks para comunicação entre serviços

Definição de serviços e arquitetura de aplicativos

Os arquivos de composição representam os serviços e as conexões do aplicativo.

Definição de serviços

Os serviços são o núcleo de um arquivo Compose. Você pode definir e nomear claramente vários serviços (como front-ends da Web, bancos de dados e serviços de cache), especificando dependências por meio de palavras-chave simples, como depends_on, para controlar a ordem de inicialização do contêiner.

Noções básicas de rede

O Docker Compose cria automaticamente redes padrão para facilitar a comunicação entre os serviços definidos. Os desenvolvedores também podem especificar redes personalizadas, se necessário, para isolamento aprimorado ou requisitos de rede detalhados.

Gerenciamento de volume

Os volumes permitem a persistência de dados além dos ciclos de vida dos contêineres. Você pode especificar volumes nomeados ou montar diretórios de host para contêineres, garantindo que bancos de dados, logs ou outros dados com estado persistam de forma consistente.

Variáveis de ambiente

O Compose simplifica a passagem de variáveis de ambiente e segredos com segurança para os contêineres. Ele oferece suporte a declarações diretas em serviços e variáveis de referência armazenadas em arquivos env juntamente com arquivos de composição para manter os valores confidenciais protegidos e separados das definições do Docker.

Dimensionamento e orquestração do Docker Compose

O Docker Compose também simplifica o dimensionamento e a orquestração básicos, o que é especialmente útil para cenários rápidos de teste de carga ou avaliação de serviços paralelos.

Dimensionamento de serviços

O sinalizador "--scale" do Compose permite que você crie várias cópias de serviços rapidamente. Isso torna simples os cenários de teste, como a avaliação do balanceamento de carga ou o tratamento de solicitações simultâneas.

Por exemplo, o dimensionamento de um contêiner de aplicativo Flask pode ser feito com apenas um comando:

docker-compose up --scale flaskapp=4

Docker Compose vs. Docker Swarm e Kubernetes

Embora o Docker Compose seja excelente no desenvolvimento local e em configurações de menor escala, ele é limitado na orquestração de vários hosts e em escala de produção. Para cenários complexos e de nível de produção em vários hosts, orquestradores mais robustos, como o Docker Swarm ou o Kubernetes, são adequados, pois oferecem balanceamento de carga avançado, autocorreção, rede avançada e escalabilidade em grande escala não disponíveis no Compose.

Nosso Docker Compose vs. Docker Compose. A postagem do blog do Kubernetes detalha melhor as principais diferenças entre o Docker Compose e o Kubernetes.  

Técnicas de otimização para uso eficiente do Compose

A utilização eficiente do Docker Compose inclui a otimização de compilações, a adição de verificações de integridade e o gerenciamento de recursos de serviço. Nesta seção, você aprenderá mais sobre essas técnicas de otimização.

Estratégias de construção eficientes

O uso de compilações de vários estágios em Dockerfiles ajuda a reduzir o tamanho das imagens do Docker, enquanto o aproveitamento explícito do cache de compilação acelera significativamente os processos de desenvolvimento e CI.

Verificações de saúde e políticas de reinício

O Compose permite que você defina verificações explícitas da integridade do contêiner para manter a confiabilidade do aplicativo. As políticas de reinicialização ajudam a garantir que os contêineres com falha sejam reiniciados automaticamente, aumentando a resiliência.

Gerenciar limites de recursos

A configuração de limites de CPU e memória diretamente nas definições do Compose YAML ajuda você a controlar as alocações de recursos, aumentando a previsibilidade e a eficiência dos recursos.

Um exemplo de snippet para limites de recursos:

services:
  flaskapp:
    image: flask
    deploy:
      resources:
        limits:
          cpus: '0.50'
          memory: 512M

Exemplo prático: Aplicação de vários contêineres

Aqui está um exemplo simplificado do mundo real envolvendo um aplicativo Python Flask emparelhado com o Redis:

services:
  redis:
    image: redis:7
    container_name: redis
    ports:
      - "6379:6379"
    restart: always
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 30s
      timeout: 5s
      retries: 3
  web:
    build: .
    container_name: flask_app
    command: gunicorn app:app --worker-class gevent --bind 0.0.0.0:5000 --timeout 3000
    ports:
      - "5000:5000"
    depends_on:
      - redis
    environment:
      - REDIS_URL=redis://redis:6379/0
    env_file:
      - .env
    volumes:
      - ./shorts:/app/shorts
      - ./temp_uploads:/app/temp_uploads
      - ./uploads:/app/uploads
    restart: always

  worker:
    build: .
    container_name: celery_worker
    command: celery -A celery_worker.celery worker --loglevel=info
    depends_on:
      - redis
    environment:
      - REDIS_URL=redis://redis:6379/0
    env_file:
      - .env
    volumes:
      - ./shorts:/app/shorts
      - ./temp_uploads:/app/temp_uploads
      - ./uploads:/app/uploads
    restart: always

O arquivo Docker Compose define um aplicativo de vários contêineres com três serviços:

1. redis
2. web (aplicativo Flask com Gunicorn)
3. trabalhador (trabalhador de aipo)

Para o serviço redis:

• Usa a imagem oficial do Redis 7.
• Define o nome do contêiner como redis.
• Mapeia a porta 6379 dentro do contêiner para 6379 no host.
• Sempre reinicia se houver uma falha (restart: always).
• Define um healthcheck que executa o redis-cli ping a cada 30 segundos, atinge o tempo limite após 5 segundos e tenta novamente 3 vezes antes de declarar o contêiner não saudável.

Para o serviço da Web:

• Cria a imagem a partir do diretório atual (build: . ).
• Nomeia o contêiner flask_app.
• Executa o comando gunicorn app:app usando gevent workers, vinculados a 0.0.0.0:5000, com um tempo limite longo de 3000 segundos
• Mapeia a porta do contêiner 5000 para 5000 no host.
• Declara uma dependência do serviço redis, garantindo que o Redis seja iniciado primeiro.
• Define uma variável de ambiente REDIS_URL que aponta para o contêiner interno do Redis.
• Carrega variáveis de ambiente adicionais do arquivo .env.
• Monta três pastas locais no contêiner:
• ./shorts para /app/shorts,
• ./temp_uploads para /app/temp_uploads 
• ./uploads para /app/uploads
• Configurado para sempre reiniciar se houver falha.

Para o trabalhador serviço:

• Também cria a imagem a partir do diretório atual (build: .), reutilizando o mesmo Dockerfile que o web da Web.
• Nomeia o contêiner: celery_worker.
• Executa o comando celery -A celery_worker.celery worker --loglevel=info que inicia um trabalhador do Celery para processar trabalhos em segundo plano.
• Declara uma dependência do serviço redis, garantindo que o Redis seja iniciado primeiro.
• Define a mesma variável de ambiente REDIS_URL para que você se conecte ao corretor Redis.
• Carrega outras variáveis de ambiente do arquivo .env.
• Monta as mesmas três pastas que a pasta web permitindo que o aplicativo Web e o trabalhador compartilhem arquivos e uploads.
• Configurado para sempre reiniciar se houver falha.

Explore mais ideias de projetos do Docker em nosso tutorial 10 ideias de projetos do Docker. 

Criação e execução de aplicativos com vários contêineres

O Docker Compose oferece um conjunto de ferramentas simples para tarefas rotineiras de contêineres:

Construindo imagens

Use docker compose build para gerar imagens de contêineres de acordo com os Dockerfiles definidos por você. Abordamos mais informações sobre a criação de imagens do Docker em nosso site Como aprender a usar o Docker do zero: Um guia para profissionais de dados tutorial. 

Serviços em execução

O uso do endereço docker compose up inicia todos os serviços definidos no arquivo de composição. Para o modo desvinculado, use docker compose up -d. Nosso curso Introdução ao Docker aborda mais detalhadamente a execução de um contêiner em segundo plano. 

Visualização de contêineres em execução

Para visualizar os contêineres ativos e seus status, use docker compose ps para listar todos os serviços em execução.

Interrupção de serviços

Use docker compose down para interromper os serviços em execução. 

Visualização de registros

Use docker compose logs para verificar os registros. Você pode especificar um contêiner para verificar os registros usando docker logs container_name. Para transmitir os registros, use docker compose -f container_name. 

Nosso guia Os 18 principais comandos do Docker para criar, executar e gerenciar contêineres detalha mais comandos do Docker para que você possa gerenciar aplicativos em ambientes com confiança.

Casos de uso avançados do Docker Compose 

A composição de fluxos de trabalho se adapta a configurações de desenvolvimento mais complexas ou a diferentes configurações de ambiente.

Configuração de vários ambientes

Vários arquivos Compose ou arquivos de substituição facilitam diferentes configurações de ambiente (desenvolvimento, teste, produção). Isso mantém as definições legíveis e passíveis de manutenção, permitindo modificações rápidas sem configurações desordenadas.

Gerenciamento de dependências

Enquanto o site depends_on lida com a ordem de inicialização básica, cenários complexos podem incorporar scripts de inicialização (como "wait-for-it"), garantindo que os contêineres sejam iniciados somente depois que condições específicas forem atendidas, como a prontidão do banco de dados.

Integração com CI/CD

O Compose se integra sem esforço aos fluxos de trabalho de integração contínua, automatizando configurações completas de ambiente para testes. Plataformas como o GitLab CI e o GitHub Actions oferecem abordagens nativas ou diretas para a integração do Compose, simplificando os testes automatizados.

Práticas recomendadas e desafios comuns

Você pode evitar armadilhas comuns e criar configurações de fácil manutenção organizando e estruturando as definições do Compose cuidadosamente.

Organização do arquivo de composição

Mantenha seus arquivos do Compose claros e modulares. Para projetos mais simples, um único arquivo pode ser suficiente, mas para aplicativos maiores, considere dividir a configuração em vários arquivos do Compose usando o recurso de substituição. Isso permite que você:

• Separação lógica de componentes (por exemplo, docker-compose.backend.yml, docker-compose.frontend.yml)
• Personalização mais fácil do ambiente local em comparação com o ambiente de produção
• Controle de versão e colaboração simplificados, pois as alterações em um serviço não afetam o arquivo inteiro

Use nomes de serviços significativos e indentação consistente para facilitar a leitura e a navegação dos arquivos.

Possíveis armadilhas

Esteja ciente desses erros comuns:

• Usando as tags latest para imagens: Isso introduz imprevisibilidade, pois a versão real da imagem pode mudar com o tempo. Sempre fixe explicitamente as versões das imagens (por exemplo, postgres:15.1) para garantir a consistência entre os ambientes.
• Segredos de código rígido: Nunca inclua dados confidenciais (por exemplo, chaves de API, senhas) diretamente nos arquivos do Compose. Em vez disso, use variáveis de ambiente, arquivos .env (excluídos do controle de versão) ou ferramentas de gerenciamento de segredos, como o Docker Secrets, para um manuseio seguro.
• Definições de serviço excessivamente complexas: Resista ao impulso de colocar muita lógica ou muitas responsabilidades em um único recipiente. Siga o princípio da responsabilidade única e favoreça a simplicidade sempre que possível.
• Negligenciar a rede explícita: Defina redes personalizadas no Compose em vez de confiar no comportamento padrão. Isso oferece melhor controle sobre a comunicação do serviço, reduz os conflitos de portas e melhora os limites de segurança.

Ao adotar essas práticas, seus fluxos de trabalho baseados no Compose serão mais robustos, seguros e fáceis de manter em ambientes colaborativos ou em evolução.

Conclusão

O Docker Compose simplifica significativamente a criação, o gerenciamento e a execução de aplicativos com vários contêineres para os desenvolvedores. Suas definições claras baseadas em YAML, a facilidade de orquestração e o dimensionamento direto o tornam inestimável para cenários de desenvolvimento local e arquiteturas de implantação mais simples. Embora os orquestradores avançados, como o Docker Swarm e o Kubernetes, sejam mais adequados para cargas de trabalho de produção em larga escala, o Compose continua sendo um ponto de entrada essencial para entender os fundamentos da orquestração de contêineres e melhorar os fluxos de trabalho dos desenvolvedores.

Confira nossos cursos sobre o Docker para que você aprenda:

• Containerização e virtualização com Docker e Kubernetes 
• Docker intermediário