Kom i gang

Hendelser og køer: Valkey, NATS og RabbitMQ.

Bakgrunnsjobber, hendelser og meldinger mellom tjenestene i en applikasjon: når du bør velge Valkey, NATS eller RabbitMQ, tilkoblingsvariablene, eksempler for Laravel, Node.js og Python, ressurser, sikkerhetskopier og grenser.

10 MIN LESING

Når en nettside gir en worker en oppgave — sende en e-post, endre størrelse på et bilde, belaste en ordre — eller én tjeneste forteller de andre at noe har skjedd, går meldingen gjennom en kø eller en meldingsmegler. Et prosjekt kan ha tre slike, og hver legges til som en tjeneste: Oversikt → Tjenester → Legg til en tjeneste.

TjenesteVelg den for
Valkeyenkle jobbkøer (Laravel-køer og Horizon, BullMQ, Celery, RQ), og hendelser i Streams — når du allerede bruker den til cache og økter
NATSlett meldingsutveksling mellom tjenester: hendelser, forespørsel og svar, og varige strømmer med JetStream
RabbitMQen klassisk meldingsmegler: ruting via exchanges, kvitteringer, nye forsøk og dead-lettering, quorum-køer

Er du usikker, start med Valkey for bakgrunnsjobber: de fleste rammeverk støtter den rett ut av boksen. Velg RabbitMQ når meldinger må rutes mellom mange køer og ingen får gå tapt, og NATS når tjenester utveksler mange små meldinger eller spør hverandre om svar.

Valkey: jobbkøer og Streams

Valkey er et Redis-kompatibelt lager — den samme administrerte tjenesten som i Databaser. Den første Valkey-tjenesten i applikasjonen gir alle kodetjenester REDIS_URL, REDIS_HOST, REDIS_PORT og REDIS_PASSWORD; hver Valkey gir også sin egen RIVERVO_<NAME>_URL.

Tre måter å sende meldinger gjennom den på:

  • Jobbkøer — Laravel-køer med driveren redis og Horizon, BullMQ, Celery, RQ. Biblioteket lagrer jobbene i Valkey; en worker tar dem én etter én og prøver på nytt de som feiler.
  • Streams med konsumentgrupper — XADD legger en hendelse til i en strøm, konsumentene i en gruppe leser den med XREADGROUP og bekrefter den med XACK. Hendelser lagres: en konsument som ble stoppet, fortsetter der den slapp, en hendelse som ikke ble bekreftet, kan hentes på nytt, og en ny gruppe kan lese strømmen fra starten.
  • Pub/Sub — PUBLISH og SUBSCRIBE leverer en melding bare til abonnentene som er tilkoblet akkurat da. Meldingen lagres ikke: en abonnent som starter på nytt eller ikke er tilkoblet ennå, går glipp av den. Bruk Pub/Sub bare der en tapt melding ikke gjør skade (for eksempel et «oppdater»-signal), og Streams eller en kø til alt annet.

Valkey sikkerhetskopieres hver dag som de andre databasene; den kan også nås utenfra når du åpner tilgang. Se Databaser.

NATS

NATS er et lett og raskt meldingssystem, med JetStream slått på:

  • Publisering og abonnement — en tjeneste publiserer til et subject som orders.created, og alle som abonnerer på subjectet, får meldingen. Uten JetStream er dette «send og glem», som Pub/Sub over.
  • Forespørsel og svar — én tjeneste spør, en annen svarer. Når flere instanser svarer som en kø-gruppe, fordeler NATS forespørslene mellom dem.
  • JetStream — varige strømmer: meldinger lagres på tjenestens disk, en konsument husker hva den har lest, og hver melding leveres minst én gang til den er kvittert for.
  • Nøkkel-verdi- og objektlager bygget på JetStream — for små delte innstillinger, låser eller filer mellom tjenester.

Variabler. Den første NATS-tjenesten i applikasjonen gir alle kodetjenester:

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

Hver NATS-tjeneste gir også RIVERVO_<NAME>_URL med en adresse på samme form — NAME er tjenestens navn med store bokstaver, der bindestreker er gjort om til _: en tjeneste som heter events, gir RIVERVO_EVENTS_URL.

JetStream lagrer strømmene sine på tjenestens disk; strømmer som holdes i minnet, kan bruke omtrent en fjerdedel av tjenestens minne.

RabbitMQ

RabbitMQ 4.1 er en klassisk meldingsmegler: produsenter publiserer til exchanges, exchanges ruter meldingene til køer etter routing keys, konsumenter kvitterer for hver melding, og en melding som avvises eller utløper, kan gå til en dead-letter-exchange. For køer der meldingene må overleve en omstart, bruker du quorum-køer (argumentet x-queue-type: quorum) og publiserer meldingene som persistente.

Variabler. Den første RabbitMQ-tjenesten i applikasjonen gir alle kodetjenester:

VariabelVerdi
AMQP_URLamqp://<user>:<password>@<service name>:5672/%2f
RABBITMQ_HOSTtjenestens navn
RABBITMQ_PORT5672
RABBITMQ_USER, RABBITMQ_PASSWORDbrukeren og passordet
RABBITMQ_VHOST/

%2f på slutten av AMQP_URL er standard virtuell vert /, skrevet slik tilkoblingsadresser krever. Hver RabbitMQ-tjeneste gir også sin egen RIVERVO_<NAME>_URL med en adresse på samme form.

Administrasjons-API. HTTP-API-et for administrasjon lytter på port 15672 i applikasjonens private nettverk: applikasjonens tjenester når det på http://<service name>:15672 med samme bruker og passord, for eksempel:

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

Det finnes ingen administrasjonsside på internett. Tjenestens side i panelet viser en kort liste over køene, kun for lesing: meldinger klare, meldinger uten kvittering og konsumenter.

Kun intern

NATS og RabbitMQ har ingen offentlig adresse og kan ikke nås utenfra applikasjonen — fra datamaskinen din, en annen server eller en annen applikasjon. I motsetning til PostgreSQL, MySQL og Valkey tilbys ikke tilgang utenfra for dem. Tjenestene som publiserer og mottar meldinger, kjører som tjenester i den samme applikasjonen: webtjenester, bakgrunnsworkers og planlagte jobber.

En tjeneste til av samme type

Bare den første Valkey-, NATS- og RabbitMQ-tjenesten i applikasjonen får de vanlige navnene (REDIS_*, NATS_URL, AMQP_URL og RABBITMQ_*). Den neste av samme type legger bare til sin egen RIVERVO_<NAME>_URL; les den variabelen i koden din, eller sett de vanlige navnene til verdiene dens i fanen Variabler. Variabler når en tjeneste ved neste utrulling — se Miljøvariabler.

Laravel

Valkey. Sett i fanen Variabler:

QUEUE_CONNECTION=redis

Kjør php artisan queue:work — eller php artisan horizon med Horizon — som en bakgrunnsworker. Se Laravel.

RabbitMQ. Laravel har ingen innebygd RabbitMQ-driver, og Rivervo endrer ikke QUEUE_CONNECTION av seg selv. Slik bruker du RabbitMQ til Laravel-køer:

  1. Installer pakken: composer require vladimir-yuldashev/laravel-queue-rabbitmq.
  2. Legg til tilkoblingen rabbitmq i config/queue.php slik pakkens README viser for din versjon. Den leser RABBITMQ_HOST, RABBITMQ_PORT, RABBITMQ_USER, RABBITMQ_PASSWORD og RABBITMQ_VHOST, som applikasjonen 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', '/'),
        ],
    ],
],
  1. Sett QUEUE_CONNECTION=rabbitmq i fanen Variabler og rull ut. Workeren er fortsatt php artisan queue:work.

NATS. Det finnes ingen offisiell Laravel-kødriver for NATS. Bruk en NATS-klient for PHP i din egen kode — for eksempel basis-company/nats — og gi den vert, port, bruker og passord fra NATS_URL. Sjekk at klienten støtter funksjonene du trenger (JetStream, nøkkel-verdi), før 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 webtjenesten
const emails = new Queue('emails', { connection })
await emails.add('welcome', { userId: 42 }, { attempts: 3 })
 
// i bakgrunnsworkeren
new Worker('emails', async (job) => {
  await sendWelcome(job.data.userId)
}, { connection })

BullMQ krever maxRetriesPerRequest: null på tilkoblingen som workerne bruker.

Valkey Streams

import IORedis from 'ioredis'
 
const redis = new IORedis(process.env.REDIS_URL)
 
// produsent
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 finnes 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 oppføring som er lest, men ikke kvittert for, blir liggende som ventende i gruppen; XAUTOCLAIM gir den til en annen konsument.

NATS (nats.js)

import { connect, JSONCodec, AckPolicy } from 'nats'
 
const nc = await connect({ servers: process.env.NATS_URL })
const jc = JSONCodec()
 
// én gang: en strøm for subjectene orders.* og en varig 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 })
 
// produsent
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()
}

Forespørsel og svar: én tjeneste svarer med nc.subscribe('prices.get', { queue: 'prices', callback: (err, msg) => msg.respond(jc.encode(price)) }), en annen spør 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' } })
 
// produsent
ch.sendToQueue('emails', Buffer.from(JSON.stringify({ userId: 42 })), { persistent: true })
 
// konsument: høyst 10 meldinger uten kvittering om 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 som deklarerer køen, må deklarere den med de samme argumentene.

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):
    ...

Kjør celery -A tasks worker --loglevel=info som en bakgrunnsworker. Celery godtar amqp://-adresser som de er. Med RabbitMQ kan nyere Celery-versjoner deklarere quorum-køer (task_default_queue_type = "quorum") — se Celery-dokumentasjonen for din versjon.

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"})
 
# produsent
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()

Levert mer enn én gang

Køer og meldingsmeglere leverer en melding på nytt når en worker stopper før den har bekreftet den — under en utrulling, en omstart eller en gjenoppretting. Skriv konsumentene slik at det ikke gjør skade å behandle den samme meldingen to ganger: lagre ID-en til hver behandlede melding, eller gjør selve handlingen gjentakbar (for eksempel «sett statusen til betalt» i stedet for «legg til en betaling»).

Ressurser og pris

TjenesteStarter medMinst minne
NATS256 MB minne · 1 CPU-kjerne · 5 GB disk256 MB
RabbitMQ1 GB minne · 1 CPU-kjerne · 10 GB disk512 MB

Hver av dem prises etter minne, CPU og disk som alle andre tjenester — se Tjenester i et prosjekt. Ressursene kan endres senere under tjenestens Innstillinger.

Sikkerhetskopier og gjenoppretting

NATS og RabbitMQ sikkerhetskopieres hver dag; vi beholder de siste 7 dagene og 4 ukene, som for de andre tjenestene.

  • Sikkerhetskopien kopierer tjenestens datafiler mens den kjører. For RabbitMQ inneholder den samme sikkerhetskopien også en eksport av definisjonene: brukere, virtuelle verter, køer, exchanges, bindinger og policyer.
  • Det finnes ingen gjenoppretting til et nøyaktig tidspunkt — det gjelder bare PostgreSQL og MySQL. Du gjenoppretter en av de daglige kopiene.
  • En gjenoppretting stopper tjenesten en kort stund, legger tilbake filene og starter den igjen. Meldinger som kom inn eller ble kvittert for rundt tidspunktet for sikkerhetskopien, kan mangle eller bli levert på nytt — enda en grunn til å gjøre konsumentene trygge å gjenta.
  • For RabbitMQ: hvis de kopierte filene ikke kan startes, starter tjenesten bare med definisjonene: køene, exchangene og brukerne er der, men meldingene fra sikkerhetskopien er tapt.

Vedlikehold og flytting

NATS og RabbitMQ har ikke noe vedlikeholdstidspunkt å stille inn. De flyttes ikke automatisk til en annen server; skulle det bli nødvendig, avtaler kundestøtten det med deg.

Står du fast?

Chat med oss – AI svarer med en gang, og en tekniker kommer inn når det trengs, når som helst på døgnet.

Kontakt kundestøtte