Začít

Události a fronty: Valkey, NATS a RabbitMQ.

Úlohy na pozadí, události a zprávy mezi službami aplikace: kdy zvolit Valkey, NATS nebo RabbitMQ, proměnné pro připojení, příklady pro Laravel, Node.js a Python, prostředky, zálohy a omezení.

9 MIN ČTENÍ

Když web předá práci workeru — odeslat e-mail, zmenšit obrázek, naúčtovat objednávku — nebo když jedna služba dá ostatním vědět, že se něco stalo, jde zpráva přes frontu nebo message broker. Projekt může mít tři takové služby, každou přidanou jako službu: Přehled → Služby → Přidat službu.

SlužbaKdy ji zvolit
Valkeyjednoduché fronty úloh (fronty a Horizon v Laravelu, BullMQ, Celery, RQ) a události ve Streams — když ho už používáte pro cache a relace
NATSlehké zasílání zpráv mezi službami: události, požadavek a odpověď a trvalé streamy s JetStreamem
RabbitMQklasický message broker: směrování přes exchange, potvrzování, opakované pokusy a dead-lettering, quorum fronty

Pokud si nejste jistí, začněte pro úlohy na pozadí s Valkey: většina frameworků ho podporuje hned po instalaci. RabbitMQ zvolte, když se zprávy musí směrovat mezi mnoha frontami a žádná se nesmí ztratit, a NATS, když si služby vyměňují hodně malých zpráv nebo se navzájem ptají na odpovědi.

Valkey: fronty úloh a Streams

Valkey je úložiště kompatibilní s Redisem — stejná spravovaná služba jako v článku Databáze. První Valkey aplikace dá každé službě s kódem REDIS_URL, REDIS_HOST, REDIS_PORT a REDIS_PASSWORD; každý Valkey navíc poskytuje vlastní RIVERVO_<NAME>_URL.

Zprávy přes něj můžete posílat třemi způsoby:

  • Fronty úloh — fronty v Laravelu s ovladačem redis a Horizon, BullMQ, Celery, RQ. Knihovna uchovává úlohy ve Valkey; worker je bere jednu po druhé a ty, které selžou, zkouší znovu.
  • Streams se skupinami konzumentů — XADD přidá událost do streamu, konzumenti skupiny ji čtou pomocí XREADGROUP a potvrzují pomocí XACK. Události se ukládají: konzument, který byl zastavený, pokračuje tam, kde skončil, nepotvrzenou událost lze převzít znovu a nová skupina může stream číst od začátku.
  • Pub/Sub — PUBLISH a SUBSCRIBE doručí zprávu jen odběratelům, kteří jsou v tu chvíli připojení. Zpráva se neukládá: odběratel, který se právě restartuje nebo ještě není připojený, o ni přijde. Pub/Sub používejte jen tam, kde ztracená zpráva neuškodí (například signál „obnovit“), a na vše ostatní Streams nebo frontu.

Valkey se zálohuje každý den jako ostatní databáze; když otevřete přístup, je dostupný i zvenčí. Viz Databáze.

NATS

NATS je lehký a rychlý systém pro zasílání zpráv se zapnutým JetStreamem:

  • Publikování a odběr — služba publikuje do subjectu, například orders.created, a zprávu dostane každý odběratel daného subjectu. Bez JetStreamu jde o „pošli a zapomeň“, jako u Pub/Sub výše.
  • Požadavek a odpověď — jedna služba se ptá, druhá odpovídá. Když odpovídá několik instancí jako queue group, NATS mezi ně požadavky rozdělí.
  • JetStream — trvalé streamy: zprávy se ukládají na disk služby, konzument si pamatuje, co už přečetl, a každá zpráva se doručuje alespoň jednou, dokud není potvrzena.
  • Úložiště klíč–hodnota a objektové úložiště postavené na JetStreamu — pro malá sdílená nastavení, zámky nebo soubory mezi službami.

Proměnné. První NATS aplikace dá každé službě s kódem:

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

Každá služba NATS navíc poskytuje RIVERVO_<NAME>_URL s adresou stejného tvaru — NAME je název služby velkými písmeny, s pomlčkami nahrazenými _: služba s názvem events dá RIVERVO_EVENTS_URL.

JetStream uchovává své streamy na disku služby; streamy držené v paměti mohou využít zhruba čtvrtinu paměti služby.

RabbitMQ

RabbitMQ 4.1 je klasický message broker: producenti publikují do exchange, exchange směrují zprávy do front podle routing klíčů, konzumenti každou zprávu potvrzují a zpráva, která je odmítnuta nebo vyprší, může skončit v dead-letter exchange. Pro fronty, jejichž zprávy musí přežít restart, používejte quorum fronty (argument x-queue-type: quorum) a zprávy publikujte jako persistentní.

Proměnné. První RabbitMQ aplikace dá každé službě s kódem:

ProměnnáHodnota
AMQP_URLamqp://<user>:<password>@<service name>:5672/%2f
RABBITMQ_HOSTnázev služby
RABBITMQ_PORT5672
RABBITMQ_USER, RABBITMQ_PASSWORDuživatel a heslo
RABBITMQ_VHOST/

%2f na konci AMQP_URL je výchozí virtuální hostitel /, zapsaný tak, jak to adresy pro připojení vyžadují. Každá služba RabbitMQ navíc poskytuje vlastní RIVERVO_<NAME>_URL s adresou stejného tvaru.

Management API. HTTP management API naslouchá na portu 15672 uvnitř privátní sítě aplikace: služby aplikace se k němu dostanou na http://<service name>:15672 se stejným uživatelem a heslem, například:

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

Správcovská stránka na internetu není. Stránka služby v panelu ukazuje krátký přehled jejích front jen pro čtení: připravené zprávy, nepotvrzené zprávy a konzumenty.

Pouze interní

NATS a RabbitMQ nemají veřejnou adresu a zvenčí aplikace se k nim dostat nelze — ze svého počítače, z jiného serveru ani z jiné aplikace. Na rozdíl od PostgreSQL, MySQL a Valkey se u nich přístup zvenčí nenabízí. Služby, které zprávy publikují a konzumují, běží jako služby téže aplikace: webové služby, workery na pozadí a plánované úlohy.

Druhá služba stejného druhu

Obvyklé názvy (REDIS_*, NATS_URL, AMQP_URL a RABBITMQ_*) dostane jen první Valkey, NATS a RabbitMQ aplikace. Další služba stejného druhu přidá jen vlastní RIVERVO_<NAME>_URL; tuto proměnnou čtěte ve svém kódu, nebo na kartě Proměnné nastavte obvyklé názvy na její hodnoty. Proměnné se do služby dostanou s jejím dalším nasazením — viz Proměnné prostředí.

Laravel

Valkey. Na kartě Proměnné nastavte:

QUEUE_CONNECTION=redis

Spusťte php artisan queue:work — nebo php artisan horizon, pokud používáte Horizon — jako worker na pozadí. Viz Laravel.

RabbitMQ. Laravel nemá vestavěný ovladač pro RabbitMQ a Rivervo QUEUE_CONNECTION samo nemění. Chcete-li RabbitMQ používat pro fronty v Laravelu:

  1. Nainstalujte balíček: composer require vladimir-yuldashev/laravel-queue-rabbitmq.
  2. Přidejte připojení rabbitmq do config/queue.php tak, jak to pro vaši verzi ukazuje README balíčku. Čte RABBITMQ_HOST, RABBITMQ_PORT, RABBITMQ_USER, RABBITMQ_PASSWORD a RABBITMQ_VHOST, které už aplikace 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 kartě Proměnné nastavte QUEUE_CONNECTION=rabbitmq a nasaďte. Worker zůstává php artisan queue:work.

NATS. Oficiální ovladač front pro NATS Laravel nemá. Ve vlastním kódu použijte NATS klienta pro PHP — například basis-company/nats — a předejte mu hostitele, port, uživatele a heslo z NATS_URL. Než na něm začnete stavět, ověřte, že klient podporuje funkce, které potřebujete (JetStream, klíč–hodnota).

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 potřebuje maxRetriesPerRequest: null u připojení, které používají jeho workery.

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)
    }
  }
}

Záznam, který byl přečten, ale nepotvrzen, zůstává ve skupině jako čekající; XAUTOCLAIM ho předá jinému konzumentovi.

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()
}

Požadavek a odpověď: jedna služba odpovídá pomocí nc.subscribe('prices.get', { queue: 'prices', callback: (err, msg) => msg.respond(jc.encode(price)) }), druhá se ptá pomocí 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
  }
})

Každá služba, která frontu deklaruje, ji musí deklarovat se stejnými argumenty.

Python

Celery (Valkey nebo 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):
    ...

Spusťte celery -A tasks worker --loglevel=info jako worker na pozadí. Celery přijímá adresy amqp:// tak, jak jsou. S RabbitMQ umějí novější verze Celery deklarovat quorum fronty (task_default_queue_type = "quorum") — viz dokumentace Celery pro vaši verzi.

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"})
 
# 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()

Doručeno víc než jednou

Fronty a brokery doručí zprávu znovu, když se worker zastaví dřív, než ji potvrdí — během nasazení, restartu nebo obnovy. Konzumenty pište tak, aby dvojí zpracování téže zprávy neuškodilo: ukládejte ID každé zpracované zprávy, nebo udělejte samotnou akci opakovatelnou (například „nastavit stav na zaplaceno“ místo „přidat platbu“).

Prostředky a cena

SlužbaZačíná sNejméně paměti
NATS256 MB paměti · 1 jádro CPU · 5 GB disku256 MB
RabbitMQ1 GB paměti · 1 jádro CPU · 10 GB disku512 MB

Cena každé z nich se počítá podle paměti, CPU a disku jako u jakékoli služby — viz Služby projektu. Prostředky můžete později změnit v Nastavení služby.

Zálohy a obnova

NATS a RabbitMQ se zálohují každý den; uchováváme posledních 7 dní a 4 týdny, stejně jako u ostatních služeb.

  • Záloha kopíruje datové soubory služby za jejího běhu. U RabbitMQ obsahuje stejná záloha i export definic: uživatelů, virtuálních hostitelů, front, exchange, vazeb a politik.
  • Obnova k přesnému okamžiku není k dispozici — ta je jen pro PostgreSQL a MySQL. Obnovujete jednu z denních kopií.
  • Obnova službu na krátkou dobu zastaví, vrátí soubory a znovu ji spustí. Zprávy, které přišly nebo byly potvrzeny kolem doby zálohy, mohou chybět nebo být doručeny znovu — další důvod psát konzumenty tak, aby opakování nevadilo.
  • Pokud u RabbitMQ zkopírované soubory nejde spustit, služba naběhne jen s definicemi: fronty, exchange a uživatelé jsou na místě, ale zprávy ze zálohy jsou ztracené.

Údržba a přesuny

NATS a RabbitMQ nemají nastavitelný čas údržby. Na jiný server se automaticky nepřesouvají; pokud by to někdy bylo potřeba, podpora to s vámi domluví.

Pořád si nevíte rady?

Napište nám do chatu — AI odpoví hned a technik se připojí, když je potřeba, v kteroukoli denní dobu.

Kontaktovat podporu