Pesquisar
Português
Conteúdo
  1. Tutorial de Docker
Primeiros passos
  1. O que é Docker
  2. Instalar Docker
  3. Tour pela interface do Docker Desktop
  4. Primeiro contêiner
  5. Imagens (Image)
  6. Ciclo de vida dos contêineres
  7. Parâmetros do docker run
  8. Consultar logs e depurar
Imagens e Dockerfile
  1. Introdução ao Dockerfile
  2. gerar automaticamente com docker init
  3. Guia de instruções do Dockerfile
  4. Cache de build e otimização
  5. Builds em múltiplos estágios
  6. Publicar no Docker Hub
Dados e redes
  1. Volume e persistência de dados
  2. Redes e comunicação entre contêineres
  3. Variáveis de ambiente e .env
Docker Compose
  1. Introdução ao Docker Compose
  2. Sintaxe do compose.yaml
  3. Comandos do Docker Compose
  4. Exemplo prático: configurar WordPress
Exemplos práticos
  1. Aplicações Python
  2. Aplicações Node.js
  3. Nginx e proxy reverso
  4. MySQL
  5. PostgreSQL
  6. Redis
Operação e tópicos avançados
  1. Liberar espaço em disco
  2. Boas práticas de segurança
  3. Rootless e Podman
  4. Imagens multiplataforma
  5. Build automático com GitHub Actions
  6. Implantar em um servidor na nuvem
  7. Fundamentos internos
  8. Guia de mensagens de erro comuns
  9. Referência rápida de comandos Docker
Referência de comandos
  1. docker build
  2. docker exec
  3. docker ps
  4. docker logs
  5. docker cp
  6. docker inspect
  7. docker volume
  8. docker network
  9. docker compose up
  10. docker compose down

Tutorial de docker compose up: opções e exemplos

docker compose up cria e inicia os serviços definidos em compose.yaml. Para começar com Compose, veja Introdução ao Docker Compose; para outros comandos do Compose, consulte comandos do docker compose.

Sintaxe

docker compose up [opções] [nome do serviço...]

Se você não especificar um serviço, todos serão iniciados. O up segue estas etapas: cria a rede, cria o Volume, baixa ou constrói a imagem quando necessário, cria os contêineres (e recria os que tiveram alterações de configuração) e inicia os contêineres.

Opções

OpçãoDescrição
-d, --detachExecuta em segundo plano. Sem essa opção, os logs aparecem em primeiro plano; pressione Ctrl+C para parar
--buildConstrói a imagem antes de iniciar
--no-buildNão constrói; falha se a imagem não existir
--pull always|missing|neverDefine se a imagem deve ser baixada antes da inicialização
--waitAguarda até que todos os serviços estejam em execução (os que têm verificação de integridade precisam estar healthy) antes de retornar; implica -d
--wait-timeout segundosTempo máximo de espera de --wait
--force-recreateRecria os contêineres mesmo que a configuração não tenha mudado
--no-recreateNão recria contêineres que já existam
--no-depsNão inicia os serviços definidos em depends_on
--scale serviço=quantidadeInicia várias réplicas
--remove-orphansRemove os contêineres de serviços que não existem mais em compose.yaml
-V, --renew-anon-volumesCria novos Volumes anônimos em vez de reutilizar os do contêiner antigo
--abort-on-container-exitPara todos os contêineres quando qualquer um deles parar (não pode ser usado com -d)
--exit-code-from serviçoUsa o código de saída desse serviço como código de saída do comando; implica a opção anterior
-t, --timeout segundosTempo de espera ao parar os contêineres
-w, --watchMonitora alterações nos arquivos e sincroniza ou reconstrói (veja aplicativo Node.js)
--no-startApenas cria, sem iniciar
--quiet-pull / --quiet-buildNão exibe o progresso do download ou da construção
--no-log-prefix, --timestamps, --no-colorFormato dos logs no modo de primeiro plano
--dry-runMostra o que seria feito, sem executar de verdade

Projeto de exemplo

services:
  web:
    image: nginx:1.30-alpine
    ports:
      - "8080:80"
    depends_on:
      - cache
  cache:
    image: redis:8-alpine
    volumes:
      - cache_data:/data
  worker:
    image: alpine:3.23
    command: ["sh", "-c", "echo worker done"]

volumes:
  cache_data:

Iniciar todos os serviços

$ docker compose up -d
[+] up 15/15
 ✔ Image redis:8-alpine           Pulled                                                                                                          3.4s
 ✔ Network ref-compose_default    Created                                                                                                         0.0s
 ✔ Volume ref-compose_cache_data  Created                                                                                                         0.0s
 ✔ Container ref-compose-worker-1 Started                                                                                                         0.4s
 ✔ Container ref-compose-cache-1  Started                                                                                                         0.6s
 ✔ Container ref-compose-web-1    Started                                                                                                         0.8s

$ docker compose ps -a
NAME                   IMAGE               COMMAND                  SERVICE   CREATED        STATUS                              PORTS
ref-compose-cache-1    redis:8-alpine      "docker-entrypoint.s…"   cache     1 second ago   Up Less than a second               6379/tcp
ref-compose-web-1      nginx:1.30-alpine   "/docker-entrypoint.…"   web       1 second ago   Up Less than a second               0.0.0.0:8080->80/tcp, [::]:8080->80/tcp
ref-compose-worker-1   alpine:3.23         "sh -c 'echo worker …"   worker    1 second ago   Exited (0) Less than a second ago

O worker termina depois de executar echo, por isso aparece como Exited (0). Esse é o comportamento normal de um serviço de execução única.

Processar apenas alguns serviços

$ docker compose up -d --no-deps web
[+] up 1/1
 ✔ Container ref-compose-web-1 Running                                                                                                            0.0s

$ docker compose up -d --force-recreate web
[+] up 2/2
 ✔ Container ref-compose-cache-1 Running                                                                                                          0.0s
 ✔ Container ref-compose-web-1   Started                                                                                                          0.4s

$ docker compose up -d --wait cache
[+] up 1/1
 ✔ Container ref-compose-cache-1 Healthy                                                                                                          0.5s
  • --no-deps web: processa apenas web e ignora o cache, do qual ele depende. Como a configuração não mudou, apenas Running é exibido.
  • --force-recreate web: recria web mesmo que a configuração não tenha mudado (Started). Como não foi usado --no-deps, o cache definido em depends_on também é verificado (Running).
  • --wait cache: aguarda até que cache esteja pronto para retornar. Como a imagem do Redis não define uma verificação de integridade, o contêiner é considerado pronto quando está em execução.

--scale: várias réplicas

$ docker compose up -d --scale worker=3 worker
[+] up 3/3
 ✔ Container ref-compose-worker-3 Started                                                                                                         0.5s
 ✔ Container ref-compose-worker-2 Started                                                                                                         0.3s
 ✔ Container ref-compose-worker-1 Started                                                                                                         0.2s

$ docker compose ps -a worker
NAME                   IMAGE         COMMAND                  SERVICE   CREATED         STATUS                              PORTS
ref-compose-worker-1   alpine:3.23   "sh -c 'echo worker …"   worker    4 seconds ago   Exited (0) Less than a second ago   
ref-compose-worker-2   alpine:3.23   "sh -c 'echo worker …"   worker    1 second ago    Exited (0) Less than a second ago   
ref-compose-worker-3   alpine:3.23   "sh -c 'echo worker …"   worker    1 second ago    Exited (0) Less than a second ago

--scale worker=3 cria 3 contêineres para worker, com nomes numerados automaticamente como -1, -2 e -3. Não é possível escalar diretamente um serviço que tenha uma porta do host correspondente (ports), pois as portas do host entrariam em conflito.

--exit-code-from: executar testes no CI

$ docker compose up --abort-on-container-exit --exit-code-from worker worker
[+] up 2/2
 ✔ Container ref-compose-worker-2 Removed                                                                                                         0.0s
 ✔ Container ref-compose-worker-3 Removed                                                                                                         0.0s
Attaching to worker-1
worker-1  | worker done
worker-1 exited with code 0
Aborting on container exit...
Container ref-compose-worker-1 Stopping
Container ref-compose-worker-1 Stopped
w Enable Watch   d Detach
  • Apenas worker é executado. Quando ele termina (--abort-on-container-exit), todo o up também termina, e o código de saída do up é o código de saída de worker (--exit-code-from). Use essa opção no CI para executar serviços de teste: se o teste falhar, o comando falha e o CI também.
  • Os contêineres worker-2 e worker-3, criados na etapa anterior com --scale, foram removidos desta vez (Removed), pois nenhuma quantidade de réplicas foi especificada e o padrão voltou a ser 1.

Capítulos relacionados

Exercícios

Exercício: altere a porta de web no compose.yaml do exemplo para 8081:80, aplique a alteração com um comando e confirme que apenas web foi recriado.

Resposta 
docker compose up -d

Na saída, web aparece como Recreated／Started e cache como Running (sem alterações). Em docker compose ps, a porta PORTS de web passa a ser 0.0.0.0:8081->80/tcp.

Perguntas frequentes

Como aplicar as alterações feitas em compose.yaml?

Execute docker compose up -d novamente. O Compose compara as configurações e recria apenas os serviços que mudaram. docker compose restart não aplica novas configurações; veja o teste em [comandos do docker compose](/pt/docker/compose-commands/).

Por que o up -d não reconstruiu a imagem depois que alterei o Dockerfile?

Se a imagem já existir, up não a reconstrói automaticamente. Adicione --build: docker compose up -d --build.

Qual é a diferença entre --wait e service_healthy em depends_on?

depends_on controla a ordem de inicialização entre os serviços; --wait faz o próprio comando docker compose up aguardar até que todos os serviços estejam em execução (os que têm verificação de integridade precisam estar healthy) antes de retornar. Isso é útil para executar a próxima etapa em scripts e no CI.

Atualizado 14 de outubro de 2026