Event dan antrean: Valkey, NATS, dan RabbitMQ.
Tugas latar belakang, event, dan pesan antarlayanan aplikasi: kapan memilih Valkey, NATS, atau RabbitMQ, variabel koneksi, contoh untuk Laravel, Node.js, dan Python, resource, backup, serta batasan.
Saat website menyerahkan pekerjaan ke worker — mengirim email, mengubah ukuran gambar, menagih pesanan — atau satu layanan memberi tahu layanan lain bahwa sesuatu terjadi, pesannya melewati antrean atau message broker. Sebuah proyek bisa memiliki tiga jenisnya, masing-masing ditambahkan sebagai layanan: Ringkasan → Layanan → Tambah layanan.
| Layanan | Pilih untuk |
|---|---|
| Valkey | antrean tugas sederhana (antrean Laravel dan Horizon, BullMQ, Celery, RQ), dan event di Streams — jika Anda sudah memakainya untuk cache dan sesi |
| NATS | pertukaran pesan ringan antarlayanan: event, request dan reply, serta stream tahan lama dengan JetStream |
| RabbitMQ | message broker klasik: routing melalui exchange, acknowledgement, retry dan dead-lettering, quorum queue |
Jika ragu, mulailah dengan Valkey untuk tugas latar belakang: sebagian besar framework langsung mendukungnya. Pilih RabbitMQ jika pesan harus dirutekan di antara banyak antrean dan tidak boleh ada yang hilang, dan NATS jika layanan bertukar banyak pesan kecil atau saling meminta jawaban.
Valkey: antrean tugas dan Streams
Valkey adalah penyimpanan yang kompatibel dengan Redis — layanan terkelola yang sama seperti di Database. Valkey pertama di aplikasi memberikan REDIS_URL, REDIS_HOST, REDIS_PORT, dan REDIS_PASSWORD ke setiap layanan kode; setiap Valkey juga memberikan RIVERVO_<NAME>_URL miliknya sendiri.
Tiga cara mengirim pesan melaluinya:
- Antrean tugas — antrean Laravel dengan driver
redisdan Horizon, BullMQ, Celery, RQ. Library menyimpan tugas di Valkey; worker mengambilnya satu per satu dan mengulang tugas yang gagal. - Streams dengan consumer group —
XADDmenambahkan event ke stream, consumer dalam satu group membacanya denganXREADGROUPdan mengonfirmasinya denganXACK. Event disimpan: consumer yang sempat berhenti melanjutkan dari posisi terakhirnya, event yang belum dikonfirmasi bisa diambil lagi, dan group baru bisa membaca stream dari awal. - Pub/Sub —
PUBLISHdanSUBSCRIBEmengirim pesan hanya ke subscriber yang terhubung saat itu. Pesan tidak disimpan: subscriber yang sedang restart atau belum terhubung akan melewatkannya. Gunakan Pub/Sub hanya jika pesan yang hilang tidak berdampak (misalnya sinyal «refresh»), dan Streams atau antrean untuk hal lainnya.
Valkey di-backup setiap hari seperti database lainnya; Valkey juga bisa dijangkau dari luar saat Anda membuka akses. Lihat Database.
NATS
NATS adalah sistem pertukaran pesan yang ringan dan cepat, dengan JetStream yang sudah aktif:
- Publish dan subscribe — layanan memublikasikan ke subject seperti
orders.created, setiap subscriber subject tersebut menerima pesannya. Tanpa JetStream, ini bersifat fire-and-forget, seperti Pub/Sub di atas. - Request dan reply — satu layanan bertanya, layanan lain menjawab. Jika beberapa instance menjawab sebagai queue group, NATS membagi request di antara mereka.
- JetStream — stream tahan lama: pesan disimpan di disk layanan, consumer mengingat apa yang sudah dibacanya, dan setiap pesan dikirim setidaknya sekali sampai di-acknowledge.
- Key-value dan object store yang dibangun di atas JetStream — untuk pengaturan bersama yang kecil, lock, atau file antarlayanan.
Variabel. NATS pertama di aplikasi memberikan ke setiap layanan kode:
NATS_URL=nats://<user>:<password>@<service name>:4222
Setiap layanan NATS juga memberikan RIVERVO_<NAME>_URL dengan alamat berformat sama — NAME adalah nama layanan dalam huruf kapital, dengan tanda hubung diubah menjadi _: layanan bernama events memberikan RIVERVO_EVENTS_URL.
JetStream menyimpan stream-nya di disk layanan; stream yang disimpan di memori bisa memakai sekitar seperempat memori layanan.
RabbitMQ
RabbitMQ 4.1 adalah message broker klasik: producer memublikasikan ke exchange, exchange merutekan pesan ke queue berdasarkan routing key, consumer melakukan acknowledge untuk setiap pesan, dan pesan yang ditolak atau kedaluwarsa bisa diteruskan ke exchange dead-letter. Untuk antrean yang pesannya harus bertahan setelah restart, gunakan quorum queue (argumen x-queue-type: quorum) dan publikasikan pesan sebagai persistent.
Variabel. RabbitMQ pertama di aplikasi memberikan ke setiap layanan kode:
| Variabel | Nilai |
|---|---|
AMQP_URL | amqp://<user>:<password>@<service name>:5672/%2f |
RABBITMQ_HOST | nama layanan |
RABBITMQ_PORT | 5672 |
RABBITMQ_USER, RABBITMQ_PASSWORD | user dan password |
RABBITMQ_VHOST | / |
%2f di akhir AMQP_URL adalah virtual host default /, ditulis sesuai format yang diwajibkan alamat koneksi. Setiap layanan RabbitMQ juga memberikan RIVERVO_<NAME>_URL miliknya sendiri dengan alamat berformat sama.
Management API. HTTP API manajemen mendengarkan di port 15672 di dalam jaringan privat aplikasi: layanan aplikasi menjangkaunya di http://<service name>:15672 dengan user dan password yang sama, misalnya:
curl -u "$RABBITMQ_USER:$RABBITMQ_PASSWORD" "http://$RABBITMQ_HOST:15672/api/queues"Tidak ada halaman manajemen di internet. Halaman layanan di panel menampilkan daftar singkat antreannya yang hanya bisa dibaca: pesan siap, belum di-acknowledge, dan jumlah consumer.
Hanya internal
NATS dan RabbitMQ tidak memiliki alamat publik dan tidak bisa dijangkau dari luar aplikasi — dari komputer Anda, server lain, atau aplikasi lain. Berbeda dengan PostgreSQL, MySQL, dan Valkey, akses dari luar tidak tersedia untuk keduanya. Layanan yang memublikasikan dan mengonsumsi pesan berjalan sebagai layanan dari aplikasi yang sama: layanan web, worker latar belakang, dan tugas terjadwal.
Layanan kedua dengan jenis yang sama
Hanya Valkey, NATS, dan RabbitMQ pertama di aplikasi yang mendapat nama-nama standar (REDIS_*, NATS_URL, AMQP_URL, dan RABBITMQ_*). Layanan berikutnya dengan jenis yang sama hanya menambahkan RIVERVO_<NAME>_URL miliknya sendiri; baca variabel tersebut di kode Anda, atau atur nama-nama standar ke nilainya di tab Variabel. Variabel sampai ke layanan pada deploy berikutnya — lihat Variabel environment.
Laravel
Valkey. Atur di tab Variabel:
QUEUE_CONNECTION=redisJalankan php artisan queue:work — atau php artisan horizon jika memakai Horizon — sebagai worker latar belakang. Lihat Laravel.
RabbitMQ. Laravel tidak memiliki driver RabbitMQ bawaan, dan Rivervo tidak mengubah QUEUE_CONNECTION dengan sendirinya. Untuk memakai RabbitMQ bagi antrean Laravel:
- Instal package:
composer require vladimir-yuldashev/laravel-queue-rabbitmq. - Tambahkan koneksi
rabbitmqkeconfig/queue.phpseperti yang ditunjukkan README package untuk versi Anda. Koneksi ini membacaRABBITMQ_HOST,RABBITMQ_PORT,RABBITMQ_USER,RABBITMQ_PASSWORD, danRABBITMQ_VHOST, yang sudah dimiliki aplikasi:
'rabbitmq' => [
'driver' => 'rabbitmq',
'hosts' => [
[
'host' => env('RABBITMQ_HOST', '127.0.0.1'),
'port' => env('RABBITMQ_PORT', 5672),
'user' => env('RABBITMQ_USER', 'guest'),
'password' => env('RABBITMQ_PASSWORD', 'guest'),
'vhost' => env('RABBITMQ_VHOST', '/'),
],
],
],- Atur
QUEUE_CONNECTION=rabbitmqdi tab Variabel lalu deploy. Worker tetapphp artisan queue:work.
NATS. Tidak ada driver antrean Laravel resmi untuk NATS. Gunakan client NATS untuk PHP di kode Anda sendiri — misalnya basis-company/nats — dan berikan host, port, user, dan password dari NATS_URL. Pastikan client tersebut mendukung fitur yang Anda butuhkan (JetStream, key-value) sebelum membangun di atasnya.
Node.js
BullMQ (Valkey)
import { Queue, Worker } from 'bullmq'
import IORedis from 'ioredis'
const connection = new IORedis(process.env.REDIS_URL, { maxRetriesPerRequest: null })
// di layanan web
const emails = new Queue('emails', { connection })
await emails.add('welcome', { userId: 42 }, { attempts: 3 })
// di worker latar belakang
new Worker('emails', async (job) => {
await sendWelcome(job.data.userId)
}, { connection })BullMQ memerlukan maxRetriesPerRequest: null pada koneksi yang dipakai worker-nya.
Valkey Streams
import IORedis from 'ioredis'
const redis = new IORedis(process.env.REDIS_URL)
// producer
await redis.xadd('orders', '*', 'id', '42')
// consumer dari group «billing»
await redis.xgroup('CREATE', 'orders', 'billing', '0', 'MKSTREAM').catch((err) => {
if (!String(err).includes('BUSYGROUP')) throw err // group sudah ada
})
const me = process.env.HOSTNAME ?? 'worker'
for (;;) {
const res = await redis.xreadgroup('GROUP', 'billing', me, 'COUNT', 10, 'BLOCK', 5000, 'STREAMS', 'orders', '>')
for (const [, entries] of res ?? []) {
for (const [id, fields] of entries) {
await handleOrder(fields)
await redis.xack('orders', 'billing', id)
}
}
}Entri yang sudah dibaca tetapi belum di-acknowledge tetap tertunda di group; XAUTOCLAIM menyerahkannya ke consumer lain.
NATS (nats.js)
import { connect, JSONCodec, AckPolicy } from 'nats'
const nc = await connect({ servers: process.env.NATS_URL })
const jc = JSONCodec()
// sekali saja: stream untuk subject orders.* dan consumer tahan lama
const jsm = await nc.jetstreamManager()
await jsm.streams.add({ name: 'ORDERS', subjects: ['orders.>'] })
await jsm.consumers.add('ORDERS', { durable_name: 'billing', ack_policy: AckPolicy.Explicit })
// producer
const js = nc.jetstream()
await js.publish('orders.created', jc.encode({ id: 42 }))
// consumer
const consumer = await js.consumers.get('ORDERS', 'billing')
for await (const m of await consumer.consume()) {
await handleOrder(jc.decode(m.data))
m.ack()
}Request dan reply: satu layanan menjawab dengan nc.subscribe('prices.get', { queue: 'prices', callback: (err, msg) => msg.respond(jc.encode(price)) }), layanan lain bertanya dengan await nc.request('prices.get', jc.encode({ sku: 'A1' }), { timeout: 2000 }).
RabbitMQ (amqplib)
import amqp from 'amqplib'
const conn = await amqp.connect(process.env.AMQP_URL)
const ch = await conn.createChannel()
await ch.assertQueue('emails', { durable: true, arguments: { 'x-queue-type': 'quorum' } })
// producer
ch.sendToQueue('emails', Buffer.from(JSON.stringify({ userId: 42 })), { persistent: true })
// consumer: maksimal 10 pesan yang belum di-acknowledge sekaligus
await ch.prefetch(10)
await ch.consume('emails', async (msg) => {
try {
await sendWelcome(JSON.parse(msg.content.toString()).userId)
ch.ack(msg)
} catch {
ch.nack(msg, false, false) // ke exchange dead-letter, jika antrean memilikinya
}
})Setiap layanan yang mendeklarasikan antrean harus mendeklarasikannya dengan argumen yang sama.
Python
Celery (Valkey atau RabbitMQ)
import os
from celery import Celery
app = Celery("tasks", broker=os.environ["REDIS_URL"]) # atau os.environ["AMQP_URL"]
@app.task(acks_late=True)
def send_welcome(user_id):
...Jalankan celery -A tasks worker --loglevel=info sebagai worker latar belakang. Celery menerima alamat amqp:// apa adanya. Dengan RabbitMQ, versi Celery terbaru bisa mendeklarasikan quorum queue (task_default_queue_type = "quorum") — lihat dokumentasi Celery untuk versi Anda.
RQ (Valkey)
import os
from redis import Redis
from rq import Queue
queue = Queue("emails", connection=Redis.from_url(os.environ["REDIS_URL"]))
queue.enqueue(send_welcome, 42)Worker: rq worker emails --url "$REDIS_URL".
NATS (nats-py)
import asyncio, json, os
import nats
from nats.errors import TimeoutError
async def main():
nc = await nats.connect(os.environ["NATS_URL"])
js = nc.jetstream()
await js.add_stream(name="ORDERS", subjects=["orders.>"])
await js.publish("orders.created", json.dumps({"id": 42}).encode())
sub = await js.pull_subscribe("orders.>", durable="billing")
while True:
try:
msgs = await sub.fetch(10, timeout=5)
except TimeoutError:
continue
for msg in msgs:
await handle_order(json.loads(msg.data))
await msg.ack()
asyncio.run(main())RabbitMQ (pika)
import json, os
import pika
conn = pika.BlockingConnection(pika.URLParameters(os.environ["AMQP_URL"]))
ch = conn.channel()
ch.queue_declare(queue="emails", durable=True, arguments={"x-queue-type": "quorum"})
# producer
ch.basic_publish(exchange="", routing_key="emails",
body=json.dumps({"user_id": 42}),
properties=pika.BasicProperties(delivery_mode=2))
# consumer
def on_message(ch, method, properties, body):
send_welcome(json.loads(body)["user_id"])
ch.basic_ack(delivery_tag=method.delivery_tag)
ch.basic_qos(prefetch_count=10)
ch.basic_consume(queue="emails", on_message_callback=on_message)
ch.start_consuming()Terkirim lebih dari sekali
Antrean dan broker mengirim ulang pesan jika worker berhenti sebelum mengonfirmasinya — saat deploy, restart, atau pemulihan. Tulis consumer sedemikian rupa sehingga memproses pesan yang sama dua kali tidak menimbulkan masalah: simpan ID setiap pesan yang sudah diproses, atau buat tindakannya aman untuk diulang (misalnya «ubah status menjadi lunas» alih-alih «tambahkan pembayaran»).
Resource dan harga
| Layanan | Mulai dengan | Memori minimum |
|---|---|---|
| NATS | memori 256 MB · 1 core CPU · disk 5 GB | 256 MB |
| RabbitMQ | memori 1 GB · 1 core CPU · disk 10 GB | 512 MB |
Masing-masing dihargai berdasarkan memori, CPU, dan disk seperti layanan lain — lihat Layanan dalam proyek. Resource bisa diubah nanti di Pengaturan layanan.
Backup dan pemulihan
NATS dan RabbitMQ di-backup setiap hari; kami menyimpan backup 7 hari terakhir dan 4 minggu terakhir, sama seperti layanan lainnya.
- Backup menyalin file data layanan saat layanan berjalan. Untuk RabbitMQ, backup yang sama juga berisi ekspor definisinya: user, virtual host, queue, exchange, binding, dan policy.
- Tidak ada pemulihan ke titik waktu tertentu — itu hanya untuk PostgreSQL dan MySQL. Anda memulihkan salah satu salinan harian.
- Pemulihan menghentikan layanan sebentar, mengembalikan file-nya, lalu menjalankannya lagi. Pesan yang masuk atau di-acknowledge sekitar waktu backup bisa hilang atau terkirim ulang — alasan lain untuk membuat consumer aman diulang.
- Untuk RabbitMQ, jika file yang disalin tidak bisa dijalankan, layanan dimulai hanya dengan definisinya: queue, exchange, dan user tersedia, tetapi pesan dari backup hilang.
Pemeliharaan dan pemindahan
NATS dan RabbitMQ tidak memiliki jadwal pemeliharaan yang perlu diatur. Keduanya tidak dipindahkan ke server lain secara otomatis; jika suatu saat diperlukan, tim support akan mengaturnya bersama Anda.