Hændelser og køer: Valkey, NATS og RabbitMQ.
Baggrundsjob, hændelser og beskeder mellem en applikations tjenester: hvornår du vælger Valkey, NATS eller RabbitMQ, forbindelsesvariablerne, eksempler til Laravel, Node.js og Python, ressourcer, backups og grænser.
Når en side giver en opgave videre til en worker — sende en e-mail, skalere et billede, trække betaling for en ordre — eller når én tjeneste fortæller de andre, at noget er sket, går beskeden gennem en kø eller en message broker. Et projekt kan have tre af dem, som hver tilføjes som en tjeneste: Oversigt → Tjenester → Tilføj en tjeneste.
| Tjeneste | Vælg den til |
|---|---|
| Valkey | simple jobkøer (Laravel-køer og Horizon, BullMQ, Celery, RQ) og hændelser i Streams — når du allerede bruger den til cache og sessioner |
| NATS | let beskedudveksling mellem tjenester: hændelser, forespørgsel og svar samt holdbare streams med JetStream |
| RabbitMQ | en klassisk message broker: routing via exchanges, kvitteringer, genforsøg og dead-lettering, quorum-køer |
Er du i tvivl, så start med Valkey til baggrundsjob: de fleste frameworks understøtter den direkte. Vælg RabbitMQ, når beskeder skal routes mellem mange køer, og ingen må gå tabt, og NATS, når tjenester udveksler mange små beskeder eller beder hinanden om svar.
Valkey: jobkøer og Streams
Valkey er et Redis-kompatibelt lager — den samme administrerede tjeneste som under Databaser. Applikationens første Valkey giver alle kodetjenester REDIS_URL, REDIS_HOST, REDIS_PORT og REDIS_PASSWORD; hver Valkey giver også sin egen RIVERVO_<NAME>_URL.
Tre måder at sende beskeder gennem den på:
- Jobkøer — Laravel-køer med driveren
redisog Horizon, BullMQ, Celery, RQ. Biblioteket gemmer jobbene i Valkey; en worker tager dem ét ad gangen og prøver igen med dem, der fejler. - Streams med consumer groups —
XADDtilføjer en hændelse til en stream, en gruppes consumers læser den medXREADGROUPog bekræfter den medXACK. Hændelser gemmes: en consumer, der var stoppet, fortsætter, hvor den slap, en hændelse, der ikke blev bekræftet, kan tages igen, og en ny gruppe kan læse streamen fra begyndelsen. - Pub/Sub —
PUBLISHogSUBSCRIBEleverer kun en besked til de abonnenter, der er forbundet i det øjeblik. Beskeden gemmes ikke: en abonnent, der genstarter eller endnu ikke er forbundet, går glip af den. Brug kun Pub/Sub, hvor en tabt besked ikke gør skade (f.eks. et «opdater»-signal), og Streams eller en kø til alt andet.
Der tages backup af Valkey hver dag ligesom de andre databaser; den kan også nås udefra, når du åbner adgang. Se Databaser.
NATS
NATS er et let og hurtigt beskedsystem med JetStream slået til:
- Publicér og abonnér — en tjeneste publicerer til et subject som
orders.created, og alle abonnenter på subjectet får beskeden. Uden JetStream er det fire-and-forget ligesom Pub/Sub ovenfor. - Forespørgsel og svar — én tjeneste spørger, en anden svarer. Når flere instanser svarer som en queue group, fordeler NATS forespørgslerne mellem dem.
- JetStream — holdbare streams: beskeder gemmes på tjenestens disk, en consumer husker, hvad den har læst, og hver besked leveres mindst én gang, indtil den er kvitteret.
- Key-value- og object store bygget på JetStream — til små delte indstillinger, låse eller filer mellem tjenester.
Variabler. Applikationens første NATS giver alle kodetjenester:
NATS_URL=nats://<bruger>:<adgangskode>@<tjenestenavn>:4222
Hver NATS-tjeneste giver også RIVERVO_<NAME>_URL med en adresse på samme form — NAME er tjenestens navn med store bogstaver, hvor bindestreger er erstattet af _: en tjeneste med navnet events giver RIVERVO_EVENTS_URL.
JetStream gemmer sine streams på tjenestens disk; streams, der holdes i hukommelsen, kan bruge omkring en fjerdedel af tjenestens hukommelse.
RabbitMQ
RabbitMQ 4.1 er en klassisk message broker: producenter publicerer til exchanges, exchanges router beskederne til køer efter routing keys, consumers kvitterer for hver besked, og en besked, der afvises eller udløber, kan sendes til en dead-letter-exchange. Til køer, hvis beskeder skal overleve en genstart, bruger du quorum-køer (argumentet x-queue-type: quorum) og publicerer beskederne som persistente.
Variabler. Applikationens første RabbitMQ giver alle kodetjenester:
| Variabel | Værdi |
|---|---|
AMQP_URL | amqp://<bruger>:<adgangskode>@<tjenestenavn>:5672/%2f |
RABBITMQ_HOST | tjenestens navn |
RABBITMQ_PORT | 5672 |
RABBITMQ_USER, RABBITMQ_PASSWORD | brugeren og adgangskoden |
RABBITMQ_VHOST | / |
%2f i slutningen af AMQP_URL er standard-virtual host /, skrevet sådan som forbindelsesadresser kræver det. Hver RabbitMQ-tjeneste giver også sin egen RIVERVO_<NAME>_URL med en adresse på samme form.
Management API. Management-HTTP-API'et lytter på port 15672 i applikationens private netværk: applikationens tjenester når det på http://<tjenestenavn>:15672 med samme bruger og adgangskode, for eksempel:
curl -u "$RABBITMQ_USER:$RABBITMQ_PASSWORD" "http://$RABBITMQ_HOST:15672/api/queues"Der er ingen management-side på internettet. Tjenestens side i panelet viser en kort liste over dens køer, kun til læsning: klare beskeder, ikke-kvitterede beskeder og consumers.
Kun intern
NATS og RabbitMQ har ingen offentlig adresse og kan ikke nås uden for applikationen — fra din computer, en anden server eller en anden applikation. I modsætning til PostgreSQL, MySQL og Valkey tilbydes der ikke adgang udefra til dem. De tjenester, der publicerer og modtager beskeder, kører som tjenester i samme applikation: webtjenester, baggrundsworkers og planlagte job.
En tjeneste mere af samme slags
Kun applikationens første Valkey, NATS og RabbitMQ får de sædvanlige navne (REDIS_*, NATS_URL, AMQP_URL og RABBITMQ_*). Den næste af samme slags tilføjer kun sin egen RIVERVO_<NAME>_URL; læs den variabel i din kode, eller sæt de sædvanlige navne til dens værdier under fanen Variabler. Variabler når en tjeneste ved dens næste deploy — se Miljøvariabler.
Laravel
Valkey. Angiv under fanen Variabler:
QUEUE_CONNECTION=redisKør php artisan queue:work — eller php artisan horizon med Horizon — som baggrundsworker. Se Laravel.
RabbitMQ. Laravel har ingen indbygget RabbitMQ-driver, og Rivervo ændrer ikke QUEUE_CONNECTION af sig selv. Sådan bruger du RabbitMQ til Laravel-køer:
- Installer pakken:
composer require vladimir-yuldashev/laravel-queue-rabbitmq. - Tilføj forbindelsen
rabbitmqiconfig/queue.php, sådan som pakkens README viser for din version. Den læserRABBITMQ_HOST,RABBITMQ_PORT,RABBITMQ_USER,RABBITMQ_PASSWORDogRABBITMQ_VHOST, som applikationen allerede har:
'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', '/'),
],
],
],- Sæt
QUEUE_CONNECTION=rabbitmqunder fanen Variabler, og deploy. Workeren er fortsatphp artisan queue:work.
NATS. Der findes ingen officiel Laravel-kødriver til NATS. Brug en NATS-klient til PHP i din egen kode — f.eks. basis-company/nats — og giv den vært, port, bruger og adgangskode fra NATS_URL. Tjek, at klienten understøtter de funktioner, du har brug for (JetStream, key-value), før du bygger videre på den.
Node.js
BullMQ (Valkey)
import { Queue, Worker } from 'bullmq'
import IORedis from 'ioredis'
const connection = new IORedis(process.env.REDIS_URL, { maxRetriesPerRequest: null })
// i webtjenesten
const emails = new Queue('emails', { connection })
await emails.add('welcome', { userId: 42 }, { attempts: 3 })
// i baggrundsworkeren
new Worker('emails', async (job) => {
await sendWelcome(job.data.userId)
}, { connection })BullMQ kræver maxRetriesPerRequest: null på den forbindelse, dens workers bruger.
Valkey Streams
import IORedis from 'ioredis'
const redis = new IORedis(process.env.REDIS_URL)
// producent
await redis.xadd('orders', '*', 'id', '42')
// consumer i gruppen «billing»
await redis.xgroup('CREATE', 'orders', 'billing', '0', 'MKSTREAM').catch((err) => {
if (!String(err).includes('BUSYGROUP')) throw err // gruppen findes allerede
})
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)
}
}
}En post, der er læst, men ikke kvitteret, forbliver ventende i gruppen; XAUTOCLAIM giver den videre til en anden consumer.
NATS (nats.js)
import { connect, JSONCodec, AckPolicy } from 'nats'
const nc = await connect({ servers: process.env.NATS_URL })
const jc = JSONCodec()
// én gang: en stream til subjects orders.* og en holdbar 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 })
// producent
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()
}Forespørgsel og svar: én tjeneste svarer med nc.subscribe('prices.get', { queue: 'prices', callback: (err, msg) => msg.respond(jc.encode(price)) }), en anden spørger med 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 })
// consumer: højst 10 ikke-kvitterede beskeder ad gangen
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) // til dead-letter-exchangen, hvis køen har en
}
})Alle tjenester, der erklærer køen, skal erklære den med de samme argumenter.
Python
Celery (Valkey eller RabbitMQ)
import os
from celery import Celery
app = Celery("tasks", broker=os.environ["REDIS_URL"]) # eller os.environ["AMQP_URL"]
@app.task(acks_late=True)
def send_welcome(user_id):
...Kør celery -A tasks worker --loglevel=info som baggrundsworker. Celery accepterer amqp://-adresser, som de er. Med RabbitMQ kan nyere Celery-versioner erklære quorum-køer (task_default_queue_type = "quorum") — se Celerys dokumentation for din 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)Workeren: 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))
# 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()Leveret mere end én gang
Køer og brokers leverer en besked igen, når en worker stopper, før den har bekræftet den — under et deploy, en genstart eller en gendannelse. Skriv dine consumers, så det ikke gør skade at behandle den samme besked to gange: gem id'et for hver behandlet besked, eller gør selve handlingen gentagelig (f.eks. «sæt status til betalt» i stedet for «tilføj en betaling»).
Ressourcer og pris
| Tjeneste | Starter med | Mindste hukommelse |
|---|---|---|
| NATS | 256 MB hukommelse · 1 CPU-kerne · 5 GB disk | 256 MB |
| RabbitMQ | 1 GB hukommelse · 1 CPU-kerne · 10 GB disk | 512 MB |
Hver prissættes efter hukommelse, CPU og disk som enhver anden tjeneste — se Et projekts tjenester. Ressourcerne kan ændres senere under tjenestens Indstillinger.
Backups og gendannelse
Der tages backup af NATS og RabbitMQ hver dag; vi gemmer de sidste 7 dage og 4 uger ligesom for de andre tjenester.
- Backuppen kopierer tjenestens datafiler, mens den kører. For RabbitMQ indeholder den samme backup også en eksport af dens definitioner: brugere, virtual hosts, køer, exchanges, bindings og politikker.
- Der er ingen gendannelse til et præcist tidspunkt — det findes kun for PostgreSQL og MySQL. Du gendanner en af de daglige kopier.
- En gendannelse stopper tjenesten i kort tid, lægger filerne tilbage og starter den igen. Beskeder, der kom ind eller blev kvitteret omkring tidspunktet for backuppen, kan mangle eller blive leveret igen — endnu en grund til at gøre dine consumers sikre at gentage.
- For RabbitMQ gælder, at hvis de kopierede filer ikke kan startes, starter tjenesten kun med definitionerne: køerne, exchanges og brugerne er der, men beskederne fra backuppen er tabt.
Vedligeholdelse og flytning
NATS og RabbitMQ har ikke noget vedligeholdelsestidspunkt, du skal angive. De flyttes ikke automatisk til en anden server; hvis det nogensinde bliver nødvendigt, aftaler supporten det med dig.