Mulai sekarang

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.

9 MENIT BACA

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.

LayananPilih untuk
Valkeyantrean tugas sederhana (antrean Laravel dan Horizon, BullMQ, Celery, RQ), dan event di Streams — jika Anda sudah memakainya untuk cache dan sesi
NATSpertukaran pesan ringan antarlayanan: event, request dan reply, serta stream tahan lama dengan JetStream
RabbitMQmessage 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 redis dan Horizon, BullMQ, Celery, RQ. Library menyimpan tugas di Valkey; worker mengambilnya satu per satu dan mengulang tugas yang gagal.
  • Streams dengan consumer group — XADD menambahkan event ke stream, consumer dalam satu group membacanya dengan XREADGROUP dan mengonfirmasinya dengan XACK. 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 — PUBLISH dan SUBSCRIBE mengirim 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:

VariabelNilai
AMQP_URLamqp://<user>:<password>@<service name>:5672/%2f
RABBITMQ_HOSTnama layanan
RABBITMQ_PORT5672
RABBITMQ_USER, RABBITMQ_PASSWORDuser 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=redis

Jalankan 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:

  1. Instal package: composer require vladimir-yuldashev/laravel-queue-rabbitmq.
  2. Tambahkan koneksi rabbitmq ke config/queue.php seperti yang ditunjukkan README package untuk versi Anda. Koneksi ini membaca RABBITMQ_HOST, RABBITMQ_PORT, RABBITMQ_USER, RABBITMQ_PASSWORD, dan RABBITMQ_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', '/'),
        ],
    ],
],
  1. Atur QUEUE_CONNECTION=rabbitmq di tab Variabel lalu deploy. Worker tetap php 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

LayananMulai denganMemori minimum
NATSmemori 256 MB · 1 core CPU · disk 5 GB256 MB
RabbitMQmemori 1 GB · 1 core CPU · disk 10 GB512 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.

Masih ada kendala?

Chat dengan kami — AI langsung menjawab dan engineer bergabung bila diperlukan, kapan saja.

Hubungi dukungan