docker-compose.yml

name: ukolio

services:
    proxy:
        build:
            context: ./proxy
            dockerfile: Dockerfile
        ports:
            - "${PROXY_PORT}:80"
        restart: unless-stopped
        depends_on:
            frontend:
                condition: service_healthy
            backend:
                condition: service_healthy
        healthcheck:
            test: ["CMD", "nc", "-z", "127.0.0.1", "80"]
            interval: 10s
            timeout: 5s
            retries: 5
            start_period: 10s
        networks:
            - frontend
            - backend

    frontend:
        build:
            context: ./frontend
            dockerfile: Dockerfile
        restart: unless-stopped
        healthcheck:
            test: ["CMD", "wget", "-q", "--spider", "http://127.0.0.1/"]
            interval: 10s
            timeout: 5s
            retries: 5
            start_period: 10s
        networks:
            - frontend

    backend:
        build:
            context: ./backend
            dockerfile: Dockerfile
        environment:
            APP_ENV: ${APP_ENV:-development}
            MYSQL_HOST: ${MYSQL_HOST}
            MYSQL_DATABASE: ${MYSQL_DATABASE}
            MYSQL_USER: ${MYSQL_USER}
            MYSQL_PASSWORD: ${MYSQL_PASSWORD}
            MYSQL_ROOT_PASSWORD: ${MYSQL_ROOT_PASSWORD}
            AUTHORIZATION_TOKEN_KEY: ${AUTHORIZATION_TOKEN_KEY}
            GOOGLE_CLIENT_ID: ${GOOGLE_CLIENT_ID:-}
            BACKEND_FRANKENPHP_WORKERS: ${BACKEND_FRANKENPHP_WORKERS}
            BACKEND_CORS_ALLOWED_ORIGIN: ${BACKEND_CORS_ALLOWED_ORIGIN}
            BACKEND_LOG_LEVEL: ${BACKEND_LOG_LEVEL}
            SMTP_HOST: ${SMTP_HOST}
            SMTP_PORT: ${SMTP_PORT}
            SMTP_USER: ${SMTP_USER}
            SMTP_PASSWORD: ${SMTP_PASSWORD}
            EMAIL_FROM: ${EMAIL_FROM}
            PROXY_HOST: ${PROXY_HOST}
            PROXY_PORT_SSL: ${PROXY_PORT_SSL}
            S3_ENDPOINT: ${S3_ENDPOINT}
            S3_REGION: ${S3_REGION}
            S3_BUCKET: ${S3_BUCKET}
            S3_ACCESS_KEY: ${S3_ACCESS_KEY}
            S3_SECRET_KEY: ${S3_SECRET_KEY}
            S3_USE_PATH_STYLE: ${S3_USE_PATH_STYLE}
            TASK_FILE_MAX_SIZE_MB: ${TASK_FILE_MAX_SIZE_MB}
            REDIS_HOST: ${REDIS_HOST}
            REDIS_PORT: ${REDIS_PORT}
            REDIS_PASSWORD: ${REDIS_PASSWORD}
            MEMCACHED_HOST: ${MEMCACHED_HOST}
            MEMCACHED_PORT: ${MEMCACHED_PORT}
            MCP_SESSION_TTL: ${MCP_SESSION_TTL}
            MERCURE_PUBLISHER_JWT_KEY: ${MERCURE_PUBLISHER_JWT_KEY}
            MERCURE_SUBSCRIBER_JWT_KEY: ${MERCURE_SUBSCRIBER_JWT_KEY}
            MERCURE_PUBLISH_URL: ${MERCURE_PUBLISH_URL}
            RABBITMQ_HOST: ${RABBITMQ_HOST}
            RABBITMQ_PORT: ${RABBITMQ_PORT}
            RABBITMQ_USER: ${RABBITMQ_USER}
            RABBITMQ_PASSWORD: ${RABBITMQ_PASSWORD}
            BACKEND_AMQP_CONSUMER_PREFETCH: ${BACKEND_AMQP_CONSUMER_PREFETCH}
            MEILI_HOST: ${MEILI_HOST}
            MEILI_PORT: ${MEILI_PORT}
            MEILI_MASTER_KEY: ${MEILI_MASTER_KEY}
            MEILI_INDEX_PREFIX: ${MEILI_INDEX_PREFIX}
        depends_on:
            db:
                condition: service_healthy
            redis:
                condition: service_healthy
            memcached:
                condition: service_started
            minio:
                condition: service_started
            rabbitmq:
                condition: service_healthy
            meilisearch:
                condition: service_healthy
        restart: unless-stopped
        healthcheck:
            test: ["CMD", "curl", "-fsS", "http://127.0.0.1/api/health"]
            interval: 10s
            timeout: 5s
            retries: 5
            start_period: 20s
        networks:
            - backend
        volumes:
            - ./log:/app/log

    db:
        image: mariadb:11.4
        restart: unless-stopped
        environment:
            MYSQL_ROOT_PASSWORD: ${MYSQL_ROOT_PASSWORD}
            MYSQL_DATABASE: ${MYSQL_DATABASE}
            MYSQL_USER: ${MYSQL_USER}
            MYSQL_PASSWORD: ${MYSQL_PASSWORD}
        healthcheck:
            test: ["CMD", "healthcheck.sh", "--connect", "--innodb_initialized"]
            interval: 10s
            timeout: 5s
            retries: 10
            start_period: 20s
        networks:
            - backend
        volumes:
            - ukolio_data:/var/lib/mysql

    adminer:
        image: adminer:5.4.2
        restart: unless-stopped
        networks:
            - frontend
            - backend
        profiles:
            - dev

    mailpit:
        image: axllent/mailpit:v1.20
        restart: unless-stopped
        networks:
            - backend
            - frontend
        environment:
            MP_SMTP_AUTH_ACCEPT_ANY: 1
            MP_SMTP_AUTH_ALLOW_INSECURE: 1

    minio:
        image: minio/minio:RELEASE.2025-01-20T14-49-07Z
        command: server /data --console-address ":9001"
        environment:
            MINIO_ROOT_USER: ${S3_ACCESS_KEY}
            MINIO_ROOT_PASSWORD: ${S3_SECRET_KEY}
        restart: unless-stopped
        networks:
            - backend
        ports:
            - "9001:9001"
        volumes:
            - ukolio_minio:/data

    memcached:
        image: memcached:1.6.41-alpine
        restart: unless-stopped
        networks:
            - backend

    redis:
        image: redis:8.6.3-alpine
        restart: unless-stopped
        environment:
            REDIS_PASSWORD: ${REDIS_PASSWORD}
        command: redis-server --save 60 1 --loglevel warning --requirepass ${REDIS_PASSWORD}
        healthcheck:
            test: ["CMD-SHELL", "redis-cli -a \"$$REDIS_PASSWORD\" ping | grep -q PONG"]
            interval: 10s
            timeout: 5s
            retries: 5
            start_period: 5s
        networks:
            - backend
        volumes:
            - ukolio_redis:/data

    rabbitmq:
        image: rabbitmq:4.3.0-alpine
        restart: unless-stopped
        environment:
            RABBITMQ_DEFAULT_USER: ${RABBITMQ_USER}
            RABBITMQ_DEFAULT_PASS: ${RABBITMQ_PASSWORD}
        healthcheck:
            test: ["CMD-SHELL", "rabbitmq-diagnostics -q ping"]
            interval: 10s
            timeout: 5s
            retries: 10
            start_period: 20s
        networks:
            - backend
        volumes:
            - ukolio_rabbitmq:/var/lib/rabbitmq

    meilisearch:
        image: getmeili/meilisearch:v1.11
        restart: unless-stopped
        environment:
            MEILI_MASTER_KEY: ${MEILI_MASTER_KEY}
            MEILI_ENV: production
            MEILI_NO_ANALYTICS: "true"
        healthcheck:
            test: ["CMD-SHELL", "wget -qO- http://127.0.0.1:7700/health | grep -q available"]
            interval: 10s
            timeout: 5s
            retries: 10
            start_period: 10s
        networks:
            - backend
        volumes:
            - ukolio_meilisearch:/meili_data

networks:
    frontend:
        name: ukolio_frontend
    backend:
        name: ukolio_backend

volumes:
    ukolio_data:
        name: ukolio_data
    ukolio_minio:
        name: ukolio_minio
    ukolio_redis:
        name: ukolio_redis
    ukolio_rabbitmq:
        name: ukolio_rabbitmq
    ukolio_meilisearch:
        name: ukolio_meilisearch