# Docker Compose Deployment

Deploy FluxiQ PIX using Docker Compose for development, testing, or small-scale production environments.

## Prerequisites

- Docker 24+ with Docker Compose v2
- 8 GB RAM (development) or 32 GB RAM (production)
- Ports 4001-4003, 5432, 6379, 4222 available

## Development Environment

### docker-compose.yml

```yaml
version: "3.8"

services:
  postgres:
    image: postgres:16-alpine
    environment:
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: postgres
      POSTGRES_DB: monetarie
    ports:
      - "5432:5432"
    volumes:
      - pgdata:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U postgres"]
      interval: 5s
      timeout: 3s
      retries: 10

  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 5s
      timeout: 3s
      retries: 5

  nats:
    image: nats:2.10-alpine
    command: ["--jetstream", "--store_dir=/data"]
    ports:
      - "4222:4222"
      - "8222:8222"
    volumes:
      - natsdata:/data

  pix-backend:
    image: pix-backend:latest
    build:
      context: ./backend
      dockerfile: Dockerfile
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_healthy
      nats:
        condition: service_started
    ports:
      - "4001:4001"
      - "4002:4002"
      - "4003:4003"
    environment:
      DB_HOST: postgres
      DB_PORT: "5432"
      DB_USER: postgres
      DB_PASS: postgres
      DB_NAME: monetarie
      REDIS_HOST: redis
      REDIS_PORT: "6379"
      NATS_HOST: nats
      NATS_PORT: "4222"
      NATS_ENABLED: "true"
      SECRET_KEY_BASE: "dev-only-secret-key-base-replace-in-production-min-64-chars!!"
      SIMULATOR_ENABLED: "true"
      BACEN_ENABLED: "false"
      MIX_ENV: prod

volumes:
  pgdata:
  natsdata:
```

### Start and Initialize

```bash
# Start all services
docker compose up -d

# Wait for backend to be ready
docker compose logs -f pix-backend

# Run migrations
docker compose exec pix-backend bin/monetarie_pix eval "Shared.Release.migrate()"

# Seed data
docker compose exec pix-backend bin/monetarie_pix eval "Shared.Release.seed()"
```

## Production Environment

For production Docker Compose deployments, add the following enhancements:

### Resource Limits

```yaml
services:
  pix-backend:
    deploy:
      resources:
        limits:
          cpus: "4"
          memory: 4G
        reservations:
          cpus: "2"
          memory: 2G
    restart: always

  postgres:
    deploy:
      resources:
        limits:
          cpus: "4"
          memory: 8G
    command: >
      postgres
        -c max_connections=6000
        -c shared_buffers=2GB
        -c effective_cache_size=6GB
        -c work_mem=64MB
```

### TLS Configuration

```yaml
services:
  nginx:
    image: nginx:1.25-alpine
    ports:
      - "443:443"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf:ro
      - ./certs:/etc/ssl/certs:ro
    depends_on:
      - pix-backend
```

### High Availability (Docker Compose)

For HA with Docker Compose, deploy multiple backend instances behind a load balancer:

```yaml
services:
  pix-backend-1:
    <<: *backend-base
    hostname: pix-backend-1

  pix-backend-2:
    <<: *backend-base
    hostname: pix-backend-2

  haproxy:
    image: haproxy:2.9
    ports:
      - "4003:4003"
    volumes:
      - ./haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro
```

## Monitoring (Optional)

Add Prometheus and Grafana for observability:

```yaml
services:
  prometheus:
    image: prom/prometheus:v2.50.0
    ports:
      - "9090:9090"
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml:ro

  grafana:
    image: grafana/grafana:10.3.0
    ports:
      - "3000:3000"
    environment:
      GF_SECURITY_ADMIN_PASSWORD: admin
```

## Useful Commands

```bash
# View logs
docker compose logs -f pix-backend

# Restart backend
docker compose restart pix-backend

# Run database migration
docker compose exec pix-backend bin/monetarie_pix eval "Shared.Release.migrate()"

# Open PostgreSQL shell
docker compose exec postgres psql -U postgres -d monetarie

# Check NATS streams
docker compose exec nats nats stream ls

# Stop everything (preserve data)
docker compose down

# Stop everything (delete data)
docker compose down -v
```

## Expected Outcome

After completing this deployment:

- All services are running and healthy
- The database has 25 migrations applied and seed data loaded
- The backend API is accessible on port 4003
- NATS JetStream has 7 streams configured
- Health checks pass on all endpoints