michaelschiemer/docker-compose.yml

# ⚠️  DEPRECATED - Legacy Docker Compose Configuration ⚠️
#
# This file is DEPRECATED and kept ONLY for backward compatibility during migration.
# ⚠️  DO NOT USE THIS FILE FOR NEW DEPLOYMENTS ⚠️
#
# This file will be REMOVED after the migration period (planned: Q2 2025).
# All developers must migrate to the Base+Override Pattern before then.
#
# ✅ PREFERRED: Use Base+Override Pattern:
#   - docker-compose.base.yml (shared services)
#   - docker-compose.local.yml (local development overrides)
#   - docker-compose.staging.yml (staging overrides)
#   - docker-compose.production.yml (production overrides)
#
# 📖 Usage:
#   Local:      docker compose -f docker-compose.base.yml -f docker-compose.local.yml up
#   Staging:    docker compose -f docker-compose.base.yml -f docker-compose.staging.yml up
#   Production: docker compose -f docker-compose.base.yml -f docker-compose.production.yml up
#
# 🔗 See deployment/README.md for details on the Base+Override Pattern
# 🔗 See ENV_SETUP.md for environment configuration guide
#
# ⚠️  Migration Required:
#   1. Create .env.base from .env.example (run: make env-base)
#   2. Create .env.local for local overrides (run: make env-local)
#   3. Update all docker compose commands to use Base+Override files
#   4. Test your local setup before removing this legacy file
#
# 📅 Deprecation Timeline:
#   - Created: Base+Override Pattern introduced
#   - Planned Removal: Q2 2025 (after all developers have migrated)
#   - Action Required: Migrate before removal date

services:
  web:
    container_name: web
    build:
      context: docker/nginx
      dockerfile: Dockerfile
    ports:
      - "8888:80"
      - "8443:443"
    environment:
      - APP_ENV=${APP_ENV:-development}
    healthcheck:
      test: ["CMD", "nc", "-z", "127.0.0.1", "443"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: ${HEALTHCHECK_START_PERIOD:-10s}
    logging:
      driver: "${LOG_DRIVER:-local}"
      options:
        max-size: "${LOG_MAX_SIZE:-5m}"
        max-file: "${LOG_MAX_FILE:-2}"
    volumes:
      - ./:/var/www/html:${VOLUME_MODE:-cached}
      - ./ssl:/var/www/ssl:ro
    depends_on:
      php:
        condition: service_started
    restart: ${RESTART_POLICY:-unless-stopped}
    networks:
      - frontend
      - backend
    # Legacy .env file (Fallback for backward compatibility)
    # Preferred: Use docker-compose.base.yml + docker-compose.local.yml
    # See ENV_SETUP.md for new Base+Override Pattern
    env_file:
      - .env
    deploy:
      resources:
        limits:
          memory: ${WEB_MEMORY_LIMIT:-256M}
          cpus: ${WEB_CPU_LIMIT:-0.5}
        reservations:
          memory: ${WEB_MEMORY_RESERVATION:-128M}
          cpus: ${WEB_CPU_RESERVATION:-0.25}

  php:
    container_name: php
    build:
      context: .
      dockerfile: docker/php/Dockerfile
      args:
        - ENV=${APP_ENV:-dev}
        - COMPOSER_INSTALL_FLAGS=${COMPOSER_INSTALL_FLAGS:---no-scripts --no-autoloader}
    user: "${PHP_USER:-1000:1000}"
    logging:
      driver: "${LOG_DRIVER:-local}"
      options:
        max-size: "${LOG_MAX_SIZE:-5m}"
        max-file: "${LOG_MAX_FILE:-2}"
    volumes:
      # Shared Volume für Composer-Cache über Container-Neustarts hinweg
      - composer-cache:/root/.composer/cache
      # Bindet das Projektverzeichnis für Produktivbetrieb  ein
      #- project-data:/var/www/html:cached
      # Variante mit mounting:
      - ./:/var/www/html:${VOLUME_MODE:-cached}
      # Verhindert Überschreiben der Vendor-Verzeichnisse
      #- /var/www/html/vendor

      # Host-Mounts für direkten Zugriff (Development-friendly)
      - ./storage/logs:/var/www/html/storage/logs:rw
      - ./storage/uploads:/var/www/html/storage/uploads:rw
      - ./storage/analytics:/var/www/html/storage/analytics:rw

      # Docker-Volumes für Performance (keine Host-Sync nötig)
      - storage-cache:/var/www/html/storage/cache:rw
      - storage-queue:/var/www/html/storage/queue:rw
      - storage-discovery:/var/www/html/storage/discovery:rw

      - var-data:/var/www/html/var:rw
    environment:
      PHP_IDE_CONFIG: "${PHP_IDE_CONFIG:-serverName=docker}"
      APP_ENV: ${APP_ENV:-development}
      APP_DEBUG: ${APP_DEBUG:-true}
      XDEBUG_MODE: ${XDEBUG_MODE:-debug}
    healthcheck:
      test: [ "CMD", "php", "-v" ]
      interval: 30s
      timeout: 10s
      retries: 3
    restart: ${RESTART_POLICY:-unless-stopped}
    networks:
      - backend
      - cache
    # Legacy .env file (Fallback for backward compatibility)
    # Preferred: Use docker-compose.base.yml + docker-compose.local.yml
    env_file:
      - .env
    deploy:
      resources:
        limits:
          memory: ${PHP_MEMORY_LIMIT:-512M}
          cpus: ${PHP_CPU_LIMIT:-1.0}
        reservations:
          memory: ${PHP_MEMORY_RESERVATION:-256M}
          cpus: ${PHP_CPU_RESERVATION:-0.5}

  php-test:
    container_name: php-test
    build:
      context: .
      dockerfile: docker/php/Dockerfile.test
    user: "1000:1000"
    profiles:
      - test
    volumes:
      - ./:/var/www/html:${VOLUME_MODE:-cached}
      - composer-cache:/home/appuser/.composer/cache
      - storage-cache:/var/www/html/storage/cache:rw
      - storage-queue:/var/www/html/storage/queue:rw
      - storage-discovery:/var/www/html/storage/discovery:rw
      - var-data:/var/www/html/var:rw
    environment:
      APP_ENV: testing
      APP_DEBUG: true
      DB_HOST: db
      REDIS_HOST: redis
    networks:
      - backend
      - cache
    # Legacy .env file (Fallback for backward compatibility)
    env_file:
      - .env
    entrypoint: []
    command: ["php", "-v"]

  db:
    container_name: db
    image: postgres:16-alpine
    restart: ${RESTART_POLICY:-unless-stopped}
    environment:
      POSTGRES_DB: ${DB_DATABASE:-michaelschiemer}
      POSTGRES_USER: ${DB_USERNAME:-postgres}
      POSTGRES_PASSWORD: ${DB_PASSWORD:-StartSimple2024!}
      # Performance & Connection Settings
      POSTGRES_INITDB_ARGS: "-E UTF8 --locale=C"
      PGDATA: /var/lib/postgresql/data/pgdata
    ports:
      - "${DB_EXTERNAL_PORT:-5433}:5432"
    volumes:
      - db_data:/var/lib/postgresql/data
      - "${DB_CONFIG_PATH:-./docker/postgres/postgresql.conf}:/etc/postgresql/postgresql.conf:ro"
      - "${DB_INIT_PATH:-./docker/postgres/init}:/docker-entrypoint-initdb.d:ro"
    command:
      - "postgres"
      - "-c"
      - "config_file=/etc/postgresql/postgresql.conf"
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U ${DB_USERNAME:-postgres} -d ${DB_DATABASE:-michaelschiemer}"]
      interval: 10s
      timeout: 5s
      retries: 5
      start_period: 30s
    logging:
      driver: "${LOG_DRIVER:-local}"
      options:
        max-size: "${LOG_MAX_SIZE:-5m}"
        max-file: "${LOG_MAX_FILE:-2}"
    networks:
      - backend
    deploy:
      resources:
        limits:
          memory: ${DB_MEMORY_LIMIT:-1G}
          cpus: ${DB_CPU_LIMIT:-1.0}
        reservations:
          memory: ${DB_MEMORY_RESERVATION:-512M}
          cpus: ${DB_CPU_RESERVATION:-0.5}

  redis:
    container_name: redis
    image: redis:7-alpine
    volumes:
      - "${REDIS_CONFIG_PATH:-./docker/redis/redis.conf}:/usr/local/etc/redis/redis.conf:ro"
      - redis_data:/data
    command: ["redis-server", "/usr/local/etc/redis/redis.conf"]
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 30s
      timeout: 5s
      retries: 3
      start_period: 30s
    restart: ${RESTART_POLICY:-unless-stopped}
    logging:
      driver: "${LOG_DRIVER:-local}"
      options:
        max-size: "${LOG_MAX_SIZE:-5m}"
        max-file: "${LOG_MAX_FILE:-2}"
    networks:
      - cache
    # Legacy .env file (Fallback for backward compatibility)
    env_file:
      - .env
    deploy:
      resources:
        limits:
          memory: ${REDIS_MEMORY_LIMIT:-256M}
          cpus: ${REDIS_CPU_LIMIT:-0.5}
        reservations:
          memory: ${REDIS_MEMORY_RESERVATION:-128M}
          cpus: ${REDIS_CPU_RESERVATION:-0.25}

  queue-worker:
    container_name: queue-worker
    build:
      context: .
      dockerfile: docker/worker/Dockerfile
    user: "1000:1000"  # Same user ID as PHP container
    entrypoint: ""  # Override any entrypoint
    command: ["php", "/var/www/html/worker.php"]  # Direct command execution
    depends_on:
      php:
        condition: service_healthy
      redis:
        condition: service_healthy
      db:
        condition: service_healthy
    volumes:
      - ./:/var/www/html:cached
      # Use same storage volumes as PHP container for consistency
      - storage-cache:/var/www/html/storage/cache:rw
      - storage-queue:/var/www/html/storage/queue:rw
      - storage-discovery:/var/www/html/storage/discovery:rw
      - ./storage/logs:/var/www/html/storage/logs:rw
      - var-data:/var/www/html/var:rw
    environment:
      - APP_ENV=${APP_ENV:-development}
      - WORKER_DEBUG=${WORKER_DEBUG:-false}
      - WORKER_SLEEP_TIME=${WORKER_SLEEP_TIME:-100000}
      - WORKER_MAX_JOBS=${WORKER_MAX_JOBS:-1000}
    restart: unless-stopped
    networks:
      - backend
      - cache
    # Legacy .env file (Fallback for backward compatibility)
    env_file:
      - .env
    # Graceful shutdown timeout
    stop_grace_period: 30s
    # Resource limits for the worker
    deploy:
      resources:
        limits:
          memory: 1G
        reservations:
          memory: 512M

  minio:
    container_name: minio
    image: minio/minio:latest
    restart: ${RESTART_POLICY:-unless-stopped}
    environment:
      - TZ=Europe/Berlin
      - MINIO_ROOT_USER=${MINIO_ROOT_USER:-minioadmin}
      - MINIO_ROOT_PASSWORD=${MINIO_ROOT_PASSWORD:-minioadmin}
    command: server /data --console-address ":9001"
    ports:
      - "${MINIO_API_PORT:-9000}:9000"
      - "${MINIO_CONSOLE_PORT:-9001}:9001"
    volumes:
      - minio_data:/data
      - /etc/timezone:/etc/timezone:ro
      - /etc/localtime:/etc/localtime:ro
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:9000/minio/health/live"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 10s
    networks:
      - backend
    logging:
      driver: "${LOG_DRIVER:-local}"
      options:
        max-size: "${LOG_MAX_SIZE:-5m}"
        max-file: "${LOG_MAX_FILE:-2}"
    deploy:
      resources:
        limits:
          memory: ${MINIO_MEMORY_LIMIT:-512M}
          cpus: ${MINIO_CPU_LIMIT:-0.5}
        reservations:
          memory: ${MINIO_MEMORY_RESERVATION:-256M}
          cpus: ${MINIO_CPU_RESERVATION:-0.25}

#  websocket:
#    build:
#      context: .
#    container_name: websocket
#    command: php websocket.php
#    ports:
#      - "8081:8081"
#    networks:
#      - frontend
#      - backend
#    volumes:
#      - ./:/var/www/html

networks:
  frontend:
    driver: bridge
  backend:
    driver: bridge
    internal: ${NETWORK_BACKEND_INTERNAL:-false}
  cache:
    driver: bridge
    internal: ${NETWORK_CACHE_INTERNAL:-false}

volumes:
  redis_data:
  composer-cache:
  # storage-data entfernt - wird jetzt granular gemountet
  storage-cache:      # Cache-Verzeichnis (Performance-kritisch)
  storage-queue:      # Queue-Verzeichnis (Performance-kritisch)
  storage-discovery:  # Discovery-Cache (Framework-intern)
  var-data:
  #cache-volume:
  db_data:
  project-data:
  worker-logs:
  worker-queue:
  worker-storage:  # Complete separate storage for worker with correct permissions
  minio_data:      # MinIO object storage data