Dulu aku mengelompokkan background job, message broker, event log, dan workflow dengan satu sebutan: queue. Akibatnya, PgBoss, RabbitMQ, Kafka, dan Temporal terlihat seperti pilihan untuk menjawab pertanyaan yang sama.
Perbedaannya lebih terasa saat worker gagal. Kalau worker crash setelah menagih kartu tapi sebelum mengakui message, worker lain bisa menjalankan operasi yang sama lagi. Aturan recovery queue dan cara aplikasi menangani duplikat sama-sama berpengaruh.
Aku mulai dari siapa yang membutuhkan message, berapa lama message harus tersedia, dan apa yang terjadi kalau sebagian proses gagal.
Job, broker, stream, dan workflow
graph TD
A[Something needs to happen later] --> B{What kind of later?}
B --> C[Background job]
B --> D[Message between services]
B --> E[Replayable event history]
B --> F[Long running workflow]
C --> C1[PgBoss or BullMQ]
D --> D1[RabbitMQ, ActiveMQ, IBM MQ, SQS, Pub/Sub, Service Bus]
E --> E1[Kafka, Redis Streams, NATS JetStream]
F --> F1[Temporal]
Background job menjadi bagian dari aplikasi: kirim email, ubah ukuran gambar, atau retry webhook. Message antar service mungkin perlu dikirim ke beberapa consumer, masing-masing dengan backlog sendiri.
Event log menyimpan record untuk dibaca lagi. Consumer mencatat posisinya dan bisa me-replay history yang masih disimpan. Workflow menyimpan kemajuan proses yang bisa mencakup beberapa pemanggilan, retry, timer, dan waktu tunggu.
Kategori ini bisa tumpang tindih. RabbitMQ punya stream dan queue, sementara library job bisa mendukung dependency antar job. Aku memakai kategori ini untuk menjelaskan kebutuhan sebelum membandingkan fitur.
Pertanyaan yang aku tanyakan dulu
- Apakah satu worker menangani setiap item, atau setiap subscriber perlu salinannya?
- Apakah pekerjaan yang selesai boleh dibuang, atau consumer baru harus bisa me-replay-nya?
- Apa yang perlu terurut: semua message, satu akun, atau satu workflow?
- Apa yang terjadi kalau pemrosesan berjalan dua kali, atau berhenti setelah sebagian efeknya selesai?
- Apakah delay dan retry cukup, atau prosesnya perlu state yang tahan kegagalan di antara beberapa langkah?
- Database, broker, dan layanan cloud mana yang udah bisa dioperasikan tim?
Jawaban terakhir itu memengaruhi keputusan. Mengganti integrasi JMS atau IBM MQ yang berjalan juga berarti mengganti client, pengetahuan operasional, dan prosedur recovery-nya.
Delivery dan retention
graph LR
P[Producer] --> JQ[Job Queue]
JQ --> W1[Worker]
JQ --> W2[Worker]
P2[Producer] --> EX[Broker or Topic]
EX --> Q1[Consumer Queue A]
EX --> Q2[Consumer Queue B]
P3[Producer] --> LOG[Event Log]
LOG --> CG1[Consumer Group A]
LOG --> CG2[Consumer Group B]
Worker yang berbagi queue mengambil pekerjaan dari antrean yang sama. Queue atau subscription terpisah memberi setiap consumer salinannya sendiri. Pembaca log yang disimpan mencatat posisi masing-masing dalam history yang sama.
Menerima, mengakui, dan menghapus message adalah operasi terpisah di banyak sistem. Aku mengecek operasi mana yang memajukan progres dan mana yang menghapus data sebelum menganggap consumer lain bisa memulihkannya.
PgBoss
Aku mulai dengan PgBoss untuk background work berukuran moderat kalau aplikasi udah memakai PostgreSQL. Job berada di database, dan backend PostgreSQL mengambilnya dengan FOR UPDATE SKIP LOCKED.
Bagian yang berguna adalah membuat job di dalam database transaction yang udah ada. Insert order dan job process-order bisa commit bersama. Kalau transaction di-rollback, keduanya nggak terlihat oleh worker.
sequenceDiagram
participant App
participant DB as PostgreSQL
participant Worker
App->>DB: BEGIN
App->>DB: INSERT order
App->>DB: INSERT job into pgboss table
App->>DB: COMMIT
Worker->>DB: Claim job with row lock
Worker->>DB: Mark job completed
Enqueue harus memakai transaction yang sama. Dua pemanggilan terpisah nggak menjadi atomic hanya karena keduanya memakai PostgreSQL. Queue di sistem lain biasanya perlu outbox atau mekanisme recovery lain untuk menangani celah di antara kedua write.
Job juga menambah database write, koneksi, dan pekerjaan retention. Aku akan mengukur beban itu bersama query aplikasi sebelum memutuskan apakah cocok. Aku membahas pilihannya dalam PgBoss vs BullMQ dan perilaku locking dalam PostgreSQL advisory locks.
BullMQ
Untuk background job Node.js, aku mempertimbangkan BullMQ kalau Redis udah menjadi infrastruktur production. Delay, retry, prioritas, rate limit, dan dependency antar job bisa mengurangi kode yang perlu ditulis aplikasi.
Dalam deployment Redis, worker memegang lock job yang terus diperbarui. Kalau lock kedaluwarsa, recovery stalled job bisa mengembalikan job ke waiting atau menggagalkannya setelah batas yang dikonfigurasi. Event loop yang sibuk bisa menghalangi pembaruan lock meskipun proses worker masih hidup.
sequenceDiagram
participant Producer
participant Redis
participant Worker
participant Checker as Stall Checker
Producer->>Redis: Add job
Worker->>Redis: Move job to active and lock it
Worker->>Redis: Renew lock while processing
Note over Worker: Worker crashes
Checker->>Redis: Lock expired?
Checker->>Redis: Move job back to waiting
Recovery itu bisa menjalankan job lagi, jadi handler harus bisa menghadapi pengulangan. Persistence, failover, dan memory policy Redis juga menentukan apa yang bertahan setelah restart. Pilihan itu perlu diperhatikan sama seriusnya dengan API job; aku membahas tradeoff penyimpanannya dalam strategi caching.
Prioritas job di BullMQ juga menjadi pemakaian praktis dari priority queue.
RabbitMQ
RabbitMQ menyediakan exchange untuk producer melakukan publish dan queue untuk dibaca consumer. Binding menentukan message mana yang masuk ke setiap queue. Event pembayaran bisa dikirim ke email, risk, dan fulfillment tanpa producer harus memanggil ketiga service itu.
graph LR
P[Producer] --> EX[Topic Exchange]
EX -->|payment.succeeded| Q1[Email Queue]
EX -->|payment.*| Q2[Risk Queue]
EX -->|payment.succeeded| Q3[Fulfillment Queue]
Q1 --> C1[Email Worker]
Q2 --> C2[Risk Worker]
Q3 --> C3[Fulfillment Worker]
Aku mempertimbangkannya kalau aturan routing dan queue terpisah untuk tiap service menjadi kebutuhan utama. Durability exchange dan queue, persistence message, serta publisher confirm dan consumer acknowledgment menangani bagian delivery yang berbeda. Acknowledgment dari consumer nggak memberi tahu producer bahwa publish sebelumnya berhasil.
Queue dan stream punya perilaku retention yang berbeda. Message yang diakui keluar dari queue biasa; RabbitMQ Streams menyimpan log tereplikasi yang bisa dibaca consumer berulang kali. Pilih stream kalau consumer membutuhkan replay, lalu tentukan retention yang sesuai.
Beberapa consumer, redelivery, dan retry juga memengaruhi urutan pemrosesan. Aku mencatat siapa yang bertanggung jawab atas setiap queue dan bagaimana pemrosesannya dipulihkan setelah kegagalan.
ActiveMQ dan Artemis
Aku mempertimbangkan ActiveMQ Classic dan Apache ActiveMQ Artemis ketika client yang udah ada bergantung pada JMS atau protokol messaging tertentu. Queue JMS membagi pekerjaan, sedangkan topic mendukung subscription. Durable topic subscription menyimpan message untuk subscriber saat subscriber itu offline.
Classic dan Artemis adalah implementasi broker terpisah. Perpindahan di antara keduanya merupakan perubahan integrasi yang perlu pengujian kompatibilitas dan recovery. Aku nggak akan mengganti deployment stabil hanya karena arsitekturnya lebih lama, dan nggak akan memilihnya untuk aplikasi baru tanpa kebutuhan yang membenarkan beban operasionalnya.
IBM MQ
IBM MQ sering menjadi bagian dari integrasi enterprise yang udah ada. Queue manager-nya memiliki queue dan menyimpan message di dalamnya. Persistence adalah pengaturan message: persistent message dicatat ke log untuk recovery setelah queue manager restart.
Aku akan mempertimbangkannya kalau sistem di sekitarnya atau standar organisasi mengharuskannya. Administrasi, kontrol akses, lisensi, dan dukungan perlu masuk dalam keputusan itu. Beban tersebut sulit aku benarkan untuk proyek pribadi yang kecil.
Kafka
Kafka cocok ketika event harus tetap tersedia setelah dibaca consumer. Topic berisi partition yang terurut, dan consumer group mencatat progres secara independen. Membaca record nggak menghapusnya; retention dan cleanup policy menentukan apa yang tetap disimpan.
graph LR
P[Payment Service] --> T[Kafka Topic: payments]
T --> CG1[Fraud Consumer Group]
T --> CG2[Analytics Consumer Group]
T --> CG3[Notification Consumer Group]
T --> CG4[Data Warehouse Consumer Group]
Fraud service dan analytics service bisa membaca event yang sama dengan kecepatan berbeda. Consumer baru bisa membaca history yang masih tersimpan, dan consumer yang diperbaiki bisa memprosesnya ulang. History itulah alasan aku memperkenalkan event log.
Ordering berlaku dalam satu partition. Menjaga event satu akun tetap bersama membutuhkan partitioning yang konsisten, dan perubahan jumlah partition bisa mengubah pemetaan key. Pemrosesan record secara bersamaan juga bisa mengubah urutan efek setelah delivery.
Desain partition, schema, retention, dan recovery consumer menjadi bagian dari aplikasi. Aku menerima pekerjaan itu untuk event bisnis yang perlu di-replay; job email dengan retry delay belum cukup menjadi alasan menambah Kafka.
SQS
SQS menjadi titik awalku untuk worker queue di AWS. Message yang diterima tetap berada di queue, tapi disembunyikan selama visibility timeout. Worker menghapusnya setelah pemrosesan. Kalau timeout habis lebih dulu, message bisa tersedia lagi.
sequenceDiagram
participant Worker
participant SQS
Worker->>SQS: Receive message
SQS-->>Worker: Message plus receipt handle
Note over SQS: Message is invisible
alt Worker succeeds
Worker->>SQS: Delete message
else Worker crashes
Note over SQS: Visibility timeout expires
SQS-->>Worker: Message can be delivered again
end
Standard queue bisa mengirim duplikat. FIFO queue menambah ordering dalam message group dan deduplikasi pengiriman, tapi keduanya tetap perlu menangani worker yang gagal setelah efek eksternal terjadi. Visibility timeout juga perlu cukup untuk waktu pemrosesan, atau diperpanjang selama pekerjaan berjalan.
Aku akan menaruh routing di luar queue SQS dasar, lalu memberi message gagal tujuan yang jelas dan jalur untuk diproses kembali.
SNS
SNS mendistribusikan message yang dipublikasikan ke subscription. Dengan satu queue SQS untuk setiap subscriber, setiap consumer punya backlog dan retry policy sendiri.
graph LR
P[Publisher] --> SNS[SNS Topic]
SNS --> Q1[SQS: Email Consumer]
SNS --> Q2[SQS: Fraud Consumer]
SNS --> Q3[SQS: Analytics Consumer]
Q1 --> C1[Email Worker]
Q2 --> C2[Fraud Worker]
Q3 --> C3[Analytics Worker]
Filter subscription memungkinkan consumer memilih message yang dibutuhkan. Kombinasi SNS dan SQS ini yang akan aku pakai untuk fanout di AWS.
Replay perlu jawaban yang lebih spesifik dari nama produknya. Topic SNS FIFO mendukung pengarsipan message dan replay yang opsional. Fitur itu harus diaktifkan dan dikonfigurasi; perilaku itu nggak berlaku untuk setiap topic atau subscription SNS.
Redis Streams
Redis Streams menyimpan entry dengan ID. Consumer bisa membaca langsung atau berbagi pekerjaan lewat consumer group. Pending entry mencatat delivery yang belum diakui, sehingga worker lain bisa memulihkan pekerjaan yang belum selesai.
Misalnya, XAUTOCLAIM memindahkan pending entry yang udah cukup lama idle ke consumer lain. Recovery tetap membutuhkan logika aplikasi untuk memproses entry itu dengan aman.
Mengakui entry dan memangkas stream adalah operasi berbeda. Retention, pemakaian memori, dan persistence Redis perlu pengaturan yang jelas. Aku akan mempertimbangkan ini kalau Redis udah tersedia dan history yang disimpan sesuai kapasitasnya.
Google Pub/Sub
Pub/Sub memberi sebuah topic subscription yang independen, dengan push atau pull delivery. Default-nya adalah delivery minimal sekali tanpa jaminan urutan. Ordering key dan retention menambah perilaku yang harus dipilih secara sengaja.
Pub/Sub juga mendukung replay lewat seek dan exactly once delivery untuk pull subscription dalam satu region. Jaminan delivery itu nggak membuat pemanggilan API eksternal dan update database lokal menjadi satu operasi atomic.
Aku akan mengevaluasinya untuk consumer event yang independen di GCP, lalu memeriksa mode subscription dan pengaturan recovery yang dipakai aplikasi.
Azure Service Bus
Service Bus menyediakan queue dan topic subscription. Dalam mode PeekLock, consumer mengunci message dan menyelesaikannya setelah diproses. Lock yang kedaluwarsa sebelum selesai bisa menyebabkan redelivery.
Session mendukung pemrosesan terurut dalam satu session. Duplicate detection melacak ID message dalam rentang waktu yang dikonfigurasi; fitur itu nggak mencegah pengulangan semua efek di dalam consumer.
Aku akan mempertimbangkannya untuk aplikasi Azure yang membutuhkan fitur broker ini, dengan service tier, durasi lock, dan perilaku session sebagai bagian dari desain.
NATS
Core NATS mengirim ke subscriber yang sedang terhubung tanpa menyimpan message untuk replay. Subject seperti payments.created menjadi model routing-nya.
JetStream menambah stream yang disimpan, state consumer, acknowledgment, dan replay. Aku memisahkan kedua mode itu saat mengevaluasi NATS: worker yang perlu tahan kegagalan membutuhkan perilaku berbeda dari subscriber yang mendengarkan notifikasi langsung.
Beanstalkd dan Gearman
Beanstalkd mengelompokkan job ke dalam tube. Worker memesan job, lalu menghapus, melepas, atau menguburnya. Time to run membatasi durasi reservasi.
Gearman mengirim pekerjaan ke worker yang terdaftar untuk nama function tertentu. Konfigurasi persistent queue menentukan apakah background job bertahan setelah job server restart.
Aku akan mempertahankan keduanya dalam sistem yang berjalan kalau perilaku recovery-nya memenuhi kebutuhan. Usia saja bukan alasan untuk menggantinya, tapi aku akan memeriksa persistence dan dukungan operasional sebelum memasukkannya ke sistem baru.
Temporal
Temporal menyimpan history workflow supaya proses bisa pulih setelah kegagalan worker. Kode workflow mengoordinasikan langkah, sedangkan activity menjalankan operasi seperti pemanggilan API. Timer dan signal membuat proses bisa menunggu tanpa terus memakai worker selama waktu tunggu.
Kode workflow harus deterministik supaya state-nya bisa dibangun ulang dari history. Activity bisa di-retry, jadi efeknya tetap perlu dilindungi dari eksekusi duplikat.
Aku mengevaluasi Temporal ketika worker mulai menyimpan state machine di berbagai job dan tabel: langkah mana yang selesai, apa yang perlu di-retry, dan apa yang sedang ditunggu proses. Satu task dengan penghitung retry nggak membutuhkan semua mekanisme itu.
Kesalahan yang aku perhatikan
Acknowledgment queue nggak bisa membatalkan operasi eksternal. Kalau worker menagih kartu lalu crash sebelum mencatat keberhasilan, retry tanpa pemeriksaan bisa mengulang tagihan. Consumer perlu identitas operasi yang tetap dan jalur recovery untuk hasil yang belum pasti itu.
Retry juga perlu aturan berhenti. Message dengan data yang nggak valid nggak akan membaik setelah dicoba lagi. Message gagal perlu penanggung jawab, konteks yang cukup untuk diperiksa, dan cara retry yang terkendali setelah penyebabnya diperbaiki.
Ordering perlu cakupan yang jelas. Urutan per akun berbeda dari satu urutan global untuk semua message. Urutan delivery queue juga nggak menjamin urutan penyelesaian handler yang berjalan bersamaan.
Queue menampung perbedaan throughput sementara. Kalau producer terus mengirim 10.000 message per detik sementara consumer menangani 1.000, backlog bertambah 9.000 setiap detik. Aku memantau kedalaman queue, usia message tertua, laju pemrosesan, retry, message gagal, dan error worker bersama-sama.
Membandingkan pilihan
| Kebutuhan | Kandidat | Yang akan aku periksa |
|---|---|---|
| Job aplikasi | PgBoss, BullMQ | Batas transaction, retry, kapasitas penyimpanan |
| Message antar service dengan routing | RabbitMQ, ActiveMQ Classic, Artemis, IBM MQ | Kompatibilitas client, acknowledgment, persistence |
| Worker dan fanout di AWS | SQS, SNS | Visibility timeout, message group, recovery subscriber |
| Delivery event di GCP | Pub/Sub | Mode subscription, ordering, retention |
| Messaging di Azure | Service Bus | Session, lock, rentang duplicate detection |
| Event yang disimpan | Kafka, RabbitMQ Streams, Redis Streams, NATS JetStream | Cakupan replay, retention, progres consumer |
| Message langsung berdasarkan subject | Core NATS | Apakah message yang terlewat bisa diterima |
| Job server yang udah dipakai | Beanstalkd, Gearman | Konfigurasi persistence dan prosedur recovery |
| Proses dengan beberapa langkah | Temporal | Determinisme workflow dan retry activity |
Pilihan awalku
Untuk aplikasi yang udah memakai PostgreSQL, aku mulai dengan PgBoss dan mengukur beban database. Kalau deployment Redis udah tersedia dan fitur job-nya dibutuhkan, aku mempertimbangkan BullMQ.
Untuk worker queue di AWS, aku mulai dengan SQS dan menambah SNS kalau beberapa consumer membutuhkan salinan independen. Untuk routing antar service, aku mempertimbangkan RabbitMQ. Kontrak JMS dan IBM MQ yang udah ada bisa membuat broker tersebut menjadi pilihan praktis.
Aku mempertimbangkan Kafka ketika history event perlu disimpan, dan Temporal ketika proses perlu mempertahankan progres di beberapa langkah. Aku memilih sistem yang perilaku kegagalan dan recovery-nya bisa aku jelaskan untuk aplikasi itu.

Memuat komentar...