docker-compose.yml

services:
  mysql:
    image: mysql:8.0
    container_name: mysql
    environment:
      MYSQL_DATABASE: ${MYSQL_DATABASE}
      MYSQL_ROOT_PASSWORD: ${MYSQL_ROOT_PASSWORD}
      MYSQL_USERNAME: ${MYSQL_USERNAME}
      MYSQL_PASSWORD: ${MYSQL_PASSWORD}
      TZ: Asia/Seoul
    ports:
      - "3306:3306"
    volumes:
      - mysql_data:/var/lib/mysql
    networks:
      - app-network
    healthcheck:
      test: ["CMD", "mysqladmin" ,"ping", "-h", "localhost", "-u${MYSQL_USERNAME}", "-p${MYSQL_PASSWORD}"]
      interval: 10s
      timeout: 5s
      retries: 5
      start_period: 30s

  redis:
    image: redis
    container_name: redis
    environment:
      TZ: Asia/Seoul
    ports:
      - "6379:6379"
    command: redis-server --requirepass ${REDIS_PASSWORD}
    volumes:
      - redis_data:/data
    networks:
      - app-network
    healthcheck:
      test: ["CMD", "redis-cli", "-a", "${REDIS_PASSWORD}", "ping"]
      interval: 10s
      timeout: 5s
      retries: 5

  mongo:
    image: mongo
    container_name: mongo
    environment:
      MONGO_INITDB_ROOT_USERNAME: ${MONGO_INITDB_ROOT_USERNAME}
      MONGO_INITDB_ROOT_PASSWORD: ${MONGO_INITDB_ROOT_PASSWORD}
      TZ: Asia/Seoul
    ports:
      - "27017:27017"
    volumes:
      - mongo_data:/data/db
    networks:
      - app-network
    healthcheck:
      test: |
        mongosh \
          --host localhost \
          --port 27017 \
          --username "${MONGO_INITDB_ROOT_USERNAME}" \
          --password "${MONGO_INITDB_ROOT_PASSWORD}" \
          --authenticationDatabase admin \
          --quiet \
          --eval 'quit(db.runCommand({ ping: 1 }).ok ? 0 : 1)'
      interval: 10s
      timeout: 5s
      retries: 5
      start_period: 30s

  nginx:
    image: ${NGINX_IMAGE_NAME}:${NGINX_IMAGE_TAG}
    container_name: nginx
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - /etc/letsencrypt:/etc/letsencrypt
    depends_on:
      springboot:
        condition: service_started
      fastapi:
        condition: service_started
    networks:
      - app-network
    environment:
      TZ: Asia/Seoul

  springboot:
    # build:
    #   context: ./server/springboot
    #   dockerfile: spring-dockerfile
    image: ${SPRINGBOOT_IMAGE_NAME}:${SPRINGBOOT_IMAGE_TAG}
    container_name: springboot
    ports:
      - "8088:8088"
    depends_on:
      mysql:
        condition: service_healthy
      redis:
        condition: service_healthy
    environment:
      # 🔧 File Storage
      FILE_STORAGE_PATH: ${FILE_STORAGE_PATH}
      LANG: C.UTF-8
      LC_ALL: C.UTF-8
      JAVA_TOOL_OPTIONS: -Dfile.encoding=UTF-8
      TZ: Asia/Seoul

      # 🛢️ Database (MySQL)
      MYSQL_URL: ${MYSQL_URL}
      MYSQL_DATABASE: ${MYSQL_DATABASE}
      MYSQL_ROOT_USER: ${MYSQL_ROOT_USER}
      MYSQL_ROOT_PASSWORD: ${MYSQL_ROOT_PASSWORD}

      # 🔑 JWT
      JWT_SECRET: ${JWT_SECRET}
      JWT_ACCESS_TOKEN_EXPIRATION: ${JWT_ACCESS_TOKEN_EXPIRATION}
      JWT_REFRESH_TOKEN_EXPIRATION: ${JWT_REFRESH_TOKEN_EXPIRATION}
      JWT_TEMPORARY_TOKEN_EXPIRATION: ${JWT_TEMPORARY_TOKEN_EXPIRATION}

      # 🔌 Redis
      REDIS_HOST: ${REDIS_HOST}
      REDIS_PORT: ${REDIS_PORT}
      REDIS_PASSWORD: ${REDIS_PASSWORD}
      REDIS_TTL: ${REDIS_TTL}

      # 🖥️ Server
      SERVER_PORT: ${SERVER_PORT}

      # 📋 Logging Levels
      LOG_LEVEL_ROOT: ${LOG_LEVEL_ROOT}
      LOG_LEVEL_SPRING_WEB: ${LOG_LEVEL_SPRING_WEB}
      LOG_LEVEL_APP: ${LOG_LEVEL_APP}
      LOG_LEVEL_MYBATIS: ${LOG_LEVEL_MYBATIS}

      # Spring Profile
      SPRING_PROFILES_ACTIVE: ${SPRING_PROFILES_ACTIVE}

      # WebAuthn
      WEBAUTHN_RP_ID: ${WEBAUTHN_RP_ID}
      WEBAUTHN_RP_NAME: ${WEBAUTHN_RP_NAME}
      WEBAUTHN_RP_ORIGIN: ${WEBAUTHN_RP_ORIGIN}

      # Cookie Domain
      APP_COOKIE_DOMAIN: ${APP_COOKIE_DOMAIN}

      # Cool SMS
      COOLSMS_API_KEY: ${COOLSMS_API_KEY}
      COOLSMS_API_SECRET: ${COOLSMS_API_SECRET}
      COOLSMS_SENDER_PHONE: ${COOLSMS_SENDER_PHONE}

      # Image
      SPRINGBOOT_IMAGE_NAME: ${SPRINGBOOT_IMAGE_NAME}
      FASTAPI_IMAGE_NAME: ${FASTAPI_IMAGE_NAME}
      NGINX_IMAGE_NAME: ${NGINX_IMAGE_NAME}

      # FastAPI 연동
      FASTAPI_BASE_URL: ${FASTAPI_BASE_URL}

      # AWS
      AWS_ACCESS_KEY_ID: ${AWS_ACCESS_KEY_ID}
      AWS_SECRET_ACCESS_KEY: ${AWS_SECRET_ACCESS_KEY}
      AWS_S3_BUCKET: ${AWS_S3_BUCKET}
      AWS_REGION: ${AWS_REGION}
    networks:
      - app-network
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8088/actuator/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  springboot-test: # 테스트용 스프링 부트 서버
    image: ${SPRINGBOOT_IMAGE_NAME}:${SPRINGBOOT_IMAGE_TAG}
    container_name: springboot-test
    ports:
      - "8089:8088"
    depends_on:
      mysql:
        condition: service_healthy
      redis:
        condition: service_healthy
    environment:
      # 🔧 File Storage
      FILE_STORAGE_PATH_TEST: ${FILE_STORAGE_PATH_TEST:-/tmp/test-storage}
      LANG: C.UTF-8
      LC_ALL: C.UTF-8
      JAVA_TOOL_OPTIONS: -Dfile.encoding=UTF-8
      TZ: Asia/Seoul

      # 🛢️ Database (MySQL)
      MYSQL_URL_TEST: ${MYSQL_URL_TEST}
      MYSQL_DATABASE_TEST: ${MYSQL_DATABASE_TEST}
      MYSQL_ROOT_USER: ${MYSQL_ROOT_USER}
      MYSQL_ROOT_PASSWORD: ${MYSQL_ROOT_PASSWORD}

      # 🔑 JWT - 테스트용 시크릿 사용
      JWT_SECRET_TEST: ${JWT_SECRET_TEST}
      JWT_ACCESS_TOKEN_EXPIRATION: ${JWT_ACCESS_TOKEN_EXPIRATION}
      JWT_REFRESH_TOKEN_EXPIRATION: ${JWT_REFRESH_TOKEN_EXPIRATION}
      JWT_TEMPORARY_TOKEN_EXPIRATION: ${JWT_TEMPORARY_TOKEN_EXPIRATION}

      # 🔌 Redis
      REDIS_HOST: ${REDIS_HOST}
      REDIS_PORT: ${REDIS_PORT}
      REDIS_PASSWORD: ${REDIS_PASSWORD}
      REDIS_TTL_TEST: ${REDIS_TTL_TEST:-60}

      # 🖥️ Server
      SERVER_PORT: 8088

      # Spring Profile - 테스트용 프로필 활성화
      SPRING_PROFILES_ACTIVE: loadtest

      # --- 아래는 테스트 환경에서 주의/분리/모의 처리해야 할 설정들 ---
      # WebAuthn (테스트 시 동작 방식 고려, 필요시 더미 값 또는 비활성화)
      WEBAUTHN_RP_ID_TEST: ${WEBAUTHN_RP_ID_TEST:-localhost}
      WEBAUTHN_RP_NAME_TEST: ${WEBAUTHN_RP_NAME_TEST:-Test RP}
      WEBAUTHN_RP_ORIGIN_TEST: ${WEBAUTHN_RP_ORIGIN_TEST:-http://localhost:8089}

      # Cookie Domain (테스트 환경에 맞게 설정)
      APP_COOKIE_DOMAIN_TEST: ${APP_COOKIE_DOMAIN_TEST:-localhost}

      # Cool SMS (테스트 시 실제 발송되지 않도록 더미 키 사용 또는 모의 처리)
      COOLSMS_API_KEY_TEST: ${COOLSMS_API_KEY_TEST:-TEST_API_KEY}
      COOLSMS_API_SECRET_TEST: ${COOLSMS_API_SECRET_TEST:-TEST_API_SECRET}
      COOLSMS_SENDER_PHONE_TEST: ${COOLSMS_SENDER_PHONE_TEST:-01000000000}

      # Image
      SPRINGBOOT_IMAGE_NAME: ${SPRINGBOOT_IMAGE_NAME}
      FASTAPI_IMAGE_NAME: ${FASTAPI_IMAGE_NAME}
      NGINX_IMAGE_NAME: ${NGINX_IMAGE_NAME}

      # FastAPI 연동 (테스트용 FastAPI가 있다면 그 주소로, 없다면 운영 주소 사용 시 주의)
      FASTAPI_BASE_URL_TEST: ${FASTAPI_BASE_URL_TEST}

      # AWS S3
      AWS_ACCESS_KEY_ID_TEST: ${AWS_ACCESS_KEY_ID_TEST:-TEST_ACCESS_KEY}
      AWS_SECRET_ACCESS_KEY_TEST: ${AWS_SECRET_ACCESS_KEY_TEST:-TEST_SECRET_KEY}
      AWS_S3_BUCKET_TEST: ${AWS_S3_BUCKET_TEST:-test-s3-bucket}
      AWS_REGION_TEST: ${AWS_REGION_TEST:-ap-northeast-2}
    networks:
      - app-network
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8088/actuator/ml/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  fastapi:
    # build:
    #   context: ./server/fastapi-app
    #   dockerfile: python-dockerfile
    image: ${FASTAPI_IMAGE_NAME}:${FASTAPI_IMAGE_TAG}
    container_name: fastapi
    ports:
      - "8000:8000"
    depends_on:
      mongo:
        condition: service_healthy
      springboot:
        condition: service_healthy
    environment:
      MONGO_URI: ${MONGO_URI}
      MONGO_DB: ${MONGO_DB}
      APP_ENV: ${APP_ENV}
      APP_PORT: ${APP_PORT}
      ROBOFLOW_API_KEY: ${ROBOFLOW_API_KEY}
      GEMINI_API_KEY: ${GEMINI_API_KEY}
      PYTHONPATH: ${PYTHONPATH}
      # Spring Boot
      SPRING_API_URL: ${SPRING_API_URL}
      OPENAI_API_KEY: ${OPENAI_API_KEY}
      TZ: Asia/Seoul
    volumes:
      - /home/ubuntu/app/models/weights:/home/ubuntu/app/models/weights
      - /var/lib/jenkins/workspace/pixelro_server-develop/server/fastapi-app/app/vectorstore/medical_knowledge:/app/vectorstore/medical_knowledge
    networks:
      - app-network
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8000/ml/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  fastapi-test:
    # build:
    #   context: ./server/fastapi-app
    #   dockerfile: python-dockerfile
    image: ${FASTAPI_IMAGE_NAME}:${FASTAPI_IMAGE_TAG}
    container_name: fastapi-test
    ports:
      - "8001:8000"
    depends_on:
      mongo:
        condition: service_healthy
      springboot:
        condition: service_healthy
    environment:
      MONGO_URI: ${MONGO_URI_TEST}
      MONGO_URI_TEST: ${MONGO_URI_TEST}
      MONGO_DB: ${MONGO_DB_TEST}
      MONGO_DB_TEST: ${MONGO_DB_TEST}
      APP_ENV: ${APP_ENV}
      APP_PORT: ${APP_PORT}
      ROBOFLOW_API_KEY: ${ROBOFLOW_API_KEY}
      GEMINI_API_KEY: ${GEMINI_API_KEY}
      PYTHONPATH: ${PYTHONPATH}
      # Spring Boot
      SPRING_API_URL: ${SPRING_API_URL_TEST}
      OPENAI_API_KEY: ${OPENAI_API_KEY}
      USE_MOCK: "true"
      TZ: Asia/Seoul
    volumes:
      - /home/ubuntu/app/models/weights:/home/ubuntu/app/models/weights
      - /var/lib/jenkins/workspace/pixelro_server-develop/server/fastapi-app/app/vectorstore/medical_knowledge:/app/vectorstore/medical_knowledge
    networks:
      - app-network
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8000/ml/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    ports:
      - "9090:9090"
    volumes:
      - ./monitoring/prometheus/prometheus.yml:/etc/prometheus/prometheus.yml
      - prometheus_data:/prometheus
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
      - '--storage.tsdb.path=/prometheus'
      - '--web.external-url=${PROMETHEUS_EXTERNAL_URL}'
      - '--web.enable-remote-write-receiver'
    networks:
      - app-network
    restart: unless-stopped
    environment:
      TZ: Asia/Seoul

  prometheus-k6:
    image: prom/prometheus:latest
    container_name: prometheus-k6
    ports:
      - "9091:9090"
    volumes:
      - ./monitoring/prometheus/prometheus-k6.yml:/etc/prometheus/prometheus.yml
      - prometheus-k6_data:/prometheus
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
      - '--storage.tsdb.path=/prometheus'
      - '--log.level=debug'
      - '--web.enable-remote-write-receiver'
      - '--enable-feature=native-histograms'
    networks:
      - app-network
    restart: unless-stopped
    environment:
      TZ: Asia/Seoul

  node-exporter:
    image: prom/node-exporter:latest
    container_name: node-exporter
    ports:
      - "9100:9100"
    volumes:
      - /proc:/host/proc:ro
      - /sys:/host/sys:ro
      - /:/rootfs:ro
    command:
      - '--path.procfs=/host/proc'
      - '--path.sysfs=/host/sys'
      - '--path.rootfs=/rootfs'
      - '--collector.filesystem.mount-points-exclude=^/(sys|proc|dev|host|etc)($$|/)'
    networks:
      - app-network
    restart: unless-stopped
    environment:
      TZ: Asia/Seoul

  nginx-exporter:
    image: nginx/nginx-prometheus-exporter:latest
    container_name: nginx-exporter
    ports:
      - "9113:9113"
    command:
      - '-nginx.scrape-uri=http://nginx/nginx_status'
    networks:
      - app-network
    depends_on:
      - nginx
    restart: unless-stopped
    environment:
      TZ: Asia/Seoul

  grafana:
    image: grafana/grafana:latest
    container_name: grafana
    ports:
      - "3000:3000"
    volumes:
      - grafana_data:/var/lib/grafana
      - ./monitoring/grafana/provisioning:/etc/grafana/provisioning
      - ./monitoring/grafana/grafana.ini:/etc/grafana/grafana.ini
    environment:
      GF_SECURITY_ADMIN_USER: ${GF_SECURITY_ADMIN_USER}
      GF_SECURITY_ADMIN_PASSWORD: ${GF_SECURITY_ADMIN_PASSWORD}
      TZ: Asia/Seoul
    depends_on:
      - prometheus
    networks:
      - app-network

  loki:
    image: grafana/loki:latest
    container_name: loki
    ports:
      - "3100:3100"
    volumes:
      - ./monitoring/loki/loki-config.yml:/etc/loki/local-config.yaml
      - loki_data:/loki
    command: -config.file=/etc/loki/local-config.yaml
    networks:
      - app-network
    restart: unless-stopped
    environment:
      TZ: Asia/Seoul

  promtail:
    image: grafana/promtail:latest
    container_name: promtail
    volumes:
      - ./monitoring/promtail/promtail-config.yml:/etc/promtail/config.yaml
      - /var/log:/var/log
      - /var/run/docker.sock:/var/run/docker.sock:ro
    command: -config.file=/etc/promtail/config.yaml
    networks:
      - app-network
    depends_on:
      - loki
    restart: unless-stopped
    environment:
      TZ: Asia/Seoul

  # k6:
  #   image: grafana/k6:latest
  #   container_name: k6
  #   profiles: ["loadtest"]
  #   networks:
  #     - app-network
  #   volumes:
  #     - ./scripts:/scripts
  #   # command: run /scripts/your-main-test.js
  #   # '--vus', '10', '--duration', '30s'
  #   environment:
  #     TZ: Asia/Seoul
  #     K6_PROMETHEUS_RW_SERVER_URL: http://prometheus-k6:9090/k6/api/v1/write
  #     K6_PROMETHEUS_RW_STALE_MARKERS: "true"
  #     # K6_OUT: prometheus=vu # k6 v0.40.0 이상에서 Prometheus 확장 사용 시 메트릭 포맷
  #   depends_on:
  #     springboot-test:
  #       condition: service_healthy

networks:
  app-network:
    driver: bridge

volumes:
  mysql_data:
  redis_data:
  mongo_data:
  prometheus_data:
  prometheus-k6_data:
  grafana_data:
  loki_data: