docker-compose.yml

volumes:
  mysql_master_data: {}
  mysql_slave_data: {}
  redis-data: {}
  redis-token-data: {}
  kafka_data: {}
  elasticsearch_data: {}
  users-service-logs: {}
  questions-server-logs: {}

services:
  # Redis 설정
  redis:
    image: redis:latest
    container_name: redis-cache
    ports:
      - "6379:6379"
    volumes:
      - redis-data:/data
    command: redis-server --appendonly yes
    restart: always
    # networks:
    #   - app_network
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 5s
      timeout: 3s
      retries: 5
  
  redis-token:
    image: redis:latest
    container_name: redis-token
    ports:
      - "6380:6380"
    volumes:
      - redis-token-data:/data
      - ./redis.conf:/usr/local/etc/redis/redis.conf # Redis 설정 파일 마운트
    command: redis-server /usr/local/etc/redis/redis.conf --appendonly yes    
    restart: always
    # networks:
    #   - app_network
    healthcheck:
      test: ["CMD", "redis-cli", "-p", "6380", "ping"]
      interval: 5s
      timeout: 3s
      retries: 5

  # MySQL Master 설정
  mysql-master:
    image: mysql:8.0
    container_name: database-master
    environment:
      MYSQL_ROOT_PASSWORD: ${DB_ROOT_PASSWORD}
      MYSQL_DATABASE: ${DB_DATABASE}
      MYSQL_USER: ${DB_USERNAME}
      MYSQL_PASSWORD: ${DB_PASSWORD}
      TZ: Asia/Seoul
    ports:
      - "3307:3306"
    volumes:
      - mysql_master_data:/var/lib/mysql
      - ./mysql-master-init.sql:/docker-entrypoint-initdb.d/init.sql
    command:
      - --character-set-server=utf8mb4
      - --collation-server=utf8mb4_unicode_ci
      - --server-id=1
      - --log-bin=mysql-bin
      - --binlog-format=row
      - --gtid_mode=ON
      - --enforce-gtid-consistency=ON
      - --log-slave-updates=ON
      - --sync_binlog=1
      - --binlog-do-db=project
    # networks:
    #   - app_network
    healthcheck:
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost", "-u", "${DB_USERNAME}", "--password=${DB_PASSWORD}"]
      interval: 10s
      timeout: 5s
      retries: 5

  # MySQL Slave 설정
  mysql-slave:
    image: mysql:8.0
    container_name: database-slave
    environment:
      MYSQL_ROOT_PASSWORD: ${DB_ROOT_PASSWORD}
      MYSQL_DATABASE: ${DB_DATABASE}
      MYSQL_USER: ${DB_USERNAME}
      MYSQL_PASSWORD: ${DB_PASSWORD}
      TZ: Asia/Seoul
    ports:
      - "3308:3306"
    volumes:
      - mysql_slave_data:/var/lib/mysql
      - ./mysql-slave-init.sql:/docker-entrypoint-initdb.d/init.sql
    command:
      - --character-set-server=utf8mb4
      - --collation-server=utf8mb4_unicode_ci
      - --server-id=2
      - --relay-log=mysql-relay-bin
      - --gtid_mode=ON
      - --enforce-gtid-consistency=ON
      - --log-slave-updates=ON
      - --read-only=1
      - --replicate-do-db=project
    depends_on:
      mysql-master:
        condition: service_healthy
    # networks:
    #   - app_network
    healthcheck:
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost", "-u", "${DB_USERNAME}", "--password=${DB_PASSWORD}"]
      interval: 10s
      timeout: 5s
      retries: 5


  spring_paypick:
    # build:
    #   context: ./be
    #   dockerfile: Dockerfile
    container_name: paypick_spring
    image : skyriv213/paypick
    platform: linux/amd64  # 수정된 라인
    restart: always
    ports:
      - "8080:8080"
    environment:
      SPRING_DATASOURCE_URL: jdbc:mysql://database-master:3306/ana?serverTimezone=Asia/Seoul&characterEncoding=UTF-8
      SPRING_DATASOURCE_USERNAME: root
      SPRING_DATASOURCE_PASSWORD: ${DB_PASSWORD}
      SPRING_JPA_HIBERNATE_DDL_AUTO: create
      SPRING_JPA_PROPERTIES_HIBERNATE_DIALECT: org.hibernate.dialect.MySQL8Dialect

  # GPT 애플리케이션 설정
  gpt-app:
    build:
      context: ./gpt_be
      dockerfile: Dockerfile
    container_name: gpt-app
    ports:
      - "8000:8000"
    volumes:
      - ./gpt_be/ssl_cert.pem:/app/ssl_cert.pem:ro
      - ./gpt_be/ssl_key.pem:/app/ssl_key.pem:ro
    environment:
      - MYSQL_HOST=mysql-master
      - MYSQL_USER=${DB_USERNAME}
      - MYSQL_PASSWORD=${DB_PASSWORD}
      - MYSQL_DATABASE=project
      - MYSQL_PORT=3306
      - TZ=Asia/Seoul
      - JWT_SECRET_KEY=${SECRET_KEY}
      - JWT_ALGORITHM=${JWT_ALGORITHM}
      - PERPLEXITY_API_KEY=${PERPLEXITY_API_KEY}
      - SSL_MODE=enabled
    depends_on:
      mysql-master:
        condition: service_healthy
    # networks:
    #   - app_network
    restart: unless-stopped
    # healthcheck:
    #   test: ["CMD", "curl", "-f", "http://localhost:8000/health"]
    #   interval: 10s
    #   timeout: 5s
    #   retries: 3
    #   start_period: 30s

  # Nginx 설정
  nginx:
    image: nginx
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx/nginx.conf:/etc/nginx/nginx.conf:ro
      - ./nginx/logs:/var/log/nginx
      - ./nginx/letsencrypt-ssl/certificate.crt:/etc/nginx/ssl/certificate.crt
      - ./nginx/letsencrypt-ssl/private.key:/etc/nginx/ssl/private.key
    depends_on:
      user-service:
        condition: service_healthy      
      questions-server:
        condition: service_healthy
      gpt-app:
        condition: service_started
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:80/", "--max-time", "5"]
      interval: 30s
      timeout: 10s
      retries: 3
    # networks:
    #   - app_network  

  user-service:
    build:
      context: ./users-service
      dockerfile: Dockerfile
    container_name: user-service
    ports:
      - "8441:8441"
    # volumes:
    #   - ./shared-keystore.p12:/app/keystore.p12:ro
    environment:
      - SPRING_DATASOURCE_MASTER_URL=${DB_MASTER_URL}
      - SPRING_DATASOURCE_MASTER_USERNAME=${DB_USERNAME}
      - SPRING_DATASOURCE_MASTER_PASSWORD=${DB_PASSWORD}
      - SPRING_DATASOURCE_SLAVE_URL=${DB_SLAVE_URL}
      - SPRING_DATASOURCE_SLAVE_USERNAME=${DB_USERNAME}
      - SPRING_DATASOURCE_SLAVE_PASSWORD=${DB_PASSWORD}
      - TZ=Asia/Seoul
      - SECRET_KEY=${SECRET_KEY}
      - JWT_ALGORITHM=HS256
      - KAKAO_CLIENT_ID=${KAKAO_CLIENT_ID}
      - KAKAO_CLIENT_SECRET=${KAKAO_CLIENT_SECRET}
      - GOOGLE_CLIENT_ID=${GOOGLE_CLIENT_ID}
      - GOOGLE_CLIENT_SECRET=${GOOGLE_CLIENT_SECRET}
      - SPRING_DATA_REDIS_HOST=${SPRING_DATA_REDIS_HOST}
      - SPRING_DATA_REDIS_PORT=${SPRING_DATA_REDIS_PORT}
      - SPRING_DATA_REDIS_TOKEN_HOST=${SPRING_DATA_REDIS_TOKEN_HOST}
      - SPRING_DATA_REDIS_TOKEN_PORT=${SPRING_DATA_REDIS_TOKEN_PORT}
    depends_on:
      redis:
        condition: service_healthy
      redis-token:
        condition: service_healthy
      mysql-master:
        condition: service_healthy
      mysql-slave:
        condition: service_healthy
    volumes:
      - users-service-logs:/app/logs/app
    healthcheck:
      test: ["CMD", "curl", "-f", "https://localhost:8441/actuator/health", "--insecure"]
      interval: 30s
      timeout: 10s
      retries: 5
      start_period: 60s
    restart: unless-stopped

  questions-server:
    build:
      context: ./questions-server
      dockerfile: Dockerfile
    container_name: questions-server
    ports:
      - "8442:8442"
    # volumes:
    #   - ./shared-keystore.p12:/app/keystore.p12:ro
    environment:
      - SPRING_DATASOURCE_MASTER_URL=${DB_MASTER_URL}
      - SPRING_DATASOURCE_MASTER_USERNAME=${DB_USERNAME}
      - SPRING_DATASOURCE_MASTER_PASSWORD=${DB_PASSWORD}
      - SPRING_DATASOURCE_SLAVE_URL=${DB_SLAVE_URL}
      - SPRING_DATASOURCE_SLAVE_USERNAME=${DB_USERNAME}
      - SPRING_DATASOURCE_SLAVE_PASSWORD=${DB_PASSWORD}
      - SPRING_DATA_REDIS_HOST=${SPRING_DATA_REDIS_HOST}
      - SPRING_DATA_REDIS_PORT=${SPRING_DATA_REDIS_PORT}
      - SPRING_DATA_REDIS_TOKEN_HOST=${SPRING_DATA_REDIS_TOKEN_HOST}
      - SPRING_DATA_REDIS_TOKEN_PORT=${SPRING_DATA_REDIS_TOKEN_PORT}
      - TZ=Asia/Seoul
      - SECRET_KEY=${SECRET_KEY}
      - JWT_ALGORITHM=HS256
    depends_on:
      redis:
        condition: service_healthy
      redis-token:
        condition: service_healthy
      mysql-master:
        condition: service_healthy
      mysql-slave:
        condition: service_healthy
    healthcheck:
      test: ["CMD", "curl", "-f", "https://localhost:8442/actuator/health", "--insecure"]
      interval: 30s
      timeout: 10s
      retries: 5
      start_period: 60s
    volumes:
      - questions-server-logs:/app/logs/app
    restart: unless-stopped

  filebeat:
    image: docker.elastic.co/beats/filebeat:8.15.2
    user: root
    volumes:
      - ./filebeat/filebeat.yml:/usr/share/filebeat/filebeat.yml
      - ./filebeat/log:/var/log/app
      - ./nginx/logs:/var/log/nginx
      - users-service-logs:/var/log/app/users-service
      - questions-server-logs:/var/log/app/questions-server
    command: filebeat -e -c /usr/share/filebeat/filebeat.yml
    depends_on:
      - user-service
      - questions-server
      - nginx
      - kafka

  kafka:
    image: confluentinc/cp-kafka:7.4.0
    container_name: kafka
    user: "0:0"  # Run as root to avoid permission issues
    ports:
      - "9092:9092"
    environment:
      KAFKA_KRAFT_MODE: "true"
      KAFKA_NODE_ID: 1
      CLUSTER_ID: "MkU3OEVBNjU1NTY0MDk5Qg"
      KAFKA_LISTENERS: PLAINTEXT://:9092,CONTROLLER://:9093
      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://kafka:9092
      KAFKA_CONTROLLER_QUORUM_VOTERS: "1@kafka:9093"
      KAFKA_CONTROLLER_LISTENER_NAMES: "CONTROLLER"
      KAFKA_PROCESS_ROLES: "broker,controller"
      KAFKA_LOG_DIRS: "/var/kafka-logs"
      KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1
      KAFKA_TRANSACTION_STATE_LOG_REPLICATION_FACTOR: 1
      KAFKA_TRANSACTION_STATE_LOG_MIN_ISR: 1
      KAFKA_AUTO_CREATE_TOPICS_ENABLE: "true"
    volumes:
      - kafka_data:/var/kafka-logs
    healthcheck:
      test: ["CMD-SHELL", "kafka-topics --bootstrap-server localhost:9092 --list"]
      interval: 30s
      timeout: 10s
      retries: 3

    # Elasticsearch
  elasticsearch:
    image: docker.elastic.co/elasticsearch/elasticsearch:8.11.0
    platform: linux/amd64
    container_name: elasticsearch
    environment:
      - discovery.type=single-node
      - xpack.security.enabled=false
      - "ES_JAVA_OPTS=-Xms512m -Xmx512m"
    ports:
      - "9200:9200"
    volumes:
      - elasticsearch_data:/usr/share/elasticsearch/data
    healthcheck:
      test: ["CMD-SHELL", "curl -f http://localhost:9200/_cluster/health || exit 1"]
      interval: 30s
      timeout: 10s
      retries: 3
    # Logstash
  logstash:
    image: docker.elastic.co/logstash/logstash:8.11.0
    container_name: logstash
    volumes:
      - ./logstash/logstash.conf:/usr/share/logstash/pipeline/logstash.conf
    environment:
      LS_JAVA_OPTS: "-Xmx256m -Xms256m"
    depends_on:
      kafka:
        condition: service_healthy
      elasticsearch:
        condition: service_healthy
    healthcheck:
      test: ["CMD-SHELL", "curl -f http://localhost:9600 || exit 1"]
      interval: 30s
      timeout: 10s
      retries: 3

    # Kibana
  kibana:
    image: docker.elastic.co/kibana/kibana:8.11.0
    container_name: kibana
    ports:
      - "5601:5601"
    environment:
      - ELASTICSEARCH_HOSTS=http://elasticsearch:9200
    depends_on:
      elasticsearch:
        condition: service_healthy


  kafka-init:
    image: confluentinc/cp-kafka:7.4.0
    volumes:
      - ./kafka/kafka-init.sh:/kafka-init.sh
    command: sh /kafka-init.sh
    depends_on:
      kafka:
        condition: service_healthy
  # networks:
#   app_network:
#     driver: bridge