docker-compose.yml

x-logging: &default_logging
  driver: json-file
  options:
    max-size: "10m"
    max-file: "3"

x-app-env: &app_env
  DEBUG: "false"
  DATABASE_ECHO: "false"

  DATABASE_HOST: ${DATABASE_HOST:-postgres}
  DATABASE_PORT: ${DATABASE_PORT:-5432}
  REDIS_HOST: ${REDIS_HOST:-redis}
  REDIS_PORT: ${REDIS_PORT:-6379}

  S3_ENDPOINT: ${S3_ENDPOINT:-http://minio:9000}
  S3_REGION: ${S3_REGION:-us-east-1}
  S3_BUCKET: ${S3_BUCKET:-app-bucket}
  S3_USE_SSL: ${S3_USE_SSL:-false}
  S3_PATH_STYLE: ${S3_PATH_STYLE:-true}
  S3_PUBLIC_BASE_URL: ${S3_PUBLIC_BASE_URL:-http://localhost:9000/${S3_BUCKET:-app-bucket}}
  S3_PRESIGN_TTL: ${S3_PRESIGN_TTL:-300}

x-app-common: &app_common
  build:
    context: .
    dockerfile: Dockerfile
  restart: unless-stopped
  init: true
  env_file:
    - .env
  environment:
    <<: *app_env
  networks:
    - internal
  logging: *default_logging
  depends_on:
    postgres:
      condition: service_healthy
    redis:
      condition: service_healthy
    minio:
      condition: service_healthy
    minio-setup:
      condition: service_completed_successfully

services:
  postgres:
    image: postgres:18.0-alpine
    container_name: postgres_db
    restart: unless-stopped
    environment:
      POSTGRES_USER: ${POSTGRES_USER:-admin}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-admin123}
      POSTGRES_DB: ${POSTGRES_DB:-sampledb}
    volumes:
      - postgres_data:/var/lib/postgresql/data
      - ./postgres_init:/docker-entrypoint-initdb.d:ro
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U $${POSTGRES_USER} -d $${POSTGRES_DB}"]
      interval: 10s
      timeout: 5s
      retries: 10
    networks:
      - internal
    logging: *default_logging

  redis:
    image: redis:7.2-alpine
    container_name: redis
    restart: unless-stopped
    command: ["redis-server", "--appendonly", "yes"]
    volumes:
      - redis_data:/data
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 10s
      timeout: 3s
      retries: 10
    networks:
      - internal
    logging: *default_logging

  minio:
    image: minio/minio:latest
    container_name: minio
    restart: unless-stopped
    environment:
      MINIO_ROOT_USER: ${MINIO_ROOT_USER:-minioadmin}
      MINIO_ROOT_PASSWORD: ${MINIO_ROOT_PASSWORD:-minioadmin}
    command: server --console-address ":9001" /data
    volumes:
      - minio_data:/data
      - minio_config:/root/.minio
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:9000/minio/health/ready"]
      interval: 10s
      timeout: 5s
      retries: 10
    networks:
      - internal
    logging: *default_logging
    ports:
      - "9000:9000"
      - "127.0.0.1:9001:9001"

  minio-setup:
    image: minio/mc:latest
    container_name: minio_setup
    restart: "no"
    network_mode: "service:minio"
    env_file:
      - .env
    environment:
      MINIO_ROOT_USER: ${MINIO_ROOT_USER:-minioadmin}
      MINIO_ROOT_PASSWORD: ${MINIO_ROOT_PASSWORD:-minioadmin}
      S3_BUCKET: ${S3_BUCKET:-app-bucket}
    depends_on:
      minio:
        condition: service_healthy
    entrypoint: >
      sh -c "
      mc alias set local http://localhost:9000 $${MINIO_ROOT_USER} $${MINIO_ROOT_PASSWORD} &&
      mc mb -p local/$${S3_BUCKET} || true &&
      mc anonymous set download local/$${S3_BUCKET} || true
      "

  evolution_api:
    container_name: evolution_api
    image: evoapicloud/evolution-api:latest
    restart: unless-stopped
    depends_on:
      redis:
        condition: service_healthy
      postgres:
        condition: service_healthy
    networks:
      - internal
    logging: *default_logging
    ports:
      - "127.0.0.1:8080:8080"
    volumes:
      - evolution_instances:/evolution/instances
    environment:
      SERVER_TYPE: http
      SERVER_PORT: 8080
      SERVER_URL: ${EVOLUTION_SERVER_URL:-http://localhost:8080}
      CORS_ORIGIN: "*"
      CORS_METHODS: GET,POST,PUT,DELETE
      CORS_CREDENTIALS: "true"
      DATABASE_PROVIDER: postgresql
      CACHE_REDIS_ENABLED: "true"
      CACHE_REDIS_URI: redis://redis:6379/6
      DATABASE_CONNECTION_URI: ${EVOLUTION_DATABASE_URI:-postgresql://evo_user:evo_pass@postgres:5432/evo_db?schema=public}

  rabbitmq:
    image: rabbitmq:3.13-management-alpine
    container_name: rabbitmq
    restart: unless-stopped
    volumes:
      - rabbitmq_data:/var/lib/rabbitmq
    healthcheck:
      test: ["CMD", "rabbitmq-diagnostics", "-q", "ping"]
      interval: 10s
      timeout: 5s
      retries: 10
    networks:
      - internal
    logging: *default_logging
    environment:
      RABBITMQ_DEFAULT_USER: ${RABBITMQ_USER:-guest}
      RABBITMQ_DEFAULT_PASS: ${RABBITMQ_PASS:-guest}

  backend:
    <<: *app_common
    container_name: app_backend
    ports:
      - "127.0.0.1:8000:8000"
    command: ["uv", "run", "uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000", "--workers", "${WEB_CONCURRENCY:-2}"]

  worker_dispatch_outbox_events:
    <<: *app_common
    container_name: worker_dispatch_outbox_events
    command:
      [
        "uv", "run", "python", "-m", "app.workers",
        "--job", "dispatch_outbox_events",
        "--interval", "${DISPATCH_OUTBOX_EVENTS_INTERVAL_SECONDS:-2}",
        "--batch-size", "${DISPATCH_OUTBOX_EVENTS_BATCH_SIZE:-50}"
      ]

  rabbitmq_consumer:
    <<: *app_common
    container_name: rabbitmq_consumer
    command: ["uv", "run", "python", "-m", "app.consumer"]
    depends_on:
      rabbitmq:
        condition: service_healthy

networks:
  internal:
    driver: bridge

volumes:
  postgres_data:
  redis_data:
  minio_data:
  minio_config:
  evolution_instances:
  rabbitmq_data: