# Qwen-Image-Layered 클라우드 전환 (10/10): 운영 가이드 및 여정 회고

## 시리즈 완결: 무엇을 이뤘나

10부작 여정을 통해 완성한 것:

```
v1: 로컬 GPU의 한계 인식
  ↓
v2: Hugging Face vs Vertex AI 비교 분석
  ↓
v3: Hugging Face 실전 테스트 (한계 확인)
  ↓
v4: Vertex AI Model Garden 배포 성공
  ↓
v5: FastAPI 백엔드 클라우드 통합
  ↓
v6: 비용 최적화 (95% 절감)
  ↓
v7: 성능 벤치마크 (정량적 검증)
  ↓
v8: 하이브리드 아키텍처 (복원력 확보)
  ↓
v9: 비용 모니터링 대시보드
  ↓
v10: [현재글] 운영 가이드
```

**핵심 성과**:
- ✅ 하드웨어 독립성 달성
- ✅ 무한 확장성 확보
- ✅ 비용 95% 절감 (로컬 GPU 대비)
- ✅ 운영 복잡도 대폭 감소

## 프로덕션 배포 체크리스트

### Phase 1: 인프라 준비

```markdown
□ Google Cloud 프로젝트 생성
□ 결제 계정 연결 및 예산 알림 설정 ($50/month)
□ Vertex AI API 활성화
□ 서비스 계정 생성 및 권한 부여
□ Docker 이미지 빌드 및 GCR 푸시
□ Vertex AI 엔드포인트 배포 (최소 인스턴스 = 0)
□ Redis 인스턴스 생성 (Memorystore 또는 Docker)
□ Cloud Storage 버킷 생성 (결과 저장용)
```

### Phase 2: 애플리케이션 배포

```markdown
□ FastAPI 서버 Docker 이미지 빌드
□ Worker Docker 이미지 빌드
□ docker-compose.yml 작성
□ 환경 변수 설정 (.env)
□ Nginx 리버스 프록시 설정
□ SSL 인증서 설정 (Let's Encrypt)
□ DNS 설정
□ 헬스 체크 엔드포인트 테스트
```

### Phase 3: 모니터링 설정

```markdown
□ Prometheus 설치 및 설정
□ Grafana 설치 및 대시보드 구성
□ Slack Webhook 생성
□ 비용 알림 스크립트 배포
□ 로그 수집 (ELK 또는 Cloud Logging)
□ Uptime 모니터링 (UptimeRobot)
```

### Phase 4: 테스트

```markdown
□ 단위 테스트 (pytest)
□ 통합 테스트 (API 엔드포인트)
□ 부하 테스트 (locust 또는 k6)
□ Cold Start 시나리오 테스트
□ 폴백 체인 테스트 (Vertex AI 강제 실패)
□ 캐싱 동작 확인
```

## Docker Compose 배포

### 전체 스택 구성

```yaml
# docker-compose.yml
version: '3.8'

services:
  api:
    build: ./backend
    ports:
      - "8000:8000"
    environment:
      - VERTEX_AI_PROJECT_ID=${VERTEX_AI_PROJECT_ID}
      - VERTEX_AI_LOCATION=${VERTEX_AI_LOCATION}
      - VERTEX_AI_ENDPOINT_ID=${VERTEX_AI_ENDPOINT_ID}
      - REDIS_HOST=redis
      - GOOGLE_APPLICATION_CREDENTIALS=/app/credentials.json
    volumes:
      - ./vertex-ai-key.json:/app/credentials.json:ro
      - ./storage:/app/storage
    depends_on:
      - redis

  worker:
    build: ./backend
    command: python worker.py
    environment:
      - VERTEX_AI_PROJECT_ID=${VERTEX_AI_PROJECT_ID}
      - VERTEX_AI_LOCATION=${VERTEX_AI_LOCATION}
      - VERTEX_AI_ENDPOINT_ID=${VERTEX_AI_ENDPOINT_ID}
      - REDIS_HOST=redis
      - GOOGLE_APPLICATION_CREDENTIALS=/app/credentials.json
    volumes:
      - ./vertex-ai-key.json:/app/credentials.json:ro
      - ./storage:/app/storage
    depends_on:
      - redis
    deploy:
      replicas: 2  # Worker 2개 실행

  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"
    volumes:
      - redis_data:/data

  prometheus:
    image: prom/prometheus
    ports:
      - "9090:9090"
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
      - prometheus_data:/prometheus

  grafana:
    image: grafana/grafana
    ports:
      - "3000:3000"
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=admin
    volumes:
      - grafana_data:/var/lib/grafana

  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf:ro
      - ./ssl:/etc/nginx/ssl:ro
    depends_on:
      - api

volumes:
  redis_data:
  prometheus_data:
  grafana_data:
```

### 배포 명령어

```bash
# 1. 환경 변수 설정
cp .env.example .env
nano .env  # 값 입력

# 2. 빌드
docker-compose build

# 3. 실행
docker-compose up -d

# 4. 로그 확인
docker-compose logs -f api worker

# 5. 헬스 체크
curl http://localhost:8000/health

# 6. 중단
docker-compose down
```

## 일반적인 문제 해결

### 문제 1: "Vertex AI quota exceeded"

**증상**:
```
ResourceExhausted: 429 Quota exceeded for aiplatform.googleapis.com/online_prediction_requests_per_base_model
```

**해결**:

```bash
# 1. 현재 할당량 확인
gcloud compute project-info describe --project=PROJECT_ID

# 2. 할당량 증가 요청
Google Cloud Console → IAM & Admin → Quotas
→ "Vertex AI online prediction requests" 검색
→ "EDIT QUOTAS" 클릭
→ 증가 요청 (예: 100 → 1000)

# 3. 임시 조치: Rate Limiting 추가
# worker.py에 sleep 추가
await asyncio.sleep(0.5)  # 요청 간격 조절
```

### 문제 2: "Cold Start too slow"

**증상**: 첫 요청 시 3-4분 대기

**해결**:

```python
# scripts/keep_warm.py
from google.cloud import aiplatform
import time

def keep_warm():
    """5분마다 더미 요청 전송"""
    endpoint = aiplatform.Endpoint(ENDPOINT_NAME)

    while True:
        try:
            # 최소 크기 이미지로 빠른 요청
            endpoint.predict(
                instances=[{
                    "image": DUMMY_IMAGE_B64,
                    "layers": 1,
                    "resolution": 512
                }],
                timeout=60
            )
            print("✅ Keep-warm request sent")
        except:
            pass

        time.sleep(300)  # 5분

if __name__ == "__main__":
    keep_warm()
```

**또는 최소 인스턴스 1로 설정** (비용 증가 감수)

### 문제 3: "Redis connection timeout"

**증상**:
```
redis.exceptions.ConnectionError: Error connecting to Redis
```

**해결**:

```bash
# 1. Redis 상태 확인
docker-compose ps redis
docker-compose logs redis

# 2. Redis 재시작
docker-compose restart redis

# 3. 연결 설정 확인
# config.py
redis_host = "redis"  # Docker Compose 서비스 이름
redis_port = 6379
redis_db = 0
```

### 문제 4: "High costs"

**증상**: 월 비용이 예산 초과

**해결**:

```python
# 1. 비용 분석
python scripts/weekly_cost_report.py

# 2. 최적화 제안 확인
curl http://localhost:8000/api/cost/suggestions

# 3. 주요 최적화
# - 캐싱 활성화 (20% 절감)
# - Spot Instances 사용 (70% 절감)
# - 시간대별 스케일링 (62% 절감)
# - 배치 처리 (50% 절감)

# 4. 긴급 조치: 최소 인스턴스 0으로 설정
gcloud ai endpoints update ENDPOINT_ID \
    --region=us-central1 \
    --min-replica-count=0
```

## 운영 루틴

### 일일 체크

```bash
# 1. 헬스 체크
curl https://your-domain.com/health

# 2. 비용 확인
curl https://your-domain.com/api/cost/today

# 3. 백엔드 상태
curl https://your-domain.com/api/health/backends

# 4. 로그 확인 (최근 100줄)
docker-compose logs --tail=100 api worker
```

### 주간 리뷰

```bash
# 1. 비용 리포트
python scripts/weekly_cost_report.py

# 2. 성능 분석
# Grafana 대시보드 확인
# - 평균 응답 시간
# - 에러율
# - 백엔드 사용 분포

# 3. 최적화 제안
python scripts/cost_optimizer.py
```

### 월간 작업

```markdown
□ 비용 리포트 생성 및 검토
□ 보안 패치 적용 (Docker 이미지 업데이트)
□ 로그 정리 (90일 이상 데이터 삭제)
□ 백업 확인 (Redis 스냅샷)
□ SSL 인증서 갱신 확인
□ Vertex AI 모델 버전 업데이트 검토
```

## 프로젝트 회고

### 무엇이 잘 되었나

**1. 클라우드 전환 결정**
- 하드웨어 종속성 제거
- 운영 복잡도 대폭 감소
- 비용 효율성 극대화

**2. 하이브리드 아키텍처**
- 단일 장애점 제거
- Vertex AI 장애 시에도 서비스 유지
- 복원력 확보

**3. 모니터링 우선**
- 비용 가시성 확보로 예산 관리 용이
- 문제 조기 발견 및 해결

**4. 점진적 최적화**
- 기본 구현 → 벤치마크 → 최적화 순서
- 측정하지 않은 것은 개선하지 않음

### 어려웠던 점

**1. Vertex AI 배포 복잡도**
- Model Garden UI는 인기 모델만
- 커스텀 모델은 Docker 이미지 직접 빌드 필요
- 학습 곡선이 가파름

**해결**: 공식 문서 + 커뮤니티 + 시행착오

**2. Cold Start 문제**
- 3-4분은 UX에 치명적
- 최소 인스턴스 1 유지는 비용 부담

**절충안**: 업무 시간만 최소 1, 야간은 0

**3. 비용 예측의 어려움**
- 초기에는 실제 비용 예측 불가능
- 사용 패턴에 따라 크게 변동

**해결**: 소규모로 시작 → 점진적 확대 + 모니터링

### 배운 교훈

**1. "클라우드는 항상 비싸다"는 편견 깨기**
- 적극적 최적화로 로컬 GPU보다 저렴
- Pay-as-you-go가 핵심

**2. "완벽한 시스템"보다 "점진적 개선"**
- v1에서 모든 최적화를 넣으려 하지 말 것
- 동작하는 시스템 → 측정 → 개선

**3. "모니터링은 선택이 아니라 필수"**
- 비용과 성능 가시성 없이는 최적화 불가능

**4. "폴백 전략의 중요성"**
- 클라우드도 장애는 발생함
- 하이브리드 아키텍처로 복원력 확보

## 향후 개선 방향

### 단기 (1-3개월)

```markdown
□ WebSocket 실시간 진행 상황 개선
  - 현재: 1초마다 폴링
  - 개선: 실시간 Server-Sent Events

□ 배치 처리 API 추가
  - 여러 이미지 동시 업로드
  - ZIP 파일 업로드 지원

□ 레이어 편집 기능
  - 브라우저 내 간단한 편집 (이동, 크기 조정)
  - Qwen-Image-Edit 통합 검토
```

### 중기 (3-6개월)

```markdown
□ Multi-region 배포
  - Asia, Europe 리전 추가
  - 지역별 라우팅으로 지연 시간 감소

□ API 서비스화
  - 개발자용 REST API 공개
  - SDK (Python, JavaScript)
  - 요금제 (Free: 10/월, Pro: 100/월)

□ AI 품질 개선
  - Alpha Matting 후처리 추가
  - 레이어 순서 자동 최적화
```

### 장기 (6-12개월)

```markdown
□ 비디오 레이어 분해
  - 프레임별 처리
  - 시간축 편집 기능

□ 3D 지원
  - Depth 정보 포함
  - 3D 에디터 통합 (Blender)

□ AI 자동 편집
  - "이 포스터를 빨간색 계열로"
  - "텍스트를 영어로 변환"
```

## 비용 최종 정리

### 시나리오별 실제 비용

```
케이스 1: 개인 프로젝트 (월 100회)
- Vertex AI (최적화): $0.90
- 네트워크: $0.02
- Storage: $0.30
- 총: $1.22/월

케이스 2: 스타트업 MVP (월 5,000회)
- Vertex AI (최적화): $45
- 네트워크: $1
- Storage: $0.30
- 총: $46.30/월

케이스 3: 프로덕션 (월 50,000회)
- Vertex AI (최적화): $450
- Always On (업무 시간): $121.50
- 네트워크: $10
- Storage: $0.30
- 총: $581.80/월

vs 로컬 GPU: $80/월 (고정)
```

**손익 분기점**: 월 약 26,000회 이상이면 로컬 GPU 고려

## 최종 아키텍처 다이어그램

```
┌──────────────────────────────────────────────────────────┐
│                    User Browser                           │
└───────────────────┬──────────────────────────────────────┘
                    │ HTTPS
                    ↓
┌──────────────────────────────────────────────────────────┐
│                    Nginx (SSL)                            │
└───────────────────┬──────────────────────────────────────┘
                    │
                    ↓
┌──────────────────────────────────────────────────────────┐
│               FastAPI (API Server)                        │
│  - 업로드 엔드포인트                                      │
│  - 작업 생성/조회                                         │
│  - 비용 API                                               │
└───────────┬────────────────────────┬─────────────────────┘
            │                        │
            ↓                        ↓
┌─────────────────┐        ┌────────────────────┐
│     Redis       │        │    Worker (x2)     │
│  - 작업 큐       │←───────│  - 작업 처리        │
│  - 캐시         │        │  - 폴백 로직        │
│  - 비용 추적     │        └────────┬───────────┘
└─────────────────┘                 │
                                    ↓
                    ┌───────────────────────────────┐
                    │  Decomposer Orchestrator      │
                    │  - 자동 폴백                   │
                    │  - Circuit Breaker            │
                    └─┬──────────┬──────────┬───────┘
                      │          │          │
         ┌────────────┘          │          └─────────────┐
         ↓                       ↓                        ↓
┌─────────────────┐  ┌────────────────────┐  ┌────────────────┐
│  Vertex AI      │  │ Hugging Face       │  │ Local GPU      │
│  (Primary)      │  │ (Secondary)        │  │ (Tertiary)     │
│  - T4 GPU       │  │ - Inference        │  │ - RTX 3090     │
│  - Auto-scaling │  │   Endpoints        │  │ - Optional     │
└─────────────────┘  └────────────────────┘  └────────────────┘
         │                       │                        │
         └───────────────────────┴────────────────────────┘
                                 ↓
                    ┌───────────────────────────┐
                    │     결과 저장 (PNG)        │
                    │  - Cloud Storage          │
                    │  - 24시간 TTL             │
                    └───────────────────────────┘

┌──────────────────────────────────────────────────────────┐
│                   Monitoring Stack                        │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐               │
│  │Prometheus│→ │ Grafana  │  │  Slack   │               │
│  │          │  │Dashboard │  │  Alerts  │               │
│  └──────────┘  └──────────┘  └──────────┘               │
└──────────────────────────────────────────────────────────┘
```

## 마무리

### 프로젝트의 의의

이 시리즈는 단순한 "클라우드 마이그레이션"이 아니었다.

**기술적 성장**:
- 최신 AI 모델 (Qwen-Image-Layered) 실전 활용
- Vertex AI, Hugging Face 등 MLOps 플랫폼 경험
- Docker, Kubernetes 등 컨테이너 오케스트레이션
- Prometheus, Grafana 모니터링 스택 구축

**사고방식 변화**:
- "내가 소유해야 한다" → "서비스로 활용한다"
- "완벽한 시작" → "점진적 개선"
- "기술 선택" → "트레이드오프 이해"

### 다음 여정

AI 기술은 계속 발전한다. 이 프로젝트가 완성된 시점에도 더 좋은 모델이 나올 것이다.

하지만 **"문제 인식 → 조사 → 구현 → 최적화 → 운영"**의 과정은 항상 동일하다.

이 여정이 여러분의 다음 프로젝트에 영감이 되기를 바란다.

---

**시리즈 완결!** 🎉

**이전 글**: [비용 모니터링 대시보드 (9/10)](./update-qwen-image-layered-project-v9.md)

**전체 시리즈**:
1. [프로젝트 업그레이드 배경](./update-qwen-image-layered-project-v1.md)
2. [Hugging Face vs Vertex AI 비교](./update-qwen-image-layered-project-v2.md)
3. [Hugging Face API 테스트](./update-qwen-image-layered-project-v3.md)
4. [Vertex AI 배포 실전](./update-qwen-image-layered-project-v4.md)
5. [API 엔드포인트 재설계](./update-qwen-image-layered-project-v5.md)
6. [비용 최적화 전략](./update-qwen-image-layered-project-v6.md)
7. [성능 벤치마크](./update-qwen-image-layered-project-v7.md)
8. [하이브리드 아키텍처](./update-qwen-image-layered-project-v8.md)
9. [비용 모니터링 대시보드](./update-qwen-image-layered-project-v9.md)
10. [운영 가이드 및 결론](./update-qwen-image-layered-project-v10.md)

**프로젝트 저장소**: (v10 완성 후 공개 예정)

**피드백 환영**: GitHub Issues 또는 이메일

**다음 프로젝트를 기대하며!** 🚀