Kezdés

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.

10 PERC OLVASÁS

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ásMire válaszd
Valkeyegyszerű feladatsorok (Laravel queues és Horizon, BullMQ, Celery, RQ), valamint események Streamsben – ha már használod gyorsítótárhoz és munkamenetekhez
NATSkönnyű üzenetküldés szolgáltatások között: események, kérés és válasz, valamint tartós streamek JetStreammel
RabbitMQklasszikus ü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 redis driverrel é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 XADD hozzáfűz egy eseményt a streamhez, a csoport fogyasztói az XREADGROUP paranccsal olvassák, és az XACK paranccsal 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 a SUBSCRIBE csak 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_URLamqp://<user>:<password>@<service name>:5672/%2f
RABBITMQ_HOSTa szolgáltatás neve
RABBITMQ_PORT5672
RABBITMQ_USER, RABBITMQ_PASSWORDa 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=redis

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

  1. Telepítsd a csomagot: composer require vladimir-yuldashev/laravel-queue-rabbitmq.
  2. Add hozzá a rabbitmq kapcsolatot a config/queue.php fájlhoz úgy, ahogy a csomag README-je mutatja a te verziódhoz. Ez a RABBITMQ_HOST, RABBITMQ_PORT, RABBITMQ_USER, RABBITMQ_PASSWORD és RABBITMQ_VHOST vá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', '/'),
        ],
    ],
],
  1. Állítsd be a QUEUE_CONNECTION=rabbitmq értéket a Változók fülön, és telepíts. A worker továbbra is php 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ásKezdő erőforrásokLegkevesebb memória
NATS256 MB memória · 1 CPU-mag · 5 GB lemez256 MB
RabbitMQ1 GB memória · 1 CPU-mag · 10 GB lemez512 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.

Elakadtál?

Írj nekünk chaten — az AI azonnal válaszol, és ha kell, egy mérnök is bekapcsolódik, a nap bármely szakában.

Ügyfélszolgálat