Započnite

Događaji i redovi: Valkey, NATS i RabbitMQ.

Pozadinski zadaci, događaji i poruke između servisa aplikacije: kada izabrati Valkey, NATS ili RabbitMQ, promenljive za povezivanje, primeri za Laravel, Node.js i Python, resursi, rezervne kopije i ograničenja.

9 MIN ČITANJA

Kada sajt prepusti posao workeru — pošalje imejl, promeni veličinu slike, naplati porudžbinu — ili jedan servis javi ostalima da se nešto desilo, poruka prolazi kroz red ili message broker. Projekat može imati tri takva servisa, a svaki se dodaje kao servis: Pregled → Servisi → Dodaj servis.

ServisIzaberite ga za
Valkeyjednostavne redove zadataka (Laravel redovi i Horizon, BullMQ, Celery, RQ) i događaje u Streams — kada ga već koristite za keš i sesije
NATSlagano slanje poruka između servisa: događaji, zahtev i odgovor, i trajni tokovi uz JetStream
RabbitMQklasičan message broker: rutiranje preko exchangeova, potvrde, ponovni pokušaji i dead-lettering, quorum redovi

Ako niste sigurni, za pozadinske zadatke počnite sa Valkey: većina frameworka ga podržava odmah. Izaberite RabbitMQ kada poruke moraju da se rutiraju između mnogo redova i nijedna ne sme da se izgubi, a NATS kada servisi razmenjuju mnogo malih poruka ili traže odgovore jedni od drugih.

Valkey: redovi zadataka i Streams

Valkey je skladište kompatibilno sa Redis-om — isti upravljani servis kao u Bazama podataka. Prvi Valkey aplikacije daje svakom servisu sa kodom REDIS_URL, REDIS_HOST, REDIS_PORT i REDIS_PASSWORD; svaki Valkey daje i sopstveni RIVERVO_<NAME>_URL.

Tri načina za slanje poruka kroz njega:

  • Redovi zadataka — Laravel redovi sa drajverom redis i Horizon, BullMQ, Celery, RQ. Biblioteka čuva zadatke u Valkey-u; worker ih preuzima jedan po jedan i ponovo pokušava one koji ne uspeju.
  • Streams sa grupama potrošača — XADD dodaje događaj u tok, potrošači iz grupe ga čitaju pomoću XREADGROUP i potvrđuju pomoću XACK. Događaji se čuvaju: potrošač koji je bio zaustavljen nastavlja tamo gde je stao, nepotvrđeni događaj se može ponovo preuzeti, a nova grupa može čitati tok od početka.
  • Pub/Sub — PUBLISH i SUBSCRIBE isporučuju poruku samo pretplatnicima koji su povezani u tom trenutku. Poruka se ne čuva: pretplatnik koji se restartuje ili još nije povezan je propušta. Pub/Sub koristite samo tamo gde izgubljena poruka ne pravi štetu (na primer signal „osveži“), a za sve ostalo Streams ili red.

Za Valkey se rezervne kopije prave svakog dana kao i za druge baze; može mu se pristupiti i spolja kada otvorite pristup. Pogledajte Baze podataka.

NATS

NATS je lagan i brz sistem za razmenu poruka, sa uključenim JetStream-om:

  • Objavljivanje i pretplata — servis objavljuje na temu kao što je orders.created, a svaki pretplatnik te teme dobija poruku. Bez JetStream-a ovo je „pošalji i zaboravi“, kao Pub/Sub iznad.
  • Zahtev i odgovor — jedan servis pita, drugi odgovara. Kada više instanci odgovara kao queue grupa, NATS raspoređuje zahteve između njih.
  • JetStream — trajni tokovi: poruke se čuvaju na disku servisa, potrošač pamti šta je pročitao, a svaka poruka se isporučuje najmanje jednom dok ne bude potvrđena.
  • Key-value i object store izgrađeni na JetStream-u — za mala zajednička podešavanja, zaključavanja ili fajlove između servisa.

Promenljive. Prvi NATS aplikacije daje svakom servisu sa kodom:

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

Svaki NATS servis daje i RIVERVO_<NAME>_URL sa adresom istog oblika — NAME je ime servisa velikim slovima, sa crticama pretvorenim u _: servis nazvan events daje RIVERVO_EVENTS_URL.

JetStream čuva svoje tokove na disku servisa; tokovi koji se čuvaju u memoriji mogu koristiti oko četvrtine memorije servisa.

RabbitMQ

RabbitMQ 4.1 je klasičan message broker: proizvođači objavljuju na exchangeove, exchangeovi rutiraju poruke u redove prema ključevima rutiranja, potrošači potvrđuju svaku poruku, a poruka koja je odbijena ili istekne može otići na dead-letter exchange. Za redove čije poruke moraju preživeti restart koristite quorum redove (argument x-queue-type: quorum) i objavljujte poruke kao trajne.

Promenljive. Prvi RabbitMQ aplikacije daje svakom servisu sa kodom:

PromenljivaVrednost
AMQP_URLamqp://<user>:<password>@<service name>:5672/%2f
RABBITMQ_HOSTime servisa
RABBITMQ_PORT5672
RABBITMQ_USER, RABBITMQ_PASSWORDkorisnik i lozinka
RABBITMQ_VHOST/

%2f na kraju AMQP_URL je podrazumevani virtuelni host /, zapisan onako kako to zahtevaju adrese za povezivanje. Svaki RabbitMQ servis daje i sopstveni RIVERVO_<NAME>_URL sa adresom istog oblika.

Management API. Management HTTP API sluša na portu 15672 unutar privatne mreže aplikacije: servisi aplikacije mu pristupaju na http://<service name>:15672 sa istim korisnikom i lozinkom, na primer:

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

Stranica za upravljanje nije dostupna na internetu. Stranica servisa u panelu prikazuje kratku listu njegovih redova, samo za čitanje: spremne poruke, nepotvrđene poruke i potrošače.

Samo interni

NATS i RabbitMQ nemaju javnu adresu i ne mogu im se pristupiti izvan aplikacije — sa vašeg računara, drugog servera ili iz druge aplikacije. Za razliku od PostgreSQL-a, MySQL-a i Valkey-a, pristup spolja za njih nije ponuđen. Servisi koji objavljuju i preuzimaju poruke rade kao servisi iste aplikacije: veb servisi, pozadinski workeri i zakazani zadaci.

Drugi servis iste vrste

Uobičajena imena (REDIS_*, NATS_URL, AMQP_URL i RABBITMQ_*) dobijaju samo prvi Valkey, NATS i RabbitMQ aplikacije. Sledeći iste vrste dodaje samo sopstveni RIVERVO_<NAME>_URL; čitajte tu promenljivu u kodu ili na kartici Promenljive postavite uobičajena imena na njene vrednosti. Promenljive stižu do servisa pri sledećem deployu — pogledajte Promenljive okruženja.

Laravel

Valkey. Na kartici Promenljive postavite:

QUEUE_CONNECTION=redis

Pokrenite php artisan queue:work — ili php artisan horizon uz Horizon — kao pozadinski worker. Pogledajte Laravel.

RabbitMQ. Laravel nema ugrađen drajver za RabbitMQ, a Rivervo ne menja QUEUE_CONNECTION sam. Da biste RabbitMQ koristili za Laravel redove:

  1. Instalirajte paket: composer require vladimir-yuldashev/laravel-queue-rabbitmq.
  2. Dodajte vezu rabbitmq u config/queue.php onako kako README paketa prikazuje za vašu verziju. Ona čita RABBITMQ_HOST, RABBITMQ_PORT, RABBITMQ_USER, RABBITMQ_PASSWORD i RABBITMQ_VHOST, koje aplikacija već ima:
'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. Postavite QUEUE_CONNECTION=rabbitmq na kartici Promenljive i uradite deploy. Worker ostaje php artisan queue:work.

NATS. Ne postoji zvanični Laravel drajver za redove za NATS. U sopstvenom kodu koristite NATS klijent za PHP — na primer basis-company/nats — i prosledite mu host, port, korisnika i lozinku iz NATS_URL. Pre nego što se na njega oslonite, proverite da li klijent podržava funkcije koje vam trebaju (JetStream, key-value).

Node.js

BullMQ (Valkey)

import { Queue, Worker } from 'bullmq'
import IORedis from 'ioredis'
 
const connection = new IORedis(process.env.REDIS_URL, { maxRetriesPerRequest: null })
 
// u veb servisu
const emails = new Queue('emails', { connection })
await emails.add('welcome', { userId: 42 }, { attempts: 3 })
 
// u pozadinskom workeru
new Worker('emails', async (job) => {
  await sendWelcome(job.data.userId)
}, { connection })

BullMQ zahteva maxRetriesPerRequest: null na vezi koju koriste njegovi workeri.

Valkey Streams

import IORedis from 'ioredis'
 
const redis = new IORedis(process.env.REDIS_URL)
 
// proizvođač
await redis.xadd('orders', '*', 'id', '42')
 
// potrošač iz grupe „billing“
await redis.xgroup('CREATE', 'orders', 'billing', '0', 'MKSTREAM').catch((err) => {
  if (!String(err).includes('BUSYGROUP')) throw err // grupa već postoji
})
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)
    }
  }
}

Unos koji je pročitan, ali nije potvrđen, ostaje na čekanju u grupi; XAUTOCLAIM ga predaje drugom potrošaču.

NATS (nats.js)

import { connect, JSONCodec, AckPolicy } from 'nats'
 
const nc = await connect({ servers: process.env.NATS_URL })
const jc = JSONCodec()
 
// jednom: tok za teme orders.* i trajni potrošač
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 })
 
// proizvođač
const js = nc.jetstream()
await js.publish('orders.created', jc.encode({ id: 42 }))
 
// potrošač
const consumer = await js.consumers.get('ORDERS', 'billing')
for await (const m of await consumer.consume()) {
  await handleOrder(jc.decode(m.data))
  m.ack()
}

Zahtev i odgovor: jedan servis odgovara pomoću nc.subscribe('prices.get', { queue: 'prices', callback: (err, msg) => msg.respond(jc.encode(price)) }), a drugi pita pomoću 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' } })
 
// proizvođač
ch.sendToQueue('emails', Buffer.from(JSON.stringify({ userId: 42 })), { persistent: true })
 
// potrošač: najviše 10 nepotvrđenih poruka istovremeno
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) // na dead-letter exchange, ako ga red ima
  }
})

Svaki servis koji deklariše red mora ga deklarisati sa istim argumentima.

Python

Celery (Valkey ili RabbitMQ)

import os
from celery import Celery
 
app = Celery("tasks", broker=os.environ["REDIS_URL"])  # ili os.environ["AMQP_URL"]
 
@app.task(acks_late=True)
def send_welcome(user_id):
    ...

Pokrenite celery -A tasks worker --loglevel=info kao pozadinski worker. Celery prihvata amqp:// adrese takve kakve su. Uz RabbitMQ, novije verzije Celery-ja mogu da deklarišu quorum redove (task_default_queue_type = "quorum") — pogledajte dokumentaciju Celery-ja za vašu verziju.

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"})
 
# proizvođač
ch.basic_publish(exchange="", routing_key="emails",
                 body=json.dumps({"user_id": 42}),
                 properties=pika.BasicProperties(delivery_mode=2))
 
# potrošač
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()

Isporučeno više puta

Redovi i brokeri ponovo isporučuju poruku kada se worker zaustavi pre nego što je potvrdi — tokom deploya, restarta ili vraćanja. Pišite potrošače tako da dvostruka obrada iste poruke ne pravi štetu: čuvajte ID svake obrađene poruke ili napravite da se sama radnja može ponoviti (na primer „postavi status na plaćeno“ umesto „dodaj uplatu“).

Resursi i cena

ServisPočetna konfiguracijaNajmanje memorije
NATS256 MB memorije · 1 CPU jezgro · 5 GB diska256 MB
RabbitMQ1 GB memorije · 1 CPU jezgro · 10 GB diska512 MB

Cena svakog se računa prema memoriji, CPU-u i disku kao za svaki servis — pogledajte Servisi projekta. Resursi se kasnije mogu promeniti u Podešavanjima servisa.

Rezervne kopije i vraćanje

Za NATS i RabbitMQ rezervne kopije se prave svakog dana; čuvamo poslednjih 7 dana i 4 nedelje, kao i za ostale servise.

  • Rezervna kopija kopira fajlove sa podacima servisa dok on radi. Za RabbitMQ ista kopija sadrži i izvoz njegovih definicija: korisnika, virtuelnih hostova, redova, exchangeova, vezivanja i polisa.
  • Nema vraćanja na tačan trenutak — to postoji samo za PostgreSQL i MySQL. Vraćate jednu od dnevnih kopija.
  • Vraćanje nakratko zaustavlja servis, vraća fajlove i ponovo ga pokreće. Poruke koje su stigle ili su potvrđene oko vremena pravljenja kopije mogu nedostajati ili biti ponovo isporučene — još jedan razlog da potrošači budu bezbedni za ponavljanje.
  • Za RabbitMQ, ako kopirani fajlovi ne mogu da se pokrenu, servis se pokreće samo sa definicijama: redovi, exchangeovi i korisnici postoje, ali poruke iz rezervne kopije su izgubljene.

Održavanje i premeštanje

NATS i RabbitMQ nemaju vreme održavanja koje se podešava. Ne premeštaju se automatski na drugi server; ako to ikada bude potrebno, podrška to dogovara sa vama.

I dalje vam treba pomoć?

Pišite nam u čet — AI odgovara odmah, a inženjer se uključuje kada je potrebno, u bilo koje doba dana.

Kontaktirajte podršku