Започнете

Събития и опашки: Valkey, NATS и RabbitMQ.

Фонови задачи, събития и съобщения между услугите на приложението: кога да изберете Valkey, NATS или RabbitMQ, променливи за свързване, примери за Laravel, Node.js и Python, ресурси, резервни копия и ограничения.

10 МИН. ЧЕТЕНЕ

Когато сайтът предава работа на worker — да изпрати имейл, да преоразмери изображение, да таксува поръчка — или една услуга съобщава на другите, че нещо се е случило, съобщението минава през опашка или брокер на съобщения. Проектът може да има три такива, всяка добавена като услуга: Преглед → Услуги → Добавяне на услуга.

УслугаИзберете я за
Valkeyпрости опашки със задачи (опашки на Laravel и Horizon, BullMQ, Celery, RQ) и събития в Streams — когато вече я използвате за кеш и сесии
NATSлеки съобщения между услугите: събития, заявка и отговор и устойчиви потоци с JetStream
RabbitMQкласически брокер на съобщения: маршрутизиране през exchanges, потвърждения, повторни опити и dead-lettering, quorum опашки

Ако не сте сигурни, започнете с Valkey за фонови задачи: повечето фреймуърци я поддържат наготово. Изберете RabbitMQ, когато съобщенията трябва да се маршрутизират между много опашки и нито едно не бива да се губи, и NATS, когато услугите обменят много малки съобщения или си искат отговори една от друга.

Valkey: опашки със задачи и Streams

Valkey е Redis-съвместимо хранилище — същата управлявана услуга като в Бази данни. Първата Valkey на приложението дава на всяка услуга с код REDIS_URL, REDIS_HOST, REDIS_PORT и REDIS_PASSWORD; всяка Valkey дава и своя RIVERVO_<NAME>_URL.

Три начина за изпращане на съобщения през нея:

  • Опашки със задачи — опашки на Laravel с драйвера redis и Horizon, BullMQ, Celery, RQ. Библиотеката пази задачите във Valkey; worker ги взима една по една и повтаря неуспешните.
  • Streams с consumer groups — XADD добавя събитие към поток, консуматорите от групата го четат с XREADGROUP и го потвърждават с XACK. Събитията се съхраняват: спрян консуматор продължава оттам, докъдето е стигнал, непотвърдено събитие може да се вземе отново, а нова група може да прочете потока от началото.
  • Pub/Sub — PUBLISH и SUBSCRIBE доставят съобщението само на абонатите, свързани в този момент. Съобщението не се съхранява: абонат, който се рестартира или още не е свързан, го пропуска. Използвайте Pub/Sub само там, където загубено съобщение не вреди (например сигнал „обнови“), а за всичко останало — Streams или опашка.

Valkey се архивира всеки ден като другите бази данни; може да бъде достъпна и отвън, когато отворите достъпа. Вижте Бази данни.

NATS

NATS е лека и бърза система за съобщения с включен JetStream:

  • Публикуване и абониране — услуга публикува в тема като orders.created, всеки абонат на темата получава съобщението. Без JetStream това е „изпрати и забрави“, като Pub/Sub по-горе.
  • Заявка и отговор — една услуга пита, друга отговаря. Когато няколко инстанции отговарят като queue group, NATS разпределя заявките между тях.
  • JetStream — устойчиви потоци: съобщенията се съхраняват на диска на услугата, консуматорът помни какво е прочел и всяко съобщение се доставя поне веднъж, докато не бъде потвърдено.
  • Key-value и обектно хранилище върху JetStream — за малки общи настройки, заключвания или файлове между услугите.

Променливи. Първата NATS на приложението дава на всяка услуга с код:

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

Всяка услуга NATS дава и RIVERVO_<NAME>_URL с адрес в същия вид — NAME е името на услугата с главни букви, като тиретата стават _: услуга с име events дава RIVERVO_EVENTS_URL.

JetStream пази потоците си на диска на услугата; потоците в паметта могат да използват около една четвърт от паметта на услугата.

RabbitMQ

RabbitMQ 4.1 е класически брокер на съобщения: производителите публикуват в exchanges, exchanges маршрутизират съобщенията към опашки по routing keys, консуматорите потвърждават всяко съобщение, а отхвърлено или изтекло съобщение може да отиде в dead-letter exchange. За опашки, чиито съобщения трябва да оцелеят при рестарт, използвайте quorum опашки (аргументът x-queue-type: quorum) и публикувайте съобщенията като persistent.

Променливи. Първият RabbitMQ на приложението дава на всяка услуга с код:

ПроменливаСтойност
AMQP_URLamqp://<user>:<password>@<service name>:5672/%2f
RABBITMQ_HOSTимето на услугата
RABBITMQ_PORT5672
RABBITMQ_USER, RABBITMQ_PASSWORDпотребителят и паролата
RABBITMQ_VHOST/

%2f в края на AMQP_URL е виртуалният хост по подразбиране /, записан така, както го изискват адресите за свързване. Всяка услуга RabbitMQ дава и собствен RIVERVO_<NAME>_URL с адрес в същия вид.

Management API. HTTP API-то за управление слуша на порт 15672 в частната мрежа на приложението: услугите на приложението го достигат на http://<service name>:15672 със същите потребител и парола, например:

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

Страница за управление в интернет няма. Страницата на услугата в панела показва кратък списък с опашките ѝ само за четене: готови съобщения, непотвърдени и консуматори.

Само вътрешни

NATS и RabbitMQ нямат публичен адрес и не могат да бъдат достъпени извън приложението — от компютъра ви, от друг сървър или от друго приложение. За разлика от PostgreSQL, MySQL и Valkey, за тях не се предлага достъп отвън. Услугите, които публикуват и консумират съобщения, работят като услуги на същото приложение: уеб услуги, фонови worker процеси и планирани задачи.

Втора услуга от същия вид

Обичайните имена (REDIS_*, NATS_URL, AMQP_URL и RABBITMQ_*) получават само първите Valkey, NATS и RabbitMQ на приложението. Следващата от същия вид добавя само своя RIVERVO_<NAME>_URL; четете тази променлива в кода си или задайте обичайните имена с нейните стойности в раздела Променливи. Променливите стигат до услугата при следващото ѝ внедряване — вижте Променливи на средата.

Laravel

Valkey. Задайте в раздела Променливи:

QUEUE_CONNECTION=redis

Стартирайте php artisan queue:work — или php artisan horizon с Horizon — като фонов worker. Вижте Laravel.

RabbitMQ. Laravel няма вграден драйвер за RabbitMQ, а Rivervo не променя QUEUE_CONNECTION само. За да използвате RabbitMQ за опашките на Laravel:

  1. Инсталирайте пакета: composer require vladimir-yuldashev/laravel-queue-rabbitmq.
  2. Добавете връзката rabbitmq в config/queue.php, както показва README на пакета за вашата версия. Тя чете RABBITMQ_HOST, RABBITMQ_PORT, RABBITMQ_USER, RABBITMQ_PASSWORD и RABBITMQ_VHOST, които приложението вече има:
'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. Задайте QUEUE_CONNECTION=rabbitmq в раздела Променливи и внедрете. Worker-ът остава php artisan queue:work.

NATS. Официален драйвер за опашки на Laravel за NATS няма. Използвайте NATS клиент за PHP в собствения си код — например basis-company/nats — и му подайте хоста, порта, потребителя и паролата от NATS_URL. Проверете дали клиентът поддържа нужните ви възможности (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 })
 
// в уеб услугата
const emails = new Queue('emails', { connection })
await emails.add('welcome', { userId: 42 }, { attempts: 3 })
 
// във фоновия worker
new Worker('emails', async (job) => {
  await sendWelcome(job.data.userId)
}, { connection })

BullMQ изисква maxRetriesPerRequest: null за връзката, която използват неговите worker процеси.

Valkey Streams

import IORedis from 'ioredis'
 
const redis = new IORedis(process.env.REDIS_URL)
 
// производител
await redis.xadd('orders', '*', 'id', '42')
 
// консуматор от групата „billing“
await redis.xgroup('CREATE', 'orders', 'billing', '0', 'MKSTREAM').catch((err) => {
  if (!String(err).includes('BUSYGROUP')) throw err // групата вече съществува
})
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)
    }
  }
}

Запис, който е прочетен, но не е потвърден, остава чакащ в групата; XAUTOCLAIM го предава на друг консуматор.

NATS (nats.js)

import { connect, JSONCodec, AckPolicy } from 'nats'
 
const nc = await connect({ servers: process.env.NATS_URL })
const jc = JSONCodec()
 
// еднократно: поток за темите orders.* и устойчив консуматор
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 })
 
// производител
const js = nc.jetstream()
await js.publish('orders.created', jc.encode({ id: 42 }))
 
// консуматор
const consumer = await js.consumers.get('ORDERS', 'billing')
for await (const m of await consumer.consume()) {
  await handleOrder(jc.decode(m.data))
  m.ack()
}

Заявка и отговор: една услуга отговаря с nc.subscribe('prices.get', { queue: 'prices', callback: (err, msg) => msg.respond(jc.encode(price)) }), друга пита с 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' } })
 
// производител
ch.sendToQueue('emails', Buffer.from(JSON.stringify({ userId: 42 })), { persistent: true })
 
// консуматор: най-много 10 непотвърдени съобщения наведнъж
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 exchange, ако опашката има такъв
  }
})

Всяка услуга, която декларира опашката, трябва да я декларира със същите аргументи.

Python

Celery (Valkey или RabbitMQ)

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

Стартирайте celery -A tasks worker --loglevel=info като фонов worker. Celery приема адресите amqp:// във вида, в който са. С RabbitMQ новите версии на Celery могат да декларират quorum опашки (task_default_queue_type = "quorum") — вижте документацията на Celery за вашата версия.

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"})
 
# производител
ch.basic_publish(exchange="", routing_key="emails",
                 body=json.dumps({"user_id": 42}),
                 properties=pika.BasicProperties(delivery_mode=2))
 
# консуматор
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()

Доставка повече от веднъж

Опашките и брокерите доставят съобщението отново, когато worker спре, преди да го потвърди — по време на внедряване, рестарт или възстановяване. Пишете консуматорите така, че двукратната обработка на едно и също съобщение да не вреди: пазете ID-то на всяко обработено съобщение или направете самото действие повторяемо (например „задай статус платено“ вместо „добави плащане“).

Ресурси и цена

УслугаЗапочва сМинимална памет
NATS256 MB памет · 1 процесорно ядро · 5 GB диск256 MB
RabbitMQ1 GB памет · 1 процесорно ядро · 10 GB диск512 MB

Всяка се таксува според паметта, процесора и диска си като всяка услуга — вижте Услуги на проекта. Ресурсите могат да се променят по-късно в Настройки на услугата.

Резервни копия и възстановяване

NATS и RabbitMQ се архивират всеки ден; пазим последните 7 дни и 4 седмици, както при другите услуги.

  • Архивирането копира файловете с данни на услугата, докато тя работи. За RabbitMQ същото копие съдържа и експорт на дефинициите ѝ: потребители, виртуални хостове, опашки, exchanges, bindings и политики.
  • Възстановяване към точен момент няма — то е само за PostgreSQL и MySQL. Възстановявате едно от дневните копия.
  • Възстановяването спира услугата за кратко, връща файловете и я стартира отново. Съобщения, пристигнали или потвърдени около момента на архивирането, може да липсват или да бъдат доставени отново — още една причина консуматорите да са безопасни при повторение.
  • За RabbitMQ, ако копираните файлове не могат да бъдат стартирани, услугата стартира само с дефинициите: опашките, exchanges и потребителите са налице, но съобщенията от резервното копие се губят.

Поддръжка и преместване

NATS и RabbitMQ нямат време за поддръжка, което да се задава. Те не се преместват автоматично на друг сървър; ако някога се наложи, екипът по поддръжка го уговаря с вас.

Още имате въпроси?

Пишете ни в чата — AI отговаря веднага, а инженер се включва, когато е нужно, по всяко време на денонощието.

Връзка с поддръжката