# Deployment com Docker Compose

Guia detalhado para deploy do Monetarie PIX usando Docker Compose em tres modos: producao, desenvolvimento e alta disponibilidade.

## Pre-requisitos

- Docker Engine 24.0+ e Docker Compose 2.20+ instalados
- Acesso ao registro de imagens Docker (ou codigo-fonte para build local)
- Para modo producao: PostgreSQL 16, Redis 7 e NATS 2.10 externos
- Para modo HA: certificados TLS para o load balancer nginx

## Modos de Deploy

### Modo Producao

Apenas os servicos da aplicacao (backend + admin). Assume infraestrutura externa (PostgreSQL, Redis, NATS).

```bash
cd deploy/docker-compose
cp .env.example .env
# Editar .env com configuracoes de producao
docker compose up -d
```

### Modo Desenvolvimento

Aplicacao + infraestrutura completa em containers (PostgreSQL + Redis + NATS). Build a partir do codigo-fonte.

```bash
cd deploy/docker-compose
cp .env.example .env
docker compose -f docker-compose.yml -f docker-compose.dev.yml up -d
```

### Modo Alta Disponibilidade

Multiplas replicas com load balancer nginx e terminacao TLS.

```bash
cd deploy/docker-compose
cp .env.example .env
# Colocar certificados em ./certs/server.crt e ./certs/server.key
docker compose -f docker-compose.yml -f docker-compose.ha.yml up -d
```

## Configuracao de Ambiente

### Variaveis Obrigatorias

Edite o arquivo `.env` com os valores adequados:

```ini
# === Banco de Dados ===
DB_HOST=postgres              # Hostname do PostgreSQL
DB_PORT=5432                  # Porta do PostgreSQL
DB_USER=postgres              # Usuario do PostgreSQL
DB_PASS=<SENHA_SEGURA>        # Senha do PostgreSQL
DB_NAME=monetarie                # Nome do banco
DATABASE_URL=ecto://postgres:<SENHA_SEGURA>@postgres:5432/monetarie

# === Redis ===
REDIS_HOST=redis              # Hostname do Redis
REDIS_PORT=6379               # Porta do Redis

# === NATS ===
NATS_HOST=nats                # Hostname do NATS
NATS_PORT=4222                # Porta do NATS
NATS_ENABLED=true             # Habilitar workers JetStream

# === Phoenix ===
SECRET_KEY_BASE=<CHAVE_64_CHARS>  # mix phx.gen.secret ou openssl rand -base64 64
PHX_HOST=localhost                 # Hostname publico da API
PORT=4003                          # Porta do backend
MIX_ENV=prod                       # Ambiente Elixir
POOL_SIZE=20                       # Conexoes por repo (total = POOL_SIZE x 4)

# === Autenticacao ===
JWT_SECRET=<SECRET_COMPARTILHADO_CORE>       # Deve ser igual ao GUARDIAN_SECRET_KEY do Core
GUARDIAN_SECRET_KEY=<SECRET_COMPARTILHADO>    # Fallback para JWT
```

### Variaveis Opcionais

```ini
# === BACEN ===
BACEN_ENABLED=false           # true para conectar ao BACEN real
BACEN_ENV=homolog             # homolog ou production
SIMULATOR_ENABLED=false       # true para usar simulador BACEN

# === Rate Limiting ===
RATE_LIMIT_MODE=strict        # strict (bloqueia) ou permissive (apenas loga)
RATE_LIMIT_BYPASS_AUTH=false  # DEVE ser false em producao

# === Imagens Docker ===
PIX_BACKEND_IMAGE=monetarie/pix-backend:latest
PIX_ADMIN_IMAGE=monetarie/pix-admin:latest

# === Portas Externas ===
ADMIN_PORT=8080               # Porta do portal admin
```

::: danger SEGURANCA
Nunca faca commit do arquivo `.env` com credenciais reais. O `.gitignore` ja inclui `.env` por padrao.
:::

## Modo Producao (Detalhado)

### 1. Preparar Infraestrutura Externa

Antes de iniciar, certifique-se que os servicos externos estao acessiveis:

```bash
# Testar conectividade PostgreSQL
pg_isready -h <DB_HOST> -p 5432 -U postgres

# Testar conectividade Redis
redis-cli -h <REDIS_HOST> -p 6379 ping
# Esperado: PONG

# Testar conectividade NATS
curl -s http://<NATS_HOST>:8222/healthz
# Esperado: {"status":"ok"}
```

### 2. Configurar e Iniciar

```bash
cd deploy/docker-compose
cp .env.example .env
# Editar .env com valores de producao

docker compose up -d
```

Saida esperada:
```
[+] Running 2/2
 ✔ Container pix-backend  Healthy
 ✔ Container pix-admin    Started
```

### 3. Executar Migrations

```bash
docker compose exec backend bin/monetarie_pix eval "Shared.Release.migrate()"
```

### 4. Popular Seeds (Primeira Execucao)

```bash
docker compose exec backend bin/monetarie_pix eval "Shared.Release.seed()"
```

### 5. Verificar Saude

```bash
curl -s http://localhost:4003/health
# Esperado: {"status":"ok"}

curl -s http://localhost:8080
# Esperado: HTML do portal admin
```

## Modo HA (Detalhado)

### 1. Preparar Certificados TLS

Coloque os certificados no diretorio `certs/`:

```bash
# Certificados auto-assinados para teste
openssl req -x509 -nodes -days 365 -newkey rsa:2048 \
  -keyout certs/server.key \
  -out certs/server.crt \
  -subj "/CN=pixapi.fluxiq.com.br"
```

Para producao, use certificados de uma CA confiavel (Let's Encrypt ou comercial).

### 2. Iniciar com HA

```bash
docker compose -f docker-compose.yml -f docker-compose.ha.yml up -d
```

Saida esperada:
```
[+] Running 6/6
 ✔ Container pix-backend-1    Healthy
 ✔ Container pix-backend-2    Healthy
 ✔ Container pix-backend-3    Healthy
 ✔ Container pix-admin-1      Started
 ✔ Container pix-admin-2      Started
 ✔ Container pix-nginx-lb     Healthy
```

### 3. Escalar Manualmente

```bash
# Escalar backend para 5 replicas
docker compose -f docker-compose.yml -f docker-compose.ha.yml \
  up -d --scale backend=5
```

### Configuracao do nginx Load Balancer

O modo HA inclui nginx com a seguinte configuracao:

| Rota | Destino | Descricao |
|------|---------|-----------|
| `/api/*` | upstream `pix-backend` | API REST do backend |
| `/socket/*` | upstream `pix-backend` | WebSocket (upgrade automatico) |
| `/health` | upstream `pix-backend` | Health check |
| `/metrics` | upstream `pix-backend` | Metricas Prometheus |
| `/*` | upstream `pix-admin` | Portal Admin (SPA Vue) |

**Recursos do nginx HA:**
- TLS 1.2/1.3 com cifras seguras
- Redirect automatico HTTP --> HTTPS
- WebSocket upgrade para `/socket`
- Health checks com failover automatico (`proxy_next_upstream`)
- Compressao gzip habilitada
- Logs com informacoes de upstream

### Limites de Recursos (HA)

| Servico | CPU Request | CPU Limit | RAM Request | RAM Limit |
|---------|------------|-----------|-------------|-----------|
| Backend (x3) | 1.0 | 2.0 | 1 GB | 2 GB |
| Admin (x2) | 0.25 | 0.5 | 256 MB | 512 MB |

## Health Checks

### Verificacao Completa

```bash
# Status de todos os containers
docker compose ps

# Logs do backend (ultimas 50 linhas)
docker compose logs --tail=50 backend

# Health check do backend
curl -s http://localhost:4003/health

# Metricas Prometheus
curl -s http://localhost:4003/metrics | grep pix_

# NATS JetStream streams (modo dev)
curl -s http://localhost:8222/jsz | python3 -m json.tool
```

### Health Check Automatico

O backend possui health check configurado no Docker Compose:

```yaml
healthcheck:
  test: ["CMD", "curl", "-f", "http://localhost:4003/health"]
  interval: 30s
  timeout: 10s
  retries: 3
  start_period: 40s
```

## Migrations e Seeds

### Executar Migrations

```bash
# Modo producao
docker compose exec backend bin/monetarie_pix eval "Shared.Release.migrate()"

# Modo dev
docker compose -f docker-compose.yml -f docker-compose.dev.yml \
  exec backend bin/monetarie_pix eval "Shared.Release.migrate()"
```

### Executar Seeds

```bash
docker compose exec backend bin/monetarie_pix eval "Shared.Release.seed()"
```

### Rollback de Migration

```bash
# Rollback da ultima migration
docker compose exec backend bin/monetarie_pix eval \
  "Shared.Release.rollback(Shared.Repo, 1)"
```

## Backup e Restore

### Backup do PostgreSQL

```bash
# Modo dev (PostgreSQL em container)
docker compose -f docker-compose.yml -f docker-compose.dev.yml \
  exec postgres pg_dump -U postgres monetarie > backup_$(date +%Y%m%d).sql

# Modo producao (PostgreSQL externo)
pg_dump -h <DB_HOST> -U postgres monetarie > backup_$(date +%Y%m%d).sql
```

### Restore do PostgreSQL

```bash
# Modo dev
docker compose -f docker-compose.yml -f docker-compose.dev.yml \
  exec -T postgres psql -U postgres monetarie < backup_20260213.sql

# Modo producao
psql -h <DB_HOST> -U postgres monetarie < backup_20260213.sql
```

### Backup de Volumes Docker

```bash
# Listar volumes
docker volume ls | grep pix

# Backup de volume
docker run --rm -v deploy-docker-compose_pgdata:/data \
  -v $(pwd):/backup alpine tar czf /backup/pgdata_backup.tar.gz /data
```

## Monitoramento

### Endpoint Prometheus

O backend expoe metricas Prometheus em `/metrics`:

```bash
curl -s http://localhost:4003/metrics | head -20
```

Metricas disponiveis:
- `pix_http_request_duration_seconds` — Duracao de requisicoes HTTP
- `pix_db_pool_size` — Tamanho do pool de conexoes
- `pix_worker_message_processed_total` — Mensagens processadas por worker
- `pix_worker_batch_completed_total` — Batches completados
- `pix_circuit_breaker_state` — Estado do circuit breaker

### Configuracao Prometheus (Exemplo)

```yaml
# prometheus.yml
scrape_configs:
  - job_name: 'monetarie-pix'
    scrape_interval: 15s
    static_configs:
      - targets: ['localhost:4003']
    metrics_path: /metrics
```

## Atualizacao

### Atualizar Imagens

```bash
# Parar servicos
docker compose down

# Atualizar imagens
docker compose pull

# Iniciar novamente
docker compose up -d

# Executar migrations (se houver novas)
docker compose exec backend bin/monetarie_pix eval "Shared.Release.migrate()"
```

### Atualizacao Zero-Downtime (Modo HA)

```bash
# Atualizar imagem no .env
# PIX_BACKEND_IMAGE=monetarie/pix-backend:v1.1.0

# Rolling update (1 container por vez)
docker compose -f docker-compose.yml -f docker-compose.ha.yml \
  up -d --no-recreate --scale backend=3

# Forcar recriacao com nova imagem
docker compose -f docker-compose.yml -f docker-compose.ha.yml \
  up -d --force-recreate backend
```

## Resultado Esperado

Ao final deste guia, voce tera:

- Monetarie PIX rodando em Docker Compose no modo escolhido (producao, dev ou HA)
- Configuracao de ambiente validada com health checks
- Banco de dados migrado e populado com dados de referencia
- Capacidade de realizar backup, restore e atualizacao dos servicos
- Monitoramento basico via endpoint Prometheus