Események és sorok: Valkey, NATS és RabbitMQ.
Háttérfeladatok, események és üzenetek egy alkalmazás szolgáltatásai között: mikor válaszd a Valkeyt, a NATS-ot vagy a RabbitMQ-t, kapcsolati változók, példák Laravelhez, Node.js-hez és Pythonhoz, erőforrások, mentések és korlátok.
Amikor egy oldal munkát ad át egy workernek – e-mail küldése, kép átméretezése, rendelés terhelése –, vagy egy szolgáltatás jelzi a többinek, hogy valami történt, az üzenet egy soron vagy egy üzenetközvetítőn (brokeren) halad át. Egy projektben háromféle ilyen lehet, mindegyiket szolgáltatásként adod hozzá: Áttekintés → Szolgáltatások → Szolgáltatás hozzáadása.
| Szolgáltatás | Mire válaszd |
|---|---|
| Valkey | egyszerű feladatsorok (Laravel queues és Horizon, BullMQ, Celery, RQ), valamint események Streamsben – ha már használod gyorsítótárhoz és munkamenetekhez |
| NATS | könnyű üzenetküldés szolgáltatások között: események, kérés és válasz, valamint tartós streamek JetStreammel |
| RabbitMQ | klasszikus üzenetközvetítő: útválasztás exchange-eken keresztül, nyugták, újrapróbálkozás és dead-lettering, quorum sorok |
Ha bizonytalan vagy, háttérfeladatokhoz kezdd a Valkey-vel: a legtöbb keretrendszer alapból támogatja. A RabbitMQ-t válaszd, ha az üzeneteket sok sor között kell irányítani, és egy sem veszhet el, a NATS-ot pedig, ha a szolgáltatások sok kis üzenetet váltanak, vagy választ kérnek egymástól.
Valkey: feladatsorok és Streams
A Valkey Redis-kompatibilis tároló – ugyanaz a felügyelt szolgáltatás, mint az Adatbázisok között. Az alkalmazás első Valkey-szolgáltatása minden kódszolgáltatásnak megadja a REDIS_URL, REDIS_HOST, REDIS_PORT és REDIS_PASSWORD változókat; minden Valkey ezenkívül a saját RIVERVO_<NAME>_URL változóját is megadja.
Háromféleképpen küldhetsz rajta üzeneteket:
- Feladatsorok – Laravel queues
redisdriverrel és Horizonnal, BullMQ, Celery, RQ. A könyvtár a Valkey-ben tárolja a feladatokat; egy worker egyenként veszi ki őket, és újrapróbálja a sikerteleneket. - Streams fogyasztói csoportokkal – az
XADDhozzáfűz egy eseményt a streamhez, a csoport fogyasztói azXREADGROUPparanccsal olvassák, és azXACKparanccsal nyugtázzák. Az események tárolódnak: a leállított fogyasztó ott folytatja, ahol abbahagyta, a nem nyugtázott esemény újra felvehető, egy új csoport pedig az elejétől olvashatja a streamet. - Pub/Sub – a
PUBLISHés aSUBSCRIBEcsak az adott pillanatban csatlakozott feliratkozóknak kézbesíti az üzenetet. Az üzenet nem tárolódik: az újrainduló vagy még nem csatlakozott feliratkozó lemarad róla. A Pub/Sub-ot csak ott használd, ahol egy elveszett üzenet nem okoz kárt (például egy „frissítés” jelzésnél), minden máshoz Streamst vagy sort.
A Valkey-t a többi adatbázishoz hasonlóan naponta mentjük; ha megnyitod a hozzáférést, kívülről is elérhető. Lásd: Adatbázisok.
NATS
A NATS könnyű, gyors üzenetküldő rendszer, bekapcsolt JetStreammel:
- Publikálás és feliratkozás – egy szolgáltatás egy subjectre publikál, például
orders.created, és a subject minden feliratkozója megkapja az üzenetet. JetStream nélkül ez „küldd el és felejtsd el” működés, mint a fenti Pub/Sub. - Kérés és válasz – egy szolgáltatás kérdez, egy másik válaszol. Ha több példány queue groupként válaszol, a NATS elosztja közöttük a kéréseket.
- JetStream – tartós streamek: az üzenetek a szolgáltatás lemezén tárolódnak, a fogyasztó megjegyzi, mit olvasott már, és minden üzenetet legalább egyszer kézbesítünk, amíg nyugtázást nem kap.
- Kulcs-érték és objektumtár a JetStreamre építve – kis közös beállításokhoz, zárakhoz vagy fájlokhoz a szolgáltatások között.
Változók. Az alkalmazás első NATS-szolgáltatása minden kódszolgáltatásnak megadja:
NATS_URL=nats://<user>:<password>@<service name>:4222
Minden NATS-szolgáltatás egy azonos formájú címmel a RIVERVO_<NAME>_URL változót is megadja – a NAME a szolgáltatás neve nagybetűkkel, a kötőjelek helyén _ jellel: egy events nevű szolgáltatás RIVERVO_EVENTS_URL változót ad.
A JetStream a streamjeit a szolgáltatás lemezén tárolja; a memóriában tartott streamek a szolgáltatás memóriájának nagyjából negyedét használhatják.
RabbitMQ
A RabbitMQ 4.1 klasszikus üzenetközvetítő: a küldők exchange-ekre publikálnak, az exchange-ek routing key alapján sorokba irányítják az üzeneteket, a fogyasztók minden üzenetet nyugtáznak, az elutasított vagy lejárt üzenet pedig egy dead-letter exchange-re kerülhet. Azokhoz a sorokhoz, amelyek üzeneteinek túl kell élniük egy újraindítást, használj quorum sorokat (x-queue-type: quorum argumentum), és az üzeneteket tartósként publikáld.
Változók. Az alkalmazás első RabbitMQ-szolgáltatása minden kódszolgáltatásnak megadja:
| Változó | Érték |
|---|---|
AMQP_URL | amqp://<user>:<password>@<service name>:5672/%2f |
RABBITMQ_HOST | a szolgáltatás neve |
RABBITMQ_PORT | 5672 |
RABBITMQ_USER, RABBITMQ_PASSWORD | a felhasználó és a jelszó |
RABBITMQ_VHOST | / |
Az AMQP_URL végén lévő %2f az alapértelmezett / virtuális host, abban a formában, ahogy a kapcsolati címek megkövetelik. Minden RabbitMQ-szolgáltatás egy azonos formájú címmel a saját RIVERVO_<NAME>_URL változóját is megadja.
Management API. A management HTTP API az alkalmazás privát hálózatán belül a 15672 porton figyel: az alkalmazás szolgáltatásai a http://<service name>:15672 címen érik el ugyanazzal a felhasználóval és jelszóval, például:
curl -u "$RABBITMQ_USER:$RABBITMQ_PASSWORD" "http://$RABBITMQ_HOST:15672/api/queues"Az interneten nincs management oldal. A szolgáltatás oldala a panelben rövid, csak olvasható listát mutat a soraidról: kézbesítésre kész és nem nyugtázott üzenetek, valamint fogyasztók.
Csak belső
A NATS-nak és a RabbitMQ-nak nincs nyilvános címe, és az alkalmazáson kívülről – a számítógépedről, egy másik szerverről vagy egy másik alkalmazásból – nem érhetők el. A PostgreSQL-lel, a MySQL-lel és a Valkey-vel ellentétben hozzájuk nem kínálunk külső hozzáférést. Az üzeneteket publikáló és fogyasztó szolgáltatások ugyanannak az alkalmazásnak a szolgáltatásaiként futnak: webszolgáltatások, háttérworkerek és ütemezett feladatok.
Második azonos típusú szolgáltatás
Csak az alkalmazás első Valkey-, NATS- és RabbitMQ-szolgáltatása kapja a szokásos neveket (REDIS_*, NATS_URL, AMQP_URL és RABBITMQ_*). A következő azonos típusú csak a saját RIVERVO_<NAME>_URL változóját adja hozzá; ezt a változót olvasd a kódodban, vagy állítsd be a szokásos neveket az értékeire a Változók fülön. A változók a következő telepítéssel jutnak el egy szolgáltatáshoz – lásd: Környezeti változók.
Laravel
Valkey. Állítsd be a Változók fülön:
QUEUE_CONNECTION=redisFuttasd a php artisan queue:work parancsot – vagy Horizonnal a php artisan horizon parancsot – háttérworkerként. Lásd: Laravel.
RabbitMQ. A Laravelben nincs beépített RabbitMQ-driver, és a Rivervo nem módosítja magától a QUEUE_CONNECTION értékét. Ha RabbitMQ-t szeretnél használni a Laravel-sorokhoz:
- Telepítsd a csomagot:
composer require vladimir-yuldashev/laravel-queue-rabbitmq. - Add hozzá a
rabbitmqkapcsolatot aconfig/queue.phpfájlhoz úgy, ahogy a csomag README-je mutatja a te verziódhoz. Ez aRABBITMQ_HOST,RABBITMQ_PORT,RABBITMQ_USER,RABBITMQ_PASSWORDésRABBITMQ_VHOSTváltozókat olvassa, amelyek az alkalmazásnak már megvannak:
'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', '/'),
],
],
],- Állítsd be a
QUEUE_CONNECTION=rabbitmqértéket a Változók fülön, és telepíts. A worker továbbra isphp artisan queue:work.
NATS. A NATS-hoz nincs hivatalos Laravel-sordriver. Használj PHP-s NATS-klienst a saját kódodban – például a basis-company/nats csomagot –, és add meg neki a hostot, a portot, a felhasználót és a jelszót a NATS_URL alapján. Mielőtt építenél rá, ellenőrizd, hogy a kliens támogatja-e a szükséges funkciókat (JetStream, kulcs-érték).
Node.js
BullMQ (Valkey)
import { Queue, Worker } from 'bullmq'
import IORedis from 'ioredis'
const connection = new IORedis(process.env.REDIS_URL, { maxRetriesPerRequest: null })
// a webszolgáltatásban
const emails = new Queue('emails', { connection })
await emails.add('welcome', { userId: 42 }, { attempts: 3 })
// a háttérworkerben
new Worker('emails', async (job) => {
await sendWelcome(job.data.userId)
}, { connection })A BullMQ-nak maxRetriesPerRequest: null beállítás kell a workerei által használt kapcsolaton.
Valkey Streams
import IORedis from 'ioredis'
const redis = new IORedis(process.env.REDIS_URL)
// küldő
await redis.xadd('orders', '*', 'id', '42')
// a „billing” csoport fogyasztója
await redis.xgroup('CREATE', 'orders', 'billing', '0', 'MKSTREAM').catch((err) => {
if (!String(err).includes('BUSYGROUP')) throw err // a csoport már létezik
})
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)
}
}
}Az elolvasott, de nem nyugtázott bejegyzés függőben marad a csoportban; az XAUTOCLAIM átadja egy másik fogyasztónak.
NATS (nats.js)
import { connect, JSONCodec, AckPolicy } from 'nats'
const nc = await connect({ servers: process.env.NATS_URL })
const jc = JSONCodec()
// egyszer: stream az orders.* subjectekhez és egy tartós fogyasztó
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 })
// küldő
const js = nc.jetstream()
await js.publish('orders.created', jc.encode({ id: 42 }))
// fogyasztó
const consumer = await js.consumers.get('ORDERS', 'billing')
for await (const m of await consumer.consume()) {
await handleOrder(jc.decode(m.data))
m.ack()
}Kérés és válasz: az egyik szolgáltatás a nc.subscribe('prices.get', { queue: 'prices', callback: (err, msg) => msg.respond(jc.encode(price)) }) hívással válaszol, a másik a await nc.request('prices.get', jc.encode({ sku: 'A1' }), { timeout: 2000 }) hívással kérdez.
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' } })
// küldő
ch.sendToQueue('emails', Buffer.from(JSON.stringify({ userId: 42 })), { persistent: true })
// fogyasztó: egyszerre legfeljebb 10 nem nyugtázott üzenet
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) // a dead-letter exchange-re, ha a sornak van ilyen
}
})Minden szolgáltatásnak, amely deklarálja a sort, ugyanazokkal az argumentumokkal kell deklarálnia.
Python
Celery (Valkey vagy RabbitMQ)
import os
from celery import Celery
app = Celery("tasks", broker=os.environ["REDIS_URL"]) # vagy os.environ["AMQP_URL"]
@app.task(acks_late=True)
def send_welcome(user_id):
...Futtasd a celery -A tasks worker --loglevel=info parancsot háttérworkerként. A Celery az amqp:// címeket változtatás nélkül elfogadja. RabbitMQ esetén az újabb Celery-verziók quorum sorokat is deklarálhatnak (task_default_queue_type = "quorum") – lásd a Celery dokumentációját a te verziódhoz.
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)A 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"})
# küldő
ch.basic_publish(exchange="", routing_key="emails",
body=json.dumps({"user_id": 42}),
properties=pika.BasicProperties(delivery_mode=2))
# fogyasztó
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()Többszöri kézbesítés
A sorok és a brokerek újra kézbesítik az üzenetet, ha egy worker a nyugtázás előtt leáll – telepítés, újraindítás vagy visszaállítás közben. Úgy írd meg a fogyasztókat, hogy ugyanannak az üzenetnek a kétszeri feldolgozása ne okozzon kárt: tárold minden feldolgozott üzenet azonosítóját, vagy tedd magát a műveletet megismételhetővé (például „állítsd az állapotot fizetettre” a „adj hozzá egy fizetést” helyett).
Erőforrások és ár
| Szolgáltatás | Kezdő erőforrások | Legkevesebb memória |
|---|---|---|
| NATS | 256 MB memória · 1 CPU-mag · 5 GB lemez | 256 MB |
| RabbitMQ | 1 GB memória · 1 CPU-mag · 10 GB lemez | 512 MB |
Mindegyik ára a memóriája, a CPU-ja és a lemeze alapján alakul, mint bármely szolgáltatásé – lásd: Egy projekt szolgáltatásai. Az erőforrások később módosíthatók a szolgáltatás Beállítások részén.
Mentések és visszaállítás
A NATS-ot és a RabbitMQ-t naponta mentjük; a többi szolgáltatáshoz hasonlóan az utolsó 7 napot és 4 hetet őrizzük meg.
- A mentés a szolgáltatás futása közben másolja az adatfájlokat. RabbitMQ esetén ugyanaz a mentés a definíciók exportját is tartalmazza: felhasználók, virtuális hostok, sorok, exchange-ek, kötések és szabályzatok.
- Pontos időpontra való visszaállítás nincs – az csak PostgreSQL-hez és MySQL-hez érhető el. A napi másolatok egyikét állítod vissza.
- A visszaállítás rövid időre leállítja a szolgáltatást, visszamásolja a fájlokat, majd újraindítja. A mentés időpontja körül érkezett vagy nyugtázott üzenetek hiányozhatnak, vagy újra kézbesítődhetnek – ez is ok arra, hogy a fogyasztók biztonságosan megismételhetők legyenek.
- RabbitMQ esetén, ha a másolt fájlokkal nem indul el, a szolgáltatás csak a definíciókkal indul: a sorok, az exchange-ek és a felhasználók megvannak, de a mentésben lévő üzenetek elvesznek.
Karbantartás és költöztetés
A NATS-hoz és a RabbitMQ-hoz nem kell karbantartási időt beállítani. Automatikusan nem költöztetjük őket másik szerverre; ha erre valaha szükség lesz, az ügyfélszolgálat egyezteti veled.