Semua tulisan
Software Engineering10 menit baca

Memilih Sistem Queue yang Tepat

Membandingkan job queue, message broker, event log, dan workflow engine berdasarkan kebutuhan delivery dan recovery-nya.

Di artikel ini 20 bagian

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

mermaid
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

  1. Apakah satu worker menangani setiap item, atau setiap subscriber perlu salinannya?
  2. Apakah pekerjaan yang selesai boleh dibuang, atau consumer baru harus bisa me-replay-nya?
  3. Apa yang perlu terurut: semua message, satu akun, atau satu workflow?
  4. Apa yang terjadi kalau pemrosesan berjalan dua kali, atau berhenti setelah sebagian efeknya selesai?
  5. Apakah delay dan retry cukup, atau prosesnya perlu state yang tahan kegagalan di antara beberapa langkah?
  6. 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

mermaid
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.

mermaid
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.

mermaid
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.

mermaid
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.

mermaid
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.

mermaid
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.

mermaid
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

KebutuhanKandidatYang akan aku periksa
Job aplikasiPgBoss, BullMQBatas transaction, retry, kapasitas penyimpanan
Message antar service dengan routingRabbitMQ, ActiveMQ Classic, Artemis, IBM MQKompatibilitas client, acknowledgment, persistence
Worker dan fanout di AWSSQS, SNSVisibility timeout, message group, recovery subscriber
Delivery event di GCPPub/SubMode subscription, ordering, retention
Messaging di AzureService BusSession, lock, rentang duplicate detection
Event yang disimpanKafka, RabbitMQ Streams, Redis Streams, NATS JetStreamCakupan replay, retention, progres consumer
Message langsung berdasarkan subjectCore NATSApakah message yang terlewat bisa diterima
Job server yang udah dipakaiBeanstalkd, GearmanKonfigurasi persistence dan prosedur recovery
Proses dengan beberapa langkahTemporalDeterminisme 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.

Topik

Makasih udah baca

Gimana menurutmu?

Kasih reaksi atau komentar di bawah.

Memuat reaksi…

Bagikan tulisan ini

Memuat komentar...

Tulisan terkait

Semua tulisan