Jetzt starten

Events und Queues: Valkey, NATS und RabbitMQ.

Hintergrundjobs, Events und Nachrichten zwischen den Diensten einer Anwendung: wann Valkey, NATS oder RabbitMQ passt, die Verbindungsvariablen, Beispiele für Laravel, Node.js und Python, Ressourcen, Backups und Grenzen.

10 MIN. LESEZEIT

Wenn eine Website Arbeit an einen Worker übergibt – eine E-Mail senden, ein Bild verkleinern, eine Bestellung abrechnen – oder ein Dienst den anderen mitteilt, dass etwas passiert ist, läuft die Nachricht über eine Queue oder einen Message Broker. Ein Projekt kann drei davon haben, jeweils als Dienst hinzugefügt: Übersicht → Dienste → Dienst hinzufügen.

DienstWählen Sie ihn für
Valkeyeinfache Job-Queues (Laravel-Queues und Horizon, BullMQ, Celery, RQ) und Events in Streams – wenn Sie ihn ohnehin für Cache und Sessions nutzen
NATSschlanken Nachrichtenaustausch zwischen Diensten: Events, Request/Reply und dauerhafte Streams mit JetStream
RabbitMQeinen klassischen Message Broker: Routing über Exchanges, Bestätigungen, Wiederholungen und Dead-Lettering, Quorum-Queues

Wenn Sie unsicher sind, beginnen Sie bei Hintergrundjobs mit Valkey: Die meisten Frameworks unterstützen es direkt. Wählen Sie RabbitMQ, wenn Nachrichten zwischen vielen Queues verteilt werden müssen und keine verloren gehen darf, und NATS, wenn Dienste viele kleine Nachrichten austauschen oder einander nach Antworten fragen.

Valkey: Job-Queues und Streams

Valkey ist ein Redis-kompatibler Speicher – derselbe verwaltete Dienst wie unter Datenbanken. Das erste Valkey der Anwendung gibt jedem Code-Dienst REDIS_URL, REDIS_HOST, REDIS_PORT und REDIS_PASSWORD; jedes Valkey liefert außerdem seine eigene RIVERVO_<NAME>_URL.

Drei Wege, Nachrichten darüber zu senden:

  • Job-Queues – Laravel-Queues mit dem Treiber redis und Horizon, BullMQ, Celery, RQ. Die Bibliothek legt die Jobs in Valkey ab; ein Worker nimmt sie nacheinander auf und wiederholt fehlgeschlagene.
  • Streams mit Consumer Groups – XADD hängt ein Event an einen Stream an, die Consumer einer Gruppe lesen es mit XREADGROUP und bestätigen es mit XACK. Events werden gespeichert: Ein angehaltener Consumer macht dort weiter, wo er aufgehört hat, ein nicht bestätigtes Event kann erneut abgeholt werden, und eine neue Gruppe kann den Stream von Anfang an lesen.
  • Pub/Sub – PUBLISH und SUBSCRIBE stellen eine Nachricht nur den Abonnenten zu, die in diesem Moment verbunden sind. Die Nachricht wird nicht gespeichert: Ein Abonnent, der gerade neu startet oder noch nicht verbunden ist, verpasst sie. Nutzen Sie Pub/Sub nur dort, wo eine verlorene Nachricht keinen Schaden anrichtet (etwa ein „Neu laden“-Signal), und für alles andere Streams oder eine Queue.

Valkey wird wie die anderen Datenbanken täglich gesichert; wenn Sie den Zugriff öffnen, ist es auch von außen erreichbar. Siehe Datenbanken.

NATS

NATS ist ein schlankes, schnelles Messaging-System, bei uns mit eingeschaltetem JetStream:

  • Publish/Subscribe – ein Dienst veröffentlicht auf ein Subject wie orders.created, jeder Abonnent des Subjects erhält die Nachricht. Ohne JetStream ist das „Fire and Forget“, wie Pub/Sub oben.
  • Request/Reply – ein Dienst fragt, ein anderer antwortet. Antworten mehrere Instanzen als Queue Group, verteilt NATS die Anfragen auf sie.
  • JetStream – dauerhafte Streams: Nachrichten werden auf der Festplatte des Dienstes gespeichert, ein Consumer merkt sich, was er gelesen hat, und jede Nachricht wird mindestens einmal zugestellt, bis sie bestätigt ist.
  • Key-Value- und Object-Store auf Basis von JetStream – für kleine gemeinsame Einstellungen, Sperren oder Dateien zwischen Diensten.

Variablen. Das erste NATS der Anwendung gibt jedem Code-Dienst:

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

Jeder NATS-Dienst liefert außerdem RIVERVO_<NAME>_URL mit einer Adresse derselben Form – NAME ist der Name des Dienstes in Großbuchstaben, Bindestriche werden zu _: Ein Dienst namens events liefert RIVERVO_EVENTS_URL.

JetStream legt seine Streams auf der Festplatte des Dienstes ab; im Arbeitsspeicher gehaltene Streams dürfen etwa ein Viertel des Arbeitsspeichers des Dienstes belegen.

RabbitMQ

RabbitMQ 4.1 ist ein klassischer Message Broker: Producer veröffentlichen an Exchanges, Exchanges leiten die Nachrichten anhand von Routing Keys an Queues weiter, Consumer bestätigen jede Nachricht, und eine abgelehnte oder abgelaufene Nachricht kann an einen Dead-Letter-Exchange gehen. Für Queues, deren Nachrichten einen Neustart überstehen müssen, verwenden Sie Quorum-Queues (das Argument x-queue-type: quorum) und veröffentlichen Nachrichten als persistent.

Variablen. Das erste RabbitMQ der Anwendung gibt jedem Code-Dienst:

VariableWert
AMQP_URLamqp://<user>:<password>@<service name>:5672/%2f
RABBITMQ_HOSTder Name des Dienstes
RABBITMQ_PORT5672
RABBITMQ_USER, RABBITMQ_PASSWORDBenutzer und Passwort
RABBITMQ_VHOST/

%2f am Ende von AMQP_URL ist der Standard-Virtual-Host /, so geschrieben, wie Verbindungsadressen es verlangen. Jeder RabbitMQ-Dienst liefert außerdem seine eigene RIVERVO_<NAME>_URL mit einer Adresse derselben Form.

Management-API. Die HTTP-Management-API lauscht auf Port 15672 im privaten Netzwerk der Anwendung: Die Dienste der Anwendung erreichen sie unter http://<service name>:15672 mit demselben Benutzer und Passwort, zum Beispiel:

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

Eine Management-Oberfläche im Internet gibt es nicht. Die Seite des Dienstes im Panel zeigt eine kurze, schreibgeschützte Liste seiner Queues: bereite und unbestätigte Nachrichten sowie Consumer.

Nur intern

NATS und RabbitMQ haben keine öffentliche Adresse und sind von außerhalb der Anwendung nicht erreichbar – weder von Ihrem Computer noch von einem anderen Server oder einer anderen Anwendung. Anders als bei PostgreSQL, MySQL und Valkey gibt es für sie keinen Zugriff von außen. Die Dienste, die Nachrichten veröffentlichen und verarbeiten, laufen als Dienste derselben Anwendung: Webdienste, Hintergrund-Worker und geplante Jobs.

Ein zweiter Dienst derselben Art

Nur das erste Valkey, NATS und RabbitMQ der Anwendung erhalten die üblichen Namen (REDIS_*, NATS_URL, AMQP_URL und RABBITMQ_*). Jeder weitere Dienst derselben Art fügt nur seine eigene RIVERVO_<NAME>_URL hinzu; lesen Sie diese Variable in Ihrem Code oder setzen Sie die üblichen Namen im Tab Variablen auf ihre Werte. Variablen erreichen einen Dienst mit seinem nächsten Deployment – siehe Umgebungsvariablen.

Laravel

Valkey. Setzen Sie im Tab Variablen:

QUEUE_CONNECTION=redis

Führen Sie php artisan queue:work – oder mit Horizon php artisan horizon – als Hintergrund-Worker aus. Siehe Laravel.

RabbitMQ. Laravel bringt keinen RabbitMQ-Treiber mit, und Rivervo ändert QUEUE_CONNECTION nicht von selbst. So nutzen Sie RabbitMQ für Laravel-Queues:

  1. Installieren Sie das Paket: composer require vladimir-yuldashev/laravel-queue-rabbitmq.
  2. Fügen Sie die Verbindung rabbitmq in config/queue.php so hinzu, wie es die README des Pakets für Ihre Version zeigt. Sie liest RABBITMQ_HOST, RABBITMQ_PORT, RABBITMQ_USER, RABBITMQ_PASSWORD und RABBITMQ_VHOST, die die Anwendung bereits hat:
'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. Setzen Sie QUEUE_CONNECTION=rabbitmq im Tab Variablen und deployen Sie. Der Worker bleibt php artisan queue:work.

NATS. Einen offiziellen Laravel-Queue-Treiber für NATS gibt es nicht. Verwenden Sie in Ihrem eigenen Code einen NATS-Client für PHP – zum Beispiel basis-company/nats – und übergeben Sie ihm Host, Port, Benutzer und Passwort aus NATS_URL. Prüfen Sie, ob der Client die benötigten Funktionen (JetStream, Key-Value) unterstützt, bevor Sie darauf aufbauen.

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 benötigt maxRetriesPerRequest: null an der Verbindung, die seine Worker nutzen.

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

Ein gelesener, aber nicht bestätigter Eintrag bleibt in der Gruppe ausstehend; XAUTOCLAIM übergibt ihn an einen anderen Consumer.

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

Request/Reply: Ein Dienst antwortet mit nc.subscribe('prices.get', { queue: 'prices', callback: (err, msg) => msg.respond(jc.encode(price)) }), ein anderer fragt mit 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
  }
})

Jeder Dienst, der die Queue deklariert, muss sie mit denselben Argumenten deklarieren.

Python

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

Führen Sie celery -A tasks worker --loglevel=info als Hintergrund-Worker aus. Celery akzeptiert amqp://-Adressen unverändert. Mit RabbitMQ können neuere Celery-Versionen Quorum-Queues deklarieren (task_default_queue_type = "quorum") – siehe die Celery-Dokumentation für Ihre Version.

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)

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

Mehrfach zugestellt

Queues und Broker stellen eine Nachricht erneut zu, wenn ein Worker anhält, bevor er sie bestätigt hat – bei einem Deployment, einem Neustart oder einer Wiederherstellung. Schreiben Sie Consumer so, dass die doppelte Verarbeitung derselben Nachricht keinen Schaden anrichtet: Speichern Sie die ID jeder verarbeiteten Nachricht, oder machen Sie die Aktion selbst wiederholbar (zum Beispiel „Status auf bezahlt setzen“ statt „Zahlung hinzufügen“).

Ressourcen und Preis

DienstStartet mitMindestens Arbeitsspeicher
NATS256 MB Arbeitsspeicher · 1 CPU-Kern · 5 GB Festplatte256 MB
RabbitMQ1 GB Arbeitsspeicher · 1 CPU-Kern · 10 GB Festplatte512 MB

Jeder wird wie jeder Dienst nach Arbeitsspeicher, CPU und Festplatte berechnet – siehe Dienste eines Projekts. Die Ressourcen lassen sich später in den Einstellungen des Dienstes ändern.

Backups und Wiederherstellung

NATS und RabbitMQ werden täglich gesichert; wie bei den anderen Diensten bewahren wir die letzten 7 Tage und 4 Wochen auf.

  • Das Backup kopiert die Datendateien des Dienstes im laufenden Betrieb. Bei RabbitMQ enthält dasselbe Backup zusätzlich einen Export seiner Definitionen: Benutzer, virtuelle Hosts, Queues, Exchanges, Bindings und Policies.
  • Eine Wiederherstellung auf einen exakten Zeitpunkt gibt es nicht – die bieten wir nur für PostgreSQL und MySQL. Sie stellen eine der täglichen Kopien wieder her.
  • Eine Wiederherstellung hält den Dienst kurz an, spielt die Dateien zurück und startet ihn wieder. Nachrichten, die um den Zeitpunkt des Backups herum eingetroffen sind oder bestätigt wurden, können fehlen oder erneut zugestellt werden – ein weiterer Grund, Consumer wiederholsicher zu schreiben.
  • Lassen sich bei RabbitMQ die kopierten Dateien nicht starten, startet der Dienst nur mit den Definitionen: Queues, Exchanges und Benutzer sind vorhanden, die Nachrichten aus dem Backup gehen jedoch verloren.

Wartung und Umzüge

Für NATS und RabbitMQ lässt sich kein Wartungszeitfenster festlegen. Sie werden nicht automatisch auf einen anderen Server verschoben; sollte das einmal nötig sein, stimmt der Support es mit Ihnen ab.

Noch Fragen?

Schreiben Sie uns im Chat – die AI antwortet sofort, und bei Bedarf kommt ein Techniker dazu, zu jeder Tageszeit.

Support kontaktieren