docker-compose.yaml

services:
    alphabench__fastapi:
        build:
            context: .
            dockerfile: Dockerfile # Use the main Dockerfile for FastAPI
        image: alphabench__fastapi:latest
        container_name: alphabench__fastapi
        command: uvicorn src.main:app --host 0.0.0.0 --port 8000 --reload
        volumes:
            - .:/app
        ports:
            - "8000:8000"
        environment:
            - ENV_FILE=.env
        env_file:
            - .env
        depends_on:
            - alphabench__postgres
            - alphabench__redis
        healthcheck:
            test: ["CMD", "curl", "-f", "http://localhost:8000/health"]
            interval: 30s
            timeout: 10s
            retries: 3
        networks:
            - alphabench__network
        deploy:
            resources:
                limits:
                    cpus: "0.5"
                    memory: "768m"
                reservations:
                    cpus: "0.3"
                    memory: "512m"

    celery_worker_script_generator:
        build:
            context: .
            dockerfile: Dockerfile.worker # Use a separate Dockerfile for workers
        container_name: celery_worker_script_generator
        command: celery -A src.infrastructure.queue.celery_app worker --loglevel=info -E --queues=script_generation --hostname=script_generator@%h
        volumes:
            - .:/app
        ports:
            - "8081:8081"
        env_file:
            - .env
        depends_on:
            - alphabench__redis
            - alphabench__postgres
        healthcheck:
            test: ["CMD", "pgrep", "celery"]
            interval: 30s
            timeout: 10s
            retries: 3
        networks:
            - alphabench__network
        deploy:
            resources:
                limits:
                    cpus: "0.4"
                    memory: "768m"
                reservations:
                    cpus: "0.2"
                    memory: "512m"

    celery_worker_script_validator:
        build:
            context: .
            dockerfile: Dockerfile.worker # Use a separate Dockerfile for workers
        container_name: celery_worker_script_validator
        command: celery -A src.infrastructure.queue.celery_app worker --loglevel=info -E --queues=script_validation --hostname=script_validator@%h --concurrency=2 --max-tasks-per-child=10 --max-memory-per-child=512000
        volumes:
            - .:/app
        env_file:
            - .env
        ports:
            - "8082:8082"
        depends_on:
            - alphabench__redis
            - alphabench__postgres
        healthcheck:
            test: ["CMD", "pgrep", "celery"]
            interval: 30s
            timeout: 10s
            retries: 3
        networks:
            - alphabench__network
        deploy:
            resources:
                limits:
                    cpus: "0.8"
                    memory: "1.5G"
                reservations:
                    cpus: "0.4"
                    memory: "768m"

    celery_worker_backtest:
        build:
            context: .
            dockerfile: Dockerfile.worker # Use a separate Dockerfile for workers
        container_name: celery_worker_backtest
        command: celery -A src.infrastructure.queue.celery_app worker --loglevel=info -E --queues=backtest_execution --hostname=backtest_execution@%h --concurrency=2 --max-tasks-per-child=10 --max-memory-per-child=512000
        volumes:
            - .:/app
        ports:
            - "8083:8083"
        env_file:
            - .env
        depends_on:
            - alphabench__redis
            - alphabench__postgres
        healthcheck:
            test: ["CMD", "pgrep", "celery"]
            interval: 30s
            timeout: 10s
            retries: 3
        networks:
            - alphabench__network
        deploy:
            resources:
                limits:
                    cpus: "0.8"
                    memory: "1.5G"
                reservations:
                    cpus: "0.4"
                    memory: "768m"

    celery_worker_report_generator:
        build:
            context: .
            dockerfile: Dockerfile.worker # Use a separate Dockerfile for workers
        container_name: celery_worker_report_generator
        command: celery -A src.infrastructure.queue.celery_app worker --loglevel=info -E --queues=report_generation --hostname=report_generator@%h
        volumes:
            - .:/app
        env_file:
            - .env
        ports:
            - "8084:8084"
        depends_on:
            - alphabench__redis
            - alphabench__postgres
        healthcheck:
            test: ["CMD", "pgrep", "celery"]
            interval: 30s
            timeout: 10s
            retries: 3
        networks:
            - alphabench__network
        deploy:
            resources:
                limits:
                    cpus: "0.3"
                    memory: "512m"
                reservations:
                    cpus: "0.2"
                    memory: "384m"

    alphabench__postgres:
        image: timescale/timescaledb:latest-pg15
        container_name: alphabench__postgres
        volumes:
            - postgres_data:/var/lib/postgresql/data
            - ./scripts/001_initial_schema.sql:/docker-entrypoint-initdb.d/001_initial_schema.sql
        environment:
            - POSTGRES_USER=${POSTGRES_USER}
            - POSTGRES_PASSWORD=${POSTGRES_PASSWORD}
            - POSTGRES_DB=${POSTGRES_DB}
        ports:
            - "5432:5432"
        healthcheck:
            test:
                [
                    "CMD-SHELL",
                    "pg_isready -U ${POSTGRES_USER} -d ${POSTGRES_DB}",
                ]
            interval: 30s
            timeout: 10s
            retries: 3
        networks:
            - alphabench__network
        deploy:
            resources:
                limits:
                    cpus: "0.5"
                    memory: "2G"
                reservations:
                    cpus: "0.3"
                    memory: "1G"

    alphabench__redis:
        image: redis:latest
        container_name: alphabench__redis
        command: redis-server --requirepass ${REDIS_PASSWORD}
        ports:
            - "${REDIS_PORT}:6379"
        environment:
            - REDIS_PASSWORD=${REDIS_PASSWORD}
        healthcheck:
            test: ["CMD", "redis-cli", "-a", "${REDIS_PASSWORD}", "ping"]
            interval: 10s
            timeout: 5s
            retries: 3
            start_period: 30s
        restart: always
        volumes:
            - redis_data:/data
        networks:
            - alphabench__network
        deploy:
            resources:
                limits:
                    cpus: "0.2"
                    memory: "256m"
                reservations:
                    cpus: "0.1"
                    memory: "128m"

    celery_flower:
        image: mher/flower:latest
        container_name: celery_flower
        command: >
            celery 
            --broker=redis://:${REDIS_PASSWORD}@alphabench__redis:6379/0
            flower
            --port=5555 
            --address=0.0.0.0
            --enable_events=True
            --persistent=True
            --url_prefix=flower
        ports:
            - "5555:5555"
        env_file:
            - .env
        environment:
            - CELERY_BROKER_URL=redis://:${REDIS_PASSWORD}@alphabench__redis:6379/0
        depends_on:
            - alphabench__redis
        networks:
            - alphabench__network
        deploy:
            resources:
                limits:
                    cpus: "0.05"
                    memory: "96m"

    alphabench__prometheus:
        image: prom/prometheus:v2.44.0
        container_name: alphabench__prometheus
        volumes:
            - ./prometheus:/etc/prometheus
            - prometheus_data:/prometheus
        command:
            - "--config.file=/etc/prometheus/prometheus.yml"
        ports:
            - "9090:9090"
        healthcheck:
            test: ["CMD", "wget", "--spider", "http://localhost:9090/-/healthy"]
            interval: 30s
            timeout: 10s
            retries: 3
        networks:
            - alphabench__network
        deploy:
            resources:
                limits:
                    cpus: "0.2"
                    memory: "384m"

    alphabench__grafana:
        image: grafana/grafana:9.5.2
        container_name: alphabench__grafana
        ports:
            - "3000:3000"
        volumes:
            - grafana_data:/var/lib/grafana
        env_file:
            - .env
        environment:
            - GF_SECURITY_ADMIN_USER=${GF_SECURITY_ADMIN_USER}
            - GF_SECURITY_ADMIN_PASSWORD=${GF_SECURITY_ADMIN_PASSWORD}
        healthcheck:
            test:
                ["CMD", "wget", "--spider", "http://localhost:3000/api/health"]
            interval: 30s
            timeout: 10s
            retries: 3
        networks:
            - alphabench__network
        deploy:
            resources:
                limits:
                    cpus: "0.15"
                    memory: "256m"
volumes:
    postgres_data:
    redis_data:
    prometheus_data:
    grafana_data:

networks:
    alphabench__network:
        driver: bridge
        external: true