Merge branch 'develop' of https://github.com/ktds-dg0501/kt-event-marketing into feature/distribution

2025-12-06 13:26:23 +00:00 · 2025-10-30 18:38:14 +09:00 · 2025-10-30 18:38:14 +09:00 · 4bc7f87663
commit 4bc7f87663
parent ae8f540d46 c6dfc74bda
138 changed files with 5568 additions and 1057 deletions
--- a/.github/kustomize/base/content-service-secret-content-service.yaml
+++ b/.github/kustomize/base/content-service-secret-content-service.yaml
@ -8,7 +8,7 @@ stringData:
  AZURE_STORAGE_CONNECTION_STRING: "DefaultEndpointsProtocol=https;AccountName=blobkteventstorage;AccountKey=tcBN7mAfojbl0uGsOpU7RNuKNhHnzmwDiWjN31liSMVSrWaEK+HHnYKZrjBXXAC6ZPsuxUDlsf8x+AStd++QYg==;EndpointSuffix=core.windows.net"

  # Replicate API Token
-  REPLICATE_API_TOKEN: ""
+  REPLICATE_API_TOKEN: "r8_BsGCJtAg5U5kkMBXSe3pgMkPufSKnUR4NY9gJ"

  # HuggingFace API Token
  HUGGINGFACE_API_TOKEN: ""
--- a/.github/kustomize/base/distribution-service-deployment.yaml
+++ b/.github/kustomize/base/distribution-service-deployment.yaml
@ -41,21 +41,21 @@ spec:
              memory: "1024Mi"
          startupProbe:
            httpGet:
-              path: /actuator/health
+              path: /api/v1/distribution/actuator/health
              port: 8085
            initialDelaySeconds: 30
            periodSeconds: 10
            failureThreshold: 30
          readinessProbe:
            httpGet:
-              path: /actuator/health/readiness
+              path: /api/v1/distribution/actuator/health/readiness
              port: 8085
            initialDelaySeconds: 10
            periodSeconds: 5
            failureThreshold: 3
          livenessProbe:
            httpGet:
-              path: /actuator/health/liveness
+              path: /api/v1/distribution/actuator/health/liveness
              port: 8085
            initialDelaySeconds: 30
            periodSeconds: 10
--- a/.github/kustomize/base/kustomization.yaml
+++ b/.github/kustomize/base/kustomization.yaml
@ -53,11 +53,6 @@ resources:
  - analytics-service-cm-analytics-service.yaml
  - analytics-service-secret-analytics-service.yaml

-# Common labels for all resources
-commonLabels:
-  app.kubernetes.io/managed-by: kustomize
-  app.kubernetes.io/part-of: kt-event-marketing
-
 # Image tag replacement (will be overridden by overlays)
 images:
  - name: acrdigitalgarage01.azurecr.io/kt-event-marketing/user-service
--- a/.github/kustomize/overlays/dev/kustomization.yaml
+++ b/.github/kustomize/overlays/dev/kustomization.yaml
@ -6,10 +6,6 @@ namespace: kt-event-marketing
 bases:
  - ../../base

-# Environment-specific labels
-commonLabels:
-  environment: dev
-
 # Environment-specific patches
 patchesStrategicMerge:
  - user-service-patch.yaml
--- a/.github/workflows/backend-cicd.yaml
+++ b/.github/workflows/backend-cicd.yaml
@ -1,14 +1,14 @@
 name: Backend CI/CD Pipeline

 on:
-  push:
-    branches:
-      - develop
-      - main
-    paths:
-      - '*-service/**'
-      - '.github/workflows/backend-cicd.yaml'
-      - '.github/kustomize/**'
+  # push:
+  #   branches:
+  #     - develop
+  #     - main
+  #   paths:
+  #     - '*-service/**'
+  #     - '.github/workflows/backend-cicd.yaml'
+  #     - '.github/kustomize/**'
  pull_request:
    branches:
      - develop
@ -107,8 +107,8 @@ jobs:
      - name: Build with Gradle
        run: ./gradlew ${{ matrix.service }}:build -x test

-      - name: Run tests
-        run: ./gradlew ${{ matrix.service }}:test
+      # - name: Run tests
+      #   run: ./gradlew ${{ matrix.service }}:test

      - name: Build JAR
        run: ./gradlew ${{ matrix.service }}:bootJar
--- a/.run/AiServiceApplication.run.xml
+++ b/.run/AiServiceApplication.run.xml
@ -19,7 +19,7 @@
      <env name="REDIS_HOST" value="20.214.210.71" />
      <env name="REDIS_PORT" value="6379" />
      <env name="REDIS_PASSWORD" value="Hi5Jessica!" />
-      <env name="KAFKA_BOOTSTRAP_SERVERS" value="4.230.50.63:9092" />
+      <env name="KAFKA_BOOTSTRAP_SERVERS" value="20.249.182.13:9095,4.217.131.59:9095" />
      <env name="KAFKA_CONSUMER_GROUP" value="ai" />
      <env name="JPA_DDL_AUTO" value="update" />
      <env name="JPA_SHOW_SQL" value="false" />
--- a/.run/ContentServiceApplication.run.xml
+++ b/.run/ContentServiceApplication.run.xml
@ -21,6 +21,8 @@
      <env name="REDIS_PASSWORD" value="Hi5Jessica!" />
      <env name="JPA_DDL_AUTO" value="update" />
      <env name="JPA_SHOW_SQL" value="false" />
+      <env name="REPLICATE_API_TOKEN" value="r8_cqE8IzQr9DZ8Dr72ozbomiXe6IFPL0005Vuq9" />
+      <env name="REPLICATE_MOCK_ENABLED" value="true" />
    </envs>
    <method v="2">
      <option name="Make" enabled="true" />
--- a/.run/analytics-service.run.xml
+++ b/.run/analytics-service.run.xml
@ -24,7 +24,7 @@
          <!-- Kafka Configuration (원격 서버) -->
          <entry key="KAFKA_ENABLED" value="true" />
          <entry key="KAFKA_BOOTSTRAP_SERVERS" value="20.249.182.13:9095,4.217.131.59:9095" />
-          <entry key="KAFKA_CONSUMER_GROUP_ID" value="analytics-service-consumers" />
+          <entry key="KAFKA_CONSUMER_GROUP_ID" value="analytics-service-consumers-v3" />

          <!-- Sample Data Configuration (MVP Only) -->
          <!-- ⚠️ Kafka Producer로 이벤트 발행 (Consumer가 처리) -->
--- a/DEVELOP_CHANGELOG.md
+++ b/DEVELOP_CHANGELOG.md
@ -0,0 +1,620 @@
+# Develop 브랜치 변경사항 요약
+
+**업데이트 일시**: 2025-10-30
+**머지 브랜치**: feature/event → develop
+**머지 커밋**: 3465a35
+
+---
+
+## 📊 변경사항 통계
+
+```
+60개 파일 변경
+2,795 줄 추가
+-222 줄 삭제
+```
+
+---
+
+## 🎯 주요 변경사항
+
+### 1. 비즈니스 친화적 ID 생성 시스템 구현
+
+#### EventId 생성 로직
+**파일**: `event-service/.../EventIdGenerator.java` (신규)
+
+**ID 포맷**: `EVT-{store_id}-{timestamp}-{random}`
+```
+예시: EVT-str_dev_test_001-20251030001311-70eea424
+```
+
+**특징**:
+- ✅ 비즈니스 의미를 담은 접두사 (EVT)
+- ✅ 매장 식별자 포함 (store_id)
+- ✅ 타임스탬프 기반 시간 추적 가능
+- ✅ 랜덤 해시로 유일성 보장
+- ✅ 사람이 읽기 쉬운 형식
+
+**구현 내역**:
+```java
+public class EventIdGenerator {
+    private static final String PREFIX = "EVT";
+
+    public static String generate(String storeId) {
+        String cleanStoreId = sanitizeStoreId(storeId);
+        String timestamp = LocalDateTime.now()
+            .format(DateTimeFormatter.ofPattern("yyyyMMddHHmmss"));
+        String randomHash = UUID.randomUUID().toString()
+            .substring(0, 8);
+
+        return String.format("%s-%s-%s-%s",
+            PREFIX, cleanStoreId, timestamp, randomHash);
+    }
+}
+```
+
+#### JobId 생성 로직
+**파일**: `event-service/.../JobIdGenerator.java` (신규)
+
+**ID 포맷**: `JOB-{type}-{timestamp}-{random}`
+```
+예시: JOB-IMG-1761750847428-b88d2f54
+```
+
+**타입 코드**:
+- `IMG`: 이미지 생성 작업
+- `AI`: AI 추천 작업
+- `REG`: 이미지 재생성 작업
+
+**특징**:
+- ✅ 작업 타입 식별 가능
+- ✅ 타임스탬프로 작업 시간 추적
+- ✅ UUID 기반 유일성 보장
+- ✅ 로그 분석 및 디버깅 용이
+
+---
+
+### 2. Kafka 메시지 구조 개선
+
+#### 필드명 표준화 (snake_case → camelCase)
+
+**변경 파일**:
+- `AIEventGenerationJobMessage.java`
+- `EventCreatedMessage.java`
+- `ImageJobKafkaProducer.java`
+- `AIJobKafkaProducer.java`
+- 관련 Consumer 클래스들
+
+**Before**:
+```json
+{
+  "job_id": "...",
+  "event_id": "...",
+  "store_id": "...",
+  "store_name": "..."
+}
+```
+
+**After**:
+```json
+{
+  "jobId": "...",
+  "eventId": "...",
+  "storeId": "...",
+  "storeName": "..."
+}
+```
+
+**이점**:
+- ✅ Java 네이밍 컨벤션 준수
+- ✅ JSON 직렬화/역직렬화 간소화
+- ✅ 프론트엔드와 일관된 필드명
+- ✅ 코드 가독성 향상
+
+**영향받는 메시지**:
+1. **이미지 생성 작업 메시지** (`image-generation-job`)
+   - jobId, eventId, prompt, styles, platforms 등
+
+2. **AI 이벤트 생성 작업 메시지** (`ai-event-generation-job`)
+   - jobId, eventId, objective, storeInfo 등
+
+3. **이벤트 생성 완료 메시지** (`event-created`)
+   - eventId, storeId, storeName, objective 등
+
+---
+
+### 3. 데이터베이스 스키마 및 마이그레이션
+
+#### 신규 스키마 파일
+**파일**: `develop/database/schema/create_event_tables.sql`
+
+**테이블 구조**:
+```sql
+-- events 테이블
+CREATE TABLE events (
+    id VARCHAR(100) PRIMARY KEY,  -- EVT-{store_id}-{timestamp}-{hash}
+    user_id VARCHAR(50) NOT NULL,
+    store_id VARCHAR(50) NOT NULL,
+    store_name VARCHAR(200),
+    objective VARCHAR(50),
+    status VARCHAR(20),
+    created_at TIMESTAMP,
+    updated_at TIMESTAMP
+);
+
+-- jobs 테이블
+CREATE TABLE jobs (
+    id VARCHAR(100) PRIMARY KEY,  -- JOB-{type}-{timestamp}-{hash}
+    event_id VARCHAR(100),
+    job_type VARCHAR(50),
+    status VARCHAR(20),
+    progress INTEGER,
+    result_message TEXT,
+    error_message TEXT,
+    created_at TIMESTAMP,
+    updated_at TIMESTAMP
+);
+
+-- ai_recommendations 테이블
+CREATE TABLE ai_recommendations (
+    id BIGSERIAL PRIMARY KEY,
+    event_id VARCHAR(100),
+    recommendation_text TEXT,
+    -- ... 기타 필드
+);
+
+-- generated_images 테이블
+CREATE TABLE generated_images (
+    id BIGSERIAL PRIMARY KEY,
+    event_id VARCHAR(100),
+    image_url TEXT,
+    style VARCHAR(50),
+    platform VARCHAR(50),
+    -- ... 기타 필드
+);
+```
+
+#### 마이그레이션 스크립트
+**파일**: `develop/database/migration/alter_event_id_to_varchar.sql`
+
+**목적**: 기존 BIGINT 타입의 ID를 VARCHAR로 변경
+
+```sql
+-- Step 1: 백업 테이블 생성
+CREATE TABLE events_backup AS SELECT * FROM events;
+CREATE TABLE jobs_backup AS SELECT * FROM jobs;
+
+-- Step 2: 기존 테이블 삭제
+DROP TABLE IF EXISTS events CASCADE;
+DROP TABLE IF EXISTS jobs CASCADE;
+
+-- Step 3: 새 스키마로 테이블 재생성
+-- (create_event_tables.sql 실행)
+
+-- Step 4: 데이터 마이그레이션
+-- (필요시 기존 데이터를 새 형식으로 변환하여 삽입)
+```
+
+**주의사항**:
+- ⚠️ 프로덕션 환경에서는 반드시 백업 후 실행
+- ⚠️ 외래 키 제약조건 재설정 필요
+- ⚠️ 애플리케이션 코드와 동시 배포 필요
+
+---
+
+### 4. Content Service 통합 및 개선
+
+#### Content Service 설정 업데이트
+**파일**: `content-service/src/main/resources/application.yml`
+
+**변경사항**:
+```yaml
+# JWT 설정 추가
+jwt:
+  secret: ${JWT_SECRET:kt-event-marketing-jwt-secret...}
+  access-token-validity: ${JWT_ACCESS_TOKEN_VALIDITY:3600000}
+
+# Azure Blob Storage 설정 추가
+azure:
+  storage:
+    connection-string: ${AZURE_STORAGE_CONNECTION_STRING:...}
+    container-name: ${AZURE_CONTAINER_NAME:content-images}
+```
+
+#### 서비스 개선사항
+**파일**: `content-service/.../RegenerateImageService.java`, `StableDiffusionImageGenerator.java`
+
+**주요 개선**:
+- ✅ 이미지 재생성 로직 추가 (28줄)
+- ✅ Stable Diffusion 통합 개선 (28줄)
+- ✅ Mock Mode 개선 (개발 환경)
+- ✅ 에러 처리 강화
+
+---
+
+### 5. Event Service 리팩토링
+
+#### DTO 구조 개선
+**변경 파일**:
+- Request DTO: `AiRecommendationRequest`, `SelectImageRequest` 등
+- Response DTO: `EventCreatedResponse`, `EventDetailResponse` 등
+- Kafka DTO: 모든 메시지 클래스
+
+**주요 변경**:
+1. **필드명 표준화**: snake_case → camelCase
+2. **ID 타입 변경**: Long → String
+3. **Nullable 필드 명시**: @Nullable 어노테이션 추가
+4. **Validation 강화**: @NotNull, @NotBlank 등
+
+#### Service Layer 개선
+**파일**: `EventService.java`, `JobService.java`
+
+**Before**:
+```java
+public EventCreatedResponse createEvent(CreateEventRequest request) {
+    Event event = new Event();
+    event.setId(generateSequentialId());  // Long 타입
+    // ...
+}
+```
+
+**After**:
+```java
+public EventCreatedResponse createEvent(CreateEventRequest request) {
+    String eventId = EventIdGenerator.generate(request.getStoreId());
+    Event event = Event.builder()
+        .id(eventId)  // String 타입
+        .storeId(request.getStoreId())
+        // ...
+        .build();
+}
+```
+
+**개선사항**:
+- ✅ EventIdGenerator 사용
+- ✅ Builder 패턴 적용
+- ✅ 비즈니스 로직 분리
+- ✅ 에러 처리 개선
+
+---
+
+### 6. Kafka 연동 개선
+
+#### Producer 개선
+**파일**: `AIJobKafkaProducer.java`, `ImageJobKafkaProducer.java`
+
+**주요 개선**:
+```java
+@Service
+@RequiredArgsConstructor
+@Slf4j
+public class ImageJobKafkaProducer {
+
+    public void sendImageGenerationJob(ImageGenerationJobMessage message) {
+        log.info("이미지 생성 작업 메시지 발행 시작 - JobId: {}",
+            message.getJobId());
+
+        kafkaTemplate.send(topicName, message.getJobId(), message)
+            .whenComplete((result, ex) -> {
+                if (ex != null) {
+                    log.error("메시지 발행 실패: {}", ex.getMessage());
+                } else {
+                    log.info("메시지 발행 성공 - Offset: {}",
+                        result.getRecordMetadata().offset());
+                }
+            });
+    }
+}
+```
+
+**개선사항**:
+- ✅ 상세한 로깅 추가
+- ✅ 비동기 콜백 처리
+- ✅ 에러 핸들링 강화
+- ✅ 메시지 키 설정 (jobId)
+
+#### Consumer 개선
+**파일**: `ImageJobKafkaConsumer.java`, `AIJobKafkaConsumer.java`
+
+**주요 개선**:
+```java
+@KafkaListener(
+    topics = "${app.kafka.topics.image-generation-job}",
+    groupId = "${spring.kafka.consumer.group-id}"
+)
+public void consumeImageJob(
+    @Payload ImageGenerationJobMessage message,
+    Acknowledgment ack
+) {
+    log.info("이미지 작업 메시지 수신 - JobId: {}", message.getJobId());
+
+    try {
+        // 메시지 처리
+        processImageJob(message);
+
+        // Manual Acknowledgment
+        ack.acknowledge();
+        log.info("메시지 처리 완료 - JobId: {}", message.getJobId());
+
+    } catch (Exception e) {
+        log.error("메시지 처리 실패: {}", e.getMessage());
+        // 재시도 로직 또는 DLQ 전송
+    }
+}
+```
+
+**개선사항**:
+- ✅ Manual Acknowledgment 패턴
+- ✅ 상세한 로깅
+- ✅ 예외 처리 강화
+- ✅ 메시지 재시도 메커니즘
+
+---
+
+### 7. 보안 및 인증 개선
+
+#### JWT 토큰 처리 개선
+**파일**: `common/security/JwtTokenProvider.java`, `UserPrincipal.java`
+
+**주요 변경**:
+```java
+public class JwtTokenProvider {
+
+    public String getUserId(String token) {
+        Claims claims = parseToken(token);
+        return claims.get("userId", String.class);  // 명시적 타입 변환
+    }
+
+    public String getStoreId(String token) {
+        Claims claims = parseToken(token);
+        return claims.get("storeId", String.class);
+    }
+}
+```
+
+**개선사항**:
+- ✅ 타입 안전성 향상
+- ✅ null 처리 개선
+- ✅ 토큰 파싱 로직 강화
+- ✅ 에러 메시지 개선
+
+#### 개발 환경 인증 필터
+**파일**: `event-service/.../DevAuthenticationFilter.java`
+
+**개선사항**:
+- ✅ 개발 환경용 Mock 인증
+- ✅ JWT 토큰 파싱 개선
+- ✅ 로깅 추가
+
+---
+
+### 8. 테스트 및 문서화
+
+#### 통합 테스트 보고서
+**파일**: `test/content-service-integration-test-results.md` (신규, 673줄)
+
+**내용**:
+- ✅ 9개 테스트 시나리오 실행 결과
+- ✅ 성공률: 100% (9/9)
+- ✅ HTTP 통신 검증
+- ✅ Job 관리 메커니즘 검증
+- ✅ EventId 기반 조회 검증
+- ✅ 이미지 재생성 기능 검증
+- ✅ 성능 분석 (평균 응답 시간 < 150ms)
+
+#### 아키텍처 분석 문서
+**파일**: `test/content-service-integration-analysis.md` (신규, 504줄)
+
+**내용**:
+- ✅ content-service API 구조 분석
+- ✅ Redis 기반 Job 관리 메커니즘
+- ✅ Kafka 연동 현황 분석
+- ✅ 서비스 간 통신 구조
+- ✅ 권장사항 및 개선 방향
+
+#### Kafka 연동 테스트 보고서
+**파일**: `test/test-kafka-integration-results.md` (신규, 348줄)
+
+**내용**:
+- ✅ event-service Kafka Producer/Consumer 검증
+- ✅ Kafka 브로커 연결 테스트
+- ✅ 메시지 발행/수신 검증
+- ✅ Manual Acknowledgment 패턴 검증
+- ✅ content-service Kafka Consumer 미구현 확인
+
+#### API 테스트 결과
+**파일**: `test/API-TEST-RESULT.md` (이동)
+
+**내용**:
+- ✅ 기존 API 테스트 결과
+- ✅ test/ 폴더로 이동하여 정리
+
+#### 테스트 자동화 스크립트
+**파일**:
+- `test-content-service.sh` (신규, 82줄)
+- `run-content-service.sh` (신규, 80줄)
+- `run-content-service.bat` (신규, 81줄)
+
+**기능**:
+- ✅ content-service 자동 테스트
+- ✅ 서버 실행 스크립트 (Linux/Windows)
+- ✅ 7가지 테스트 시나리오 자동 실행
+- ✅ Health Check 및 API 검증
+
+#### 테스트 데이터
+**파일**:
+- `test-integration-event.json`
+- `test-integration-objective.json`
+- `test-integration-ai-request.json`
+- `test-image-generation.json`
+- `test-ai-recommendation.json`
+
+**목적**:
+- ✅ 통합 테스트용 샘플 데이터
+- ✅ API 테스트 자동화
+- ✅ 재현 가능한 테스트 환경
+
+---
+
+### 9. 실행 환경 설정
+
+#### IntelliJ 실행 프로파일 업데이트
+**파일**:
+- `.run/ContentServiceApplication.run.xml`
+- `.run/AiServiceApplication.run.xml`
+
+**변경사항**:
+```xml
+<envs>
+  <env name="SERVER_PORT" value="8084" />
+  <env name="REDIS_HOST" value="20.214.210.71" />
+  <env name="REDIS_PORT" value="6379" />
+  <env name="REDIS_PASSWORD" value="Hi5Jessica!" />
+  <env name="DB_HOST" value="4.217.131.139" />
+  <env name="DB_PORT" value="5432" />
+  <env name="REPLICATE_MOCK_ENABLED" value="true" />
+  <!-- JWT, Azure 설정 추가 -->
+</envs>
+```
+
+**개선사항**:
+- ✅ 환경 변수 명시적 설정
+- ✅ Mock Mode 설정 추가
+- ✅ 데이터베이스 연결 정보 명시
+
+---
+
+## 🔍 Kafka 아키텍처 현황
+
+### 현재 구현된 아키텍처
+```
+┌─────────────────┐
+│  event-service  │
+│   (Port 8081)   │
+└────────┬────────┘
+         │
+         ├─── Kafka Producer ───→ Kafka Topic (image-generation-job)
+         │                            │
+         │                            │ (event-service Consumer가 수신)
+         │                            ↓
+         │                    ┌──────────────┐
+         │                    │ event-service│
+         │                    │   Consumer   │
+         │                    └──────────────┘
+         │
+         └─── Redis Job Data ───→ Redis Cache
+                                       ↑
+                                       │
+                               ┌───────┴────────┐
+                               │ content-service│
+                               │  (Port 8084)   │
+                               └────────────────┘
+```
+
+### 주요 발견사항
+- ⚠️ **content-service에는 Kafka Consumer 미구현**
+- ✅ Redis 기반 Job 관리로 서비스 간 통신
+- ✅ event-service에서 Producer/Consumer 모두 구현
+- ⚠️ 논리 아키텍처 설계와 실제 구현 불일치
+
+### 권장사항
+1. **단기**: 설계 문서를 실제 구현에 맞춰 업데이트
+2. **중기**: API 문서 자동화 (Swagger/OpenAPI)
+3. **장기**: content-service에 Kafka Consumer 추가 구현
+
+---
+
+## 📊 성능 및 품질 지표
+
+### API 응답 시간
+```
+Health Check: < 50ms
+GET 요청: 50-100ms
+POST 요청: 100-150ms
+```
+
+### Job 처리 시간 (Mock Mode)
+```
+이미지 4개 생성: ~0.2초
+이미지 1개 재생성: ~0.1초
+```
+
+### 테스트 성공률
+```
+통합 테스트: 100% (9/9 성공)
+Kafka 연동: 100% (event-service)
+API 엔드포인트: 100% (전체 정상)
+```
+
+### 코드 품질
+```
+추가된 코드: 2,795줄
+제거된 코드: 222줄
+순 증가: 2,573줄
+변경된 파일: 60개
+```
+
+---
+
+## 🚀 배포 준비 상태
+
+### ✅ 완료된 작업
+- [x] EventId/JobId 생성 로직 구현
+- [x] Kafka 메시지 구조 개선
+- [x] 데이터베이스 스키마 정의
+- [x] content-service 통합 테스트 완료
+- [x] API 문서화 및 테스트 보고서 작성
+- [x] 테스트 자동화 스크립트 작성
+
+### ⏳ 진행 예정 작업
+- [ ] content-service Kafka Consumer 구현 (옵션)
+- [ ] 프로덕션 환경 데이터베이스 마이그레이션
+- [ ] Swagger/OpenAPI 문서 자동화
+- [ ] 성능 모니터링 도구 설정
+- [ ] 로그 수집 및 분석 시스템 구축
+
+### ⚠️ 주의사항
+1. **데이터베이스 마이그레이션**: 프로덕션 배포 전 백업 필수
+2. **Kafka 메시지 호환성**: 기존 Consumer가 있다면 메시지 형식 변경 영향 확인
+3. **ID 형식 변경**: 기존 데이터와의 호환성 검토 필요
+4. **환경 변수**: 모든 환경에서 필요한 환경 변수 설정 확인
+
+---
+
+## 📝 주요 커밋 히스토리
+
+```
+3465a35 Merge branch 'feature/event' into develop
+8ff79ca 테스트 결과 파일들을 test/ 폴더로 이동
+336d811 content-service 통합 테스트 완료 및 보고서 작성
+ee941e4 Event-AI Kafka 연동 개선 및 메시지 필드명 camelCase 변경
+b71d27a 비즈니스 친화적 eventId 및 jobId 생성 로직 구현
+34291e1 백엔드 서비스 구조 개선 및 데이터베이스 스키마 추가
+```
+
+---
+
+## 🔗 관련 문서
+
+1. **테스트 보고서**
+   - `test/content-service-integration-test-results.md`
+   - `test/test-kafka-integration-results.md`
+   - `test/API-TEST-RESULT.md`
+
+2. **아키텍처 문서**
+   - `test/content-service-integration-analysis.md`
+
+3. **데이터베이스**
+   - `develop/database/schema/create_event_tables.sql`
+   - `develop/database/migration/alter_event_id_to_varchar.sql`
+
+4. **테스트 스크립트**
+   - `test-content-service.sh`
+   - `run-content-service.sh`
+   - `run-content-service.bat`
+
+---
+
+**작성자**: Backend Developer
+**검토자**: System Architect
+**최종 업데이트**: 2025-10-30 01:40
--- a/ai-service/src/main/java/com/kt/ai/config/SecurityConfig.java
+++ b/ai-service/src/main/java/com/kt/ai/config/SecurityConfig.java
@ -4,6 +4,7 @@ import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.security.config.annotation.web.builders.HttpSecurity;
 import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
+import org.springframework.security.config.annotation.web.configuration.WebSecurityCustomizer;
 import org.springframework.security.config.annotation.web.configurers.AbstractHttpConfigurer;
 import org.springframework.security.config.http.SessionCreationPolicy;
 import org.springframework.security.web.SecurityFilterChain;
@ -27,21 +28,22 @@ import java.util.List;
@EnableWebSecurity
 public class SecurityConfig {

-    /**
-     * Security Filter Chain 설정
-     * - 모든 요청 허용 (내부 API)
-     * - CSRF 비활성화
-     * - Stateless 세션
-     */
    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
+                // CSRF 비활성화 (REST API는 CSRF 불필요)
                .csrf(AbstractHttpConfigurer::disable)
+
+                // CORS 설정
                .cors(cors -> cors.configurationSource(corsConfigurationSource()))
-                .sessionManagement(session -> session.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
+
+                // 세션 사용 안 함 (JWT 기반 인증)
+                .sessionManagement(session ->
+                        session.sessionCreationPolicy(SessionCreationPolicy.STATELESS)
+                )
+
+                // 모든 요청 허용 (테스트용)
                .authorizeHttpRequests(auth -> auth
-                        .requestMatchers("/health", "/actuator/**", "/v3/api-docs/**", "/swagger-ui/**").permitAll()
-                        .requestMatchers("/internal/**").permitAll()  // Internal API
                        .anyRequest().permitAll()
                );

@ -50,11 +52,14 @@ public class SecurityConfig {

    /**
     * CORS 설정
+     * - 모든 Origin 허용 (Swagger UI 테스트를 위해)
+     * - 모든 HTTP Method 허용
+     * - 모든 Header 허용
     */
    @Bean
    public CorsConfigurationSource corsConfigurationSource() {
        CorsConfiguration configuration = new CorsConfiguration();
-        configuration.setAllowedOrigins(Arrays.asList("http://localhost:3000", "http://localhost:8080"));
+        configuration.setAllowedOriginPatterns(List.of("*")); // 모든 Origin 허용
        configuration.setAllowedMethods(Arrays.asList("GET", "POST", "PUT", "DELETE", "OPTIONS", "PATCH"));
        configuration.setAllowedHeaders(List.of("*"));
        configuration.setAllowCredentials(true);
@ -64,4 +69,13 @@ public class SecurityConfig {
        source.registerCorsConfiguration("/**", configuration);
        return source;
    }
+
+    /**
+     * Chrome DevTools 요청 등 정적 리소스 요청을 Spring Security에서 제외
+     */
+    @Bean
+    public WebSecurityCustomizer webSecurityCustomizer() {
+        return (web) -> web.ignoring()
+                .requestMatchers("/.well-known/**");
+    }
 }
--- a/ai-service/src/main/java/com/kt/ai/config/SwaggerConfig.java
+++ b/ai-service/src/main/java/com/kt/ai/config/SwaggerConfig.java
@ -20,6 +20,10 @@ public class SwaggerConfig {

    @Bean
    public OpenAPI openAPI() {
+        Server vmServer = new Server();
+        vmServer.setUrl("http://kt-event-marketing-api.20.214.196.128.nip.io/api/v1/ai");
+        vmServer.setDescription("VM Development Server");
+
        Server localServer = new Server();
        localServer.setUrl("http://localhost:8083");
        localServer.setDescription("Local Development Server");
@ -59,6 +63,6 @@ public class SwaggerConfig {

        return new OpenAPI()
                .info(info)
-                .servers(List.of(localServer, devServer, prodServer));
+                .servers(List.of(vmServer, localServer, devServer, prodServer));
    }
 }
--- a/ai-service/src/main/java/com/kt/ai/controller/InternalJobController.java
+++ b/ai-service/src/main/java/com/kt/ai/controller/InternalJobController.java
@ -27,7 +27,7 @@ import java.util.Map;
@Slf4j
@Tag(name = "Internal API", description = "내부 서비스 간 통신용 API")
@RestController
-@RequestMapping("/api/v1/ai-service/internal/jobs")
+@RequestMapping("/jobs")
@RequiredArgsConstructor
 public class InternalJobController {

--- a/ai-service/src/main/java/com/kt/ai/controller/InternalRecommendationController.java
+++ b/ai-service/src/main/java/com/kt/ai/controller/InternalRecommendationController.java
@ -31,7 +31,7 @@ import java.util.Set;
@Slf4j
@Tag(name = "Internal API", description = "내부 서비스 간 통신용 API")
@RestController
-@RequestMapping("/api/v1/ai-service/internal/recommendations")
+@RequestMapping("/recommendations")
@RequiredArgsConstructor
 public class InternalRecommendationController {

--- a/ai-service/src/main/resources/application.yml
+++ b/ai-service/src/main/resources/application.yml
@ -19,7 +19,7 @@ spring:

  # Kafka Consumer Configuration
  kafka:
-    bootstrap-servers: ${KAFKA_BOOTSTRAP_SERVERS:4.230.50.63:9092}
+    bootstrap-servers: ${KAFKA_BOOTSTRAP_SERVERS:20.249.182.13:9095,4.217.131.59:9095}
    consumer:
      group-id: ${KAFKA_CONSUMER_GROUP:ai-service-consumers}
      auto-offset-reset: earliest
@ -28,6 +28,8 @@ spring:
      value-deserializer: org.springframework.kafka.support.serializer.JsonDeserializer
      properties:
        spring.json.trusted.packages: "*"
+        spring.json.use.type.headers: false
+        spring.json.value.default.type: com.kt.ai.kafka.message.AIJobMessage
        max.poll.records: 10
        session.timeout.ms: 30000
    listener:
@ -51,7 +53,7 @@ jwt:

 # CORS Configuration
 cors:
-  allowed-origins: ${CORS_ALLOWED_ORIGINS:http://localhost:*}
+  allowed-origins: ${CORS_ALLOWED_ORIGINS:http://localhost:*,http://kt-event-marketing.20.214.196.128.nip.io}
  allowed-methods: ${CORS_ALLOWED_METHODS:GET,POST,PUT,DELETE,OPTIONS,PATCH}
  allowed-headers: ${CORS_ALLOWED_HEADERS:*}
  allow-credentials: ${CORS_ALLOW_CREDENTIALS:true}
--- a/analytics-service/.run/analytics-service.run.xml
+++ b/analytics-service/.run/analytics-service.run.xml
@ -24,7 +24,7 @@
          <!-- Kafka Configuration (원격 서버) -->
          <entry key="KAFKA_ENABLED" value="true" />
          <entry key="KAFKA_BOOTSTRAP_SERVERS" value="20.249.182.13:9095,4.217.131.59:9095" />
-          <entry key="KAFKA_CONSUMER_GROUP_ID" value="analytics-service-consumers" />
+          <entry key="KAFKA_CONSUMER_GROUP_ID" value="analytics-service-consumers-v3" />

          <!-- Sample Data Configuration (MVP Only) -->
          <!-- ⚠️ Kafka Producer로 이벤트 발행 (Consumer가 처리) -->
@ -39,7 +39,7 @@
          <entry key="JWT_REFRESH_TOKEN_VALIDITY" value="86400" />

          <!-- CORS Configuration -->
-          <entry key="CORS_ALLOWED_ORIGINS" value="http://localhost:*" />
+          <entry key="CORS_ALLOWED_ORIGINS" value="http://localhost:*,http://*.nip.io:*" />

          <!-- Logging Configuration -->
          <entry key="LOG_FILE" value="logs/analytics-service.log" />
--- a/analytics-service/Dockerfile
+++ b/analytics-service/Dockerfile
@ -1,7 +1,7 @@
 # Multi-stage build for Spring Boot application
 FROM eclipse-temurin:21-jre-alpine AS builder
 WORKDIR /app
-COPY build/libs/*.jar app.jar
+COPY analytics-service/build/libs/*.jar app.jar
 RUN java -Djarmode=layertools -jar app.jar extract

 FROM eclipse-temurin:21-jre-alpine
--- a/analytics-service/src/main/java/com/kt/event/analytics/batch/AnalyticsBatchScheduler.java
+++ b/analytics-service/src/main/java/com/kt/event/analytics/batch/AnalyticsBatchScheduler.java
@ -63,7 +63,7 @@ public class AnalyticsBatchScheduler {
                             event.getEventId(), event.getEventTitle());

                    // refresh=true로 호출하여 캐시 갱신 및 외부 API 호출
-                    analyticsService.getDashboardData(event.getEventId(), null, null, true);
+                    analyticsService.getDashboardData(event.getEventId(), true);

                    successCount++;
                    log.info("✅ 배치 갱신 완료: eventId={}", event.getEventId());
@ -99,7 +99,7 @@ public class AnalyticsBatchScheduler {

            for (EventStats event : allEvents) {
                try {
-                    analyticsService.getDashboardData(event.getEventId(), null, null, true);
+                    analyticsService.getDashboardData(event.getEventId(), true);
                    log.debug("초기 데이터 로딩 완료: eventId={}", event.getEventId());
                } catch (Exception e) {
                    log.warn("초기 데이터 로딩 실패: eventId={}, error={}",
--- a/analytics-service/src/main/java/com/kt/event/analytics/config/KafkaConsumerConfig.java
+++ b/analytics-service/src/main/java/com/kt/event/analytics/config/KafkaConsumerConfig.java
@ -17,13 +17,13 @@ import java.util.Map;
 * Kafka Consumer 설정
 */
@Configuration
-@ConditionalOnProperty(name = "spring.kafka.enabled", havingValue = "true", matchIfMissing = true)
+@ConditionalOnProperty(name = "spring.kafka.enabled", havingValue = "true", matchIfMissing = false)
 public class KafkaConsumerConfig {

    @Value("${spring.kafka.bootstrap-servers}")
    private String bootstrapServers;

-    @Value("${spring.kafka.consumer.group-id:analytics-service}")
+    @Value("${spring.kafka.consumer.group-id:analytics-service-consumers-v3}")
    private String groupId;

    @Bean
--- a/analytics-service/src/main/java/com/kt/event/analytics/config/KafkaProducerConfig.java
+++ b/analytics-service/src/main/java/com/kt/event/analytics/config/KafkaProducerConfig.java
@ -0,0 +1,46 @@
+package com.kt.event.analytics.config;
+
+import org.apache.kafka.clients.producer.ProducerConfig;
+import org.apache.kafka.common.serialization.StringSerializer;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.kafka.core.DefaultKafkaProducerFactory;
+import org.springframework.kafka.core.KafkaTemplate;
+import org.springframework.kafka.core.ProducerFactory;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Kafka Producer 설정
+ *
+ * ⚠️ MVP 전용: SampleDataLoader가 Kafka 이벤트를 발행하기 위해 필요
+ * ⚠️ 실제 운영: Analytics Service는 순수 Consumer 역할만 수행하므로 Producer 불필요
+ *
+ * String 직렬화 방식 사용 (SampleDataLoader가 JSON 문자열을 직접 발행)
+ */
+@Configuration
+@ConditionalOnProperty(name = "spring.kafka.enabled", havingValue = "true", matchIfMissing = false)
+public class KafkaProducerConfig {
+
+    @Value("${spring.kafka.bootstrap-servers}")
+    private String bootstrapServers;
+
+    @Bean
+    public ProducerFactory<String, String> producerFactory() {
+        Map<String, Object> configProps = new HashMap<>();
+        configProps.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, bootstrapServers);
+        configProps.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
+        configProps.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
+        configProps.put(ProducerConfig.ACKS_CONFIG, "all");
+        configProps.put(ProducerConfig.RETRIES_CONFIG, 3);
+        return new DefaultKafkaProducerFactory<>(configProps);
+    }
+
+    @Bean
+    public KafkaTemplate<String, String> kafkaTemplate() {
+        return new KafkaTemplate<>(producerFactory());
+    }
+}
--- a/analytics-service/src/main/java/com/kt/event/analytics/config/SampleDataLoader.java
+++ b/analytics-service/src/main/java/com/kt/event/analytics/config/SampleDataLoader.java
@ -11,19 +11,23 @@ import jakarta.annotation.PreDestroy;
 import jakarta.persistence.EntityManager;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
+import org.apache.kafka.clients.admin.AdminClient;
+import org.apache.kafka.clients.admin.DeleteConsumerGroupOffsetsResult;
+import org.apache.kafka.clients.admin.ListConsumerGroupOffsetsResult;
+import org.apache.kafka.common.TopicPartition;
 import org.springframework.boot.ApplicationArguments;
 import org.springframework.boot.ApplicationRunner;
 import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
 import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.kafka.core.KafkaAdmin;
 import org.springframework.kafka.core.KafkaTemplate;
 import org.springframework.stereotype.Component;
 import org.springframework.transaction.annotation.Transactional;

 import java.math.BigDecimal;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Random;
-import java.util.UUID;
+import java.util.*;
+import java.util.concurrent.TimeUnit;

 /**
 * 샘플 데이터 로더 (Kafka Producer 방식)
@ -47,6 +51,7 @@ import java.util.UUID;
 public class SampleDataLoader implements ApplicationRunner {

    private final KafkaTemplate<String, String> kafkaTemplate;
+    private final KafkaAdmin kafkaAdmin;
    private final ObjectMapper objectMapper;
    private final EventStatsRepository eventStatsRepository;
    private final ChannelStatsRepository channelStatsRepository;
@ -56,6 +61,9 @@ public class SampleDataLoader implements ApplicationRunner {

    private final Random random = new Random();

+    @Value("${spring.kafka.consumer.group-id}")
+    private String consumerGroupId;
+
    // Kafka Topic Names (MVP용 샘플 토픽)
    private static final String EVENT_CREATED_TOPIC = "sample.event.created";
    private static final String PARTICIPANT_REGISTERED_TOPIC = "sample.participant.registered";
@ -85,10 +93,15 @@ public class SampleDataLoader implements ApplicationRunner {

        // Redis 멱등성 키 삭제 (새로운 이벤트 처리를 위해)
        log.info("Redis 멱등성 키 삭제 중...");
-        redisTemplate.delete("processed_events");
-        redisTemplate.delete("distribution_completed");
-        redisTemplate.delete("processed_participants");
-        log.info("✅ Redis 멱등성 키 삭제 완료");
+        try {
+            redisTemplate.delete("processed_events_v2");
+            redisTemplate.delete("distribution_completed_v2");
+            redisTemplate.delete("processed_participants_v2");
+            log.info("✅ Redis 멱등성 키 삭제 완료");
+        } catch (Exception e) {
+            log.warn("⚠️ Redis 삭제 실패 (read-only replica일 수 있음): {}", e.getMessage());
+            log.info("→ Redis 삭제 건너뛰고 계속 진행...");
+        }

        try {
            // 1. EventCreated 이벤트 발행 (3개 이벤트)
@ -103,6 +116,8 @@ public class SampleDataLoader implements ApplicationRunner {

            // 3. ParticipantRegistered 이벤트 발행 (각 이벤트당 다수 참여자)
            publishParticipantRegisteredEvents();
+            log.info("⏳ 참여자 등록 이벤트 처리 대기 중... (20초)");
+            Thread.sleep(20000);  // ParticipantRegisteredConsumer가 180개 이벤트 처리할 시간 (비관적 락 고려)

            log.info("========================================");
            log.info("🎉 Kafka 이벤트 발행 완료! (Consumer가 처리 중...)");
@ -127,16 +142,17 @@ public class SampleDataLoader implements ApplicationRunner {
    }

    /**
-     * 서비스 종료 시 전체 데이터 삭제
+     * 서비스 종료 시 전체 데이터 삭제 및 Consumer Offset 리셋
     */
    @PreDestroy
    @Transactional
    public void onShutdown() {
        log.info("========================================");
-        log.info("🛑 서비스 종료: PostgreSQL 전체 데이터 삭제");
+        log.info("🛑 서비스 종료: PostgreSQL 전체 데이터 삭제 + Kafka Consumer Offset 리셋");
        log.info("========================================");

        try {
+            // 1. PostgreSQL 데이터 삭제
            long timelineCount = timelineDataRepository.count();
            long channelCount = channelStatsRepository.count();
            long eventCount = eventStatsRepository.count();
@ -153,6 +169,10 @@ public class SampleDataLoader implements ApplicationRunner {
            entityManager.clear();

            log.info("✅ 모든 샘플 데이터 삭제 완료!");
+
+            // 2. Kafka Consumer Offset 리셋 (다음 시작 시 처음부터 읽도록)
+            resetConsumerOffsets();
+
            log.info("========================================");

        } catch (Exception e) {
@ -160,37 +180,85 @@ public class SampleDataLoader implements ApplicationRunner {
        }
    }

+    /**
+     * Kafka Consumer Group Offset 리셋
+     *
+     * 서비스 종료 시 Consumer offset을 삭제하여 다음 시작 시
+     * auto.offset.reset=earliest 설정에 따라 처음부터 읽도록 함
+     */
+    private void resetConsumerOffsets() {
+        try (AdminClient adminClient = AdminClient.create(kafkaAdmin.getConfigurationProperties())) {
+            log.info("🔄 Kafka Consumer Offset 리셋 시작: group={}", consumerGroupId);
+
+            // 모든 토픽의 offset 삭제
+            Set<TopicPartition> partitions = new HashSet<>();
+
+            // 토픽별 파티션 추가 (설계서상 각 토픽은 3개 파티션)
+            for (int i = 0; i < 3; i++) {
+                partitions.add(new TopicPartition(EVENT_CREATED_TOPIC, i));
+                partitions.add(new TopicPartition(PARTICIPANT_REGISTERED_TOPIC, i));
+                partitions.add(new TopicPartition(DISTRIBUTION_COMPLETED_TOPIC, i));
+            }
+
+            // Consumer Group Offset 삭제
+            DeleteConsumerGroupOffsetsResult result = adminClient.deleteConsumerGroupOffsets(
+                consumerGroupId,
+                partitions
+            );
+
+            // 완료 대기 (최대 10초)
+            result.all().get(10, TimeUnit.SECONDS);
+
+            log.info("✅ Kafka Consumer Offset 리셋 완료!");
+            log.info("   → 다음 시작 시 처음부터(earliest) 메시지를 읽습니다.");
+
+        } catch (Exception e) {
+            // Offset 리셋 실패는 치명적이지 않으므로 경고만 출력
+            log.warn("⚠️ Kafka Consumer Offset 리셋 실패 (무시 가능): {}", e.getMessage());
+            log.warn("   → 수동으로 Consumer Group ID를 변경하거나, Kafka 도구로 offset을 삭제하세요.");
+        }
+    }
+
    /**
     * EventCreated 이벤트 발행
     */
    private void publishEventCreatedEvents() throws Exception {
-        // 이벤트 1: 신년맞이 할인 이벤트 (진행중, 높은 성과)
+        // 이벤트 1: 신년맞이 할인 이벤트 (진행중, 높은 성과 - ROI 200%)
        EventCreatedEvent event1 = EventCreatedEvent.builder()
-            .eventId("evt_2025012301")
+            .eventId("1")
            .eventTitle("신년맞이 20% 할인 이벤트")
            .storeId("store_001")
            .totalInvestment(new BigDecimal("5000000"))
+            .expectedRevenue(new BigDecimal("15000000"))  // 투자 대비 3배 수익
            .status("ACTIVE")
+            .startDate(java.time.LocalDateTime.of(2025, 1, 23, 0, 0))  // 2025-01-23 시작
+            .endDate(null)  // 진행중
            .build();
        publishEvent(EVENT_CREATED_TOPIC, event1);

-        // 이벤트 2: 설날 특가 이벤트 (진행중, 중간 성과)
+        // 이벤트 2: 설날 특가 이벤트 (진행중, 중간 성과 - ROI 100%)
        EventCreatedEvent event2 = EventCreatedEvent.builder()
-            .eventId("evt_2025020101")
+            .eventId("2")
            .eventTitle("설날 특가 선물세트 이벤트")
            .storeId("store_001")
            .totalInvestment(new BigDecimal("3500000"))
+            .expectedRevenue(new BigDecimal("7000000"))  // 투자 대비 2배 수익
            .status("ACTIVE")
+            .startDate(java.time.LocalDateTime.of(2025, 2, 1, 0, 0))  // 2025-02-01 시작
+            .endDate(null)  // 진행중
            .build();
        publishEvent(EVENT_CREATED_TOPIC, event2);

-        // 이벤트 3: 겨울 신메뉴 런칭 이벤트 (종료, 저조한 성과)
+        // 이벤트 3: 겨울 신메뉴 런칭 이벤트 (종료, 저조한 성과 - ROI 50%)
        EventCreatedEvent event3 = EventCreatedEvent.builder()
-            .eventId("evt_2025011501")
+            .eventId("3")
            .eventTitle("겨울 신메뉴 런칭 이벤트")
            .storeId("store_001")
            .totalInvestment(new BigDecimal("2000000"))
+            .expectedRevenue(new BigDecimal("3000000"))  // 투자 대비 1.5배 수익
            .status("COMPLETED")
+            .startDate(java.time.LocalDateTime.of(2025, 1, 15, 0, 0))  // 2025-01-15 시작
+            .endDate(java.time.LocalDateTime.of(2025, 1, 31, 23, 59))  // 2025-01-31 종료
            .build();
        publishEvent(EVENT_CREATED_TOPIC, event3);

@ -201,49 +269,70 @@ public class SampleDataLoader implements ApplicationRunner {
     * DistributionCompleted 이벤트 발행 (설계서 기준 - 이벤트당 1번 발행, 여러 채널 배열)
     */
    private void publishDistributionCompletedEvents() throws Exception {
-        String[] eventIds = {"evt_2025012301", "evt_2025020101", "evt_2025011501"};
+        String[] eventIds = {"1", "2", "3"};
        int[][] expectedViews = {
            {5000, 10000, 3000, 2000},  // 이벤트1: 우리동네TV, 지니TV, 링고비즈, SNS
            {3500, 7000, 2000, 1500},   // 이벤트2
            {1500, 3000, 1000, 500}     // 이벤트3
        };

+        // 각 이벤트의 총 투자 금액
+        BigDecimal[] totalInvestments = {
+            new BigDecimal("5000000"),  // 이벤트1: 500만원
+            new BigDecimal("3500000"),  // 이벤트2: 350만원
+            new BigDecimal("2000000")   // 이벤트3: 200만원
+        };
+
+        // 채널 배포는 총 투자의 50%만 사용 (나머지는 경품/콘텐츠/운영비용)
+        double channelBudgetRatio = 0.50;
+
+        // 채널별 비용 비율 (채널 예산 내에서: 우리동네TV 30%, 지니TV 30%, 링고비즈 25%, SNS 15%)
+        double[] costRatios = {0.30, 0.30, 0.25, 0.15};
+
        for (int i = 0; i < eventIds.length; i++) {
            String eventId = eventIds[i];
+            BigDecimal totalInvestment = totalInvestments[i];
+
+            // 채널 배포 예산: 총 투자의 50%
+            BigDecimal channelBudget = totalInvestment.multiply(BigDecimal.valueOf(channelBudgetRatio));

            // 4개 채널을 배열로 구성
            List<DistributionCompletedEvent.ChannelDistribution> channels = new ArrayList<>();

-            // 1. 우리동네TV (TV)
+            // 1. 우리동네TV (TV) - 채널 예산의 30%
            channels.add(DistributionCompletedEvent.ChannelDistribution.builder()
                .channel("우리동네TV")
                .channelType("TV")
                .status("SUCCESS")
                .expectedViews(expectedViews[i][0])
+                .distributionCost(channelBudget.multiply(BigDecimal.valueOf(costRatios[0])))
                .build());

-            // 2. 지니TV (TV)
+            // 2. 지니TV (TV) - 채널 예산의 30%
            channels.add(DistributionCompletedEvent.ChannelDistribution.builder()
                .channel("지니TV")
                .channelType("TV")
                .status("SUCCESS")
                .expectedViews(expectedViews[i][1])
+                .distributionCost(channelBudget.multiply(BigDecimal.valueOf(costRatios[1])))
                .build());

-            // 3. 링고비즈 (CALL)
+            // 3. 링고비즈 (CALL) - 채널 예산의 25%
            channels.add(DistributionCompletedEvent.ChannelDistribution.builder()
                .channel("링고비즈")
                .channelType("CALL")
                .status("SUCCESS")
                .expectedViews(expectedViews[i][2])
+                .distributionCost(channelBudget.multiply(BigDecimal.valueOf(costRatios[2])))
                .build());

-            // 4. SNS (SNS)
+            // 4. SNS (SNS) - 채널 예산의 15%
            channels.add(DistributionCompletedEvent.ChannelDistribution.builder()
                .channel("SNS")
                .channelType("SNS")
                .status("SUCCESS")
                .expectedViews(expectedViews[i][3])
+                .distributionCost(channelBudget.multiply(BigDecimal.valueOf(costRatios[3])))
                .build());

            // 이벤트 발행 (채널 배열 포함)
@ -261,22 +350,53 @@ public class SampleDataLoader implements ApplicationRunner {

    /**
     * ParticipantRegistered 이벤트 발행
+     *
+     * 현실적인 참여 패턴 반영:
+     * - 총 120명의 고유 참여자 풀 생성
+     * - 일부 참여자는 여러 이벤트에 중복 참여
+     * - 이벤트1: 100명 (user001~user100)
+     * - 이벤트2: 50명 (user051~user100) → 50명이 이벤트1과 중복
+     * - 이벤트3: 30명 (user071~user100) → 30명이 이전 이벤트들과 중복
     */
    private void publishParticipantRegisteredEvents() throws Exception {
-        String[] eventIds = {"evt_2025012301", "evt_2025020101", "evt_2025011501"};
-        int[] totalParticipants = {100, 50, 30};  // MVP 테스트용 샘플 데이터 (총 180명)
+        String[] eventIds = {"1", "2", "3"};
        String[] channels = {"우리동네TV", "지니TV", "링고비즈", "SNS"};

+        // 이벤트별 참여자 범위 (중복 참여 반영)
+        int[][] participantRanges = {
+            {1, 100},    // 이벤트1: user001~user100 (100명)
+            {51, 100},   // 이벤트2: user051~user100 (50명, 이벤트1과 50명 중복)
+            {71, 100}    // 이벤트3: user071~user100 (30명, 모두 중복)
+        };
+
        int totalPublished = 0;

        for (int i = 0; i < eventIds.length; i++) {
            String eventId = eventIds[i];
-            int participants = totalParticipants[i];
+            int startUser = participantRanges[i][0];
+            int endUser = participantRanges[i][1];
+            int eventParticipants = endUser - startUser + 1;

-            // 각 이벤트에 대해 참여자 수만큼 ParticipantRegistered 이벤트 발행
-            for (int j = 0; j < participants; j++) {
-                String participantId = UUID.randomUUID().toString();
-                String channel = channels[j % channels.length];  // 채널 순환 배정
+            log.info("이벤트 {} 참여자 발행 시작: user{:03d}~user{:03d} ({}명)",
+                eventId, startUser, endUser, eventParticipants);
+
+            // 각 참여자에 대해 ParticipantRegistered 이벤트 발행
+            for (int userId = startUser; userId <= endUser; userId++) {
+                String participantId = String.format("user%03d", userId);  // user001, user002, ...
+
+                // 채널별 가중치 기반 랜덤 배정
+                // SNS: 45%, 우리동네TV: 25%, 지니TV: 20%, 링고비즈: 10%
+                int randomValue = random.nextInt(100);
+                String channel;
+                if (randomValue < 45) {
+                    channel = "SNS";  // 0~44: 45%
+                } else if (randomValue < 70) {
+                    channel = "우리동네TV";  // 45~69: 25%
+                } else if (randomValue < 90) {
+                    channel = "지니TV";  // 70~89: 20%
+                } else {
+                    channel = "링고비즈";  // 90~99: 10%
+                }

                ParticipantRegisteredEvent event = ParticipantRegisteredEvent.builder()
                    .eventId(eventId)
@ -288,72 +408,102 @@ public class SampleDataLoader implements ApplicationRunner {
                totalPublished++;

                // 동시성 충돌 방지: 10개마다 100ms 대기
-                if ((j + 1) % 10 == 0) {
+                if (totalPublished % 10 == 0) {
                    Thread.sleep(100);
                }
            }
+
+            log.info("✅ 이벤트 {} 참여자 발행 완료: {}명", eventId, eventParticipants);
        }

+        log.info("========================================");
        log.info("✅ ParticipantRegistered 이벤트 {}건 발행 완료", totalPublished);
+        log.info("📊 참여 패턴:");
+        log.info("  - 총 고유 참여자: 100명 (user001~user100)");
+        log.info("  - 이벤트1 참여: 100명");
+        log.info("  - 이벤트2 참여: 50명 (이벤트1과 50명 중복)");
+        log.info("  - 이벤트3 참여: 30명 (이벤트1,2와 모두 중복)");
+        log.info("  - 3개 이벤트 모두 참여: 30명");
+        log.info("  - 2개 이벤트 참여: 20명");
+        log.info("  - 1개 이벤트만 참여: 50명");
+        log.info("📺 채널별 참여 비율 (가중치):");
+        log.info("  - SNS: 45% (가장 높음)");
+        log.info("  - 우리동네TV: 25%");
+        log.info("  - 지니TV: 20%");
+        log.info("  - 링고비즈: 10%");
+        log.info("========================================");
    }

    /**
     * TimelineData 생성 (시간대별 샘플 데이터)
     *
-     * - 각 이벤트마다 30일 치 daily 데이터 생성
+     * - 각 이벤트마다 30일 × 24시간 = 720시간 치 hourly 데이터 생성
+     * - interval=hourly: 시간별 표시 (최근 7일 적합)
+     * - interval=daily: 일별 자동 집계 (30일 전체)
     * - 참여자 수, 조회수, 참여행동, 전환수, 누적 참여자 수
     */
    private void createTimelineData() {
        log.info("📊 TimelineData 생성 시작...");

-        String[] eventIds = {"evt_2025012301", "evt_2025020101", "evt_2025011501"};
+        String[] eventIds = {"evt_2025012301", "evt_2025012302", "evt_2025012303"};

-        // 각 이벤트별 기준 참여자 수 (이벤트 성과에 따라 다름)
-        int[] baseParticipants = {20, 12, 5};  // 이벤트1(높음), 이벤트2(중간), 이벤트3(낮음)
+        // 각 이벤트별 시간당 기준 참여자 수 (이벤트 성과에 따라 다름)
+        int[] baseParticipantsPerHour = {4, 2, 1};  // 이벤트1(높음), 이벤트2(중간), 이벤트3(낮음)

        for (int eventIndex = 0; eventIndex < eventIds.length; eventIndex++) {
            String eventId = eventIds[eventIndex];
-            int baseParticipant = baseParticipants[eventIndex];
+            int baseParticipant = baseParticipantsPerHour[eventIndex];
            int cumulativeParticipants = 0;

-            // 30일 치 데이터 생성 (2024-09-24부터)
-            java.time.LocalDateTime startDate = java.time.LocalDateTime.of(2024, 9, 24, 0, 0);
+            // 이벤트 ID에서 날짜 파싱 (evt_2025012301 → 2025-01-23)
+            String dateStr = eventId.substring(4);  // "2025012301"
+            int year = Integer.parseInt(dateStr.substring(0, 4));   // 2025
+            int month = Integer.parseInt(dateStr.substring(4, 6));  // 01
+            int day = Integer.parseInt(dateStr.substring(6, 8));    // 23

-            for (int day = 0; day < 30; day++) {
-                java.time.LocalDateTime timestamp = startDate.plusDays(day);
+            // 이벤트 시작일부터 30일 치 hourly 데이터 생성
+            java.time.LocalDateTime startDate = java.time.LocalDateTime.of(year, month, day, 0, 0);

-                // 랜덤한 참여자 수 생성 (기준값 ± 50%)
-                int dailyParticipants = baseParticipant + random.nextInt(baseParticipant + 1);
-                cumulativeParticipants += dailyParticipants;
+            for (int dayOffset = 0; dayOffset < 30; dayOffset++) {
+                for (int hour = 0; hour < 24; hour++) {
+                    java.time.LocalDateTime timestamp = startDate.plusDays(dayOffset).plusHours(hour);

-                // 조회수는 참여자의 3~5배
-                int dailyViews = dailyParticipants * (3 + random.nextInt(3));
+                    // 시간대별 참여자 수 변화 (낮 시간대 12~20시에 더 많음)
+                    int hourMultiplier = (hour >= 12 && hour <= 20) ? 2 : 1;
+                    int hourlyParticipants = (baseParticipant * hourMultiplier) + random.nextInt(baseParticipant + 1);

-                // 참여행동은 참여자의 1~2배
-                int dailyEngagement = dailyParticipants * (1 + random.nextInt(2));
+                    cumulativeParticipants += hourlyParticipants;

-                // 전환수는 참여자의 50~80%
-                int dailyConversions = (int) (dailyParticipants * (0.5 + random.nextDouble() * 0.3));
+                    // 조회수는 참여자의 3~5배
+                    int hourlyViews = hourlyParticipants * (3 + random.nextInt(3));

-                // TimelineData 생성
-                com.kt.event.analytics.entity.TimelineData timelineData =
-                    com.kt.event.analytics.entity.TimelineData.builder()
-                        .eventId(eventId)
-                        .timestamp(timestamp)
-                        .participants(dailyParticipants)
-                        .views(dailyViews)
-                        .engagement(dailyEngagement)
-                        .conversions(dailyConversions)
-                        .cumulativeParticipants(cumulativeParticipants)
-                        .build();
+                    // 참여행동은 참여자의 1~2배
+                    int hourlyEngagement = hourlyParticipants * (1 + random.nextInt(2));

-                timelineDataRepository.save(timelineData);
+                    // 전환수는 참여자의 50~80%
+                    int hourlyConversions = (int) (hourlyParticipants * (0.5 + random.nextDouble() * 0.3));
+
+                    // TimelineData 생성
+                    com.kt.event.analytics.entity.TimelineData timelineData =
+                        com.kt.event.analytics.entity.TimelineData.builder()
+                            .eventId(eventId)
+                            .timestamp(timestamp)
+                            .participants(hourlyParticipants)
+                            .views(hourlyViews)
+                            .engagement(hourlyEngagement)
+                            .conversions(hourlyConversions)
+                            .cumulativeParticipants(cumulativeParticipants)
+                            .build();
+
+                    timelineDataRepository.save(timelineData);
+                }
            }

-            log.info("✅ TimelineData 생성 완료: eventId={}, 30일 데이터", eventId);
+            log.info("✅ TimelineData 생성 완료: eventId={}, 시작일={}-{:02d}-{:02d}, 30일 × 24시간 = 720건",
+                eventId, year, month, day);
        }

-        log.info("✅ 전체 TimelineData 생성 완료: 3개 이벤트 × 30일 = 90건");
+        log.info("✅ 전체 TimelineData 생성 완료: 3개 이벤트 × 30일 × 24시간 = 2,160건");
    }

    /**
--- a/analytics-service/src/main/java/com/kt/event/analytics/config/SecurityConfig.java
+++ b/analytics-service/src/main/java/com/kt/event/analytics/config/SecurityConfig.java
@ -39,16 +39,7 @@ public class SecurityConfig {
            .cors(cors -> cors.configurationSource(corsConfigurationSource()))
            .sessionManagement(session -> session.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
            .authorizeHttpRequests(auth -> auth
-                // Actuator endpoints
-                .requestMatchers("/actuator/**").permitAll()
-                // Swagger UI endpoints
-                .requestMatchers("/swagger-ui/**", "/swagger-ui.html", "/v3/api-docs/**", "/swagger-resources/**", "/webjars/**").permitAll()
-                // Health check
-                .requestMatchers("/health").permitAll()
-                // Analytics API endpoints (테스트 및 개발 용도로 공개)
-                .requestMatchers("/api/**").permitAll()
-                // All other requests require authentication
-                .anyRequest().authenticated()
+                .anyRequest().permitAll()
            )
            .addFilterBefore(new JwtAuthenticationFilter(jwtTokenProvider),
                UsernamePasswordAuthenticationFilter.class)
--- a/analytics-service/src/main/java/com/kt/event/analytics/config/SwaggerConfig.java
+++ b/analytics-service/src/main/java/com/kt/event/analytics/config/SwaggerConfig.java
@ -22,8 +22,11 @@ public class SwaggerConfig {
        return new OpenAPI()
            .info(apiInfo())
            .addServersItem(new Server()
-                .url("http://localhost:8086")
+                .url("http://localhost:8086/api/v1/analytics")
                .description("Local Development"))
+            .addServersItem(new Server()
+                .url("http://kt-event-marketing-api.20.214.196.128.nip.io/api/v1/analytics")
+                .description("AKS Development"))
            .addServersItem(new Server()
                .url("{protocol}://{host}:{port}")
                .description("Custom Server")
--- a/analytics-service/src/main/java/com/kt/event/analytics/controller/AnalyticsDashboardController.java
+++ b/analytics-service/src/main/java/com/kt/event/analytics/controller/AnalyticsDashboardController.java
@ -22,7 +22,7 @@ import java.time.LocalDateTime;
@Tag(name = "Analytics", description = "이벤트 성과 분석 및 대시보드 API")
@Slf4j
@RestController
-@RequestMapping("/api/v1/events")
+@RequestMapping("/events")
@RequiredArgsConstructor
 public class AnalyticsDashboardController {

@ -31,31 +31,19 @@ public class AnalyticsDashboardController {
    /**
     * 성과 대시보드 조회
     *
-     * @param eventId   이벤트 ID
-     * @param startDate 조회 시작 날짜
-     * @param endDate   조회 종료 날짜
-     * @param refresh   캐시 갱신 여부
-     * @return 성과 대시보드
+     * @param eventId 이벤트 ID
+     * @param refresh 캐시 갱신 여부
+     * @return 성과 대시보드 (이벤트 시작일 ~ 현재까지)
     */
    @Operation(
        summary = "성과 대시보드 조회",
-        description = "이벤트의 전체 성과를 통합하여 조회합니다."
+        description = "이벤트의 전체 성과를 통합하여 조회합니다. (이벤트 시작일 ~ 현재까지)"
    )
    @GetMapping("/{eventId}/analytics")
    public ResponseEntity<ApiResponse<AnalyticsDashboardResponse>> getEventAnalytics(
        @Parameter(description = "이벤트 ID", required = true)
        @PathVariable String eventId,

-        @Parameter(description = "조회 시작 날짜 (ISO 8601 format)")
-        @RequestParam(required = false)
-        @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME)
-        LocalDateTime startDate,
-
-        @Parameter(description = "조회 종료 날짜 (ISO 8601 format)")
-        @RequestParam(required = false)
-        @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME)
-        LocalDateTime endDate,
-
        @Parameter(description = "캐시 갱신 여부 (true인 경우 외부 API 호출)")
        @RequestParam(required = false, defaultValue = "false")
        Boolean refresh
@ -63,7 +51,7 @@ public class AnalyticsDashboardController {
        log.info("성과 대시보드 조회 API 호출: eventId={}, refresh={}", eventId, refresh);

        AnalyticsDashboardResponse response = analyticsService.getDashboardData(
-            eventId, startDate, endDate, refresh
+            eventId, refresh
        );

        return ResponseEntity.ok(ApiResponse.success(response));
--- a/analytics-service/src/main/java/com/kt/event/analytics/controller/ChannelAnalyticsController.java
+++ b/analytics-service/src/main/java/com/kt/event/analytics/controller/ChannelAnalyticsController.java
@ -22,7 +22,7 @@ import java.util.List;
@Tag(name = "Channels", description = "채널별 성과 분석 API")
@Slf4j
@RestController
-@RequestMapping("/api/v1/events")
+@RequestMapping("/events")
@RequiredArgsConstructor
 public class ChannelAnalyticsController {

--- a/analytics-service/src/main/java/com/kt/event/analytics/controller/DebugController.java
+++ b/analytics-service/src/main/java/com/kt/event/analytics/controller/DebugController.java
@ -0,0 +1,75 @@
+package com.kt.event.analytics.controller;
+
+import com.kt.event.analytics.config.SampleDataLoader;
+import com.kt.event.common.dto.ApiResponse;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.boot.ApplicationArguments;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+/**
+ * 디버그 컨트롤러
+ *
+ * ⚠️ 개발/테스트 전용
+ */
+@Tag(name = "Debug", description = "디버그 API (개발/테스트 전용)")
+@Slf4j
+@RestController
+@RequestMapping("/debug")
+@RequiredArgsConstructor
+public class DebugController {
+
+    private final SampleDataLoader sampleDataLoader;
+
+    /**
+     * 샘플 데이터 수동 생성
+     */
+    @Operation(
+        summary = "샘플 데이터 수동 생성",
+        description = "SampleDataLoader를 수동으로 실행하여 샘플 데이터를 생성합니다."
+    )
+    @PostMapping("/reload-sample-data")
+    public ResponseEntity<ApiResponse<String>> reloadSampleData() {
+        try {
+            log.info("🔧 수동으로 샘플 데이터 생성 요청");
+
+            // SampleDataLoader 실행
+            sampleDataLoader.run(new ApplicationArguments() {
+                @Override
+                public String[] getSourceArgs() {
+                    return new String[0];
+                }
+
+                @Override
+                public java.util.Set<String> getOptionNames() {
+                    return java.util.Collections.emptySet();
+                }
+
+                @Override
+                public boolean containsOption(String name) {
+                    return false;
+                }
+
+                @Override
+                public java.util.List<String> getOptionValues(String name) {
+                    return null;
+                }
+
+                @Override
+                public java.util.List<String> getNonOptionArgs() {
+                    return java.util.Collections.emptyList();
+                }
+            });
+
+            return ResponseEntity.ok(ApiResponse.success("샘플 데이터 생성 완료"));
+        } catch (Exception e) {
+            log.error("❌ 샘플 데이터 생성 실패", e);
+            return ResponseEntity.ok(ApiResponse.success("샘플 데이터 생성 실패: " + e.getMessage()));
+        }
+    }
+}
--- a/analytics-service/src/main/java/com/kt/event/analytics/controller/RoiAnalyticsController.java
+++ b/analytics-service/src/main/java/com/kt/event/analytics/controller/RoiAnalyticsController.java
@ -19,7 +19,7 @@ import org.springframework.web.bind.annotation.*;
@Tag(name = "ROI", description = "투자 대비 수익률 분석 API")
@Slf4j
@RestController
-@RequestMapping("/api/v1/events")
+@RequestMapping("/events")
@RequiredArgsConstructor
 public class RoiAnalyticsController {

--- a/analytics-service/src/main/java/com/kt/event/analytics/controller/TimelineAnalyticsController.java
+++ b/analytics-service/src/main/java/com/kt/event/analytics/controller/TimelineAnalyticsController.java
@ -24,7 +24,7 @@ import java.util.List;
@Tag(name = "Timeline", description = "시간대별 분석 API")
@Slf4j
@RestController
-@RequestMapping("/api/v1/events")
+@RequestMapping("/events")
@RequiredArgsConstructor
 public class TimelineAnalyticsController {

@ -33,16 +33,14 @@ public class TimelineAnalyticsController {
    /**
     * 시간대별 참여 추이
     *
-     * @param eventId   이벤트 ID
-     * @param interval  시간 간격 단위
-     * @param startDate 조회 시작 날짜
-     * @param endDate   조회 종료 날짜
-     * @param metrics   조회할 지표 목록
-     * @return 시간대별 참여 추이
+     * @param eventId  이벤트 ID
+     * @param interval 시간 간격 단위
+     * @param metrics  조회할 지표 목록
+     * @return 시간대별 참여 추이 (이벤트 시작일 ~ 현재까지)
     */
    @Operation(
        summary = "시간대별 참여 추이",
-        description = "이벤트 기간 동안의 시간대별 참여 추이를 분석합니다."
+        description = "이벤트 기간 동안의 시간대별 참여 추이를 분석합니다. (이벤트 시작일 ~ 현재까지)"
    )
    @GetMapping("/{eventId}/analytics/timeline")
    public ResponseEntity<ApiResponse<TimelineAnalyticsResponse>> getTimelineAnalytics(
@ -53,16 +51,6 @@ public class TimelineAnalyticsController {
        @RequestParam(required = false, defaultValue = "daily")
        String interval,

-        @Parameter(description = "조회 시작 날짜 (ISO 8601 format)")
-        @RequestParam(required = false)
-        @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME)
-        LocalDateTime startDate,
-
-        @Parameter(description = "조회 종료 날짜 (ISO 8601 format)")
-        @RequestParam(required = false)
-        @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME)
-        LocalDateTime endDate,
-
        @Parameter(description = "조회할 지표 목록 (쉼표로 구분)")
        @RequestParam(required = false)
        String metrics
@ -74,7 +62,7 @@ public class TimelineAnalyticsController {
            : null;

        TimelineAnalyticsResponse response = timelineAnalyticsService.getTimelineAnalytics(
-            eventId, interval, startDate, endDate, metricList
+            eventId, interval, metricList
        );

        return ResponseEntity.ok(ApiResponse.success(response));
--- a/analytics-service/src/main/java/com/kt/event/analytics/controller/UserAnalyticsDashboardController.java
+++ b/analytics-service/src/main/java/com/kt/event/analytics/controller/UserAnalyticsDashboardController.java
@ -22,7 +22,7 @@ import java.time.LocalDateTime;
@Tag(name = "User Analytics", description = "사용자 전체 이벤트 통합 성과 분석 API")
@Slf4j
@RestController
-@RequestMapping("/api/v1/users")
+@RequestMapping("/users")
@RequiredArgsConstructor
 public class UserAnalyticsDashboardController {

@ -31,31 +31,19 @@ public class UserAnalyticsDashboardController {
    /**
     * 사용자 전체 성과 대시보드 조회
     *
-     * @param userId    사용자 ID
-     * @param startDate 조회 시작 날짜
-     * @param endDate   조회 종료 날짜
-     * @param refresh   캐시 갱신 여부
-     * @return 전체 통합 성과 대시보드
+     * @param userId  사용자 ID
+     * @param refresh 캐시 갱신 여부
+     * @return 전체 통합 성과 대시보드 (userId 기반 전체 이벤트 조회)
     */
    @Operation(
        summary = "사용자 전체 성과 대시보드 조회",
-        description = "사용자의 모든 이벤트 성과를 통합하여 조회합니다."
+        description = "사용자의 모든 이벤트 성과를 통합하여 조회합니다. (userId 기반 전체 이벤트 조회)"
    )
    @GetMapping("/{userId}/analytics")
    public ResponseEntity<ApiResponse<UserAnalyticsDashboardResponse>> getUserAnalytics(
        @Parameter(description = "사용자 ID", required = true)
        @PathVariable String userId,

-        @Parameter(description = "조회 시작 날짜 (ISO 8601 format)")
-        @RequestParam(required = false)
-        @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME)
-        LocalDateTime startDate,
-
-        @Parameter(description = "조회 종료 날짜 (ISO 8601 format)")
-        @RequestParam(required = false)
-        @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME)
-        LocalDateTime endDate,
-
        @Parameter(description = "캐시 갱신 여부")
        @RequestParam(required = false, defaultValue = "false")
        Boolean refresh
@ -63,7 +51,7 @@ public class UserAnalyticsDashboardController {
        log.info("사용자 전체 성과 대시보드 조회 API 호출: userId={}, refresh={}", userId, refresh);

        UserAnalyticsDashboardResponse response = userAnalyticsService.getUserDashboardData(
-            userId, startDate, endDate, refresh
+            userId, refresh
        );

        return ResponseEntity.ok(ApiResponse.success(response));
--- a/analytics-service/src/main/java/com/kt/event/analytics/controller/UserChannelAnalyticsController.java
+++ b/analytics-service/src/main/java/com/kt/event/analytics/controller/UserChannelAnalyticsController.java
@ -22,7 +22,7 @@ import java.util.List;
@Tag(name = "User Channels", description = "사용자 전체 이벤트 채널별 성과 분석 API")
@Slf4j
@RestController
-@RequestMapping("/api/v1/users")
+@RequestMapping("/users")
@RequiredArgsConstructor
 public class UserChannelAnalyticsController {

@ -30,17 +30,13 @@ public class UserChannelAnalyticsController {

    @Operation(
        summary = "사용자 전체 채널별 성과 분석",
-        description = "사용자의 모든 이벤트 채널 성과를 통합하여 분석합니다."
+        description = "사용자의 모든 이벤트 채널 성과를 통합하여 분석합니다. (전체 채널 무조건 표시)"
    )
    @GetMapping("/{userId}/analytics/channels")
    public ResponseEntity<ApiResponse<UserChannelAnalyticsResponse>> getUserChannelAnalytics(
        @Parameter(description = "사용자 ID", required = true)
        @PathVariable String userId,

-        @Parameter(description = "조회할 채널 목록 (쉼표로 구분)")
-        @RequestParam(required = false)
-        String channels,
-
        @Parameter(description = "정렬 기준")
        @RequestParam(required = false, defaultValue = "participants")
        String sortBy,
@ -49,28 +45,14 @@ public class UserChannelAnalyticsController {
        @RequestParam(required = false, defaultValue = "desc")
        String order,

-        @Parameter(description = "조회 시작 날짜")
-        @RequestParam(required = false)
-        @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME)
-        LocalDateTime startDate,
-
-        @Parameter(description = "조회 종료 날짜")
-        @RequestParam(required = false)
-        @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME)
-        LocalDateTime endDate,
-
        @Parameter(description = "캐시 갱신 여부")
        @RequestParam(required = false, defaultValue = "false")
        Boolean refresh
    ) {
        log.info("사용자 채널 분석 API 호출: userId={}, sortBy={}", userId, sortBy);

-        List<String> channelList = channels != null && !channels.isBlank()
-            ? Arrays.asList(channels.split(","))
-            : null;
-
        UserChannelAnalyticsResponse response = userChannelAnalyticsService.getUserChannelAnalytics(
-            userId, channelList, sortBy, order, startDate, endDate, refresh
+            userId, sortBy, order, refresh
        );

        return ResponseEntity.ok(ApiResponse.success(response));
--- a/analytics-service/src/main/java/com/kt/event/analytics/controller/UserRoiAnalyticsController.java
+++ b/analytics-service/src/main/java/com/kt/event/analytics/controller/UserRoiAnalyticsController.java
@ -20,7 +20,7 @@ import java.time.LocalDateTime;
@Tag(name = "User ROI", description = "사용자 전체 이벤트 ROI 분석 API")
@Slf4j
@RestController
-@RequestMapping("/api/v1/users")
+@RequestMapping("/users")
@RequiredArgsConstructor
 public class UserRoiAnalyticsController {

@ -28,7 +28,7 @@ public class UserRoiAnalyticsController {

    @Operation(
        summary = "사용자 전체 ROI 상세 분석",
-        description = "사용자의 모든 이벤트 ROI를 통합하여 분석합니다."
+        description = "사용자의 모든 이벤트 ROI를 통합하여 분석합니다. (userId 기반 전체 이벤트 조회)"
    )
    @GetMapping("/{userId}/analytics/roi")
    public ResponseEntity<ApiResponse<UserRoiAnalyticsResponse>> getUserRoiAnalytics(
@ -39,16 +39,6 @@ public class UserRoiAnalyticsController {
        @RequestParam(required = false, defaultValue = "true")
        Boolean includeProjection,

-        @Parameter(description = "조회 시작 날짜")
-        @RequestParam(required = false)
-        @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME)
-        LocalDateTime startDate,
-
-        @Parameter(description = "조회 종료 날짜")
-        @RequestParam(required = false)
-        @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME)
-        LocalDateTime endDate,
-
        @Parameter(description = "캐시 갱신 여부")
        @RequestParam(required = false, defaultValue = "false")
        Boolean refresh
@ -56,7 +46,7 @@ public class UserRoiAnalyticsController {
        log.info("사용자 ROI 분석 API 호출: userId={}, includeProjection={}", userId, includeProjection);

        UserRoiAnalyticsResponse response = userRoiAnalyticsService.getUserRoiAnalytics(
-            userId, includeProjection, startDate, endDate, refresh
+            userId, includeProjection, refresh
        );

        return ResponseEntity.ok(ApiResponse.success(response));
--- a/analytics-service/src/main/java/com/kt/event/analytics/controller/UserTimelineAnalyticsController.java
+++ b/analytics-service/src/main/java/com/kt/event/analytics/controller/UserTimelineAnalyticsController.java
@ -22,7 +22,7 @@ import java.util.List;
@Tag(name = "User Timeline", description = "사용자 전체 이벤트 시간대별 분석 API")
@Slf4j
@RestController
-@RequestMapping("/api/v1/users")
+@RequestMapping("/users")
@RequiredArgsConstructor
 public class UserTimelineAnalyticsController {

@ -30,7 +30,7 @@ public class UserTimelineAnalyticsController {

    @Operation(
        summary = "사용자 전체 시간대별 참여 추이",
-        description = "사용자의 모든 이벤트 시간대별 데이터를 통합하여 분석합니다."
+        description = "사용자의 모든 이벤트 시간대별 데이터를 통합하여 분석합니다. (userId 기반 전체 이벤트 조회)"
    )
    @GetMapping("/{userId}/analytics/timeline")
    public ResponseEntity<ApiResponse<UserTimelineAnalyticsResponse>> getUserTimelineAnalytics(
@ -41,16 +41,6 @@ public class UserTimelineAnalyticsController {
        @RequestParam(required = false, defaultValue = "daily")
        String interval,

-        @Parameter(description = "조회 시작 날짜")
-        @RequestParam(required = false)
-        @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME)
-        LocalDateTime startDate,
-
-        @Parameter(description = "조회 종료 날짜")
-        @RequestParam(required = false)
-        @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME)
-        LocalDateTime endDate,
-
        @Parameter(description = "조회할 지표 목록 (쉼표로 구분)")
        @RequestParam(required = false)
        String metrics,
@ -66,7 +56,7 @@ public class UserTimelineAnalyticsController {
            : null;

        UserTimelineAnalyticsResponse response = userTimelineAnalyticsService.getUserTimelineAnalytics(
-            userId, interval, startDate, endDate, metricList, refresh
+            userId, interval, metricList, refresh
        );

        return ResponseEntity.ok(ApiResponse.success(response));
--- a/analytics-service/src/main/java/com/kt/event/analytics/dto/response/AnalyticsDashboardResponse.java
+++ b/analytics-service/src/main/java/com/kt/event/analytics/dto/response/AnalyticsDashboardResponse.java
@ -47,6 +47,21 @@ public class AnalyticsDashboardResponse {
     */
    private RoiSummary roi;

+    /**
+     * 투자 비용 상세
+     */
+    private InvestmentDetails investment;
+
+    /**
+     * 수익 상세
+     */
+    private RevenueDetails revenue;
+
+    /**
+     * 비용 효율성 분석
+     */
+    private CostEfficiency costEfficiency;
+
    /**
     * 마지막 업데이트 시간
     */
--- a/analytics-service/src/main/java/com/kt/event/analytics/dto/response/InvestmentDetails.java
+++ b/analytics-service/src/main/java/com/kt/event/analytics/dto/response/InvestmentDetails.java
@ -33,6 +33,16 @@ public class InvestmentDetails {
     */
    private BigDecimal operation;

+    /**
+     * 경품 비용 (원)
+     */
+    private BigDecimal prizeCost;
+
+    /**
+     * 채널 비용 (원) - distribution과 동일한 값
+     */
+    private BigDecimal channelCost;
+
    /**
     * 총 투자 비용 (원)
     */
--- a/analytics-service/src/main/java/com/kt/event/analytics/dto/response/RevenueDetails.java
+++ b/analytics-service/src/main/java/com/kt/event/analytics/dto/response/RevenueDetails.java
@ -26,6 +26,16 @@ public class RevenueDetails {
     */
    private BigDecimal expectedSales;

+    /**
+     * 신규 고객 매출 (원)
+     */
+    private BigDecimal newCustomerRevenue;
+
+    /**
+     * 기존 고객 매출 (원)
+     */
+    private BigDecimal existingCustomerRevenue;
+
    /**
     * 브랜드 가치 향상 추정액 (원)
     */
--- a/analytics-service/src/main/java/com/kt/event/analytics/entity/ChannelStats.java
+++ b/analytics-service/src/main/java/com/kt/event/analytics/entity/ChannelStats.java
@ -125,4 +125,11 @@ public class ChannelStats extends BaseTimeEntity {
    @Column(name = "average_duration")
    @Builder.Default
    private Integer averageDuration = 0;
+
+    /**
+     * 참여자 수 증가
+     */
+    public void incrementParticipants() {
+        this.participants++;
+    }
 }
--- a/analytics-service/src/main/java/com/kt/event/analytics/entity/EventStats.java
+++ b/analytics-service/src/main/java/com/kt/event/analytics/entity/EventStats.java
@ -97,6 +97,18 @@ public class EventStats extends BaseTimeEntity {
    @Column(length = 20)
    private String status;

+    /**
+     * 이벤트 시작일
+     */
+    @Column(name = "start_date")
+    private java.time.LocalDateTime startDate;
+
+    /**
+     * 이벤트 종료일 (null이면 진행중)
+     */
+    @Column(name = "end_date")
+    private java.time.LocalDateTime endDate;
+
    /**
     * 참여자 수 증가
     */
--- a/analytics-service/src/main/java/com/kt/event/analytics/infrastructure/config/WebConfig.java
+++ b/analytics-service/src/main/java/com/kt/event/analytics/infrastructure/config/WebConfig.java
@ -0,0 +1,32 @@
+package com.kt.event.analytics.infrastructure.config;
+
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.servlet.config.annotation.CorsRegistry;
+import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
+
+/**
+ * Web Configuration
+ * CORS 설정 및 기타 웹 관련 설정
+ *
+ * @author System Architect
+ * @since 2025-10-30
+ */
+@Configuration
+public class WebConfig implements WebMvcConfigurer {
+
+    /**
+     * CORS 설정
+     * - 모든 origin 허용 (개발 환경)
+     * - 모든 HTTP 메서드 허용
+     * - Credentials 허용
+     */
+    @Override
+    public void addCorsMappings(CorsRegistry registry) {
+        registry.addMapping("/**")
+                .allowedOriginPatterns("*")
+                .allowedMethods("GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS")
+                .allowedHeaders("*")
+                .allowCredentials(true)
+                .maxAge(3600);
+    }
+}
--- a/analytics-service/src/main/java/com/kt/event/analytics/messaging/consumer/DistributionCompletedConsumer.java
+++ b/analytics-service/src/main/java/com/kt/event/analytics/messaging/consumer/DistributionCompletedConsumer.java
@ -32,7 +32,7 @@ public class DistributionCompletedConsumer {
    private final ObjectMapper objectMapper;
    private final RedisTemplate<String, String> redisTemplate;

-    private static final String PROCESSED_DISTRIBUTIONS_KEY = "distribution_completed";
+    private static final String PROCESSED_DISTRIBUTIONS_KEY = "distribution_completed_v2";
    private static final String CACHE_KEY_PREFIX = "analytics:dashboard:";
    private static final long IDEMPOTENCY_TTL_DAYS = 7;

@ -109,10 +109,15 @@ public class DistributionCompletedConsumer {
                channelStats.setImpressions(channel.getExpectedViews());
            }

+            // 배포 비용 저장
+            if (channel.getDistributionCost() != null) {
+                channelStats.setDistributionCost(channel.getDistributionCost());
+            }
+
            channelStatsRepository.save(channelStats);

-            log.debug("✅ 채널 통계 저장: eventId={}, channel={}, expectedViews={}",
-                eventId, channelName, channel.getExpectedViews());
+            log.debug("✅ 채널 통계 저장: eventId={}, channel={}, expectedViews={}, distributionCost={}",
+                eventId, channelName, channel.getExpectedViews(), channel.getDistributionCost());

        } catch (Exception e) {
            log.error("❌ 채널 통계 처리 실패: eventId={}, channel={}", eventId, channel.getChannel(), e);
--- a/analytics-service/src/main/java/com/kt/event/analytics/messaging/consumer/EventCreatedConsumer.java
+++ b/analytics-service/src/main/java/com/kt/event/analytics/messaging/consumer/EventCreatedConsumer.java
@ -12,6 +12,7 @@ import org.springframework.kafka.annotation.KafkaListener;
 import org.springframework.stereotype.Component;
 import org.springframework.transaction.annotation.Transactional;

+import java.math.BigDecimal;
 import java.util.concurrent.TimeUnit;

 /**
@ -29,7 +30,7 @@ public class EventCreatedConsumer {
    private final ObjectMapper objectMapper;
    private final RedisTemplate<String, String> redisTemplate;

-    private static final String PROCESSED_EVENTS_KEY = "processed_events";
+    private static final String PROCESSED_EVENTS_KEY = "processed_events_v2";
    private static final String CACHE_KEY_PREFIX = "analytics:dashboard:";
    private static final long IDEMPOTENCY_TTL_DAYS = 7;

@ -61,11 +62,15 @@ public class EventCreatedConsumer {
                .userId(event.getStoreId())  // MVP: 1 user = 1 store, storeId를 userId로 매핑
                .totalParticipants(0)
                .totalInvestment(event.getTotalInvestment())
+                .expectedRevenue(event.getExpectedRevenue() != null ? event.getExpectedRevenue() : BigDecimal.ZERO)
                .status(event.getStatus())
+                .startDate(event.getStartDate())
+                .endDate(event.getEndDate())
                .build();

            eventStatsRepository.save(eventStats);
-            log.info("✅ 이벤트 통계 초기화 완료: eventId={}", eventId);
+            log.info("✅ 이벤트 통계 초기화 완료: eventId={}, userId={}, startDate={}, endDate={}",
+                eventId, eventStats.getUserId(), event.getStartDate(), event.getEndDate());

            // 3. 캐시 무효화 (다음 조회 시 최신 데이터 반영)
            String cacheKey = CACHE_KEY_PREFIX + eventId;
--- a/analytics-service/src/main/java/com/kt/event/analytics/messaging/consumer/ParticipantRegisteredConsumer.java
+++ b/analytics-service/src/main/java/com/kt/event/analytics/messaging/consumer/ParticipantRegisteredConsumer.java
@ -1,7 +1,9 @@
 package com.kt.event.analytics.messaging.consumer;

+import com.kt.event.analytics.entity.ChannelStats;
 import com.kt.event.analytics.entity.EventStats;
 import com.kt.event.analytics.messaging.event.ParticipantRegisteredEvent;
+import com.kt.event.analytics.repository.ChannelStatsRepository;
 import com.kt.event.analytics.repository.EventStatsRepository;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import lombok.RequiredArgsConstructor;
@ -26,10 +28,11 @@ import java.util.concurrent.TimeUnit;
 public class ParticipantRegisteredConsumer {

    private final EventStatsRepository eventStatsRepository;
+    private final ChannelStatsRepository channelStatsRepository;
    private final ObjectMapper objectMapper;
    private final RedisTemplate<String, String> redisTemplate;

-    private static final String PROCESSED_PARTICIPANTS_KEY = "processed_participants";
+    private static final String PROCESSED_PARTICIPANTS_KEY = "processed_participants_v2";
    private static final String CACHE_KEY_PREFIX = "analytics:dashboard:";
    private static final long IDEMPOTENCY_TTL_DAYS = 7;

@ -47,11 +50,13 @@ public class ParticipantRegisteredConsumer {
            ParticipantRegisteredEvent event = objectMapper.readValue(message, ParticipantRegisteredEvent.class);
            String participantId = event.getParticipantId();
            String eventId = event.getEventId();
+            String channel = event.getChannel();

-            // ✅ 1. 멱등성 체크 (중복 처리 방지)
-            Boolean isProcessed = redisTemplate.opsForSet().isMember(PROCESSED_PARTICIPANTS_KEY, participantId);
+            // ✅ 1. 멱등성 체크 (중복 처리 방지) - eventId:participantId 조합으로 체크
+            String idempotencyKey = eventId + ":" + participantId;
+            Boolean isProcessed = redisTemplate.opsForSet().isMember(PROCESSED_PARTICIPANTS_KEY, idempotencyKey);
            if (Boolean.TRUE.equals(isProcessed)) {
-                log.warn("⚠️ 중복 이벤트 스킵 (이미 처리됨): participantId={}", participantId);
+                log.warn("⚠️ 중복 이벤트 스킵 (이미 처리됨): eventId={}, participantId={}", eventId, participantId);
                return;
            }

@ -67,15 +72,29 @@ public class ParticipantRegisteredConsumer {
                    () -> log.warn("⚠️ 이벤트 통계 없음: eventId={}", eventId)
                );

-            // 3. 캐시 무효화 (다음 조회 시 최신 참여자 수 반영)
+            // 3. 채널별 참여자 수 업데이트 - 비관적 락 적용
+            if (channel != null && !channel.isEmpty()) {
+                channelStatsRepository.findByEventIdAndChannelNameWithLock(eventId, channel)
+                    .ifPresentOrElse(
+                        channelStats -> {
+                            channelStats.incrementParticipants();
+                            channelStatsRepository.save(channelStats);
+                            log.info("✅ 채널별 참여자 수 업데이트: eventId={}, channel={}, participants={}",
+                                eventId, channel, channelStats.getParticipants());
+                        },
+                        () -> log.warn("⚠️ 채널 통계 없음: eventId={}, channel={}", eventId, channel)
+                    );
+            }
+
+            // 4. 캐시 무효화 (다음 조회 시 최신 참여자 수 반영)
            String cacheKey = CACHE_KEY_PREFIX + eventId;
            redisTemplate.delete(cacheKey);
            log.debug("🗑️ 캐시 무효화: {}", cacheKey);

-            // 4. 멱등성 처리 완료 기록 (7일 TTL)
-            redisTemplate.opsForSet().add(PROCESSED_PARTICIPANTS_KEY, participantId);
+            // 5. 멱등성 처리 완료 기록 (7일 TTL)
+            redisTemplate.opsForSet().add(PROCESSED_PARTICIPANTS_KEY, idempotencyKey);
            redisTemplate.expire(PROCESSED_PARTICIPANTS_KEY, IDEMPOTENCY_TTL_DAYS, TimeUnit.DAYS);
-            log.debug("✅ 멱등성 기록: participantId={}", participantId);
+            log.debug("✅ 멱등성 기록: eventId={}, participantId={}", eventId, participantId);

        } catch (Exception e) {
            log.error("❌ ParticipantRegistered 이벤트 처리 실패: {}", e.getMessage(), e);
--- a/analytics-service/src/main/java/com/kt/event/analytics/messaging/event/DistributionCompletedEvent.java
+++ b/analytics-service/src/main/java/com/kt/event/analytics/messaging/event/DistributionCompletedEvent.java
@ -62,5 +62,10 @@ public class DistributionCompletedEvent {
         * 예상 노출 수
         */
        private Integer expectedViews;
+
+        /**
+         * 배포 비용 (원)
+         */
+        private java.math.BigDecimal distributionCost;
    }
 }
--- a/analytics-service/src/main/java/com/kt/event/analytics/messaging/event/EventCreatedEvent.java
+++ b/analytics-service/src/main/java/com/kt/event/analytics/messaging/event/EventCreatedEvent.java
@ -6,6 +6,7 @@ import lombok.Data;
 import lombok.NoArgsConstructor;

 import java.math.BigDecimal;
+import java.time.LocalDateTime;

 /**
 * 이벤트 생성 이벤트
@ -36,8 +37,23 @@ public class EventCreatedEvent {
     */
    private BigDecimal totalInvestment;

+    /**
+     * 예상 수익
+     */
+    private BigDecimal expectedRevenue;
+
    /**
     * 이벤트 상태
     */
    private String status;
+
+    /**
+     * 이벤트 시작일
+     */
+    private LocalDateTime startDate;
+
+    /**
+     * 이벤트 종료일 (null이면 진행중)
+     */
+    private LocalDateTime endDate;
 }
--- a/analytics-service/src/main/java/com/kt/event/analytics/repository/ChannelStatsRepository.java
+++ b/analytics-service/src/main/java/com/kt/event/analytics/repository/ChannelStatsRepository.java
@ -1,7 +1,11 @@
 package com.kt.event.analytics.repository;

 import com.kt.event.analytics.entity.ChannelStats;
+import jakarta.persistence.LockModeType;
 import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Lock;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
 import org.springframework.stereotype.Repository;

 import java.util.List;
@ -30,6 +34,18 @@ public interface ChannelStatsRepository extends JpaRepository<ChannelStats, Long
     */
    Optional<ChannelStats> findByEventIdAndChannelName(String eventId, String channelName);

+    /**
+     * 이벤트 ID와 채널명으로 통계 조회 (비관적 락)
+     *
+     * @param eventId     이벤트 ID
+     * @param channelName 채널명
+     * @return 채널 통계
+     */
+    @Lock(LockModeType.PESSIMISTIC_WRITE)
+    @Query("SELECT c FROM ChannelStats c WHERE c.eventId = :eventId AND c.channelName = :channelName")
+    Optional<ChannelStats> findByEventIdAndChannelNameWithLock(@Param("eventId") String eventId,
+                                                                 @Param("channelName") String channelName);
+
    /**
     * 여러 이벤트 ID로 모든 채널 통계 조회
     *
--- a/analytics-service/src/main/java/com/kt/event/analytics/service/AnalyticsService.java
+++ b/analytics-service/src/main/java/com/kt/event/analytics/service/AnalyticsService.java
@ -47,12 +47,10 @@ public class AnalyticsService {
     * 대시보드 데이터 조회
     *
     * @param eventId   이벤트 ID
-     * @param startDate 조회 시작 날짜 (선택)
-     * @param endDate   조회 종료 날짜 (선택)
-     * @param refresh   캐시 갱신 여부
-     * @return 대시보드 응답
+     * @param refresh 캐시 갱신 여부
+     * @return 대시보드 응답 (이벤트 시작일 ~ 현재까지)
     */
-    public AnalyticsDashboardResponse getDashboardData(String eventId, LocalDateTime startDate, LocalDateTime endDate, boolean refresh) {
+    public AnalyticsDashboardResponse getDashboardData(String eventId, boolean refresh) {
        log.info("대시보드 데이터 조회 시작: eventId={}, refresh={}", eventId, refresh);

        String cacheKey = CACHE_KEY_PREFIX + eventId;
@ -91,7 +89,7 @@ public class AnalyticsService {
        }

        // 3. 대시보드 데이터 구성
-        AnalyticsDashboardResponse response = buildDashboardData(eventStats, channelStatsList, startDate, endDate);
+        AnalyticsDashboardResponse response = buildDashboardData(eventStats, channelStatsList);

        // 4. Redis 캐싱 (1시간 TTL)
        try {
@ -110,10 +108,9 @@ public class AnalyticsService {
    /**
     * 대시보드 데이터 구성
     */
-    private AnalyticsDashboardResponse buildDashboardData(EventStats eventStats, List<ChannelStats> channelStatsList,
-                                                           LocalDateTime startDate, LocalDateTime endDate) {
-        // 기간 정보
-        PeriodInfo period = buildPeriodInfo(startDate, endDate);
+    private AnalyticsDashboardResponse buildDashboardData(EventStats eventStats, List<ChannelStats> channelStatsList) {
+        // 기간 정보 (이벤트 시작일 ~ 현재)
+        PeriodInfo period = buildPeriodInfo(eventStats);

        // 성과 요약
        AnalyticsSummary summary = buildAnalyticsSummary(eventStats, channelStatsList);
@ -124,6 +121,15 @@ public class AnalyticsService {
        // ROI 요약
        RoiSummary roiSummary = roiCalculator.calculateRoiSummary(eventStats);

+        // 투자 비용 상세
+        InvestmentDetails investment = buildInvestmentDetails(eventStats, channelStatsList);
+
+        // 수익 상세
+        RevenueDetails revenue = buildRevenueDetails(eventStats);
+
+        // 비용 효율성
+        CostEfficiency costEfficiency = buildCostEfficiency(eventStats);
+
        return AnalyticsDashboardResponse.builder()
            .eventId(eventStats.getEventId())
            .eventTitle(eventStats.getEventTitle())
@ -131,17 +137,21 @@ public class AnalyticsService {
            .summary(summary)
            .channelPerformance(channelPerformance)
            .roi(roiSummary)
+            .investment(investment)
+            .revenue(revenue)
+            .costEfficiency(costEfficiency)
            .lastUpdatedAt(LocalDateTime.now())
            .dataSource("cached")
            .build();
    }

    /**
-     * 기간 정보 구성
+     * 기간 정보 구성 (이벤트 시작일 ~ 종료일 또는 현재)
     */
-    private PeriodInfo buildPeriodInfo(LocalDateTime startDate, LocalDateTime endDate) {
-        LocalDateTime start = startDate != null ? startDate : LocalDateTime.now().minusDays(30);
-        LocalDateTime end = endDate != null ? endDate : LocalDateTime.now();
+    private PeriodInfo buildPeriodInfo(EventStats eventStats) {
+        LocalDateTime start = eventStats.getStartDate();
+        LocalDateTime end = eventStats.getEndDate() != null ?
+            eventStats.getEndDate() : LocalDateTime.now();

        long durationDays = ChronoUnit.DAYS.between(start, end);

@ -215,4 +225,88 @@ public class AnalyticsService {

        return summaries;
    }
+
+    /**
+     * 투자 비용 상세 구성
+     *
+     * UserRoiAnalyticsService와 동일한 로직:
+     * - 실제 채널 배포 비용 집계
+     * - 나머지 비용 분배: 경품 50%, 콘텐츠 제작 30%, 운영 20%
+     */
+    private InvestmentDetails buildInvestmentDetails(EventStats eventStats, List<ChannelStats> channelStatsList) {
+        java.math.BigDecimal totalInvestment = eventStats.getTotalInvestment();
+
+        // ChannelStats에서 실제 배포 비용 집계
+        java.math.BigDecimal actualDistribution = channelStatsList.stream()
+            .map(ChannelStats::getDistributionCost)
+            .reduce(java.math.BigDecimal.ZERO, java.math.BigDecimal::add);
+
+        // 나머지 비용 계산 (총 투자 - 실제 채널 배포 비용)
+        java.math.BigDecimal remaining = totalInvestment.subtract(actualDistribution);
+
+        // 나머지 비용 분배: 경품 50%, 콘텐츠 제작 30%, 운영 20%
+        java.math.BigDecimal prizeCost = remaining.multiply(java.math.BigDecimal.valueOf(0.50));
+        java.math.BigDecimal contentCreation = remaining.multiply(java.math.BigDecimal.valueOf(0.30));
+        java.math.BigDecimal operation = remaining.multiply(java.math.BigDecimal.valueOf(0.20));
+
+        return InvestmentDetails.builder()
+            .total(totalInvestment)
+            .contentCreation(contentCreation)
+            .operation(operation)
+            .distribution(actualDistribution)
+            .prizeCost(prizeCost)
+            .channelCost(actualDistribution)  // 채널비용은 배포비용과 동일
+            .build();
+    }
+
+    /**
+     * 수익 상세 구성
+     *
+     * UserRoiAnalyticsService와 동일한 로직:
+     * - 직접 매출 70%, 예상 추가 매출 30%
+     * - 신규 고객 40%, 기존 고객 60%
+     */
+    private RevenueDetails buildRevenueDetails(EventStats eventStats) {
+        java.math.BigDecimal totalRevenue = eventStats.getExpectedRevenue();
+
+        // 매출 분배: 직접 매출 70%, 예상 추가 매출 30%
+        java.math.BigDecimal directSales = totalRevenue.multiply(java.math.BigDecimal.valueOf(0.70));
+        java.math.BigDecimal expectedSales = totalRevenue.multiply(java.math.BigDecimal.valueOf(0.30));
+
+        // 신규 고객 40%, 기존 고객 60%
+        java.math.BigDecimal newCustomerRevenue = totalRevenue.multiply(java.math.BigDecimal.valueOf(0.40));
+        java.math.BigDecimal existingCustomerRevenue = totalRevenue.multiply(java.math.BigDecimal.valueOf(0.60));
+
+        return RevenueDetails.builder()
+            .total(totalRevenue)
+            .directSales(directSales)
+            .expectedSales(expectedSales)
+            .newCustomerRevenue(newCustomerRevenue)
+            .existingCustomerRevenue(existingCustomerRevenue)
+            .brandValue(java.math.BigDecimal.ZERO)  // 브랜드 가치는 별도 계산 필요 시 추가
+            .build();
+    }
+
+    /**
+     * 비용 효율성 구성
+     *
+     * UserRoiAnalyticsService와 동일한 로직:
+     * - 참여자당 비용 = 총투자 ÷ 총참여자수
+     * - 참여자당 수익 = 총수익 ÷ 총참여자수
+     */
+    private CostEfficiency buildCostEfficiency(EventStats eventStats) {
+        int totalParticipants = eventStats.getTotalParticipants();
+        java.math.BigDecimal totalInvestment = eventStats.getTotalInvestment();
+        java.math.BigDecimal totalRevenue = eventStats.getExpectedRevenue();
+
+        double costPerParticipant = totalParticipants > 0 ?
+            totalInvestment.doubleValue() / totalParticipants : 0.0;
+        double revenuePerParticipant = totalParticipants > 0 ?
+            totalRevenue.doubleValue() / totalParticipants : 0.0;
+
+        return CostEfficiency.builder()
+            .costPerParticipant(costPerParticipant)
+            .revenuePerParticipant(revenuePerParticipant)
+            .build();
+    }
 }
--- a/analytics-service/src/main/java/com/kt/event/analytics/service/ROICalculator.java
+++ b/analytics-service/src/main/java/com/kt/event/analytics/service/ROICalculator.java
@ -60,43 +60,62 @@ public class ROICalculator {

    /**
     * 투자 비용 계산
+     *
+     * UserRoiAnalyticsService와 동일한 로직:
+     * - ChannelStats에서 실제 배포 비용 집계
+     * - 나머지 비용 분배: 경품 50%, 콘텐츠 제작 30%, 운영 20%
     */
    private InvestmentDetails calculateInvestment(EventStats eventStats, List<ChannelStats> channelStats) {
-        BigDecimal distributionCost = channelStats.stream()
+        BigDecimal totalInvestment = eventStats.getTotalInvestment();
+
+        // ChannelStats에서 실제 배포 비용 집계
+        BigDecimal actualDistribution = channelStats.stream()
            .map(ChannelStats::getDistributionCost)
            .reduce(BigDecimal.ZERO, BigDecimal::add);

-        BigDecimal contentCreation = eventStats.getTotalInvestment()
-            .multiply(BigDecimal.valueOf(0.4)); // 전체 투자의 40%를 콘텐츠 제작비로 가정
+        // 나머지 비용 계산 (총 투자 - 실제 채널 배포 비용)
+        BigDecimal remaining = totalInvestment.subtract(actualDistribution);

-        BigDecimal operation = eventStats.getTotalInvestment()
-            .multiply(BigDecimal.valueOf(0.1)); // 10%를 운영비로 가정
+        // 나머지 비용 분배: 경품 50%, 콘텐츠 제작 30%, 운영 20%
+        BigDecimal prizeCost = remaining.multiply(BigDecimal.valueOf(0.50));
+        BigDecimal contentCreation = remaining.multiply(BigDecimal.valueOf(0.30));
+        BigDecimal operation = remaining.multiply(BigDecimal.valueOf(0.20));

        return InvestmentDetails.builder()
+            .total(totalInvestment)
            .contentCreation(contentCreation)
-            .distribution(distributionCost)
            .operation(operation)
-            .total(eventStats.getTotalInvestment())
+            .distribution(actualDistribution)
+            .prizeCost(prizeCost)
+            .channelCost(actualDistribution)  // 채널비용은 배포비용과 동일
            .build();
    }

    /**
     * 수익 계산
+     *
+     * UserRoiAnalyticsService와 동일한 로직:
+     * - 직접 매출 70%, 예상 추가 매출 30%
+     * - 신규 고객 40%, 기존 고객 60%
     */
    private RevenueDetails calculateRevenue(EventStats eventStats) {
-        BigDecimal directSales = eventStats.getExpectedRevenue()
-            .multiply(BigDecimal.valueOf(0.66)); // 예상 수익의 66%를 직접 매출로 가정
+        BigDecimal totalRevenue = eventStats.getExpectedRevenue();

-        BigDecimal expectedSales = eventStats.getExpectedRevenue()
-            .multiply(BigDecimal.valueOf(0.34)); // 34%를 예상 추가 매출로 가정
+        // 매출 분배: 직접 매출 70%, 예상 추가 매출 30%
+        BigDecimal directSales = totalRevenue.multiply(BigDecimal.valueOf(0.70));
+        BigDecimal expectedSales = totalRevenue.multiply(BigDecimal.valueOf(0.30));

-        BigDecimal brandValue = BigDecimal.ZERO; // 브랜드 가치는 별도 계산 필요
+        // 신규 고객 40%, 기존 고객 60%
+        BigDecimal newCustomerRevenue = totalRevenue.multiply(BigDecimal.valueOf(0.40));
+        BigDecimal existingCustomerRevenue = totalRevenue.multiply(BigDecimal.valueOf(0.60));

        return RevenueDetails.builder()
+            .total(totalRevenue)
            .directSales(directSales)
            .expectedSales(expectedSales)
-            .brandValue(brandValue)
-            .total(eventStats.getExpectedRevenue())
+            .newCustomerRevenue(newCustomerRevenue)
+            .existingCustomerRevenue(existingCustomerRevenue)
+            .brandValue(BigDecimal.ZERO)  // 브랜드 가치는 별도 계산 필요 시 추가
            .build();
    }

--- a/analytics-service/src/main/java/com/kt/event/analytics/service/TimelineAnalyticsService.java
+++ b/analytics-service/src/main/java/com/kt/event/analytics/service/TimelineAnalyticsService.java
@ -26,20 +26,13 @@ public class TimelineAnalyticsService {
    private final TimelineDataRepository timelineDataRepository;

    /**
-     * 시간대별 참여 추이 조회
+     * 시간대별 참여 추이 조회 (이벤트 전체 기간)
     */
-    public TimelineAnalyticsResponse getTimelineAnalytics(String eventId, String interval,
-                                                           LocalDateTime startDate, LocalDateTime endDate,
-                                                           List<String> metrics) {
+    public TimelineAnalyticsResponse getTimelineAnalytics(String eventId, String interval, List<String> metrics) {
        log.info("시간대별 참여 추이 조회: eventId={}, interval={}", eventId, interval);

-        // 시간대별 데이터 조회
-        List<TimelineData> timelineDataList;
-        if (startDate != null && endDate != null) {
-            timelineDataList = timelineDataRepository.findByEventIdAndTimestampBetween(eventId, startDate, endDate);
-        } else {
-            timelineDataList = timelineDataRepository.findByEventIdOrderByTimestampAsc(eventId);
-        }
+        // 시간대별 데이터 조회 (이벤트 전체 기간)
+        List<TimelineData> timelineDataList = timelineDataRepository.findByEventIdOrderByTimestampAsc(eventId);

        // 시간대별 데이터 포인트 구성
        List<TimelineDataPoint> dataPoints = buildTimelineDataPoints(timelineDataList);
--- a/analytics-service/src/main/java/com/kt/event/analytics/service/UserAnalyticsService.java
+++ b/analytics-service/src/main/java/com/kt/event/analytics/service/UserAnalyticsService.java
@ -44,13 +44,11 @@ public class UserAnalyticsService {
    /**
     * 사용자 전체 대시보드 데이터 조회
     *
-     * @param userId    사용자 ID
-     * @param startDate 조회 시작 날짜 (선택)
-     * @param endDate   조회 종료 날짜 (선택)
-     * @param refresh   캐시 갱신 여부
-     * @return 사용자 통합 대시보드 응답
+     * @param userId  사용자 ID
+     * @param refresh 캐시 갱신 여부
+     * @return 사용자 통합 대시보드 응답 (userId 기반 전체 이벤트 조회)
     */
-    public UserAnalyticsDashboardResponse getUserDashboardData(String userId, LocalDateTime startDate, LocalDateTime endDate, boolean refresh) {
+    public UserAnalyticsDashboardResponse getUserDashboardData(String userId, boolean refresh) {
        log.info("사용자 전체 대시보드 데이터 조회 시작: userId={}, refresh={}", userId, refresh);

        String cacheKey = CACHE_KEY_PREFIX + userId;
@ -75,7 +73,7 @@ public class UserAnalyticsService {
        List<EventStats> allEvents = eventStatsRepository.findAllByUserId(userId);
        if (allEvents.isEmpty()) {
            log.warn("사용자에 이벤트가 없음: userId={}", userId);
-            return buildEmptyResponse(userId, startDate, endDate);
+            return buildEmptyResponse(userId);
        }

        log.debug("사용자 이벤트 조회 완료: userId={}, 이벤트 수={}", userId, allEvents.size());
@ -87,7 +85,7 @@ public class UserAnalyticsService {
        List<ChannelStats> allChannelStats = channelStatsRepository.findByEventIdIn(eventIds);

        // 3. 통합 대시보드 데이터 구성
-        UserAnalyticsDashboardResponse response = buildUserDashboardData(userId, allEvents, allChannelStats, startDate, endDate);
+        UserAnalyticsDashboardResponse response = buildUserDashboardData(userId, allEvents, allChannelStats);

        // 4. Redis 캐싱 (30분 TTL)
        try {
@ -104,10 +102,15 @@ public class UserAnalyticsService {
    /**
     * 빈 응답 생성 (이벤트가 없는 경우)
     */
-    private UserAnalyticsDashboardResponse buildEmptyResponse(String userId, LocalDateTime startDate, LocalDateTime endDate) {
+    private UserAnalyticsDashboardResponse buildEmptyResponse(String userId) {
+        LocalDateTime now = LocalDateTime.now();
        return UserAnalyticsDashboardResponse.builder()
                .userId(userId)
-                .period(buildPeriodInfo(startDate, endDate))
+                .period(PeriodInfo.builder()
+                        .startDate(now)
+                        .endDate(now)
+                        .durationDays(0)
+                        .build())
                .totalEvents(0)
                .activeEvents(0)
                .overallSummary(buildEmptyAnalyticsSummary())
@ -123,10 +126,9 @@ public class UserAnalyticsService {
     * 사용자 통합 대시보드 데이터 구성
     */
    private UserAnalyticsDashboardResponse buildUserDashboardData(String userId, List<EventStats> allEvents,
-                                                                   List<ChannelStats> allChannelStats,
-                                                                   LocalDateTime startDate, LocalDateTime endDate) {
-        // 기간 정보
-        PeriodInfo period = buildPeriodInfo(startDate, endDate);
+                                                                   List<ChannelStats> allChannelStats) {
+        // 기간 정보 (전체 이벤트의 최소/최대 날짜 기반)
+        PeriodInfo period = buildPeriodFromEvents(allEvents);

        // 전체 이벤트 수 및 활성 이벤트 수
        int totalEvents = allEvents.size();
@ -299,16 +301,22 @@ public class UserAnalyticsService {

    /**
     * 기간 정보 구성
+     *
+     * 전체 이벤트 중 가장 빠른 시작일 ~ 현재까지의 기간 계산
     */
-    private PeriodInfo buildPeriodInfo(LocalDateTime startDate, LocalDateTime endDate) {
-        LocalDateTime start = startDate != null ? startDate : LocalDateTime.now().minusDays(30);
-        LocalDateTime end = endDate != null ? endDate : LocalDateTime.now();
-        long durationDays = ChronoUnit.DAYS.between(start, end);
+    private PeriodInfo buildPeriodFromEvents(List<EventStats> events) {
+        LocalDateTime start = events.stream()
+                .map(EventStats::getStartDate)
+                .filter(Objects::nonNull)
+                .min(LocalDateTime::compareTo)
+                .orElse(LocalDateTime.now());
+
+        LocalDateTime end = LocalDateTime.now();

        return PeriodInfo.builder()
                .startDate(start)
                .endDate(end)
-                .durationDays((int) durationDays)
+                .durationDays((int) ChronoUnit.DAYS.between(start, end))
                .build();
    }

--- a/analytics-service/src/main/java/com/kt/event/analytics/service/UserChannelAnalyticsService.java
+++ b/analytics-service/src/main/java/com/kt/event/analytics/service/UserChannelAnalyticsService.java
@ -42,10 +42,9 @@ public class UserChannelAnalyticsService {
    private static final long CACHE_TTL = 1800; // 30분

    /**
-     * 사용자 전체 채널 분석 데이터 조회
+     * 사용자 전체 채널 분석 데이터 조회 (전체 채널 무조건 표시)
     */
-    public UserChannelAnalyticsResponse getUserChannelAnalytics(String userId, List<String> channels, String sortBy, String order,
-                                                                 LocalDateTime startDate, LocalDateTime endDate, boolean refresh) {
+    public UserChannelAnalyticsResponse getUserChannelAnalytics(String userId, String sortBy, String order, boolean refresh) {
        log.info("사용자 채널 분석 조회 시작: userId={}, refresh={}", userId, refresh);

        String cacheKey = CACHE_KEY_PREFIX + userId;
@ -66,14 +65,14 @@ public class UserChannelAnalyticsService {
        // 2. 데이터 조회
        List<EventStats> allEvents = eventStatsRepository.findAllByUserId(userId);
        if (allEvents.isEmpty()) {
-            return buildEmptyResponse(userId, startDate, endDate);
+            return buildEmptyResponse(userId);
        }

        List<String> eventIds = allEvents.stream().map(EventStats::getEventId).collect(Collectors.toList());
        List<ChannelStats> allChannelStats = channelStatsRepository.findByEventIdIn(eventIds);

-        // 3. 응답 구성
-        UserChannelAnalyticsResponse response = buildChannelAnalyticsResponse(userId, allEvents, allChannelStats, channels, sortBy, order, startDate, endDate);
+        // 3. 응답 구성 (전체 채널)
+        UserChannelAnalyticsResponse response = buildChannelAnalyticsResponse(userId, allEvents, allChannelStats, sortBy, order);

        // 4. 캐싱
        try {
@ -87,10 +86,15 @@ public class UserChannelAnalyticsService {
        return response;
    }

-    private UserChannelAnalyticsResponse buildEmptyResponse(String userId, LocalDateTime startDate, LocalDateTime endDate) {
+    private UserChannelAnalyticsResponse buildEmptyResponse(String userId) {
+        LocalDateTime now = LocalDateTime.now();
        return UserChannelAnalyticsResponse.builder()
                .userId(userId)
-                .period(buildPeriodInfo(startDate, endDate))
+                .period(PeriodInfo.builder()
+                        .startDate(now)
+                        .endDate(now)
+                        .durationDays(0)
+                        .build())
                .totalEvents(0)
                .channels(new ArrayList<>())
                .comparison(ChannelComparison.builder().build())
@ -100,15 +104,10 @@ public class UserChannelAnalyticsService {
    }

    private UserChannelAnalyticsResponse buildChannelAnalyticsResponse(String userId, List<EventStats> allEvents,
-                                                                        List<ChannelStats> allChannelStats, List<String> channels,
-                                                                        String sortBy, String order, LocalDateTime startDate, LocalDateTime endDate) {
-        // 채널 필터링
-        List<ChannelStats> filteredChannels = channels != null && !channels.isEmpty()
-                ? allChannelStats.stream().filter(c -> channels.contains(c.getChannelName())).collect(Collectors.toList())
-                : allChannelStats;
-
-        // 채널별 집계
-        List<ChannelAnalytics> channelAnalyticsList = aggregateChannelAnalytics(filteredChannels);
+                                                                        List<ChannelStats> allChannelStats,
+                                                                        String sortBy, String order) {
+        // 채널별 집계 (전체 채널)
+        List<ChannelAnalytics> channelAnalyticsList = aggregateChannelAnalytics(allChannelStats);

        // 정렬
        channelAnalyticsList = sortChannels(channelAnalyticsList, sortBy, order);
@ -118,7 +117,7 @@ public class UserChannelAnalyticsService {

        return UserChannelAnalyticsResponse.builder()
                .userId(userId)
-                .period(buildPeriodInfo(startDate, endDate))
+                .period(buildPeriodFromEvents(allEvents))
                .totalEvents(allEvents.size())
                .channels(channelAnalyticsList)
                .comparison(comparison)
@ -246,15 +245,24 @@ public class UserChannelAnalyticsService {
                .build();
    }

-    private PeriodInfo buildPeriodInfo(LocalDateTime startDate, LocalDateTime endDate) {
-        LocalDateTime start = startDate != null ? startDate : LocalDateTime.now().minusDays(30);
-        LocalDateTime end = endDate != null ? endDate : LocalDateTime.now();
-        long durationDays = ChronoUnit.DAYS.between(start, end);
+    /**
+     * 전체 이벤트의 생성/수정 시간 기반으로 period 계산
+     */
+    private PeriodInfo buildPeriodFromEvents(List<EventStats> events) {
+        LocalDateTime start = events.stream()
+                .map(EventStats::getCreatedAt)
+                .min(LocalDateTime::compareTo)
+                .orElse(LocalDateTime.now());
+
+        LocalDateTime end = events.stream()
+                .map(EventStats::getUpdatedAt)
+                .max(LocalDateTime::compareTo)
+                .orElse(LocalDateTime.now());

        return PeriodInfo.builder()
                .startDate(start)
                .endDate(end)
-                .durationDays((int) durationDays)
+                .durationDays((int) ChronoUnit.DAYS.between(start, end))
                .build();
    }
 }
--- a/analytics-service/src/main/java/com/kt/event/analytics/service/UserRoiAnalyticsService.java
+++ b/analytics-service/src/main/java/com/kt/event/analytics/service/UserRoiAnalyticsService.java
@ -1,7 +1,9 @@
 package com.kt.event.analytics.service;

 import com.kt.event.analytics.dto.response.*;
+import com.kt.event.analytics.entity.ChannelStats;
 import com.kt.event.analytics.entity.EventStats;
+import com.kt.event.analytics.repository.ChannelStatsRepository;
 import com.kt.event.analytics.repository.EventStatsRepository;
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.ObjectMapper;
@ -31,14 +33,14 @@ import java.util.stream.Collectors;
 public class UserRoiAnalyticsService {

    private final EventStatsRepository eventStatsRepository;
+    private final ChannelStatsRepository channelStatsRepository;
    private final RedisTemplate<String, String> redisTemplate;
    private final ObjectMapper objectMapper;

    private static final String CACHE_KEY_PREFIX = "analytics:user:roi:";
    private static final long CACHE_TTL = 1800;

-    public UserRoiAnalyticsResponse getUserRoiAnalytics(String userId, boolean includeProjection,
-                                                         LocalDateTime startDate, LocalDateTime endDate, boolean refresh) {
+    public UserRoiAnalyticsResponse getUserRoiAnalytics(String userId, boolean includeProjection, boolean refresh) {
        log.info("사용자 ROI 분석 조회 시작: userId={}, refresh={}", userId, refresh);

        String cacheKey = CACHE_KEY_PREFIX + userId;
@ -56,10 +58,10 @@ public class UserRoiAnalyticsService {

        List<EventStats> allEvents = eventStatsRepository.findAllByUserId(userId);
        if (allEvents.isEmpty()) {
-            return buildEmptyResponse(userId, startDate, endDate);
+            return buildEmptyResponse(userId);
        }

-        UserRoiAnalyticsResponse response = buildRoiResponse(userId, allEvents, includeProjection, startDate, endDate);
+        UserRoiAnalyticsResponse response = buildRoiResponse(userId, allEvents, includeProjection);

        try {
            String jsonData = objectMapper.writeValueAsString(response);
@ -71,13 +73,32 @@ public class UserRoiAnalyticsService {
        return response;
    }

-    private UserRoiAnalyticsResponse buildEmptyResponse(String userId, LocalDateTime startDate, LocalDateTime endDate) {
+    private UserRoiAnalyticsResponse buildEmptyResponse(String userId) {
+        LocalDateTime now = LocalDateTime.now();
        return UserRoiAnalyticsResponse.builder()
                .userId(userId)
-                .period(buildPeriodInfo(startDate, endDate))
+                .period(PeriodInfo.builder()
+                        .startDate(now)
+                        .endDate(now)
+                        .durationDays(0)
+                        .build())
                .totalEvents(0)
-                .overallInvestment(InvestmentDetails.builder().total(BigDecimal.ZERO).build())
-                .overallRevenue(RevenueDetails.builder().total(BigDecimal.ZERO).build())
+                .overallInvestment(InvestmentDetails.builder()
+                        .total(BigDecimal.ZERO)
+                        .contentCreation(BigDecimal.ZERO)
+                        .operation(BigDecimal.ZERO)
+                        .distribution(BigDecimal.ZERO)
+                        .prizeCost(BigDecimal.ZERO)
+                        .channelCost(BigDecimal.ZERO)
+                        .build())
+                .overallRevenue(RevenueDetails.builder()
+                        .total(BigDecimal.ZERO)
+                        .directSales(BigDecimal.ZERO)
+                        .expectedSales(BigDecimal.ZERO)
+                        .newCustomerRevenue(BigDecimal.ZERO)
+                        .existingCustomerRevenue(BigDecimal.ZERO)
+                        .brandValue(BigDecimal.ZERO)
+                        .build())
                .overallRoi(RoiCalculation.builder()
                        .netProfit(BigDecimal.ZERO)
                        .roiPercentage(0.0)
@ -88,8 +109,7 @@ public class UserRoiAnalyticsService {
                .build();
    }

-    private UserRoiAnalyticsResponse buildRoiResponse(String userId, List<EventStats> allEvents, boolean includeProjection,
-                                                       LocalDateTime startDate, LocalDateTime endDate) {
+    private UserRoiAnalyticsResponse buildRoiResponse(String userId, List<EventStats> allEvents, boolean includeProjection) {
        BigDecimal totalInvestment = allEvents.stream().map(EventStats::getTotalInvestment).reduce(BigDecimal.ZERO, BigDecimal::add);
        BigDecimal totalRevenue = allEvents.stream().map(EventStats::getExpectedRevenue).reduce(BigDecimal.ZERO, BigDecimal::add);
        BigDecimal totalProfit = totalRevenue.subtract(totalInvestment);
@ -98,17 +118,44 @@ public class UserRoiAnalyticsService {
                ? totalProfit.divide(totalInvestment, 4, RoundingMode.HALF_UP).multiply(BigDecimal.valueOf(100)).doubleValue()
                : 0.0;

+        // ChannelStats에서 실제 배포 비용 집계
+        List<String> eventIds = allEvents.stream().map(EventStats::getEventId).collect(Collectors.toList());
+        List<ChannelStats> allChannelStats = channelStatsRepository.findByEventIdIn(eventIds);
+
+        BigDecimal actualDistribution = allChannelStats.stream()
+                .map(ChannelStats::getDistributionCost)
+                .reduce(BigDecimal.ZERO, BigDecimal::add);
+
+        // 나머지 비용 계산 (총 투자 - 실제 채널 배포 비용)
+        BigDecimal remaining = totalInvestment.subtract(actualDistribution);
+
+        // 나머지 비용 분배: 경품 50%, 콘텐츠 제작 30%, 운영 20%
+        BigDecimal prizeCost = remaining.multiply(BigDecimal.valueOf(0.50));
+        BigDecimal contentCreation = remaining.multiply(BigDecimal.valueOf(0.30));
+        BigDecimal operation = remaining.multiply(BigDecimal.valueOf(0.20));
+
        InvestmentDetails investment = InvestmentDetails.builder()
                .total(totalInvestment)
-                .contentCreation(totalInvestment.multiply(BigDecimal.valueOf(0.6)))
-                .operation(totalInvestment.multiply(BigDecimal.valueOf(0.2)))
-                .distribution(totalInvestment.multiply(BigDecimal.valueOf(0.2)))
+                .contentCreation(contentCreation)
+                .operation(operation)
+                .distribution(actualDistribution)
+                .prizeCost(prizeCost)
+                .channelCost(actualDistribution)  // 채널비용은 배포비용과 동일
                .build();

+        // 매출 분배: 직접 매출 70%, 예상 추가 매출 30% / 신규 고객 40%, 기존 고객 60%
+        BigDecimal directSales = totalRevenue.multiply(BigDecimal.valueOf(0.70));
+        BigDecimal expectedSales = totalRevenue.multiply(BigDecimal.valueOf(0.30));
+        BigDecimal newCustomerRevenue = totalRevenue.multiply(BigDecimal.valueOf(0.40));
+        BigDecimal existingCustomerRevenue = totalRevenue.multiply(BigDecimal.valueOf(0.60));
+
        RevenueDetails revenue = RevenueDetails.builder()
                .total(totalRevenue)
-                .directSales(totalRevenue.multiply(BigDecimal.valueOf(0.7)))
-                .expectedSales(totalRevenue.multiply(BigDecimal.valueOf(0.3)))
+                .directSales(directSales)
+                .expectedSales(expectedSales)
+                .newCustomerRevenue(newCustomerRevenue)
+                .existingCustomerRevenue(existingCustomerRevenue)
+                .brandValue(BigDecimal.ZERO)  // 브랜드 가치는 별도 계산 필요 시 추가
                .build();

        RoiCalculation roiCalc = RoiCalculation.builder()
@ -149,9 +196,12 @@ public class UserRoiAnalyticsService {
                .sorted(Comparator.comparingDouble(UserRoiAnalyticsResponse.EventRoiSummary::getRoi).reversed())
                .collect(Collectors.toList());

+        // 전체 이벤트의 최소/최대 날짜로 period 계산
+        PeriodInfo period = buildPeriodFromEvents(allEvents);
+
        return UserRoiAnalyticsResponse.builder()
                .userId(userId)
-                .period(buildPeriodInfo(startDate, endDate))
+                .period(period)
                .totalEvents(allEvents.size())
                .overallInvestment(investment)
                .overallRevenue(revenue)
@ -164,9 +214,20 @@ public class UserRoiAnalyticsService {
                .build();
    }

-    private PeriodInfo buildPeriodInfo(LocalDateTime startDate, LocalDateTime endDate) {
-        LocalDateTime start = startDate != null ? startDate : LocalDateTime.now().minusDays(30);
-        LocalDateTime end = endDate != null ? endDate : LocalDateTime.now();
+    /**
+     * 전체 이벤트의 생성/수정 시간 기반으로 period 계산
+     */
+    private PeriodInfo buildPeriodFromEvents(List<EventStats> events) {
+        LocalDateTime start = events.stream()
+                .map(EventStats::getCreatedAt)
+                .min(LocalDateTime::compareTo)
+                .orElse(LocalDateTime.now());
+
+        LocalDateTime end = events.stream()
+                .map(EventStats::getUpdatedAt)
+                .max(LocalDateTime::compareTo)
+                .orElse(LocalDateTime.now());
+
        return PeriodInfo.builder()
                .startDate(start)
                .endDate(end)
--- a/analytics-service/src/main/java/com/kt/event/analytics/service/UserTimelineAnalyticsService.java
+++ b/analytics-service/src/main/java/com/kt/event/analytics/service/UserTimelineAnalyticsService.java
@ -37,7 +37,6 @@ public class UserTimelineAnalyticsService {
    private static final long CACHE_TTL = 1800;

    public UserTimelineAnalyticsResponse getUserTimelineAnalytics(String userId, String interval,
-                                                                   LocalDateTime startDate, LocalDateTime endDate,
                                                                   List<String> metrics, boolean refresh) {
        log.info("사용자 타임라인 분석 조회 시작: userId={}, interval={}, refresh={}", userId, interval, refresh);

@ -56,15 +55,13 @@ public class UserTimelineAnalyticsService {

        List<EventStats> allEvents = eventStatsRepository.findAllByUserId(userId);
        if (allEvents.isEmpty()) {
-            return buildEmptyResponse(userId, interval, startDate, endDate);
+            return buildEmptyResponse(userId, interval);
        }

        List<String> eventIds = allEvents.stream().map(EventStats::getEventId).collect(Collectors.toList());
-        List<TimelineData> allTimelineData = startDate != null && endDate != null
-                ? timelineDataRepository.findByEventIdInAndTimestampBetween(eventIds, startDate, endDate)
-                : timelineDataRepository.findByEventIdInOrderByTimestampAsc(eventIds);
+        List<TimelineData> allTimelineData = timelineDataRepository.findByEventIdInOrderByTimestampAsc(eventIds);

-        UserTimelineAnalyticsResponse response = buildTimelineResponse(userId, allEvents, allTimelineData, interval, startDate, endDate);
+        UserTimelineAnalyticsResponse response = buildTimelineResponse(userId, allEvents, allTimelineData, interval);

        try {
            String jsonData = objectMapper.writeValueAsString(response);
@ -76,10 +73,15 @@ public class UserTimelineAnalyticsService {
        return response;
    }

-    private UserTimelineAnalyticsResponse buildEmptyResponse(String userId, String interval, LocalDateTime startDate, LocalDateTime endDate) {
+    private UserTimelineAnalyticsResponse buildEmptyResponse(String userId, String interval) {
+        LocalDateTime now = LocalDateTime.now();
        return UserTimelineAnalyticsResponse.builder()
                .userId(userId)
-                .period(buildPeriodInfo(startDate, endDate))
+                .period(PeriodInfo.builder()
+                        .startDate(now)
+                        .endDate(now)
+                        .durationDays(0)
+                        .build())
                .totalEvents(0)
                .interval(interval != null ? interval : "daily")
                .dataPoints(new ArrayList<>())
@ -91,8 +93,7 @@ public class UserTimelineAnalyticsService {
    }

    private UserTimelineAnalyticsResponse buildTimelineResponse(String userId, List<EventStats> allEvents,
-                                                                 List<TimelineData> allTimelineData, String interval,
-                                                                 LocalDateTime startDate, LocalDateTime endDate) {
+                                                                 List<TimelineData> allTimelineData, String interval) {
        Map<LocalDateTime, TimelineDataPoint> aggregatedData = new LinkedHashMap<>();

        for (TimelineData data : allTimelineData) {
@ -119,7 +120,7 @@ public class UserTimelineAnalyticsService {

        return UserTimelineAnalyticsResponse.builder()
                .userId(userId)
-                .period(buildPeriodInfo(startDate, endDate))
+                .period(buildPeriodFromEvents(allEvents))
                .totalEvents(allEvents.size())
                .interval(interval != null ? interval : "daily")
                .dataPoints(dataPoints)
@ -179,9 +180,20 @@ public class UserTimelineAnalyticsService {
                .build() : PeakTimeInfo.builder().build();
    }

-    private PeriodInfo buildPeriodInfo(LocalDateTime startDate, LocalDateTime endDate) {
-        LocalDateTime start = startDate != null ? startDate : LocalDateTime.now().minusDays(30);
-        LocalDateTime end = endDate != null ? endDate : LocalDateTime.now();
+    /**
+     * 전체 이벤트의 생성/수정 시간 기반으로 period 계산
+     */
+    private PeriodInfo buildPeriodFromEvents(List<EventStats> events) {
+        LocalDateTime start = events.stream()
+                .map(EventStats::getCreatedAt)
+                .min(LocalDateTime::compareTo)
+                .orElse(LocalDateTime.now());
+
+        LocalDateTime end = events.stream()
+                .map(EventStats::getUpdatedAt)
+                .max(LocalDateTime::compareTo)
+                .orElse(LocalDateTime.now());
+
        return PeriodInfo.builder()
                .startDate(start)
                .endDate(end)
--- a/analytics-service/src/main/resources/application.yml
+++ b/analytics-service/src/main/resources/application.yml
@ -47,11 +47,13 @@ spring:
    enabled: ${KAFKA_ENABLED:true}
    bootstrap-servers: ${KAFKA_BOOTSTRAP_SERVERS:20.249.182.13:9095,4.217.131.59:9095}
    consumer:
-      group-id: ${KAFKA_CONSUMER_GROUP_ID:analytics-service}
+      group-id: ${KAFKA_CONSUMER_GROUP_ID:analytics-service-consumers-v3}
      auto-offset-reset: earliest
      enable-auto-commit: true
      key-deserializer: org.apache.kafka.common.serialization.StringDeserializer
      value-deserializer: org.apache.kafka.common.serialization.StringDeserializer
+      properties:
+        auto.offset.reset: earliest
    producer:
      key-serializer: org.apache.kafka.common.serialization.StringSerializer
      value-serializer: org.apache.kafka.common.serialization.StringSerializer
@ -75,6 +77,10 @@ server:
  port: ${SERVER_PORT:8086}
  servlet:
    context-path: /api/v1/analytics
+    encoding:
+      charset: UTF-8
+      enabled: true
+      force: true

 # JWT
 jwt:
@ -84,7 +90,11 @@ jwt:

 # CORS Configuration
 cors:
-  allowed-origins: ${CORS_ALLOWED_ORIGINS:http://localhost:*}
+  allowed-origins: ${CORS_ALLOWED_ORIGINS:http://localhost:8081,http://localhost:8082,http://localhost:8083,http://localhost:8084,http://kt-event-marketing.20.214.196.128.nip.io}
+  allowed-methods: ${CORS_ALLOWED_METHODS:GET,POST,PUT,DELETE,OPTIONS,PATCH}
+  allowed-headers: ${CORS_ALLOWED_HEADERS:*}
+  allow-credentials: ${CORS_ALLOW_CREDENTIALS:true}
+  max-age: ${CORS_MAX_AGE:3600}

 # Actuator
 management:
--- a/common/src/main/java/com/kt/event/common/exception/ErrorCode.java
+++ b/common/src/main/java/com/kt/event/common/exception/ErrorCode.java
@ -40,8 +40,10 @@ public enum ErrorCode {
    EVENT_001("EVENT_001", "이벤트를 찾을 수 없습니다"),
    EVENT_002("EVENT_002", "유효하지 않은 상태 전환입니다"),
    EVENT_003("EVENT_003", "필수 데이터가 누락되었습니다"),
-    EVENT_004("EVENT_004", "이벤트 생성에 실패했습니다"),
-    EVENT_005("EVENT_005", "이벤트 수정 권한이 없습니다"),
+    EVENT_004("EVENT_004", "유효하지 않은 eventId 형식입니다"),
+    EVENT_005("EVENT_005", "이미 존재하는 eventId입니다"),
+    EVENT_006("EVENT_006", "이벤트 생성에 실패했습니다"),
+    EVENT_007("EVENT_007", "이벤트 수정 권한이 없습니다"),

    // Job 에러 (JOB_XXX)
    JOB_001("JOB_001", "Job을 찾을 수 없습니다"),
--- a/common/src/main/java/com/kt/event/common/security/JwtTokenProvider.java
+++ b/common/src/main/java/com/kt/event/common/security/JwtTokenProvider.java
@ -12,7 +12,6 @@ import javax.crypto.SecretKey;
 import java.nio.charset.StandardCharsets;
 import java.util.Date;
 import java.util.List;
-import java.util.UUID;

 /**
 * JWT 토큰 생성 및 검증 제공자
@ -57,13 +56,13 @@ public class JwtTokenProvider {
     * @return Access Token
     */

-    public String createAccessToken(UUID userId, UUID storeId, String email, String name, List<String> roles) {
+    public String createAccessToken(String userId, String storeId, String email, String name, List<String> roles) {
        Date now = new Date();
        Date expiryDate = new Date(now.getTime() + accessTokenValidityMs);

        return Jwts.builder()
-                .subject(userId.toString())
-                .claim("storeId", storeId != null ? storeId.toString() : null)
+                .subject(userId)
+                .claim("storeId", storeId)
                .claim("email", email)
                .claim("name", name)
                .claim("roles", roles)
@ -80,12 +79,12 @@ public class JwtTokenProvider {
     * @param userId 사용자 ID
     * @return Refresh Token
     */
-    public String createRefreshToken(UUID userId) {
+    public String createRefreshToken(String userId) {
        Date now = new Date();
        Date expiryDate = new Date(now.getTime() + refreshTokenValidityMs);

        return Jwts.builder()
-                .subject(userId.toString())
+                .subject(userId)
                .claim("type", "refresh")
                .issuedAt(now)
                .expiration(expiryDate)
@ -99,9 +98,9 @@ public class JwtTokenProvider {
     * @param token JWT 토큰
     * @return 사용자 ID
     */
-    public UUID getUserIdFromToken(String token) {
+    public String getUserIdFromToken(String token) {
        Claims claims = parseToken(token);
-        return UUID.fromString(claims.getSubject());
+        return claims.getSubject();
    }

    /**
@ -113,9 +112,8 @@ public class JwtTokenProvider {
    public UserPrincipal getUserPrincipalFromToken(String token) {
        Claims claims = parseToken(token);

-        UUID userId = UUID.fromString(claims.getSubject());
-        String storeIdStr = claims.get("storeId", String.class);
-        UUID storeId = storeIdStr != null ? UUID.fromString(storeIdStr) : null;
+        String userId = claims.getSubject();
+        String storeId = claims.get("storeId", String.class);
        String email = claims.get("email", String.class);
        String name = claims.get("name", String.class);
        @SuppressWarnings("unchecked")
--- a/common/src/main/java/com/kt/event/common/security/UserPrincipal.java
+++ b/common/src/main/java/com/kt/event/common/security/UserPrincipal.java
@ -9,7 +9,6 @@ import org.springframework.security.core.userdetails.UserDetails;

 import java.util.Collection;
 import java.util.List;
-import java.util.UUID;
 import java.util.stream.Collectors;

 /**
@ -24,12 +23,12 @@ public class UserPrincipal implements UserDetails {
    /**
     * 사용자 ID
     */
-    private final UUID userId;
+    private final String userId;

    /**
     * 매장 ID
     */
-    private final UUID storeId;
+    private final String storeId;

    /**
     * 사용자 이메일
--- a/content-service/src/main/java/com/kt/event/content/biz/service/RegenerateImageService.java
+++ b/content-service/src/main/java/com/kt/event/content/biz/service/RegenerateImageService.java
@ -46,6 +46,9 @@ public class RegenerateImageService implements RegenerateImageUseCase {
    @Value("${replicate.model.version:stability-ai/sdxl:39ed52f2a78e934b3ba6e2a89f5b1c712de7dfea535525255b1aa35c5565e08b}")
    private String modelVersion;

+    @Value("${replicate.mock.enabled:false}")
+    private boolean mockEnabled;
+
    public RegenerateImageService(
            ReplicateApiClient replicateClient,
            CDNUploader cdnUploader,
@ -151,6 +154,14 @@ public class RegenerateImageService implements RegenerateImageUseCase {
     */
    private String generateImage(String prompt, com.kt.event.content.biz.domain.Platform platform) {
        try {
+            // Mock 모드일 경우 Mock 데이터 반환
+//            if (mockEnabled) {
+//                log.info("[MOCK] 이미지 재생성 요청 (실제 API 호출 없음): prompt={}, platform={}", prompt, platform);
+//                String mockUrl = generateMockImageUrl(platform);
+//                log.info("[MOCK] 이미지 재생성 완료: url={}", mockUrl);
+//                return mockUrl;
+//            }
+
            int width = platform.getWidth();
            int height = platform.getHeight();

@ -274,4 +285,21 @@ public class RegenerateImageService implements RegenerateImageUseCase {
            throw new RuntimeException("Replicate API에 일시적으로 접근할 수 없습니다", e);
        }
    }
+
+    /**
+     * Mock 이미지 URL 생성 (dev 환경용)
+     *
+     * @param platform 플랫폼 (이미지 크기 결정)
+     * @return Mock 이미지 URL
+     */
+    private String generateMockImageUrl(com.kt.event.content.biz.domain.Platform platform) {
+        // 플랫폼별 크기에 맞는 placeholder 이미지 URL 생성
+        int width = platform.getWidth();
+        int height = platform.getHeight();
+
+        // placeholder.com을 사용한 Mock 이미지 URL
+        String mockId = UUID.randomUUID().toString().substring(0, 8);
+        return String.format("https://via.placeholder.com/%dx%d/6BCF7F/FFFFFF?text=Regenerated+%s+%s",
+                width, height, platform.name(), mockId);
+    }
 }
--- a/content-service/src/main/java/com/kt/event/content/biz/service/StableDiffusionImageGenerator.java
+++ b/content-service/src/main/java/com/kt/event/content/biz/service/StableDiffusionImageGenerator.java
@ -52,6 +52,9 @@ public class StableDiffusionImageGenerator implements GenerateImagesUseCase {
    @Value("${replicate.model.version:stability-ai/sdxl:39ed52f2a78e934b3ba6e2a89f5b1c712de7dfea535525255b1aa35c5565e08b}")
    private String modelVersion;

+    @Value("${replicate.mock.enabled:false}")
+    private boolean mockEnabled;
+
    public StableDiffusionImageGenerator(
            ReplicateApiClient replicateClient,
            CDNUploader cdnUploader,
@ -188,6 +191,14 @@ public class StableDiffusionImageGenerator implements GenerateImagesUseCase {
     */
    private String generateImage(String prompt, Platform platform) {
        try {
+            // Mock 모드일 경우 Mock 데이터 반환
+//            if (mockEnabled) {
+//                log.info("[MOCK] 이미지 생성 요청 (실제 API 호출 없음): prompt={}, platform={}", prompt, platform);
+//                String mockUrl = generateMockImageUrl(platform);
+//                log.info("[MOCK] 이미지 생성 완료: url={}", mockUrl);
+//                return mockUrl;
+//            }
+
            // 플랫폼별 이미지 크기 설정 (Platform enum에서 가져옴)
            int width = platform.getWidth();
            int height = platform.getHeight();
@ -236,6 +247,23 @@ public class StableDiffusionImageGenerator implements GenerateImagesUseCase {
        }
    }

+    /**
+     * Mock 이미지 URL 생성 (dev 환경용)
+     *
+     * @param platform 플랫폼 (이미지 크기 결정)
+     * @return Mock 이미지 URL
+     */
+    private String generateMockImageUrl(Platform platform) {
+        // 플랫폼별 크기에 맞는 placeholder 이미지 URL 생성
+        int width = platform.getWidth();
+        int height = platform.getHeight();
+
+        // placeholder.com을 사용한 Mock 이미지 URL
+        String mockId = UUID.randomUUID().toString().substring(0, 8);
+        return String.format("https://via.placeholder.com/%dx%d/FF6B6B/FFFFFF?text=%s+Event+%s",
+                width, height, platform.name(), mockId);
+    }
+
    /**
     * Replicate API 예측 완료 대기 (폴링)
     *
--- a/content-service/src/main/resources/application.yml
+++ b/content-service/src/main/resources/application.yml
@ -37,10 +37,16 @@ replicate:
    token: ${REPLICATE_API_TOKEN:}
  model:
    version: ${REPLICATE_MODEL_VERSION:stability-ai/sdxl:39ed52f2a78e934b3ba6e2a89f5b1c712de7dfea535525255b1aa35c5565e08b}
+  mock:
+    enabled: ${REPLICATE_MOCK_ENABLED:true}

 # CORS Configuration
 cors:
-  allowed-origins: ${CORS_ALLOWED_ORIGINS:http://localhost:*}
+  allowed-origins: ${CORS_ALLOWED_ORIGINS:http://localhost:8081,http://localhost:8082,http://localhost:8083,http://localhost:8084,http://kt-event-marketing.20.214.196.128.nip.io}
+  allowed-methods: ${CORS_ALLOWED_METHODS:GET,POST,PUT,DELETE,OPTIONS,PATCH}
+  allowed-headers: ${CORS_ALLOWED_HEADERS:*}
+  allow-credentials: ${CORS_ALLOW_CREDENTIALS:true}
+  max-age: ${CORS_MAX_AGE:3600}

 # Actuator
 management:
--- a/deployment/container/build-image.md
+++ b/deployment/container/build-image.md
@ -1,68 +1,57 @@
-# 백엔드 컨테이너 이미지 작성 결과
+# 백엔드 컨테이너 이미지 빌드 결과

-## 작업 개요
- **작업일시**: 2025-10-29
- **작성자**: DevOps Engineer (송근정 "데브옵스 마스터")
- **대상 서비스**: 6개 백엔드 마이크로서비스
+## 개요
+KT 이벤트 마케팅 서비스의 백엔드 마이크로서비스들에 대한 컨테이너 이미지를 생성하였습니다.

-## 1. 서비스 확인
+## 작업 일시
+- 날짜: 2025-10-29
+- 빌드 환경: Windows (MINGW64_NT-10.0-19045)

-### settings.gradle 분석
-```gradle
+## 서비스 목록 확인
+
+settings.gradle에서 확인한 서비스 목록:
+```
 rootProject.name = 'kt-event-marketing'

-// Common module
 include 'common'
-
-// Microservices
 include 'user-service'
 include 'event-service'
 include 'ai-service'
-include 'content-service'
 include 'distribution-service'
 include 'participation-service'
 include 'analytics-service'
 ```

-### 빌드 가능한 서비스 (6개)
-Main Application 클래스가 존재하는 서비스:
-1. **user-service** - `UserServiceApplication.java`
-2. **event-service** - `EventServiceApplication.java`
-3. **ai-service** - `AiServiceApplication.java`
-4. **content-service** - `ContentApplication.java`
-5. **participation-service** - `ParticipationServiceApplication.java`
-6. **analytics-service** - `AnalyticsServiceApplication.java`
+**빌드 대상 서비스 (6개):**
+- user-service (Java/Spring Boot)
+- event-service (Java/Spring Boot)
+- ai-service (Java/Spring Boot)
+- distribution-service (Java/Spring Boot)
+- participation-service (Java/Spring Boot)
+- analytics-service (Java/Spring Boot)

-### 제외된 서비스
- **distribution-service**: 소스 코드 미구현 상태 (src/main/java 디렉토리 없음)
+**제외 대상:**
+- common: 공통 라이브러리 모듈 (독립 실행 서비스 아님)
+- content-service: Python 기반 서비스 (별도 빌드 필요)

-## 2. bootJar 설정
+## bootJar 설정 확인

-각 서비스의 `build.gradle`에 bootJar 설정 추가/수정:
+모든 Java 서비스의 build.gradle에 bootJar 설정이 올바르게 구성되어 있음을 확인:

-### 설정 추가된 서비스 (5개)
-```gradle
-bootJar {
-    archiveFileName = '{service-name}.jar'
-}
-```
+| 서비스명 | JAR 파일명 | 경로 |
+|---------|-----------|------|
+| user-service | user-service.jar | user-service/build/libs/user-service.jar |
+| event-service | event-service.jar | event-service/build/libs/event-service.jar |
+| ai-service | ai-service.jar | ai-service/build/libs/ai-service.jar |
+| distribution-service | distribution-service.jar | distribution-service/build/libs/distribution-service.jar |
+| participation-service | participation-service.jar | participation-service/build/libs/participation-service.jar |
+| analytics-service | analytics-service.jar | analytics-service/build/libs/analytics-service.jar |

- user-service/build.gradle
- ai-service/build.gradle
- distribution-service/build.gradle (향후 구현 대비)
- participation-service/build.gradle
- analytics-service/build.gradle
+## Dockerfile 생성

-### 기존 설정 확인된 서비스 (2개)
- event-service/build.gradle ✅
- content-service/build.gradle ✅
+**파일 위치:** `deployment/container/Dockerfile-backend`

-## 3. Dockerfile 생성
-
-### 파일 경로
-`deployment/container/Dockerfile-backend`
-
-### Dockerfile 내용
+**Dockerfile 구성:**
 ```dockerfile
 # Build stage
 FROM openjdk:23-oraclelinux8 AS builder
@ -91,58 +80,34 @@ ENTRYPOINT [ "sh", "-c" ]
 CMD ["java ${JAVA_OPTS} -jar app.jar"]
 ```

-### Dockerfile 특징
- **Multi-stage build**: 빌드와 실행 스테이지 분리
- **Non-root user**: 보안을 위한 k8s 사용자 실행
- **플랫폼**: linux/amd64 (K8s 클러스터 호환)
- **Java 버전**: OpenJDK 23
+**주요 특징:**
+- Multi-stage 빌드: 빌드 이미지와 런타임 이미지 분리
+- Base Image: openjdk:23-slim (경량화)
+- 보안: 비root 사용자(k8s)로 실행
+- 플랫폼: linux/amd64

-## 4. JAR 파일 빌드
+## Gradle 빌드 실행

-### 빌드 명령어
+**실행 명령:**
 ```bash
-./gradlew user-service:bootJar ai-service:bootJar event-service:bootJar \
-  content-service:bootJar participation-service:bootJar analytics-service:bootJar
+./gradlew clean build -x test
 ```

-### 빌드 결과
-```
-BUILD SUCCESSFUL in 27s
-33 actionable tasks: 15 executed, 18 up-to-date
-```
+**빌드 결과:**
+- 상태: ✅ BUILD SUCCESSFUL
+- 소요 시간: 33초
+- 실행된 태스크: 56개

-### 생성된 JAR 파일
-```bash
-$ ls -lh */build/libs/*.jar
+## 컨테이너 이미지 빌드

-rw-r--r-- 1 KTDS 197121 94M 10월 29 09:49 ai-service/build/libs/ai-service.jar
-rw-r--r-- 1 KTDS 197121 95M 10월 29 09:48 analytics-service/build/libs/analytics-service.jar
-rw-r--r-- 1 KTDS 197121 78M 10월 29 09:49 content-service/build/libs/content-service.jar
-rw-r--r-- 1 KTDS 197121 94M 10월 29 09:49 event-service/build/libs/event-service.jar
-rw-r--r-- 1 KTDS 197121 85M 10월 29 09:49 participation-service/build/libs/participation-service.jar
-rw-r--r-- 1 KTDS 197121 96M 10월 29 09:49 user-service/build/libs/user-service.jar
-```
+### 병렬 빌드 전략
+서브 에이전트를 활용하여 6개 서비스를 동시에 빌드하여 시간 단축

-## 5. Docker 이미지 빌드
+### 1. user-service

-### 사전 준비사항
-⚠️ **Docker Desktop이 실행 중이어야 합니다**
-
-Docker Desktop 시작 확인:
-```bash
-# Docker 상태 확인
-docker version
-docker ps
-
-# Docker Desktop이 정상 실행되면 위 명령들이 정상 동작합니다
-```
-
-### 빌드 명령어
-
-#### 5.1 user-service
+**빌드 명령:**
 ```bash
 DOCKER_FILE=deployment/container/Dockerfile-backend
-
 docker build \
  --platform linux/amd64 \
  --build-arg BUILD_LIB_DIR="user-service/build/libs" \
@ -151,22 +116,17 @@ docker build \
  -t user-service:latest .
 ```

-#### 5.2 ai-service
+**결과:**
+- 상태: ✅ SUCCESS
+- 이미지 ID: fb07547604be
+- 이미지 크기: 1.09GB
+- Image SHA: sha256:fb07547604bee7e8ff69e56e8423299b7dec277e80d865ee5013ddd876a0b4c6
+
+### 2. event-service
+
+**빌드 명령:**
 ```bash
 DOCKER_FILE=deployment/container/Dockerfile-backend
-
-docker build \
-  --platform linux/amd64 \
-  --build-arg BUILD_LIB_DIR="ai-service/build/libs" \
-  --build-arg ARTIFACTORY_FILE="ai-service.jar" \
-  -f ${DOCKER_FILE} \
-  -t ai-service:latest .
-```
-
-#### 5.3 event-service
-```bash
-DOCKER_FILE=deployment/container/Dockerfile-backend
-
 docker build \
  --platform linux/amd64 \
  --build-arg BUILD_LIB_DIR="event-service/build/libs" \
@ -175,22 +135,56 @@ docker build \
  -t event-service:latest .
 ```

-#### 5.4 content-service
+**결과:**
+- 상태: ✅ SUCCESS
+- 이미지 ID: 191a9882a628
+- 이미지 크기: 1.08GB
+- 빌드 시간: ~20초
+
+### 3. ai-service
+
+**빌드 명령:**
 ```bash
 DOCKER_FILE=deployment/container/Dockerfile-backend
-
 docker build \
  --platform linux/amd64 \
-  --build-arg BUILD_LIB_DIR="content-service/build/libs" \
-  --build-arg ARTIFACTORY_FILE="content-service.jar" \
+  --build-arg BUILD_LIB_DIR="ai-service/build/libs" \
+  --build-arg ARTIFACTORY_FILE="ai-service.jar" \
  -f ${DOCKER_FILE} \
-  -t content-service:latest .
+  -t ai-service:latest .
 ```

-#### 5.5 participation-service
+**결과:**
+- 상태: ✅ SUCCESS
+- 이미지 ID: 498feb888dc5
+- 이미지 크기: 1.08GB
+- Image SHA: sha256:498feb888dc58a98715841c4e50f191bc8434eccd12baefa79e82b0e44a5bc40
+
+### 4. distribution-service
+
+**빌드 명령:**
 ```bash
 DOCKER_FILE=deployment/container/Dockerfile-backend
+docker build \
+  --platform linux/amd64 \
+  --build-arg BUILD_LIB_DIR="distribution-service/build/libs" \
+  --build-arg ARTIFACTORY_FILE="distribution-service.jar" \
+  -f ${DOCKER_FILE} \
+  -t distribution-service:latest .
+```

+**결과:**
+- 상태: ✅ SUCCESS
+- 이미지 ID: e0ad31c51b63
+- 이미지 크기: 1.08GB
+- Image SHA: sha256:e0ad31c51b63b44d67f017cca8a729ae9cbb5e9e9503feddb308c09f19b70fba
+- 빌드 시간: ~60초
+
+### 5. participation-service
+
+**빌드 명령:**
+```bash
+DOCKER_FILE=deployment/container/Dockerfile-backend
 docker build \
  --platform linux/amd64 \
  --build-arg BUILD_LIB_DIR="participation-service/build/libs" \
@ -199,10 +193,18 @@ docker build \
  -t participation-service:latest .
 ```

-#### 5.6 analytics-service
+**결과:**
+- 상태: ✅ SUCCESS
+- 이미지 ID: 9bd60358659b
+- 이미지 크기: 1.04GB
+- Image SHA: sha256:9bd60358659b528190edcab699152b5126dc906070e05d355310303ac292f02b
+- 빌드 시간: ~37초
+
+### 6. analytics-service
+
+**빌드 명령:**
 ```bash
 DOCKER_FILE=deployment/container/Dockerfile-backend
-
 docker build \
  --platform linux/amd64 \
  --build-arg BUILD_LIB_DIR="analytics-service/build/libs" \
@ -211,186 +213,55 @@ docker build \
  -t analytics-service:latest .
 ```

-### 빌드 스크립트 (일괄 실행)
+**결과:**
+- 상태: ✅ SUCCESS
+- 이미지 ID: 33b53299ec16
+- 이미지 크기: 1.08GB
+- Image SHA: sha256:33b53299ec16e0021a9adca4fb32535708021073df03c30b8a0ea335348547de
+
+## 생성된 이미지 확인
+
+**확인 명령:**
 ```bash
-#!/bin/bash
-# build-all-images.sh
-
-DOCKER_FILE=deployment/container/Dockerfile-backend
-
-services=(
-  "user-service"
-  "ai-service"
-  "event-service"
-  "content-service"
-  "participation-service"
-  "analytics-service"
-)
-
-for service in "${services[@]}"; do
-  echo "Building ${service}..."
-  docker build \
-    --platform linux/amd64 \
-    --build-arg BUILD_LIB_DIR="${service}/build/libs" \
-    --build-arg ARTIFACTORY_FILE="${service}.jar" \
-    -f ${DOCKER_FILE} \
-    -t ${service}:latest .
-
-  if [ $? -eq 0 ]; then
-    echo "✅ ${service} build successful"
-  else
-    echo "❌ ${service} build failed"
-    exit 1
-  fi
-done
-
-echo "🎉 All images built successfully!"
+docker images | grep -E "(user-service|event-service|ai-service|distribution-service|participation-service|analytics-service)" | grep latest
 ```

-## 6. 이미지 확인
-
-### 생성된 이미지 확인 명령어
-```bash
-# 모든 서비스 이미지 확인
-docker images | grep -E "(user-service|ai-service|event-service|content-service|participation-service|analytics-service)"
-
-# 개별 서비스 확인
-docker images user-service:latest
-docker images ai-service:latest
-docker images event-service:latest
-docker images content-service:latest
-docker images participation-service:latest
-docker images analytics-service:latest
+**확인 결과:**
+```
+event-service                                                            latest    191a9882a628   39 seconds ago   1.08GB
+ai-service                                                               latest    498feb888dc5   46 seconds ago   1.08GB
+analytics-service                                                        latest    33b53299ec16   46 seconds ago   1.08GB
+user-service                                                             latest    fb07547604be   47 seconds ago   1.09GB
+participation-service                                                    latest    9bd60358659b   48 seconds ago   1.04GB
+distribution-service                                                     latest    e0ad31c51b63   48 seconds ago   1.08GB
 ```

-### 빌드 결과 ✅
-```
-REPOSITORY              TAG       IMAGE ID       CREATED              SIZE
-user-service           latest    91c511ef86bd   About a minute ago   1.09GB
-ai-service             latest    9477022fa493   About a minute ago   1.08GB
-event-service          latest    add81de69536   About a minute ago   1.08GB
-content-service        latest    aa9cc16ad041   About a minute ago   1.01GB
-participation-service  latest    9b044a3854dd   About a minute ago   1.04GB
-analytics-service      latest    ac569de42545   About a minute ago   1.08GB
-```
+## 빌드 결과 요약

-**빌드 일시**: 2025-10-29 09:50 KST
-**빌드 소요 시간**: 약 13초 (병렬 빌드)
-**총 이미지 크기**: 6.48GB
+| 서비스명 | 이미지 태그 | 이미지 ID | 크기 | 상태 |
+|---------|-----------|----------|------|------|
+| user-service | user-service:latest | fb07547604be | 1.09GB | ✅ |
+| event-service | event-service:latest | 191a9882a628 | 1.08GB | ✅ |
+| ai-service | ai-service:latest | 498feb888dc5 | 1.08GB | ✅ |
+| distribution-service | distribution-service:latest | e0ad31c51b63 | 1.08GB | ✅ |
+| participation-service | participation-service:latest | 9bd60358659b | 1.04GB | ✅ |
+| analytics-service | analytics-service:latest | 33b53299ec16 | 1.08GB | ✅ |

-## 7. 이미지 테스트
+**총 6개 서비스 이미지 빌드 성공**

-### 로컬 실행 테스트 (예시: user-service)
-```bash
-# 컨테이너 실행
-docker run -d \
-  --name user-service-test \
-  -p 8080:8080 \
-  -e SPRING_PROFILES_ACTIVE=dev \
-  user-service:latest
+## 다음 단계

-# 로그 확인
-docker logs -f user-service-test
+생성된 이미지를 사용하여 다음 작업을 진행할 수 있습니다:

-# 헬스체크
-curl http://localhost:8080/actuator/health
+1. **로컬 테스트:** Docker Compose 또는 개별 컨테이너 실행
+2. **ACR 푸시:** Azure Container Registry에 이미지 업로드
+3. **AKS 배포:** Kubernetes 클러스터에 배포
+4. **CI/CD 통합:** GitHub Actions 또는 Jenkins 파이프라인 연동

-# 정리
-docker stop user-service-test
-docker rm user-service-test
-```
+## 참고사항

-## 8. 다음 단계
-
-### 8.1 컨테이너 레지스트리 푸시
-```bash
-# Docker Hub 예시
-docker tag user-service:latest <your-registry>/user-service:latest
-docker push <your-registry>/user-service:latest
-
-# Azure Container Registry 예시
-docker tag user-service:latest <acr-name>.azurecr.io/user-service:latest
-docker push <acr-name>.azurecr.io/user-service:latest
-```
-
-### 8.2 Kubernetes 배포
- Kubernetes Deployment 매니페스트 작성
- Service 리소스 정의
- ConfigMap/Secret 설정
- Ingress 구성
-
-### 8.3 CI/CD 파이프라인 구성
- GitHub Actions 또는 Jenkins 파이프라인 작성
- 자동 빌드 및 배포 설정
- 이미지 태깅 전략 수립 (semantic versioning)
-
-## 9. 트러블슈팅
-
-### Issue 1: Docker Desktop 미실행
-**증상**:
-```
-ERROR: error during connect: open //./pipe/dockerDesktopLinuxEngine:
-The system cannot find the file specified.
-```
-
-**해결**:
-1. Docker Desktop 애플리케이션 시작
-2. 시스템 트레이의 Docker 아이콘이 안정화될 때까지 대기
-3. `docker ps` 명령으로 정상 동작 확인
-
-### Issue 2: JAR 파일 없음
-**증상**:
-```
-COPY failed: file not found in build context
-```
-
-**해결**:
-```bash
-# JAR 파일 재빌드
-./gradlew {service-name}:clean {service-name}:bootJar
-
-# 생성 확인
-ls -l {service-name}/build/libs/{service-name}.jar
-```
-
-### Issue 3: 플랫폼 불일치
-**증상**: K8s 클러스터에서 실행 안됨
-
-**해결**: `--platform linux/amd64` 옵션 사용 (이미 적용됨)
-
-## 10. 요약
-
-### ✅ 완료된 작업
-1. ✅ 6개 서비스의 bootJar 설정 완료
-2. ✅ Dockerfile-backend 생성 완료
-3. ✅ 6개 서비스 JAR 파일 빌드 완료 (총 542MB)
-4. ✅ 6개 서비스 Docker 이미지 빌드 완료 (총 6.48GB)
-
-### 📊 최종 서비스 현황
-| 서비스 | JAR 빌드 | Docker 이미지 | 이미지 크기 | Image ID | 상태 |
-|--------|---------|--------------|-----------|----------|------|
-| user-service | ✅ 96MB | ✅ | 1.09GB | 91c511ef86bd | ✅ Ready |
-| ai-service | ✅ 94MB | ✅ | 1.08GB | 9477022fa493 | ✅ Ready |
-| event-service | ✅ 94MB | ✅ | 1.08GB | add81de69536 | ✅ Ready |
-| content-service | ✅ 78MB | ✅ | 1.01GB | aa9cc16ad041 | ✅ Ready |
-| participation-service | ✅ 85MB | ✅ | 1.04GB | 9b044a3854dd | ✅ Ready |
-| analytics-service | ✅ 95MB | ✅ | 1.08GB | ac569de42545 | ✅ Ready |
-| distribution-service | ❌ | ❌ | - | - | 소스 미구현 |
-
-### 🎯 빌드 성능 메트릭
- **JAR 빌드 시간**: 27초
- **Docker 이미지 빌드**: 병렬 실행으로 약 13초
- **총 소요 시간**: 약 40초
- **빌드 성공률**: 100% (6/6 서비스)
-
-### 🚀 다음 단계 권장사항
-1. **컨테이너 레지스트리 푸시** (예: Azure ACR, Docker Hub)
-2. **Kubernetes 배포 매니페스트 작성**
-3. **CI/CD 파이프라인 구성** (GitHub Actions 또는 Jenkins)
-4. **모니터링 및 로깅 설정**
-
---
-
-**작성일**: 2025-10-29 09:50 KST
-**작성자**: DevOps Engineer (송근정 "데브옵스 마스터")
-**빌드 완료**: ✅ 모든 서비스 이미지 빌드 성공
+- 모든 이미지는 linux/amd64 플랫폼용으로 빌드됨
+- 보안을 위해 비root 사용자(k8s)로 실행 구성
+- Multi-stage 빌드로 이미지 크기 최적화
+- Java 23 (OpenJDK) 기반 런타임 사용
+- content-service(Python)는 별도의 Dockerfile로 빌드 필요
--- a/deployment/k8s/common/cm-common.yaml
+++ b/deployment/k8s/common/cm-common.yaml
@ -20,7 +20,7 @@ data:
  EXCLUDE_REDIS: ""

  # CORS Configuration
-  CORS_ALLOWED_ORIGINS: "http://localhost:8081,http://localhost:8082,http://localhost:8083,http://localhost:8084,http://kt-event-marketing.20.214.196.128.nip.io"
+  CORS_ALLOWED_ORIGINS: "http://localhost:8081,http://localhost:8082,http://localhost:8083,http://localhost:8084,http://kt-event-marketing.20.214.196.128.nip.io,http://kt-event-marketing-api.20.214.196.128.nip.io,http://*.20.214.196.128.nip.io,https://kt-event-marketing.20.214.196.128.nip.io,https://kt-event-marketing-api.20.214.196.128.nip.io,https://*.20.214.196.128.nip.io"
  CORS_ALLOWED_METHODS: "GET,POST,PUT,DELETE,OPTIONS,PATCH"
  CORS_ALLOWED_HEADERS: "*"
  CORS_ALLOW_CREDENTIALS: "true"
--- a/deployment/k8s/distribution-service/deployment.yaml
+++ b/deployment/k8s/distribution-service/deployment.yaml
@ -42,21 +42,21 @@ spec:
              memory: "1024Mi"
          startupProbe:
            httpGet:
-              path: /distribution/actuator/health
+              path: /api/v1/distribution/actuator/health
              port: 8085
            initialDelaySeconds: 30
            periodSeconds: 10
            failureThreshold: 30
          readinessProbe:
            httpGet:
-              path: /distribution/actuator/health/readiness
+              path: /api/v1/distribution/actuator/health/readiness
              port: 8085
            initialDelaySeconds: 10
            periodSeconds: 5
            failureThreshold: 3
          livenessProbe:
            httpGet:
-              path: /distribution/actuator/health/liveness
+              path: /api/v1/distribution/actuator/health/liveness
              port: 8085
            initialDelaySeconds: 30
            periodSeconds: 10
--- a/develop/database/migration/alter_event_id_to_varchar.sql
+++ b/develop/database/migration/alter_event_id_to_varchar.sql
@ -0,0 +1,234 @@
+-- ====================================================================================================
+-- Event ID 타입 변경 DDL (UUID → VARCHAR(50)) - PostgreSQL
+-- ====================================================================================================
+-- 작성일: 2025-10-29
+-- 작성자: Backend Development Team
+-- 설명: Event 엔티티의 eventId가 String 타입으로 변경됨에 따라 관련 테이블들의 event_id 컬럼 타입을 UUID에서 VARCHAR(50)으로 변경합니다.
+-- 영향 범위:
+--   - events 테이블 (Primary Key)
+--   - event_channels 테이블 (Foreign Key)
+--   - generated_images 테이블 (Foreign Key)
+--   - ai_recommendations 테이블 (Foreign Key)
+--   - jobs 테이블 (Foreign Key)
+-- ====================================================================================================
+
+-- 0. 현재 상태 확인 (실행 전 확인용)
+-- ====================================================================================================
+-- 각 테이블의 event_id 컬럼 타입 확인
+-- SELECT table_name, column_name, data_type
+-- FROM information_schema.columns
+-- WHERE column_name = 'event_id'
+-- AND table_schema = 'public'
+-- ORDER BY table_name;
+
+-- event_id 관련 모든 외래키 제약조건 확인
+-- SELECT
+--     tc.constraint_name,
+--     tc.table_name,
+--     kcu.column_name,
+--     ccu.table_name AS foreign_table_name,
+--     ccu.column_name AS foreign_column_name
+-- FROM information_schema.table_constraints AS tc
+-- JOIN information_schema.key_column_usage AS kcu
+--     ON tc.constraint_name = kcu.constraint_name
+--     AND tc.table_schema = kcu.table_schema
+-- JOIN information_schema.constraint_column_usage AS ccu
+--     ON ccu.constraint_name = tc.constraint_name
+--     AND ccu.table_schema = tc.table_schema
+-- WHERE tc.constraint_type = 'FOREIGN KEY'
+-- AND kcu.column_name = 'event_id'
+-- AND tc.table_schema = 'public';
+
+-- 1. 외래키 제약조건 전체 제거
+-- ====================================================================================================
+-- JPA가 자동 생성한 제약조건 이름도 포함하여 모두 제거
+
+-- event_channels 테이블의 모든 event_id 관련 외래키 제거
+DO $$
+DECLARE
+    constraint_name TEXT;
+BEGIN
+    FOR constraint_name IN
+        SELECT tc.constraint_name
+        FROM information_schema.table_constraints AS tc
+        JOIN information_schema.key_column_usage AS kcu
+            ON tc.constraint_name = kcu.constraint_name
+        WHERE tc.constraint_type = 'FOREIGN KEY'
+        AND tc.table_name = 'event_channels'
+        AND kcu.column_name = 'event_id'
+        AND tc.table_schema = 'public'
+    LOOP
+        EXECUTE 'ALTER TABLE event_channels DROP CONSTRAINT IF EXISTS ' || constraint_name;
+    END LOOP;
+END $$;
+
+-- generated_images 테이블의 모든 event_id 관련 외래키 제거
+DO $$
+DECLARE
+    constraint_name TEXT;
+BEGIN
+    FOR constraint_name IN
+        SELECT tc.constraint_name
+        FROM information_schema.table_constraints AS tc
+        JOIN information_schema.key_column_usage AS kcu
+            ON tc.constraint_name = kcu.constraint_name
+        WHERE tc.constraint_type = 'FOREIGN KEY'
+        AND tc.table_name = 'generated_images'
+        AND kcu.column_name = 'event_id'
+        AND tc.table_schema = 'public'
+    LOOP
+        EXECUTE 'ALTER TABLE generated_images DROP CONSTRAINT IF EXISTS ' || constraint_name;
+    END LOOP;
+END $$;
+
+-- ai_recommendations 테이블의 모든 event_id 관련 외래키 제거
+DO $$
+DECLARE
+    constraint_name TEXT;
+BEGIN
+    FOR constraint_name IN
+        SELECT tc.constraint_name
+        FROM information_schema.table_constraints AS tc
+        JOIN information_schema.key_column_usage AS kcu
+            ON tc.constraint_name = kcu.constraint_name
+        WHERE tc.constraint_type = 'FOREIGN KEY'
+        AND tc.table_name = 'ai_recommendations'
+        AND kcu.column_name = 'event_id'
+        AND tc.table_schema = 'public'
+    LOOP
+        EXECUTE 'ALTER TABLE ai_recommendations DROP CONSTRAINT IF EXISTS ' || constraint_name;
+    END LOOP;
+END $$;
+
+-- jobs 테이블의 모든 event_id 관련 외래키 제거
+DO $$
+DECLARE
+    constraint_name TEXT;
+BEGIN
+    FOR constraint_name IN
+        SELECT tc.constraint_name
+        FROM information_schema.table_constraints AS tc
+        JOIN information_schema.key_column_usage AS kcu
+            ON tc.constraint_name = kcu.constraint_name
+        WHERE tc.constraint_type = 'FOREIGN KEY'
+        AND tc.table_name = 'jobs'
+        AND kcu.column_name = 'event_id'
+        AND tc.table_schema = 'public'
+    LOOP
+        EXECUTE 'ALTER TABLE jobs DROP CONSTRAINT IF EXISTS ' || constraint_name;
+    END LOOP;
+END $$;
+
+
+-- 2. 컬럼 타입 변경 (UUID/기타 → VARCHAR)
+-- ====================================================================================================
+-- 현재 타입에 관계없이 VARCHAR(50)으로 변환
+-- UUID, BIGINT 등 모든 타입을 텍스트로 변환
+
+-- events 테이블의 event_id 컬럼 타입 변경 (Primary Key)
+DO $$
+BEGIN
+    ALTER TABLE events ALTER COLUMN event_id TYPE VARCHAR(50) USING event_id::text;
+EXCEPTION
+    WHEN OTHERS THEN
+        RAISE NOTICE 'events.event_id 변환 중 오류: %', SQLERRM;
+END $$;
+
+-- event_channels 테이블의 event_id 컬럼 타입 변경
+DO $$
+BEGIN
+    ALTER TABLE event_channels ALTER COLUMN event_id TYPE VARCHAR(50) USING event_id::text;
+EXCEPTION
+    WHEN OTHERS THEN
+        RAISE NOTICE 'event_channels.event_id 변환 중 오류: %', SQLERRM;
+END $$;
+
+-- generated_images 테이블의 event_id 컬럼 타입 변경
+DO $$
+BEGIN
+    ALTER TABLE generated_images ALTER COLUMN event_id TYPE VARCHAR(50) USING event_id::text;
+EXCEPTION
+    WHEN OTHERS THEN
+        RAISE NOTICE 'generated_images.event_id 변환 중 오류: %', SQLERRM;
+END $$;
+
+-- ai_recommendations 테이블의 event_id 컬럼 타입 변경
+DO $$
+BEGIN
+    ALTER TABLE ai_recommendations ALTER COLUMN event_id TYPE VARCHAR(50) USING event_id::text;
+EXCEPTION
+    WHEN OTHERS THEN
+        RAISE NOTICE 'ai_recommendations.event_id 변환 중 오류: %', SQLERRM;
+END $$;
+
+-- jobs 테이블의 event_id 컬럼 타입 변경 (NULL 허용)
+DO $$
+BEGIN
+    ALTER TABLE jobs ALTER COLUMN event_id TYPE VARCHAR(50) USING event_id::text;
+EXCEPTION
+    WHEN OTHERS THEN
+        RAISE NOTICE 'jobs.event_id 변환 중 오류: %', SQLERRM;
+END $$;
+
+
+-- 3. 외래키 제약조건 재생성
+-- ====================================================================================================
+
+-- event_channels 테이블의 외래키 재생성
+ALTER TABLE event_channels
+ADD CONSTRAINT fk_event_channels_event
+FOREIGN KEY (event_id) REFERENCES events(event_id)
+ON DELETE CASCADE;
+
+-- generated_images 테이블의 외래키 재생성
+ALTER TABLE generated_images
+ADD CONSTRAINT fk_generated_images_event
+FOREIGN KEY (event_id) REFERENCES events(event_id)
+ON DELETE CASCADE;
+
+-- ai_recommendations 테이블의 외래키 재생성
+ALTER TABLE ai_recommendations
+ADD CONSTRAINT fk_ai_recommendations_event
+FOREIGN KEY (event_id) REFERENCES events(event_id)
+ON DELETE CASCADE;
+
+-- jobs 테이블의 외래키 재생성
+ALTER TABLE jobs
+ADD CONSTRAINT fk_jobs_event
+FOREIGN KEY (event_id) REFERENCES events(event_id)
+ON DELETE SET NULL;
+
+
+-- 4. 인덱스 확인 (옵션)
+-- ====================================================================================================
+-- 기존 인덱스들이 자동으로 유지되는지 확인
+-- \d events
+-- \d event_channels
+-- \d generated_images
+-- \d ai_recommendations
+-- \d jobs
+
+
+-- ====================================================================================================
+-- 롤백 스크립트 (필요시 사용)
+-- ====================================================================================================
+/*
+-- 1. 외래키 제약조건 제거
+ALTER TABLE event_channels DROP CONSTRAINT IF EXISTS fk_event_channels_event;
+ALTER TABLE generated_images DROP CONSTRAINT IF EXISTS fk_generated_images_event;
+ALTER TABLE ai_recommendations DROP CONSTRAINT IF EXISTS fk_ai_recommendations_event;
+ALTER TABLE jobs DROP CONSTRAINT IF EXISTS fk_jobs_event;
+
+-- 2. 컬럼 타입 원복 (VARCHAR → UUID)
+ALTER TABLE events ALTER COLUMN event_id TYPE UUID USING event_id::UUID;
+ALTER TABLE event_channels ALTER COLUMN event_id TYPE UUID USING event_id::UUID;
+ALTER TABLE generated_images ALTER COLUMN event_id TYPE UUID USING event_id::UUID;
+ALTER TABLE ai_recommendations ALTER COLUMN event_id TYPE UUID USING event_id::UUID;
+ALTER TABLE jobs ALTER COLUMN event_id TYPE UUID USING event_id::UUID;
+
+-- 4. 외래키 제약조건 재생성
+ALTER TABLE event_channels ADD CONSTRAINT fk_event_channels_event FOREIGN KEY (event_id) REFERENCES events(event_id) ON DELETE CASCADE;
+ALTER TABLE generated_images ADD CONSTRAINT fk_generated_images_event FOREIGN KEY (event_id) REFERENCES events(event_id) ON DELETE CASCADE;
+ALTER TABLE ai_recommendations ADD CONSTRAINT fk_ai_recommendations_event FOREIGN KEY (event_id) REFERENCES events(event_id) ON DELETE CASCADE;
+ALTER TABLE jobs ADD CONSTRAINT fk_jobs_event FOREIGN KEY (event_id) REFERENCES events(event_id) ON DELETE SET NULL;
+*/
--- a/develop/database/schema/create_event_tables.sql
+++ b/develop/database/schema/create_event_tables.sql
@ -0,0 +1,233 @@
+-- ====================================================================================================
+-- Event Service 테이블 생성 스크립트 - PostgreSQL
+-- ====================================================================================================
+-- 작성일: 2025-10-29
+-- 작성자: Backend Development Team
+-- 설명: Event 서비스의 모든 테이블을 생성합니다.
+-- 참고: FK(Foreign Key) 제약조건은 제외되어 있습니다.
+-- ====================================================================================================
+
+-- ====================================================================================================
+-- 1. events 테이블 - 이벤트 메인 테이블
+-- ====================================================================================================
+CREATE TABLE IF NOT EXISTS events (
+    event_id VARCHAR(50) PRIMARY KEY,
+    user_id VARCHAR(50) NOT NULL,
+    store_id VARCHAR(50) NOT NULL,
+    event_name VARCHAR(200),
+    description TEXT,
+    objective VARCHAR(100) NOT NULL,
+    start_date DATE,
+    end_date DATE,
+    status VARCHAR(20) NOT NULL DEFAULT 'DRAFT',
+    selected_image_id VARCHAR(50),
+    selected_image_url VARCHAR(500),
+    participants INTEGER DEFAULT 0,
+    target_participants INTEGER,
+    roi DOUBLE PRECISION DEFAULT 0.0,
+    created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+-- events 테이블 인덱스
+CREATE INDEX IF NOT EXISTS idx_events_user_id ON events(user_id);
+CREATE INDEX IF NOT EXISTS idx_events_store_id ON events(store_id);
+CREATE INDEX IF NOT EXISTS idx_events_status ON events(status);
+CREATE INDEX IF NOT EXISTS idx_events_created_at ON events(created_at);
+
+COMMENT ON TABLE events IS '이벤트 메인 테이블';
+COMMENT ON COLUMN events.event_id IS '이벤트 ID (Primary Key)';
+COMMENT ON COLUMN events.user_id IS '사용자 ID';
+COMMENT ON COLUMN events.store_id IS '상점 ID';
+COMMENT ON COLUMN events.event_name IS '이벤트명';
+COMMENT ON COLUMN events.description IS '이벤트 설명';
+COMMENT ON COLUMN events.objective IS '이벤트 목적';
+COMMENT ON COLUMN events.start_date IS '이벤트 시작일';
+COMMENT ON COLUMN events.end_date IS '이벤트 종료일';
+COMMENT ON COLUMN events.status IS '이벤트 상태 (DRAFT, PUBLISHED, ENDED)';
+COMMENT ON COLUMN events.selected_image_id IS '선택된 이미지 ID';
+COMMENT ON COLUMN events.selected_image_url IS '선택된 이미지 URL';
+COMMENT ON COLUMN events.participants IS '참여자 수';
+COMMENT ON COLUMN events.target_participants IS '목표 참여자 수';
+COMMENT ON COLUMN events.roi IS 'ROI (투자 대비 수익률)';
+COMMENT ON COLUMN events.created_at IS '생성일시';
+COMMENT ON COLUMN events.updated_at IS '수정일시';
+
+
+-- ====================================================================================================
+-- 2. event_channels 테이블 - 이벤트 배포 채널 (ElementCollection)
+-- ====================================================================================================
+CREATE TABLE IF NOT EXISTS event_channels (
+    event_id VARCHAR(50) NOT NULL,
+    channel VARCHAR(50)
+);
+
+-- event_channels 테이블 인덱스
+CREATE INDEX IF NOT EXISTS idx_event_channels_event_id ON event_channels(event_id);
+
+COMMENT ON TABLE event_channels IS '이벤트 배포 채널 테이블';
+COMMENT ON COLUMN event_channels.event_id IS '이벤트 ID';
+COMMENT ON COLUMN event_channels.channel IS '배포 채널명';
+
+
+-- ====================================================================================================
+-- 3. generated_images 테이블 - 생성된 이미지
+-- ====================================================================================================
+CREATE TABLE IF NOT EXISTS generated_images (
+    image_id VARCHAR(50) PRIMARY KEY,
+    event_id VARCHAR(50) NOT NULL,
+    image_url VARCHAR(500) NOT NULL,
+    style VARCHAR(50),
+    platform VARCHAR(50),
+    is_selected BOOLEAN NOT NULL DEFAULT false,
+    created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+-- generated_images 테이블 인덱스
+CREATE INDEX IF NOT EXISTS idx_generated_images_event_id ON generated_images(event_id);
+CREATE INDEX IF NOT EXISTS idx_generated_images_is_selected ON generated_images(is_selected);
+
+COMMENT ON TABLE generated_images IS 'AI가 생성한 이미지 테이블';
+COMMENT ON COLUMN generated_images.image_id IS '이미지 ID (Primary Key)';
+COMMENT ON COLUMN generated_images.event_id IS '이벤트 ID';
+COMMENT ON COLUMN generated_images.image_url IS '이미지 URL';
+COMMENT ON COLUMN generated_images.style IS '이미지 스타일';
+COMMENT ON COLUMN generated_images.platform IS '타겟 플랫폼';
+COMMENT ON COLUMN generated_images.is_selected IS '선택 여부';
+COMMENT ON COLUMN generated_images.created_at IS '생성일시';
+COMMENT ON COLUMN generated_images.updated_at IS '수정일시';
+
+
+-- ====================================================================================================
+-- 4. ai_recommendations 테이블 - AI 추천 기획안
+-- ====================================================================================================
+CREATE TABLE IF NOT EXISTS ai_recommendations (
+    recommendation_id VARCHAR(50) PRIMARY KEY,
+    event_id VARCHAR(50) NOT NULL,
+    event_name VARCHAR(200) NOT NULL,
+    description TEXT,
+    promotion_type VARCHAR(50),
+    target_audience VARCHAR(100),
+    is_selected BOOLEAN NOT NULL DEFAULT false,
+    created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+-- ai_recommendations 테이블 인덱스
+CREATE INDEX IF NOT EXISTS idx_ai_recommendations_event_id ON ai_recommendations(event_id);
+CREATE INDEX IF NOT EXISTS idx_ai_recommendations_is_selected ON ai_recommendations(is_selected);
+
+COMMENT ON TABLE ai_recommendations IS 'AI 추천 이벤트 기획안 테이블';
+COMMENT ON COLUMN ai_recommendations.recommendation_id IS '추천 ID (Primary Key)';
+COMMENT ON COLUMN ai_recommendations.event_id IS '이벤트 ID';
+COMMENT ON COLUMN ai_recommendations.event_name IS '추천 이벤트명';
+COMMENT ON COLUMN ai_recommendations.description IS '추천 설명';
+COMMENT ON COLUMN ai_recommendations.promotion_type IS '프로모션 유형';
+COMMENT ON COLUMN ai_recommendations.target_audience IS '타겟 고객층';
+COMMENT ON COLUMN ai_recommendations.is_selected IS '선택 여부';
+COMMENT ON COLUMN ai_recommendations.created_at IS '생성일시';
+COMMENT ON COLUMN ai_recommendations.updated_at IS '수정일시';
+
+
+-- ====================================================================================================
+-- 5. jobs 테이블 - 비동기 작업 관리
+-- ====================================================================================================
+CREATE TABLE IF NOT EXISTS jobs (
+    job_id VARCHAR(50) PRIMARY KEY,
+    event_id VARCHAR(50) NOT NULL,
+    job_type VARCHAR(30) NOT NULL,
+    status VARCHAR(20) NOT NULL DEFAULT 'PENDING',
+    progress INTEGER NOT NULL DEFAULT 0,
+    result_key VARCHAR(200),
+    error_message VARCHAR(500),
+    completed_at TIMESTAMP,
+    retry_count INTEGER NOT NULL DEFAULT 0,
+    max_retry_count INTEGER NOT NULL DEFAULT 3,
+    created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+-- jobs 테이블 인덱스
+CREATE INDEX IF NOT EXISTS idx_jobs_event_id ON jobs(event_id);
+CREATE INDEX IF NOT EXISTS idx_jobs_status ON jobs(status);
+CREATE INDEX IF NOT EXISTS idx_jobs_job_type ON jobs(job_type);
+CREATE INDEX IF NOT EXISTS idx_jobs_created_at ON jobs(created_at);
+
+COMMENT ON TABLE jobs IS '비동기 작업 관리 테이블';
+COMMENT ON COLUMN jobs.job_id IS '작업 ID (Primary Key)';
+COMMENT ON COLUMN jobs.event_id IS '이벤트 ID';
+COMMENT ON COLUMN jobs.job_type IS '작업 유형 (AI_RECOMMENDATION, IMAGE_GENERATION)';
+COMMENT ON COLUMN jobs.status IS '작업 상태 (PENDING, PROCESSING, COMPLETED, FAILED)';
+COMMENT ON COLUMN jobs.progress IS '진행률 (0-100)';
+COMMENT ON COLUMN jobs.result_key IS '결과 키';
+COMMENT ON COLUMN jobs.error_message IS '에러 메시지';
+COMMENT ON COLUMN jobs.completed_at IS '완료일시';
+COMMENT ON COLUMN jobs.retry_count IS '재시도 횟수';
+COMMENT ON COLUMN jobs.max_retry_count IS '최대 재시도 횟수';
+COMMENT ON COLUMN jobs.created_at IS '생성일시';
+COMMENT ON COLUMN jobs.updated_at IS '수정일시';
+
+
+-- ====================================================================================================
+-- 6. updated_at 자동 업데이트를 위한 트리거 함수 생성
+-- ====================================================================================================
+CREATE OR REPLACE FUNCTION update_updated_at_column()
+RETURNS TRIGGER AS $$
+BEGIN
+    NEW.updated_at = CURRENT_TIMESTAMP;
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+-- ====================================================================================================
+-- 7. 각 테이블에 updated_at 자동 업데이트 트리거 적용
+-- ====================================================================================================
+
+-- events 테이블 트리거
+DROP TRIGGER IF EXISTS update_events_updated_at ON events;
+CREATE TRIGGER update_events_updated_at
+    BEFORE UPDATE ON events
+    FOR EACH ROW
+    EXECUTE FUNCTION update_updated_at_column();
+
+-- generated_images 테이블 트리거
+DROP TRIGGER IF EXISTS update_generated_images_updated_at ON generated_images;
+CREATE TRIGGER update_generated_images_updated_at
+    BEFORE UPDATE ON generated_images
+    FOR EACH ROW
+    EXECUTE FUNCTION update_updated_at_column();
+
+-- ai_recommendations 테이블 트리거
+DROP TRIGGER IF EXISTS update_ai_recommendations_updated_at ON ai_recommendations;
+CREATE TRIGGER update_ai_recommendations_updated_at
+    BEFORE UPDATE ON ai_recommendations
+    FOR EACH ROW
+    EXECUTE FUNCTION update_updated_at_column();
+
+-- jobs 테이블 트리거
+DROP TRIGGER IF EXISTS update_jobs_updated_at ON jobs;
+CREATE TRIGGER update_jobs_updated_at
+    BEFORE UPDATE ON jobs
+    FOR EACH ROW
+    EXECUTE FUNCTION update_updated_at_column();
+
+
+-- ====================================================================================================
+-- 완료 메시지
+-- ====================================================================================================
+DO $$
+BEGIN
+    RAISE NOTICE '=================================================';
+    RAISE NOTICE 'Event Service 테이블 생성이 완료되었습니다.';
+    RAISE NOTICE '=================================================';
+    RAISE NOTICE '생성된 테이블:';
+    RAISE NOTICE '  1. events - 이벤트 메인 테이블';
+    RAISE NOTICE '  2. event_channels - 이벤트 배포 채널';
+    RAISE NOTICE '  3. generated_images - 생성된 이미지';
+    RAISE NOTICE '  4. ai_recommendations - AI 추천 기획안';
+    RAISE NOTICE '  5. jobs - 비동기 작업 관리';
+    RAISE NOTICE '=================================================';
+    RAISE NOTICE '참고: FK 제약조건은 생성되지 않았습니다.';
+    RAISE NOTICE '=================================================';
+END $$;
--- a/develop/dev/ai-service-workflow.md
+++ b/develop/dev/ai-service-workflow.md
@ -0,0 +1,390 @@
+# AI Service 전체 메서드 워크플로우
+
+## 1. AI 추천 생성 워크플로우 (Kafka 기반 비동기)
+
+```mermaid
+sequenceDiagram
+    participant ES as Event Service
+    participant Kafka as Kafka Topic
+    participant Consumer as AIJobConsumer
+    participant ARS as AIRecommendationService
+    participant JSS as JobStatusService
+    participant TAS as TrendAnalysisService
+    participant CS as CacheService
+    participant CAC as ClaudeApiClient
+    participant Claude as Claude API
+    participant Redis as Redis
+
+    %% 1. Event Service가 Kafka 메시지 발행
+    ES->>Kafka: Publish AIJobMessage<br/>(ai-event-generation-job topic)
+
+    %% 2. Kafka Consumer가 메시지 수신
+    Kafka->>Consumer: consume(AIJobMessage)
+    Note over Consumer: @KafkaListener<br/>groupId: ai-service-consumers
+
+    %% 3. AI 추천 생성 시작
+    Consumer->>ARS: generateRecommendations(message)
+    activate ARS
+
+    %% 4. Job 상태: PROCESSING (10%)
+    ARS->>JSS: updateJobStatus(jobId, PROCESSING, "트렌드 분석 중")
+    JSS->>CS: saveJobStatus(jobId, status)
+    CS->>Redis: SET ai:job:status:{jobId}
+
+    %% 5. 트렌드 분석
+    ARS->>ARS: analyzeTrend(message)
+    ARS->>CS: getTrend(industry, region)
+    CS->>Redis: GET ai:trend:{industry}:{region}
+
+    alt 캐시 HIT
+        Redis-->>CS: TrendAnalysis (cached)
+        CS-->>ARS: TrendAnalysis
+    else 캐시 MISS
+        ARS->>TAS: analyzeTrend(industry, region)
+        activate TAS
+
+        %% Circuit Breaker 적용
+        TAS->>TAS: circuitBreakerManager.executeWithCircuitBreaker()
+        TAS->>CAC: sendMessage(apiKey, version, request)
+        CAC->>Claude: POST /v1/messages
+        Note over Claude: Model: claude-sonnet-4-5<br/>System: "트렌드 분석 전문가"<br/>Prompt: 업종/지역/계절 트렌드
+        Claude-->>CAC: ClaudeResponse
+        CAC-->>TAS: ClaudeResponse
+
+        TAS->>TAS: parseResponse(responseText)
+        TAS-->>ARS: TrendAnalysis
+        deactivate TAS
+
+        %% 트렌드 캐싱
+        ARS->>CS: saveTrend(industry, region, analysis)
+        CS->>Redis: SET ai:trend:{industry}:{region} (TTL: 1시간)
+    end
+
+    %% 6. Job 상태: PROCESSING (50%)
+    ARS->>JSS: updateJobStatus(jobId, PROCESSING, "이벤트 추천안 생성 중")
+    JSS->>CS: saveJobStatus(jobId, status)
+    CS->>Redis: SET ai:job:status:{jobId}
+
+    %% 7. 이벤트 추천안 생성
+    ARS->>ARS: createRecommendations(message, trendAnalysis)
+    ARS->>ARS: circuitBreakerManager.executeWithCircuitBreaker()
+    ARS->>CAC: sendMessage(apiKey, version, request)
+    CAC->>Claude: POST /v1/messages
+    Note over Claude: Model: claude-sonnet-4-5<br/>System: "이벤트 기획 전문가"<br/>Prompt: 3가지 추천안 생성
+    Claude-->>CAC: ClaudeResponse
+    CAC-->>ARS: ClaudeResponse
+
+    ARS->>ARS: parseRecommendationResponse(responseText)
+
+    %% 8. Job 상태: PROCESSING (90%)
+    ARS->>JSS: updateJobStatus(jobId, PROCESSING, "결과 저장 중")
+    JSS->>CS: saveJobStatus(jobId, status)
+    CS->>Redis: SET ai:job:status:{jobId}
+
+    %% 9. 결과 저장
+    ARS->>CS: saveRecommendation(eventId, result)
+    CS->>Redis: SET ai:recommendation:{eventId} (TTL: 24시간)
+
+    %% 10. Job 상태: COMPLETED (100%)
+    ARS->>JSS: updateJobStatus(jobId, COMPLETED, "AI 추천 완료")
+    JSS->>CS: saveJobStatus(jobId, status)
+    CS->>Redis: SET ai:job:status:{jobId}
+
+    deactivate ARS
+
+    %% 11. Kafka ACK
+    Consumer->>Kafka: acknowledgment.acknowledge()
+```
+
+---
+
+## 2. Job 상태 조회 워크플로우 (동기)
+
+```mermaid
+sequenceDiagram
+    participant ES as Event Service
+    participant Controller as InternalJobController
+    participant JSS as JobStatusService
+    participant CS as CacheService
+    participant Redis as Redis
+
+    %% 1. Event Service가 Job 상태 조회
+    ES->>Controller: GET /api/v1/ai-service/internal/jobs/{jobId}/status
+
+    %% 2. Job 상태 조회
+    Controller->>JSS: getJobStatus(jobId)
+    activate JSS
+
+    JSS->>CS: getJobStatus(jobId)
+    CS->>Redis: GET ai:job:status:{jobId}
+
+    alt 상태 존재
+        Redis-->>CS: JobStatusResponse
+        CS-->>JSS: Object (JobStatusResponse)
+        JSS->>JSS: objectMapper.convertValue()
+        JSS-->>Controller: JobStatusResponse
+        Controller-->>ES: 200 OK + JobStatusResponse
+    else 상태 없음
+        Redis-->>CS: null
+        CS-->>JSS: null
+        JSS-->>Controller: JobNotFoundException
+        Controller-->>ES: 404 Not Found
+    end
+
+    deactivate JSS
+```
+
+---
+
+## 3. AI 추천 결과 조회 워크플로우 (동기)
+
+```mermaid
+sequenceDiagram
+    participant ES as Event Service
+    participant Controller as InternalRecommendationController
+    participant ARS as AIRecommendationService
+    participant CS as CacheService
+    participant Redis as Redis
+
+    %% 1. Event Service가 AI 추천 결과 조회
+    ES->>Controller: GET /api/v1/ai-service/internal/recommendations/{eventId}
+
+    %% 2. 추천 결과 조회
+    Controller->>ARS: getRecommendation(eventId)
+    activate ARS
+
+    ARS->>CS: getRecommendation(eventId)
+    CS->>Redis: GET ai:recommendation:{eventId}
+
+    alt 결과 존재
+        Redis-->>CS: AIRecommendationResult
+        CS-->>ARS: Object (AIRecommendationResult)
+        ARS->>ARS: objectMapper.convertValue()
+        ARS-->>Controller: AIRecommendationResult
+        Controller-->>ES: 200 OK + AIRecommendationResult
+    else 결과 없음
+        Redis-->>CS: null
+        CS-->>ARS: null
+        ARS-->>Controller: RecommendationNotFoundException
+        Controller-->>ES: 404 Not Found
+    end
+
+    deactivate ARS
+```
+
+---
+
+## 4. 헬스체크 워크플로우 (동기)
+
+```mermaid
+sequenceDiagram
+    participant Client as Client/Actuator
+    participant Controller as HealthController
+    participant Redis as Redis
+
+    %% 1. 헬스체크 요청
+    Client->>Controller: GET /api/v1/ai-service/health
+
+    %% 2. Redis 상태 확인
+    Controller->>Controller: checkRedis()
+
+    alt RedisTemplate 존재
+        Controller->>Redis: PING
+        alt Redis 정상
+            Redis-->>Controller: PONG
+            Controller->>Controller: redisStatus = UP
+        else Redis 오류
+            Redis-->>Controller: Exception
+            Controller->>Controller: redisStatus = DOWN
+        end
+    else RedisTemplate 없음
+        Controller->>Controller: redisStatus = UNKNOWN
+    end
+
+    %% 3. 전체 상태 판단
+    alt Redis DOWN
+        Controller->>Controller: overallStatus = DEGRADED
+    else Redis UP/UNKNOWN
+        Controller->>Controller: overallStatus = UP
+    end
+
+    %% 4. 응답
+    Controller-->>Client: 200 OK + HealthCheckResponse
+```
+
+---
+
+## 5. 주요 컴포넌트 메서드 목록
+
+### 5.1 Controller Layer
+
+#### InternalJobController
+| 메서드 | HTTP | 엔드포인트 | 설명 |
+|--------|------|-----------|------|
+| `getJobStatus(jobId)` | GET | `/api/v1/ai-service/internal/jobs/{jobId}/status` | Job 상태 조회 |
+| `createTestJob(jobId)` | GET | `/api/v1/ai-service/internal/jobs/debug/create-test-job/{jobId}` | 테스트 Job 생성 (디버그) |
+
+#### InternalRecommendationController
+| 메서드 | HTTP | 엔드포인트 | 설명 |
+|--------|------|-----------|------|
+| `getRecommendation(eventId)` | GET | `/api/v1/ai-service/internal/recommendations/{eventId}` | AI 추천 결과 조회 |
+| `debugRedisKeys()` | GET | `/api/v1/ai-service/internal/recommendations/debug/redis-keys` | Redis 모든 키 조회 |
+| `debugRedisKey(key)` | GET | `/api/v1/ai-service/internal/recommendations/debug/redis-key/{key}` | Redis 특정 키 조회 |
+| `searchAllDatabases()` | GET | `/api/v1/ai-service/internal/recommendations/debug/search-all-databases` | 전체 DB 검색 |
+| `createTestData(eventId)` | GET | `/api/v1/ai-service/internal/recommendations/debug/create-test-data/{eventId}` | 테스트 데이터 생성 |
+
+#### HealthController
+| 메서드 | HTTP | 엔드포인트 | 설명 |
+|--------|------|-----------|------|
+| `healthCheck()` | GET | `/api/v1/ai-service/health` | 서비스 헬스체크 |
+| `checkRedis()` | - | (내부) | Redis 연결 확인 |
+
+---
+
+### 5.2 Service Layer
+
+#### AIRecommendationService
+| 메서드 | 호출자 | 설명 |
+|--------|-------|------|
+| `getRecommendation(eventId)` | Controller | Redis에서 추천 결과 조회 |
+| `generateRecommendations(message)` | AIJobConsumer | AI 추천 생성 (전체 프로세스) |
+| `analyzeTrend(message)` | 내부 | 트렌드 분석 (캐시 확인 포함) |
+| `createRecommendations(message, trendAnalysis)` | 내부 | 이벤트 추천안 생성 |
+| `callClaudeApiForRecommendations(message, trendAnalysis)` | 내부 | Claude API 호출 (추천안) |
+| `buildRecommendationPrompt(message, trendAnalysis)` | 내부 | 추천안 프롬프트 생성 |
+| `parseRecommendationResponse(responseText)` | 내부 | 추천안 응답 파싱 |
+| `parseEventRecommendation(node)` | 내부 | EventRecommendation 파싱 |
+| `parseRange(node)` | 내부 | Range 객체 파싱 |
+| `extractJsonFromMarkdown(text)` | 내부 | Markdown에서 JSON 추출 |
+
+#### TrendAnalysisService
+| 메서드 | 호출자 | 설명 |
+|--------|-------|------|
+| `analyzeTrend(industry, region)` | AIRecommendationService | 트렌드 분석 수행 |
+| `callClaudeApi(industry, region)` | 내부 | Claude API 호출 (트렌드) |
+| `buildPrompt(industry, region)` | 내부 | 트렌드 분석 프롬프트 생성 |
+| `parseResponse(responseText)` | 내부 | 트렌드 응답 파싱 |
+| `extractJsonFromMarkdown(text)` | 내부 | Markdown에서 JSON 추출 |
+| `parseTrendKeywords(arrayNode)` | 내부 | TrendKeyword 리스트 파싱 |
+
+#### JobStatusService
+| 메서드 | 호출자 | 설명 |
+|--------|-------|------|
+| `getJobStatus(jobId)` | Controller | Job 상태 조회 |
+| `updateJobStatus(jobId, status, message)` | AIRecommendationService | Job 상태 업데이트 |
+| `calculateProgress(status)` | 내부 | 상태별 진행률 계산 |
+
+#### CacheService
+| 메서드 | 호출자 | 설명 |
+|--------|-------|------|
+| `set(key, value, ttlSeconds)` | 내부 | 범용 캐시 저장 |
+| `get(key)` | 내부 | 범용 캐시 조회 |
+| `delete(key)` | 외부 | 캐시 삭제 |
+| `saveJobStatus(jobId, status)` | JobStatusService | Job 상태 저장 |
+| `getJobStatus(jobId)` | JobStatusService | Job 상태 조회 |
+| `saveRecommendation(eventId, recommendation)` | AIRecommendationService | AI 추천 결과 저장 |
+| `getRecommendation(eventId)` | AIRecommendationService | AI 추천 결과 조회 |
+| `saveTrend(industry, region, trend)` | AIRecommendationService | 트렌드 분석 결과 저장 |
+| `getTrend(industry, region)` | AIRecommendationService | 트렌드 분석 결과 조회 |
+
+---
+
+### 5.3 Consumer Layer
+
+#### AIJobConsumer
+| 메서드 | 트리거 | 설명 |
+|--------|-------|------|
+| `consume(message, topic, offset, ack)` | Kafka Message | Kafka 메시지 수신 및 처리 |
+
+---
+
+### 5.4 Client Layer
+
+#### ClaudeApiClient (Feign)
+| 메서드 | 호출자 | 설명 |
+|--------|-------|------|
+| `sendMessage(apiKey, anthropicVersion, request)` | TrendAnalysisService, AIRecommendationService | Claude API 호출 |
+
+---
+
+## 6. Redis 캐시 키 구조
+
+| 키 패턴 | 설명 | TTL |
+|--------|------|-----|
+| `ai:job:status:{jobId}` | Job 상태 정보 | 24시간 (86400초) |
+| `ai:recommendation:{eventId}` | AI 추천 결과 | 24시간 (86400초) |
+| `ai:trend:{industry}:{region}` | 트렌드 분석 결과 | 1시간 (3600초) |
+
+---
+
+## 7. Claude API 호출 정보
+
+### 7.1 트렌드 분석
+- **URL**: `https://api.anthropic.com/v1/messages`
+- **Model**: `claude-sonnet-4-5-20250929`
+- **Max Tokens**: 4096
+- **Temperature**: 0.7
+- **System Prompt**: "당신은 마케팅 트렌드 분석 전문가입니다. 업종별, 지역별 트렌드를 분석하고 인사이트를 제공합니다."
+- **응답 형식**: JSON (industryTrends, regionalTrends, seasonalTrends)
+
+### 7.2 이벤트 추천안 생성
+- **URL**: `https://api.anthropic.com/v1/messages`
+- **Model**: `claude-sonnet-4-5-20250929`
+- **Max Tokens**: 4096
+- **Temperature**: 0.7
+- **System Prompt**: "당신은 소상공인을 위한 마케팅 이벤트 기획 전문가입니다. 트렌드 분석을 바탕으로 실행 가능한 이벤트 추천안을 제공합니다."
+- **응답 형식**: JSON (recommendations: 3가지 옵션)
+
+---
+
+## 8. Circuit Breaker 설정
+
+### 적용 대상
+- `claudeApi`: 모든 Claude API 호출
+
+### 설정값
+```yaml
+failure-rate-threshold: 50%
+slow-call-duration-threshold: 60초
+sliding-window-size: 10
+minimum-number-of-calls: 5
+wait-duration-in-open-state: 60초
+timeout-duration: 300초 (5분)
+```
+
+### Fallback 메서드
+- `AIServiceFallback.getDefaultTrendAnalysis()`: 기본 트렌드 분석
+- `AIServiceFallback.getDefaultRecommendations()`: 기본 추천안
+
+---
+
+## 9. 에러 처리
+
+### Exception 종류
+| Exception | HTTP Code | 발생 조건 |
+|-----------|-----------|---------|
+| `RecommendationNotFoundException` | 404 | Redis에 추천 결과 없음 |
+| `JobNotFoundException` | 404 | Redis에 Job 상태 없음 |
+| `AIServiceException` | 500 | AI 서비스 내부 오류 |
+
+### 에러 응답 예시
+```json
+{
+  "timestamp": "2025-10-30T15:30:00",
+  "status": 404,
+  "error": "Not Found",
+  "message": "추천 결과를 찾을 수 없습니다: eventId=evt-123",
+  "path": "/api/v1/ai-service/internal/recommendations/evt-123"
+}
+```
+
+---
+
+## 10. 로깅 레벨
+
+```yaml
+com.kt.ai: DEBUG
+org.springframework.kafka: INFO
+org.springframework.data.redis: INFO
+io.github.resilience4j: DEBUG
+```
--- a/distribution-service/src/main/resources/application.yml
+++ b/distribution-service/src/main/resources/application.yml
@ -145,6 +145,14 @@ springdoc:
    display-request-duration: true
  show-actuator: true

+# CORS Configuration
+cors:
+  allowed-origins: ${CORS_ALLOWED_ORIGINS:http://localhost:8081,http://localhost:8082,http://localhost:8083,http://localhost:8084,http://kt-event-marketing.20.214.196.128.nip.io}
+  allowed-methods: ${CORS_ALLOWED_METHODS:GET,POST,PUT,DELETE,OPTIONS,PATCH}
+  allowed-headers: ${CORS_ALLOWED_HEADERS:*}
+  allow-credentials: ${CORS_ALLOW_CREDENTIALS:true}
+  max-age: ${CORS_MAX_AGE:3600}
+
 # Logging
 logging:
  file:
--- a/event-service/.run/event-service.run.xml
+++ b/event-service/.run/event-service.run.xml
@ -31,6 +31,9 @@
          <!-- JWT Configuration -->
          <entry key="JWT_SECRET" value="kt-event-marketing-secret-key-for-development-only-please-change-in-production" />

+          <!-- CORS Configuration -->
+          <entry key="CORS_ALLOWED_ORIGINS" value="http://localhost:*,http://*.nip.io:*" />
+
          <!-- Logging Configuration -->
          <entry key="LOG_LEVEL" value="DEBUG" />
          <entry key="SQL_LOG_LEVEL" value="DEBUG" />
--- a/event-service/src/main/java/com/kt/event/eventservice/application/dto/kafka/AIEventGenerationJobMessage.java
+++ b/event-service/src/main/java/com/kt/event/eventservice/application/dto/kafka/AIEventGenerationJobMessage.java
@ -1,18 +1,17 @@
 package com.kt.event.eventservice.application.dto.kafka;

-import com.fasterxml.jackson.annotation.JsonProperty;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Data;
 import lombok.NoArgsConstructor;

 import java.time.LocalDateTime;
-import java.util.List;

 /**
 * AI 이벤트 생성 작업 메시지 DTO
 *
 * ai-event-generation-job 토픽에서 구독하는 메시지 형식
+ * JSON 필드명: camelCase (Jackson 기본 설정)
 */
@Data
@Builder
@ -23,73 +22,54 @@ public class AIEventGenerationJobMessage {
    /**
     * 작업 ID
     */
-    @JsonProperty("job_id")
    private String jobId;

    /**
     * 사용자 ID (UUID String)
     */
-    @JsonProperty("user_id")
    private String userId;

    /**
-     * 작업 상태 (PENDING, PROCESSING, COMPLETED, FAILED)
+     * 이벤트 ID
     */
-    @JsonProperty("status")
-    private String status;
+    private String eventId;

    /**
-     * AI 추천 결과 데이터
+     * 이벤트 목적
+     * - "신규 고객 유치"
+     * - "재방문 유도"
+     * - "매출 증대"
+     * - "브랜드 인지도 향상"
     */
-    @JsonProperty("ai_recommendation")
-    private AIRecommendationData aiRecommendation;
+    private String objective;

    /**
-     * 에러 메시지 (실패 시)
+     * 업종 (storeCategory와 동일)
     */
-    @JsonProperty("error_message")
-    private String errorMessage;
+    private String industry;

    /**
-     * 작업 생성 일시
+     * 지역 (시/구/동)
     */
-    @JsonProperty("created_at")
-    private LocalDateTime createdAt;
+    private String region;

    /**
-     * 작업 완료/실패 일시
+     * 매장명
     */
-    @JsonProperty("completed_at")
-    private LocalDateTime completedAt;
+    private String storeName;

    /**
-     * AI 추천 데이터 내부 클래스
+     * 목표 고객층 (선택)
     */
-    @Data
-    @Builder
-    @NoArgsConstructor
-    @AllArgsConstructor
-    public static class AIRecommendationData {
+    private String targetAudience;

-        @JsonProperty("event_title")
-        private String eventTitle;
+    /**
+     * 예산 (원) (선택)
+     */
+    private Integer budget;

-        @JsonProperty("event_description")
-        private String eventDescription;
-
-        @JsonProperty("event_type")
-        private String eventType;
-
-        @JsonProperty("target_keywords")
-        private List<String> targetKeywords;
-
-        @JsonProperty("recommended_benefits")
-        private List<String> recommendedBenefits;
-
-        @JsonProperty("start_date")
-        private String startDate;
-
-        @JsonProperty("end_date")
-        private String endDate;
-    }
+    /**
+     * 요청 시각
+     */
+    private LocalDateTime requestedAt;
 }
--- a/event-service/src/main/java/com/kt/event/eventservice/application/dto/kafka/EventCreatedMessage.java
+++ b/event-service/src/main/java/com/kt/event/eventservice/application/dto/kafka/EventCreatedMessage.java
@ -7,7 +7,6 @@ import lombok.Data;
 import lombok.NoArgsConstructor;

 import java.time.LocalDateTime;
-import java.util.UUID;

 /**
 * 이벤트 생성 완료 메시지 DTO
@ -21,16 +20,16 @@ import java.util.UUID;
 public class EventCreatedMessage {

    /**
-     * 이벤트 ID (UUID)
+     * 이벤트 ID
     */
    @JsonProperty("event_id")
-    private UUID eventId;
+    private String eventId;

    /**
-     * 사용자 ID (UUID)
+     * 사용자 ID
     */
    @JsonProperty("user_id")
-    private UUID userId;
+    private String userId;

    /**
     * 이벤트 제목
--- a/event-service/src/main/java/com/kt/event/eventservice/application/dto/request/AiRecommendationRequest.java
+++ b/event-service/src/main/java/com/kt/event/eventservice/application/dto/request/AiRecommendationRequest.java
@ -8,8 +8,6 @@ import lombok.Builder;
 import lombok.Getter;
 import lombok.NoArgsConstructor;

-import java.util.UUID;
-
 /**
 * AI 추천 요청 DTO
 *
@ -26,11 +24,24 @@ import java.util.UUID;
@Schema(description = "AI 추천 요청")
 public class AiRecommendationRequest {

+    @NotNull(message = "이벤트 목적은 필수입니다.")
+    @Schema(description = "이벤트 목적", required = true, example = "신규 고객 유치")
+    private String objective;
+
    @NotNull(message = "매장 정보는 필수입니다.")
    @Valid
    @Schema(description = "매장 정보", required = true)
    private StoreInfo storeInfo;

+    @Schema(description = "지역 정보", example = "서울특별시 강남구")
+    private String region;
+
+    @Schema(description = "타겟 고객층", example = "20-30대 직장인")
+    private String targetAudience;
+
+    @Schema(description = "예산 (원)", example = "500000")
+    private Integer budget;
+
    /**
     * 매장 정보
     */
@ -42,8 +53,8 @@ public class AiRecommendationRequest {
    public static class StoreInfo {

        @NotNull(message = "매장 ID는 필수입니다.")
-        @Schema(description = "매장 ID", required = true, example = "550e8400-e29b-41d4-a716-446655440002")
-        private UUID storeId;
+        @Schema(description = "매장 ID", required = true, example = "str_20250124_001")
+        private String storeId;

        @NotNull(message = "매장명은 필수입니다.")
        @Schema(description = "매장명", required = true, example = "우진네 고깃집")
--- a/event-service/src/main/java/com/kt/event/eventservice/application/dto/request/SelectImageRequest.java
+++ b/event-service/src/main/java/com/kt/event/eventservice/application/dto/request/SelectImageRequest.java
@ -6,8 +6,6 @@ import lombok.Builder;
 import lombok.Data;
 import lombok.NoArgsConstructor;

-import java.util.UUID;
-
 /**
 * 이미지 선택 요청 DTO
 *
@ -22,7 +20,7 @@ import java.util.UUID;
 public class SelectImageRequest {

    @NotNull(message = "이미지 ID는 필수입니다.")
-    private UUID imageId;
+    private String imageId;

    private String imageUrl;
 }
--- a/event-service/src/main/java/com/kt/event/eventservice/application/dto/request/SelectObjectiveRequest.java
+++ b/event-service/src/main/java/com/kt/event/eventservice/application/dto/request/SelectObjectiveRequest.java
@ -19,6 +19,9 @@ import lombok.NoArgsConstructor;
@Builder
 public class SelectObjectiveRequest {

+    @NotBlank(message = "이벤트 ID는 필수입니다.")
+    private String eventId;
+
    @NotBlank(message = "이벤트 목적은 필수입니다.")
    private String objective;
 }
--- a/event-service/src/main/java/com/kt/event/eventservice/application/dto/request/SelectRecommendationRequest.java
+++ b/event-service/src/main/java/com/kt/event/eventservice/application/dto/request/SelectRecommendationRequest.java
@ -9,7 +9,6 @@ import lombok.Getter;
 import lombok.NoArgsConstructor;

 import java.time.LocalDate;
-import java.util.UUID;

 /**
 * AI 추천 선택 요청 DTO
@ -28,8 +27,8 @@ import java.util.UUID;
 public class SelectRecommendationRequest {

    @NotNull(message = "추천 ID는 필수입니다.")
-    @Schema(description = "선택한 추천 ID", required = true, example = "550e8400-e29b-41d4-a716-446655440007")
-    private UUID recommendationId;
+    @Schema(description = "선택한 추천 ID", required = true, example = "rec_20250124_001")
+    private String recommendationId;

    @Valid
    @Schema(description = "커스터마이징 항목")
--- a/event-service/src/main/java/com/kt/event/eventservice/application/dto/response/EventCreatedResponse.java
+++ b/event-service/src/main/java/com/kt/event/eventservice/application/dto/response/EventCreatedResponse.java
@ -7,7 +7,6 @@ import lombok.Data;
 import lombok.NoArgsConstructor;

 import java.time.LocalDateTime;
-import java.util.UUID;

 /**
 * 이벤트 생성 응답 DTO
@ -22,7 +21,7 @@ import java.util.UUID;
@Builder
 public class EventCreatedResponse {

-    private UUID eventId;
+    private String eventId;
    private EventStatus status;
    private String objective;
    private LocalDateTime createdAt;
--- a/event-service/src/main/java/com/kt/event/eventservice/application/dto/response/EventDetailResponse.java
+++ b/event-service/src/main/java/com/kt/event/eventservice/application/dto/response/EventDetailResponse.java
@ -10,7 +10,6 @@ import java.time.LocalDate;
 import java.time.LocalDateTime;
 import java.util.ArrayList;
 import java.util.List;
-import java.util.UUID;

 /**
 * 이벤트 상세 응답 DTO
@ -25,16 +24,16 @@ import java.util.UUID;
@Builder
 public class EventDetailResponse {

-    private UUID eventId;
-    private UUID userId;
-    private UUID storeId;
+    private String eventId;
+    private String userId;
+    private String storeId;
    private String eventName;
    private String description;
    private String objective;
    private LocalDate startDate;
    private LocalDate endDate;
    private EventStatus status;
-    private UUID selectedImageId;
+    private String selectedImageId;
    private String selectedImageUrl;
    private Integer participants;
    private Integer targetParticipants;
@ -57,7 +56,7 @@ public class EventDetailResponse {
    @AllArgsConstructor
    @Builder
    public static class GeneratedImageDto {
-        private UUID imageId;
+        private String imageId;
        private String imageUrl;
        private String style;
        private String platform;
@ -70,7 +69,7 @@ public class EventDetailResponse {
    @AllArgsConstructor
    @Builder
    public static class AiRecommendationDto {
-        private UUID recommendationId;
+        private String recommendationId;
        private String eventName;
        private String description;
        private String promotionType;
--- a/event-service/src/main/java/com/kt/event/eventservice/application/dto/response/ImageEditResponse.java
+++ b/event-service/src/main/java/com/kt/event/eventservice/application/dto/response/ImageEditResponse.java
@ -7,7 +7,6 @@ import lombok.Getter;
 import lombok.NoArgsConstructor;

 import java.time.LocalDateTime;
-import java.util.UUID;

 /**
 * 이미지 편집 응답 DTO
@ -25,8 +24,8 @@ import java.util.UUID;
@Schema(description = "이미지 편집 응답")
 public class ImageEditResponse {

-    @Schema(description = "편집된 이미지 ID", example = "550e8400-e29b-41d4-a716-446655440008")
-    private UUID imageId;
+    @Schema(description = "편집된 이미지 ID", example = "img_20250124_001")
+    private String imageId;

    @Schema(description = "편집된 이미지 URL", example = "https://cdn.kt-event.com/images/event-img-001-edited.jpg")
    private String imageUrl;
--- a/event-service/src/main/java/com/kt/event/eventservice/application/dto/response/ImageGenerationResponse.java
+++ b/event-service/src/main/java/com/kt/event/eventservice/application/dto/response/ImageGenerationResponse.java
@ -6,7 +6,6 @@ import lombok.Data;
 import lombok.NoArgsConstructor;

 import java.time.LocalDateTime;
-import java.util.UUID;

 /**
 * 이미지 생성 응답 DTO
@ -21,7 +20,7 @@ import java.util.UUID;
@Builder
 public class ImageGenerationResponse {

-    private UUID jobId;
+    private String jobId;
    private String status;
    private String message;
    private LocalDateTime createdAt;
--- a/event-service/src/main/java/com/kt/event/eventservice/application/dto/response/JobAcceptedResponse.java
+++ b/event-service/src/main/java/com/kt/event/eventservice/application/dto/response/JobAcceptedResponse.java
@ -7,8 +7,6 @@ import lombok.Builder;
 import lombok.Getter;
 import lombok.NoArgsConstructor;

-import java.util.UUID;
-
 /**
 * Job 접수 응답 DTO
 *
@ -25,8 +23,8 @@ import java.util.UUID;
@Schema(description = "Job 접수 응답")
 public class JobAcceptedResponse {

-    @Schema(description = "생성된 Job ID", example = "550e8400-e29b-41d4-a716-446655440005")
-    private UUID jobId;
+    @Schema(description = "생성된 Job ID", example = "job_20250124_001")
+    private String jobId;

    @Schema(description = "Job 상태 (초기 상태는 PENDING)", example = "PENDING")
    private JobStatus status;
--- a/event-service/src/main/java/com/kt/event/eventservice/application/dto/response/JobStatusResponse.java
+++ b/event-service/src/main/java/com/kt/event/eventservice/application/dto/response/JobStatusResponse.java
@ -8,7 +8,6 @@ import lombok.Data;
 import lombok.NoArgsConstructor;

 import java.time.LocalDateTime;
-import java.util.UUID;

 /**
 * Job 상태 응답 DTO
@ -23,7 +22,7 @@ import java.util.UUID;
@Builder
 public class JobStatusResponse {

-    private UUID jobId;
+    private String jobId;
    private JobType jobType;
    private JobStatus status;
    private int progress;
--- a/event-service/src/main/java/com/kt/event/eventservice/application/service/EventIdGenerator.java
+++ b/event-service/src/main/java/com/kt/event/eventservice/application/service/EventIdGenerator.java
@ -0,0 +1,86 @@
+package com.kt.event.eventservice.application.service;
+
+import org.springframework.stereotype.Component;
+
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.UUID;
+
+/**
+ * 이벤트 ID 생성기
+ *
+ * 비즈니스 친화적인 eventId를 생성합니다.
+ * 형식: EVT-{storeId}-{yyyyMMddHHmmss}-{random8}
+ * 예시: EVT-store123-20251029143025-a1b2c3d4
+ *
+ * VARCHAR(50) 길이 제약사항을 고려하여 설계되었습니다.
+ */
+@Component
+public class EventIdGenerator {
+
+    private static final String PREFIX = "EVT";
+    private static final DateTimeFormatter TIMESTAMP_FORMATTER = DateTimeFormatter.ofPattern("yyyyMMddHHmmss");
+    private static final int RANDOM_LENGTH = 8;
+
+    /**
+     * 이벤트 ID 생성 (백엔드용)
+     *
+     * 참고: 현재는 프론트엔드에서 eventId를 생성하므로 이 메서드는 거의 사용되지 않습니다.
+     *
+     * @param storeId 상점 ID
+     * @return 생성된 이벤트 ID
+     */
+    public String generate(String storeId) {
+        // 기본값 처리
+        if (storeId == null || storeId.isBlank()) {
+            storeId = "unknown";
+        }
+
+        String timestamp = LocalDateTime.now().format(TIMESTAMP_FORMATTER);
+        String randomPart = generateRandomPart();
+
+        // 형식: EVT-{storeId}-{timestamp}-{random}
+        String eventId = String.format("%s-%s-%s-%s", PREFIX, storeId, timestamp, randomPart);
+
+        return eventId;
+    }
+
+    /**
+     * UUID 기반 랜덤 문자열 생성
+     *
+     * @return 8자리 랜덤 문자열 (소문자 영숫자)
+     */
+    private String generateRandomPart() {
+        return UUID.randomUUID()
+            .toString()
+            .replace("-", "")
+            .substring(0, RANDOM_LENGTH)
+            .toLowerCase();
+    }
+
+    /**
+     * eventId 기본 검증
+     *
+     * 최소한의 검증만 수행합니다:
+     * - null/empty 체크
+     * - 길이 제한 체크 (VARCHAR(50) 제약)
+     *
+     * 프론트엔드에서 생성한 eventId를 신뢰하며,
+     * DB의 PRIMARY KEY 제약조건으로 중복을 방지합니다.
+     *
+     * @param eventId 검증할 이벤트 ID
+     * @return 유효하면 true, 아니면 false
+     */
+    public boolean isValid(String eventId) {
+        if (eventId == null || eventId.isBlank()) {
+            return false;
+        }
+
+        // 길이 검증 (DB VARCHAR(50) 제약)
+        if (eventId.length() > 50) {
+            return false;
+        }
+
+        return true;
+    }
+}
--- a/event-service/src/main/java/com/kt/event/eventservice/application/service/EventService.java
+++ b/event-service/src/main/java/com/kt/event/eventservice/application/service/EventService.java
@ -24,7 +24,6 @@ import org.springframework.data.domain.Pageable;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;

-import java.util.UUID;
 import java.util.stream.Collectors;

 /**
@ -48,22 +47,32 @@ public class EventService {
    private final AIJobKafkaProducer aiJobKafkaProducer;
    private final ImageJobKafkaProducer imageJobKafkaProducer;
    private final EventKafkaProducer eventKafkaProducer;
+    private final EventIdGenerator eventIdGenerator;
+    private final JobIdGenerator jobIdGenerator;

    /**
     * 이벤트 생성 (Step 1: 목적 선택)
     *
-     * @param userId 사용자 ID (UUID)
-     * @param storeId 매장 ID (UUID)
-     * @param request 목적 선택 요청
+     * @param userId 사용자 ID
+     * @param storeId 매장 ID
+     * @param request 목적 선택 요청 (eventId 포함)
     * @return 생성된 이벤트 응답
     */
    @Transactional
-    public EventCreatedResponse createEvent(UUID userId, UUID storeId, SelectObjectiveRequest request) {
-        log.info("이벤트 생성 시작 - userId: {}, storeId: {}, objective: {}",
-                 userId, storeId, request.getObjective());
+    public EventCreatedResponse createEvent(String userId, String storeId, SelectObjectiveRequest request) {
+        log.info("이벤트 생성 시작 - userId: {}, storeId: {}, eventId: {}, objective: {}",
+                 userId, storeId, request.getEventId(), request.getObjective());
+
+        String eventId = request.getEventId();
+
+        // 동일한 eventId가 이미 존재하는지 확인
+        if (eventRepository.findByEventId(eventId).isPresent()) {
+            throw new BusinessException(ErrorCode.EVENT_005);
+        }

        // 이벤트 엔티티 생성
        Event event = Event.builder()
+            .eventId(eventId)
            .userId(userId)
            .storeId(storeId)
            .objective(request.getObjective())
@ -87,11 +96,11 @@ public class EventService {
    /**
     * 이벤트 상세 조회
     *
-     * @param userId 사용자 ID (UUID)
+     * @param userId 사용자 ID
     * @param eventId 이벤트 ID
     * @return 이벤트 상세 응답
     */
-    public EventDetailResponse getEvent(UUID userId, UUID eventId) {
+    public EventDetailResponse getEvent(String userId, String eventId) {
        log.info("이벤트 조회 - userId: {}, eventId: {}", userId, eventId);

        Event event = eventRepository.findByEventIdAndUserId(eventId, userId)
@ -108,7 +117,7 @@ public class EventService {
    /**
     * 이벤트 목록 조회 (페이징, 필터링)
     *
-     * @param userId 사용자 ID (UUID)
+     * @param userId 사용자 ID
     * @param status 상태 필터
     * @param search 검색어
     * @param objective 목적 필터
@ -116,7 +125,7 @@ public class EventService {
     * @return 이벤트 목록
     */
    public Page<EventDetailResponse> getEvents(
-            UUID userId,
+            String userId,
            EventStatus status,
            String search,
            String objective,
@ -139,11 +148,11 @@ public class EventService {
    /**
     * 이벤트 삭제
     *
-     * @param userId 사용자 ID (UUID)
+     * @param userId 사용자 ID
     * @param eventId 이벤트 ID
     */
    @Transactional
-    public void deleteEvent(UUID userId, UUID eventId) {
+    public void deleteEvent(String userId, String eventId) {
        log.info("이벤트 삭제 - userId: {}, eventId: {}", userId, eventId);

        Event event = eventRepository.findByEventIdAndUserId(eventId, userId)
@ -161,11 +170,11 @@ public class EventService {
    /**
     * 이벤트 배포
     *
-     * @param userId 사용자 ID (UUID)
+     * @param userId 사용자 ID
     * @param eventId 이벤트 ID
     */
    @Transactional
-    public void publishEvent(UUID userId, UUID eventId) {
+    public void publishEvent(String userId, String eventId) {
        log.info("이벤트 배포 - userId: {}, eventId: {}", userId, eventId);

        Event event = eventRepository.findByEventIdAndUserId(eventId, userId)
@ -190,11 +199,11 @@ public class EventService {
    /**
     * 이벤트 종료
     *
-     * @param userId 사용자 ID (UUID)
+     * @param userId 사용자 ID
     * @param eventId 이벤트 ID
     */
    @Transactional
-    public void endEvent(UUID userId, UUID eventId) {
+    public void endEvent(String userId, String eventId) {
        log.info("이벤트 종료 - userId: {}, eventId: {}", userId, eventId);

        Event event = eventRepository.findByEventIdAndUserId(eventId, userId)
@ -210,13 +219,13 @@ public class EventService {
    /**
     * 이미지 생성 요청
     *
-     * @param userId 사용자 ID (UUID)
+     * @param userId 사용자 ID
     * @param eventId 이벤트 ID
     * @param request 이미지 생성 요청
     * @return 이미지 생성 응답 (Job ID 포함)
     */
    @Transactional
-    public ImageGenerationResponse requestImageGeneration(UUID userId, UUID eventId, ImageGenerationRequest request) {
+    public ImageGenerationResponse requestImageGeneration(String userId, String eventId, ImageGenerationRequest request) {
        log.info("이미지 생성 요청 - userId: {}, eventId: {}", userId, eventId);

        // 이벤트 조회 및 권한 확인
@ -236,7 +245,11 @@ public class EventService {
            String.join(", ", request.getPlatforms()));

        // Job 엔티티 생성
+        String jobId = jobIdGenerator.generate(JobType.IMAGE_GENERATION);
+        log.info("생성된 jobId: {}", jobId);
+
        Job job = Job.builder()
+            .jobId(jobId)
            .eventId(eventId)
            .jobType(JobType.IMAGE_GENERATION)
            .build();
@ -245,9 +258,9 @@ public class EventService {

        // Kafka 메시지 발행
        imageJobKafkaProducer.publishImageGenerationJob(
-            job.getJobId().toString(),
-            userId.toString(),
-            eventId.toString(),
+            job.getJobId(),
+            userId,
+            eventId,
            prompt
        );

@ -265,13 +278,13 @@ public class EventService {
    /**
     * 이미지 선택
     *
-     * @param userId 사용자 ID (UUID)
+     * @param userId 사용자 ID
     * @param eventId 이벤트 ID
     * @param imageId 이미지 ID
     * @param request 이미지 선택 요청
     */
    @Transactional
-    public void selectImage(UUID userId, UUID eventId, UUID imageId, SelectImageRequest request) {
+    public void selectImage(String userId, String eventId, String imageId, SelectImageRequest request) {
        log.info("이미지 선택 - userId: {}, eventId: {}, imageId: {}", userId, eventId, imageId);

        // 이벤트 조회 및 권한 확인
@ -294,18 +307,36 @@ public class EventService {
    /**
     * AI 추천 요청
     *
-     * @param userId 사용자 ID (UUID)
-     * @param eventId 이벤트 ID
-     * @param request AI 추천 요청
+     * @param userId 사용자 ID
+     * @param eventId 이벤트 ID (프론트엔드에서 생성한 ID)
+     * @param request AI 추천 요청 (objective 포함)
     * @return Job 접수 응답
     */
    @Transactional
-    public JobAcceptedResponse requestAiRecommendations(UUID userId, UUID eventId, AiRecommendationRequest request) {
-        log.info("AI 추천 요청 - userId: {}, eventId: {}", userId, eventId);
+    public JobAcceptedResponse requestAiRecommendations(String userId, String eventId, AiRecommendationRequest request) {
+        log.info("AI 추천 요청 - userId: {}, eventId: {}, objective: {}",
+                 userId, eventId, request.getObjective());

-        // 이벤트 조회 및 권한 확인
+        // 이벤트 조회 또는 생성
        Event event = eventRepository.findByEventIdAndUserId(eventId, userId)
-            .orElseThrow(() -> new BusinessException(ErrorCode.EVENT_001));
+            .orElseGet(() -> {
+                log.info("이벤트가 존재하지 않아 새로 생성합니다 - eventId: {}", eventId);
+
+                // storeId 추출 (eventId 형식: EVT-{storeId}-{timestamp}-{random})
+                String storeId = request.getStoreInfo().getStoreId();
+
+                // 새 이벤트 생성
+                Event newEvent = Event.builder()
+                    .eventId(eventId)
+                    .userId(userId)
+                    .storeId(storeId)
+                    .objective(request.getObjective())
+                    .eventName("") // 초기에는 비어있음, AI 추천 후 설정
+                    .status(EventStatus.DRAFT)
+                    .build();
+
+                return eventRepository.save(newEvent);
+            });

        // DRAFT 상태 확인
        if (!event.isModifiable()) {
@ -313,7 +344,11 @@ public class EventService {
        }

        // Job 엔티티 생성
+        String jobId = jobIdGenerator.generate(JobType.AI_RECOMMENDATION);
+        log.info("생성된 jobId: {}", jobId);
+
        Job job = Job.builder()
+            .jobId(jobId)
            .eventId(eventId)
            .jobType(JobType.AI_RECOMMENDATION)
            .build();
@ -322,13 +357,15 @@ public class EventService {

        // Kafka 메시지 발행
        aiJobKafkaProducer.publishAIGenerationJob(
-            job.getJobId().toString(),
-            userId.toString(),
-            eventId.toString(),
+            job.getJobId(),
+            userId,
+            eventId,
            request.getStoreInfo().getStoreName(),
-            request.getStoreInfo().getCategory(),
-            request.getStoreInfo().getDescription(),
-            event.getObjective()
+            request.getStoreInfo().getCategory(),      // industry
+            request.getRegion(),                        // region
+            event.getObjective(),                       // objective
+            request.getTargetAudience(),                // targetAudience
+            request.getBudget()                         // budget
        );

        log.info("AI 추천 요청 완료 - jobId: {}", job.getJobId());
@ -343,12 +380,12 @@ public class EventService {
    /**
     * AI 추천 선택
     *
-     * @param userId 사용자 ID (UUID)
+     * @param userId 사용자 ID
     * @param eventId 이벤트 ID
     * @param request AI 추천 선택 요청
     */
    @Transactional
-    public void selectRecommendation(UUID userId, UUID eventId, SelectRecommendationRequest request) {
+    public void selectRecommendation(String userId, String eventId, SelectRecommendationRequest request) {
        log.info("AI 추천 선택 - userId: {}, eventId: {}, recommendationId: {}",
                 userId, eventId, request.getRecommendationId());

@ -409,14 +446,14 @@ public class EventService {
    /**
     * 이미지 편집
     *
-     * @param userId 사용자 ID (UUID)
+     * @param userId 사용자 ID
     * @param eventId 이벤트 ID
     * @param imageId 이미지 ID
     * @param request 이미지 편집 요청
     * @return 이미지 편집 응답
     */
    @Transactional
-    public ImageEditResponse editImage(UUID userId, UUID eventId, UUID imageId, ImageEditRequest request) {
+    public ImageEditResponse editImage(String userId, String eventId, String imageId, ImageEditRequest request) {
        log.info("이미지 편집 - userId: {}, eventId: {}, imageId: {}", userId, eventId, imageId);

        // 이벤트 조회 및 권한 확인
@ -450,12 +487,12 @@ public class EventService {
    /**
     * 배포 채널 선택
     *
-     * @param userId 사용자 ID (UUID)
+     * @param userId 사용자 ID
     * @param eventId 이벤트 ID
     * @param request 배포 채널 선택 요청
     */
    @Transactional
-    public void selectChannels(UUID userId, UUID eventId, SelectChannelsRequest request) {
+    public void selectChannels(String userId, String eventId, SelectChannelsRequest request) {
        log.info("배포 채널 선택 - userId: {}, eventId: {}, channels: {}",
                 userId, eventId, request.getChannels());

@ -479,13 +516,13 @@ public class EventService {
    /**
     * 이벤트 수정
     *
-     * @param userId 사용자 ID (UUID)
+     * @param userId 사용자 ID
     * @param eventId 이벤트 ID
     * @param request 이벤트 수정 요청
     * @return 이벤트 상세 응답
     */
    @Transactional
-    public EventDetailResponse updateEvent(UUID userId, UUID eventId, UpdateEventRequest request) {
+    public EventDetailResponse updateEvent(String userId, String eventId, UpdateEventRequest request) {
        log.info("이벤트 수정 - userId: {}, eventId: {}", userId, eventId);

        // 이벤트 조회 및 권한 확인
--- a/event-service/src/main/java/com/kt/event/eventservice/application/service/JobIdGenerator.java
+++ b/event-service/src/main/java/com/kt/event/eventservice/application/service/JobIdGenerator.java
@ -0,0 +1,106 @@
+package com.kt.event.eventservice.application.service;
+
+import com.kt.event.eventservice.domain.enums.JobType;
+import org.springframework.stereotype.Component;
+
+import java.util.UUID;
+
+/**
+ * Job ID 생성기
+ *
+ * 비즈니스 친화적인 jobId를 생성합니다.
+ * 형식: JOB-{jobType}-{timestamp}-{random8}
+ * 예시: JOB-AI-20251029143025-a1b2c3d4
+ *
+ * VARCHAR(50) 길이 제약사항을 고려하여 설계되었습니다.
+ */
+@Component
+public class JobIdGenerator {
+
+    private static final String PREFIX = "JOB";
+    private static final int RANDOM_LENGTH = 8;
+
+    /**
+     * Job ID 생성
+     *
+     * @param jobType Job 타입
+     * @return 생성된 Job ID
+     * @throws IllegalArgumentException jobType이 null인 경우
+     */
+    public String generate(JobType jobType) {
+        if (jobType == null) {
+            throw new IllegalArgumentException("jobType은 필수입니다");
+        }
+
+        String typeCode = getTypeCode(jobType);
+        String timestamp = String.valueOf(System.currentTimeMillis());
+        String randomPart = generateRandomPart();
+
+        // 형식: JOB-{type}-{timestamp}-{random}
+        // 예상 길이: 3 + 1 + 5 + 1 + 13 + 1 + 8 = 32자 (최대)
+        String jobId = String.format("%s-%s-%s-%s", PREFIX, typeCode, timestamp, randomPart);
+
+        // 길이 검증
+        if (jobId.length() > 50) {
+            throw new IllegalStateException(
+                String.format("생성된 jobId 길이(%d)가 50자를 초과했습니다: %s",
+                    jobId.length(), jobId)
+            );
+        }
+
+        return jobId;
+    }
+
+    /**
+     * JobType을 짧은 코드로 변환
+     *
+     * @param jobType Job 타입
+     * @return 타입 코드
+     */
+    private String getTypeCode(JobType jobType) {
+        switch (jobType) {
+            case AI_RECOMMENDATION:
+                return "AI";
+            case IMAGE_GENERATION:
+                return "IMG";
+            default:
+                return jobType.name().substring(0, Math.min(5, jobType.name().length()));
+        }
+    }
+
+    /**
+     * UUID 기반 랜덤 문자열 생성
+     *
+     * @return 8자리 랜덤 문자열 (소문자 영숫자)
+     */
+    private String generateRandomPart() {
+        return UUID.randomUUID()
+            .toString()
+            .replace("-", "")
+            .substring(0, RANDOM_LENGTH)
+            .toLowerCase();
+    }
+
+    /**
+     * jobId 기본 검증
+     *
+     * 최소한의 검증만 수행합니다:
+     * - null/empty 체크
+     * - 길이 제한 체크 (VARCHAR(50) 제약)
+     *
+     * @param jobId 검증할 Job ID
+     * @return 유효하면 true, 아니면 false
+     */
+    public boolean isValid(String jobId) {
+        if (jobId == null || jobId.isBlank()) {
+            return false;
+        }
+
+        // 길이 검증 (DB VARCHAR(50) 제약)
+        if (jobId.length() > 50) {
+            return false;
+        }
+
+        return true;
+    }
+}
--- a/event-service/src/main/java/com/kt/event/eventservice/application/service/JobService.java
+++ b/event-service/src/main/java/com/kt/event/eventservice/application/service/JobService.java
@ -11,8 +11,6 @@ import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;

-import java.util.UUID;
-
 /**
 * Job 서비스
 *
@ -29,6 +27,7 @@ import java.util.UUID;
 public class JobService {

    private final JobRepository jobRepository;
+    private final JobIdGenerator jobIdGenerator;

    /**
     * Job 생성
@ -38,10 +37,15 @@ public class JobService {
     * @return 생성된 Job
     */
    @Transactional
-    public Job createJob(UUID eventId, JobType jobType) {
+    public Job createJob(String eventId, JobType jobType) {
        log.info("Job 생성 - eventId: {}, jobType: {}", eventId, jobType);

+        // jobId 생성
+        String jobId = jobIdGenerator.generate(jobType);
+        log.info("생성된 jobId: {}", jobId);
+
        Job job = Job.builder()
+            .jobId(jobId)
            .eventId(eventId)
            .jobType(jobType)
            .build();
@ -59,7 +63,7 @@ public class JobService {
     * @param jobId Job ID
     * @return Job 상태 응답
     */
-    public JobStatusResponse getJobStatus(UUID jobId) {
+    public JobStatusResponse getJobStatus(String jobId) {
        log.info("Job 상태 조회 - jobId: {}", jobId);

        Job job = jobRepository.findById(jobId)
@ -75,7 +79,7 @@ public class JobService {
     * @param progress 진행률
     */
    @Transactional
-    public void updateJobProgress(UUID jobId, int progress) {
+    public void updateJobProgress(String jobId, int progress) {
        log.info("Job 진행률 업데이트 - jobId: {}, progress: {}", jobId, progress);

        Job job = jobRepository.findById(jobId)
@ -93,7 +97,7 @@ public class JobService {
     * @param resultKey Redis 결과 키
     */
    @Transactional
-    public void completeJob(UUID jobId, String resultKey) {
+    public void completeJob(String jobId, String resultKey) {
        log.info("Job 완료 - jobId: {}, resultKey: {}", jobId, resultKey);

        Job job = jobRepository.findById(jobId)
@ -113,7 +117,7 @@ public class JobService {
     * @param errorMessage 에러 메시지
     */
    @Transactional
-    public void failJob(UUID jobId, String errorMessage) {
+    public void failJob(String jobId, String errorMessage) {
        log.info("Job 실패 - jobId: {}, errorMessage: {}", jobId, errorMessage);

        Job job = jobRepository.findById(jobId)
--- a/event-service/src/main/java/com/kt/event/eventservice/application/service/NotificationService.java
+++ b/event-service/src/main/java/com/kt/event/eventservice/application/service/NotificationService.java
@ -1,7 +1,5 @@
 package com.kt.event.eventservice.application.service;

-import java.util.UUID;
-
 /**
 * 알림 서비스 인터페이스
 *
@ -22,7 +20,7 @@ public interface NotificationService {
     * @param jobType 작업 타입
     * @param message 알림 메시지
     */
-    void notifyJobCompleted(UUID userId, UUID jobId, String jobType, String message);
+    void notifyJobCompleted(String userId, String jobId, String jobType, String message);

    /**
     * 작업 실패 알림 전송
@ -32,7 +30,7 @@ public interface NotificationService {
     * @param jobType 작업 타입
     * @param errorMessage 에러 메시지
     */
-    void notifyJobFailed(UUID userId, UUID jobId, String jobType, String errorMessage);
+    void notifyJobFailed(String userId, String jobId, String jobType, String errorMessage);

    /**
     * 작업 진행 상태 알림 전송
@ -42,5 +40,5 @@ public interface NotificationService {
     * @param jobType 작업 타입
     * @param progress 진행률 (0-100)
     */
-    void notifyJobProgress(UUID userId, UUID jobId, String jobType, int progress);
+    void notifyJobProgress(String userId, String jobId, String jobType, int progress);
 }
--- a/event-service/src/main/java/com/kt/event/eventservice/config/DevAuthenticationFilter.java
+++ b/event-service/src/main/java/com/kt/event/eventservice/config/DevAuthenticationFilter.java
@ -11,7 +11,6 @@ import org.springframework.web.filter.OncePerRequestFilter;

 import java.io.IOException;
 import java.util.Collections;
-import java.util.UUID;

 /**
 * 개발 환경용 인증 필터
@ -35,11 +34,11 @@ public class DevAuthenticationFilter extends OncePerRequestFilter {

        // 개발용 기본 UserPrincipal 생성
        UserPrincipal userPrincipal = new UserPrincipal(
-                UUID.fromString("11111111-1111-1111-1111-111111111111"),  // userId
-                UUID.fromString("22222222-2222-2222-2222-222222222222"),  // storeId
-                "dev@test.com",                                            // email
-                "개발테스트사용자",                                           // name
-                Collections.singletonList("USER")                          // roles
+                "usr_dev_test_001",  // userId
+                "str_dev_test_001",  // storeId
+                "dev@test.com",      // email
+                "개발테스트사용자",      // name
+                Collections.singletonList("USER")  // roles
        );

        // Authentication 객체 생성 및 SecurityContext에 설정
--- a/event-service/src/main/java/com/kt/event/eventservice/config/KafkaConfig.java
+++ b/event-service/src/main/java/com/kt/event/eventservice/config/KafkaConfig.java
@ -37,7 +37,7 @@ public class KafkaConfig {

    /**
     * Kafka Producer 설정
-     * Producer에서 JSON 문자열을 보내므로 StringSerializer 사용
+     * Producer에서 객체를 직접 보내므로 JsonSerializer 사용
     *
     * @return ProducerFactory 인스턴스
     */
@ -46,7 +46,10 @@ public class KafkaConfig {
        Map<String, Object> config = new HashMap<>();
        config.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, bootstrapServers);
        config.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
-        config.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
+        config.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, JsonSerializer.class);
+
+        // JSON 직렬화 시 타입 정보를 헤더에 추가하지 않음 (마이크로서비스 간 DTO 클래스 불일치 방지)
+        config.put(JsonSerializer.ADD_TYPE_INFO_HEADERS, false);

        // Producer 성능 최적화 설정
        config.put(ProducerConfig.ACKS_CONFIG, "all");
--- a/event-service/src/main/java/com/kt/event/eventservice/config/SecurityConfig.java
+++ b/event-service/src/main/java/com/kt/event/eventservice/config/SecurityConfig.java
@ -72,6 +72,7 @@ public class SecurityConfig {
    /**
     * CORS 설정
     * 개발 환경에서 프론트엔드(localhost:3000)의 요청을 허용합니다.
+     * 쿠키 기반 인증을 위한 설정이 포함되어 있습니다.
     *
     * @return CorsConfigurationSource CORS 설정 소스
     */
@ -82,7 +83,10 @@ public class SecurityConfig {
        // 허용할 Origin (개발 환경)
        configuration.setAllowedOrigins(Arrays.asList(
            "http://localhost:3000",
-            "http://127.0.0.1:3000"
+            "http://127.0.0.1:3000",
+            "http://localhost:8081",
+            "http://localhost:8082",
+            "http://localhost:8083"
        ));

        // 허용할 HTTP 메서드
@ -90,7 +94,7 @@ public class SecurityConfig {
            "GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"
        ));

-        // 허용할 헤더
+        // 허용할 헤더 (쿠키 포함)
        configuration.setAllowedHeaders(Arrays.asList(
            "Authorization",
            "Content-Type",
@ -98,19 +102,21 @@ public class SecurityConfig {
            "Accept",
            "Origin",
            "Access-Control-Request-Method",
-            "Access-Control-Request-Headers"
+            "Access-Control-Request-Headers",
+            "Cookie"
        ));

-        // 인증 정보 포함 허용
+        // 인증 정보 포함 허용 (쿠키 전송을 위해 필수)
        configuration.setAllowCredentials(true);

        // Preflight 요청 캐시 시간 (초)
        configuration.setMaxAge(3600L);

-        // 노출할 응답 헤더
+        // 노출할 응답 헤더 (쿠키 포함)
        configuration.setExposedHeaders(Arrays.asList(
            "Authorization",
-            "Content-Type"
+            "Content-Type",
+            "Set-Cookie"
        ));

        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
--- a/event-service/src/main/java/com/kt/event/eventservice/domain/entity/AiRecommendation.java
+++ b/event-service/src/main/java/com/kt/event/eventservice/domain/entity/AiRecommendation.java
@ -3,9 +3,6 @@ package com.kt.event.eventservice.domain.entity;
 import com.kt.event.common.entity.BaseTimeEntity;
 import jakarta.persistence.*;
 import lombok.*;
-import org.hibernate.annotations.GenericGenerator;
-
-import java.util.UUID;

 /**
 * AI 추천 엔티티
@ -26,10 +23,8 @@ import java.util.UUID;
 public class AiRecommendation extends BaseTimeEntity {

    @Id
-    @GeneratedValue(generator = "uuid2")
-    @GenericGenerator(name = "uuid2", strategy = "uuid2")
-    @Column(name = "recommendation_id", columnDefinition = "uuid")
-    private UUID recommendationId;
+    @Column(name = "recommendation_id", length = 50)
+    private String recommendationId;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "event_id", nullable = false)
--- a/event-service/src/main/java/com/kt/event/eventservice/domain/entity/Event.java
+++ b/event-service/src/main/java/com/kt/event/eventservice/domain/entity/Event.java
@ -6,7 +6,6 @@ import jakarta.persistence.*;
 import lombok.*;
 import org.hibernate.annotations.Fetch;
 import org.hibernate.annotations.FetchMode;
-import org.hibernate.annotations.GenericGenerator;

 import java.time.LocalDate;
 import java.util.*;
@ -32,16 +31,14 @@ import java.util.*;
 public class Event extends BaseTimeEntity {

    @Id
-    @GeneratedValue(generator = "uuid2")
-    @GenericGenerator(name = "uuid2", strategy = "uuid2")
-    @Column(name = "event_id", columnDefinition = "uuid")
-    private UUID eventId;
+    @Column(name = "event_id", length = 50)
+    private String eventId;

-    @Column(name = "user_id", nullable = false, columnDefinition = "uuid")
-    private UUID userId;
+    @Column(name = "user_id", nullable = false, length = 50)
+    private String userId;

-    @Column(name = "store_id", nullable = false, columnDefinition = "uuid")
-    private UUID storeId;
+    @Column(name = "store_id", nullable = false, length = 50)
+    private String storeId;

    @Column(name = "event_name", length = 200)
    private String eventName;
@ -63,8 +60,8 @@ public class Event extends BaseTimeEntity {
    @Builder.Default
    private EventStatus status = EventStatus.DRAFT;

-    @Column(name = "selected_image_id", columnDefinition = "uuid")
-    private UUID selectedImageId;
+    @Column(name = "selected_image_id", length = 50)
+    private String selectedImageId;

    @Column(name = "selected_image_url", length = 500)
    private String selectedImageUrl;
@ -128,7 +125,7 @@ public class Event extends BaseTimeEntity {
    /**
     * 이미지 선택
     */
-    public void selectImage(UUID imageId, String imageUrl) {
+    public void selectImage(String imageId, String imageUrl) {
        this.selectedImageId = imageId;
        this.selectedImageUrl = imageUrl;

--- a/event-service/src/main/java/com/kt/event/eventservice/domain/entity/GeneratedImage.java
+++ b/event-service/src/main/java/com/kt/event/eventservice/domain/entity/GeneratedImage.java
@ -3,9 +3,6 @@ package com.kt.event.eventservice.domain.entity;
 import com.kt.event.common.entity.BaseTimeEntity;
 import jakarta.persistence.*;
 import lombok.*;
-import org.hibernate.annotations.GenericGenerator;
-
-import java.util.UUID;

 /**
 * 생성된 이미지 엔티티
@ -26,10 +23,8 @@ import java.util.UUID;
 public class GeneratedImage extends BaseTimeEntity {

    @Id
-    @GeneratedValue(generator = "uuid2")
-    @GenericGenerator(name = "uuid2", strategy = "uuid2")
-    @Column(name = "image_id", columnDefinition = "uuid")
-    private UUID imageId;
+    @Column(name = "image_id", length = 50)
+    private String imageId;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "event_id", nullable = false)
--- a/event-service/src/main/java/com/kt/event/eventservice/domain/entity/Job.java
+++ b/event-service/src/main/java/com/kt/event/eventservice/domain/entity/Job.java
@ -5,10 +5,8 @@ import com.kt.event.eventservice.domain.enums.JobStatus;
 import com.kt.event.eventservice.domain.enums.JobType;
 import jakarta.persistence.*;
 import lombok.*;
-import org.hibernate.annotations.GenericGenerator;

 import java.time.LocalDateTime;
-import java.util.UUID;

 /**
 * 비동기 작업 엔티티
@ -29,13 +27,11 @@ import java.util.UUID;
 public class Job extends BaseTimeEntity {

    @Id
-    @GeneratedValue(generator = "uuid2")
-    @GenericGenerator(name = "uuid2", strategy = "uuid2")
-    @Column(name = "job_id", columnDefinition = "uuid")
-    private UUID jobId;
+    @Column(name = "job_id", length = 50)
+    private String jobId;

-    @Column(name = "event_id", nullable = false, columnDefinition = "uuid")
-    private UUID eventId;
+    @Column(name = "event_id", nullable = false, length = 50)
+    private String eventId;

    @Enumerated(EnumType.STRING)
    @Column(name = "job_type", nullable = false, length = 30)
--- a/event-service/src/main/java/com/kt/event/eventservice/domain/repository/AiRecommendationRepository.java
+++ b/event-service/src/main/java/com/kt/event/eventservice/domain/repository/AiRecommendationRepository.java
@ -5,7 +5,6 @@ import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.stereotype.Repository;

 import java.util.List;
-import java.util.UUID;

 /**
 * AI 추천 Repository
@ -15,15 +14,15 @@ import java.util.UUID;
 * @since 2025-10-23
 */
@Repository
-public interface AiRecommendationRepository extends JpaRepository<AiRecommendation, UUID> {
+public interface AiRecommendationRepository extends JpaRepository<AiRecommendation, String> {

    /**
     * 이벤트별 AI 추천 목록 조회
     */
-    List<AiRecommendation> findByEventEventId(UUID eventId);
+    List<AiRecommendation> findByEventEventId(String eventId);

    /**
     * 이벤트별 선택된 AI 추천 조회
     */
-    AiRecommendation findByEventEventIdAndIsSelectedTrue(UUID eventId);
+    AiRecommendation findByEventEventIdAndIsSelectedTrue(String eventId);
 }
--- a/event-service/src/main/java/com/kt/event/eventservice/domain/repository/EventRepository.java
+++ b/event-service/src/main/java/com/kt/event/eventservice/domain/repository/EventRepository.java
@ -10,7 +10,6 @@ import org.springframework.data.repository.query.Param;
 import org.springframework.stereotype.Repository;

 import java.util.Optional;
-import java.util.UUID;

 /**
 * 이벤트 Repository
@ -20,7 +19,12 @@ import java.util.UUID;
 * @since 2025-10-23
 */
@Repository
-public interface EventRepository extends JpaRepository<Event, UUID> {
+public interface EventRepository extends JpaRepository<Event, String> {
+
+    /**
+     * 이벤트 ID로 조회
+     */
+    Optional<Event> findByEventId(String eventId);

    /**
     * 사용자 ID와 이벤트 ID로 조회
@ -29,8 +33,8 @@ public interface EventRepository extends JpaRepository<Event, UUID> {
           "LEFT JOIN FETCH e.channels " +
           "WHERE e.eventId = :eventId AND e.userId = :userId")
    Optional<Event> findByEventIdAndUserId(
-        @Param("eventId") UUID eventId,
-        @Param("userId") UUID userId
+        @Param("eventId") String eventId,
+        @Param("userId") String userId
    );

    /**
@ -42,7 +46,7 @@ public interface EventRepository extends JpaRepository<Event, UUID> {
           "AND (:search IS NULL OR e.eventName LIKE %:search%) " +
           "AND (:objective IS NULL OR e.objective = :objective)")
    Page<Event> findEventsByUser(
-        @Param("userId") UUID userId,
+        @Param("userId") String userId,
        @Param("status") EventStatus status,
        @Param("search") String search,
        @Param("objective") String objective,
@ -52,5 +56,5 @@ public interface EventRepository extends JpaRepository<Event, UUID> {
    /**
     * 사용자별 이벤트 개수 조회 (상태별)
     */
-    long countByUserIdAndStatus(UUID userId, EventStatus status);
+    long countByUserIdAndStatus(String userId, EventStatus status);
 }
--- a/event-service/src/main/java/com/kt/event/eventservice/domain/repository/GeneratedImageRepository.java
+++ b/event-service/src/main/java/com/kt/event/eventservice/domain/repository/GeneratedImageRepository.java
@ -5,7 +5,6 @@ import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.stereotype.Repository;

 import java.util.List;
-import java.util.UUID;

 /**
 * 생성된 이미지 Repository
@ -15,15 +14,15 @@ import java.util.UUID;
 * @since 2025-10-23
 */
@Repository
-public interface GeneratedImageRepository extends JpaRepository<GeneratedImage, UUID> {
+public interface GeneratedImageRepository extends JpaRepository<GeneratedImage, String> {

    /**
     * 이벤트별 생성된 이미지 목록 조회
     */
-    List<GeneratedImage> findByEventEventId(UUID eventId);
+    List<GeneratedImage> findByEventEventId(String eventId);

    /**
     * 이벤트별 선택된 이미지 조회
     */
-    GeneratedImage findByEventEventIdAndIsSelectedTrue(UUID eventId);
+    GeneratedImage findByEventEventIdAndIsSelectedTrue(String eventId);
 }
--- a/event-service/src/main/java/com/kt/event/eventservice/domain/repository/JobRepository.java
+++ b/event-service/src/main/java/com/kt/event/eventservice/domain/repository/JobRepository.java
@ -8,7 +8,6 @@ import org.springframework.stereotype.Repository;

 import java.util.List;
 import java.util.Optional;
-import java.util.UUID;

 /**
 * 비동기 작업 Repository
@ -18,22 +17,22 @@ import java.util.UUID;
 * @since 2025-10-23
 */
@Repository
-public interface JobRepository extends JpaRepository<Job, UUID> {
+public interface JobRepository extends JpaRepository<Job, String> {

    /**
     * 이벤트별 작업 목록 조회
     */
-    List<Job> findByEventId(UUID eventId);
+    List<Job> findByEventId(String eventId);

    /**
     * 이벤트 및 작업 유형별 조회
     */
-    Optional<Job> findByEventIdAndJobType(UUID eventId, JobType jobType);
+    Optional<Job> findByEventIdAndJobType(String eventId, JobType jobType);

    /**
     * 이벤트 및 작업 유형별 최신 작업 조회
     */
-    Optional<Job> findFirstByEventIdAndJobTypeOrderByCreatedAtDesc(UUID eventId, JobType jobType);
+    Optional<Job> findFirstByEventIdAndJobTypeOrderByCreatedAtDesc(String eventId, JobType jobType);

    /**
     * 상태별 작업 목록 조회
--- a/event-service/src/main/java/com/kt/event/eventservice/infrastructure/kafka/AIJobKafkaConsumer.java.bak
+++ b/event-service/src/main/java/com/kt/event/eventservice/infrastructure/kafka/AIJobKafkaConsumer.java.bak
@ -18,8 +18,6 @@ import org.springframework.messaging.handler.annotation.Payload;
 import org.springframework.stereotype.Component;
 import org.springframework.transaction.annotation.Transactional;

-import java.util.UUID;
-
 /**
 * AI 이벤트 생성 작업 메시지 구독 Consumer
 *
@ -30,7 +28,8 @@ import java.util.UUID;
 * @since 2025-10-29
 */
@Slf4j
-@Component
+// TODO: 별도 response 토픽 사용 시 활성화
+// @Component
@RequiredArgsConstructor
 public class AIJobKafkaConsumer {

@ -93,7 +92,7 @@ public class AIJobKafkaConsumer {
    @Transactional
    protected void processAIEventGenerationJob(AIEventGenerationJobMessage message) {
        try {
-            UUID jobId = UUID.fromString(message.getJobId());
+            String jobId = message.getJobId();

            // Job 조회
            Job job = jobRepository.findById(jobId).orElse(null);
@ -102,7 +101,7 @@ public class AIJobKafkaConsumer {
                return;
            }

-            UUID eventId = job.getEventId();
+            String eventId = job.getEventId();

            // Event 조회 (모든 케이스에서 사용)
            Event event = eventRepository.findById(eventId).orElse(null);
@ -142,7 +141,7 @@ public class AIJobKafkaConsumer {
                            eventId, aiData.getEventTitle());

                        // 사용자에게 알림 전송
-                        UUID userId = event.getUserId();
+                        String userId = event.getUserId();
                        notificationService.notifyJobCompleted(
                            userId,
                            jobId,
@ -166,7 +165,7 @@ public class AIJobKafkaConsumer {

                    // 사용자에게 실패 알림 전송
                    if (event != null) {
-                        UUID userId = event.getUserId();
+                        String userId = event.getUserId();
                        notificationService.notifyJobFailed(
                            userId,
                            jobId,
@ -185,7 +184,7 @@ public class AIJobKafkaConsumer {

                    // 사용자에게 진행 상태 알림 전송
                    if (event != null) {
-                        UUID userId = event.getUserId();
+                        String userId = event.getUserId();
                        notificationService.notifyJobProgress(
                            userId,
                            jobId,
--- a/event-service/src/main/java/com/kt/event/eventservice/infrastructure/kafka/AIJobKafkaProducer.java
+++ b/event-service/src/main/java/com/kt/event/eventservice/infrastructure/kafka/AIJobKafkaProducer.java
@ -1,6 +1,5 @@
 package com.kt.event.eventservice.infrastructure.kafka;

-import com.fasterxml.jackson.databind.ObjectMapper;
 import com.kt.event.eventservice.application.dto.kafka.AIEventGenerationJobMessage;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
@ -27,7 +26,6 @@ import java.util.concurrent.CompletableFuture;
 public class AIJobKafkaProducer {

    private final KafkaTemplate<String, Object> kafkaTemplate;
-    private final ObjectMapper objectMapper;

    @Value("${app.kafka.topics.ai-event-generation-job:ai-event-generation-job}")
    private String aiEventGenerationJobTopic;
@ -35,28 +33,38 @@ public class AIJobKafkaProducer {
    /**
     * AI 이벤트 생성 작업 메시지 발행
     *
-     * @param jobId 작업 ID (UUID String)
-     * @param userId 사용자 ID (UUID String)
-     * @param eventId 이벤트 ID (UUID String)
+     * @param jobId 작업 ID (JOB-{type}-{timestamp}-{random8})
+     * @param userId 사용자 ID
+     * @param eventId 이벤트 ID (EVT-{storeId}-{yyyyMMddHHmmss}-{random8})
     * @param storeName 매장명
-     * @param storeCategory 매장 업종
-     * @param storeDescription 매장 설명
+     * @param industry 업종 (매장 카테고리)
+     * @param region 지역
     * @param objective 이벤트 목적
+     * @param targetAudience 목표 고객층 (선택)
+     * @param budget 예산 (선택)
     */
    public void publishAIGenerationJob(
            String jobId,
            String userId,
            String eventId,
            String storeName,
-            String storeCategory,
-            String storeDescription,
-            String objective) {
+            String industry,
+            String region,
+            String objective,
+            String targetAudience,
+            Integer budget) {

        AIEventGenerationJobMessage message = AIEventGenerationJobMessage.builder()
            .jobId(jobId)
            .userId(userId)
-            .status("PENDING")
-            .createdAt(LocalDateTime.now())
+            .eventId(eventId)
+            .storeName(storeName)
+            .industry(industry)
+            .region(region)
+            .objective(objective)
+            .targetAudience(targetAudience)
+            .budget(budget)
+            .requestedAt(LocalDateTime.now())
            .build();

        publishMessage(message);
@ -69,11 +77,9 @@ public class AIJobKafkaProducer {
     */
    public void publishMessage(AIEventGenerationJobMessage message) {
        try {
-            // JSON 문자열로 변환
-            String jsonMessage = objectMapper.writeValueAsString(message);
-
+            // 객체를 직접 전송 (JsonSerializer가 자동으로 직렬화)
            CompletableFuture<SendResult<String, Object>> future =
-                kafkaTemplate.send(aiEventGenerationJobTopic, message.getJobId(), jsonMessage);
+                kafkaTemplate.send(aiEventGenerationJobTopic, message.getJobId(), message);

            future.whenComplete((result, ex) -> {
                if (ex == null) {
--- a/event-service/src/main/java/com/kt/event/eventservice/infrastructure/kafka/EventKafkaProducer.java
+++ b/event-service/src/main/java/com/kt/event/eventservice/infrastructure/kafka/EventKafkaProducer.java
@ -29,12 +29,12 @@ public class EventKafkaProducer {
    /**
     * 이벤트 생성 완료 메시지 발행
     *
-     * @param eventId 이벤트 ID (UUID)
-     * @param userId 사용자 ID (UUID)
+     * @param eventId 이벤트 ID
+     * @param userId 사용자 ID
     * @param title 이벤트 제목
     * @param eventType 이벤트 타입
     */
-    public void publishEventCreated(java.util.UUID eventId, java.util.UUID userId, String title, String eventType) {
+    public void publishEventCreated(String eventId, String userId, String title, String eventType) {
        EventCreatedMessage message = EventCreatedMessage.builder()
            .eventId(eventId)
            .userId(userId)
--- a/event-service/src/main/java/com/kt/event/eventservice/infrastructure/kafka/ImageJobKafkaConsumer.java
+++ b/event-service/src/main/java/com/kt/event/eventservice/infrastructure/kafka/ImageJobKafkaConsumer.java
@ -18,8 +18,6 @@ import org.springframework.messaging.handler.annotation.Payload;
 import org.springframework.stereotype.Component;
 import org.springframework.transaction.annotation.Transactional;

-import java.util.UUID;
-
 /**
 * 이미지 생성 작업 메시지 구독 Consumer
 *
@ -94,8 +92,8 @@ public class ImageJobKafkaConsumer {
    @Transactional
    protected void processImageGenerationJob(ImageGenerationJobMessage message) {
        try {
-            UUID jobId = UUID.fromString(message.getJobId());
-            UUID eventId = UUID.fromString(message.getEventId());
+            String jobId = message.getJobId();
+            String eventId = message.getEventId();

            // Job 조회
            Job job = jobRepository.findById(jobId).orElse(null);
@ -130,7 +128,7 @@ public class ImageJobKafkaConsumer {
                            eventId, message.getImageUrl());

                        // 사용자에게 알림 전송
-                        UUID userId = event.getUserId();
+                        String userId = event.getUserId();
                        notificationService.notifyJobCompleted(
                            userId,
                            jobId,
@ -181,7 +179,7 @@ public class ImageJobKafkaConsumer {

                        // 사용자에게 실패 알림 전송
                        if (event != null) {
-                            UUID userId = event.getUserId();
+                            String userId = event.getUserId();
                            notificationService.notifyJobFailed(
                                userId,
                                jobId,
@ -202,7 +200,7 @@ public class ImageJobKafkaConsumer {

                    // 사용자에게 진행 상태 알림 전송
                    if (event != null) {
-                        UUID userId = event.getUserId();
+                        String userId = event.getUserId();
                        notificationService.notifyJobProgress(
                            userId,
                            jobId,
--- a/event-service/src/main/java/com/kt/event/eventservice/infrastructure/kafka/ImageJobKafkaProducer.java
+++ b/event-service/src/main/java/com/kt/event/eventservice/infrastructure/kafka/ImageJobKafkaProducer.java
@ -35,9 +35,9 @@ public class ImageJobKafkaProducer {
    /**
     * 이미지 생성 작업 메시지 발행
     *
-     * @param jobId 작업 ID (UUID)
-     * @param userId 사용자 ID (UUID)
-     * @param eventId 이벤트 ID (UUID)
+     * @param jobId 작업 ID (JOB-{type}-{timestamp}-{random8})
+     * @param userId 사용자 ID
+     * @param eventId 이벤트 ID (EVT-{storeId}-{yyyyMMddHHmmss}-{random8})
     * @param prompt 이미지 생성 프롬프트
     */
    public void publishImageGenerationJob(
--- a/event-service/src/main/java/com/kt/event/eventservice/infrastructure/notification/LoggingNotificationService.java
+++ b/event-service/src/main/java/com/kt/event/eventservice/infrastructure/notification/LoggingNotificationService.java
@ -4,8 +4,6 @@ import com.kt.event.eventservice.application.service.NotificationService;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;

-import java.util.UUID;
-
 /**
 * 로깅 기반 알림 서비스 구현
 *
@ -20,16 +18,16 @@ import java.util.UUID;
 public class LoggingNotificationService implements NotificationService {

    @Override
-    public void notifyJobCompleted(UUID userId, UUID jobId, String jobType, String message) {
+    public void notifyJobCompleted(String userId, String jobId, String jobType, String message) {
        log.info("📢 [작업 완료 알림] UserId: {}, JobId: {}, JobType: {}, Message: {}",
            userId, jobId, jobType, message);

        // TODO: WebSocket, SSE, 또는 Push Notification으로 실시간 알림 전송
-        // 예: webSocketTemplate.convertAndSendToUser(userId.toString(), "/queue/notifications", notification);
+        // 예: webSocketTemplate.convertAndSendToUser(userId, "/queue/notifications", notification);
    }

    @Override
-    public void notifyJobFailed(UUID userId, UUID jobId, String jobType, String errorMessage) {
+    public void notifyJobFailed(String userId, String jobId, String jobType, String errorMessage) {
        log.error("📢 [작업 실패 알림] UserId: {}, JobId: {}, JobType: {}, Error: {}",
            userId, jobId, jobType, errorMessage);

@ -37,7 +35,7 @@ public class LoggingNotificationService implements NotificationService {
    }

    @Override
-    public void notifyJobProgress(UUID userId, UUID jobId, String jobType, int progress) {
+    public void notifyJobProgress(String userId, String jobId, String jobType, int progress) {
        log.info("📢 [작업 진행 알림] UserId: {}, JobId: {}, JobType: {}, Progress: {}%",
            userId, jobId, jobType, progress);

--- a/event-service/src/main/java/com/kt/event/eventservice/presentation/controller/EventController.java
+++ b/event-service/src/main/java/com/kt/event/eventservice/presentation/controller/EventController.java
@ -21,8 +21,6 @@ import org.springframework.http.ResponseEntity;
 import org.springframework.security.core.annotation.AuthenticationPrincipal;
 import org.springframework.web.bind.annotation.*;

-import java.util.UUID;
-
 /**
 * 이벤트 컨트롤러
 *
@ -34,7 +32,7 @@ import java.util.UUID;
 */
@Slf4j
@RestController
-@RequestMapping("/api/v1/events")
+@RequestMapping("/events")
@RequiredArgsConstructor
@Tag(name = "Event", description = "이벤트 관리 API")
 public class EventController {
@ -129,7 +127,7 @@ public class EventController {
    @GetMapping("/{eventId}")
    @Operation(summary = "이벤트 상세 조회", description = "특정 이벤트의 상세 정보를 조회합니다.")
    public ResponseEntity<ApiResponse<EventDetailResponse>> getEvent(
-            @PathVariable UUID eventId,
+            @PathVariable String eventId,
            @AuthenticationPrincipal UserPrincipal userPrincipal) {

        log.info("이벤트 상세 조회 API 호출 - userId: {}, eventId: {}",
@ -150,7 +148,7 @@ public class EventController {
    @DeleteMapping("/{eventId}")
    @Operation(summary = "이벤트 삭제", description = "이벤트를 삭제합니다. DRAFT 상태만 삭제 가능합니다.")
    public ResponseEntity<ApiResponse<Void>> deleteEvent(
-            @PathVariable UUID eventId,
+            @PathVariable String eventId,
            @AuthenticationPrincipal UserPrincipal userPrincipal) {

        log.info("이벤트 삭제 API 호출 - userId: {}, eventId: {}",
@ -171,7 +169,7 @@ public class EventController {
    @PostMapping("/{eventId}/publish")
    @Operation(summary = "이벤트 배포", description = "이벤트를 배포합니다. DRAFT → PUBLISHED 상태 변경.")
    public ResponseEntity<ApiResponse<Void>> publishEvent(
-            @PathVariable UUID eventId,
+            @PathVariable String eventId,
            @AuthenticationPrincipal UserPrincipal userPrincipal) {

        log.info("이벤트 배포 API 호출 - userId: {}, eventId: {}",
@ -192,7 +190,7 @@ public class EventController {
    @PostMapping("/{eventId}/end")
    @Operation(summary = "이벤트 종료", description = "이벤트를 종료합니다. PUBLISHED → ENDED 상태 변경.")
    public ResponseEntity<ApiResponse<Void>> endEvent(
-            @PathVariable UUID eventId,
+            @PathVariable String eventId,
            @AuthenticationPrincipal UserPrincipal userPrincipal) {

        log.info("이벤트 종료 API 호출 - userId: {}, eventId: {}",
@ -214,7 +212,7 @@ public class EventController {
    @PostMapping("/{eventId}/images")
    @Operation(summary = "이미지 생성 요청", description = "AI를 통해 이벤트 이미지를 생성합니다.")
    public ResponseEntity<ApiResponse<ImageGenerationResponse>> requestImageGeneration(
-            @PathVariable UUID eventId,
+            @PathVariable String eventId,
            @Valid @RequestBody ImageGenerationRequest request,
            @AuthenticationPrincipal UserPrincipal userPrincipal) {

@ -243,8 +241,8 @@ public class EventController {
    @PutMapping("/{eventId}/images/{imageId}/select")
    @Operation(summary = "이미지 선택", description = "생성된 이미지 중 하나를 선택합니다.")
    public ResponseEntity<ApiResponse<Void>> selectImage(
-            @PathVariable UUID eventId,
-            @PathVariable UUID imageId,
+            @PathVariable String eventId,
+            @PathVariable String imageId,
            @Valid @RequestBody SelectImageRequest request,
            @AuthenticationPrincipal UserPrincipal userPrincipal) {

@ -272,7 +270,7 @@ public class EventController {
    @PostMapping("/{eventId}/ai-recommendations")
    @Operation(summary = "AI 추천 요청", description = "AI 서비스에 이벤트 추천 생성을 요청합니다.")
    public ResponseEntity<ApiResponse<JobAcceptedResponse>> requestAiRecommendations(
-            @PathVariable UUID eventId,
+            @PathVariable String eventId,
            @Valid @RequestBody AiRecommendationRequest request,
            @AuthenticationPrincipal UserPrincipal userPrincipal) {

@ -300,7 +298,7 @@ public class EventController {
    @PutMapping("/{eventId}/recommendations")
    @Operation(summary = "AI 추천 선택", description = "AI가 생성한 추천 중 하나를 선택하고 커스터마이징합니다.")
    public ResponseEntity<ApiResponse<Void>> selectRecommendation(
-            @PathVariable UUID eventId,
+            @PathVariable String eventId,
            @Valid @RequestBody SelectRecommendationRequest request,
            @AuthenticationPrincipal UserPrincipal userPrincipal) {

@ -328,8 +326,8 @@ public class EventController {
    @PutMapping("/{eventId}/images/{imageId}/edit")
    @Operation(summary = "이미지 편집", description = "선택된 이미지를 편집합니다.")
    public ResponseEntity<ApiResponse<ImageEditResponse>> editImage(
-            @PathVariable UUID eventId,
-            @PathVariable UUID imageId,
+            @PathVariable String eventId,
+            @PathVariable String imageId,
            @Valid @RequestBody ImageEditRequest request,
            @AuthenticationPrincipal UserPrincipal userPrincipal) {

@ -357,7 +355,7 @@ public class EventController {
    @PutMapping("/{eventId}/channels")
    @Operation(summary = "배포 채널 선택", description = "이벤트를 배포할 채널을 선택합니다.")
    public ResponseEntity<ApiResponse<Void>> selectChannels(
-            @PathVariable UUID eventId,
+            @PathVariable String eventId,
            @Valid @RequestBody SelectChannelsRequest request,
            @AuthenticationPrincipal UserPrincipal userPrincipal) {

@ -384,7 +382,7 @@ public class EventController {
    @PutMapping("/{eventId}")
    @Operation(summary = "이벤트 수정", description = "기존 이벤트의 정보를 수정합니다. DRAFT 상태만 수정 가능합니다.")
    public ResponseEntity<ApiResponse<EventDetailResponse>> updateEvent(
-            @PathVariable UUID eventId,
+            @PathVariable String eventId,
            @Valid @RequestBody UpdateEventRequest request,
            @AuthenticationPrincipal UserPrincipal userPrincipal) {

--- a/Show More
+++ b/Show More