Händelser och köer: Valkey, NATS och RabbitMQ.
Bakgrundsjobb, händelser och meddelanden mellan en applikations tjänster: när du ska välja Valkey, NATS eller RabbitMQ, anslutningsvariablerna, exempel för Laravel, Node.js och Python, resurser, backup och gränser.
När en webbplats lämnar över arbete till en worker – skicka ett mejl, ändra storlek på en bild, debitera en order – eller när en tjänst berättar för de andra att något har hänt, går meddelandet via en kö eller en meddelandemäklare. Ett projekt kan ha tre sådana, var och en tillagd som en tjänst: Översikt → Tjänster → Lägg till en tjänst.
| Tjänst | Välj den för |
|---|---|
| Valkey | enkla jobbköer (Laravel-köer och Horizon, BullMQ, Celery, RQ) och händelser i Streams – när du redan använder den för cache och sessioner |
| NATS | lättviktiga meddelanden mellan tjänster: händelser, förfrågan och svar samt beständiga strömmar med JetStream |
| RabbitMQ | en klassisk meddelandemäklare: routning via exchanges, kvitteringar, nya försök och dead-lettering, quorum-köer |
Om du är osäker, börja med Valkey för bakgrundsjobb: de flesta ramverk stöder den direkt. Välj RabbitMQ när meddelanden ska routas mellan många köer och inget får gå förlorat, och NATS när tjänster utbyter många små meddelanden eller ber varandra om svar.
Valkey: jobbköer och Streams
Valkey är en Redis-kompatibel lagring – samma hanterade tjänst som i Databaser. Applikationens första Valkey ger varje kodtjänst REDIS_URL, REDIS_HOST, REDIS_PORT och REDIS_PASSWORD. Varje Valkey ger också sin egen RIVERVO_<NAME>_URL.
Tre sätt att skicka meddelanden via den:
- Jobbköer – Laravel-köer med drivrutinen
redisoch Horizon, BullMQ, Celery, RQ. Biblioteket sparar jobben i Valkey. En worker tar dem ett i taget och försöker igen med dem som misslyckas. - Streams med konsumentgrupper –
XADDlägger till en händelse i en ström, konsumenter i en grupp läser den medXREADGROUPoch bekräftar den medXACK. Händelserna sparas: en konsument som har stoppats fortsätter där den slutade, en händelse som inte har bekräftats kan tas igen, och en ny grupp kan läsa strömmen från början. - Pub/Sub –
PUBLISHochSUBSCRIBElevererar ett meddelande bara till de prenumeranter som är anslutna just då. Meddelandet sparas inte: en prenumerant som startar om eller inte har anslutit än missar det. Använd Pub/Sub bara där ett förlorat meddelande inte gör någon skada (till exempel en «uppdatera»-signal), och Streams eller en kö för allt annat.
Valkey säkerhetskopieras varje dag som de andra databaserna, och den kan också nås utifrån när du öppnar åtkomst. Se Databaser.
NATS
NATS är ett lättviktigt, snabbt meddelandesystem, med JetStream påslaget:
- Publicera och prenumerera – en tjänst publicerar till ett subject som
orders.created, och varje prenumerant på subjectet får meddelandet. Utan JetStream är det «skicka och glöm», som Pub/Sub ovan. - Förfrågan och svar – en tjänst frågar, en annan svarar. När flera instanser svarar som en kögrupp fördelar NATS förfrågningarna mellan dem.
- JetStream – beständiga strömmar: meddelanden sparas på tjänstens disk, en konsument kommer ihåg vad den har läst, och varje meddelande levereras minst en gång tills det har kvitterats.
- Nyckel-värde- och objektlagring byggd på JetStream – för små gemensamma inställningar, lås eller filer mellan tjänster.
Variabler. Applikationens första NATS ger varje kodtjänst:
NATS_URL=nats://<användare>:<lösenord>@<tjänstens namn>:4222
Varje NATS-tjänst ger också RIVERVO_<NAME>_URL med en adress av samma form – NAME är tjänstens namn med versaler, där bindestreck blir _: en tjänst som heter events ger RIVERVO_EVENTS_URL.
JetStream sparar sina strömmar på tjänstens disk. Strömmar som hålls i minnet får använda ungefär en fjärdedel av tjänstens minne.
RabbitMQ
RabbitMQ 4.1 är en klassisk meddelandemäklare: producenter publicerar till exchanges, exchanges routar meddelandena till köer utifrån routningsnycklar, konsumenter kvitterar varje meddelande, och ett meddelande som avvisas eller går ut kan skickas till en dead-letter-exchange. För köer vars meddelanden måste överleva en omstart, använd quorum-köer (argumentet x-queue-type: quorum) och publicera meddelanden som beständiga.
Variabler. Applikationens första RabbitMQ ger varje kodtjänst:
| Variabel | Värde |
|---|---|
AMQP_URL | amqp://<användare>:<lösenord>@<tjänstens namn>:5672/%2f |
RABBITMQ_HOST | tjänstens namn |
RABBITMQ_PORT | 5672 |
RABBITMQ_USER, RABBITMQ_PASSWORD | användaren och lösenordet |
RABBITMQ_VHOST | / |
%2f i slutet av AMQP_URL är standardvärden / för virtuell värd, skriven så som anslutningsadresser kräver. Varje RabbitMQ-tjänst ger också sin egen RIVERVO_<NAME>_URL med en adress av samma form.
Management-API. Management-API:et över HTTP lyssnar på port 15672 i applikationens privata nätverk: applikationens tjänster når det på http://<tjänstens namn>:15672 med samma användare och lösenord, till exempel:
curl -u "$RABBITMQ_USER:$RABBITMQ_PASSWORD" "http://$RABBITMQ_HOST:15672/api/queues"Det finns ingen management-sida på internet. Tjänstens sida i panelen visar en kort lista över dess köer, endast för läsning: meddelanden som är redo, okvitterade och konsumenter.
Endast intern
NATS och RabbitMQ har ingen publik adress och kan inte nås utanför applikationen – från din dator, en annan server eller en annan applikation. Till skillnad från PostgreSQL, MySQL och Valkey erbjuds ingen åtkomst utifrån för dem. Tjänsterna som publicerar och konsumerar meddelanden körs som tjänster i samma applikation: webbtjänster, bakgrunds-workers och schemalagda jobb.
En andra tjänst av samma sort
Bara applikationens första Valkey, NATS och RabbitMQ får de vanliga namnen (REDIS_*, NATS_URL, AMQP_URL och RABBITMQ_*). Nästa av samma sort lägger bara till sin egen RIVERVO_<NAME>_URL. Läs den variabeln i din kod, eller ange de vanliga namnen med dess värden under fliken Variabler. Variabler når en tjänst vid nästa driftsättning – se Miljövariabler.
Laravel
Valkey. Ange under fliken Variabler:
QUEUE_CONNECTION=redisKör php artisan queue:work – eller php artisan horizon med Horizon – som en bakgrunds-worker. Se Laravel.
RabbitMQ. Laravel har ingen inbyggd drivrutin för RabbitMQ, och Rivervo ändrar inte QUEUE_CONNECTION av sig själv. Så använder du RabbitMQ för Laravel-köer:
- Installera paketet:
composer require vladimir-yuldashev/laravel-queue-rabbitmq. - Lägg till anslutningen
rabbitmqiconfig/queue.phpså som paketets README visar för din version. Den läserRABBITMQ_HOST,RABBITMQ_PORT,RABBITMQ_USER,RABBITMQ_PASSWORDochRABBITMQ_VHOST, som applikationen redan 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', '/'),
],
],
],- Ange
QUEUE_CONNECTION=rabbitmqunder fliken Variabler och driftsätt. Workern är fortfarandephp artisan queue:work.
NATS. Det finns ingen officiell Laravel-ködrivrutin för NATS. Använd en NATS-klient för PHP i din egen kod – till exempel basis-company/nats – och ge den värd, port, användare och lösenord från NATS_URL. Kontrollera att klienten stöder de funktioner du behöver (JetStream, nyckel-värde) innan du bygger 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 webbtjänsten
const emails = new Queue('emails', { connection })
await emails.add('welcome', { userId: 42 }, { attempts: 3 })
// i bakgrunds-workern
new Worker('emails', async (job) => {
await sendWelcome(job.data.userId)
}, { connection })BullMQ kräver maxRetriesPerRequest: null på anslutningen som dess workers använder.
Valkey Streams
import IORedis from 'ioredis'
const redis = new IORedis(process.env.REDIS_URL)
// producent
await redis.xadd('orders', '*', 'id', '42')
// konsument i gruppen «billing»
await redis.xgroup('CREATE', 'orders', 'billing', '0', 'MKSTREAM').catch((err) => {
if (!String(err).includes('BUSYGROUP')) throw err // gruppen finns redan
})
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 som har lästs men inte kvitterats ligger kvar som väntande i gruppen. XAUTOCLAIM lämnar över den till en annan konsument.
NATS (nats.js)
import { connect, JSONCodec, AckPolicy } from 'nats'
const nc = await connect({ servers: process.env.NATS_URL })
const jc = JSONCodec()
// en gång: en ström för subjects orders.* och en beständig konsument
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 }))
// konsument
const consumer = await js.consumers.get('ORDERS', 'billing')
for await (const m of await consumer.consume()) {
await handleOrder(jc.decode(m.data))
m.ack()
}Förfrågan och svar: en tjänst svarar med nc.subscribe('prices.get', { queue: 'prices', callback: (err, msg) => msg.respond(jc.encode(price)) }), en annan frågar 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 })
// konsument: högst 10 okvitterade meddelanden åt gången
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) // till dead-letter-exchangen, om kön har en
}
})Varje tjänst som deklarerar kön måste deklarera den med samma argument.
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 en bakgrunds-worker. Celery tar emot amqp://-adresser som de är. Med RabbitMQ kan nyare Celery-versioner deklarera quorum-köer (task_default_queue_type = "quorum") – se Celerys dokumentation för 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)Workern: 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))
# konsument
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()Levererat mer än en gång
Köer och mäklare levererar ett meddelande igen när en worker stoppas innan den har bekräftat det – vid en driftsättning, en omstart eller en återställning. Skriv konsumenter så att det inte gör någon skada att hantera samma meddelande två gånger: spara ID:t för varje behandlat meddelande, eller gör själva åtgärden upprepningsbar (till exempel «sätt status till betald» i stället för «lägg till en betalning»).
Resurser och pris
| Tjänst | Startar med | Minsta minne |
|---|---|---|
| NATS | 256 MB minne · 1 CPU-kärna · 5 GB disk | 256 MB |
| RabbitMQ | 1 GB minne · 1 CPU-kärna · 10 GB disk | 512 MB |
Var och en prissätts efter minne, CPU och disk som vilken tjänst som helst – se Tjänster i ett projekt. Resurserna kan ändras senare under tjänstens Inställningar.
Backup och återställning
NATS och RabbitMQ säkerhetskopieras varje dag. Vi sparar de senaste 7 dagarna och 4 veckorna, som för de andra tjänsterna.
- Backupen kopierar tjänstens datafiler medan den körs. För RabbitMQ innehåller samma backup också en export av dess definitioner: användare, virtuella värdar, köer, exchanges, bindningar och policyer.
- Det finns ingen återställning till en exakt tidpunkt – det finns bara för PostgreSQL och MySQL. Du återställer en av de dagliga kopiorna.
- En återställning stoppar tjänsten en kort stund, lägger tillbaka filerna och startar den igen. Meddelanden som kom in eller kvitterades runt tiden för backupen kan saknas eller levereras igen – ännu ett skäl att göra konsumenterna säkra att upprepa.
- Om de kopierade filerna för RabbitMQ inte går att starta, startar tjänsten med enbart definitionerna: köerna, exchanges och användarna finns där, men meddelandena från backupen går förlorade.
Underhåll och flyttar
NATS och RabbitMQ har ingen underhållstid att ställa in. De flyttas inte automatiskt till en annan server. Om det någon gång behövs ordnar supporten det tillsammans med dig.