Tecnologia e Infraestrutura → Docker Compose e Ambiente Dave

Docker Compose e Ambiente Dave

1) Porquê Compose

• A paridade com a venda (imagens, variáveis, redes) é menor do que «funciona comigo».
• Início rápido para os novatos → 'make up' e para a luta.
• Estandes isolados por desenvolvedor/ramo → trabalho paralelo sem conflitos.
• Testes de integração em dependências reais.

2) Estrutura básica do repositório

project/
docker/
app/      # Dockerfile, скрипты web/      # Nginx/Traefik конфиги seed/      # сидеры/фикстуры compose.yaml       # общий базовый стек compose.override.yaml   # локальные оверрайды (в.gitignore)
compose.ci.yaml      # для CI
.env.example       # шаблон окружения
Makefile         # удобные цели devcontainer.json     # VS Code Dev Containers (опционально)

• compose. yaml - descreve o «esqueleto» (serviços, redes, volumes) igual para dave/CI.
• override - apenas edições locais: mappings de diretório, portas, bandeiras debug.
• .env. example → o desenvolvedor cópia em '.eng' e configura os valores.

3) Esqueleto compose. yaml (exemplo)

yaml name: project services:
gateway:
image: traefik:v3 command:
- "--providers.docker=true"
- "--entrypoints.web.address=:80"
- "--entrypoints.websecure.address=:443"
- "--certificatesresolvers.dev.acme.tlschallenge=true"
ports: ["80:80", "443:443"]
volumes:
- /var/run/docker.sock:/var/run/docker.sock:ro networks: [edge, core]

api:
build:
context:.
dockerfile: docker/app/Dockerfile target: dev env_file: [.env]
command:./scripts/dev-start.sh volumes:
-./:/app:cached depends_on: [db, redis, kafka]
labels:
- "traefik.http.routers.api.rule=Host(`${API_HOST}`)"
- "traefik.http.services.api.loadbalancer.server.port=8080"
networks: [core]

db:
image: postgres:16 environment:
POSTGRES_USER: ${DB_USER}
POSTGRES_PASSWORD: ${DB_PASS}
POSTGRES_DB: ${DB_NAME}
volumes:
- pgdata:/var/lib/postgresql/data healthcheck: {test: ["CMD-SHELL","pg_isready -U $$POSTGRES_USER"], interval: 5s, timeout: 3s, retries: 20}
networks: [core]

redis:
image: redis:7 command: ["redis-server","--appendonly","yes"]
volumes: [ "redisdata:/data" ]
networks: [core]

kafka:
image: bitnami/kafka:3 environment:
KAFKA_ENABLE_KRAFT: "yes"
KAFKA_CFG_PROCESS_ROLES: "controller,broker"
KAFKA_CFG_NODE_ID: 1
KAFKA_CFG_LISTENERS: PLAINTEXT://:9092
KAFKA_CFG_ADVERTISED_LISTENERS: PLAINTEXT://kafka:9092 networks: [core]

mailhog:
image: mailhog/mailhog ports: ["8025:8025"]
networks: [core]

mock-psp:
image: wiremock/wiremock:3 command: ["--verbose","--global-response-templating"]
volumes: ["./docker/mocks/psp:/home/wiremock"]
labels:
- "traefik.http.routers.mockpsp.rule=Host(`${PSP_HOST}`)"
networks: [core]

volumes:
pgdata: {}
redisdata: {}

networks:
edge: {}
core: {}

• Traefik/NGINX como gateway: aproxima o padrão de routing do de venda.
• Healthcheck e depends _ on com 'condition: service _ healthy' (em v3 através de script waiting) é um começo ordenado.
• Volumes para Persistência (BD/dinheiro) e bind-mount para código (hot-reload).

4) Perfis e arquivos múltiplos

Os profiles ('profiles: [dave, ci, extras]') incluem/excluem serviços ('docker compose --profile extras up -d').

• `docker compose -f compose. yaml -f compose. dev. yaml up '- fundir configurações.

• `compose. yaml '- básico.
• `compose. dev. yaml '- bind-mounts, debag, fichicheflags.
• `compose. extras. yaml '- ferramentas (Grafana, pgAdmin, Kafdrop).
• `compose. ci. yaml '- «cabeça sem gráficos», sem bind-mounts.

5) Variáveis, segredos e configurações

.eng é a fonte geral de variáveis: hosts, credenciais de base de teste, bandeiras.

• segredos de dummy local (chaves de braçadeira),
• integração com skinny-Vault/SOPS para particularmente sensível.
• Princípio: Dados minimamente necessários. PAN/PII - tokens/ficstures.

6) Montagens e velocidade

6. 1 Multi-stage + BuildKit

Dockerfile com os objetivos 'base', 'dave', 'prod'; cache-layer compartilhado para dependências.
Ativar o BuildKit: 'DOCKER _ BUILDKIT = 1' (ou no configh).
«--mount = tipo = cachê, target =/root/.cache/...» para pip/npm/maven.

6. 2 Ciclo rápido

Bind-mount кода + hot-reload (nodemon, uvicorn --reload, Spring Devtools).
Uma meta particular dave com a montagem apenas do que você deseja.
Makefile цели: `make up`, `make down`, `make logs`, `make rebuild`, `make seed`.

make
ENV?= dev up:
docker compose --profile $(ENV) up -d down:
docker compose down -v logs:
docker compose logs -f --tail=200 rebuild:
DOCKER_BUILDKIT=1 docker compose build --pull --no-cache api seed:
docker compose run --rm api./scripts/seed.sh migrate:
docker compose run --rm api./scripts/migrate.sh test:
docker compose -f compose.yaml -f compose.ci.yaml run --rm api./scripts/test.sh

7) BD, migração, siding

As migrações (Flyway/Liquibase/Albic/Prisma) são iniciadas com um hub após o início de 'db' (espera healthcheck).
Ciding: um contêiner «seed» separado com ficturas; repetível e idimpotente.
O volume 'pgdata' pode ser reativado/restaurado com o script 'reset-db'. sh`.

8) Corretores, cachês, CDC

Kafka/Rabbit/Redpanda - como na venda (configs mínimos).
Redis com AOF incluído para realismo.
Conectores CDC (opcional): Debezium em um serviço separado para testes de integração de analistas.

9) Moki fornecedores externos

WireMock/Prism para o REST, MockServer para os cenários complexos.
Mailhog/SMTP4Dev para cartas.
Localstack/MinIO para estoques de nuvem e compatibilidade S3.
Política: Todos os PSP/KYC/KMS externos - por meio de McHab contratos (OpenAPI) e não «Internet».

10) Proxy inverso e TLS

• `api. local. test`, `mockpsp. local. test`.
• TLS: mkcert para emitir um certificado local de confiança para testar HSTS/secure-cookies.
• Use as sessões de sticky apenas para as malas onde isso é realmente importante.

11) Perfis de desenvolvedor: Node/Python/Java

Node: mount 'node _ modales' como um dinheiro (volume) para acelerar install; 'CHOKIDAR _ USEPOLLING = 1' no Windows/WSL.
Python: `pip cache` как volume, `watchfiles`/`uvicorn --reload`.
Java: JRebel/Devtools, 'mvn -T 1C + camada com dependências.

12) Testes e qualidade

Testes de integração dentro da rede Compose: 'docker compose run teste'.
Testcontainers (para JVM/Node/Python/.NET) é uma opção de integração unit sem pilha completa.
Um contrato de testes com um hub → gate na CI.
Linters/Pré-commit: execute em um contêiner de repetição.

13) Devcontainers e «IDE-como-código»

`devcontainer. json 'capta a imagem do escravo (CLI, SDK, linters), monta o projeto, expulsa' postCreateCommand '.
As mesmas ferramentas, não «entupimos» o hóspede, a nova máquina está pronta em minutos.

14) Segurança em dave

Sem root nas imagens de aplicativos; 'readOnlyRootFilesystem' sempre que possível.
Sem chaves de guerra ou segredos, mesmo temporariamente.
Logi - sem PII/PAN; camuflagem ao nível do formator.
Segregação de portas e redes: acesso externo somente por gateway.

15) FinOps/desempenho em local

Limite os recursos de 'deploy. resources. limits '(Compose lê parcialmente, mas ajuda a disciplina).
Reduza o fã-out (menos serviços padrão; extras - perfis).
Cash BuildKit e kits de volume para gerentes de pacotes.

16) CI с Compose

Use os mesmos 'compose. yaml` + `compose. ci. yaml 'sem bind-mounts.
Cash Dependence - Como um volume attachable entre jobs/camadas.
Jobs paralelo: 'name:' no Compose é diferente (ou prefixo por ramo) para que os estandes não fiquem em conflito.

17) Trapachuting

'docker compose ps '/' logs -f '/' exec' é um diagnóstico básico.
Verifique o DNS na rede Compose.
Se o bind-mount «trava» no macOS/Windows - ': cached '/': delegated' ou Mutagen/virtuofs.
Healthcheck é «verde», mas o serviço está «morto»: verifique «readiness» sua aplicação e ordem de migração.

18) Folha de cheque de implementação

1. Pilha básica (gateway, api, db, cachê, queue) em compose. yaml.
2. Edição local - override (v.gitignore).
3..env. example completa e atualizada; 'make bootstrap' a cópia em '.eng'.
4. Healthchecks e cenário de espera BD/migração.
5. WireMock/Localstack/MinIO para provedores externos.
6. Siding e migração como comandos 'make seed/migrate'.
7. BuildKit + multi-estágio, cases de dependências.
8. Devcontainers/Makefile para partida rápida.
9. Perfis 'extras' para ferramentas (Grafana/pgAdmin/Kafdrop).
10. A CI usa a mesma compose (+ ci-override).

19) Anti-pattern

«Monstro-compose» em 40 serviços, sempre em andamento: inclua perfis.
Portos duros e em conflito entre desenvolvedores.
Segredos/chaves em Git ou '.env. example`.
Dependência de «internet» para testes (PSP real/KYC).
Falta de healthcheck/espera - corrida de migração e lançamentos.
Falta de siding → testes de integração flaky.

20) Total

Compose é um motor de velocidade desenvolvida, um único arquivo descreve o seu mundo de serviços, e os perfis/overraides oferecem flexibilidade. Mantenha a paridade com a venda, automatize o siding e as migrações, mantenha os mooks e os TLS «como em combate», acelere as montagens do BuildKit 'om - e você terá um ambiente local em que você pode trabalhar, testar facilmente e reproduzir com segurança os cenários de venda iGaming/fintech.