docker-compose.yml

services:
  # Database Services
  postgres-auth:
    image: postgres:16.10-alpine3.22
    container_name: postgres-auth
    environment:
      POSTGRES_DB: authdb
      POSTGRES_USER: authuser
      POSTGRES_PASSWORD: ${DB_PASSWORD:?DB_PASSWORD required}
    volumes:
      - auth_db_data:/var/lib/postgresql/data
      - ./init-scripts/auth-db-init.sql:/docker-entrypoint-initdb.d/init.sql
    ports:
      - "5435:5432"
    networks:
      - microservices-network
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U authuser -d authdb"]
      interval: 10s
      timeout: 5s
      retries: 5

  postgres-user:
    image: postgres:16.10-alpine3.22
    container_name: postgres-user
    environment:
      POSTGRES_DB: userdb
      POSTGRES_USER: useruser
      POSTGRES_PASSWORD: ${DB_PASSWORD:?DB_PASSWORD required}
    volumes:
      - user_db_data:/var/lib/postgresql/data
      - ./init-scripts/user-db-init.sql:/docker-entrypoint-initdb.d/init.sql
    ports:
      - "5433:5432"
    networks:
      - microservices-network
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U useruser -d userdb"]
      interval: 10s
      timeout: 5s
      retries: 5

  postgres-order:
    image: postgres:16.10-alpine3.22
    container_name: postgres-order
    environment:
      POSTGRES_DB: orderdb
      POSTGRES_USER: orderuser
      POSTGRES_PASSWORD: ${DB_PASSWORD:?DB_PASSWORD required}
    volumes:
      - order_db_data:/var/lib/postgresql/data
      - ./init-scripts/order-db-init.sql:/docker-entrypoint-initdb.d/init.sql
    ports:
      - "5436:5432"
    networks:
      - microservices-network
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U orderuser -d orderdb"]
      interval: 10s
      timeout: 5s
      retries: 5

  postgres-inventory:
    image: postgres:16.10-alpine3.22
    container_name: postgres-inventory
    environment:
      POSTGRES_DB: inventorydb
      POSTGRES_USER: inventoryuser
      POSTGRES_PASSWORD: ${DB_PASSWORD:?DB_PASSWORD required}
    volumes:
      - inventory_db_data:/var/lib/postgresql/data
      - ./init-scripts/inventory-db-init.sql:/docker-entrypoint-initdb.d/init.sql
    ports:
      - "5437:5432"
    networks:
      - microservices-network
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U inventoryuser -d inventorydb"]
      interval: 10s
      timeout: 5s
      retries: 5

  postgres-notification:
    image: postgres:16.10-alpine3.22
    container_name: postgres-notification
    environment:
      POSTGRES_DB: notificationdb
      POSTGRES_USER: notificationuser
      POSTGRES_PASSWORD: ${DB_PASSWORD:?DB_PASSWORD required}
    volumes:
      - notification_db_data:/var/lib/postgresql/data
      - ./init-scripts/notification-db-init.sql:/docker-entrypoint-initdb.d/init.sql
    ports:
      - "5434:5432"
    networks:
      - microservices-network
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U notificationuser -d notificationdb"]
      interval: 10s
      timeout: 5s
      retries: 5

  # Redis Service
  redis:
    image: redis:7-alpine
    container_name: redis
    command: redis-server --requirepass ${REDIS_PASSWORD:?REDIS_PASSWORD required}
    ports:
      - "6379:6379"
    volumes:
      - redis_data:/data
    networks:
      - microservices-network
    healthcheck:
      test: ["CMD", "redis-cli", "--raw", "incr", "ping"]
      interval: 10s
      timeout: 3s
      retries: 5

  # Kafka Service
  zookeeper:
    image: confluentinc/cp-zookeeper:7.4.0
    container_name: zookeeper
    environment:
      ZOOKEEPER_CLIENT_PORT: 2181
      ZOOKEEPER_TICK_TIME: 2000
    networks:
      - microservices-network

  kafka:
    image: confluentinc/cp-kafka:7.4.0
    container_name: kafka
    depends_on:
      - zookeeper
    ports:
      - "9092:9092"
    environment:
      KAFKA_BROKER_ID: 1
      KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181
      KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: PLAINTEXT:PLAINTEXT,PLAINTEXT_HOST:PLAINTEXT
      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://kafka:29092,PLAINTEXT_HOST://localhost:9092
      KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1
      KAFKA_TRANSACTION_STATE_LOG_MIN_ISR: 1
      KAFKA_TRANSACTION_STATE_LOG_REPLICATION_FACTOR: 1
      KAFKA_AUTO_CREATE_TOPICS_ENABLE: "true"
      # Fix for cluster ID mismatch issues
      KAFKA_CLUSTER_ID: "microservices-cluster-${RANDOM:-12345}"
      KAFKA_LOG_DIRS: "/var/lib/kafka/data"
      KAFKA_NUM_PARTITIONS: 3
      KAFKA_DEFAULT_REPLICATION_FACTOR: 1
      # Auto-cleanup settings
      KAFKA_LOG_RETENTION_HOURS: 168
      KAFKA_LOG_SEGMENT_BYTES: 1073741824
      KAFKA_LOG_CLEANUP_POLICY: "delete"
    volumes:
      - kafka_data:/var/lib/kafka/data
    networks:
      - microservices-network
    healthcheck:
      test:
        [
          "CMD",
          "kafka-broker-api-versions",
          "--bootstrap-server",
          "localhost:9092",
        ]
      interval: 30s
      timeout: 10s
      retries: 5
      start_period: 60s

  # API Gateway
  api-gateway:
    build:
      context: .
      dockerfile: api-gateway/Dockerfile
    container_name: api-gateway
    ports:
      - "8080:8080"
    environment:
      - SPRING_PROFILES_ACTIVE=docker
      - AUTH_SERVICE_URL=http://auth-service:8082
      - USER_SERVICE_URL=http://user-service:8081
      - ORDER_SERVICE_URL=http://order-service:8083
      - INVENTORY_SERVICE_URL=http://inventory-service:8084
      - NOTIFICATION_SERVICE_URL=http://notification-service:8085
    entrypoint: ["sh", "-lc", "exec /opt/java/openjdk/bin/java -jar app.jar"]
    depends_on:
      - auth-service
      - user-service
      - order-service
      - inventory-service
      - notification-service
    networks:
      - microservices-network
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8080/actuator/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  # Auth Service
  auth-service:
    build:
      context: .
      dockerfile: auth-service/Dockerfile
    container_name: auth-service
    ports:
      - "8082:8082"
    environment:
      - SPRING_PROFILES_ACTIVE=docker
      - DB_URL=jdbc:postgresql://postgres-auth:5432/authdb
      - DB_USERNAME=authuser
      - DB_PASSWORD=${DB_PASSWORD:?DB_PASSWORD required}
      - REDIS_HOST=redis
      - REDIS_PASSWORD=${REDIS_PASSWORD:?REDIS_PASSWORD required}
      - KAFKA_BOOTSTRAP_SERVERS=kafka:29092
      - MAIL_HOST=${MAIL_HOST:?MAIL_HOST required}
      - MAIL_PORT=${MAIL_PORT:?MAIL_PORT required}
      - KAFKA_USER_EVENTS_TOPIC=${KAFKA_USER_EVENTS_TOPIC:-user-events-dev}
      - JWT_SECRET=${JWT_SECRET:?JWT_SECRET required}
      - JWT_ACCESS_TOKEN_EXPIRATION=7200000
      - MAIL_USERNAME=${MAIL_USERNAME:?MAIL_USERNAME required}
      - MAIL_PASSWORD=${MAIL_PASSWORD:?MAIL_PASSWORD required}
      - CORS_ALLOWED_ORIGINS=${CORS_ALLOWED_ORIGINS:-http://localhost:3000,http://localhost:5173}
      - ADMIN_USERNAME=${ADMIN_USERNAME:-admin}
      - ADMIN_PASSWORD=${ADMIN_PASSWORD:?ADMIN_PASSWORD required}
      - ADMIN_EMAIL=${ADMIN_EMAIL:-admin@example.com}
      - ADMIN_ENABLED=${ADMIN_ENABLED:-true}
      - INTERNAL_API_KEY=${INTERNAL_API_KEY:?INTERNAL_API_KEY required}
    depends_on:
      postgres-auth:
        condition: service_healthy
      redis:
        condition: service_healthy
      kafka:
        condition: service_healthy
    networks:
      - microservices-network
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8082/actuator/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  # User Service
  user-service:
    build:
      context: .
      dockerfile: user-service/Dockerfile
    container_name: user-service
    ports:
      - "8081:8081"
    environment:
      - SPRING_PROFILES_ACTIVE=docker
      - DATABASE_URL=jdbc:postgresql://postgres-user:5432/userdb
      - DATABASE_USERNAME=useruser
      - DATABASE_PASSWORD=${DB_PASSWORD:?DB_PASSWORD required}
      - REDIS_HOST=redis
      - REDIS_PASSWORD=${REDIS_PASSWORD:?REDIS_PASSWORD required}
      - KAFKA_BOOTSTRAP_SERVERS=kafka:29092
      - AUTH_SERVICE_URL=http://auth-service:8082
      - INTERNAL_API_KEY=${INTERNAL_API_KEY:?INTERNAL_API_KEY required}
      - JWT_SECRET=${JWT_SECRET:?JWT_SECRET required}
      - CORS_ALLOWED_ORIGINS=${CORS_ALLOWED_ORIGINS:-http://localhost:3000,http://localhost:5173}
      - ADMIN_USERNAME=${ADMIN_USERNAME:-admin}
      - ADMIN_EMAIL=${ADMIN_EMAIL:-admin@example.com}
      - ADMIN_FIRST_NAME=${ADMIN_FIRST_NAME:-Admin}
      - ADMIN_LAST_NAME=${ADMIN_LAST_NAME:-User}
      - ADMIN_ENABLED=${ADMIN_ENABLED:-true}
    depends_on:
      postgres-user:
        condition: service_healthy
      redis:
        condition: service_healthy
      kafka:
        condition: service_healthy
      auth-service:
        condition: service_healthy
    networks:
      - microservices-network
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8081/actuator/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  # Order Service
  order-service:
    build:
      context: .
      dockerfile: order-service/Dockerfile
    container_name: order-service
    ports:
      - "8083:8083"
    environment:
      - SPRING_PROFILES_ACTIVE=docker
      - DB_URL=jdbc:postgresql://postgres-order:5432/orderdb
      - DB_USERNAME=orderuser
      - DB_PASSWORD=${DB_PASSWORD:?DB_PASSWORD required}
      - REDIS_HOST=redis
      - REDIS_PASSWORD=${REDIS_PASSWORD:?REDIS_PASSWORD required}
      - KAFKA_BOOTSTRAP_SERVERS=kafka:29092
      - AUTH_SERVICE_URL=http://auth-service:8082
      - USER_SERVICE_URL=http://user-service:8081
      - INVENTORY_SERVICE_URL=http://inventory-service:8084
      - INTERNAL_API_KEY=${INTERNAL_API_KEY:?INTERNAL_API_KEY required}
      - JWT_SECRET=${JWT_SECRET:?JWT_SECRET required}
      - CORS_ALLOWED_ORIGINS=${CORS_ALLOWED_ORIGINS:-http://localhost:3000,http://localhost:5173,http://localhost:8080,http://localhost:8081,http://localhost:8082,http://localhost:8083}
    depends_on:
      postgres-order:
        condition: service_healthy
      redis:
        condition: service_healthy
      kafka:
        condition: service_healthy
      auth-service:
        condition: service_healthy
      user-service:
        condition: service_healthy
      inventory-service:
        condition: service_healthy
    networks:
      - microservices-network
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8083/actuator/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  # Inventory Service
  inventory-service:
    build:
      context: .
      dockerfile: inventory-service/Dockerfile
    container_name: inventory-service
    ports:
      - "8084:8084"
    environment:
      - SPRING_PROFILES_ACTIVE=docker
      - DB_URL=jdbc:postgresql://postgres-inventory:5432/inventorydb
      - DB_USERNAME=inventoryuser
      - DB_PASSWORD=${DB_PASSWORD:?DB_PASSWORD required}
      - REDIS_HOST=redis
      - REDIS_PASSWORD=${REDIS_PASSWORD:?REDIS_PASSWORD required}
      - KAFKA_BOOTSTRAP_SERVERS=kafka:29092
      - INTERNAL_API_KEY=${INTERNAL_API_KEY:?INTERNAL_API_KEY required}
      - CORS_ALLOWED_ORIGINS=${CORS_ALLOWED_ORIGINS:-http://localhost:3000,http://localhost:5173,http://localhost:8080,http://localhost:8081,http://localhost:8082,http://localhost:8083,http://localhost:8084}
    depends_on:
      postgres-inventory:
        condition: service_healthy
      redis:
        condition: service_healthy
      kafka:
        condition: service_healthy
    networks:
      - microservices-network
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8084/actuator/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  # Notification Service
  notification-service:
    build:
      context: .
      dockerfile: notification-service/Dockerfile
    container_name: notification-service
    ports:
      - "8085:8085"
    environment:
      - SPRING_PROFILES_ACTIVE=docker
      - DB_URL=jdbc:postgresql://postgres-notification:5432/notificationdb
      - DB_USERNAME=notificationuser
      - DB_PASSWORD=${DB_PASSWORD:?DB_PASSWORD required}
      - REDIS_HOST=redis
      - REDIS_PASSWORD=${REDIS_PASSWORD:?REDIS_PASSWORD required}
      - KAFKA_BOOTSTRAP_SERVERS=kafka:29092
      - MAIL_HOST=${MAIL_HOST:?MAIL_HOST required}
      - MAIL_PORT=${MAIL_PORT:-587}
      - KAFKA_USER_EVENTS_TOPIC=${KAFKA_USER_EVENTS_TOPIC:-user-events-dev}
      - KAFKA_USER_EVENTS_DLQ_TOPIC=${KAFKA_USER_EVENTS_DLQ_TOPIC:-user-events-dlq-dev}
      - JWT_SECRET=${JWT_SECRET:?JWT_SECRET required}
      - MAIL_USERNAME=${MAIL_USERNAME:?MAIL_USERNAME required}
      - MAIL_PASSWORD=${MAIL_PASSWORD:?MAIL_PASSWORD required}
      - INTERNAL_API_KEY=${INTERNAL_API_KEY:?INTERNAL_API_KEY required}
    depends_on:
      postgres-notification:
        condition: service_healthy
      redis:
        condition: service_healthy
      kafka:
        condition: service_healthy
    networks:
      - microservices-network
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8085/actuator/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  # Monitoring Services
  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    ports:
      - "9090:9090"
    volumes:
      - ./monitoring/prometheus.yml:/etc/prometheus/prometheus.yml
      - prometheus_data:/prometheus
    command:
      - "--config.file=/etc/prometheus/prometheus.yml"
      - "--storage.tsdb.path=/prometheus"
      - "--web.console.libraries=/etc/prometheus/console_libraries"
      - "--web.console.templates=/etc/prometheus/consoles"
      - "--storage.tsdb.retention.time=200h"
      - "--web.enable-lifecycle"
    networks:
      - microservices-network

  # Frontend Application
  frontend:
    build:
      context: ./frontend
      dockerfile: Dockerfile
    container_name: frontend
    ports:
      - "5173:5173"
    environment:
      - VITE_API_BASE_URL=
    depends_on:
      - api-gateway
    networks:
      - microservices-network

  grafana:
    image: grafana/grafana:latest
    container_name: grafana
    ports:
      - "3001:3000"
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=${GRAFANA_PASSWORD:?GRAFANA_PASSWORD required}
    volumes:
      - grafana_data:/var/lib/grafana
      - ./monitoring/grafana/dashboards:/etc/grafana/provisioning/dashboards
      - ./monitoring/grafana/datasources:/etc/grafana/provisioning/datasources
    networks:
      - microservices-network

volumes:
  auth_db_data:
  user_db_data:
  order_db_data:
  inventory_db_data:
  notification_db_data:
  redis_data:
  kafka_data:
  prometheus_data:
  grafana_data:

networks:
  microservices-network:
    driver: bridge