docker-compose.prod.yml

services:
  web:
    build: .
    volumes:
      - static_volume:/app/staticfiles
      - media_volume:/app/media
      - model_volume:/app/data/models:delegated
    expose:
      - 8000
    env_file:
      - ./.env.prod
    environment:
      - DEBUG=False
      - ENVIRONMENT=production
      - SERVICE_NAME=web
      - CELERY_WORKER_MAX_MEMORY_PER_CHILD=800000  
      - CELERY_WORKER_MAX_TASKS_PER_CHILD=200
      - GUNICORN_WORKERS=4
      - GUNICORN_MAX_REQUESTS=1000
      - GUNICORN_MAX_REQUESTS_JITTER=50
      - DB_NAME=${DB_NAME}
      - DB_USER=${DB_USER}
      - DB_PASSWORD=${DB_PASSWORD}
      - DB_HOST=${DB_HOST}
      - DB_PORT=${DB_PORT}
      - DB_ENGINE=${DB_ENGINE}
    depends_on:
      redis:
        condition: service_healthy
    restart: always
    networks:
      - praxia-network
    deploy:
      resources:
        limits:
          memory: 4G
        reservations:
          memory: 2G
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8000/api/health/"]
      interval: 30s
      timeout: 10s
      retries: 5
      start_period: 60s
    ulimits:
      nofile:
        soft: 65536
        hard: 65536

  redis:
    image: redis:7
    restart: always
    networks:
      - praxia-network
    command: redis-server --maxmemory 1gb --maxmemory-policy allkeys-lru --save 900 1 --save 300 10 --save 60 10000
    volumes:
      - redis_data:/data
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 10s
      timeout: 5s
      retries: 5
      start_period: 10s
    deploy:
      resources:
        limits:
          memory: 1.5G
        reservations:
          memory: 1G

  celery:
    build: .
    command: celery -A praxia_backend worker -l INFO --concurrency=4 --max-tasks-per-child=100 --max-memory-per-child=600000
    volumes:
      - media_volume:/app/media
      - model_volume:/app/data/models:delegated
    env_file:
      - ./.env.prod
    environment:
      - DEBUG=False
      - SERVICE_NAME=celery
      - CELERY_WORKER_MAX_MEMORY_PER_CHILD=600000  
      - CELERY_WORKER_MAX_TASKS_PER_CHILD=100
      - CELERY_WORKER_DISABLE_RATE_LIMITS=True
      - OMP_NUM_THREADS=2
      - DB_NAME=${DB_NAME}
      - DB_USER=${DB_USER}
      - DB_PASSWORD=${DB_PASSWORD}
      - DB_HOST=${DB_HOST}
      - DB_PORT=${DB_PORT}
      - DB_ENGINE=${DB_ENGINE}
    depends_on:
      web:
        condition: service_healthy
      redis:
        condition: service_healthy
    restart: always
    networks:
      - praxia-network
    deploy:
      resources:
        limits:
          memory: 3G
        reservations:
          memory: 1.5G
      replicas: 2
    ulimits:
      nofile:
        soft: 65536
        hard: 65536
    healthcheck:
      test: ["CMD-SHELL", "celery -A praxia_backend inspect ping --timeout=10 || exit 1"]
      interval: 45s
      timeout: 15s
      retries: 3
      start_period: 90s

  celery-beat:
    build: .
    command: celery -A praxia_backend beat -l INFO --scheduler django_celery_beat.schedulers:DatabaseScheduler
    env_file:
      - ./.env.prod
    environment:
      - DEBUG=False
      - SERVICE_NAME=celery-beat
      - DB_NAME=${DB_NAME}
      - DB_USER=${DB_USER}
      - DB_PASSWORD=${DB_PASSWORD}
      - DB_HOST=${DB_HOST}
      - DB_PORT=${DB_PORT}
      - DB_ENGINE=${DB_ENGINE}
    depends_on:
      web:
        condition: service_healthy
      redis:
        condition: service_healthy
    restart: always
    networks:
      - praxia-network
    deploy:
      resources:
        limits:
          memory: 512M
        reservations:
          memory: 256M
    healthcheck:
      test: ["CMD-SHELL", "ps aux | grep 'celery.*beat' | grep -v grep || exit 1"]
      interval: 60s
      timeout: 10s
      retries: 3
      start_period: 60s

  celery-monitor:
    build: .
    command: celery -A praxia_backend flower --port=5555
    ports:
      - "5555:5555"
    env_file:
      - ./.env.prod
    environment:
      - DEBUG=False
      - SERVICE_NAME=celery-monitor
      - DB_NAME=${DB_NAME}
      - DB_USER=${DB_USER}
      - DB_PASSWORD=${DB_PASSWORD}
      - DB_HOST=${DB_HOST}
      - DB_PORT=${DB_PORT}
      - DB_ENGINE=${DB_ENGINE}
    depends_on:
      web:
        condition: service_healthy
      redis:
        condition: service_healthy
    restart: always
    networks:
      - praxia-network
    deploy:
      resources:
        limits:
          memory: 256M
        reservations:
          memory: 128M
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:5555/api/workers"]
      interval: 60s
      timeout: 10s
      retries: 3
      start_period: 60s

  nginx:
    build: ./nginx
    volumes:
      - static_volume:/app/staticfiles
      - media_volume:/app/media
      - ./nginx/certbot/conf:/etc/letsencrypt
      - ./nginx/certbot/www:/var/www/certbot
    ports:
      - "80:80"
      - "443:443"
    depends_on:
      web:
        condition: service_healthy
    restart: always
    networks:
      - praxia-network
    deploy:
      resources:
        limits:
          memory: 512M
        reservations:
          memory: 256M

  certbot:
    image: certbot/certbot
    volumes:
      - ./nginx/certbot/conf:/etc/letsencrypt
      - ./nginx/certbot/www:/var/www/certbot
    entrypoint: "/bin/sh -c 'trap exit TERM; while :; do certbot renew; sleep 12h & wait ${!}; done;'"
    networks:
      - praxia-network

  monai:
    image: projectmonai/monai:latest
    platform: linux/amd64
    volumes:
      - model_volume:/app/data/models:delegated
    networks:
      - praxia-network
    shm_size: "2g"
    ipc: host
    ulimits:
      memlock: -1
      stack: 67108864
    deploy:
      resources:
        limits:
          memory: 2G
        reservations:
          memory: 1G
    command: ["python", "-c", "import monai; print('MONAI initialized successfully'); import time; [time.sleep(3600) for _ in iter(int, 1)]"]

  prometheus:
    image: prom/prometheus
    volumes:
      - ./prometheus:/etc/prometheus
      - prometheus_data:/prometheus
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
      - '--storage.tsdb.path=/prometheus'
      - '--web.console.libraries=/usr/share/prometheus/console_libraries'
      - '--web.console.templates=/usr/share/prometheus/consoles'
      - '--storage.tsdb.retention.time=60d'
      - '--web.enable-lifecycle'
      - '--web.enable-admin-api'
    restart: always
    networks:
      - praxia-network
    deploy:
      resources:
        limits:
          memory: 2G
        reservations:
          memory: 1G

  grafana:
    image: grafana/grafana
    volumes:
      - grafana_data:/var/lib/grafana
      - ./grafana/provisioning:/etc/grafana/provisioning
    env_file:
      - ./.env.prod
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=${GRAFANA_ADMIN_PASSWORD:-admin_password}
      - GF_USERS_ALLOW_SIGN_UP=false
      - GF_SECURITY_ALLOW_EMBEDDING=true
      - GF_AUTH_ANONYMOUS_ENABLED=false
      - GF_INSTALL_PLUGINS=grafana-clock-panel,grafana-simple-json-datasource
      - GF_SERVER_ROOT_URL=${GRAFANA_ROOT_URL}
    depends_on:
      - prometheus
    restart: always
    networks:
      - praxia-network
    deploy:
      resources:
        limits:
          memory: 1G
        reservations:
          memory: 512M

  libretranslate:
    image: libretranslate/libretranslate
    env_file:
      - ./.env.prod
    environment:
      - LT_LOAD_ONLY=${LT_LOAD_ONLY:-es,en,fr}
      - LT_THREADS=${LT_THREADS:-4}
      - LT_MEMORY=${LT_MEMORY:-512M}
      - LT_UPDATE_MODELS=${LT_UPDATE_MODELS:-false}
      - LT_DISABLE_WEB_UI=true
    restart: always
    networks:
      - praxia-network
    deploy:
      resources:
        limits:
          memory: 2G
        reservations:
          memory: 1G

  node-exporter:
    image: prom/node-exporter
    volumes:
      - /proc:/host/proc:ro
      - /sys:/host/sys:ro
      - /:/rootfs:ro
    command:
      - '--path.procfs=/host/proc'
      - '--path.sysfs=/host/sys'
      - '--collector.filesystem.ignored-mount-points=^/(sys|proc|dev|host|etc)($|/)'
      - '--collector.cpu'
      - '--collector.meminfo'
      - '--collector.diskstats'
      - '--collector.netdev'
    restart: always
    networks:
      - praxia-network
    deploy:
      resources:
        limits:
          memory: 128M
        reservations:
          memory: 64M

  cadvisor:
    image: gcr.io/cadvisor/cadvisor:latest
    container_name: cadvisor
    privileged: true
    devices:
      - /dev/kmsg:/dev/kmsg
    volumes:
      - /:/rootfs:ro
      - /var/run:/var/run:ro
      - /sys:/sys:ro
      - /var/lib/docker/:/var/lib/docker:ro
      - /dev/disk/:/dev/disk:ro
      - /etc/machine-id:/etc/machine-id:ro
    restart: always
    networks:
      - praxia-network
    command:
      - '--housekeeping_interval=30s'
      - '--max_housekeeping_interval=35s'
      - '--event_storage_event_limit=default=0'
      - '--event_storage_age_limit=default=0'
      - '--disable_metrics=disk,diskIO,network,tcp,udp,percpu,sched,process'
      - '--docker_only=true'
      - '--store_container_labels=false'
    deploy:
      resources:
        limits:
          memory: 512M
        reservations:
          memory: 256M

  redis-exporter:
    image: oliver006/redis_exporter
    env_file:
      - ./.env.prod
    environment:
      - REDIS_ADDR=redis://${REDIS_HOST:-redis}:${REDIS_PORT:-6379}
    restart: always
    networks:
      - praxia-network
    deploy:
      resources:
        limits:
          memory: 128M
        reservations:
          memory: 64M

  postgres-exporter:
    image: wrouesnel/postgres_exporter
    env_file:
      - ./.env.prod
    environment:
           - DATA_SOURCE_NAME=postgresql://${DB_USER}:${DB_PASSWORD}@${DB_HOST}:${DB_PORT:-5432}/${DB_NAME}?sslmode=disable
    restart: always
    networks:
      - praxia-network
    deploy:
      resources:
        limits:
          memory: 256M
        reservations:
          memory: 128M

  watchtower:
    image: containrrr/watchtower
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    command: --interval 3600 --cleanup
    restart: always
    networks:
      - praxia-network

networks:
  praxia-network:
    driver: bridge

volumes:
  static_volume:
  media_volume:
  model_volume:
  prometheus_data:
  grafana_data:
  redis_data: