Messaging Patterns: Pub/Sub, Request/Reply, dan Choreography

• Architecture • By TryzTech Team
MessagingArchitecturePubSubMicroservicesBackend
Bagikan

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:

  1. Validasi saldo/kartu dan pemotongan pembayaran (Payment Service).
  2. Pemotongan stok barang di gudang (Inventory Service).
  3. Pembuatan label resi pengiriman (Shipping Service).
  4. 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 InventoryReservationFailed agar Payment Service melakukan refund otomatis.

Perbandingan Kritis: Karakteristik 3 Pola

AspekRequest / ReplyPublish / SubscribeEvent Choreography
Kopling (Coupling)Tinggi (Paham endpoint tujuan)Sangat Rendah (Hanya tahu Topic)Rendah (Berbasis Event Kontrak)
Waktu EksekusiSinkron (Menunggu balasan)Asinkron (Fire and forget)Asinkron bertahap (Event-driven)
Konsistensi DataStrong Consistency (ACID)Eventual ConsistencyEventual Consistency
Tingkat KompleksitasRendah di awal, tinggi saat scaleSedangTinggi (Perlu distributed tracing)
Use Case UtamaPembayaran, otentikasi loginNotifikasi, analitik, loggingOrder 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

  1. 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).
  2. Gunakan Pub/Sub untuk memisahkan proses sekunder (side effects) seperti email, analitik, dan sinkronisasi read-model dari transaksi utama.
  3. 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.
  4. 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.

Lanjutkan membaca topik yang masih satu konteks.

Jangan Ketinggalan Info Terbaru

Dapatkan artikel teknologi, tips, dan insights menarik langsung ke email Kamu.