Začať

Udalosti a fronty: Valkey, NATS a RabbitMQ.

Úlohy na pozadí, udalosti a správy medzi službami aplikácie: kedy zvoliť Valkey, NATS alebo RabbitMQ, premenné na pripojenie, príklady pre Laravel, Node.js a Python, zdroje, zálohy a limity.

9 MIN. ČÍTANIA

Keď web odovzdá prácu workeru — poslať e-mail, zmenšiť obrázok, zaúčtovať objednávku — alebo jedna služba oznámi ostatným, že sa niečo stalo, správa ide cez frontu alebo message broker. Projekt môže mať tri takéto služby, každú pridanú ako službu: Prehľad → Služby → Pridať službu.

SlužbaZvoľte ju na
Valkeyjednoduché fronty úloh (fronty Laravelu a Horizon, BullMQ, Celery, RQ) a udalosti v Streams — keď ho už používate na cache a relácie
NATSľahkú komunikáciu medzi službami: udalosti, požiadavka a odpoveď a trvalé streamy s JetStream
RabbitMQklasický message broker: smerovanie cez exchange, potvrdzovanie, opakovanie a dead-lettering, quorum fronty

Ak si nie ste istí, začnite s Valkey pre úlohy na pozadí: väčšina frameworkov ho podporuje hneď. RabbitMQ zvoľte, keď treba správy smerovať medzi mnohými frontami a žiadna sa nesmie stratiť, a NATS, keď si služby vymieňajú veľa malých správ alebo sa navzájom pýtajú na odpovede.

Valkey: fronty úloh a Streams

Valkey je úložisko kompatibilné s Redis — tá istá spravovaná služba ako v časti Databázy. Prvý Valkey aplikácie poskytne každej službe s kódom REDIS_URL, REDIS_HOST, REDIS_PORT a REDIS_PASSWORD; každý Valkey poskytuje aj vlastnú RIVERVO_<NAME>_URL.

Tri spôsoby, ako cez neho posielať správy:

  • Fronty úloh — fronty Laravelu s ovládačom redis a Horizon, BullMQ, Celery, RQ. Knižnica uchováva úlohy vo Valkey; worker ich berie jednu po druhej a neúspešné opakuje.
  • Streams so skupinami konzumentov — XADD pridá udalosť do streamu, konzumenti skupiny ju čítajú cez XREADGROUP a potvrdzujú cez XACK. Udalosti sa ukladajú: zastavený konzument pokračuje tam, kde skončil, nepotvrdenú udalosť možno vziať znova a nová skupina môže stream čítať od začiatku.
  • Pub/Sub — PUBLISH a SUBSCRIBE doručia správu len odberateľom pripojeným v danom okamihu. Správa sa neukladá: odberateľ, ktorý sa reštartuje alebo ešte nie je pripojený, o ňu príde. Pub/Sub používajte len tam, kde stratená správa neuškodí (napríklad signál „obnoviť“), a na všetko ostatné Streams alebo frontu.

Valkey sa zálohuje každý deň ako ostatné databázy; po otvorení prístupu je dostupný aj zvonka. Pozrite si Databázy.

NATS

NATS je ľahký a rýchly systém na posielanie správ so zapnutým JetStream:

  • Publikovanie a odber — služba publikuje do subjektu, napríklad orders.created, a každý odberateľ subjektu dostane správu. Bez JetStream ide o „pošli a zabudni“, ako pri Pub/Sub vyššie.
  • Požiadavka a odpoveď — jedna služba sa pýta, iná odpovedá. Keď odpovedá viac inštancií ako queue group, NATS medzi ne požiadavky rozdeľuje.
  • JetStream — trvalé streamy: správy sa ukladajú na disk služby, konzument si pamätá, čo prečítal, a každá správa sa doručuje aspoň raz, kým nie je potvrdená.
  • Úložisko kľúč-hodnota a objektové úložisko postavené na JetStream — pre malé zdieľané nastavenia, zámky alebo súbory medzi službami.

Premenné. Prvý NATS aplikácie poskytne každej službe s kódom:

NATS_URL=nats://<user>:<password>@<service name>:4222

Každá služba NATS poskytuje aj RIVERVO_<NAME>_URL s adresou v rovnakom tvare — NAME je názov služby veľkými písmenami, pomlčky sa menia na _: služba s názvom events poskytne RIVERVO_EVENTS_URL.

JetStream uchováva streamy na disku služby; streamy uložené v pamäti môžu využiť približne štvrtinu pamäte služby.

RabbitMQ

RabbitMQ 4.1 je klasický message broker: producenti publikujú do exchange, exchange smerujú správy do front podľa smerovacích kľúčov, konzumenti každú správu potvrdzujú a odmietnutá alebo expirovaná správa môže ísť do dead-letter exchange. Pre fronty, ktorých správy musia prežiť reštart, používajte quorum fronty (argument x-queue-type: quorum) a správy publikujte ako trvalé.

Premenné. Prvý RabbitMQ aplikácie poskytne každej službe s kódom:

PremennáHodnota
AMQP_URLamqp://<user>:<password>@<service name>:5672/%2f
RABBITMQ_HOSTnázov služby
RABBITMQ_PORT5672
RABBITMQ_USER, RABBITMQ_PASSWORDpoužívateľ a heslo
RABBITMQ_VHOST/

%2f na konci AMQP_URL je predvolený virtuálny hostiteľ / zapísaný tak, ako to vyžadujú pripájacie adresy. Každá služba RabbitMQ poskytuje aj vlastnú RIVERVO_<NAME>_URL s adresou v rovnakom tvare.

Management API. HTTP management API počúva na porte 15672 v súkromnej sieti aplikácie: služby aplikácie sa k nemu dostanú na http://<service name>:15672 s tým istým používateľom a heslom, napríklad:

curl -u "$RABBITMQ_USER:$RABBITMQ_PASSWORD" "http://$RABBITMQ_HOST:15672/api/queues"

Správcovská stránka na internete nie je. Stránka služby v paneli ukazuje krátky zoznam jej front len na čítanie: pripravené správy, nepotvrdené správy a konzumentov.

Len interne

NATS a RabbitMQ nemajú verejnú adresu a nie sú dostupné zvonka aplikácie — z vášho počítača, iného servera ani inej aplikácie. Na rozdiel od PostgreSQL, MySQL a Valkey sa pre ne prístup zvonka neponúka. Služby, ktoré správy publikujú a spracúvajú, bežia ako služby tej istej aplikácie: webové služby, workery na pozadí a plánované úlohy.

Druhá služba rovnakého druhu

Bežné názvy (REDIS_*, NATS_URL, AMQP_URL a RABBITMQ_*) dostane len prvý Valkey, NATS a RabbitMQ aplikácie. Ďalšia služba rovnakého druhu pridá len vlastnú RIVERVO_<NAME>_URL; čítajte túto premennú vo svojom kóde alebo na karte Premenné nastavte bežné názvy na jej hodnoty. Premenné sa do služby dostanú pri jej ďalšom nasadení — pozrite si Premenné prostredia.

Laravel

Valkey. Na karte Premenné nastavte:

QUEUE_CONNECTION=redis

Spúšťajte php artisan queue:work — alebo php artisan horizon s Horizonom — ako worker na pozadí. Pozrite si Laravel.

RabbitMQ. Laravel nemá vstavaný ovládač pre RabbitMQ a Rivervo QUEUE_CONNECTION sám nemení. Ak chcete RabbitMQ používať pre fronty Laravelu:

  1. Nainštalujte balík: composer require vladimir-yuldashev/laravel-queue-rabbitmq.
  2. Pridajte pripojenie rabbitmq do config/queue.php podľa README balíka pre vašu verziu. Číta RABBITMQ_HOST, RABBITMQ_PORT, RABBITMQ_USER, RABBITMQ_PASSWORD a RABBITMQ_VHOST, ktoré aplikácia už má:
'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. Na karte Premenné nastavte QUEUE_CONNECTION=rabbitmq a nasaďte. Worker zostáva php artisan queue:work.

NATS. Oficiálny ovládač front Laravelu pre NATS neexistuje. Vo vlastnom kóde použite NATS klienta pre PHP — napríklad basis-company/nats — a odovzdajte mu hostiteľa, port, používateľa a heslo z NATS_URL. Skôr než na ňom niečo postavíte, overte si, že klient podporuje funkcie, ktoré potrebujete (JetStream, kľúč-hodnota).

Node.js

BullMQ (Valkey)

import { Queue, Worker } from 'bullmq'
import IORedis from 'ioredis'
 
const connection = new IORedis(process.env.REDIS_URL, { maxRetriesPerRequest: null })
 
// vo webovej službe
const emails = new Queue('emails', { connection })
await emails.add('welcome', { userId: 42 }, { attempts: 3 })
 
// vo workeri na pozadí
new Worker('emails', async (job) => {
  await sendWelcome(job.data.userId)
}, { connection })

BullMQ vyžaduje maxRetriesPerRequest: null na pripojení, ktoré používajú jeho workery.

Valkey Streams

import IORedis from 'ioredis'
 
const redis = new IORedis(process.env.REDIS_URL)
 
// producent
await redis.xadd('orders', '*', 'id', '42')
 
// konzument skupiny „billing“
await redis.xgroup('CREATE', 'orders', 'billing', '0', 'MKSTREAM').catch((err) => {
  if (!String(err).includes('BUSYGROUP')) throw err // skupina už existuje
})
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)
    }
  }
}

Záznam, ktorý bol prečítaný, ale nepotvrdený, zostáva v skupine ako čakajúci; XAUTOCLAIM ho odovzdá inému konzumentovi.

NATS (nats.js)

import { connect, JSONCodec, AckPolicy } from 'nats'
 
const nc = await connect({ servers: process.env.NATS_URL })
const jc = JSONCodec()
 
// raz: stream pre subjekty orders.* a trvalý konzument
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 })
 
// producent
const js = nc.jetstream()
await js.publish('orders.created', jc.encode({ id: 42 }))
 
// konzument
const consumer = await js.consumers.get('ORDERS', 'billing')
for await (const m of await consumer.consume()) {
  await handleOrder(jc.decode(m.data))
  m.ack()
}

Požiadavka a odpoveď: jedna služba odpovedá cez nc.subscribe('prices.get', { queue: 'prices', callback: (err, msg) => msg.respond(jc.encode(price)) }), iná sa pýta cez 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' } })
 
// producent
ch.sendToQueue('emails', Buffer.from(JSON.stringify({ userId: 42 })), { persistent: true })
 
// konzument: naraz najviac 10 nepotvrdených správ
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) // do dead-letter exchange, ak ju fronta má
  }
})

Každá služba, ktorá frontu deklaruje, ju musí deklarovať s rovnakými argumentmi.

Python

Celery (Valkey alebo RabbitMQ)

import os
from celery import Celery
 
app = Celery("tasks", broker=os.environ["REDIS_URL"])  # alebo os.environ["AMQP_URL"]
 
@app.task(acks_late=True)
def send_welcome(user_id):
    ...

Spúšťajte celery -A tasks worker --loglevel=info ako worker na pozadí. Celery prijíma adresy amqp:// tak, ako sú. S RabbitMQ vedia novšie verzie Celery deklarovať quorum fronty (task_default_queue_type = "quorum") — pozrite si dokumentáciu Celery pre vašu verziu.

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"})
 
# producent
ch.basic_publish(exchange="", routing_key="emails",
                 body=json.dumps({"user_id": 42}),
                 properties=pika.BasicProperties(delivery_mode=2))
 
# konzument
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()

Doručené viackrát

Fronty a brokery doručia správu znova, keď sa worker zastaví skôr, ako ju potvrdí — počas nasadenia, reštartu alebo obnovy. Konzumentov píšte tak, aby dvojité spracovanie tej istej správy neuškodilo: uchovávajte ID každej spracovanej správy alebo urobte samotnú akciu opakovateľnou (napríklad „nastaviť stav na zaplatené“ namiesto „pridať platbu“).

Zdroje a cena

SlužbaZačína sNajmenej pamäte
NATS256 MB pamäte · 1 jadro CPU · 5 GB disku256 MB
RabbitMQ1 GB pamäte · 1 jadro CPU · 10 GB disku512 MB

Cena každej sa určuje podľa pamäte, CPU a disku ako pri každej službe — pozrite si Služby projektu. Zdroje môžete neskôr zmeniť v Nastaveniach služby.

Zálohy a obnova

NATS a RabbitMQ sa zálohujú každý deň; uchovávame posledných 7 dní a 4 týždne, ako pri ostatných službách.

  • Záloha kopíruje dátové súbory služby počas jej behu. Pri RabbitMQ obsahuje tá istá záloha aj export jeho definícií: používateľov, virtuálnych hostiteľov, front, exchange, väzieb a politík.
  • Obnova k presnému okamihu nie je k dispozícii — tá je len pre PostgreSQL a MySQL. Obnovujete jednu z denných kópií.
  • Obnova službu nakrátko zastaví, vráti súbory a znova ju spustí. Správy, ktoré prišli alebo boli potvrdené okolo času zálohy, môžu chýbať alebo byť doručené znova — ďalší dôvod, prečo robiť konzumentov bezpečných pri opakovaní.
  • Ak sa pri RabbitMQ skopírované súbory nedajú spustiť, služba sa spustí len s definíciami: fronty, exchange a používatelia sú na mieste, ale správy zo zálohy sa stratia.

Údržba a presuny

NATS a RabbitMQ nemajú nastaviteľný čas údržby. Na iný server sa automaticky nepresúvajú; ak by to bolo niekedy potrebné, podpora to s vami dohodne.

Stále si neviete rady?

Napíšte nám do chatu — AI odpovie okamžite a technik sa pripojí, keď treba, v ktorúkoľvek dennú hodinu.

Kontaktovať podporu