Messaging Patterns: Pub/Sub, Request/Reply, dan Choreography
Ketika sistem backend berkembang dari monolit sederhana menjadi beberapa service independen, pertanyaan terbesar yang sering muncul bukan lagi bahasa pemrograman apa yang dipakai, melainkan: bagaimana service-service tersebut saling berkomunikasi secara efisien tanpa saling mengunci (tight coupling)?
Banyak tim memulai dengan memanggil HTTP REST API secara langsung dari satu service ke service lainnya. Pada awalnya cara ini terasa natural, namun seiring bertambahnya traffic, muncul masalah laten: cascading failures, timeout beruntun, latensi kumulatif yang membengkak, dan ketergantungan deployment yang rumit.
Artikel ini membahas tiga pola komunikasi utama dalam sistem terdistribusi—Request/Reply, Publish/Subscribe (Pub/Sub), dan Event Choreography—menggunakan studi kasus Order & Payment Lifecycle pada sistem e-commerce, lengkap dengan contoh implementasi Python dan perbandingan performa message broker.
Studi Kasus: Alur Order & Checkout E-Commerce
Untuk memahami perbedaan ketiga pola ini secara konkret, bayangkan sebuah pengguna mengklik tombol “Bayar Sekarang” pada aplikasi e-commerce. Proses yang harus terjadi meliputi:
- Validasi saldo/kartu dan pemotongan pembayaran (Payment Service).
- Pemotongan stok barang di gudang (Inventory Service).
- Pembuatan label resi pengiriman (Shipping Service).
- Pengiriman email konfirmasi dan push notification (Notification Service).
Mari kita bedah bagaimana masing-masing pola messaging menyelesaikan kebutuhan ini.
1. Request/Reply: Komunikasi Sinkron Langsung
Pola Request/Reply adalah pola komunikasi titik-ke-titik (point-to-point) di mana pengirim (Requester) mengirimkan pesan atau instruksi langsung ke penerima tertentu (Replier) dan menunggu respon balasan sebelum melanjutkan eksekusi (atau menggunakan future/promise).
sequenceDiagram
autonumber
actor Client
participant OrderService as Order Service
participant PaymentService as Payment Service
participant InventoryService as Inventory Service
Client->>OrderService: POST /checkout
activate OrderService
OrderService->>PaymentService: POST /charges (Tunggu Konfirmasi)
activate PaymentService
PaymentService-->>OrderService: 200 OK (Payment Success)
deactivate PaymentService
OrderService->>InventoryService: POST /reserve-stock (Tunggu Konfirmasi)
activate InventoryService
InventoryService-->>OrderService: 200 OK (Stock Reserved)
deactivate InventoryService
OrderService-->>Client: 201 Created (Order Complete)
deactivate OrderService
Kapan Tepat Digunakan?
- Transaksi yang membutuhkan kepastian status instan sebelum pengguna melanjutkan langkah berikutnya (misal: verifikasi CVV kartu kredit, otorisasi token session, atau pengecekan saldo dompet real-time).
- Operasi Read-heavy yang membutuhkan data teranyar secara deterministik.
Kelebihan & Kekurangan
- Kelebihan: Sangat mudah dipahami, mudah di-debug karena stack trace berurutan, dan konsistensi data kuat (immediate consistency).
- Kekurangan: Latensi kumulatif ($T_{total} = T_{payment} + T_{inventory} + \dots$). Jika Inventory Service down, seluruh checkout ikut gagal (single point of failure). Untuk mengamankan pola ini, Anda wajib memasang mekanisme ketahanan seperti Circuit Breaker Pattern.
2. Publish/Subscribe (Pub/Sub): Broadcast Event 1-ke-Banyak
Pada pola Publish/Subscribe, pengirim (Publisher) tidak tahu dan tidak peduli siapa yang akan memproses pesan tersebut. Publisher hanya memancarkan suatu kejadian bisnis (domain event) ke sebuah topic atau channel, lalu satu atau lebih penerima (Subscribers) yang tertarik akan mendengarkan dan memproses pesan tersebut secara asinkron.
flowchart LR
OS[Order Service] -- "Publish: OrderPaid" --> Topic((Topic: order.events))
Topic --> NS[Notification Service]
Topic --> AS[Analytics Service]
Topic --> FS[Fraud Detection Service]
Implementasi Python (Worker Event Consumer Sederhana)
Berikut contoh publisher dan subscriber asinkron di Python memanfaatkan message stream:
# order_publisher.py
import json
import uuid
from datetime import datetime
def publish_order_paid(channel, order_id: str, customer_id: str, total_amount: float):
event_payload = {
"event_id": str(uuid.uuid4()),
"event_type": "OrderPaid",
"timestamp": datetime.utcnow().isoformat(),
"data": {
"order_id": order_id,
"customer_id": customer_id,
"amount": total_amount,
}
}
# Memancarkan event ke topic 'order.events'
channel.basic_publish(
exchange="order_exchange",
routing_key="order.paid",
body=json.dumps(event_payload),
)
print(f"[x] Event dipancarkan: OrderPaid untuk Order {order_id}")
Dan di sisi subscriber (Notification Service):
# notification_worker.py
import json
def handle_order_paid_event(ch, method, properties, body):
payload = json.loads(body)
data = payload["data"]
# Kirim email ke pembeli tanpa memblokir proses checkout
send_email_receipt(
customer_id=data["customer_id"],
order_id=data["order_id"],
amount=data["amount"]
)
# Acknowledge bahwa pesan berhasil diproses
ch.basic_ack(delivery_tag=method.delivery_tag)
def send_email_receipt(customer_id: str, order_id: str, amount: float):
print(f"[Email] Bukti bayar dikirim untuk Order {order_id} senilai Rp{amount:,.0f}")
Kapan Tepat Digunakan?
- Notifikasi, audit log, analitik data, dan integrasi dengan pihak ketiga yang sifatnya tidak memblokir respon utama pengguna.
- Menambahkan consumer baru di kemudian hari tanpa perlu mengubah satu baris pun kode di Order Service.
3. Event Choreography: Alur Desentralisasi Antar Service
Dalam Choreography, tidak ada koordinator pusat (no central orchestrator). Setiap service bereaksi terhadap event yang dihasilkan oleh service sebelumnya, menjalankan tugas internalnya, lalu memancarkan event baru untuk memicu langkah berikutnya seperti tarian yang terkoordinasi secara alami.
sequenceDiagram
autonumber
participant Order as Order Service
participant Payment as Payment Service
participant Inventory as Inventory Service
participant Shipping as Shipping Service
Order->>Payment: Event: OrderCreated
Note over Payment: Memproses charge kartu...
Payment->>Inventory: Event: PaymentCaptured
Note over Inventory: Mengurangi stok gudang...
Inventory->>Shipping: Event: StockReserved
Note over Shipping: Mencetak label resi...
Kelebihan & Kekurangan Choreography
- Kelebihan:
- Loose Coupling: Service tidak memiliki dependensi langsung satu sama lain.
- Skalabilitas tinggi: Tiap service dapat di-scale secara horizontal sesuai beban masing-masing.
- Kekurangan:
- Visibilitas Rendah: Sulit melacak state keseluruhan transaksi jika terjadi kegagalan di tengah jalan tanpa sistem distributed tracing (seperti OpenTelemetry).
- Compensating Transactions yang Rumit: Jika stok di Inventory ternyata habis setelah pembayaran sukses, sistem harus memancarkan event
InventoryReservationFailedagar Payment Service melakukan refund otomatis.
Perbandingan Kritis: Karakteristik 3 Pola
| Aspek | Request / Reply | Publish / Subscribe | Event Choreography |
|---|---|---|---|
| Kopling (Coupling) | Tinggi (Paham endpoint tujuan) | Sangat Rendah (Hanya tahu Topic) | Rendah (Berbasis Event Kontrak) |
| Waktu Eksekusi | Sinkron (Menunggu balasan) | Asinkron (Fire and forget) | Asinkron bertahap (Event-driven) |
| Konsistensi Data | Strong Consistency (ACID) | Eventual Consistency | Eventual Consistency |
| Tingkat Kompleksitas | Rendah di awal, tinggi saat scale | Sedang | Tinggi (Perlu distributed tracing) |
| Use Case Utama | Pembayaran, otentikasi login | Notifikasi, analitik, logging | Order fulfillment lintas sistem |
Memilih Message Broker: RabbitMQ vs Apache Kafka vs Redis
Memilih pola messaging tidak lengkap tanpa memilih infrastruktur penghubungnya (message broker). Berikut perbandingan performa, latensi, dan model pesan:
flowchart TD
Q{Kebutuhan Sistem Anda?}
Q -- "Routing fleksibel, tugas antrean per-worker" --> RMQ[RabbitMQ]
Q -- "Throughput jutaan event/detik, event replay" --> KFK[Apache Kafka]
Q -- "Latensi sub-milidetik, in-memory, simple" --> RDS[Redis Pub/Sub / Streams]
1. RabbitMQ (AMQP)
- Model: Smart Broker, Dumb Consumer. Broker melacak acknowledgement pesan, perutean fleksibel (exchange topic, direct, fanout), dan Dead-Letter Exchange (DLX).
- Latensi: Sangat rendah (~1-5 ms).
- Throughput: ~20.000 – 100.000 pesan/detik per node.
- Kapan Memilihnya: Sangat ideal untuk task queues rumit, prioritas pesan, dan alur Choreography yang membutuhkan routing berbasis aturan spesifik.
2. Apache Kafka
- Model: Dumb Broker, Smart Consumer. Pesan disimpan sebagai distributed append-only log yang persisten dan partisi log diatur oleh consumer offset.
- Latensi: Sedang (~5-20 ms, optimal saat batching).
- Throughput: Ekstrem (ratusan ribu hingga jutaan event/detik).
- Fitur Kunci: Event Replay—consumer baru dapat memutar ulang data masa lalu dari offset nol.
- Kapan Memilihnya: Data pipeline, event sourcing, streaming analitik real-time, dan log aggregation skala besar.
3. Redis (Pub/Sub & Streams)
- Model: In-Memory data structure. Untuk bahasan detail pengaturannya, baca panduan Redis untuk Backend: Cache, Session, dan Pub/Sub.
- Latensi: Ekstrem rendah (sub-milidetik, in-memory).
- Throughput: Sangat tinggi untuk operasi memory (~100.000+ op/s).
- Kapan Memilihnya: Update UI real-time (misal: push notifikasi WebSocket), koordinasi worker ringan, atau saat arsitektur Anda belum memerlukan broker dedicated terpisah.
Ringkasan Keputusan Engineering
- Gunakan Request/Reply hanya pada batas sistem di mana pengguna atau caller memang mutlak membutuhkan hasil seketika sebelum melangkah (misalnya verifikasi otentikasi atau validasi payment gateway).
- Gunakan Pub/Sub untuk memisahkan proses sekunder (side effects) seperti email, analitik, dan sinkronisasi read-model dari transaksi utama.
- Gunakan Choreography untuk alur kerja terdistribusi skala besar, namun pastikan tim Anda sudah melengkapinya dengan distributed tracing, logging terpusat, dan penanganan transaksi kompensasi yang matang.
- Jangan langsung mengadopsi broker kompleks seperti Kafka jika throughput Anda masih di bawah ribuan event per detik; RabbitMQ atau Redis Streams sering kali memberikan keseimbangan operasional yang jauh lebih sehat untuk sebagian besar tim engineering.
Artikel Terkait
Lanjutkan membaca topik yang masih satu konteks.
Strangler Pattern: Modernisasi Aplikasi Legacy dengan Aman
Panduan praktis Strangler Pattern untuk modernisasi aplikasi legacy bertahap lewat routing gateway, coexistence data, observability, dan retirement plan.
Layered Architecture vs Clean Architecture: Perbandingan
Bandingkan Layered Architecture dan Clean Architecture dari dependency, testing, kompleksitas, serta kapan memilih masing-masing untuk project.
CQRS Pattern: Pisahkan Read dan Write untuk Sistem Skalabel
Gunakan CQRS untuk memisahkan read dan write model, meningkatkan skalabilitas, menyederhanakan query kompleks, dan memperjelas boundary.
Microservices Architecture: Kapan Dipakai dan Pola Utama
Pahami kapan microservices layak dipakai, lalu pelajari API gateway, service discovery, circuit breaker, dan strategi deployment.