물리아키텍처 설계 완료

✨ 주요 기능
- Azure 기반 물리아키텍처 설계 (개발환경/운영환경)
- 7개 마이크로서비스 물리 구조 설계
- 네트워크 아키텍처 다이어그램 작성 (Mermaid)
- 환경별 비교 분석 및 마스터 인덱스 문서

📁 생성 파일
- design/backend/physical/physical-architecture.md (마스터)
- design/backend/physical/physical-architecture-dev.md (개발환경)
- design/backend/physical/physical-architecture-prod.md (운영환경)
- design/backend/physical/*.mmd (4개 Mermaid 다이어그램)

🎯 핵심 성과
- 비용 최적화: 개발환경 월 $143, 운영환경 월 $2,860
- 확장성: 개발환경 100명 → 운영환경 10,000명 (100배)
- 가용성: 개발환경 95% → 운영환경 99.9%
- 보안: 다층 보안 아키텍처 (L1~L4)

🛠️ 기술 스택
- Azure Kubernetes Service (AKS)
- Azure Database for PostgreSQL Flexible
- Azure Cache for Redis Premium
- Azure Service Bus Premium
- Application Gateway + WAF

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

claude/class-design.md

@@ -0,0 +1,68 @@
+# 클래스설계가이드 
+
+[요청사항]
+- <작성원칙>을 준용하여 설계
+- <작성순서>에 따라 설계
+- [결과파일] 안내에 따라 파일 작성   
+
+[가이드]
+<작성원칙>
+- **유저스토리와 매칭**되어야 함. **불필요한 추가 설계 금지**
+- API설계서와 일관성 있게 설계. Controller에 API를 누락하지 말고 모두 설계 
+  - Controller 클래스는 API로 정의하지 않은 메소드 생성 안함. 단, 필요한 Private 메소드는 추가함  
+  - {service-name}-simple.puml파일에 Note로 Controller 클래스 메소드와 API 매핑표 작성: {Methond}: {API Path} {API 제목}  
+    예) login: /login 로그인 
+- 내부시퀀스설계서와 일관성 있게 설계   
+- 각 서비스별 지정된 {설계 아키텍처 패턴}을 적용
+- Clean아키텍처 적용 시 Port/Adapter라는 용어 대신 Clean 아키텍처에 맞는 용어 사용
+- 클래스의 프라퍼티와 메소드를 모두 기술할 것. 단 "Getter/Setter 메소드"는 작성하지 않음    
+- 클래스 간의 관계를 표현: Generalization, Realization, Dependency, Association, Aggregation, Composition
+
+<작성순서>
+- **서브 에이전트를 활용한 병렬 작성 필수**
+- **3단계 하이브리드 접근법 적용**
+- **마이크로서비스 아키텍처 기반 설계**
+
+- 1단계: 공통 컴포넌트 설계 (순차적)
+  - 결과: design/backend/class/common-base.puml
+
+- 2단계: 서비스별 병렬 설계 (병렬 실행)
+  - 1단계 공통 컴포넌트 참조
+  - '!include'는 사용하지 말고 필요한 인터페이스 직접 정의
+  - 클래스 설계 후 프라퍼티와 메소드를 생략한 간단한 클래스설계서도 추가로 작성
+  - 결과: 
+    - design/backend/class/{service-name}.puml
+    - design/backend/class/{service-name}-simple.puml
+
+  - 병렬 처리 기준
+    - 서비스 간 의존성이 없는 경우: 모든 서비스 동시 실행
+    - 의존성이 있는 경우: 의존성 그룹별로 묶어서 실행
+      - 예: A→B 의존 시, A 완료 후 B 실행
+      - 독립 서비스 C,D는 A,B와 병렬 실행
+
+- 3단계: 통합 및 검증 (순차적)
+  - '패키지구조표준'의 예시를 참조하여 모든 클래스와 파일이 포함된 패키지 구조도를 작성 
+    (plantuml 스크립트가 아니라 트리구조 텍스트로 작성)   
+  - 인터페이스 일치성 검증
+  - 명명 규칙 통일성 확인
+  - 의존성 검증
+  - 크로스 서비스 참조 검증
+  - **PlantUML 스크립트 파일 검사 실행**: 'PlantUML문법검사가이드' 준용
+
+[참고자료]
+- 유저스토리
+- API설계서
+- 내부시퀀스설계서
+- 패키지구조표준
+- PlantUML문법검사가이드
+
+[예시]
+- 링크: https://raw.githubusercontent.com/cna-bootcamp/clauding-guide/refs/heads/main/samples/sample-클래스설계서.puml
+  
+[결과파일]
+- 패키지 구조도: design/backend/class/package-structure.md
+- 클래스설계서: 
+  - design/backend/class/common-base.puml
+  - design/backend/class/{service-name}.puml
+- 클래스설계서(요약): design/backend/class/{service-name}-simple.puml
+- service-name은 영어로 작성 (예: profile, location, itinerary)

claude/data-design.md

@@ -0,0 +1,55 @@
+# 데이터설계가이드 
+
+[요청사항]
+- <작성원칙>을 준용하여 설계
+- <작성순서>에 따라 설계
+- [결과파일] 안내에 따라 파일 작성   
+
+[가이드]  
+<작성원칙>
+- **클래스설계서의 각 서비스별 Entity정의와 일치**해야 함. **불필요한 추가 설계 금지**
+- <데이터독립성원칙>에 따라 각 서비스마다 데이터베이스를 분리
+<작성순서>
+- 준비:
+  - 유저스토리, API설계서, 외부시퀀스설계서, 내부시퀀스설계서, 패키지구조표준 분석 및 이해
+- 실행:
+  - <병렬처리>안내에 따라 각 서비스별 병렬 수행 
+  - 데이터설계서 작성
+    - 캐시 사용 시 캐시DB 설계 포함
+    - 시작 부분에 '데이터설계 요약' 제공 
+    - 결과: {service-name}.md 
+  - ERD 작성
+    - 결과: {service-name}-erd.puml
+    - **PlantUML 스크립트 파일 생성 즉시 검사 실행**: 'PlantUML 문법 검사  가이드' 준용  
+  - 데이터베이스 스키마 스크립트 작성 
+    - 실행 가능한 SQL 스크립트 작성
+    - 결과: {service-name}-schema.psql
+- 검토: 
+  - <작성원칙> 준수 검토
+  - 스쿼드 팀원 리뷰: 누락 및 개선 사항 검토
+  - 수정 사항 선택 및 반영  
+
+<병렬처리>
+Agent 1~N: 각 서비스별 데이터베이스 설계
+  - 서비스별 독립적인 스키마 설계
+  - Entity 클래스와 1:1 매핑
+  - 서비스 간 데이터 공유 금지
+  - FK 관계는 서비스 내부에서만 설정
+
+<데이터독립성원칙>
+- **데이터 소유권**: 각 서비스가 자신의 데이터 완전 소유
+- **크로스 서비스 조인 금지**: 서비스 간 DB 조인 불가
+- **이벤트 기반 동기화**: 필요시 이벤트/메시지로 데이터 동기화
+- **캐시 활용**: 타 서비스 데이터는 캐시로만 참조 
+
+[참고자료]
+- 클래스설계서
+
+[예시]
+- 링크: https://raw.githubusercontent.com/cna-bootcamp/clauding-guide/refs/heads/main/samples/sample-데이터설계서.puml
+
+[결과파일]
+- design/backend/database/{service-name}.md
+- design/backend/database/{service-name}-erd.puml
+- design/backend/database/{service-name}-schema.psql
+- service-name은 영어로 작성 

claude/highlevel-architecture-template.md

@@ -0,0 +1,425 @@
+# High Level 아키텍처 정의서
+
+## 1. 개요 (Executive Summary)
+
+### 1.1 프로젝트 개요
+- **비즈니스 목적**: 
+- **핵심 기능**: 
+- **대상 사용자**: 
+- **예상 사용자 규모**: 
+
+### 1.2 아키텍처 범위 및 경계
+- **시스템 범위**: 
+- **포함되는 시스템**: 
+- **제외되는 시스템**: 
+- **외부 시스템 연동**: 
+
+### 1.3 문서 구성
+이 문서는 4+1 뷰 모델을 기반으로 구성되며, 논리적/물리적/프로세스/개발 관점에서 아키텍처를 정의합니다.
+
+---
+
+## 2. 아키텍처 요구사항
+
+### 2.1 기능 요구사항 요약
+| 영역 | 주요 기능 | 우선순위 |
+|------|-----------|----------|
+|  |  |  |
+
+### 2.2 비기능 요구사항 (NFRs)
+
+#### 2.2.1 성능 요구사항
+- **응답시간**: 
+- **처리량**: 
+- **동시사용자**: 
+- **데이터 처리량**: 
+
+#### 2.2.2 확장성 요구사항
+- **수평 확장**: 
+- **수직 확장**: 
+- **글로벌 확장**: 
+
+#### 2.2.3 가용성 요구사항
+- **목표 가용성**: 99.9% / 99.99% / 99.999%
+- **다운타임 허용**: 
+- **재해복구 목표**: RTO/RPO
+
+#### 2.2.4 보안 요구사항
+- **인증/인가**: 
+- **데이터 암호화**: 
+- **네트워크 보안**: 
+- **컴플라이언스**: 
+
+### 2.3 아키텍처 제약사항
+- **기술적 제약**: 
+- **비용 제약**: 
+- **시간 제약**: 
+- **조직적 제약**: 
+
+---
+
+## 3. 아키텍처 설계 원칙
+
+### 3.1 핵심 설계 원칙
+1. **확장성 우선**: 수평적 확장이 가능한 구조
+2. **장애 격리**: 단일 장애점 제거 및 Circuit Breaker 패턴
+3. **느슨한 결합**: 마이크로서비스 간 독립성 보장
+4. **관측 가능성**: 로깅, 모니터링, 추적 체계 구축
+5. **보안 바이 데자인**: 설계 단계부터 보안 고려
+
+### 3.2 아키텍처 품질 속성 우선순위
+| 순위 | 품질 속성 | 중요도 | 전략 |
+|------|-----------|--------|------|
+| 1 |  | High |  |
+| 2 |  | Medium |  |
+| 3 |  | Low |  |
+
+---
+
+## 4. 논리 아키텍처 (Logical View)
+
+### 4.1 시스템 컨텍스트 다이어그램
+```
+{논리아키텍처 경로}
+```
+
+### 4.2 도메인 아키텍처
+#### 4.2.1 도메인 모델
+| 도메인 | 책임 | 주요 엔티티 |
+|--------|------|-------------|
+|  |  |  |
+
+#### 4.2.2 바운디드 컨텍스트
+```
+[도메인별 바운디드 컨텍스트 다이어그램]
+```
+
+### 4.3 서비스 아키텍처
+#### 4.3.1 마이크로서비스 구성
+| 서비스명 | 책임 |
+|----------|------|
+|  |  |
+
+#### 4.3.2 서비스 간 통신 패턴
+- **동기 통신**: REST API, GraphQL
+- **비동기 통신**: Event-driven, Message Queue
+- **데이터 일관성**: Saga Pattern, Event Sourcing
+
+---
+
+## 5. 프로세스 아키텍처 (Process View)
+
+### 5.1 주요 비즈니스 프로세스
+#### 5.1.1 핵심 사용자 여정
+```
+[사용자 여정별 프로세스 플로우]
+```
+
+#### 5.1.2 시스템 간 통합 프로세스
+```
+[시스템 통합 시퀀스 다이어그램]
+```
+
+### 5.2 동시성 및 동기화
+- **동시성 처리 전략**: 
+- **락 관리**: 
+- **이벤트 순서 보장**: 
+
+---
+
+## 6. 개발 아키텍처 (Development View)
+
+### 6.1 개발 언어 및 프레임워크 선정
+#### 6.1.1 백엔드 기술스택
+| 서비스 | 언어 | 프레임워크 | 선정이유  |
+|----------|------|---------------|----------|
+
+#### 6.1.2 프론트엔드 기술스택
+- **언어**: 
+- **프레임워크**: 
+- **선정 이유**: 
+
+### 6.2 서비스별 개발 아키텍처 패턴
+| 서비스 | 아키텍처 패턴 | 선정 이유 |
+|--------|---------------|-----------|
+|  | Clean/Layered/Hexagonal |  |
+
+
+### 6.3 개발 가이드라인
+- **코딩 표준**: 
+- **테스트 전략**: 
+
+---
+
+## 7. 물리 아키텍처 (Physical View)
+
+### 7.1 클라우드 아키텍처 패턴
+#### 7.1.1 선정된 클라우드 패턴
+- **패턴명**: 
+- **적용 이유**: 
+- **예상 효과**: 
+
+#### 7.1.2 클라우드 제공자
+- **주 클라우드**: Azure/AWS/GCP
+- **멀티 클라우드 전략**: 
+- **하이브리드 구성**: 
+
+### 7.2 인프라스트럭처 구성
+#### 7.2.1 컴퓨팅 리소스
+| 구성요소 | 사양 | 스케일링 전략 |
+|----------|------|---------------|
+| 웹서버 |  |  |
+| 앱서버 |  |  |
+| 데이터베이스 |  |  |
+
+#### 7.2.2 네트워크 구성
+```
+[네트워크 토폴로지 다이어그램]
+```
+
+#### 7.2.3 보안 구성
+- **방화벽**: 
+- **WAF**: 
+- **DDoS 방어**: 
+- **VPN/Private Link**: 
+
+---
+
+## 8. 기술 스택 아키텍처
+
+### 8.1 API Gateway & Service Mesh
+#### 8.1.1 API Gateway
+- **제품**: 
+- **주요 기능**: 인증, 라우팅, 레이트 리미팅, 모니터링
+- **설정 전략**: 
+
+#### 8.1.2 Service Mesh
+- **제품**: Istio/Linkerd/Consul Connect
+- **적용 범위**: 
+- **트래픽 관리**: 
+
+### 8.2 데이터 아키텍처
+#### 8.2.1 데이터베이스 전략
+| 용도 | 데이터베이스 | 타입 | 특징 |
+|------|-------------|------|------|
+| 트랜잭션 |  | RDBMS |  |
+| 캐시 |  | In-Memory |  |
+| 검색 |  | Search Engine |  |
+| 분석 |  | Data Warehouse |  |
+
+#### 8.2.2 데이터 파이프라인
+```
+[데이터 플로우 다이어그램]
+```
+
+### 8.3 백킹 서비스 (Backing Services)
+#### 8.3.1 메시징 & 이벤트 스트리밍
+- **메시지 큐**: 
+- **이벤트 스트리밍**: 
+- **이벤트 스토어**: 
+
+#### 8.3.2 스토리지 서비스
+- **객체 스토리지**: 
+- **블록 스토리지**: 
+- **파일 스토리지**: 
+
+### 8.4 관측 가능성 (Observability)
+#### 8.4.1 로깅 전략
+- **로그 수집**: 
+- **로그 저장**: 
+- **로그 분석**: 
+
+#### 8.4.2 모니터링 & 알람
+- **메트릭 수집**: 
+- **시각화**: 
+- **알람 정책**: 
+
+#### 8.4.3 분산 추적
+- **추적 도구**: 
+- **샘플링 전략**: 
+- **성능 분석**: 
+
+---
+
+## 9. AI/ML 아키텍처
+
+### 9.1 AI API 통합 전략
+#### 9.1.1 AI 서비스/모델 매핑
+| 목적 | 서비스 | 모델 | Input 데이터 | Output 데이터 | SLA |
+|------|--------|-------|-------------|-------------|-----|
+|  |  |  |  |  |  |
+
+#### 9.1.2 AI 파이프라인
+```
+[AI 데이터 처리 파이프라인]
+```
+
+### 9.2 데이터 과학 플랫폼
+- **모델 개발 환경**: 
+- **모델 배포 전략**: 
+- **모델 모니터링**: 
+
+---
+
+## 10. 개발 운영 (DevOps)
+
+### 10.1 CI/CD 파이프라인
+#### 10.1.1 지속적 통합 (CI)
+- **도구**: 
+- **빌드 전략**: 
+- **테스트 자동화**: 
+
+#### 10.1.2 지속적 배포 (CD)
+- **배포 도구**: 
+- **배포 전략**: Blue-Green/Canary/Rolling
+- **롤백 정책**: 
+
+### 10.2 컨테이너 오케스트레이션
+#### 10.2.1 Kubernetes 구성
+- **클러스터 전략**: 
+- **네임스페이스 설계**: 
+- **리소스 관리**: 
+
+#### 10.2.2 헬름 차트 관리
+- **차트 구조**: 
+- **환경별 설정**: 
+- **의존성 관리**: 
+
+---
+
+## 11. 보안 아키텍처
+
+### 11.1 보안 전략
+#### 11.1.1 보안 원칙
+- **Zero Trust**: 
+- **Defense in Depth**: 
+- **Least Privilege**: 
+
+#### 11.1.2 위협 모델링
+| 위협 | 영향도 | 대응 방안 |
+|------|--------|-----------|
+|  |  |  |
+
+### 11.2 보안 구현
+#### 11.2.1 인증 & 인가
+- **ID 제공자**: 
+- **토큰 전략**: JWT/OAuth2/SAML
+- **권한 모델**: RBAC/ABAC
+
+#### 11.2.2 데이터 보안
+- **암호화 전략**: 
+- **키 관리**: 
+- **데이터 마스킹**: 
+
+---
+
+## 12. 품질 속성 구현 전략
+
+### 12.1 성능 최적화
+#### 12.1.1 캐싱 전략
+| 계층 | 캐시 유형 | TTL | 무효화 전략 |
+|------|-----------|-----|-------------|
+|  |  |  |  |
+
+#### 12.1.2 데이터베이스 최적화
+- **인덱싱 전략**: 
+- **쿼리 최적화**: 
+- **커넥션 풀링**: 
+
+### 12.2 확장성 구현
+#### 12.2.1 오토스케일링
+- **수평 확장**: HPA/VPA
+- **수직 확장**: 
+- **예측적 스케일링**: 
+
+#### 12.2.2 부하 분산
+- **로드 밸런서**: 
+- **트래픽 분산 정책**: 
+- **헬스체크**: 
+
+### 12.3 가용성 및 복원력
+#### 12.3.1 장애 복구 전략
+- **Circuit Breaker**: 
+- **Retry Pattern**: 
+- **Bulkhead Pattern**: 
+
+#### 12.3.2 재해 복구
+- **백업 전략**: 
+- **RTO/RPO**: 
+- **DR 사이트**: 
+
+---
+
+## 13. 아키텍처 의사결정 기록 (ADR)
+
+### 13.1 주요 아키텍처 결정
+| ID | 결정 사항 | 결정 일자 | 상태 | 결정 이유 |
+|----|-----------|-----------|------|-----------|
+| ADR-001 |  |  |  |  |
+
+### 13.2 트레이드오프 분석
+#### 13.2.1 성능 vs 확장성
+- **고려사항**: 
+- **선택**: 
+- **근거**: 
+
+#### 13.2.2 일관성 vs 가용성 (CAP 정리)
+- **고려사항**: 
+- **선택**: AP/CP
+- **근거**: 
+
+---
+
+## 14. 구현 로드맵
+
+### 14.1 개발 단계
+| 단계 | 기간 | 주요 산출물 | 마일스톤 |
+|------|------|-------------|-----------|
+| Phase 1 |  |  |  |
+| Phase 2 |  |  |  |
+| Phase 3 |  |  |  |
+
+### 14.2 마이그레이션 전략 (레거시 시스템이 있는 경우)
+- **데이터 마이그레이션**: 
+- **기능 마이그레이션**: 
+- **병행 운영**: 
+
+---
+
+## 15. 위험 관리
+
+### 15.1 아키텍처 위험
+| 위험 | 영향도 | 확률 | 완화 방안 |
+|------|--------|------|-----------|
+|  |  |  |  |
+
+### 15.2 기술 부채 관리
+- **식별된 기술 부채**: 
+- **해결 우선순위**: 
+- **해결 계획**: 
+
+---
+
+## 16. 부록
+
+### 16.1 참조 아키텍처
+- **업계 표준**: 
+- **내부 표준**: 
+- **외부 참조**: 
+
+### 16.2 용어집
+| 용어 | 정의 |
+|------|------|
+|  |  |
+
+### 16.3 관련 문서
+- {문서명}: {파일 위치}
+- ...
+
+---
+
+## 문서 이력
+| 버전 | 일자 | 작성자 | 변경 내용 | 승인자 |
+|------|------|--------|-----------|-------|
+| v1.0 |  |  | 초기 작성 |  |
+

claude/physical-architecture-design.md

@@ -0,0 +1,230 @@
+# 물리아키텍처설계가이드
+
+[요청사항]  
+- <작성원칙>을 준용하여 설계
+- <작성순서>에 따라 설계
+- [결과파일] 안내에 따라 파일 작성
+- 완료 후 mermaid 스크립트 테스트 방법 안내
+  - https://mermaid.live/edit 에 접근
+  - 스크립트 내용을 붙여넣어 확인
+
+[가이드]   
+<작성원칙>
+- 클라우드 기반의 물리 아키텍처 설계
+- HighLevel아키텍처정의서와 일치해야 함
+- 백킹서비스설치방법에 있는 제품을 우선적으로 사용
+- 환경별 특성에 맞는 차별화 전략 적용
+- 비용 효율성과 운영 안정성의 균형 고려
+- 선정된 아키텍처 패턴 반영 및 최적화
+
+<작성순서>
+- 준비:
+  - 아키텍처패턴, 논리아키텍처, 외부시퀀스설계서, 데이터설계서, HighLevel아키텍처정의서 분석 및 이해
+
+- 실행:
+  - 물리아키텍처 다이어그램 작성
+    - 서브에이전트로 병렬 수행 
+    - Mermaid 형식으로 작성
+    - Mermaid 스크립트 파일 검사 실행
+    - 개발환경 물리아키텍처 다이어그램 
+      - '<예시>의 '개발환경 물리아키텍처 다이어그램'의 내용을 읽어 참조
+      - 사용자 → Ingress → 서비스 → 데이터베이스 플로우만 표시
+      - 클라우드 서비스는 최소한으로만 포함
+      - 부가 설명은 문서에만 기록, 다이어그램에서 제거
+      - 네트워크, 보안, 운영 관련 아키텍처는 생략  
+      - 모니터링/로깅/보안과 관련된 제품/서비스 생략함
+    - 운영환경 물리아키텍처 다이어그램 
+      - '<예시>의 '운영환경 물리아키텍처 다이어그램'의 내용을 읽어 참조 
+    - 결과:
+      - 개발환경: physical-architecture-dev.mmd
+      - 운영환경: physical-architecture-prod.mmd
+  - 네트워크 아키텍처 다이어그램 작성 
+    - 서브에이전트로 병렬 수행 
+    - Mermaid 형식으로 작성
+    - Mermaid 스크립트 파일 검사 실행
+    - 개발환경 네트워크 다이어그램: '<예시>의 '개발환경 네트워크 다이어그램'의 내용을 읽어 참조
+    - 운영환경 네트워크 다이어그램: '<예시>의 '운영환경 네트워크 다이어그램'의 내용을 읽어 참조
+    - 결과:
+      - 개발환경: network-dev.mmd
+      - 운영환경: network-prod.mmd 
+  - 개발환경 물리아키텍처 설계서 작성
+    - <개발환경가이드>의 항목별 작성
+    - '<예시>의 '개발환경 물리아키텍처 설계서'의 내용을 읽어 참조  
+    - 비용 최적화 중심의 개발 친화적 환경 구성
+    - 빠른 배포와 테스트를 위한 단순화된 아키텍처
+    - Pod 기반 백킹서비스와 기본 보안 설정
+    - 개발팀 규모와 워크플로우에 최적화
+    - 제품/서비스 구성 
+      - Application Gateway: Kubernetes Ingress 
+      - Database: "백킹서비스설치방법"에 있는 오픈소스 DB사용  
+      - Message Queue: "백킹서비스설치방법"에 있는 {CLOUD}에서 제공하는 제품
+      - CI/CD: 'HighLevel아키텍처정의서'에 있는 CI/CD 제품
+    - 결과: physical-architecture-dev.md  
+  - 운영환경 물리아키텍처 설계서 작성
+    - <운영환경가이드>의 항목별 작성
+    - '<예시>의 '운영환경 물리아키텍처 설계서'의 내용을 읽어 참조
+    - 고가용성과 확장성을 고려한 프로덕션 환경
+    - 관리형 서비스 중심의 안정적인 구성
+    - 엔터프라이즈급 보안과 모니터링 체계
+    - 실사용자 규모에 따른 성능 최적화
+    - 결과: physical-architecture-prod.md
+  - 마스터 아키텍처 설계서 작성
+    - <마스터가이드>의 항목별 작성 
+    - '<예시>의 '마스터 물리아키텍처 설계서'의 내용을 읽어 참조
+    - 환경별 아키텍처 비교 및 통합 관리
+    - 단계별 전환 전략과 확장 로드맵
+    - 비용 분석과 운영 가이드라인
+    - 전체 시스템 거버넌스 체계
+    - 결과: physical-architecture.md
+- 검토:
+  - <작성원칙> 준수 검토
+  - 선정 아키텍처 패턴 적용 확인
+  - 환경별 비용 효율성 검증
+  - 확장성 및 성능 요구사항 충족 확인
+  - 프로젝트 팀원 리뷰 및 피드백 반영
+  - 수정 사항 선택 및 최종 반영
+
+<개발환경가이드>
+```
+대분류|중분류|소분류|작성가이드
+---|---|---|---
+1. 개요|1.1 설계 목적||개발환경 물리 아키텍처의 설계 범위, 목적, 대상을 명확히 기술
+1. 개요|1.2 설계 원칙||개발환경에 적합한 핵심 설계 원칙 4가지 정의 (MVP 우선, 비용 최적화, 개발 편의성, 단순성)
+1. 개요|1.3 참조 아키텍처||관련 아키텍처 문서들의 연관관계와 참조 방법 명시
+2. 개발환경 아키텍처 개요|2.1 환경 특성||개발환경의 목적, 사용자 규모, 가용성 목표, 확장성, 보안 수준 등 특성 정의
+2. 개발환경 아키텍처 개요|2.2 전체 아키텍처||전체 시스템 구성도와 주요 컴포넌트 간 연결 관계 설명 및 다이어그램 링크
+3. 컴퓨팅 아키텍처|3.1 Kubernetes 클러스터 구성|3.1.1 클러스터 설정|Kubernetes 버전, 서비스 계층, 네트워크 플러그인, DNS 등 클러스터 기본 설정값 표 작성
+3. 컴퓨팅 아키텍처|3.1 Kubernetes 클러스터 구성|3.1.2 노드 풀 구성|인스턴스 크기, 노드 수, 스케일링 설정, 가용영역, 가격 정책 등 노드 풀 상세 설정 표 작성
+3. 컴퓨팅 아키텍처|3.2 서비스별 리소스 할당|3.2.1 애플리케이션 서비스|각 마이크로서비스별 CPU/Memory requests, limits, replicas 상세 리소스 할당 표 작성
+3. 컴퓨팅 아키텍처|3.2 서비스별 리소스 할당|3.2.2 백킹 서비스|데이터베이스, 캐시 등 백킹서비스 Pod의 리소스 할당 및 스토리지 설정 표 작성 (PVC 사용 시 클라우드 스토리지 클래스 지정: standard, premium-ssd 등)
+3. 컴퓨팅 아키텍처|3.2 서비스별 리소스 할당|3.2.3 스토리지 클래스 구성|클라우드 제공자별 스토리지 클래스 설정 (hostPath 사용 금지, 관리형 디스크만 사용)
+4. 네트워크 아키텍처|4.1 네트워크 구성|4.1.1 네트워크 토폴로지|네트워크 구성도 및 서브넷 구조 설명, 네트워크 다이어그램 링크 제공
+4. 네트워크 아키텍처|4.1 네트워크 구성|4.1.2 네트워크 보안|Network Policy 설정, 접근 제한 규칙, 보안 정책 표 작성
+4. 네트워크 아키텍처|4.2 서비스 디스커버리||각 서비스의 내부 DNS 주소, 포트, 용도를 정리한 서비스 디스커버리 표 작성
+5. 데이터 아키텍처|5.1 데이터베이스 구성|5.1.1 주 데이터베이스 Pod 구성|컨테이너 이미지, 리소스 설정, 스토리지 구성, 데이터베이스 설정값 상세 표 작성 (스토리지는 클라우드 제공자별 관리형 스토리지 사용: Azure Disk, AWS EBS, GCP Persistent Disk 등)
+5. 데이터 아키텍처|5.1 데이터베이스 구성|5.1.2 캐시 Pod 구성|캐시 컨테이너 이미지, 리소스, 메모리 설정, 캐시 정책 등 상세 설정 표 작성 (영구 저장이 필요한 경우 클라우드 스토리지 클래스 사용)
+5. 데이터 아키텍처|5.2 데이터 관리 전략|5.2.1 데이터 초기화|Kubernetes Job을 이용한 데이터 초기화 프로세스, 실행 절차, 검증 방법 상세 기술
+5. 데이터 아키텍처|5.2 데이터 관리 전략|5.2.2 백업 전략|백업 방법, 주기, 보존 전략, 복구 절차를 서비스별로 정리한 표 작성
+6. 메시징 아키텍처|6.1 Message Queue 구성|6.1.1 Basic Tier 설정|Message Queue 전체 설정값과 큐별 상세 설정을 표로 정리하여 작성
+6. 메시징 아키텍처|6.1 Message Queue 구성|6.1.2 연결 설정|인증 방식, 연결 풀링, 재시도 정책 등 연결 관련 설정 표 작성
+7. 보안 아키텍처|7.1 개발환경 보안 정책|7.1.1 기본 보안 설정|보안 계층별 설정값과 수준을 정리한 표와 관리 대상 시크릿 목록 작성
+7. 보안 아키텍처|7.1 개발환경 보안 정책|7.1.2 시크릿 관리|시크릿 관리 방식, 순환 정책, 저장소 등 시크릿 관리 전략 표 작성
+7. 보안 아키텍처|7.2 Network Policies|7.2.1 기본 정책|Network Policy 설정 상세 내용과 보안 정책 적용 범위 표 작성
+8. 모니터링 및 로깅|8.1 기본 모니터링|8.1.1 Kubernetes 기본 모니터링|모니터링 스택 구성과 기본 알림 설정 임계값을 표로 정리
+8. 모니터링 및 로깅|8.1 기본 모니터링|8.1.2 애플리케이션 모니터링|헬스체크 설정과 수집 메트릭 유형을 표로 정리하여 작성
+8. 모니터링 및 로깅|8.2 로깅|8.2.1 로그 수집|로그 수집 방식, 저장 방식, 보존 기간과 로그 레벨 설정을 표로 작성
+9. 배포 관련 컴포넌트|||CI/CD 파이프라인 구성 요소들과 각각의 역할을 표 형태로 정리
+10. 비용 최적화|10.1 개발환경 비용 구조|10.1.1 주요 비용 요소|구성요소별 사양과 월간 예상 비용, 절약 방안을 상세 표로 작성
+10. 비용 최적화|10.1 개발환경 비용 구조|10.1.2 비용 절약 전략|컴퓨팅, 스토리지, 네트워킹 영역별 절약 방안과 절약률을 표로 정리
+11. 개발환경 운영 가이드|11.1 일상 운영|11.1.1 환경 시작/종료|일상적인 환경 관리를 위한 kubectl 명령어와 절차를 코드 블록으로 제공
+11. 개발환경 운영 가이드|11.1 일상 운영|11.1.2 데이터 관리|데이터 초기화, 백업, 복원을 위한 구체적 명령어와 절차를 코드 블록으로 작성
+11. 개발환경 운영 가이드|11.2 트러블슈팅|11.2.1 일반적인 문제 해결|자주 발생하는 문제 유형별 원인과 해결방안, 예방법을 표로 정리
+12. 개발환경 특성 요약|||개발환경의 핵심 설계 원칙, 주요 제약사항, 최적화 목표를 요약하여 기술
+```
+
+<운영환경가이드>
+```
+대분류|중분류|소분류|작성가이드
+---|---|---|---
+1. 개요|1.1 설계 목적||운영환경 물리 아키텍처의 설계 범위, 목적, 대상을 명확히 기술
+1. 개요|1.2 설계 원칙||고가용성, 확장성, 보안 우선, 관측 가능성, 재해복구 등 5대 핵심 원칙 정의
+1. 개요|1.3 참조 아키텍처||관련 아키텍처 문서들의 연관관계와 참조 방법 명시
+2. 운영환경 아키텍처 개요|2.1 환경 특성||운영환경의 목적, 사용자 규모, 가용성 목표, 확장성, 보안 수준 등 특성 정의
+2. 운영환경 아키텍처 개요|2.2 전체 아키텍처||전체 시스템 구성도와 주요 컴포넌트 간 연결 관계 설명 및 다이어그램 링크
+3. 컴퓨팅 아키텍처|3.1 Kubernetes 클러스터 구성|3.1.1 클러스터 설정|Kubernetes 버전, Standard 서비스 티어, CNI 플러그인, RBAC 등 클러스터 기본 설정값 표 작성
+3. 컴퓨팅 아키텍처|3.1 Kubernetes 클러스터 구성|3.1.2 노드 풀 구성|시스템 노드 풀과 애플리케이션 노드 풀의 인스턴스 크기, 노드 수, Multi-Zone 배포 설정 표 작성
+3. 컴퓨팅 아키텍처|3.2 고가용성 구성|3.2.1 Multi-Zone 배포|가용성 전략과 Pod Disruption Budget 설정을 표로 정리
+3. 컴퓨팅 아키텍처|3.3 서비스별 리소스 할당|3.3.1 애플리케이션 서비스|각 마이크로서비스별 CPU/Memory requests, limits, replicas, HPA 설정 상세 표 작성
+3. 컴퓨팅 아키텍처|3.3 서비스별 리소스 할당|3.3.2 HPA 구성|Horizontal Pod Autoscaler 설정을 YAML 코드 블록으로 상세 작성
+4. 네트워크 아키텍처|4.1 네트워크 토폴로지||네트워크 흐름도와 VNet 구성, 서브넷 세부 구성을 표로 정리하고 다이어그램 링크 제공
+4. 네트워크 아키텍처|4.1 네트워크 토폴로지|4.1.1 Virtual Network 구성|VPC/VNet 기본 설정과 서브넷별 주소 대역, 용도, 특별 설정을 상세 표로 작성
+4. 네트워크 아키텍처|4.1 네트워크 토폴로지|4.1.2 네트워크 보안 그룹|보안 그룹 규칙을 방향, 규칙 이름, 포트, 소스/대상별로 정리한 표 작성
+4. 네트워크 아키텍처|4.2 트래픽 라우팅|4.2.1 Application Gateway 구성|기본 설정, 프론트엔드 구성, 백엔드 및 라우팅 설정을 표로 정리
+4. 네트워크 아키텍처|4.2 트래픽 라우팅|4.2.2 WAF 구성|WAF 정책과 커스텀 규칙, 관리 규칙을 YAML 코드 블록으로 작성
+4. 네트워크 아키텍처|4.3 Network Policies|4.3.1 마이크로서비스 간 통신 제어|Network Policy 기본 설정과 Ingress/Egress 규칙을 표로 정리
+4. 네트워크 아키텍처|4.4 서비스 디스커버리||각 서비스의 내부 DNS 주소, 포트, 용도를 정리한 서비스 디스커버리 표 작성
+5. 데이터 아키텍처|5.1 관리형 주 데이터베이스|5.1.1 데이터베이스 구성|기본 설정, 고가용성, 백업 및 보안 설정을 표로 정리하여 작성 (클라우드 제공자의 관리형 데이터베이스 서비스 사용: Azure Database, AWS RDS, Google Cloud SQL 등)
+5. 데이터 아키텍처|5.1 관리형 주 데이터베이스|5.1.2 읽기 전용 복제본|읽기 복제본 구성을 YAML 코드 블록으로 상세 작성
+5. 데이터 아키텍처|5.2 관리형 캐시 서비스|5.2.1 캐시 클러스터 구성|기본 설정, 클러스터 구성, 지속성 및 보안 설정을 표로 정리 (관리형 캐시 서비스 사용: Azure Cache for Redis, AWS ElastiCache, Google Cloud Memorystore 등)
+5. 데이터 아키텍처|5.2 관리형 캐시 서비스|5.2.2 캐시 전략|운영 최적화된 캐시 전략과 패턴을 YAML 코드 블록으로 작성
+5. 데이터 아키텍처|5.3 데이터 백업 및 복구|5.3.1 자동 백업 전략|주 데이터베이스와 캐시의 자동 백업 전략을 YAML 코드 블록으로 상세 작성
+6. 메시징 아키텍처|6.1 관리형 Message Queue|6.1.1 Message Queue 구성|Premium 티어 설정과 네임스페이스, 보안 설정을 YAML 코드 블록으로 작성
+6. 메시징 아키텍처|6.1 관리형 Message Queue|6.1.2 큐 및 토픽 설계|큐와 토픽의 상세 설정을 YAML 코드 블록으로 작성
+7. 보안 아키텍처|7.1 다층 보안 아키텍처|7.1.1 보안 계층 구조|L1-L4 보안 계층별 구성 요소를 YAML 코드 블록으로 상세 작성
+7. 보안 아키텍처|7.2 인증 및 권한 관리|7.2.1 클라우드 Identity 통합|클라우드 Identity 구성과 애플리케이션 등록을 YAML 코드 블록으로 작성
+7. 보안 아키텍처|7.2 인증 및 권한 관리|7.2.2 RBAC 구성|클러스터 역할과 서비스 계정을 YAML 코드 블록으로 상세 작성
+7. 보안 아키텍처|7.3 네트워크 보안|7.3.1 Private Endpoints|각 서비스별 Private Endpoint 설정을 YAML 코드 블록으로 작성
+7. 보안 아키텍처|7.4 암호화 및 키 관리|7.4.1 관리형 Key Vault 구성|Key Vault 설정과 액세스 정책, 순환 정책을 YAML 코드 블록으로 작성
+8. 모니터링 및 관측 가능성|8.1 종합 모니터링 스택|8.1.1 클라우드 모니터링 통합|Log Analytics, Application Insights, Container Insights 설정을 YAML 코드 블록으로 작성
+8. 모니터링 및 관측 가능성|8.1 종합 모니터링 스택|8.1.2 메트릭 및 알림|중요 알림과 리소스 알림 설정을 YAML 코드 블록으로 상세 작성
+8. 모니터링 및 관측 가능성|8.2 로깅 및 추적|8.2.1 중앙집중식 로깅|로그 수집 설정과 중앙 로그 시스템 쿼리를 YAML 코드 블록으로 작성
+8. 모니터링 및 관측 가능성|8.2 로깅 및 추적|8.2.2 애플리케이션 성능 모니터링|APM 설정과 커스텀 메트릭을 YAML 코드 블록으로 작성
+9. 배포 관련 컴포넌트|||CI/CD 파이프라인 구성 요소들과 각각의 역할, 보안 스캔, 롤백 정책을 표 형태로 정리
+10. 재해복구 및 고가용성|10.1 재해복구 전략|10.1.1 백업 및 복구 목표|RTO, RPO와 백업 전략을 YAML 코드 블록으로 상세 작성
+10. 재해복구 및 고가용성|10.1 재해복구 전략|10.1.2 자동 장애조치|데이터베이스, 캐시, 애플리케이션별 장애조치 설정을 YAML 코드 블록으로 작성
+10. 재해복구 및 고가용성|10.2 비즈니스 연속성|10.2.1 운영 절차|인시던트 대응, 유지보수 윈도우, 변경 관리를 YAML 코드 블록으로 작성
+11. 비용 최적화|11.1 운영환경 비용 구조|11.1.1 월간 비용 분석|구성요소별 사양, 예상 비용, 최적화 방안을 상세 표로 작성
+11. 비용 최적화|11.1 운영환경 비용 구조|11.1.2 비용 최적화 전략|컴퓨팅, 스토리지, 네트워크 영역별 최적화 방안을 YAML 코드 블록으로 작성
+11. 비용 최적화|11.2 성능 대비 비용 효율성|11.2.1 Auto Scaling 최적화|예측 스케일링과 비용 인식 스케일링을 YAML 코드 블록으로 작성
+12. 운영 가이드|12.1 일상 운영 절차|12.1.1 정기 점검 항목|일일, 주간, 월간 운영 체크리스트를 YAML 코드 블록으로 작성
+12. 운영 가이드|12.2 인시던트 대응|12.2.1 장애 대응 절차|심각도별 대응 절차를 YAML 코드 블록으로 상세 작성
+12. 운영 가이드|12.2 인시던트 대응|12.2.2 자동 복구 메커니즘|Pod 재시작, 노드 교체, 트래픽 라우팅 등 자동 복구를 YAML 코드 블록으로 작성
+13. 확장 계획|13.1 단계별 확장 로드맵|13.1.1 Phase 1-3|각 단계별 목표, 대상, 결과물을 YAML 코드 블록으로 상세 작성
+13. 확장 계획|13.2 기술적 확장성|13.2.1 수평 확장 전략|애플리케이션, 데이터베이스, 캐시 티어별 확장 전략을 YAML 코드 블록으로 작성
+14. 운영환경 특성 요약|||운영환경의 핵심 설계 원칙, 주요 성과 목표, 최적화 목표를 요약하여 기술
+```
+
+<마스터가이드>
+```
+대분류|중분류|소분류|작성가이드
+---|---|---|---
+1. 개요|1.1 설계 목적||전체 물리 아키텍처의 통합 관리 체계와 마스터 인덱스 역할 기술
+1. 개요|1.2 아키텍처 분리 원칙||개발환경과 운영환경 분리 원칙과 단계적 발전 전략 정의
+1. 개요|1.3 문서 구조||마스터 인덱스와 환경별 상세 문서 구조 및 참조 관계 명시
+1. 개요|1.4 참조 아키텍처||관련 아키텍처 문서들(HighLevel, 논리, 패턴, API)의 연관관계 명시
+2. 환경별 아키텍처 개요|2.1 환경별 특성 비교||목적, 가용성, 사용자, 확장성, 보안, 비용 등 환경별 특성을 비교 표로 작성
+2. 환경별 아키텍처 개요|2.2 환경별 세부 문서|2.2.1 개발환경 아키텍처|개발환경 문서 링크와 주요 특징, 핵심 구성을 요약하여 기술
+2. 환경별 아키텍처 개요|2.2 환경별 세부 문서|2.2.2 운영환경 아키텍처|운영환경 문서 링크와 주요 특징, 핵심 구성을 요약하여 기술
+2. 환경별 아키텍처 개요|2.3 핵심 아키텍처 결정사항|2.3.1 공통 아키텍처 원칙|서비스 메시 제거, 비동기 통신, 관리형 Identity, 다층 보안 등 공통 원칙 기술
+2. 환경별 아키텍처 개요|2.3 핵심 아키텍처 결정사항|2.3.2 환경별 차별화 전략|개발환경과 운영환경의 최적화 전략 차이점을 비교하여 기술
+3. 네트워크 아키텍처 비교|3.1 환경별 네트워크 전략|3.1.1 환경별 네트워크 전략 비교|인그레스, 네트워크, 보안, 접근 방식을 환경별로 비교한 표 작성
+3. 네트워크 아키텍처 비교|3.2 네트워크 보안 전략|3.2.1 공통 보안 원칙|Network Policies, 관리형 Identity, Private Endpoints, TLS 암호화 등 공통 보안 원칙 기술
+3. 네트워크 아키텍처 비교|3.2 네트워크 보안 전략|3.2.2 환경별 보안 수준|Network Policy, 시크릿 관리, 암호화, 웹 보안 수준을 환경별로 비교한 표 작성
+4. 데이터 아키텍처 비교|4.1 환경별 데이터 전략|4.1.1 환경별 데이터 구성 비교|주 데이터베이스와 캐시의 환경별 구성, 가용성, 비용을 비교한 상세 표 작성 (개발환경: Pod 기반 + 클라우드 스토리지, 운영환경: 관리형 서비스)
+4. 데이터 아키텍처 비교|4.2 캐시 전략 비교|4.2.1 다층 캐시 아키텍처|L1 애플리케이션 캐시와 L2 분산 캐시의 계층별 설정을 표로 정리
+4. 데이터 아키텍처 비교|4.2 캐시 전략 비교|4.2.2 환경별 캐시 특성 비교|캐시 구성, 데이터 지속성, 성능 특성을 환경별로 비교한 표 작성
+5. 보안 아키텍처 비교|5.1 다층 보안 아키텍처|5.1.1 공통 보안 계층|L1-L4 보안 계층의 보안 기술, 적용 범위, 보안 목적을 표로 정리
+5. 보안 아키텍처 비교|5.2 환경별 보안 수준|5.2.1 환경별 보안 수준 비교|인증, 네트워크, 시크릿, 암호화 영역별 보안 수준과 강화 방안을 비교한 표 작성
+6. 모니터링 및 운영|6.1 환경별 모니터링 전략|6.1.1 환경별 모니터링 도구 비교|모니터링 도구, 메트릭, 알림, 로그 수집 방식을 환경별로 비교한 표 작성
+6. 모니터링 및 운영|6.2 CI/CD 및 배포 전략|6.2.1 환경별 배포 방식 비교|배포 방식, 자동화, 테스트, 다운타임 허용도를 환경별로 비교한 표 작성
+7. 비용 분석|7.1 환경별 비용 구조|7.1.1 월간 비용 비교|구성요소별 개발환경과 운영환경 비용을 상세 비교한 표 작성
+7. 비용 분석|7.1 환경별 비용 구조|7.1.2 환경별 비용 최적화 전략 비교|컴퓨팅, 백킹서비스, 리소스 관리 최적화 방안을 환경별로 비교한 표 작성
+8. 전환 및 확장 계획|8.1 개발환경 → 운영환경 전환 체크리스트||데이터 마이그레이션, 설정 변경, 모니터링 등 전환 체크리스트를 카테고리별로 표 작성
+8. 전환 및 확장 계획|8.2 단계별 확장 로드맵||Phase 1-3 단계별 기간, 핵심 목표, 주요 작업, 사용자 지원, 가용성을 표로 정리
+9. 핵심 SLA 지표|9.1 환경별 서비스 수준 목표||가용성, 응답시간, 배포시간, 복구시간, 동시사용자, 월간비용을 환경별로 비교한 표 작성
+```
+
+[참고자료]
+- 아키텍처패턴
+- 논리아키텍처
+- 외부시퀀스설계서
+- 데이터설계서
+- HighLevel아키텍처정의서
+
+[예시]
+- 개발환경 물리아키텍처 설계서: https://raw.githubusercontent.com/cna-bootcamp/clauding-guide/refs/heads/main/samples/physical/sample-physical-architecture-dev.md
+- 운영환경 물리아키텍처 설계서: https://raw.githubusercontent.com/cna-bootcamp/clauding-guide/refs/heads/main/samples/physical/sample-physical-architecture-prod.md
+- 마스터 물리아키텍처 설계서: https://raw.githubusercontent.com/cna-bootcamp/clauding-guide/refs/heads/main/samples/physical/sample-physical-architecture.md
+- 개발환경 물리아키텍처 다이어그램: https://raw.githubusercontent.com/cna-bootcamp/clauding-guide/refs/heads/main/samples/physical/sample-physical-architecture-dev.mmd
+- 운영환경 물리아키텍처 다이어그램: https://raw.githubusercontent.com/cna-bootcamp/clauding-guide/refs/heads/main/samples/physical/sample-physical-architecture-prod.mmd
+- 개발환경 네트워크 다이어그램: https://raw.githubusercontent.com/cna-bootcamp/clauding-guide/refs/heads/main/samples/physical/sample-network-dev.mmd 
+- 운영환경 네트워크 다이어그램: https://raw.githubusercontent.com/cna-bootcamp/clauding-guide/refs/heads/main/samples/physical/sample-network-prod.mmd 
+
+[결과파일]
+- design/backend/physical/physical-architecture.md
+- design/backend/physical/physical-architecture-dev.md
+- design/backend/physical/physical-architecture-prod.md
+- design/backend/physical/physical-architecture-dev.mmd
+- design/backend/physical/physical-architecture-prod.mmd
+- design/backend/physical/network-dev.mmd
+- design/backend/physical/network-prod.mmd

claude/sample-network-dev.mmd

@@ -0,0 +1,138 @@
+graph TB
+    %% 개발환경 네트워크 다이어그램
+    %% AI 기반 여행 일정 생성 서비스 - 개발환경
+
+    %% 외부 영역
+    subgraph Internet["🌐 인터넷"]
+        Developer["👨‍💻 개발자"]
+        QATester["🧪 QA팀"]
+    end
+
+    %% Azure 클라우드 영역
+    subgraph AzureCloud["☁️ Azure Cloud"]
+        
+        %% Virtual Network
+        subgraph VNet["🏢 Virtual Network (VNet)<br/>주소 공간: 10.0.0.0/16"]
+            
+            %% AKS 서브넷
+            subgraph AKSSubnet["🎯 AKS Subnet<br/>10.0.1.0/24"]
+                
+                %% Kubernetes 클러스터
+                subgraph AKSCluster["⚙️ AKS Cluster"]
+                    
+                    %% Ingress Controller
+                    subgraph IngressController["🚪 NGINX Ingress Controller"]
+                        LoadBalancer["⚖️ LoadBalancer Service<br/>(External IP)"]
+                        IngressPod["📦 Ingress Controller Pod"]
+                    end
+                    
+                    %% Application Tier
+                    subgraph AppTier["🚀 Application Tier"]
+                        UserService["👤 User Service<br/>Pod"]
+                        TripService["🗺️ Trip Service<br/>Pod"]
+                        AIService["🤖 AI Service<br/>Pod"]
+                        LocationService["📍 Location Service<br/>Pod"]
+                    end
+                    
+                    %% Database Tier
+                    subgraph DBTier["🗄️ Database Tier"]
+                        PostgreSQL["🐘 PostgreSQL<br/>Pod"]
+                        PostgreSQLStorage["💾 hostPath Volume<br/>(/data/postgresql)"]
+                    end
+                    
+                    %% Cache Tier
+                    subgraph CacheTier["⚡ Cache Tier"]
+                        Redis["🔴 Redis<br/>Pod"]
+                    end
+                    
+                    %% Cluster Internal Services
+                    subgraph ClusterServices["🔗 ClusterIP Services"]
+                        UserServiceDNS["user-service:8080"]
+                        TripServiceDNS["trip-service:8080"]
+                        AIServiceDNS["ai-service:8080"]
+                        LocationServiceDNS["location-service:8080"]
+                        PostgreSQLDNS["postgresql:5432"]
+                        RedisDNS["redis:6379"]
+                    end
+                end
+            end
+            
+            %% Service Bus 서브넷
+            subgraph ServiceBusSubnet["📨 Service Bus Subnet<br/>10.0.2.0/24"]
+                ServiceBus["📮 Azure Service Bus<br/>(Basic Tier)"]
+                
+                subgraph Queues["📬 Message Queues"]
+                    AIQueue["🤖 ai-schedule-generation"]
+                    LocationQueue["📍 location-search"]
+                    NotificationQueue["🔔 notification"]
+                end
+            end
+        end
+    end
+
+    %% 네트워크 연결 관계
+
+    %% 외부에서 클러스터로의 접근
+    Developer -->|"HTTPS:443<br/>(개발용 도메인)"| LoadBalancer
+    QATester -->|"API 호출/테스트"| LoadBalancer
+
+    %% Ingress Controller 내부 흐름
+    LoadBalancer -->|"트래픽 라우팅"| IngressPod
+
+    %% Ingress에서 Application Services로
+    IngressPod -->|"/api/users/**"| UserServiceDNS
+    IngressPod -->|"/api/trips/**"| TripServiceDNS
+    IngressPod -->|"/api/ai/**"| AIServiceDNS
+    IngressPod -->|"/api/locations/**"| LocationServiceDNS
+
+    %% ClusterIP Services에서 실제 Pod로
+    UserServiceDNS -->|"내부 로드밸런싱"| UserService
+    TripServiceDNS -->|"내부 로드밸런싱"| TripService
+    AIServiceDNS -->|"내부 로드밸런싱"| AIService
+    LocationServiceDNS -->|"내부 로드밸런싱"| LocationService
+
+    %% Application Services에서 Database로
+    UserService -->|"DB 연결<br/>TCP:5432"| PostgreSQLDNS
+    TripService -->|"DB 연결<br/>TCP:5432"| PostgreSQLDNS
+    AIService -->|"DB 연결<br/>TCP:5432"| PostgreSQLDNS
+    LocationService -->|"DB 연결<br/>TCP:5432"| PostgreSQLDNS
+
+    %% Application Services에서 Cache로
+    UserService -->|"캐시 연결<br/>TCP:6379"| RedisDNS
+    TripService -->|"캐시 연결<br/>TCP:6379"| RedisDNS
+    AIService -->|"캐시 연결<br/>TCP:6379"| RedisDNS
+    LocationService -->|"캐시 연결<br/>TCP:6379"| RedisDNS
+
+    %% ClusterIP Services에서 실제 Pod로 (Database/Cache)
+    PostgreSQLDNS -->|"DB 요청 처리"| PostgreSQL
+    RedisDNS -->|"캐시 요청 처리"| Redis
+
+    %% Storage 연결
+    PostgreSQL -->|"데이터 영속화"| PostgreSQLStorage
+
+    %% Service Bus 연결
+    AIService -->|"비동기 메시징<br/>HTTPS/AMQP"| ServiceBus
+    LocationService -->|"비동기 메시징<br/>HTTPS/AMQP"| ServiceBus
+    TripService -->|"알림 메시징<br/>HTTPS/AMQP"| ServiceBus
+
+    ServiceBus --> AIQueue
+    ServiceBus --> LocationQueue
+    ServiceBus --> NotificationQueue
+
+    %% 스타일 정의
+    classDef azureStyle fill:#0078D4,stroke:#fff,stroke-width:2px,color:#fff
+    classDef k8sStyle fill:#326CE5,stroke:#fff,stroke-width:2px,color:#fff
+    classDef appStyle fill:#28A745,stroke:#fff,stroke-width:2px,color:#fff
+    classDef dbStyle fill:#DC3545,stroke:#fff,stroke-width:2px,color:#fff
+    classDef cacheStyle fill:#FF6B35,stroke:#fff,stroke-width:2px,color:#fff
+    classDef serviceStyle fill:#6610F2,stroke:#fff,stroke-width:2px,color:#fff
+    classDef queueStyle fill:#FD7E14,stroke:#fff,stroke-width:2px,color:#fff
+
+    %% 스타일 적용
+    class AzureCloud,VNet azureStyle
+    class AKSCluster,AKSSubnet,IngressController k8sStyle
+    class AppTier,UserService,TripService,AIService,LocationService appStyle
+    class DBTier,PostgreSQL,PostgreSQLStorage dbStyle
+    class CacheTier,Redis cacheStyle
+    class ClusterServices,UserServiceDNS,TripServiceDNS,AIServiceDNS,LocationServiceDNS,PostgreSQLDNS,RedisDNS serviceStyle
+    class ServiceBus,ServiceBusSubnet,Queues,AIQueue,LocationQueue,NotificationQueue queueStyle

claude/sample-network-prod.mmd

@@ -0,0 +1,190 @@
+graph TB
+    %% 운영환경 네트워크 다이어그램
+    %% AI 기반 여행 일정 생성 서비스 - 운영환경
+
+    %% 외부 영역
+    subgraph Internet["🌐 인터넷"]
+        Users["👥 실사용자<br/>(1만~10만 명)"]
+        CDN["🌍 Azure Front Door<br/>+ CDN"]
+    end
+
+    %% Azure 클라우드 영역
+    subgraph AzureCloud["☁️ Azure Cloud (운영환경)"]
+        
+        %% Virtual Network
+        subgraph VNet["🏢 Virtual Network (VNet)<br/>주소 공간: 10.0.0.0/16"]
+            
+            %% Gateway Subnet
+            subgraph GatewaySubnet["🚪 Gateway Subnet<br/>10.0.4.0/24"]
+                subgraph AppGateway["🛡️ Application Gateway + WAF"]
+                    PublicIP["📍 Public IP<br/>(고정)"]
+                    PrivateIP["📍 Private IP<br/>(10.0.4.10)"]
+                    WAF["🛡️ WAF<br/>(OWASP CRS 3.2)"]
+                    RateLimiter["⏱️ Rate Limiting<br/>(100 req/min/IP)"]
+                end
+            end
+            
+            %% Application Subnet
+            subgraph AppSubnet["🎯 Application Subnet<br/>10.0.1.0/24"]
+                
+                %% AKS 클러스터
+                subgraph AKSCluster["⚙️ AKS Premium Cluster<br/>(Multi-Zone)"]
+                    
+                    %% System Node Pool
+                    subgraph SystemNodes["🔧 System Node Pool"]
+                        SystemNode1["📦 System Node 1<br/>(Zone 1)"]
+                        SystemNode2["📦 System Node 2<br/>(Zone 2)"]
+                        SystemNode3["📦 System Node 3<br/>(Zone 3)"]
+                    end
+                    
+                    %% Application Node Pool
+                    subgraph AppNodes["🚀 Application Node Pool"]
+                        AppNode1["📦 App Node 1<br/>(Zone 1)"]
+                        AppNode2["📦 App Node 2<br/>(Zone 2)"]
+                        AppNode3["📦 App Node 3<br/>(Zone 3)"]
+                    end
+                    
+                    %% Application Services (High Availability)
+                    subgraph AppServices["🚀 Application Services"]
+                        UserServiceHA["👤 User Service<br/>(3 replicas, HPA)"]
+                        TripServiceHA["🗺️ Trip Service<br/>(3 replicas, HPA)"]
+                        AIServiceHA["🤖 AI Service<br/>(2 replicas, HPA)"]
+                        LocationServiceHA["📍 Location Service<br/>(2 replicas, HPA)"]
+                    end
+                    
+                    %% Internal Load Balancer
+                    subgraph InternalLB["⚖️ Internal Services"]
+                        UserServiceLB["user-service:8080"]
+                        TripServiceLB["trip-service:8080"]
+                        AIServiceLB["ai-service:8080"]
+                        LocationServiceLB["location-service:8080"]
+                    end
+                end
+            end
+            
+            %% Database Subnet
+            subgraph DBSubnet["🗄️ Database Subnet<br/>10.0.2.0/24"]
+                subgraph AzurePostgreSQL["🐘 Azure PostgreSQL Flexible Server"]
+                    PGPrimary["📊 Primary Server<br/>(Zone 1)"]
+                    PGSecondary["📊 Read Replica<br/>(Zone 2)"]
+                    PGBackup["💾 Automated Backup<br/>(Point-in-time Recovery)"]
+                end
+            end
+            
+            %% Cache Subnet
+            subgraph CacheSubnet["⚡ Cache Subnet<br/>10.0.3.0/24"]
+                subgraph AzureRedis["🔴 Azure Cache for Redis Premium"]
+                    RedisPrimary["⚡ Primary Cache<br/>(Zone 1)"]
+                    RedisSecondary["⚡ Secondary Cache<br/>(Zone 2)"]
+                    RedisCluster["🔗 Redis Cluster<br/>(High Availability)"]
+                end
+            end
+        end
+        
+        %% Service Bus (Premium)
+        subgraph ServiceBus["📨 Azure Service Bus Premium"]
+            ServiceBusHA["📮 Service Bus Namespace<br/>(sb-tripgen-prod)"]
+            
+            subgraph QueuesHA["📬 Premium Message Queues"]
+                AIQueueHA["🤖 ai-schedule-generation<br/>(Partitioned, 16GB)"]
+                LocationQueueHA["📍 location-search<br/>(Partitioned, 16GB)"]
+                NotificationQueueHA["🔔 notification<br/>(Partitioned, 16GB)"]
+            end
+        end
+        
+        %% Private Endpoints
+        subgraph PrivateEndpoints["🔒 Private Endpoints"]
+            PGPrivateEndpoint["🔐 PostgreSQL<br/>Private Endpoint"]
+            RedisPrivateEndpoint["🔐 Redis<br/>Private Endpoint"]
+            ServiceBusPrivateEndpoint["🔐 Service Bus<br/>Private Endpoint"]
+        end
+    end
+
+    %% 네트워크 연결 관계
+
+    %% 외부에서 Azure로의 접근
+    Users -->|"HTTPS 요청"| CDN
+    CDN -->|"글로벌 가속"| PublicIP
+
+    %% Application Gateway 내부 흐름
+    PublicIP --> WAF
+    WAF --> RateLimiter
+    RateLimiter --> PrivateIP
+
+    %% Application Gateway에서 AKS로
+    PrivateIP -->|"/api/users/**<br/>NodePort 30080"| UserServiceLB
+    PrivateIP -->|"/api/trips/**<br/>NodePort 30081"| TripServiceLB
+    PrivateIP -->|"/api/ai/**<br/>NodePort 30082"| AIServiceLB
+    PrivateIP -->|"/api/locations/**<br/>NodePort 30083"| LocationServiceLB
+
+    %% Load Balancer에서 실제 서비스로
+    UserServiceLB -->|"고가용성 라우팅"| UserServiceHA
+    TripServiceLB -->|"고가용성 라우팅"| TripServiceHA
+    AIServiceLB -->|"고가용성 라우팅"| AIServiceHA
+    LocationServiceLB -->|"고가용성 라우팅"| LocationServiceHA
+
+    %% 서비스 배치 (Multi-Zone)
+    UserServiceHA -.-> AppNode1
+    UserServiceHA -.-> AppNode2
+    UserServiceHA -.-> AppNode3
+    
+    TripServiceHA -.-> AppNode1
+    TripServiceHA -.-> AppNode2
+    TripServiceHA -.-> AppNode3
+
+    %% Application Services에서 Database로 (Private Endpoint)
+    UserServiceHA -->|"Private Link<br/>TCP:5432"| PGPrivateEndpoint
+    TripServiceHA -->|"Private Link<br/>TCP:5432"| PGPrivateEndpoint
+    AIServiceHA -->|"Private Link<br/>TCP:5432"| PGPrivateEndpoint
+    LocationServiceHA -->|"Private Link<br/>TCP:5432"| PGPrivateEndpoint
+
+    %% Private Endpoint에서 실제 서비스로
+    PGPrivateEndpoint --> PGPrimary
+    PGPrivateEndpoint --> PGSecondary
+
+    %% Application Services에서 Cache로 (Private Endpoint)
+    UserServiceHA -->|"Private Link<br/>TCP:6379"| RedisPrivateEndpoint
+    TripServiceHA -->|"Private Link<br/>TCP:6379"| RedisPrivateEndpoint
+    AIServiceHA -->|"Private Link<br/>TCP:6379"| RedisPrivateEndpoint
+    LocationServiceHA -->|"Private Link<br/>TCP:6379"| RedisPrivateEndpoint
+
+    %% Private Endpoint에서 Redis로
+    RedisPrivateEndpoint --> RedisPrimary
+    RedisPrivateEndpoint --> RedisSecondary
+
+    %% High Availability 연결
+    PGPrimary -.->|"복제"| PGSecondary
+    RedisPrimary -.->|"HA 동기화"| RedisSecondary
+    PGPrimary -.->|"자동 백업"| PGBackup
+
+    %% Service Bus 연결 (Private Endpoint)
+    AIServiceHA -->|"Private Link<br/>HTTPS/AMQP"| ServiceBusPrivateEndpoint
+    LocationServiceHA -->|"Private Link<br/>HTTPS/AMQP"| ServiceBusPrivateEndpoint
+    TripServiceHA -->|"Private Link<br/>HTTPS/AMQP"| ServiceBusPrivateEndpoint
+
+    ServiceBusPrivateEndpoint --> ServiceBusHA
+    ServiceBusHA --> AIQueueHA
+    ServiceBusHA --> LocationQueueHA
+    ServiceBusHA --> NotificationQueueHA
+
+    %% 스타일 정의
+    classDef azureStyle fill:#0078D4,stroke:#fff,stroke-width:2px,color:#fff
+    classDef k8sStyle fill:#326CE5,stroke:#fff,stroke-width:2px,color:#fff
+    classDef appStyle fill:#28A745,stroke:#fff,stroke-width:2px,color:#fff
+    classDef dbStyle fill:#DC3545,stroke:#fff,stroke-width:2px,color:#fff
+    classDef cacheStyle fill:#FF6B35,stroke:#fff,stroke-width:2px,color:#fff
+    classDef serviceStyle fill:#6610F2,stroke:#fff,stroke-width:2px,color:#fff
+    classDef queueStyle fill:#FD7E14,stroke:#fff,stroke-width:2px,color:#fff
+    classDef securityStyle fill:#E83E8C,stroke:#fff,stroke-width:2px,color:#fff
+    classDef haStyle fill:#20C997,stroke:#fff,stroke-width:2px,color:#fff
+
+    %% 스타일 적용
+    class AzureCloud,VNet azureStyle
+    class AKSCluster,AppSubnet,SystemNodes,AppNodes k8sStyle
+    class AppServices,UserServiceHA,TripServiceHA,AIServiceHA,LocationServiceHA appStyle
+    class DBSubnet,AzurePostgreSQL,PGPrimary,PGSecondary,PGBackup dbStyle
+    class CacheSubnet,AzureRedis,RedisPrimary,RedisSecondary,RedisCluster cacheStyle
+    class InternalLB,UserServiceLB,TripServiceLB,AIServiceLB,LocationServiceLB serviceStyle
+    class ServiceBus,ServiceBusHA,QueuesHA,AIQueueHA,LocationQueueHA,NotificationQueueHA queueStyle
+    class AppGateway,WAF,RateLimiter,PrivateEndpoints,PGPrivateEndpoint,RedisPrivateEndpoint,ServiceBusPrivateEndpoint securityStyle
+    class CDN,SystemNode1,SystemNode2,SystemNode3,AppNode1,AppNode2,AppNode3 haStyle

claude/sample-physical-architecture-dev.mmd

@@ -0,0 +1,49 @@
+graph TB
+    %% Development Environment Physical Architecture
+    %% Core Flow: Users → Ingress → Services → Database
+    
+    Users[Mobile/Web Users] --> Ingress[Kubernetes Ingress Controller]
+    
+    subgraph "Azure Kubernetes Service - Development"
+        Ingress --> UserService[User Service Pod]
+        Ingress --> TravelService[Travel Service Pod]
+        Ingress --> ScheduleService[AI Service Pod]
+        Ingress --> LocationService[Location Service Pod]
+        
+        UserService --> PostgreSQL[PostgreSQL Pod<br/>16GB Storage]
+        TravelService --> PostgreSQL
+        ScheduleService --> PostgreSQL
+        LocationService --> PostgreSQL
+        
+        UserService --> Redis[Redis Pod<br/>Memory Cache]
+        TravelService --> Redis
+        ScheduleService --> Redis
+        LocationService --> Redis
+        
+        TravelService --> ServiceBus[Azure Service Bus<br/>Basic Tier]
+        ScheduleService --> ServiceBus
+        LocationService --> ServiceBus
+    end
+    
+    %% External APIs
+    ExternalAPI[External APIs<br/>OpenAI, Maps, Weather] --> ScheduleService
+    ExternalAPI --> LocationService
+    
+    %% Essential Azure Services
+    AKS --> ContainerRegistry[Azure Container Registry]
+    
+    %% Node Configuration
+    subgraph "Node Pool"
+        NodePool[2x Standard B2s<br/>2 vCPU, 4GB RAM]
+    end
+    
+    %% Styling
+    classDef azureService fill:#0078d4,stroke:#333,stroke-width:2px,color:#fff
+    classDef microservice fill:#ff6b6b,stroke:#333,stroke-width:2px,color:#fff
+    classDef database fill:#4ecdc4,stroke:#333,stroke-width:2px,color:#fff
+    classDef external fill:#95e1d3,stroke:#333,stroke-width:2px,color:#333
+    
+    class Ingress,ServiceBus,ContainerRegistry azureService
+    class UserService,TravelService,ScheduleService,LocationService microservice
+    class PostgreSQL,Redis database
+    class Users,ExternalAPI external

claude/sample-physical-architecture-prod.mmd

@@ -0,0 +1,184 @@
+graph TB
+    %% Production Environment Physical Architecture
+    %% Enterprise-grade Azure Cloud Architecture
+    
+    Users[Mobile/Web Users<br/>1만~10만 명] --> CDN[Azure Front Door<br/>+ CDN]
+    
+    subgraph "Azure Cloud - Production Environment"
+        CDN --> AppGateway[Application Gateway<br/>+ WAF v2<br/>Zone Redundant]
+        
+        subgraph "VNet (10.0.0.0/16)"
+            subgraph "Gateway Subnet (10.0.4.0/24)"
+                AppGateway
+            end
+            
+            subgraph "Application Subnet (10.0.1.0/24)"
+                subgraph "AKS Premium Cluster - Multi-Zone"
+                    direction TB
+                    
+                    subgraph "System Node Pool"
+                        SystemNode1[System Node 1<br/>Zone 1<br/>D2s_v3]
+                        SystemNode2[System Node 2<br/>Zone 2<br/>D2s_v3]
+                        SystemNode3[System Node 3<br/>Zone 3<br/>D2s_v3]
+                    end
+                    
+                    subgraph "Application Node Pool"
+                        AppNode1[App Node 1<br/>Zone 1<br/>D4s_v3]
+                        AppNode2[App Node 2<br/>Zone 2<br/>D4s_v3]
+                        AppNode3[App Node 3<br/>Zone 3<br/>D4s_v3]
+                    end
+                    
+                    subgraph "Application Services"
+                        UserService[User Service<br/>3 replicas, HPA<br/>2-10 replicas]
+                        TripService[Trip Service<br/>3 replicas, HPA<br/>3-15 replicas]
+                        AIService[AI Service<br/>2 replicas, HPA<br/>2-8 replicas]
+                        LocationService[Location Service<br/>2 replicas, HPA<br/>2-10 replicas]
+                    end
+                end
+            end
+            
+            AppGateway -->|NodePort 30080-30083| UserService
+            AppGateway -->|NodePort 30080-30083| TripService  
+            AppGateway -->|NodePort 30080-30083| AIService
+            AppGateway -->|NodePort 30080-30083| LocationService
+            
+            subgraph "Database Subnet (10.0.2.0/24)"
+                PostgreSQLPrimary[Azure PostgreSQL<br/>Flexible Server<br/>Primary - Zone 1<br/>GP_Standard_D4s_v3]
+                PostgreSQLReplica[PostgreSQL<br/>Read Replica<br/>Zone 2]
+                PostgreSQLBackup[Automated Backup<br/>Point-in-time Recovery<br/>35 days retention]
+            end
+            
+            subgraph "Cache Subnet (10.0.3.0/24)"
+                RedisPrimary[Azure Redis Premium<br/>P2 - 6GB<br/>Primary - Zone 1]
+                RedisSecondary[Redis Secondary<br/>Zone 2<br/>HA Enabled]
+            end
+        end
+        
+        subgraph "Service Bus Premium"
+            ServiceBusPremium[Azure Service Bus<br/>Premium Tier<br/>sb-tripgen-prod]
+            
+            subgraph "Message Queues"
+                AIQueue[ai-schedule-generation<br/>Partitioned, 16GB]
+                LocationQueue[location-search<br/>Partitioned, 16GB]  
+                NotificationQueue[notification<br/>Partitioned, 16GB]
+            end
+        end
+        
+        subgraph "Private Endpoints"
+            PostgreSQLEndpoint[PostgreSQL<br/>Private Endpoint<br/>10.0.2.10]
+            RedisEndpoint[Redis<br/>Private Endpoint<br/>10.0.3.10]
+            ServiceBusEndpoint[Service Bus<br/>Private Endpoint<br/>10.0.5.10]
+            KeyVaultEndpoint[Key Vault<br/>Private Endpoint<br/>10.0.6.10]
+        end
+        
+        subgraph "Security & Management"
+            KeyVault[Azure Key Vault<br/>Premium<br/>HSM-backed]
+            AAD[Azure Active Directory<br/>RBAC Integration]
+            Monitor[Azure Monitor<br/>+ Application Insights<br/>Log Analytics]
+        end
+        
+        %% Private Link Connections
+        UserService -->|Private Link| PostgreSQLEndpoint
+        TripService -->|Private Link| PostgreSQLEndpoint
+        AIService -->|Private Link| PostgreSQLEndpoint
+        LocationService -->|Private Link| PostgreSQLEndpoint
+        
+        PostgreSQLEndpoint --> PostgreSQLPrimary
+        PostgreSQLEndpoint --> PostgreSQLReplica
+        
+        UserService -->|Private Link| RedisEndpoint
+        TripService -->|Private Link| RedisEndpoint
+        AIService -->|Private Link| RedisEndpoint
+        LocationService -->|Private Link| RedisEndpoint
+        
+        RedisEndpoint --> RedisPrimary
+        RedisEndpoint --> RedisSecondary
+        
+        AIService -->|Private Link| ServiceBusEndpoint
+        LocationService -->|Private Link| ServiceBusEndpoint
+        TripService -->|Private Link| ServiceBusEndpoint
+        
+        ServiceBusEndpoint --> ServiceBusPremium
+        ServiceBusPremium --> AIQueue
+        ServiceBusPremium --> LocationQueue
+        ServiceBusPremium --> NotificationQueue
+        
+        %% High Availability Connections
+        PostgreSQLPrimary -.->|Replication| PostgreSQLReplica
+        PostgreSQLPrimary -.->|Auto Backup| PostgreSQLBackup
+        RedisPrimary -.->|HA Sync| RedisSecondary
+        
+        %% Security Connections
+        UserService -.->|Managed Identity| KeyVaultEndpoint
+        TripService -.->|Managed Identity| KeyVaultEndpoint
+        AIService -.->|Managed Identity| KeyVaultEndpoint
+        LocationService -.->|Managed Identity| KeyVaultEndpoint
+        
+        KeyVaultEndpoint --> KeyVault
+        
+        UserService -.->|RBAC| AAD
+        TripService -.->|RBAC| AAD
+        AIService -.->|RBAC| AAD
+        LocationService -.->|RBAC| AAD
+        
+        %% Monitoring Connections
+        UserService -.->|Telemetry| Monitor
+        TripService -.->|Telemetry| Monitor
+        AIService -.->|Telemetry| Monitor
+        LocationService -.->|Telemetry| Monitor
+    end
+    
+    %% External Integrations
+    subgraph "External Services"
+        ExternalAPI[External APIs<br/>OpenAI GPT-4 Turbo<br/>Google Maps API<br/>OpenWeatherMap API]
+    end
+    
+    %% External Connections
+    ExternalAPI -->|HTTPS/TLS 1.3| AIService
+    ExternalAPI -->|HTTPS/TLS 1.3| LocationService
+    
+    %% DevOps & CI/CD
+    subgraph "DevOps Infrastructure"
+        GitHubActions[GitHub Actions<br/>Enterprise CI/CD]
+        ArgoCD[ArgoCD<br/>GitOps Deployment<br/>HA Mode]
+        ContainerRegistry[Azure Container Registry<br/>Premium Tier<br/>Geo-replicated]
+    end
+    
+    %% DevOps Connections
+    GitHubActions -->|Build & Push| ContainerRegistry
+    ArgoCD -->|Deploy| UserService
+    ArgoCD -->|Deploy| TripService
+    ArgoCD -->|Deploy| AIService
+    ArgoCD -->|Deploy| LocationService
+    
+    %% Backup & DR
+    subgraph "Backup & Disaster Recovery"
+        BackupVault[Azure Backup Vault<br/>GRS - 99.999999999%]
+        DRSite[DR Site<br/>Secondary Region<br/>Korea Central]
+    end
+    
+    PostgreSQLPrimary -.->|Automated Backup| BackupVault
+    RedisPrimary -.->|Data Persistence| BackupVault
+    ContainerRegistry -.->|Image Backup| BackupVault
+    BackupVault -.->|Geo-replication| DRSite
+    
+    %% Styling
+    classDef azureService fill:#0078d4,stroke:#333,stroke-width:2px,color:#fff
+    classDef microservice fill:#28a745,stroke:#333,stroke-width:2px,color:#fff
+    classDef database fill:#dc3545,stroke:#333,stroke-width:2px,color:#fff
+    classDef security fill:#ffc107,stroke:#333,stroke-width:2px,color:#333
+    classDef external fill:#17a2b8,stroke:#333,stroke-width:2px,color:#fff
+    classDef devops fill:#6f42c1,stroke:#333,stroke-width:2px,color:#fff
+    classDef backup fill:#e83e8c,stroke:#333,stroke-width:2px,color:#fff
+    classDef privateEndpoint fill:#fd7e14,stroke:#333,stroke-width:2px,color:#fff
+    classDef nodePool fill:#20c997,stroke:#333,stroke-width:2px,color:#fff
+    
+    class CDN,AppGateway,ServiceBusPremium,ContainerRegistry,Monitor,AAD azureService
+    class UserService,TripService,AIService,LocationService microservice
+    class PostgreSQLPrimary,PostgreSQLReplica,PostgreSQLBackup,RedisPrimary,RedisSecondary database
+    class KeyVault,KeyVaultEndpoint security
+    class Users,ExternalAPI external
+    class GitHubActions,ArgoCD devops
+    class BackupVault,DRSite backup
+    class PostgreSQLEndpoint,RedisEndpoint,ServiceBusEndpoint privateEndpoint
+    class SystemNode1,SystemNode2,SystemNode3,AppNode1,AppNode2,AppNode3 nodePool

claude/sample-physical-architecture.md

@@ -0,0 +1,268 @@
+# 물리 아키텍처 설계서 - 마스터 인덱스
+
+## 1. 개요
+
+### 1.1 설계 목적
+- AI 기반 여행 일정 생성 서비스의 Azure Cloud 기반 물리 아키텍처 설계
+- 개발환경과 운영환경의 체계적인 아키텍처 분리 및 관리
+- 환경별 특화 구성과 단계적 확장 전략 제시
+
+### 1.2 아키텍처 분리 원칙
+- **환경별 특화**: 개발환경과 운영환경의 목적에 맞는 최적화
+- **단계적 발전**: 개발→운영 단계적 아키텍처 진화
+- **비용 효율성**: 환경별 비용 최적화 전략
+- **운영 단순성**: 환경별 복잡도 적정 수준 유지
+
+### 1.3 문서 구조
+```
+physical-architecture.md (마스터 인덱스)
+├── physical-architecture-dev.md (개발환경)
+└── physical-architecture-prod.md (운영환경)
+```
+
+### 1.4 참조 아키텍처
+- HighLevel아키텍처정의서: design/high-level-architecture.md
+- 논리아키텍처: design/backend/logical/logical-architecture.md
+- 아키텍처패턴: design/pattern/아키텍처패턴.md
+- API설계서: design/backend/api/*.yaml
+
+## 2. 환경별 아키텍처 개요
+
+### 2.1 환경별 특성 비교
+
+| 구분 | 개발환경 | 운영환경 |
+|------|----------|----------|
+| **목적** | MVP 개발/검증 | 실제 서비스 운영 |
+| **가용성** | 95% | 99.9% |
+| **사용자** | 개발팀(5명) | 실사용자(1만~10만) |
+| **확장성** | 고정 리소스 | 자동 스케일링 |
+| **보안** | 기본 수준 | 엔터프라이즈급 |
+| **비용** | 최소화($150/월) | 최적화($2,650/월) |
+| **복잡도** | 단순 | 고도화 |
+
+### 2.2 환경별 세부 문서
+
+#### 2.2.1 개발환경 아키텍처
+📄 **[물리 아키텍처 설계서 - 개발환경](./physical-architecture-dev.md)**
+
+**주요 특징:**
+- **비용 최적화**: Spot Instance, 로컬 스토리지 활용
+- **개발 편의성**: 복잡한 설정 최소화, 빠른 배포
+- **단순한 보안**: 기본 Network Policy, JWT 검증
+- **Pod 기반 백킹서비스**: PostgreSQL, Redis Pod 배포
+
+**핵심 구성:**
+📄 **[개발환경 물리 아키텍처 다이어그램](./physical-architecture-dev.mmd)**
+- NGINX Ingress → AKS Basic → Pod Services 구조
+- Application Pods, PostgreSQL Pod, Redis Pod 배치
+
+#### 2.2.2 운영환경 아키텍처  
+📄 **[물리 아키텍처 설계서 - 운영환경](./physical-architecture-prod.md)**
+
+**주요 특징:**
+- **고가용성**: Multi-Zone 배포, 자동 장애조치
+- **확장성**: HPA 기반 자동 스케일링 (10배 확장)
+- **엔터프라이즈 보안**: 다층 보안, Private Endpoint
+- **관리형 서비스**: Azure Database, Cache for Redis
+
+**핵심 구성:**
+📄 **[운영환경 물리 아키텍처 다이어그램](./physical-architecture-prod.mmd)**
+- Azure Front Door → App Gateway + WAF → AKS Premium 구조
+- Multi-Zone Apps, Azure PostgreSQL, Azure Redis Premium 배치
+
+### 2.3 핵심 아키텍처 결정사항
+
+#### 2.3.1 공통 아키텍처 원칙
+- **서비스 메시 제거**: Istio 대신 Kubernetes Network Policies 사용
+- **비동기 통신 중심**: 직접적인 서비스 간 호출 최소화
+- **Managed Identity**: 키 없는 인증으로 보안 강화
+- **다층 보안**: L1(Network) → L2(Gateway) → L3(Identity) → L4(Data)
+
+#### 2.3.2 환경별 차별화 전략
+
+**개발환경 최적화:**
+- 개발 속도와 비용 효율성 우선
+- 단순한 구성으로 운영 부담 최소화
+- Pod 기반 백킹서비스로 의존성 제거
+
+**운영환경 최적화:**
+- 가용성과 확장성 우선
+- 관리형 서비스로 운영 안정성 확보
+- 엔터프라이즈급 보안 및 모니터링
+
+## 3. 네트워크 아키텍처 비교
+
+### 3.1 환경별 네트워크 전략
+
+#### 3.1.1 환경별 네트워크 전략 비교
+
+| 구성 요소 | 개발환경 | 운영환경 | 비교 |
+|-----------|----------|----------|------|
+| **인그레스** | NGINX Ingress Controller | Azure Application Gateway + WAF | 운영환경에서 WAF 보안 강화 |
+| **네트워크** | 단일 서브넷 구성 | 다중 서브넷 (Application/Database/Cache) | 운영환경에서 계층적 분리 |
+| **보안** | 기본 Network Policy | Private Endpoint, NSG 강화 | 운영환경에서 엔터프라이즈급 보안 |
+| **접근** | 인터넷 직접 접근 허용 | Private Link 기반 보안 접근 | 운영환경에서 보안 접근 제한 |
+
+### 3.2 네트워크 보안 전략
+
+#### 3.2.1 공통 보안 원칙
+- **Network Policies**: Pod 간 통신 제어
+- **Managed Identity**: 키 없는 인증
+- **Private Endpoints**: Azure 서비스 보안 접근
+- **TLS 암호화**: 모든 외부 통신
+
+#### 3.2.2 환경별 보안 수준
+
+| 보안 요소 | 개발환경 | 운영환경 | 보안 수준 |
+|-----------|----------|----------|----------|
+| **Network Policy** | 기본 (개발 편의성 고려) | 엄격한 적용 | 운영환경에서 강화 |
+| **시크릿 관리** | Kubernetes Secrets | Azure Key Vault | 운영환경에서 HSM 보안 |
+| **암호화** | HTTPS 인그레스 레벨 | End-to-End TLS 1.3 | 운영환경에서 완전 암호화 |
+| **웹 보안** | - | WAF + DDoS 보호 | 운영환경 전용 |
+
+## 4. 데이터 아키텍처 비교
+
+### 4.1 환경별 데이터 전략
+
+#### 4.1.1 환경별 데이터 구성 비교
+
+| 데이터 서비스 | 개발환경 | 운영환경 | 가용성 | 비용 |
+|-------------|----------|----------|---------|------|
+| **PostgreSQL** | Kubernetes Pod (hostPath) | Azure Database Flexible Server | 95% vs 99.9% | 무료 vs $450/월 |
+| **Redis** | Memory Only Pod | Azure Cache Premium (Cluster) | 단일 vs 클러스터 | 무료 vs $250/월 |
+| **백업** | 수동 (주 1회) | 자동 (35일 보존) | 로컬 vs 지역간 복제 | - |
+| **데이터 지속성** | 재시작 시 손실 가능 | Zone Redundant | - | - |
+
+### 4.2 캐시 전략 비교
+
+#### 4.2.1 다층 캐시 아키텍처
+| 캐시 계층 | 캐시 타입 | TTL | 개발환경 설정 | 운영환경 설정 | 용도 |
+|----------|----------|-----|-------------|-------------|------|
+| **L1_Application** | Caffeine Cache | 5분 | max_entries: 1000 | max_entries: 2000 | 애플리케이션 레벨 로컬 캐시 |
+| **L2_Distributed** | Redis | 30분 | cluster_mode: false | cluster_mode: true | 분산 캐시, eviction_policy: allkeys-lru |
+
+#### 4.2.2 환경별 캐시 특성 비교
+
+| 캐시 특성 | 개발환경 | 운영환경 | 비고 |
+|-----------|----------|----------|------|
+| **Redis 구성** | 단일 Pod | Premium 클러스터 | 운영환경에서 고가용성 |
+| **데이터 지속성** | 메모리 전용 | 지속성 백업 | 운영환경에서 데이터 보장 |
+| **성능** | 기본 성능 | 최적화된 성능 | 운영환경에서 향상된 처리 능력 |
+
+## 5. 보안 아키텍처 비교
+
+### 5.1 다층 보안 아키텍처
+
+#### 5.1.1 공통 보안 계층
+| 보안 계층 | 보안 기술 | 적용 범위 | 보안 목적 |
+|----------|----------|----------|----------|
+| **L1_Network** | Kubernetes Network Policies | Pod-to-Pod 통신 제어 | 내부 네트워크 마이크로 세그먼테이션 |
+| **L2_Gateway** | API Gateway JWT 검증 | 외부 요청 인증/인가 | API 레벨 인증 및 인가 제어 |
+| **L3_Identity** | Azure Managed Identity | Azure 서비스 접근 | 클라우드 리소스 안전한 접근 |
+| **L4_Data** | Private Link + Key Vault | 데이터 암호화 및 비밀 관리 | 엔드투엔드 데이터 보호 |
+
+### 5.2 환경별 보안 수준
+
+#### 5.2.1 환경별 보안 수준 비교
+
+| 보안 영역 | 개발환경 | 운영환경 | 보안 강화 |
+|-----------|----------|----------|----------|
+| **인증** | JWT (고정 시크릿) | Azure AD + Managed Identity | 운영환경에서 엔터프라이즈 인증 |
+| **네트워크** | 기본 Network Policy | 엄격한 Network Policy + Private Endpoint | 운영환경에서 네트워크 격리 강화 |
+| **시크릿** | Kubernetes Secrets | Azure Key Vault (HSM) | 운영환경에서 하드웨어 보안 모듈 |
+| **암호화** | HTTPS (인그레스 레벨) | End-to-End TLS 1.3 | 운영환경에서 전 구간 암호화 |
+
+## 6. 모니터링 및 운영
+
+### 6.1 환경별 모니터링 전략
+
+#### 6.1.1 환경별 모니터링 도구 비교
+
+| 모니터링 요소 | 개발환경 | 운영환경 | 기능 차이 |
+|-------------|----------|----------|----------|
+| **도구** | Kubernetes Dashboard, kubectl logs | Azure Monitor, Application Insights | 운영환경에서 전문 APM 도구 |
+| **메트릭** | 기본 Pod/Node 메트릭 | 포괄적 APM, 비즈니스 메트릭 | 운영환경에서 비즈니스 인사이트 |
+| **알림** | 기본 알림 (Pod 재시작) | 다단계 알림 (PagerDuty, Teams) | 운영환경에서 전문 알림 체계 |
+| **로그** | 로컬 파일시스템 (7일) | Log Analytics (90일) | 운영환경에서 장기 보존 |
+
+### 6.2 CI/CD 및 배포 전략
+
+#### 6.2.1 환별별 배포 방식
+
+#### 6.2.1 환경별 배포 방식 비교
+
+| 배포 요소 | 개발환경 | 운영환경 | 안정성 차이 |
+|-----------|----------|----------|----------|
+| **배포 방식** | Rolling Update | Blue-Green Deployment | 운영환경에서 무중단 배포 |
+| **자동화** | develop 브랜치 자동 | tag 생성 + 수동 승인 | 운영환경에서 더 신중한 배포 |
+| **테스트** | 기본 헬스체크 | 종합 품질 게이트 (80% 커버리지) | 운영환경에서 더 엄격한 테스트 |
+| **다운타임** | 허용 (1-2분) | Zero Downtime | 운영환경에서 서비스 연속성 보장 |
+
+## 7. 비용 분석
+
+### 7.1 환경별 비용 구조
+
+#### 7.1.1 월간 비용 비교 (USD)
+
+| 구성요소 | 개발환경 | 운영환경 | 차이 |
+|----------|----------|----------|------|
+| **컴퓨팅** | | | |
+| AKS 노드 | $120 (Spot) | $1,200 (Reserved) | 10배 |
+| **데이터** | | | |
+| PostgreSQL | $0 (Pod) | $450 (Managed) | 무제한 |
+| Redis | $0 (Pod) | $250 (Premium) | 무제한 |
+| **네트워킹** | | | |
+| Load Balancer | $20 | $150 | 7.5배 |
+| **기타** | | | |
+| Service Bus | $10 | $150 | 15배 |
+| 모니터링 | $0 | $100 | 무제한 |
+| **총합** | **$150** | **$2,650** | **17.7배** |
+
+#### 7.1.2 비용 최적화 전략
+
+#### 7.1.2 환경별 비용 최적화 전략 비교
+
+| 최적화 영역 | 개발환경 | 운영환경 | 절약 효과 |
+|-------------|----------|----------|----------|
+| **컴퓨팅 비용** | Spot Instances 사용 | Reserved Instances | 70% vs 30% 절약 |
+| **백킹서비스** | Pod 기반 (무료) | 관리형 서비스 | 100% 절약 vs 안정성 |
+| **리소스 관리** | 비업무시간 자동 종료 | 자동 스케일링 | 시간 절약 vs 효율성 |
+| **사이징 전략** | 고정 리소스 | 성능 기반 적정 sizing | 단순 vs 최적화 |
+
+## 8. 전환 및 확장 계획
+
+### 8.1 개발환경 → 운영환경 전환 체크리스트
+
+| 카테고리 | 체크 항목 | 상태 | 우선순위 | 비고 |
+|---------|-----------|------|----------|------|
+| **데이터 마이그레이션** | 개발 데이터 백업 | ☐ | 높음 | pg_dump 사용 |
+| **데이터 마이그레이션** | 스키마 마이그레이션 스크립트 | ☐ | 높음 | Flyway/Liquibase 고려 |
+| **데이터 마이그레이션** | Azure Database 프로비저닝 | ☐ | 높음 | Flexible Server 구성 |
+| **설정 변경** | 환경 변수 분리 | ☐ | 높음 | ConfigMap/Secret 분리 |
+| **설정 변경** | Azure Key Vault 설정 | ☐ | 높음 | HSM 보안 모듈 |
+| **설정 변경** | Managed Identity 구성 | ☐ | 높음 | 키 없는 인증 |
+| **모니터링** | Azure Monitor 설정 | ☐ | 중간 | Log Analytics 연동 |
+| **모니터링** | 알림 정책 수립 | ☐ | 중간 | PagerDuty/Teams 연동 |
+| **모니터링** | 대시보드 구축 | ☐ | 낮음 | Application Insights |
+
+### 8.2 단계별 확장 로드맵
+
+| 단계 | 기간 | 핵심 목표 | 주요 작업 | 사용자 지원 | 가용성 |
+|------|------|----------|----------|-------------|----------|
+| **Phase 1** | 현재-6개월 | 안정화 | 개발환경 → 운영환경 전환<br/>기본 모니터링 및 알림 구축 | 1만 사용자 | 99.9% |
+| **Phase 2** | 6-12개월 | 최적화 | 성능 최적화 및 비용 효율화<br/>고급 모니터링 (APM) 도입 | 10만 동시 사용자 | 99.9% |
+| **Phase 3** | 12-18개월 | 글로벌 확장 | 다중 리전 배포<br/>글로벌 CDN 및 로드 밸런싱 | 100만 사용자 | 99.95% |
+
+## 9. 핵심 SLA 지표
+
+### 9.1 환경별 서비스 수준 목표
+
+| SLA 항목 | 개발환경 | 운영환경 | 글로벌환경 (Phase 3) |
+|---------|----------|----------|---------------------|
+| **가용성** | 95% | 99.9% | 99.95% |
+| **응답시간** | < 10초 | < 5초 | < 2초 |
+| **배포시간** | 30분 | 10분 | 5분 |
+| **복구시간** | 수동 복구 | < 5분 | < 2분 |
+| **동시사용자** | 개발팀 (5명) | 10만명 | 100만명 |
+| **월간비용** | $150 | $2,650 | $15,000+ |
+| **보안인시던트** | 모니터링 없음 | 0건 목표 | 0건 목표 |