Aloita

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.

8 MIN LUKUAIKA

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.

PalveluValitse se, kun tarvitset
Valkeyyksinkertaiset tehtäväjonot (Laravelin jonot ja Horizon, BullMQ, Celery, RQ) ja tapahtumat Streamsissa — kun käytät sitä jo välimuistiin ja istuntoihin
NATSkevyt viestintä palvelujen välillä: tapahtumat, pyyntö ja vastaus sekä pysyvät virrat JetStreamilla
RabbitMQperinteinen 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ä — XADD lisää tapahtuman virtaan, ryhmän kuluttajat lukevat sen XREADGROUP-komennolla ja vahvistavat sen XACK-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 — PUBLISH ja SUBSCRIBE toimittavat 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:

MuuttujaArvo
AMQP_URLamqp://<käyttäjä>:<salasana>@<palvelun nimi>:5672/%2f
RABBITMQ_HOSTpalvelun nimi
RABBITMQ_PORT5672
RABBITMQ_USER, RABBITMQ_PASSWORDkä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=redis

Aja 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:

  1. Asenna paketti: composer require vladimir-yuldashev/laravel-queue-rabbitmq.
  2. Lisää rabbitmq-yhteys tiedostoon config/queue.php niin kuin paketin README näyttää versiollesi. Se lukee muuttujat RABBITMQ_HOST, RABBITMQ_PORT, RABBITMQ_USER, RABBITMQ_PASSWORD ja RABBITMQ_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', '/'),
        ],
    ],
],
  1. Aseta QUEUE_CONNECTION=rabbitmq Muuttujat-välilehdellä ja julkaise. Workerina pysyy php 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

PalveluAlkaa resursseillaVähin muisti
NATS256 Mt muistia · 1 suoritinydin · 5 Gt levyä256 Mt
RabbitMQ1 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.

Jäikö jotain epäselväksi?

Kirjoita meille chatissa — AI vastaa heti, ja insinööri liittyy mukaan tarvittaessa mihin aikaan tahansa.

Ota yhteyttä tukeen