docker-compose.microservices.prod.yml

# Production microservices stack — RabbitMQ + orchestrator + stage workers.
# External S3/GCS (no MinIO). No Celery / Redis / Flower.
#
#   docker compose --env-file .env.production \
#     -f docker-compose.microservices.prod.yml \
#     -f docker-compose.microservices.gpu.yml \
#     -f docker-compose.observability.yml up -d --build
#
# Set COMPOSE_ENABLE_GPU=true to merge docker-compose.microservices.gpu.yml (CUDA inference).
# Set COMPOSE_PROFILES=observability in .env.production to start the LGTM stack.

x-otel-env: &otel-env
  OTEL_EXPORTER_OTLP_ENDPOINT: http://otel-collector:4317

x-worker-log-env: &worker-log-env
  LOG_JSON_FORMAT: ${LOG_JSON_FORMAT:-true}

x-s3-env: &s3-env
  STORAGE_BACKEND: ${STORAGE_BACKEND:-s3}
  S3_ENDPOINT_URL: ${S3_ENDPOINT_URL:?S3_ENDPOINT_URL is required}
  S3_ACCESS_KEY_ID: ${S3_ACCESS_KEY_ID:?S3_ACCESS_KEY_ID is required}
  S3_SECRET_ACCESS_KEY: ${S3_SECRET_ACCESS_KEY:?S3_SECRET_ACCESS_KEY is required}
  S3_REGION: ${S3_REGION:-us-east-1}
  S3_SECURE: ${S3_SECURE:-true}
  S3_MEDIA_BUCKET: ${S3_MEDIA_BUCKET:?S3_MEDIA_BUCKET is required}
  S3_MODELS_BUCKET: ${S3_MODELS_BUCKET:?S3_MODELS_BUCKET is required}

x-model-cache-env: &model-cache-env
  HF_HOME: ${HF_HOME:-/model-cache/hf}
  HUGGINGFACE_HUB_CACHE: ${HUGGINGFACE_HUB_CACHE:-/model-cache/hf/hub}
  TRANSFORMERS_CACHE: ${TRANSFORMERS_CACHE:-/model-cache/hf/transformers}
  XDG_CACHE_HOME: ${XDG_CACHE_HOME:-/model-cache/xdg-cache}
  TORCH_HOME: ${TORCH_HOME:-/model-cache/torch}
  CATT_TASHKEEL_MODEL_DIR: ${CATT_TASHKEEL_MODEL_DIR:-/model-cache/catt_tashkeel/onnx_models}
  HF_TOKEN: ${HF_TOKEN:-}
  HF_HUB_DISABLE_XET: ${HF_HUB_DISABLE_XET:-1}
  HF_HUB_DOWNLOAD_TIMEOUT: ${HF_HUB_DOWNLOAD_TIMEOUT:-120}

services:
  caddy:
    image: caddy:2.10-alpine
    container_name: dabljaar_caddy
    ports:
      - "80:80"
      - "443:443"
      - "443:443/udp"
      - "127.0.0.1:2019:2019"
    environment:
      DOMAIN: ${DOMAIN:?DOMAIN is required for production}
      ACME_EMAIL: ${ACME_EMAIL:?ACME_EMAIL is required for production}
    depends_on:
      backend:
        condition: service_healthy
    healthcheck:
      test: ["CMD", "wget", "--spider", "-q", "http://127.0.0.1:2019/config/"]
      interval: 30s
      timeout: 5s
      retries: 3
      start_period: 30s
    restart: unless-stopped
    volumes:
      - ./Caddyfile.production:/etc/caddy/Caddyfile:ro
      - ./frontend/dist:/srv:ro
      - caddy_data:/data
      - caddy_config:/config
    security_opt:
      - no-new-privileges:true
    networks:
      - dabljaar_network

  postgres:
    image: postgres:16-alpine
    container_name: dabljaar_postgres
    environment:
      POSTGRES_USER: ${POSTGRES_USER:-postgres}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?POSTGRES_PASSWORD is required}
      POSTGRES_DB: ${POSTGRES_DB:-dabljaar}
    volumes:
      - dabljaar_postgres_data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER:-postgres} -d ${POSTGRES_DB:-dabljaar}"]
      interval: 10s
      timeout: 5s
      retries: 5
    restart: unless-stopped
    security_opt:
      - no-new-privileges:true
    networks:
      - dabljaar_network

  rabbitmq:
    image: rabbitmq:3-management-alpine
    container_name: dabljaar_rabbitmq
    ports: []
    environment:
      RABBITMQ_DEFAULT_USER: ${RABBITMQ_DEFAULT_USER:-dabljaar}
      RABBITMQ_DEFAULT_PASS: ${RABBITMQ_DEFAULT_PASS:?RABBITMQ_DEFAULT_PASS is required}
    volumes:
      - ./infra/rabbitmq/rabbitmq.conf:/etc/rabbitmq/rabbitmq.conf:ro
      - ./infra/rabbitmq/enabled_plugins:/etc/rabbitmq/enabled_plugins:ro
      - rabbitmq_data:/var/lib/rabbitmq
    healthcheck:
      test: ["CMD", "rabbitmq-diagnostics", "-q", "ping"]
      interval: 10s
      timeout: 5s
      retries: 5
    restart: unless-stopped
    security_opt:
      - no-new-privileges:true
    networks:
      - dabljaar_network

  orchestrator:
    build:
      context: ./orchestrator
      dockerfile: Dockerfile
    container_name: dabljaar_orchestrator
    environment:
      RABBITMQ_URL: ${RABBITMQ_URL:?RABBITMQ_URL is required}
      DATABASE_URL: postgres://${POSTGRES_USER:-postgres}:${POSTGRES_PASSWORD}@postgres:5432/${POSTGRES_DB:-dabljaar}?sslmode=disable
      HEALTH_PORT: "8081"
      <<: *otel-env
      OTEL_SERVICE_NAME: orchestrator
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8081/readiness"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 30s
    depends_on:
      rabbitmq:
        condition: service_healthy
      postgres:
        condition: service_healthy
    restart: unless-stopped
    security_opt:
      - no-new-privileges:true
    networks:
      - dabljaar_network

  stt-service:
    build:
      context: ./stt-service
      dockerfile: Dockerfile
      additional_contexts:
        shared: ./libs/dablja-worker
        segments: ./libs/dablja-segments
        docker_torch: ./libs/docker-torch
    container_name: dabljaar_stt_service
    environment:
      <<: [*s3-env, *model-cache-env, *worker-log-env, *otel-env]
      RABBITMQ_URL: ${RABBITMQ_URL}
      DATABASE_URL: postgresql+psycopg2://${POSTGRES_USER:-postgres}:${POSTGRES_PASSWORD}@postgres:5432/${POSTGRES_DB:-dabljaar}
      SERVICE_NAME: stt
      OTEL_SERVICE_NAME: stt
      STT_MODEL_SIZE: ${STT_MODEL_SIZE:-medium}
      STT_MODEL_KEY: ${STT_MODEL_KEY:-whisper-medium}
      STT_MODEL_LOCAL_PATH: ${STT_MODEL_LOCAL_PATH:-/model-cache/whisper-medium}
      STT_DEVICE: ${STT_DEVICE:-cpu}
      STT_COMPUTE_TYPE: ${STT_COMPUTE_TYPE:-auto}
      STT_ALLOW_HF_FALLBACK: ${STT_ALLOW_HF_FALLBACK:-false}
      PREWARM_STT_MODEL: ${PREWARM_STT_MODEL:-true}
      DUBBING_TUNE_ENABLED: ${DUBBING_TUNE_ENABLED:-true}
      STT_SEGMENT_MIN_WORDS: ${STT_SEGMENT_MIN_WORDS:-10}
      STT_SEGMENT_MAX_WORDS: ${STT_SEGMENT_MAX_WORDS:-1000}
      STT_VAD_MIN_SILENCE_MS: ${STT_VAD_MIN_SILENCE_MS:-300}
      STT_BEAM_SIZE: ${STT_BEAM_SIZE:-5}
      STT_CONDITION_ON_PREVIOUS_TEXT: ${STT_CONDITION_ON_PREVIOUS_TEXT:-true}
      STT_COMPUTE_PAUSE_AFTER: ${STT_COMPUTE_PAUSE_AFTER:-true}
      PORT: 8001
    volumes:
      - ai_model_cache:/model-cache
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8001/readiness"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 300s
    depends_on:
      rabbitmq:
        condition: service_healthy
      postgres:
        condition: service_healthy
    # AI services need time to finish in-flight requests and flush model state.
    stop_grace_period: 120s
    mem_limit: ${STT_MEM_LIMIT:-8g}
    restart: unless-stopped
    security_opt:
      - no-new-privileges:true
    networks:
      - dabljaar_network

  nmt-service:
    build:
      context: ./nmt-service
      dockerfile: Dockerfile
      additional_contexts:
        shared: ./libs/dablja-worker
        docker_torch: ./libs/docker-torch
    container_name: dabljaar_nmt_service
    environment:
      <<: [*s3-env, *model-cache-env, *worker-log-env, *otel-env]
      RABBITMQ_URL: ${RABBITMQ_URL}
      DATABASE_URL: postgresql+psycopg2://${POSTGRES_USER:-postgres}:${POSTGRES_PASSWORD}@postgres:5432/${POSTGRES_DB:-dabljaar}
      SERVICE_NAME: nmt
      OTEL_SERVICE_NAME: nmt
      NMT_MODEL_KEY: ${NMT_MODEL_KEY:-nmt-v4}
      NMT_MODEL_LOCAL_PATH: ${NMT_MODEL_LOCAL_PATH:-/model-cache/nmt-v4}
      NMT_HF_FALLBACK: ${NMT_HF_FALLBACK:-facebook/nllb-200-distilled-600M}
      NMT_ALLOW_HF_FALLBACK: ${NMT_ALLOW_HF_FALLBACK:-false}
      NMT_FALLBACK_MODE: ${NMT_FALLBACK_MODE:-stage2_only}
      NMT_DEFAULT_NUM_BEAMS: ${NMT_DEFAULT_NUM_BEAMS:-5}
      NMT_MAX_LENGTH: ${NMT_MAX_LENGTH:-200}
      GROQ_API_KEY: ${GROQ_API_KEY:-}
      GROQ_MODEL: ${GROQ_MODEL:-llama-3.3-70b-versatile}
      NMT_LENGTH_ADJUST_ENABLED: ${NMT_LENGTH_ADJUST_ENABLED:-true}
      NMT_LENGTH_ADJUST_SCALE: ${NMT_LENGTH_ADJUST_SCALE:-1.0}
      NMT_LENGTH_ADJUST_TOLERANCE_PCT: ${NMT_LENGTH_ADJUST_TOLERANCE_PCT:-20}
      NMT_LENGTH_ADJUST_MAX_ITERS: ${NMT_LENGTH_ADJUST_MAX_ITERS:-5}
      DUBBING_TUNE_ENABLED: ${DUBBING_TUNE_ENABLED:-true}
      PREWARM_NMT_MODEL: ${PREWARM_NMT_MODEL:-true}
      PORT: 8002
    volumes:
      - ai_model_cache:/model-cache
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8002/readiness"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 300s
    depends_on:
      rabbitmq:
        condition: service_healthy
      postgres:
        condition: service_healthy
    stop_grace_period: 120s
    mem_limit: ${NMT_MEM_LIMIT:-4g}
    restart: unless-stopped
    security_opt:
      - no-new-privileges:true
    networks:
      - dabljaar_network

  tts-service:
    build:
      context: ./tts-service
      dockerfile: Dockerfile
      additional_contexts:
        shared: ./libs/dablja-worker
        segments: ./libs/dablja-segments
        docker_torch: ./libs/docker-torch
        docker_onnx: ./libs/docker-onnx
    container_name: dabljaar_tts_service
    environment:
      <<: [*s3-env, *model-cache-env, *worker-log-env, *otel-env]
      RABBITMQ_URL: ${RABBITMQ_URL}
      DATABASE_URL: postgresql+psycopg2://${POSTGRES_USER:-postgres}:${POSTGRES_PASSWORD}@postgres:5432/${POSTGRES_DB:-dabljaar}
      SERVICE_NAME: tts
      OTEL_SERVICE_NAME: tts
      OMNIVOICE_MODEL_NAME: ${OMNIVOICE_MODEL_NAME:-k2-fsa/OmniVoice}
      OMNIVOICE_DEVICE: ${OMNIVOICE_DEVICE:-cpu}
      OMNIVOICE_DTYPE: ${OMNIVOICE_DTYPE:-float16}
      OMNIVOICE_NUM_STEP: ${OMNIVOICE_NUM_STEP:-32}
      OMNIVOICE_GUIDANCE_SCALE: ${OMNIVOICE_GUIDANCE_SCALE:-2.0}
      OMNIVOICE_SPEED: ${OMNIVOICE_SPEED:-1.0}
      PREWARM_TTS_MODEL: ${PREWARM_TTS_MODEL:-true}
      DUBBING_TUNE_ENABLED: ${DUBBING_TUNE_ENABLED:-true}
      TTS_GROUP_BY_PAUSE: ${TTS_GROUP_BY_PAUSE:-true}
      TTS_USE_DURATION_HINT: ${TTS_USE_DURATION_HINT:-true}
      TTS_MAX_ACCUMULATED_PAUSE: ${TTS_MAX_ACCUMULATED_PAUSE:-1.5}
      TTS_COMBINE_MODE: ${TTS_COMBINE_MODE:-demo}
      TTS_MERGE_MIN_WORDS: ${TTS_MERGE_MIN_WORDS:-0}
      DUBBING_SILENCE_THRESHOLD: ${DUBBING_SILENCE_THRESHOLD:-0.0}
      PORT: 8005
    volumes:
      - ai_model_cache:/model-cache
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8005/readiness"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 600s
    depends_on:
      rabbitmq:
        condition: service_healthy
      postgres:
        condition: service_healthy
    # TTS loads large models; allow time to finish in-flight synthesis jobs.
    stop_grace_period: 180s
    mem_limit: ${TTS_MEM_LIMIT:-10g}
    restart: unless-stopped
    security_opt:
      - no-new-privileges:true
    networks:
      - dabljaar_network

  media-service:
    build:
      context: ./media-service
      dockerfile: Dockerfile
      additional_contexts:
        shared: ./libs/dablja-worker
    container_name: dabljaar_media_service
    environment:
      <<: [*s3-env, *worker-log-env, *otel-env]
      RABBITMQ_URL: ${RABBITMQ_URL}
      DATABASE_URL: postgresql+psycopg2://${POSTGRES_USER:-postgres}:${POSTGRES_PASSWORD}@postgres:5432/${POSTGRES_DB:-dabljaar}
      SERVICE_NAME: media
      OTEL_SERVICE_NAME: media
      AWS_ENDPOINT_URL: ${S3_ENDPOINT_URL}
      AWS_ACCESS_KEY_ID: ${S3_ACCESS_KEY_ID}
      AWS_SECRET_ACCESS_KEY: ${S3_SECRET_ACCESS_KEY}
      AWS_DEFAULT_REGION: ${S3_REGION:-us-east-1}
      S3_MEDIA_BUCKET: ${S3_MEDIA_BUCKET}
      MERGE_TEMP_DIR: /tmp/dubbing_merge
      LOG_LEVEL: INFO
      PORT: 8003
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8003/readiness"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 60s
    depends_on:
      rabbitmq:
        condition: service_healthy
      postgres:
        condition: service_healthy
    tmpfs:
      - /tmp
    restart: unless-stopped
    security_opt:
      - no-new-privileges:true
    networks:
      - dabljaar_network

  youtube-pot:
    image: brainicism/bgutil-ytdlp-pot-provider:1.3.1
    container_name: dabljaar_youtube_pot
    init: true
    restart: unless-stopped
    healthcheck:
      test: ["CMD-SHELL", "node -e \"require('http').get('http://127.0.0.1:4416/ping',r=>process.exit(r.statusCode<500?0:1)).on('error',()=>process.exit(1))\""]
      interval: 30s
      timeout: 5s
      retries: 3
      start_period: 15s
    networks:
      - dabljaar_network

  backend:
    build:
      context: ./backend
      dockerfile: Dockerfile.prod
      additional_contexts:
        segments: ./libs/dablja-segments
      args:
        INSTALL_AI: "false"
    container_name: dabljaar_backend
    ports: []
    volumes: []
    # The backend communicates with AI services via RabbitMQ and HTTP; it does
    # not require them to be healthy at startup. Removing the tts-service
    # dependency prevents the 10-minute model-warm-up from blocking the API.
    depends_on:
      youtube-pot:
        condition: service_healthy
      postgres:
        condition: service_healthy
      rabbitmq:
        condition: service_healthy
    command: uvicorn app.main:app --host 0.0.0.0 --port 8000 --proxy-headers
    environment:
      INSTALL_AI: "false"
      DATABASE_URL: postgresql+asyncpg://${POSTGRES_USER:-postgres}:${POSTGRES_PASSWORD}@postgres:5432/${POSTGRES_DB:-dabljaar}
      SECRET_KEY: ${SECRET_KEY:?SECRET_KEY is required}
      ALGORITHM: HS256
      ACCESS_TOKEN_EXPIRE_MINUTES: ${ACCESS_TOKEN_EXPIRE_MINUTES:-60}
      REFRESH_TOKEN_EXPIRE_DAYS: ${REFRESH_TOKEN_EXPIRE_DAYS:-7}
      GOOGLE_CLIENT_ID: ${GOOGLE_CLIENT_ID:-}
      RABBITMQ_URL: ${RABBITMQ_URL}
      TTS_SERVICE_URL: http://tts-service:8005
      STT_SERVICE_URL: http://stt-service:8001
      <<: [*s3-env, *otel-env]
      PIPELINE_SEGMENTS_MODE: ${PIPELINE_SEGMENTS_MODE:-tts_focused}
      DUBBING_TUNE_ENABLED: ${DUBBING_TUNE_ENABLED:-true}
      NMT_FALLBACK_MODE: ${NMT_FALLBACK_MODE:-stage2_only}
      NMT_MAX_LENGTH: ${NMT_MAX_LENGTH:-200}
      NMT_DEFAULT_NUM_BEAMS: ${NMT_DEFAULT_NUM_BEAMS:-5}
      STT_SEGMENT_MIN_WORDS: ${STT_SEGMENT_MIN_WORDS:-10}
      STT_SEGMENT_MAX_WORDS: ${STT_SEGMENT_MAX_WORDS:-1000}
      TTS_MAX_ACCUMULATED_PAUSE: ${TTS_MAX_ACCUMULATED_PAUSE:-1.5}
      TTS_COMBINE_MODE: ${TTS_COMBINE_MODE:-demo}
      TTS_MERGE_MIN_WORDS: ${TTS_MERGE_MIN_WORDS:-0}
      ENVIRONMENT: production
      DEBUG: "false"
      LOG_JSON_FORMAT: ${LOG_JSON_FORMAT:-true}
      SERVICE_NAME: backend
      OTEL_SERVICE_NAME: backend
      YOUTUBE_POT_BASE_URL: ${YOUTUBE_POT_BASE_URL:-http://youtube-pot:4416}
      YOUTUBE_PLAYER_CLIENTS: ${YOUTUBE_PLAYER_CLIENTS:-android_vr,tv_downgraded,mweb}
      YOUTUBE_PROXY: ${YOUTUBE_PROXY:-}
      YOUTUBE_YTDLP_VERBOSE: ${YOUTUBE_YTDLP_VERBOSE:-false}
    healthcheck:
      test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:8000/api/health').read()"]
      interval: 30s
      timeout: 10s
      retries: 5
      start_period: 30s
    stop_grace_period: 30s
    tmpfs:
      - /tmp
    restart: unless-stopped
    security_opt:
      - no-new-privileges:true
    networks:
      - dabljaar_network

volumes:
  dabljaar_postgres_data:
  ai_model_cache:
  caddy_data:
  caddy_config:
  rabbitmq_data:

networks:
  dabljaar_network:
    driver: bridge