docker-compose.yml

version: "3.8"

services:
  rushdeal_postgres:
    image: postgres:16-alpine
    container_name: rushdeal_postgres
    restart: unless-stopped
    environment:
      POSTGRES_DB: ${DB_URL}
      POSTGRES_USER: ${DB_USERNAME}
      POSTGRES_PASSWORD: ${DB_PASSWORD}
    ports:
      - "15432:5432"
    volumes:
      - rushdeal_pg_data:/var/lib/postgresql/data
      - ./scripts/init-schemas.sql:/docker-entrypoint-initdb.d/init-schemas.sql
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U ${DB_USERNAME} -d ${DB_URL}"]
      interval: 10s
      timeout: 5s
      retries: 5
    networks:
      - rushdeal-network

  rushdeal_auth_redis:
    image: redis:7-alpine
    container_name: rushdeal_auth_redis
    restart: unless-stopped
    ports:
      - "6378:6379"
    volumes:
      - rushdeal_auth_redis_data:/data
    command: redis-server --save 60 1 --loglevel warning
    healthcheck:
      test: [ "CMD", "redis-cli", "ping" ]
      interval: 5s
      timeout: 3s
      retries: 5
    networks:
      - rushdeal-network

  rushdeal_user_redis:
    image: redis:7-alpine
    container_name: rushdeal_user_redis
    restart: unless-stopped
    ports:
      - "6379:6379"
      - "6383:6379"
    volumes:
      - rushdeal_user_redis_data:/data
    healthcheck:
      test: [ "CMD", "redis-cli", "ping" ]
      interval: 5s
      timeout: 3s
      retries: 5
    networks:
     - rushdeal-network
    command: redis-server --save 60 1 --loglevel warning

  rushdeal_queue_redis: # 서비스 이름은 rushdeal_redis로 설정합니다.
    image: redis:7-alpine
    container_name: rushdeal_queue_redis
    restart: unless-stopped
    ports:
      - "6380:6379" # 6379가 Redis 기본 포트이나, 호스트 포트를 6380으로 설정하여 기존 충돌을 피합니다.
    volumes:
      - rushdeal_queue_redis_data:/data # 데이터 영속성을 위한 볼륨
    command: redis-server --save 60 1 --loglevel warning # 개발 중 데이터 날아가는거 방지 위해 60초마다 스냅샷 저장
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 5s
      timeout: 3s
      retries: 5
    networks:
      - rushdeal-network

  rushdeal_order_redis:
    image: redis:7-alpine
    container_name: rushdeal_order_redis
    restart: unless-stopped
    ports:
      - "6381:6379"
    volumes:
      - rushdeal_order_redis_data:/data
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 5s
      timeout: 3s
      retries: 5


  rushdeal_timedeal_redis:
    image: redis:7-alpine
    container_name: rushdeal_timedeal_redis
    restart: unless-stopped
    ports:
      - "6382:6379"
    volumes:
      - rushdeal_timedeal_redis_data:/data
    healthcheck:
      test: [ "CMD", "redis-cli", "ping" ]
      interval: 5s
      timeout: 3s
      retries: 5
    networks:
      - rushdeal-network



  redisinsight:
    image: redis/redisinsight:latest
    container_name: rushdeal_redisinsight
    restart: unless-stopped
    ports:
      - "5540:5540"
    depends_on:
      - rushdeal_queue_redis
      - rushdeal_order_redis
      - rushdeal_timedeal_redis
      - rushdeal_user_redis


  zookeeper:
    image: confluentinc/cp-zookeeper:7.5.0
    container_name: rushdeal_zookeeper
    platform: linux/amd64
    ports:
      - "2181:2181"
    environment:
      ZOOKEEPER_CLIENT_PORT: 2181
      ZOOKEEPER_TICK_TIME: 2000
    networks:
      - rushdeal-network
      
  kafka:
    image: confluentinc/cp-kafka:7.5.0
    container_name: rushdeal_kafka
    platform: linux/amd64
    ports:
      - "9092:9092"
    environment:
      KAFKA_BROKER_ID: 1
      KAFKA_ZOOKEEPER_CONNECT: rushdeal_zookeeper:2181
      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://kafka:29092,PLAINTEXT_HOST://localhost:9092
      KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: PLAINTEXT:PLAINTEXT,PLAINTEXT_HOST:PLAINTEXT
      KAFKA_INTER_BROKER_LISTENER_NAME: PLAINTEXT
      KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1
      KAFKA_HEAP_OPTS: "-Xmx512M -Xms256M"
    depends_on:
      - zookeeper
    networks:
      - rushdeal-network

  kafka-ui:
    image: provectuslabs/kafka-ui:latest
    container_name: rushdeal_kafka_ui
    platform: linux/amd64
    ports:
      - "18080:8080"
    environment:
      KAFKA_CLUSTERS_0_NAME: local
      KAFKA_CLUSTERS_0_BOOTSTRAPSERVERS: kafka:29092
      KAFKA_CLUSTERS_0_ZOOKEEPER: zookeeper:2181
    depends_on:
      - kafka
    networks:
      - rushdeal-network

  # Discovery Service (Eureka)
  discovery-service:
    container_name: rushdeal_eureka
    build:
      context: .
      dockerfile: Dockerfile
      args:
        SERVICE_NAME: discovery-service
    environment:
      SPRING_PROFILES_ACTIVE: ${SPRING_PROFILES_ACTIVE:-local}
      SERVER_PORT: 8761
      MANAGEMENT_METRICS_TAGS_APPLICATION: discovery-service
    ports:
      - "8761:8761"
    networks:
      rushdeal-network:
        aliases:
          - rushdeal-eureka
          - eureka
    restart: unless-stopped

  # =========================================
  # [MSA 서비스] 스프링 부트 앱 설정
  # =========================================

  auth-service:
    container_name: rushdeal_auth_service
    build:
      context: .
      dockerfile: Dockerfile
      args:
        SERVICE_NAME: auth-service
    environment:
      # Spring
      SPRING_PROFILES_ACTIVE: ${SPRING_PROFILES_ACTIVE:-local}
      SERVER_PORT: ${AUTH_SERVER_PORT:-8000}

      # Database
      DB_URL: ${DB_URL}
      DB_USERNAME: ${DB_USERNAME}
      DB_PASSWORD: ${DB_PASSWORD}

      # Redis
      AUTH_REDIS_HOST: ${AUTH_REDIS_HOST}
      AUTH_REDIS_PORT: 6379
      REDIS_PASSWORD: ${REDIS_PASSWORD}

      # JWT
      JWT_ACCESS_SECRET: ${JWT_ACCESS_SECRET}
      JWT_ACCESS_EXPIRED: ${JWT_ACCESS_EXPIRED:-3600000}
      JWT_REFRESH_SECRET: ${JWT_REFRESH_SECRET}
      JWT_REFRESH_EXPIRED: ${JWT_REFRESH_EXPIRED:-604800000}

      EUREKA_URL: ${EUREKA_URL}
      # Auth Config
      AUTH_MAX_CONCURRENT_SESSIONS: ${AUTH_MAX_CONCURRENT_SESSIONS:-3}

      # Zipkin
      MANAGEMENT_ZIPKIN_TRACING_ENDPOINT: http://zipkin:9411/api/v2/spans
      MANAGEMENT_METRICS_TAGS_APPLICATION: auth-service
    ports:
      - "${AUTH_SERVER_PORT:-8000}:${AUTH_SERVER_PORT:-8000}"
    depends_on:
      discovery-service:
        condition: service_started
      rushdeal_postgres:
        condition: service_healthy
      rushdeal_auth_redis:
        condition: service_healthy
    networks:
      - rushdeal-network
    restart: unless-stopped

  user-service:
    container_name: rushdeal_user_service
    build:
      context: .
      dockerfile: Dockerfile
      args:
        SERVICE_NAME: user-service
    environment:
      SPRING_PROFILES_ACTIVE: ${SPRING_PROFILES_ACTIVE:-local}
      SERVER_PORT: ${USER_SERVER_PORT:-8060}
      DB_URL: ${DB_URL}
      DB_USERNAME: ${DB_USERNAME}
      DB_PASSWORD: ${DB_PASSWORD}
      SPRING_DATA_REDIS_HOST: ${USER_REDIS_HOST}
      SPRING_DATA_REDIS_PORT: ${USER_REDIS_PORT:-6379}
      SPRING_DATA_REDIS_PASSWORD: ${REDIS_PASSWORD}
      EUREKA_ENABLED: ${EUREKA_ENABLED:-false}
      EUREKA_URL: ${EUREKA_URL}
      JPA_DDL_AUTO: ${JPA_DDL_AUTO:-update}
      MANAGEMENT_ZIPKIN_TRACING_ENDPOINT: http://zipkin:9411/api/v2/spans
      MANAGEMENT_METRICS_TAGS_APPLICATION: user-service
    ports:
      - "${USER_SERVER_PORT:-8060}:${USER_SERVER_PORT:-8060}"
    depends_on:
      rushdeal_postgres:
        condition: service_healthy
      rushdeal_user_redis:
        condition: service_healthy
    networks:
      - rushdeal-network
    restart: unless-stopped

  order-service:
    build:
      context: .
      dockerfile: Dockerfile
      args:
        SERVICE_NAME: order-service
    container_name: rushdeal_order_service
    environment:
      SPRING_PROFILES_ACTIVE: ${SPRING_PROFILES_ACTIVE:-local}
      SERVER_PORT: ${ORDER_SERVER_PORT:-8050}
      DB_URL: ${DB_URL}
      DB_USERNAME: ${DB_USERNAME}
      DB_PASSWORD: ${DB_PASSWORD}
      SPRING_DATA_REDIS_HOST: ${ORDER_REDIS_HOST}
      SPRING_DATA_REDIS_PORT: 6379
      SPRING_DATA_REDIS_PASSWORD: ${REDIS_PASSWORD}
      KAFKA_BROKERS: ${KAFKA_BROKERS}
      EUREKA_ENABLED: ${EUREKA_ENABLED:-false}
      EUREKA_URL: ${EUREKA_URL}
      JPA_DDL_AUTO: ${JPA_DDL_AUTO:-update}
      SHOW_SQL: ${SHOW_SQL:-false}
      SQL_INIT_MODE: ${SQL_INIT_MODE:-never}
      QUARTZ_INIT_SCHEMA: ${QUARTZ_INIT_SCHEMA:-never}
      QUARTZ_THREAD_COUNT: ${QUARTZ_THREAD_COUNT:-10}
      MANAGEMENT_ZIPKIN_TRACING_ENDPOINT: http://zipkin:9411/api/v2/spans
      MANAGEMENT_METRICS_TAGS_APPLICATION: order-service
    ports:
      - "${ORDER_SERVER_PORT:-8050}:${ORDER_SERVER_PORT:-8050}"
    depends_on:
      rushdeal_postgres:
        condition: service_healthy
      rushdeal_order_redis:
        condition: service_healthy
      kafka:
        condition: service_started
    networks:
      - rushdeal-network
    restart: unless-stopped

  payment-service:
    build:
      context: .
      dockerfile: Dockerfile
      args:
        SERVICE_NAME: payment-service
    container_name: rushdeal_payment_service
    environment:
      SPRING_PROFILES_ACTIVE: ${SPRING_PROFILES_ACTIVE:-local}
      SERVER_PORT: ${PAYMENT_SERVER_PORT:-8010}
      DB_URL: ${DB_URL}
      DB_USERNAME: ${DB_USERNAME}
      DB_PASSWORD: ${DB_PASSWORD}
      EUREKA_ENABLED: ${EUREKA_ENABLED:-false}
      EUREKA_URL: ${EUREKA_URL}
      JPA_DDL_AUTO: ${JPA_DDL_AUTO:-update}
      SHOW_SQL: ${SHOW_SQL:-false}
      PORTONE_API_SECRET: ${PORTONE_API_SECRET}
      PORTONE_STORE_ID: ${PORTONE_STORE_ID}
      PORTONE_CHANNEL_KEY: ${PORTONE_CHANNEL_KEY}
      PORTONE_WEBHOOK: ${PORTONE_WEBHOOK}
      MANAGEMENT_ZIPKIN_TRACING_ENDPOINT: http://zipkin:9411/api/v2/spans
      MANAGEMENT_METRICS_TAGS_APPLICATION: payment-service
    ports:
      - "${PAYMENT_SERVER_PORT:-8010}:${PAYMENT_SERVER_PORT:-8010}"
    depends_on:
      rushdeal_postgres:
        condition: service_healthy
    networks:
      - rushdeal-network
    restart: unless-stopped

  product-service:
    build:
      context: .
      dockerfile: Dockerfile
      args:
        SERVICE_NAME: product-service
    container_name: rushdeal_product_service
    environment:
      SPRING_PROFILES_ACTIVE: ${SPRING_PROFILES_ACTIVE:-local}
      SERVER_PORT: ${PRODUCT_SERVER_PORT:-8020}
      DB_URL: ${DB_URL}
      DB_USERNAME: ${DB_USERNAME}
      DB_PASSWORD: ${DB_PASSWORD}
      EUREKA_ENABLED: ${EUREKA_ENABLED:-false}
      EUREKA_URL: ${EUREKA_URL}
      JPA_DDL_AUTO: ${JPA_DDL_AUTO:-update}
      SHOW_SQL: ${SHOW_SQL:-false}
      SQL_INIT_MODE: ${SQL_INIT_MODE:-never}
      MANAGEMENT_ZIPKIN_TRACING_ENDPOINT: http://zipkin:9411/api/v2/spans
      MANAGEMENT_METRICS_TAGS_APPLICATION: product-service
    ports:
      - "${PRODUCT_SERVER_PORT:-8020}:${PRODUCT_SERVER_PORT:-8020}"
    depends_on:
      rushdeal_postgres:
        condition: service_healthy
    networks:
      - rushdeal-network
    restart: unless-stopped

  queue-service:
    build:
      context: .
      dockerfile: Dockerfile
      args:
        SERVICE_NAME: queue-service
    container_name: rushdeal_queue_service
    environment:
      SPRING_PROFILES_ACTIVE: ${SPRING_PROFILES_ACTIVE:-local}
      SERVER_PORT: ${QUEUE_SERVER_PORT:-8040}
      DB_URL: ${DB_URL}
      DB_USERNAME: ${DB_USERNAME}
      DB_PASSWORD: ${DB_PASSWORD}
      QUEUE_REDIS_HOST: ${QUEUE_REDIS_HOST}
      QUEUE_REDIS_PORT: 6379
      KAFKA_BROKERS: ${KAFKA_BROKERS}
      EUREKA_ENABLED: ${EUREKA_ENABLED:-false}
      EUREKA_URL: ${EUREKA_URL}
      JPA_DDL_AUTO: ${JPA_DDL_AUTO:-update}
      SHOW_SQL: ${SHOW_SQL:-false}
      MANAGEMENT_ZIPKIN_TRACING_ENDPOINT: http://zipkin:9411/api/v2/spans
      MANAGEMENT_METRICS_TAGS_APPLICATION: queue-service
    ports:
      - "${QUEUE_SERVER_PORT:-8040}:${QUEUE_SERVER_PORT:-8040}"
    depends_on:
      rushdeal_postgres:
        condition: service_healthy
      rushdeal_queue_redis:
        condition: service_healthy
      kafka:
        condition: service_started
    networks:
      - rushdeal-network
    restart: unless-stopped

  timedeal-service:
    build:
      context: .
      dockerfile: Dockerfile
      args:
        SERVICE_NAME: timedeal-service
    container_name: rushdeal_timedeal_service
    environment:
      SPRING_PROFILES_ACTIVE: ${SPRING_PROFILES_ACTIVE:-local}
      SERVER_PORT: ${TIMEDEAL_SERVER_PORT:-8030}
      DB_URL: ${DB_URL}
      DB_USERNAME: ${DB_USERNAME}
      DB_PASSWORD: ${DB_PASSWORD}
      TIMEDEAL_REDIS_HOST: ${TIMEDEAL_REDIS_HOST}
      TIMEDEAL_REDIS_PORT: 6379
      BOOTSTRAP_SERVERS: ${KAFKA_BROKERS}
      EUREKA_ENABLED: ${EUREKA_ENABLED:-false}
      EUREKA_URL: ${EUREKA_URL}
      JPA_DDL_AUTO: ${JPA_DDL_AUTO:-update}
      SHOW_SQL: ${SHOW_SQL:-false}
      SQL_INIT_MODE: ${SQL_INIT_MODE:-never}
      MANAGEMENT_ZIPKIN_TRACING_ENDPOINT: http://zipkin:9411/api/v2/spans
      MANAGEMENT_METRICS_TAGS_APPLICATION: timedeal-service
    ports:
      - "${TIMEDEAL_SERVER_PORT:-8030}:${TIMEDEAL_SERVER_PORT:-8030}"
    depends_on:
      rushdeal_postgres:
        condition: service_healthy
      rushdeal_timedeal_redis:
        condition: service_healthy
      kafka:
        condition: service_started
    networks:
      - rushdeal-network
    restart: unless-stopped

volumes:
  rushdeal_pg_data:
  rushdeal_auth_redis_data:
  rushdeal_user_redis_data:
  rushdeal_queue_redis_data:
  rushdeal_order_redis_data:
  rushdeal_timedeal_redis_data:

networks:
  rushdeal-network:
    driver: bridge