docker-compose.yml

# VoidRunner Base Docker Compose Configuration
# Production-ready setup with embedded workers

services:
  # PostgreSQL Database
  postgres:
    image: postgres:17-alpine
    environment:
      POSTGRES_DB: ${POSTGRES_DB:-voidrunner}
      POSTGRES_USER: ${POSTGRES_USER:-voidrunner}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-voidrunner_password}
      POSTGRES_INITDB_ARGS: "--encoding=UTF8 --lc-collate=C --lc-ctype=C"
    ports:
      - "${DB_PORT:-5432}:5432"
    volumes:
      - postgres_data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER:-voidrunner} -d ${POSTGRES_DB:-voidrunner}"]
      interval: 10s
      timeout: 5s
      retries: 5
    networks:
      - voidrunner-backend
    restart: unless-stopped
    deploy:
      resources:
        limits:
          memory: 1G
          cpus: '1.0'
        reservations:
          memory: 256M
          cpus: '0.25'

  # Redis for Queue Management
  redis:
    image: redis:7-alpine
    ports:
      - "${REDIS_PORT:-6379}:6379"
    command: redis-server --appendonly yes --maxmemory ${REDIS_MAX_MEMORY:-512mb} --maxmemory-policy allkeys-lru
    volumes:
      - redis_data:/data
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 10s
      timeout: 3s
      retries: 5
    networks:
      - voidrunner-backend
    restart: unless-stopped
    deploy:
      resources:
        limits:
          memory: 512M
          cpus: '0.5'
        reservations:
          memory: 128M
          cpus: '0.1'

  # VoidRunner API Server with Embedded Workers
  api:
    build:
      context: .
      dockerfile: Dockerfile
      target: ${BUILD_TARGET:-production}
    ports:
      - "${API_PORT:-8080}:8080"
    environment:
      # Server Configuration
      SERVER_HOST: "0.0.0.0"
      SERVER_PORT: "8080"
      SERVER_ENV: ${SERVER_ENV:-production}
      
      # Database Configuration
      DB_HOST: postgres
      DB_PORT: "5432"
      DB_USER: ${POSTGRES_USER:-voidrunner}
      DB_PASSWORD: ${POSTGRES_PASSWORD:-voidrunner_password}
      DB_NAME: ${POSTGRES_DB:-voidrunner}
      DB_SSL_MODE: ${DB_SSL_MODE:-require}
      
      # Redis Configuration
      REDIS_HOST: redis
      REDIS_PORT: "6379"
      REDIS_PASSWORD: ${REDIS_PASSWORD:-""}
      REDIS_DATABASE: "${REDIS_DATABASE:-0}"
      REDIS_POOL_SIZE: ${REDIS_POOL_SIZE:-10}
      REDIS_MIN_IDLE_CONNECTIONS: ${REDIS_MIN_IDLE_CONNECTIONS:-5}
      REDIS_MAX_RETRIES: ${REDIS_MAX_RETRIES:-3}
      REDIS_DIAL_TIMEOUT: ${REDIS_DIAL_TIMEOUT:-5s}
      REDIS_READ_TIMEOUT: ${REDIS_READ_TIMEOUT:-3s}
      REDIS_WRITE_TIMEOUT: ${REDIS_WRITE_TIMEOUT:-3s}
      REDIS_IDLE_TIMEOUT: ${REDIS_IDLE_TIMEOUT:-5m}
      
      # Queue Configuration
      QUEUE_TASK_QUEUE_NAME: ${QUEUE_TASK_QUEUE_NAME:-voidrunner:tasks}
      QUEUE_DEAD_LETTER_QUEUE_NAME: ${QUEUE_DEAD_LETTER_QUEUE_NAME:-voidrunner:tasks:dead}
      QUEUE_RETRY_QUEUE_NAME: ${QUEUE_RETRY_QUEUE_NAME:-voidrunner:tasks:retry}
      QUEUE_DEFAULT_PRIORITY: ${QUEUE_DEFAULT_PRIORITY:-5}
      QUEUE_MAX_RETRIES: ${QUEUE_MAX_RETRIES:-3}
      QUEUE_RETRY_DELAY: ${QUEUE_RETRY_DELAY:-30s}
      QUEUE_RETRY_BACKOFF_FACTOR: ${QUEUE_RETRY_BACKOFF_FACTOR:-2.0}
      QUEUE_MAX_RETRY_DELAY: ${QUEUE_MAX_RETRY_DELAY:-15m}
      QUEUE_VISIBILITY_TIMEOUT: ${QUEUE_VISIBILITY_TIMEOUT:-30m}
      QUEUE_MESSAGE_TTL: ${QUEUE_MESSAGE_TTL:-24h}
      QUEUE_BATCH_SIZE: ${QUEUE_BATCH_SIZE:-10}
      
      # Embedded Workers Configuration
      EMBEDDED_WORKERS: "${EMBEDDED_WORKERS:-true}"
      WORKER_POOL_SIZE: ${WORKER_POOL_SIZE:-3}
      WORKER_MAX_CONCURRENT_TASKS: ${WORKER_MAX_CONCURRENT_TASKS:-20}
      WORKER_MAX_USER_CONCURRENT_TASKS: ${WORKER_MAX_USER_CONCURRENT_TASKS:-5}
      WORKER_TASK_TIMEOUT: ${WORKER_TASK_TIMEOUT:-1h}
      WORKER_HEARTBEAT_INTERVAL: ${WORKER_HEARTBEAT_INTERVAL:-30s}
      WORKER_SHUTDOWN_TIMEOUT: ${WORKER_SHUTDOWN_TIMEOUT:-30s}
      WORKER_CLEANUP_INTERVAL: ${WORKER_CLEANUP_INTERVAL:-5m}
      WORKER_STALE_TASK_THRESHOLD: ${WORKER_STALE_TASK_THRESHOLD:-2h}
      WORKER_ID_PREFIX: ${WORKER_ID_PREFIX:-voidrunner-worker}
      
      # Executor Configuration
      DOCKER_ENDPOINT: "unix:///var/run/docker.sock"
      EXECUTOR_DEFAULT_MEMORY_LIMIT_MB: ${EXECUTOR_DEFAULT_MEMORY_LIMIT_MB:-512}
      EXECUTOR_DEFAULT_CPU_QUOTA: ${EXECUTOR_DEFAULT_CPU_QUOTA:-100000}
      EXECUTOR_DEFAULT_PIDS_LIMIT: ${EXECUTOR_DEFAULT_PIDS_LIMIT:-128}
      EXECUTOR_DEFAULT_TIMEOUT_SECONDS: ${EXECUTOR_DEFAULT_TIMEOUT_SECONDS:-3600}
      EXECUTOR_PYTHON_IMAGE: ${EXECUTOR_PYTHON_IMAGE:-python:3.11-alpine}
      EXECUTOR_BASH_IMAGE: ${EXECUTOR_BASH_IMAGE:-alpine:latest}
      EXECUTOR_JAVASCRIPT_IMAGE: ${EXECUTOR_JAVASCRIPT_IMAGE:-node:18-alpine}
      EXECUTOR_GO_IMAGE: ${EXECUTOR_GO_IMAGE:-golang:1.21-alpine}
      EXECUTOR_ENABLE_SECCOMP: "${EXECUTOR_ENABLE_SECCOMP:-true}"
      EXECUTOR_SECCOMP_PROFILE_PATH: ${EXECUTOR_SECCOMP_PROFILE_PATH:-/opt/voidrunner/seccomp-profile.json}
      EXECUTOR_ENABLE_APPARMOR: "${EXECUTOR_ENABLE_APPARMOR:-false}"
      EXECUTOR_APPARMOR_PROFILE: ${EXECUTOR_APPARMOR_PROFILE:-voidrunner-executor}
      EXECUTOR_EXECUTION_USER: ${EXECUTOR_EXECUTION_USER:-1000:1000}
      
      # Logging Configuration
      LOG_LEVEL: ${LOG_LEVEL:-info}
      LOG_FORMAT: "json"
      
      # JWT Configuration
      JWT_SECRET_KEY: ${JWT_SECRET_KEY}
      JWT_ACCESS_TOKEN_DURATION: ${JWT_ACCESS_TOKEN_DURATION:-15m}
      JWT_REFRESH_TOKEN_DURATION: ${JWT_REFRESH_TOKEN_DURATION:-168h}
      JWT_ISSUER: ${JWT_ISSUER:-voidrunner}
      JWT_AUDIENCE: ${JWT_AUDIENCE:-voidrunner-api}
      
      # CORS Configuration
      CORS_ALLOWED_ORIGINS: ${CORS_ALLOWED_ORIGINS:-"*"}
      CORS_ALLOWED_METHODS: ${CORS_ALLOWED_METHODS:-GET,POST,PUT,DELETE,OPTIONS}
      CORS_ALLOWED_HEADERS: ${CORS_ALLOWED_HEADERS:-Content-Type,Authorization,X-Request-ID}
    
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro  # For Docker executor
      - ./logs:/app/logs                               # Log persistence
      - ./seccomp:/opt/voidrunner:ro                  # Seccomp profiles (if exists)
    
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_healthy
    
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8080/health"]
      interval: 30s
      timeout: 10s
      retries: 5
      start_period: 60s
    
    networks:
      - voidrunner-backend
    
    restart: unless-stopped
    
    deploy:
      resources:
        limits:
          memory: 2G
          cpus: '2.0'
        reservations:
          memory: 512M
          cpus: '0.5'

volumes:
  postgres_data:
    driver: local
  redis_data:
    driver: local

networks:
  voidrunner-backend:
    driver: bridge