Tapahtumat ja jonot: Valkey, NATS ja RabbitMQ.
Taustatehtävät, tapahtumat ja viestit sovelluksen palvelujen välillä: milloin valita Valkey, NATS tai RabbitMQ, yhteysmuuttujat, esimerkit Laravelille, Node.js:lle ja Pythonille, resurssit, varmuuskopiot ja rajoitukset.
Kun sivusto antaa työn workerille — lähetä sähköposti, muuta kuvan kokoa, veloita tilaus — tai yksi palvelu kertoo muille, että jotain tapahtui, viesti kulkee jonon tai viestinvälittäjän kautta. Projektissa voi olla kolme sellaista, kukin lisättynä palveluna: Yleiskatsaus → Palvelut → Lisää palvelu.
| Palvelu | Valitse se, kun tarvitset |
|---|---|
| Valkey | yksinkertaiset tehtäväjonot (Laravelin jonot ja Horizon, BullMQ, Celery, RQ) ja tapahtumat Streamsissa — kun käytät sitä jo välimuistiin ja istuntoihin |
| NATS | kevyt viestintä palvelujen välillä: tapahtumat, pyyntö ja vastaus sekä pysyvät virrat JetStreamilla |
| RabbitMQ | perinteinen viestinvälittäjä: reititys exchangejen kautta, kuittaukset, uudelleenyritykset ja dead-lettering, quorum-jonot |
Jos et ole varma, aloita taustatehtävissä Valkeylla: useimmat sovelluskehykset tukevat sitä suoraan. Valitse RabbitMQ, kun viestejä on reititettävä monien jonojen välillä eikä yhtäkään saa kadota, ja NATS, kun palvelut vaihtavat paljon pieniä viestejä tai kysyvät toisiltaan vastauksia.
Valkey: tehtäväjonot ja Streams
Valkey on Redis-yhteensopiva tallennus — sama hallinnoitu palvelu kuin kohdassa Tietokannat. Sovelluksen ensimmäinen Valkey antaa jokaiselle koodipalvelulle muuttujat REDIS_URL, REDIS_HOST, REDIS_PORT ja REDIS_PASSWORD; jokainen Valkey antaa myös oman RIVERVO_<NAME>_URL-muuttujansa.
Kolme tapaa lähettää viestejä sen kautta:
- Tehtäväjonot — Laravelin jonot
redis-ajurilla ja Horizon, BullMQ, Celery, RQ. Kirjasto säilyttää tehtävät Valkeyssa; worker ottaa ne yksi kerrallaan ja yrittää epäonnistuneita uudelleen. - Streams kuluttajaryhmillä —
XADDlisää tapahtuman virtaan, ryhmän kuluttajat lukevat senXREADGROUP-komennolla ja vahvistavat senXACK-komennolla. Tapahtumat tallennetaan: pysäytetty kuluttaja jatkaa siitä, mihin jäi, vahvistamattoman tapahtuman voi ottaa uudelleen, ja uusi ryhmä voi lukea virran alusta. - Pub/Sub —
PUBLISHjaSUBSCRIBEtoimittavat viestin vain sillä hetkellä yhdistetyille tilaajille. Viestiä ei tallenneta: tilaaja, joka käynnistyy uudelleen tai ei ole vielä yhdistänyt, jää siitä paitsi. Käytä Pub/Subia vain, kun kadonnut viesti ei haittaa (esimerkiksi ”päivitä”-signaali), ja kaikkeen muuhun Streamsia tai jonoa.
Valkey varmuuskopioidaan joka päivä kuten muutkin tietokannat; siihen voi myös yhdistää ulkopuolelta, kun avaat pääsyn. Katso Tietokannat.
NATS
NATS on kevyt ja nopea viestintäjärjestelmä, jossa JetStream on käytössä:
- Julkaisu ja tilaus — palvelu julkaisee aiheeseen, kuten
orders.created, ja jokainen aiheen tilaaja saa viestin. Ilman JetStreamia tämä on ”lähetä ja unohda”, kuten yllä oleva Pub/Sub. - Pyyntö ja vastaus — palvelu kysyy, toinen vastaa. Kun useat instanssit vastaavat jonoryhmänä, NATS jakaa pyynnöt niiden kesken.
- JetStream — pysyvät virrat: viestit tallennetaan palvelun levylle, kuluttaja muistaa, mitä se on lukenut, ja jokainen viesti toimitetaan vähintään kerran, kunnes se kuitataan.
- Avain-arvo- ja objektitallennus JetStreamin päällä — pienille jaetuille asetuksille, lukoille tai tiedostoille palvelujen välillä.
Muuttujat. Sovelluksen ensimmäinen NATS antaa jokaiselle koodipalvelulle:
NATS_URL=nats://<käyttäjä>:<salasana>@<palvelun nimi>:4222
Jokainen NATS-palvelu antaa myös muuttujan RIVERVO_<NAME>_URL, jossa on samanmuotoinen osoite — NAME on palvelun nimi isoin kirjaimin, viivat muutettuina merkiksi _: events-niminen palvelu antaa muuttujan RIVERVO_EVENTS_URL.
JetStream säilyttää virtansa palvelun levyllä; muistissa säilytettävät virrat voivat käyttää noin neljänneksen palvelun muistista.
RabbitMQ
RabbitMQ 4.1 on perinteinen viestinvälittäjä: tuottajat julkaisevat exchangeihin, exchanget reitittävät viestit jonoihin reititysavainten mukaan, kuluttajat kuittaavat jokaisen viestin, ja hylätty tai vanhentunut viesti voi mennä dead-letter-exchangeen. Jonoille, joiden viestien on säilyttävä uudelleenkäynnistyksen yli, käytä quorum-jonoja (argumentti x-queue-type: quorum) ja julkaise viestit pysyvinä.
Muuttujat. Sovelluksen ensimmäinen RabbitMQ antaa jokaiselle koodipalvelulle:
| Muuttuja | Arvo |
|---|---|
AMQP_URL | amqp://<käyttäjä>:<salasana>@<palvelun nimi>:5672/%2f |
RABBITMQ_HOST | palvelun nimi |
RABBITMQ_PORT | 5672 |
RABBITMQ_USER, RABBITMQ_PASSWORD | käyttäjä ja salasana |
RABBITMQ_VHOST | / |
%2f AMQP_URL-muuttujan lopussa on oletusarvoinen virtuaalipalvelin / kirjoitettuna niin kuin yhteysosoitteet vaativat. Jokainen RabbitMQ-palvelu antaa myös oman RIVERVO_<NAME>_URL-muuttujansa, jossa on samanmuotoinen osoite.
Hallinta-API. Hallinnan HTTP-API kuuntelee porttia 15672 sovelluksen yksityisessä verkossa: sovelluksen palvelut tavoittavat sen osoitteessa http://<palvelun nimi>:15672 samalla käyttäjällä ja salasanalla, esimerkiksi:
curl -u "$RABBITMQ_USER:$RABBITMQ_PASSWORD" "http://$RABBITMQ_HOST:15672/api/queues"Hallintasivua ei ole internetissä. Palvelun sivu paneelissa näyttää lyhyen, vain luku -muotoisen luettelon sen jonoista: valmiit viestit, kuittaamattomat ja kuluttajat.
Vain sisäinen
NATSilla ja RabbitMQ:lla ei ole julkista osoitetta, eikä niitä voi tavoittaa sovelluksen ulkopuolelta — tietokoneeltasi, toiselta palvelimelta tai toisesta sovelluksesta. Toisin kuin PostgreSQL:lle, MySQL:lle ja Valkeylle, niille ei tarjota pääsyä ulkopuolelta. Viestejä julkaisevat ja kuluttavat palvelut toimivat saman sovelluksen palveluina: verkkopalveluina, taustaworkereina ja ajastettuina tehtävinä.
Toinen samantyyppinen palvelu
Vain sovelluksen ensimmäinen Valkey, NATS ja RabbitMQ saavat tavalliset nimet (REDIS_*, NATS_URL, AMQP_URL ja RABBITMQ_*). Seuraava samantyyppinen lisää vain oman RIVERVO_<NAME>_URL-muuttujansa; lue tämä muuttuja koodissasi tai aseta tavalliset nimet sen arvoihin Muuttujat-välilehdellä. Muuttujat tulevat palveluun sen seuraavassa julkaisussa — katso Ympäristömuuttujat.
Laravel
Valkey. Aseta Muuttujat-välilehdellä:
QUEUE_CONNECTION=redisAja php artisan queue:work — tai Horizonin kanssa php artisan horizon — taustaworkerina. Katso Laravel.
RabbitMQ. Laravelissa ei ole sisäänrakennettua RabbitMQ-ajuria, eikä Rivervo muuta QUEUE_CONNECTION-muuttujaa itsestään. Käyttääksesi RabbitMQ:ta Laravelin jonoille:
- Asenna paketti:
composer require vladimir-yuldashev/laravel-queue-rabbitmq. - Lisää
rabbitmq-yhteys tiedostoonconfig/queue.phpniin kuin paketin README näyttää versiollesi. Se lukee muuttujatRABBITMQ_HOST,RABBITMQ_PORT,RABBITMQ_USER,RABBITMQ_PASSWORDjaRABBITMQ_VHOST, jotka sovelluksella jo on:
'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', '/'),
],
],
],- Aseta
QUEUE_CONNECTION=rabbitmqMuuttujat-välilehdellä ja julkaise. Workerina pysyyphp artisan queue:work.
NATS. Laravelille ei ole virallista NATS-jonoajuria. Käytä omassa koodissasi PHP:n NATS-asiakaskirjastoa — esimerkiksi basis-company/nats — ja anna sille palvelin, portti, käyttäjä ja salasana NATS_URL-muuttujasta. Tarkista, että kirjasto tukee tarvitsemiasi ominaisuuksia (JetStream, avain-arvo), ennen kuin rakennat sen varaan.
Node.js
BullMQ (Valkey)
import { Queue, Worker } from 'bullmq'
import IORedis from 'ioredis'
const connection = new IORedis(process.env.REDIS_URL, { maxRetriesPerRequest: null })
// verkkopalvelussa
const emails = new Queue('emails', { connection })
await emails.add('welcome', { userId: 42 }, { attempts: 3 })
// taustaworkerissa
new Worker('emails', async (job) => {
await sendWelcome(job.data.userId)
}, { connection })BullMQ vaatii asetuksen maxRetriesPerRequest: null yhteydessä, jota sen workerit käyttävät.
Valkey Streams
import IORedis from 'ioredis'
const redis = new IORedis(process.env.REDIS_URL)
// tuottaja
await redis.xadd('orders', '*', 'id', '42')
// ryhmän «billing» kuluttaja
await redis.xgroup('CREATE', 'orders', 'billing', '0', 'MKSTREAM').catch((err) => {
if (!String(err).includes('BUSYGROUP')) throw err // ryhmä on jo olemassa
})
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)
}
}
}Luettu mutta kuittaamaton merkintä jää ryhmässä odottavaksi; XAUTOCLAIM antaa sen toiselle kuluttajalle.
NATS (nats.js)
import { connect, JSONCodec, AckPolicy } from 'nats'
const nc = await connect({ servers: process.env.NATS_URL })
const jc = JSONCodec()
// kerran: virta aiheille orders.* ja pysyvä kuluttaja
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 })
// tuottaja
const js = nc.jetstream()
await js.publish('orders.created', jc.encode({ id: 42 }))
// kuluttaja
const consumer = await js.consumers.get('ORDERS', 'billing')
for await (const m of await consumer.consume()) {
await handleOrder(jc.decode(m.data))
m.ack()
}Pyyntö ja vastaus: yksi palvelu vastaa koodilla nc.subscribe('prices.get', { queue: 'prices', callback: (err, msg) => msg.respond(jc.encode(price)) }), toinen kysyy koodilla 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' } })
// tuottaja
ch.sendToQueue('emails', Buffer.from(JSON.stringify({ userId: 42 })), { persistent: true })
// kuluttaja: enintään 10 kuittaamatonta viestiä kerrallaan
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) // dead-letter-exchangeen, jos jonolla on sellainen
}
})Jokaisen jonon määrittelevän palvelun on määriteltävä se samoilla argumenteilla.
Python
Celery (Valkey tai RabbitMQ)
import os
from celery import Celery
app = Celery("tasks", broker=os.environ["REDIS_URL"]) # tai os.environ["AMQP_URL"]
@app.task(acks_late=True)
def send_welcome(user_id):
...Aja celery -A tasks worker --loglevel=info taustaworkerina. Celery hyväksyy amqp://-osoitteet sellaisenaan. RabbitMQ:n kanssa Celeryn uudet versiot voivat määritellä quorum-jonoja (task_default_queue_type = "quorum") — katso versiosi Celery-dokumentaatio.
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"})
# tuottaja
ch.basic_publish(exchange="", routing_key="emails",
body=json.dumps({"user_id": 42}),
properties=pika.BasicProperties(delivery_mode=2))
# kuluttaja
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()Toimitettu useammin kuin kerran
Jonot ja viestinvälittäjät toimittavat viestin uudelleen, kun worker pysähtyy ennen kuin vahvistaa sen — julkaisun, uudelleenkäynnistyksen tai palautuksen aikana. Kirjoita kuluttajat niin, ettei saman viestin käsittely kahdesti aiheuta haittaa: säilytä jokaisen käsitellyn viestin tunnus tai tee itse toiminnosta toistettava (esimerkiksi ”aseta tilaksi maksettu” eikä ”lisää maksu”).
Resurssit ja hinta
| Palvelu | Alkaa resursseilla | Vähin muisti |
|---|---|---|
| NATS | 256 Mt muistia · 1 suoritinydin · 5 Gt levyä | 256 Mt |
| RabbitMQ | 1 Gt muistia · 1 suoritinydin · 10 Gt levyä | 512 Mt |
Kumpikin hinnoitellaan muistin, suorittimen ja levyn mukaan kuten mikä tahansa palvelu — katso Projektin palvelut. Resursseja voi muuttaa myöhemmin palvelun kohdassa Asetukset.
Varmuuskopiot ja palautus
NATS ja RabbitMQ varmuuskopioidaan joka päivä; säilytämme viimeiset 7 päivää ja 4 viikkoa kuten muissakin palveluissa.
- Varmuuskopio kopioi palvelun datatiedostot sen ollessa käynnissä. RabbitMQ:lle sama varmuuskopio sisältää myös viennin sen määrityksistä: käyttäjät, virtuaalipalvelimet, jonot, exchanget, sidokset ja käytännöt.
- Palautusta tarkkaan hetkeen ei ole — se on vain PostgreSQL:lle ja MySQL:lle. Palautat jonkin päivittäisistä kopioista.
- Palautus pysäyttää palvelun hetkeksi, palauttaa tiedostot ja käynnistää sen uudelleen. Varmuuskopion aikoihin saapuneet tai kuitatut viestit voivat puuttua tai tulla toimitetuiksi uudelleen — vielä yksi syy tehdä kuluttajista toistonkestäviä.
- Jos RabbitMQ:n kopioituja tiedostoja ei voi käynnistää, palvelu käynnistyy pelkillä määrityksillä: jonot, exchanget ja käyttäjät ovat paikallaan, mutta varmuuskopion viestit menetetään.
Huolto ja siirrot
NATSille ja RabbitMQ:lle ei aseteta huoltoaikaa. Niitä ei siirretä toiselle palvelimelle automaattisesti; jos sitä joskus tarvitaan, tuki sopii siitä kanssasi.