Docker Compose: build, logs, health e restart

Objetivos

• Subir os cinco serviços e dependências com um comando
• Aplicar health checks para startup previsível
• Padronizar operações de dia a dia com Compose e Makefile

Pré-requisitos

• Dockerfiles prontos para os cinco serviços
• Estrutura de monorepo organizada
• Rede e volumes configurados

Conceito

Sem orquestração, cada desenvolvedor sobe serviços em ordem diferente, com comandos diferentes, e o ambiente vira imprevisível. Docker Compose transforma essa operação em configuração versionada, reduzindo erro humano e tempo de setup.

Health check é o mecanismo que impede falso positivo de "subiu". Um container pode estar em execução, mas a aplicação interna ainda não pronta. Com checks bem definidos, você evita requests prematuros e falhas de integração difíceis de rastrear.

Nesta aula, você cria o docker-compose.yml principal com infraestrutura e serviços, além de comandos operacionais. Isso vira o ponto de entrada oficial para rodar o sistema no restante do curso.

Estrutura de arquivos

infra/
  docker-compose.yml
Makefile
services/
  customer-service/Dockerfile
  order-service/Dockerfile
  payment-service/Dockerfile
  notification-service/Dockerfile
  analytics-service/Dockerfile

Passo a passo

1. Criar infra/docker-compose.yml com os cinco serviços

version: "3.9"
services:
  customer-service:
    build: ../services/customer-service
    ports: ["8081:8080"]
    healthcheck:
      test: ["CMD", "wget", "-qO-", "http://localhost:8080/health"]
      interval: 10s
      timeout: 3s
      retries: 5

  order-service:
    build: ../services/order-service
    ports: ["8000:8000"]
    healthcheck:
      test: ["CMD", "wget", "-qO-", "http://localhost:8000/health"]
      interval: 10s
      timeout: 3s
      retries: 5

  payment-service:
    build: ../services/payment-service
    ports: ["8080:8080"]
    healthcheck:
      test: ["CMD", "wget", "-qO-", "http://localhost:8080/health"]
      interval: 10s
      timeout: 3s
      retries: 5

  notification-service:
    build: ../services/notification-service
    ports: ["4567:4567"]
    healthcheck:
      test: ["CMD", "wget", "-qO-", "http://localhost:4567/health"]
      interval: 10s
      timeout: 3s
      retries: 5

  analytics-service:
    build: ../services/analytics-service
    ports: ["3000:3000"]
    healthcheck:
      test: ["CMD", "wget", "-qO-", "http://localhost:3000/health"]
      interval: 10s
      timeout: 3s
      retries: 5

2. Incluir dependências de infra (Kafka/Redis) quando necessário

  kafka:
    image: bitnami/kafka:3.7
    ports: ["9092:9092"]

  redis:
    image: redis:7.2-alpine
    ports: ["6379:6379"]

3. Criar Makefile para operação repetível

COMPOSE_FILE=infra/docker-compose.yml

up:
	docker compose -f $(COMPOSE_FILE) up --build -d

down:
	docker compose -f $(COMPOSE_FILE) down

logs:
	docker compose -f $(COMPOSE_FILE) logs -f --tail=200

ps:
	docker compose -f $(COMPOSE_FILE) ps

restart:
	docker compose -f $(COMPOSE_FILE) restart

4. Ajustar app Node para logs úteis (exemplo em analytics-service/src/server.js)

const express = require("express");
const app = express();
app.use(express.json());

app.get("/health", (_req, res) => {
  res.json({ status: "ok", service: "analytics-service" });
});

app.listen(3000, "0.0.0.0", () => {
  console.log("[analytics-service] listening on 3000");
});

Como testar

1. Subir tudo:

docker compose -f infra/docker-compose.yml up --build -d

2. Verificar saúde:

docker compose -f infra/docker-compose.yml ps

Saída esperada: coluna STATUS com (healthy) para os cinco serviços.

3. Testar endpoints:

curl -s http://localhost:8081/health
curl -s http://localhost:8000/health
curl -s http://localhost:8080/health
curl -s http://localhost:4567/health
curl -s http://localhost:3000/health

4. Ver logs:

docker compose -f infra/docker-compose.yml logs -f customer-service order-service

Dicas de projeto

• Use health check curto e estável; agressivo demais causa falso negativo.
• Mantenha docker compose ps como primeira verificação de incidentes.
• Documente portas externas e internas para evitar confusão.
• Tenha comando rápido de down para reiniciar ambiente com segurança.

Erros comuns

• Rodar up sem --build após mudar Dockerfile.
• Check de saúde apontando para rota inexistente.
• Expor portas conflitantes no host.
• Ignorar logs de startup e depurar no escuro.

Resumo

Com Compose + health checks, o ambiente inteiro sobe de forma determinística e testável. Isso encerra a base de infraestrutura do curso e libera foco para implementação de APIs de domínio.