docker-compose.yml

# docker-compose.yml -- Local full-stack development infrastructure
# DO NOT put real secrets here. Use .env file (see .env.example).

x-backend-health: &backend-health
  interval: 10s
  timeout: 5s
  retries: 5
  start_period: 20s

services:
  postgres:
    image: timescale/timescaledb:latest-pg15
    environment:
      POSTGRES_DB: ${POSTGRES_DB:-agtech}
      POSTGRES_USER: ${POSTGRES_USER:-agtech}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?Set POSTGRES_PASSWORD in .env}
    volumes:
      - pg_data:/var/lib/postgresql/data
    ports:
      - "${POSTGRES_PORT:-5432}:5432"
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER:-agtech} -d ${POSTGRES_DB:-agtech}"]
      interval: 10s
      timeout: 5s
      retries: 5

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

  minio:
    image: minio/minio
    command: server /data --console-address ":9001"
    environment:
      MINIO_ROOT_USER: ${MINIO_ACCESS_KEY:?Set MINIO_ACCESS_KEY in .env}
      MINIO_ROOT_PASSWORD: ${MINIO_SECRET_KEY:?Set MINIO_SECRET_KEY in .env}
    volumes:
      - minio_data:/data
    ports:
      - "${MINIO_PORT:-9000}:9000"
      - "${MINIO_CONSOLE_PORT:-9001}:9001"
    healthcheck:
      test: ["CMD", "mc", "ready", "local"]
      interval: 10s
      timeout: 5s
      retries: 5
      start_period: 10s

  minio-init:
    image: minio/mc
    profiles: ["init"]
    depends_on:
      minio:
        condition: service_healthy
    environment:
      MINIO_ACCESS_KEY: ${MINIO_ACCESS_KEY:?Set MINIO_ACCESS_KEY in .env}
      MINIO_SECRET_KEY: ${MINIO_SECRET_KEY:?Set MINIO_SECRET_KEY in .env}
    entrypoint: >
      /bin/sh -c "
      mc alias set local http://minio:9000 $$MINIO_ACCESS_KEY $$MINIO_SECRET_KEY &&
      mc mb --ignore-existing local/models &&
      mc mb --ignore-existing local/raw-images &&
      mc mb --ignore-existing local/aligned-features &&
      mc mb --ignore-existing local/exports
      "

  mosquitto:
    image: eclipse-mosquitto:2
    command: mosquitto -c /mosquitto-no-auth.conf
    ports:
      - "${MQTT_PORT:-1883}:1883"
    healthcheck:
      test: ["CMD-SHELL", "mosquitto_sub -h localhost -t '$$SYS/#' -C 1 -W 3 >/dev/null 2>&1 || exit 1"]
      interval: 10s
      timeout: 5s
      retries: 5

  db-migrate:
    build:
      context: .
      dockerfile: backend/api_gateway/Dockerfile
    profiles: ["init"]
    env_file: .env
    environment:
      DATABASE_URL: ${DATABASE_URL_DOCKER:-postgresql://${POSTGRES_USER:-agtech}:${POSTGRES_PASSWORD}@postgres:5432/${POSTGRES_DB:-agtech}}
    depends_on:
      postgres:
        condition: service_healthy
    command: alembic -c /app/alembic.ini upgrade head
    working_dir: /app

  db-seed:
    build:
      context: .
      dockerfile: backend/api_gateway/Dockerfile
    profiles: ["init"]
    env_file: .env
    environment:
      DATABASE_URL: ${DATABASE_URL_DOCKER:-postgresql://${POSTGRES_USER:-agtech}:${POSTGRES_PASSWORD}@postgres:5432/${POSTGRES_DB:-agtech}}
    depends_on:
      postgres:
        condition: service_healthy
    command: python scripts/seed_zones.py
    working_dir: /app

  ai-serving:
    build:
      context: .
      dockerfile: backend/ai_serving/Dockerfile
    env_file: .env
    ports:
      - "${AI_SERVING_PORT:-8001}:8001"
    depends_on:
      minio:
        condition: service_healthy
    command: uvicorn backend.ai_serving.main:app --host 0.0.0.0 --port 8001
    healthcheck:
      <<: *backend-health
      test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:8001/healthz', timeout=2)"]

  decision-engine:
    build:
      context: .
      dockerfile: backend/decision_engine/Dockerfile
    env_file: .env
    ports:
      - "${DECISION_ENGINE_PORT:-8002}:8002"
    depends_on:
      redis:
        condition: service_healthy
    command: uvicorn backend.decision_engine.main:app --host 0.0.0.0 --port 8002
    healthcheck:
      <<: *backend-health
      test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:8002/healthz', timeout=2)"]

  ingestion-service:
    build:
      context: .
      dockerfile: backend/ingestion_service/Dockerfile
    env_file: .env
    environment:
      DATABASE_URL: ${DATABASE_URL_DOCKER:-postgresql://${POSTGRES_USER:-agtech}:${POSTGRES_PASSWORD}@postgres:5432/${POSTGRES_DB:-agtech}}
      REDIS_URL: redis://redis:6379/0
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_healthy
    command: uvicorn backend.ingestion_service.main:app --host 0.0.0.0 --port 8003
    ports:
      - "${INGESTION_SERVICE_PORT:-8003}:8003"
    healthcheck:
      <<: *backend-health
      test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:8003/healthz', timeout=2)"]

  api-gateway:
    build:
      context: .
      dockerfile: backend/api_gateway/Dockerfile
    env_file: .env
    environment:
      DATABASE_URL: ${DATABASE_URL_DOCKER:-postgresql://${POSTGRES_USER:-agtech}:${POSTGRES_PASSWORD}@postgres:5432/${POSTGRES_DB:-agtech}}
      REDIS_URL: redis://redis:6379/0
      AI_SERVING_URL: http://ai-serving:8001
      INGESTION_SERVICE_URL: http://ingestion-service:8003
      ALERT_TELEGRAM_ENABLED: ${ALERT_TELEGRAM_ENABLED:-false}
      TELEGRAM_BOT_TOKEN: ${TELEGRAM_BOT_TOKEN:-}
      TELEGRAM_CHAT_ID: ${TELEGRAM_CHAT_ID:-}
      CORS_ORIGINS: ${CORS_ORIGINS:-http://localhost:3000,http://localhost:8080}
      IMAGERY_POLL_INTERVAL_SECONDS: ${IMAGERY_POLL_INTERVAL_SECONDS:-0}
    ports:
      - "${API_GATEWAY_PORT:-8000}:8000"
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_healthy
      ai-serving:
        condition: service_healthy
      ingestion-service:
        condition: service_healthy
      decision-engine:
        condition: service_healthy
    command: uvicorn backend.api_gateway.main:app --host 0.0.0.0 --port 8000
    healthcheck:
      <<: *backend-health
      test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:8000/v1/healthz', timeout=2)"]

  frontend:
    build:
      context: .
      dockerfile: frontend/Dockerfile
      args:
        VITE_API_BASE_URL: ${VITE_API_BASE_URL:-http://localhost:8000}
        VITE_WS_URL: ${VITE_WS_URL:-ws://localhost:8000/ws/updates}
    ports:
      - "${FRONTEND_PORT:-8080}:80"
    depends_on:
      api-gateway:
        condition: service_healthy
    healthcheck:
      test: ["CMD", "wget", "--spider", "-q", "http://127.0.0.1/healthz"]
      interval: 10s
      timeout: 5s
      retries: 5
      start_period: 10s

  data-collector:
    build:
      context: .
      dockerfile: backend/api_gateway/Dockerfile
    profiles: ["data"]
    env_file: .env
    command: python scripts/run_data_collection.py --dry-run
    working_dir: /app
    volumes:
      - ./data:/app/data
      - ./reports:/app/reports

  model-exporter:
    build:
      context: .
      dockerfile: backend/ai_serving/Dockerfile
    profiles: ["ml"]
    env_file: .env
    command: python ml_pipeline/export/export_onnx.py --dry-run
    working_dir: /app
    volumes:
      - ./artifacts:/app/artifacts

volumes:
  pg_data:
  minio_data: