메시지 시스템 비교 (Message Systems Comparison)
메시지 시스템 비교 (Message Systems Comparison)¶
난이도: ⭐⭐⭐
개요¶
다양한 메시지 시스템들은 각각의 설계 철학과 강점을 가지고 있습니다. 이 장에서는 Apache Kafka, RabbitMQ, AWS SQS/SNS의 핵심 개념과 차이점을 학습하고, 사용 사례에 맞는 시스템을 선택하는 기준을 알아봅니다.
목차¶
1. Apache Kafka¶
Kafka 개요¶
Kafka는 LinkedIn에서 개발한 분산 스트리밍 플랫폼으로, 높은 처리량과 내구성을 제공합니다.
┌─────────────────────────────────────────────────────────────────────────┐
│ Kafka 아키텍처 │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌──────────────────────────────────────────────────────────────────┐ │
│ │ Kafka Cluster │ │
│ │ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │ │
│ │ │ Broker 1 │ │ Broker 2 │ │ Broker 3 │ │ │
│ │ │ (Leader) │ │ (Follower) │ │ (Follower) │ │ │
│ │ └─────────────┘ └─────────────┘ └─────────────┘ │ │
│ └──────────────────────────────────────────────────────────────────┘ │
│ ▲ │
│ │ ZooKeeper / KRaft │
│ │ (클러스터 메타데이터 관리) │
│ ▼ │
│ ┌──────────────────────────────────────────────────────────────────┐ │
│ │ ZooKeeper Ensemble │ │
│ │ ┌────────┐ ┌────────┐ ┌────────┐ │ │
│ │ │ ZK 1 │ │ ZK 2 │ │ ZK 3 │ │ │
│ │ └────────┘ └────────┘ └────────┘ │ │
│ └──────────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────┘
Topic과 Partition¶
┌─────────────────────────────────────────────────────────────────────────┐
│ Topic과 Partition │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ Topic: "orders" (3 Partitions) │
│ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ Partition 0 (Broker 1) │ │
│ │ ┌────┬────┬────┬────┬────┬────┐ │ │
│ │ │ 0 │ 1 │ 2 │ 3 │ 4 │ 5 │ ──► 오프셋 (offset) │ │
│ │ └────┴────┴────┴────┴────┴────┘ │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ Partition 1 (Broker 2) │ │
│ │ ┌────┬────┬────┬────┬────┐ │ │
│ │ │ 0 │ 1 │ 2 │ 3 │ 4 │ │ │
│ │ └────┴────┴────┴────┴────┘ │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ Partition 2 (Broker 3) │ │
│ │ ┌────┬────┬────┬────┬────┬────┬────┐ │ │
│ │ │ 0 │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ │ │
│ │ └────┴────┴────┴────┴────┴────┴────┘ │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
│ 특징: │
│ - 각 파티션은 순서 보장 │
│ - 파티션 간 순서는 보장 안됨 │
│ - 파티션 수로 병렬 처리 확장 │
│ │
└─────────────────────────────────────────────────────────────────────────┘
Consumer Group¶
┌─────────────────────────────────────────────────────────────────────────┐
│ Consumer Group │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ Topic: "orders" (4 Partitions) │
│ ┌───────────────────────────────────────────────────────────────┐ │
│ │ P0 P1 P2 P3 │ │
│ └───┬───────┬───────┬───────┬───────────────────────────────────┘ │
│ │ │ │ │ │
│ │ │ │ │ │
│ ┌───┴───────┴───────┴───────┴───────────────────────────────────┐ │
│ │ Consumer Group A (Order Service) │ │
│ │ ┌──────────┐ ┌──────────┐ ┌──────────┐ │ │
│ │ │Consumer 1│ │Consumer 2│ │Consumer 3│ │ │
│ │ │ P0, P1 │ │ P2 │ │ P3 │ │ │
│ │ └──────────┘ └──────────┘ └──────────┘ │ │
│ └───────────────────────────────────────────────────────────────┘ │
│ │ │ │ │ │
│ ┌───┴───────┴───────┴───────┴───────────────────────────────────┐ │
│ │ Consumer Group B (Analytics) │ │
│ │ ┌──────────────────────────────────────────────┐ │ │
│ │ │ Consumer 1 (P0, P1, P2, P3) │ │ │
│ │ └──────────────────────────────────────────────┘ │ │
│ └───────────────────────────────────────────────────────────────┘ │
│ │
│ 규칙: │
│ - 한 파티션은 그룹 내 하나의 Consumer만 소비 │
│ - Consumer > Partition 수 → 일부 Consumer idle │
│ - Consumer < Partition 수 → 일부 Consumer가 여러 파티션 담당 │
│ │
└─────────────────────────────────────────────────────────────────────────┘
Offset 관리¶
┌─────────────────────────────────────────────────────────────────────────┐
│ Offset 관리 │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ Partition 0: │
│ ┌────┬────┬────┬────┬────┬────┬────┬────┬────┬────┐ │
│ │ 0 │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ │
│ └────┴────┴────┴────┴────┴────┴────┴────┴────┴────┘ │
│ ▲ ▲ ▲ │
│ │ │ │ │
│ Committed Offset Current Position Log End Offset │
│ (Consumer가 (현재 처리중) (최신 메시지) │
│ 확인한 위치) │
│ │
│ ───────────────────────────────────────────────────────────────── │
│ │
│ __consumer_offsets (내부 토픽): │
│ ┌────────────────────────────────────────────────────────────────┐ │
│ │ Group: order-service, Topic: orders, Partition: 0 │ │
│ │ Committed Offset: 5 │ │
│ │ Timestamp: 2024-01-15T10:30:00Z │ │
│ └────────────────────────────────────────────────────────────────┘ │
│ │
│ Offset Reset 정책: │
│ - earliest: 처음부터 (모든 메시지) │
│ - latest: 최신부터 (새 메시지만) │
│ - none: 오프셋 없으면 에러 │
│ │
└─────────────────────────────────────────────────────────────────────────┘
분산 로그로서의 Kafka¶
┌─────────────────────────────────────────────────────────────────────────┐
│ Kafka = 분산 커밋 로그 │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ 전통적 메시지 큐: │
│ ┌─────────────────────────────────────┐ │
│ │ [msg] ─→ Queue ─→ Consumer ─→ 삭제 │ │
│ └─────────────────────────────────────┘ │
│ │
│ Kafka (로그 기반): │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ Append-Only Log │ │
│ │ ┌────┬────┬────┬────┬────┬────┬────┬────┐ │ │
│ │ │ 0 │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ ──► 새 메시지 추가 │ │
│ │ └────┴────┴────┴────┴────┴────┴────┴────┘ │ │
│ │ ▲ ▲ ▲ │ │
│ │ Consumer A Consumer B Consumer C │ │
│ │ (offset 1) (offset 3) (offset 6) │ │
│ │ │ │
│ │ - 메시지 삭제 안됨 (retention 기간까지 보존) │ │
│ │ - 각 Consumer가 자신의 오프셋 관리 │ │
│ │ - 과거 메시지 재처리 가능 (리플레이) │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
│ 장점: │
│ - 이벤트 소싱 지원 │
│ - 장애 복구 시 재처리 용이 │
│ - 여러 Consumer가 같은 데이터 독립적으로 처리 │
│ │
└─────────────────────────────────────────────────────────────────────────┘
Kafka 복제¶
┌─────────────────────────────────────────────────────────────────────────┐
│ Kafka Replication │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ Topic: orders, Partition 0 (Replication Factor: 3) │
│ │
│ ┌────────────────────┐ │
│ │ Broker 1 │ │
│ │ ┌──────────────┐ │ │
│ │ │ P0 (Leader) │◄─┼────── Producer (writes) │
│ │ │ [0][1][2][3] │──┼────── Consumer (reads) │
│ │ └──────────────┘ │ │
│ └─────────┬──────────┘ │
│ │ 복제 │
│ ┌──────┴──────┐ │
│ ▼ ▼ │
│ ┌──────────────────┐ ┌──────────────────┐ │
│ │ Broker 2 │ │ Broker 3 │ │
│ │ ┌──────────────┐ │ │ ┌──────────────┐ │ │
│ │ │P0 (Follower) │ │ │ │P0 (Follower) │ │ │
│ │ │ [0][1][2][3] │ │ │ │ [0][1][2][3] │ │ │
│ │ └──────────────┘ │ │ └──────────────┘ │ │
│ └──────────────────┘ └──────────────────┘ │
│ │
│ ISR (In-Sync Replicas): │
│ - Leader와 동기화된 복제본 목록 │
│ - acks=all: 모든 ISR에 쓰기 완료 후 ACK │
│ - Leader 장애 시 ISR 중 하나가 새 Leader │
│ │
└─────────────────────────────────────────────────────────────────────────┘
2. RabbitMQ¶
RabbitMQ 개요¶
RabbitMQ는 AMQP 프로토콜 기반의 전통적인 메시지 브로커입니다.
┌─────────────────────────────────────────────────────────────────────────┐
│ RabbitMQ 아키텍처 │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌──────────┐ ┌───────────────────────────────────┐ ┌─────────┐ │
│ │ Producer │────►│ RabbitMQ Broker │───►│Consumer │ │
│ └──────────┘ │ ┌──────────┐ ┌─────────────┐ │ └─────────┘ │
│ │ │ Exchange │───►│ Queue │ │ │
│ │ └──────────┘ └─────────────┘ │ │
│ └───────────────────────────────────┘ │
│ │
│ 핵심 구성 요소: │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ 1. Exchange: 메시지 라우팅 규칙 정의 │ │
│ │ 2. Queue: 메시지 저장소 │ │
│ │ 3. Binding: Exchange와 Queue 연결 │ │
│ │ 4. Routing Key: 라우팅 결정 키 │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────┘
Exchange 타입¶
┌─────────────────────────────────────────────────────────────────────────┐
│ Exchange 타입 │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ 1. Direct Exchange: │
│ ┌──────────┐ ┌──────────┐ ┌─────────┐ │
│ │ Producer │ │ Direct │ │ Queue A │ (routing_key=error) │
│ │ │────►│ Exchange │────►│ │ │
│ │ (error) │ │ │ └─────────┘ │
│ └──────────┘ │ │ ┌─────────┐ │
│ │ │────►│ Queue B │ (routing_key=info) │
│ └──────────┘ └─────────┘ │
│ │
│ → routing_key가 정확히 일치하는 Queue로 전달 │
│ │
├─────────────────────────────────────────────────────────────────────────┤
│ 2. Topic Exchange: │
│ ┌──────────┐ ┌──────────┐ ┌─────────────────────────────────┐│
│ │ Producer │ │ Topic │ │ Queue A: *.error ││
│ │ │────►│ Exchange │────►│ (orders.error, users.error) ││
│ │(orders. │ │ │ └─────────────────────────────────┘│
│ │ error) │ │ │ ┌─────────────────────────────────┐│
│ └──────────┘ │ │────►│ Queue B: orders.* ││
│ │ │ │ (orders.error, orders.info) ││
│ └──────────┘ └─────────────────────────────────┘│
│ │
│ → 패턴 매칭 (* = 한 단어, # = 0개 이상) │
│ │
├─────────────────────────────────────────────────────────────────────────┤
│ 3. Fanout Exchange: │
│ ┌──────────┐ ┌──────────┐ ┌─────────┐ │
│ │ Producer │ │ Fanout │────►│ Queue A │ │
│ │ │────►│ Exchange │────►│ Queue B │ 모든 Queue에 복사 │
│ │ │ │ │────►│ Queue C │ │
│ └──────────┘ └──────────┘ └─────────┘ │
│ │
│ → routing_key 무시, 바인딩된 모든 Queue에 브로드캐스트 │
│ │
├─────────────────────────────────────────────────────────────────────────┤
│ 4. Headers Exchange: │
│ ┌──────────┐ ┌──────────┐ ┌─────────┐ │
│ │ Producer │ │ Headers │────►│ Queue A │ │
│ │ headers: │────►│ Exchange │ │ x-match:│ │
│ │{type:pdf}│ │ │ │ all, │ │
│ └──────────┘ └──────────┘ │type:pdf │ │
│ └─────────┘ │
│ │
│ → 메시지 헤더 기반 라우팅 │
│ │
└─────────────────────────────────────────────────────────────────────────┘
RabbitMQ Routing 예시¶
┌─────────────────────────────────────────────────────────────────────────┐
│ Topic Exchange 라우팅 예시 │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ Topic Exchange: "logs" │
│ │
│ Bindings: │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ Queue Binding Key │ │
│ │ error_logs *.error │ │
│ │ web_logs web.* │ │
│ │ all_logs # │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
│ 메시지 라우팅: │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ Routing Key Goes to │ │
│ │ web.error error_logs, web_logs, all_logs │ │
│ │ web.info web_logs, all_logs │ │
│ │ db.error error_logs, all_logs │ │
│ │ cache.warning all_logs │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
│ 패턴 규칙: │
│ - * (star): 정확히 한 단어 │
│ - # (hash): 0개 이상의 단어 │
│ - 예: stock.# → stock.usd.nyse, stock.eur │
│ stock.* → stock.usd (O), stock.usd.nyse (X) │
│ │
└─────────────────────────────────────────────────────────────────────────┘
RabbitMQ 메시지 확인¶
┌─────────────────────────────────────────────────────────────────────────┐
│ Message Acknowledgment │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌──────────┐ ┌─────────┐ ┌──────────┐ │
│ │ Queue │ │Consumer │ │ App │ │
│ └────┬─────┘ └────┬────┘ └────┬─────┘ │
│ │ │ │ │
│ │── Deliver ────►│ │ │
│ │ │── Process ───►│ │
│ │ │ │ 처리 중... │
│ │ │◄── Done ──────│ │
│ │◄── ACK ────────│ │ │
│ │ │ │ │
│ │ (메시지 삭제) │ │ │
│ │
│ ACK 모드: │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ auto-ack: true → 전달 즉시 ACK (At-Most-Once) │ │
│ │ auto-ack: false → 명시적 ACK 필요 (At-Least-Once) │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
│ NACK/Reject: │
│ - basic_nack: 메시지 거부 (requeue 옵션) │
│ - basic_reject: 단일 메시지 거부 │
│ │
└─────────────────────────────────────────────────────────────────────────┘
RabbitMQ 고가용성¶
┌─────────────────────────────────────────────────────────────────────────┐
│ RabbitMQ Clustering │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ Classic Mirrored Queue (deprecated): │
│ ┌───────────────────────────────────────────────────────────────┐ │
│ │ Node 1 (Master) Node 2 (Mirror) Node 3 (Mirror) │ │
│ │ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │ │
│ │ │ Queue: Q1 │───►│ Queue: Q1 │───►│ Queue: Q1 │ │ │
│ │ │ [msg][msg] │ │ [msg][msg] │ │ [msg][msg] │ │ │
│ │ └─────────────┘ └─────────────┘ └─────────────┘ │ │
│ └───────────────────────────────────────────────────────────────┘ │
│ │
│ Quorum Queue (권장): │
│ ┌───────────────────────────────────────────────────────────────┐ │
│ │ Raft-based Consensus │ │
│ │ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │ │
│ │ │ Leader │ │ Follower │ │ Follower │ │ │
│ │ │ Node 1 │◄──►│ Node 2 │◄──►│ Node 3 │ │ │
│ │ └─────────────┘ └─────────────┘ └─────────────┘ │ │
│ │ │ │
│ │ - 더 강력한 데이터 일관성 │ │
│ │ - 자동 리더 선출 │ │
│ │ - poison message 처리 개선 │ │
│ └───────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────┘
3. AWS SQS/SNS¶
AWS SQS (Simple Queue Service)¶
┌─────────────────────────────────────────────────────────────────────────┐
│ AWS SQS 아키텍처 │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌──────────┐ ┌─────────────────────────────────┐ ┌─────────┐ │
│ │ Producer │────►│ SQS Queue │────►│Consumer │ │
│ └──────────┘ │ ┌─────────────────────────┐ │ └─────────┘ │
│ │ │ Distributed Storage │ │ │
│ │ │ (Multiple AZs) │ │ │
│ │ │ [msg][msg][msg][msg] │ │ │
│ │ └─────────────────────────┘ │ │
│ └─────────────────────────────────┘ │
│ │
│ 완전 관리형 서비스: │
│ - 무제한 처리량 │
│ - 자동 확장 │
│ - 인프라 관리 불필요 │
│ │
└─────────────────────────────────────────────────────────────────────────┘
Standard vs FIFO Queue¶
┌─────────────────────────────────────────────────────────────────────────┐
│ Standard Queue vs FIFO Queue │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ Standard Queue: │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ 전송: A → B → C → D │ │
│ │ 수신: A → C → B → D (순서 보장 안됨) │ │
│ │ 또는 A → A → B → C → D (중복 가능) │ │
│ │ │ │
│ │ 특징: │ │
│ │ - 최대 처리량: 거의 무제한 │ │
│ │ - At-Least-Once 전달 │ │
│ │ - Best-Effort 순서 │ │
│ │ - 가격: 저렴 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
│ FIFO Queue: │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ │ │
│ │ 전송: A → B → C → D │ │
│ │ 수신: A → B → C → D (순서 보장!) │ │
│ │ │ │
│ │ 특징: │ │
│ │ - 최대 처리량: 초당 3,000 메시지 (배치 시 30,000) │ │
│ │ - Exactly-Once 처리 │ │
│ │ - 엄격한 순서 보장 │ │
│ │ - Message Group ID로 병렬 처리 │ │
│ │ - 가격: Standard의 약 1.2배 │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────┘
FIFO Message Groups¶
┌─────────────────────────────────────────────────────────────────────────┐
│ FIFO Message Groups │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ FIFO Queue │ │
│ │ ┌─────────────────────────────────────────────────────────┐ │ │
│ │ │ Message Group: user-123 │ │ │
│ │ │ [order1] → [order2] → [order3] 순서 보장 │ │ │
│ │ └─────────────────────────────────────────────────────────┘ │ │
│ │ ┌─────────────────────────────────────────────────────────┐ │ │
│ │ │ Message Group: user-456 │ │ │
│ │ │ [order1] → [order2] 순서 보장 │ │ │
│ │ └─────────────────────────────────────────────────────────┘ │ │
│ │ ┌─────────────────────────────────────────────────────────┐ │ │
│ │ │ Message Group: user-789 │ │ │
│ │ │ [order1] 순서 보장 │ │ │
│ │ └─────────────────────────────────────────────────────────┘ │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │ │ │ │
│ ▼ ▼ ▼ │
│ ┌─────────┐ ┌─────────┐ ┌─────────┐ │
│ │Consumer1│ │Consumer2│ │Consumer3│ │
│ └─────────┘ └─────────┘ └─────────┘ │
│ │
│ - 같은 Group 내에서만 순서 보장 │
│ - 다른 Group은 병렬 처리 가능 │
│ - 확장성과 순서 보장의 균형 │
│ │
└─────────────────────────────────────────────────────────────────────────┘
AWS SNS (Simple Notification Service)¶
┌─────────────────────────────────────────────────────────────────────────┐
│ AWS SNS (Pub/Sub) │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────┐ │
│ ┌──────────┐ │ SNS Topic │ │
│ │Publisher │───────►│ "order-events" │ │
│ └──────────┘ └────────┬────────┘ │
│ │ │
│ ┌─────────────────────┼─────────────────────┐ │
│ │ │ │ │
│ ▼ ▼ ▼ │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ SQS Queue │ │ Lambda │ │ HTTP │ │
│ │ (Order Svc) │ │ (Analytics) │ │ (Webhook) │ │
│ └─────────────┘ └─────────────┘ └─────────────┘ │
│ │
│ 지원되는 Subscriber: │
│ - SQS Queue │
│ - Lambda Function │
│ - HTTP/HTTPS Endpoint │
│ - Email/SMS │
│ - Mobile Push │
│ - Kinesis Data Firehose │
│ │
└─────────────────────────────────────────────────────────────────────────┘
SNS + SQS 팬아웃 패턴¶
┌─────────────────────────────────────────────────────────────────────────┐
│ SNS + SQS Fan-out │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌──────────┐ ┌─────────────┐ │
│ │ Publisher│────►│ SNS Topic │ │
│ │ (Order) │ │ │ │
│ └──────────┘ └──────┬──────┘ │
│ │ │
│ ┌───────────────────┼───────────────────┐ │
│ │ │ │ │
│ ▼ ▼ ▼ │
│ ┌────────┐ ┌────────┐ ┌────────┐ │
│ │SQS: Q1 │ │SQS: Q2 │ │SQS: Q3 │ │
│ │Inventory│ │Payment │ │Email │ │
│ └───┬────┘ └───┬────┘ └───┬────┘ │
│ │ │ │ │
│ ▼ ▼ ▼ │
│ ┌────────┐ ┌────────┐ ┌────────┐ │
│ │Inventory│ │Payment │ │Email │ │
│ │Service │ │Service │ │Service │ │
│ └────────┘ └────────┘ └────────┘ │
│ │
│ 장점: │
│ - 서비스 간 완전한 분리 │
│ - 각 서비스 독립적 확장 │
│ - 장애 격리 │
│ - 개별 재시도/DLQ 관리 │
│ │
└─────────────────────────────────────────────────────────────────────────┘
4. 시스템 비교 및 선택 기준¶
핵심 특성 비교¶
┌─────────────────────────────────────────────────────────────────────────┐
│ 메시지 시스템 비교 │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌────────────┬────────────┬────────────┬────────────┐ │
│ │ 특성 │ Kafka │ RabbitMQ │ AWS SQS │ │
│ ├────────────┼────────────┼────────────┼────────────┤ │
│ │ 처리량 │ 매우 높음 │ 높음 │ 높음 │ │
│ │ │ 수백만/초 │ 수만/초 │ 무제한* │ │
│ ├────────────┼────────────┼────────────┼────────────┤ │
│ │ 지연시간 │ 낮음 │ 매우 낮음 │ 중간 │ │
│ │ │ ms 단위 │ sub-ms │ 수십 ms │ │
│ ├────────────┼────────────┼────────────┼────────────┤ │
│ │ 순서 보장 │ 파티션 내 │ 큐 내 │ FIFO만 │ │
│ ├────────────┼────────────┼────────────┼────────────┤ │
│ │ 메시지보존 │ 설정 기간 │ 소비시삭제 │ 최대 14일 │ │
│ ├────────────┼────────────┼────────────┼────────────┤ │
│ │ 리플레이 │ O │ X │ X │ │
│ ├────────────┼────────────┼────────────┼────────────┤ │
│ │ 라우팅 │ 단순 │ 유연 │ 단순 │ │
│ ├────────────┼────────────┼────────────┼────────────┤ │
│ │ 운영복잡도 │ 높음 │ 중간 │ 낮음 │ │
│ ├────────────┼────────────┼────────────┼────────────┤ │
│ │ 비용모델 │ 인프라비용 │ 인프라비용 │ 사용량기반 │ │
│ └────────────┴────────────┴────────────┴────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────┘
사용 사례별 추천¶
┌─────────────────────────────────────────────────────────────────────────┐
│ 사용 사례별 선택 가이드 │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ Kafka를 선택하는 경우: │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ - 실시간 스트리밍/분석 (클릭스트림, 로그) │ │
│ │ - 이벤트 소싱 / CQRS │ │
│ │ - 높은 처리량이 필요한 경우 │ │
│ │ - 메시지 리플레이가 필요한 경우 │ │
│ │ - 장기 데이터 보존 │ │
│ │ 예: 로그 수집, 메트릭 수집, 실시간 분석 │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
│ RabbitMQ를 선택하는 경우: │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ - 복잡한 라우팅 요구사항 │ │
│ │ - 낮은 지연시간 필수 │ │
│ │ - 전통적인 작업 큐 │ │
│ │ - 다양한 메시징 패턴 (RPC, Priority Queue) │ │
│ │ - AMQP 프로토콜 필요 │ │
│ │ 예: 작업 분배, 마이크로서비스 통신, IoT │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
│ AWS SQS/SNS를 선택하는 경우: │
│ ┌─────────────────────────────────────────────────────────────────┐ │
│ │ - AWS 생태계 활용 │ │
│ │ - 인프라 관리 최소화 │ │
│ │ - 예측 불가능한 트래픽 │ │
│ │ - 빠른 구축 필요 │ │
│ │ - Lambda 트리거 │ │
│ │ 예: 서버리스 아키텍처, 스타트업, 빠른 프로토타이핑 │ │
│ └─────────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────┘
선택 플로우차트¶
┌─────────────────────────────────────────────────────────────────────────┐
│ 메시지 시스템 선택 플로우 │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ 시작 │
│ │ │
│ ▼ │
│ ┌───────────────┐ │
│ │ AWS 사용 중? │ │
│ │ 관리 최소화? │ │
│ └───────┬───────┘ │
│ Yes │ No │
│ ┌────┴────┐ │
│ ▼ ▼ │
│ ┌─────────┐ ┌────────────────┐ │
│ │AWS SQS/ │ │ 이벤트 스트리밍/ │ │
│ │SNS 검토 │ │ 리플레이 필요? │ │
│ └─────────┘ └───────┬────────┘ │
│ Yes │ No │
│ ┌────┴────┐ │
│ ▼ ▼ │
│ ┌─────────┐ ┌────────────────┐ │
│ │ Kafka │ │ 복잡한 라우팅/ │ │
│ │ │ │ 낮은 지연 필요?│ │
│ └─────────┘ └───────┬────────┘ │
│ Yes │ No │
│ ┌────┴────┐ │
│ ▼ ▼ │
│ ┌─────────┐ ┌─────────┐ │
│ │RabbitMQ │ │ 둘 다 │ │
│ │ │ │ 가능 │ │
│ └─────────┘ └─────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────┘
5. 하이브리드 아키텍처¶
Kafka + RabbitMQ 조합¶
┌─────────────────────────────────────────────────────────────────────────┐
│ 하이브리드 아키텍처 예시 │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────┐ │
│ │ Event Bus (Kafka) │ │
│ ┌───────────┐ │ - 이벤트 저장소 │ │
│ │ Service │─────────►│ - 이벤트 리플레이 │ │
│ │ Events │ │ - 분석 파이프라인 │ │
│ └───────────┘ └────────────────┬────────────────────────┘ │
│ │ │
│ │ 이벤트 변환/필터 │
│ ▼ │
│ ┌─────────────────────────────────────────┐ │
│ │ Task Queue (RabbitMQ) │ │
│ │ - 작업 분배 │ │
│ │ - 복잡한 라우팅 │ │
│ │ - Priority 처리 │ │
│ └────────────────────────────────────────┘ │
│ │ │
│ ┌─────────┼─────────┐ │
│ ▼ ▼ ▼ │
│ ┌─────────┐┌─────────┐┌─────────┐ │
│ │Worker 1 ││Worker 2 ││Worker 3 │ │
│ └─────────┘└─────────┘└─────────┘ │
│ │
│ 각 시스템의 강점 활용: │
│ - Kafka: 이벤트 로그, 스트리밍, 분석 │
│ - RabbitMQ: 작업 큐, 복잡한 워크플로우 │
│ │
└─────────────────────────────────────────────────────────────────────────┘
6. 연습 문제¶
연습 1: 시스템 선택¶
다음 요구사항에 적합한 메시지 시스템을 선택하고 이유를 설명하세요:
- 실시간 주식 거래 시스템 (밀리초 지연)
- 이커머스 주문 이벤트 로그 (3년 보존)
- 이미지 리사이징 작업 큐 (우선순위 필요)
- 서버리스 기반 스타트업 MVP
- IoT 센서 데이터 수집 (초당 100만 이벤트)
연습 2: Kafka 토픽 설계¶
온라인 쇼핑몰의 주문 시스템을 위한 Kafka 토픽을 설계하세요: - 파티션 수 결정 - 파티션 키 선택 - Consumer Group 구성 - Retention 정책
연습 3: RabbitMQ 라우팅 설계¶
로그 수집 시스템을 위한 RabbitMQ Exchange/Queue를 설계하세요: - 로그 레벨별 라우팅 (error, warn, info, debug) - 서비스별 라우팅 (web, api, db) - 모든 에러 로그를 알림 서비스로 - 특정 서비스의 모든 로그를 디버깅 서비스로
다음 단계¶
13_Microservices_Basics.md에서 마이크로서비스 아키텍처의 기본 개념을 배워봅시다!
참고 자료¶
- Apache Kafka Documentation
- RabbitMQ Official Documentation
- AWS SQS/SNS Documentation
- "Kafka: The Definitive Guide" - Neha Narkhede
- "RabbitMQ in Depth" - Gavin M. Roy