Zacznij

Zdarzenia i kolejki: Valkey, NATS i RabbitMQ.

Zadania w tle, zdarzenia i wiadomości między usługami aplikacji: kiedy wybrać Valkey, NATS, a kiedy RabbitMQ, zmienne połączenia, przykłady dla Laravela, Node.js i Pythona, zasoby, kopie zapasowe i limity.

9 MIN CZYTANIA

Gdy strona przekazuje pracę workerowi — wysłanie e-maila, zmianę rozmiaru obrazka, obciążenie zamówienia — albo jedna usługa informuje pozostałe, że coś się wydarzyło, wiadomość przechodzi przez kolejkę lub brokera wiadomości. Projekt może mieć trzy takie usługi, każdą dodawaną jak zwykłą usługę: Przegląd → Usługi → Dodaj usługę.

UsługaWybierz ją do
Valkeyprostych kolejek zadań (kolejki Laravela i Horizon, BullMQ, Celery, RQ) i zdarzeń w Streams — gdy i tak używasz jej do cache i sesji
NATSlekkiej wymiany wiadomości między usługami: zdarzenia, zapytanie i odpowiedź oraz trwałe strumienie z JetStream
RabbitMQklasycznego brokera wiadomości: routing przez exchange'e, potwierdzenia, ponowienia i dead-lettering, kolejki quorum

Jeśli nie masz pewności, zacznij od Valkey do zadań w tle: większość frameworków obsługuje ją od razu. Wybierz RabbitMQ, gdy wiadomości trzeba rozsyłać między wieloma kolejkami i żadna nie może zginąć, a NATS, gdy usługi wymieniają wiele małych wiadomości albo odpytują się nawzajem.

Valkey: kolejki zadań i Streams

Valkey to magazyn zgodny z Redis — ta sama zarządzana usługa co w Bazach danych. Pierwsza Valkey w aplikacji daje każdej usłudze z kodem zmienne REDIS_URL, REDIS_HOST, REDIS_PORT i REDIS_PASSWORD; każda Valkey daje też własną RIVERVO_<NAME>_URL.

Trzy sposoby przesyłania przez nią wiadomości:

  • Kolejki zadań — kolejki Laravela ze sterownikiem redis i Horizon, BullMQ, Celery, RQ. Biblioteka trzyma zadania w Valkey; worker pobiera je po kolei i ponawia te, które się nie powiodły.
  • Streams z grupami konsumentów — XADD dopisuje zdarzenie do strumienia, konsumenci z grupy czytają je przez XREADGROUP i potwierdzają przez XACK. Zdarzenia są przechowywane: konsument, który był zatrzymany, wznawia od miejsca, w którym skończył, niepotwierdzone zdarzenie można pobrać ponownie, a nowa grupa może czytać strumień od początku.
  • Pub/Sub — PUBLISH i SUBSCRIBE dostarczają wiadomość tylko subskrybentom połączonym w danej chwili. Wiadomość nie jest przechowywana: subskrybent, który się restartuje albo jeszcze się nie połączył, ją traci. Używaj Pub/Sub tylko tam, gdzie utrata wiadomości niczego nie psuje (na przykład sygnał „odśwież”), a do wszystkiego innego Streams albo kolejki.

Valkey ma codzienną kopię zapasową jak pozostałe bazy danych; można się z nią też łączyć z zewnątrz, gdy otworzysz dostęp. Zobacz Bazy danych.

NATS

NATS to lekki, szybki system wymiany wiadomości z włączonym JetStream:

  • Publikowanie i subskrypcja — usługa publikuje do tematu, np. orders.created, a każdy subskrybent tematu dostaje wiadomość. Bez JetStream działa to na zasadzie „wyślij i zapomnij”, jak Pub/Sub powyżej.
  • Zapytanie i odpowiedź — jedna usługa pyta, druga odpowiada. Gdy kilka instancji odpowiada jako grupa kolejkowa, NATS rozkłada zapytania między nie.
  • JetStream — trwałe strumienie: wiadomości są zapisywane na dysku usługi, konsument pamięta, co już przeczytał, a każda wiadomość jest dostarczana co najmniej raz, dopóki nie zostanie potwierdzona.
  • Magazyn klucz-wartość i magazyn obiektów oparte na JetStream — do drobnych wspólnych ustawień, blokad albo plików między usługami.

Zmienne. Pierwszy NATS w aplikacji daje każdej usłudze z kodem:

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

Każda usługa NATS daje też RIVERVO_<NAME>_URL z adresem w tej samej postaci — NAME to nazwa usługi wielkimi literami, z myślnikami zamienionymi na _: usługa o nazwie events daje RIVERVO_EVENTS_URL.

JetStream trzyma strumienie na dysku usługi; strumienie przechowywane w pamięci mogą zająć mniej więcej jedną czwartą pamięci usługi.

RabbitMQ

RabbitMQ 4.1 to klasyczny broker wiadomości: producenci publikują do exchange'y, exchange'e kierują wiadomości do kolejek według kluczy routingu, konsumenci potwierdzają każdą wiadomość, a wiadomość odrzucona lub przeterminowana może trafić do exchange'a dead-letter. Dla kolejek, których wiadomości muszą przetrwać restart, używaj kolejek quorum (argument x-queue-type: quorum) i publikuj wiadomości jako trwałe.

Zmienne. Pierwszy RabbitMQ w aplikacji daje każdej usłudze z kodem:

ZmiennaWartość
AMQP_URLamqp://<user>:<password>@<service name>:5672/%2f
RABBITMQ_HOSTnazwa usługi
RABBITMQ_PORT5672
RABBITMQ_USER, RABBITMQ_PASSWORDużytkownik i hasło
RABBITMQ_VHOST/

%2f na końcu AMQP_URL to domyślny host wirtualny /, zapisany tak, jak wymagają tego adresy połączeń. Każda usługa RabbitMQ daje też własną RIVERVO_<NAME>_URL z adresem w tej samej postaci.

API zarządzania. HTTP API do zarządzania nasłuchuje na porcie 15672 w prywatnej sieci aplikacji: usługi aplikacji łączą się z nim pod adresem http://<service name>:15672 tym samym użytkownikiem i hasłem, na przykład:

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

Strony zarządzania nie ma w internecie. Strona usługi w panelu pokazuje krótką listę jej kolejek, tylko do odczytu: wiadomości gotowe, niepotwierdzone i liczbę konsumentów.

Tylko wewnętrznie

NATS i RabbitMQ nie mają adresu publicznego i nie da się z nimi połączyć spoza aplikacji — z twojego komputera, innego serwera ani innej aplikacji. W przeciwieństwie do PostgreSQL, MySQL i Valkey dostęp z zewnątrz nie jest dla nich dostępny. Usługi, które publikują i odbierają wiadomości, działają jako usługi tej samej aplikacji: usługi webowe, workery w tle i zadania harmonogramu.

Druga usługa tego samego rodzaju

Zwykłe nazwy (REDIS_*, NATS_URL, AMQP_URL i RABBITMQ_*) dostają tylko pierwsza Valkey, pierwszy NATS i pierwszy RabbitMQ w aplikacji. Kolejna usługa tego samego rodzaju dodaje tylko własną RIVERVO_<NAME>_URL; odczytuj tę zmienną w kodzie albo ustaw zwykłe nazwy na jej wartości na karcie Zmienne. Zmienne docierają do usługi przy jej najbliższym wdrożeniu — zobacz Zmienne środowiskowe.

Laravel

Valkey. Ustaw na karcie Zmienne:

QUEUE_CONNECTION=redis

Uruchom php artisan queue:work — albo php artisan horizon, jeśli używasz Horizona — jako worker w tle. Zobacz Laravel.

RabbitMQ. Laravel nie ma wbudowanego sterownika RabbitMQ, a Rivervo nie zmienia samo QUEUE_CONNECTION. Żeby używać RabbitMQ do kolejek Laravela:

  1. Zainstaluj pakiet: composer require vladimir-yuldashev/laravel-queue-rabbitmq.
  2. Dodaj połączenie rabbitmq do config/queue.php tak, jak pokazuje README pakietu dla twojej wersji. Odczytuje ono RABBITMQ_HOST, RABBITMQ_PORT, RABBITMQ_USER, RABBITMQ_PASSWORD i RABBITMQ_VHOST, które aplikacja już ma:
'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. Ustaw QUEUE_CONNECTION=rabbitmq na karcie Zmienne i wdróż. Worker pozostaje bez zmian: php artisan queue:work.

NATS. Nie ma oficjalnego sterownika kolejek Laravela dla NATS. Użyj we własnym kodzie klienta NATS dla PHP — na przykład basis-company/nats — i przekaż mu host, port, użytkownika i hasło z NATS_URL. Zanim na nim zbudujesz, sprawdź, czy klient obsługuje potrzebne funkcje (JetStream, klucz-wartość).

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 wymaga maxRetriesPerRequest: null w połączeniu, którego używają jego 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)
    }
  }
}

Wpis odczytany, ale niepotwierdzony, pozostaje w grupie jako oczekujący; XAUTOCLAIM przekazuje go innemu konsumentowi.

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

Zapytanie i odpowiedź: jedna usługa odpowiada przez nc.subscribe('prices.get', { queue: 'prices', callback: (err, msg) => msg.respond(jc.encode(price)) }), druga pyta przez 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żda usługa, która deklaruje kolejkę, musi ją deklarować z tymi samymi argumentami.

Python

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

Uruchom celery -A tasks worker --loglevel=info jako worker w tle. Celery przyjmuje adresy amqp:// bez zmian. Z RabbitMQ nowsze wersje Celery potrafią deklarować kolejki quorum (task_default_queue_type = "quorum") — zajrzyj do dokumentacji Celery dla swojej wersji.

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

Wiadomość dostarczona więcej niż raz

Kolejki i brokery dostarczają wiadomość ponownie, gdy worker zatrzyma się, zanim ją potwierdzi — podczas wdrożenia, restartu albo przywracania. Pisz konsumentów tak, żeby dwukrotne obsłużenie tej samej wiadomości niczego nie psuło: zapisuj ID każdej przetworzonej wiadomości albo spraw, żeby sama operacja dała się powtarzać (na przykład „ustaw status na opłacony” zamiast „dodaj płatność”).

Zasoby i cena

UsługaNa startNajmniej pamięci
NATS256 MB pamięci · 1 rdzeń CPU · 5 GB dysku256 MB
RabbitMQ1 GB pamięci · 1 rdzeń CPU · 10 GB dysku512 MB

Każda ma cenę według pamięci, CPU i dysku jak każda usługa — zobacz Usługi projektu. Zasoby możesz później zmienić w Ustawieniach usługi.

Kopie zapasowe i przywracanie

NATS i RabbitMQ mają kopię zapasową codziennie; przechowujemy ostatnie 7 dni i 4 tygodnie, jak w przypadku innych usług.

  • Kopia obejmuje pliki danych usługi i powstaje w trakcie jej działania. Dla RabbitMQ ta sama kopia zawiera też eksport definicji: użytkowników, hostów wirtualnych, kolejek, exchange'y, powiązań i polityk.
  • Nie ma przywracania do dokładnego momentu — to tylko dla PostgreSQL i MySQL. Przywracasz jedną z kopii dziennych.
  • Przywracanie na chwilę zatrzymuje usługę, odtwarza pliki i uruchamia ją ponownie. Wiadomości, które przyszły lub zostały potwierdzone mniej więcej w chwili tworzenia kopii, mogą zniknąć albo zostać dostarczone ponownie — to kolejny powód, by konsumenci bezpiecznie znosili powtórzenia.
  • Jeśli w RabbitMQ skopiowanych plików nie da się uruchomić, usługa startuje tylko z definicjami: kolejki, exchange'e i użytkownicy są na miejscu, ale wiadomości z kopii przepadają.

Konserwacja i przenosiny

NATS i RabbitMQ nie mają okna serwisowego do ustawienia. Nie są automatycznie przenoszone na inny serwer; jeśli kiedyś będzie to potrzebne, wsparcie uzgodni to z tobą.

Nadal masz pytania?

Napisz do nas na czacie — AI odpowiada od razu, a inżynier dołącza, gdy trzeba, o każdej porze.

Kontakt z pomocą techniczną