Evenimente și cozi: Valkey, NATS și RabbitMQ.
Sarcini în fundal, evenimente și mesaje între serviciile unei aplicații: când alegi Valkey, NATS sau RabbitMQ, variabilele de conexiune, exemple pentru Laravel, Node.js și Python, resurse, backupuri și limite.
Când un site predă o sarcină unui worker — trimite un e-mail, redimensionează o imagine, încasează o comandă — sau un serviciu le anunță pe celelalte că s-a întâmplat ceva, mesajul trece printr-o coadă sau un message broker. Un proiect poate avea trei astfel de servicii, fiecare adăugat ca serviciu: Prezentare generală → Servicii → Adaugă un serviciu.
| Serviciu | Alege-l pentru |
|---|---|
| Valkey | cozi simple de sarcini (cozile Laravel și Horizon, BullMQ, Celery, RQ) și evenimente în Streams — când îl folosești deja pentru cache și sesiuni |
| NATS | mesagerie ușoară între servicii: evenimente, cerere și răspuns, plus fluxuri durabile cu JetStream |
| RabbitMQ | un message broker clasic: rutare prin exchange-uri, confirmări, reîncercări și dead-lettering, cozi quorum |
Dacă nu ești sigur, începe cu Valkey pentru sarcinile în fundal: majoritatea framework-urilor îl suportă din start. Alege RabbitMQ când mesajele trebuie rutate între multe cozi și niciunul nu are voie să se piardă, iar NATS când serviciile schimbă multe mesaje mici sau își cer răspunsuri unele altora.
Valkey: cozi de sarcini și Streams
Valkey este un depozit compatibil cu Redis — același serviciu administrat ca în Baze de date. Primul Valkey al aplicației îi dă fiecărui serviciu de cod REDIS_URL, REDIS_HOST, REDIS_PORT și REDIS_PASSWORD; fiecare Valkey oferă și propriul RIVERVO_<NAME>_URL.
Trei moduri de a trimite mesaje prin el:
- Cozi de sarcini — cozile Laravel cu driverul
redisși Horizon, BullMQ, Celery, RQ. Biblioteca ține sarcinile în Valkey; un worker le preia pe rând și le reîncearcă pe cele care eșuează. - Streams cu grupuri de consumatori —
XADDadaugă un eveniment într-un stream, consumatorii unui grup îl citesc cuXREADGROUPși îl confirmă cuXACK. Evenimentele se păstrează: un consumator care a fost oprit continuă de unde a rămas, un eveniment neconfirmat poate fi preluat din nou, iar un grup nou poate citi stream-ul de la început. - Pub/Sub —
PUBLISHșiSUBSCRIBElivrează un mesaj doar abonaților conectați în acel moment. Mesajul nu se păstrează: un abonat care repornește sau încă nu s-a conectat îl ratează. Folosește Pub/Sub doar acolo unde un mesaj pierdut nu face rău (de exemplu un semnal de „reîmprospătare”), iar pentru restul — Streams sau o coadă.
Valkey are backup zilnic, ca celelalte baze de date; poate fi accesat și din exterior când deschizi accesul. Vezi Baze de date.
NATS
NATS este un sistem de mesagerie ușor și rapid, cu JetStream activat:
- Publicare și abonare — un serviciu publică pe un subiect precum
orders.created, iar fiecare abonat al subiectului primește mesajul. Fără JetStream, acesta este de tip „trimite și uită”, ca Pub/Sub de mai sus. - Cerere și răspuns — un serviciu întreabă, altul răspunde. Când mai multe instanțe răspund ca grup de coadă, NATS împarte cererile între ele.
- JetStream — fluxuri durabile: mesajele se păstrează pe discul serviciului, un consumator ține minte ce a citit, iar fiecare mesaj este livrat cel puțin o dată, până este confirmat.
- Depozit cheie-valoare și depozit de obiecte, construite pe JetStream — pentru setări comune mici, blocări sau fișiere între servicii.
Variabile. Primul NATS al aplicației îi dă fiecărui serviciu de cod:
NATS_URL=nats://<user>:<password>@<service name>:4222
Fiecare serviciu NATS oferă și RIVERVO_<NAME>_URL, cu o adresă de aceeași formă — NAME este numele serviciului cu majuscule, cu cratimele înlocuite de _: un serviciu numit events oferă RIVERVO_EVENTS_URL.
JetStream își ține fluxurile pe discul serviciului; fluxurile păstrate în memorie pot folosi cam un sfert din memoria serviciului.
RabbitMQ
RabbitMQ 4.1 este un message broker clasic: producătorii publică în exchange-uri, exchange-urile rutează mesajele către cozi după cheile de rutare, consumatorii confirmă fiecare mesaj, iar un mesaj respins sau expirat poate ajunge într-un exchange de dead-letter. Pentru cozile ale căror mesaje trebuie să supraviețuiască unei reporniri, folosește cozi quorum (argumentul x-queue-type: quorum) și publică mesajele ca persistente.
Variabile. Primul RabbitMQ al aplicației îi dă fiecărui serviciu de cod:
| Variabilă | Valoare |
|---|---|
AMQP_URL | amqp://<user>:<password>@<service name>:5672/%2f |
RABBITMQ_HOST | numele serviciului |
RABBITMQ_PORT | 5672 |
RABBITMQ_USER, RABBITMQ_PASSWORD | utilizatorul și parola |
RABBITMQ_VHOST | / |
%2f de la finalul AMQP_URL este gazda virtuală implicită /, scrisă așa cum o cer adresele de conexiune. Fiecare serviciu RabbitMQ oferă și propriul RIVERVO_<NAME>_URL, cu o adresă de aceeași formă.
API-ul de administrare. API-ul HTTP de administrare ascultă pe portul 15672 în rețeaua privată a aplicației: serviciile aplicației ajung la el la http://<service name>:15672, cu același utilizator și aceeași parolă, de exemplu:
curl -u "$RABBITMQ_USER:$RABBITMQ_PASSWORD" "http://$RABBITMQ_HOST:15672/api/queues"Nu există o pagină de administrare pe internet. Pagina serviciului din panou arată o listă scurtă, doar în citire, a cozilor lui: mesaje gata de livrare, neconfirmate și consumatori.
Doar intern
NATS și RabbitMQ nu au adresă publică și nu pot fi accesate din afara aplicației — de pe calculatorul tău, de pe alt server sau din altă aplicație. Spre deosebire de PostgreSQL, MySQL și Valkey, pentru ele nu se oferă acces din exterior. Serviciile care publică și consumă mesaje rulează ca servicii ale aceleiași aplicații: servicii web, workeri în fundal și sarcini programate.
Al doilea serviciu de același tip
Doar primul Valkey, primul NATS și primul RabbitMQ al aplicației primesc numele obișnuite (REDIS_*, NATS_URL, AMQP_URL și RABBITMQ_*). Următorul de același tip adaugă doar propriul RIVERVO_<NAME>_URL; citește acea variabilă în cod sau setează numele obișnuite la valorile lui în fila Variabile. Variabilele ajung la un serviciu la următorul lui deploy — vezi Variabile de mediu.
Laravel
Valkey. Setează în fila Variabile:
QUEUE_CONNECTION=redisRulează php artisan queue:work — sau php artisan horizon, cu Horizon — ca worker în fundal. Vezi Laravel.
RabbitMQ. Laravel nu are un driver RabbitMQ inclus, iar Rivervo nu schimbă singur QUEUE_CONNECTION. Ca să folosești RabbitMQ pentru cozile Laravel:
- Instalează pachetul:
composer require vladimir-yuldashev/laravel-queue-rabbitmq. - Adaugă conexiunea
rabbitmqînconfig/queue.php, așa cum arată README-ul pachetului pentru versiunea ta. Ea citeșteRABBITMQ_HOST,RABBITMQ_PORT,RABBITMQ_USER,RABBITMQ_PASSWORDșiRABBITMQ_VHOST, pe care aplicația le are deja:
'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', '/'),
],
],
],- Setează
QUEUE_CONNECTION=rabbitmqîn fila Variabile și fă deploy. Workerul rămânephp artisan queue:work.
NATS. Nu există un driver oficial de coadă Laravel pentru NATS. Folosește în propriul cod un client NATS pentru PHP — de exemplu basis-company/nats — și dă-i hostul, portul, utilizatorul și parola din NATS_URL. Verifică dacă clientul suportă funcțiile de care ai nevoie (JetStream, cheie-valoare) înainte să construiești pe el.
Node.js
BullMQ (Valkey)
import { Queue, Worker } from 'bullmq'
import IORedis from 'ioredis'
const connection = new IORedis(process.env.REDIS_URL, { maxRetriesPerRequest: null })
// in the web service
const emails = new Queue('emails', { connection })
await emails.add('welcome', { userId: 42 }, { attempts: 3 })
// in the background worker
new Worker('emails', async (job) => {
await sendWelcome(job.data.userId)
}, { connection })BullMQ are nevoie de maxRetriesPerRequest: null pe conexiunea folosită de workerii săi.
Valkey Streams
import IORedis from 'ioredis'
const redis = new IORedis(process.env.REDIS_URL)
// producer
await redis.xadd('orders', '*', 'id', '42')
// consumer of the group «billing»
await redis.xgroup('CREATE', 'orders', 'billing', '0', 'MKSTREAM').catch((err) => {
if (!String(err).includes('BUSYGROUP')) throw err // the group already exists
})
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)
}
}
}O intrare citită, dar neconfirmată rămâne în așteptare în grup; XAUTOCLAIM o predă altui consumator.
NATS (nats.js)
import { connect, JSONCodec, AckPolicy } from 'nats'
const nc = await connect({ servers: process.env.NATS_URL })
const jc = JSONCodec()
// once: a stream for the subjects orders.* and a durable consumer
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()
}Cerere și răspuns: un serviciu răspunde cu nc.subscribe('prices.get', { queue: 'prices', callback: (err, msg) => msg.respond(jc.encode(price)) }), altul întreabă cu 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: at most 10 unacknowledged messages at a time
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) // to the dead-letter exchange, if the queue has one
}
})Fiecare serviciu care declară coada trebuie s-o declare cu aceleași argumente.
Python
Celery (Valkey sau RabbitMQ)
import os
from celery import Celery
app = Celery("tasks", broker=os.environ["REDIS_URL"]) # or os.environ["AMQP_URL"]
@app.task(acks_late=True)
def send_welcome(user_id):
...Rulează celery -A tasks worker --loglevel=info ca worker în fundal. Celery acceptă adresele amqp:// așa cum sunt. Cu RabbitMQ, versiunile recente de Celery pot declara cozi quorum (task_default_queue_type = "quorum") — vezi documentația Celery pentru versiunea ta.
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)Workerul: 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()Livrat de mai multe ori
Cozile și brokerii livrează din nou un mesaj când un worker se oprește înainte să-l confirme — în timpul unui deploy, al unei reporniri sau al unei restaurări. Scrie consumatorii astfel încât procesarea aceluiași mesaj de două ori să nu facă rău: păstrează ID-ul fiecărui mesaj procesat sau fă acțiunea în sine repetabilă (de exemplu „setează starea pe plătit” în loc de „adaugă o plată”).
Resurse și preț
| Serviciu | Pornește cu | Memorie minimă |
|---|---|---|
| NATS | 256 MB de memorie · 1 nucleu CPU · 5 GB de disc | 256 MB |
| RabbitMQ | 1 GB de memorie · 1 nucleu CPU · 10 GB de disc | 512 MB |
Fiecare are prețul dat de memorie, CPU și disc, ca orice serviciu — vezi Serviciile unui proiect. Resursele se pot schimba mai târziu din Setări ale serviciului.
Backupuri și restaurare
NATS și RabbitMQ au backup zilnic; păstrăm ultimele 7 zile și 4 săptămâni, ca la celelalte servicii.
- Backupul copiază fișierele de date ale serviciului în timp ce acesta rulează. Pentru RabbitMQ, același backup conține și un export al definițiilor: utilizatori, gazde virtuale, cozi, exchange-uri, legături (bindings) și politici.
- Nu există restaurare la un moment exact — aceasta este doar pentru PostgreSQL și MySQL. Restaurezi una dintre copiile zilnice.
- O restaurare oprește serviciul pentru scurt timp, pune fișierele la loc și îl pornește din nou. Mesajele sosite sau confirmate în jurul momentului backupului pot lipsi sau pot fi livrate din nou — încă un motiv ca procesarea repetată să nu facă rău consumatorilor.
- Pentru RabbitMQ, dacă fișierele copiate nu pot fi pornite, serviciul pornește doar cu definițiile: cozile, exchange-urile și utilizatorii există, dar mesajele din backup se pierd.
Mentenanță și mutări
NATS și RabbitMQ nu au o fereastră de mentenanță de setat. Nu sunt mutate automat pe alt server; dacă va fi vreodată nevoie, echipa de suport stabilește asta împreună cu tine.