Începe acum

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.

10 MIN DE CITIT

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.

ServiciuAlege-l pentru
Valkeycozi simple de sarcini (cozile Laravel și Horizon, BullMQ, Celery, RQ) și evenimente în Streams — când îl folosești deja pentru cache și sesiuni
NATSmesagerie ușoară între servicii: evenimente, cerere și răspuns, plus fluxuri durabile cu JetStream
RabbitMQun 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 — XADD adaugă un eveniment într-un stream, consumatorii unui grup îl citesc cu XREADGROUP și îl confirmă cu XACK. 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 și SUBSCRIBE livrează 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_URLamqp://<user>:<password>@<service name>:5672/%2f
RABBITMQ_HOSTnumele serviciului
RABBITMQ_PORT5672
RABBITMQ_USER, RABBITMQ_PASSWORDutilizatorul ș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=redis

Rulează 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:

  1. Instalează pachetul: composer require vladimir-yuldashev/laravel-queue-rabbitmq.
  2. Adaugă conexiunea rabbitmq în config/queue.php, așa cum arată README-ul pachetului pentru versiunea ta. Ea citește RABBITMQ_HOST, RABBITMQ_PORT, RABBITMQ_USER, RABBITMQ_PASSWORD și RABBITMQ_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', '/'),
        ],
    ],
],
  1. Setează QUEUE_CONNECTION=rabbitmq în fila Variabile și fă deploy. Workerul rămâne php 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ț

ServiciuPornește cuMemorie minimă
NATS256 MB de memorie · 1 nucleu CPU · 5 GB de disc256 MB
RabbitMQ1 GB de memorie · 1 nucleu CPU · 10 GB de disc512 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.

Încă ai întrebări?

Scrie-ne în chat — asistentul AI răspunde imediat, iar un inginer intervine când e nevoie, la orice oră.

Contactează suportul