დაწყება

მოვლენები და რიგები: Valkey, NATS და RabbitMQ.

ფონური ამოცანები, მოვლენები და შეტყობინებები აპლიკაციის სერვისებს შორის: როდის აირჩიოთ Valkey, NATS ან RabbitMQ, კავშირის ცვლადები, მაგალითები Laravel-ისთვის, Node.js-ისა და Python-ისთვის, რესურსები, სარეზერვო ასლები და შეზღუდვები.

9 წთ კითხვა

როცა საიტი სამუშაოს ვორკერს გადასცემს — ელფოსტის გაგზავნა, სურათის ზომის შეცვლა, შეკვეთის საფასურის ჩამოჭრა — ან ერთი სერვისი დანარჩენებს ატყობინებს, რომ რაღაც მოხდა, შეტყობინება რიგით ან შეტყობინებების ბროკერით გადის. პროექტს სამივე შეიძლება ჰქონდეს, თითოეული სერვისად ემატება: მიმოხილვა → სერვისები → სერვისის დამატება.

სერვისიროდის აირჩიოთ
Valkeyამოცანების მარტივი რიგები (Laravel-ის რიგები და Horizon, BullMQ, Celery, RQ) და მოვლენები Streams-ში — როცა მას უკვე იყენებთ ქეშისა და სესიებისთვის
NATSმსუბუქი შეტყობინებები სერვისებს შორის: მოვლენები, მოთხოვნა-პასუხი და მდგრადი ნაკადები JetStream-ით
RabbitMQკლასიკური შეტყობინებების ბროკერი: მარშრუტიზაცია exchange-ებით, დადასტურებები, განმეორებითი ცდები და 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-ში ინახავს; ვორკერი მათ სათითაოდ იღებს და წარუმატებლებს ხელახლა ცდის.
  • Streams მომხმარებელთა ჯგუფებით — XADD ნაკადს მოვლენას ამატებს, ჯგუფის მომხმარებლები მას XREADGROUP-ით კითხულობენ და XACK-ით ადასტურებენ. მოვლენები ინახება: გაჩერებული მომხმარებელი იქიდან აგრძელებს, სადაც შეჩერდა, დაუდასტურებელი მოვლენის ხელახლა აღება შეიძლება, ახალ ჯგუფს კი ნაკადის თავიდან წაკითხვა შეუძლია.
  • Pub/Sub — PUBLISH და SUBSCRIBE შეტყობინებას მხოლოდ იმ გამომწერებს აწვდის, ვინც იმ მომენტში დაკავშირებულია. შეტყობინება არ ინახება: გამომწერი, რომელიც გადაიტვირთება ან ჯერ არ დაკავშირებულა, მას ვერ მიიღებს. Pub/Sub მხოლოდ იქ გამოიყენეთ, სადაც დაკარგული შეტყობინება ზიანს არ მოიტანს (მაგალითად, სიგნალი «განახლება»), დანარჩენი ყველაფრისთვის კი — Streams ან რიგი.

Valkey ყოველდღე რეზერვდება, ისევე როგორც სხვა მონაცემთა ბაზები; წვდომის გახსნის შემთხვევაში მასთან დაკავშირება გარედანაც შეიძლება. იხილეთ მონაცემთა ბაზები.

NATS

NATS მსუბუქი, სწრაფი შეტყობინებების სისტემაა, ჩართული JetStream-ით:

  • გამოქვეყნება და გამოწერა — სერვისი აქვეყნებს თემაში, მაგალითად orders.created, და თემის ყველა გამომწერი შეტყობინებას იღებს. JetStream-ის გარეშე ეს პრინციპით «გაგზავნე და დაივიწყე» მუშაობს, როგორც ზემოთ აღწერილი Pub/Sub.
  • მოთხოვნა და პასუხი — ერთი სერვისი კითხულობს, მეორე პასუხობს. როცა რამდენიმე ინსტანსი რიგის ჯგუფად პასუხობს, NATS მოთხოვნებს მათ შორის ანაწილებს.
  • JetStream — მდგრადი ნაკადები: შეტყობინებები სერვისის დისკზე ინახება, მომხმარებელს (consumer) ახსოვს, რა წაიკითხა, და ყოველი შეტყობინება მიიწოდება სულ მცირე ერთხელ, სანამ არ დადასტურდება.
  • გასაღები-მნიშვნელობის და ობიექტების საცავი JetStream-ზე — მცირე საერთო პარამეტრების, ბლოკირებების ან ფაილებისთვის სერვისებს შორის.

ცვლადები. აპლიკაციის პირველი NATS კოდის ყველა სერვისს აძლევს:

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

ყოველი NATS სერვისი ასევე იძლევა RIVERVO_<NAME>_URL-ს იმავე ფორმის მისამართით — NAME არის სერვისის სახელი დიდი ასოებით, სადაც ტირეები _-ით არის შეცვლილი: სერვისი სახელით events იძლევა RIVERVO_EVENTS_URL-ს.

JetStream ნაკადებს სერვისის დისკზე ინახავს; მეხსიერებაში შენახულ ნაკადებს შეუძლიათ სერვისის მეხსიერების დაახლოებით მეოთხედი გამოიყენონ.

RabbitMQ

RabbitMQ 4.1 კლასიკური შეტყობინებების ბროკერია: მწარმოებლები აქვეყნებენ exchange-ებში, exchange-ები შეტყობინებებს მარშრუტიზაციის გასაღებებით რიგებში ანაწილებს, მომხმარებლები ყოველ შეტყობინებას ადასტურებენ, ხოლო უარყოფილი ან ვადაგასული შეტყობინება შეიძლება გადავიდეს 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-ს იმავე ფორმის მისამართით.

მართვის 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-სგან განსხვავებით, მათთვის გარედან წვდომა არ არის გათვალისწინებული. სერვისები, რომლებიც შეტყობინებებს აქვეყნებენ და იღებენ, იმავე აპლიკაციის სერვისებად მუშაობენ: ვებ-სერვისები, ფონური ვორკერები და დაგეგმილი ამოცანები.

იმავე ტიპის მეორე სერვისი

ჩვეულ სახელებს (REDIS_*, NATS_URL, AMQP_URL და RABBITMQ_*) აპლიკაციის მხოლოდ პირველი Valkey, NATS და RabbitMQ იღებს. იმავე ტიპის მომდევნო სერვისი მხოლოდ საკუთარ RIVERVO_<NAME>_URL-ს ამატებს; წაიკითხეთ ეს ცვლადი თქვენს კოდში ან ცვლადების ჩანართზე ჩვეულ სახელებს მისი მნიშვნელობები მიანიჭეთ. ცვლადები სერვისს მომდევნო განთავსებისას მიაღწევს — იხილეთ გარემოს ცვლადები.

Laravel

Valkey. ცვლადების ჩანართზე დააყენეთ:

QUEUE_CONNECTION=redis

გაუშვით php artisan queue:work — ან Horizon-ის შემთხვევაში php artisan horizon — ფონურ ვორკერად. იხილეთ Laravel.

RabbitMQ. Laravel-ს ჩაშენებული RabbitMQ დრაივერი არ აქვს, და Rivervo QUEUE_CONNECTION-ს თავისით არ ცვლის. Laravel-ის რიგებისთვის RabbitMQ-ის გამოსაყენებლად:

  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 და განათავსეთ. ვორკერი კვლავ php artisan queue:work რჩება.

NATS. NATS-ისთვის Laravel-ის ოფიციალური რიგის დრაივერი არ არსებობს. გამოიყენეთ PHP-ის NATS კლიენტი საკუთარ კოდში — მაგალითად, basis-company/nats — და მიეცით მას ჰოსტი, პორტი, მომხმარებელი და პაროლი NATS_URL-იდან. სანამ მასზე რამეს ააშენებთ, შეამოწმეთ, უჭერს თუ არა კლიენტი მხარს თქვენთვის საჭირო ფუნქციებს (JetStream, გასაღები-მნიშვნელობა).

Node.js

BullMQ (Valkey)

import { Queue, Worker } from 'bullmq'
import IORedis from 'ioredis'
 
const connection = new IORedis(process.env.REDIS_URL, { maxRetriesPerRequest: null })
 
// in the web service
const emails = new Queue('emails', { connection })
await emails.add('welcome', { userId: 42 }, { attempts: 3 })
 
// in the background worker
new Worker('emails', async (job) => {
  await sendWelcome(job.data.userId)
}, { connection })

BullMQ-ს სჭირდება maxRetriesPerRequest: null იმ კავშირზე, რომელსაც მისი ვორკერები იყენებენ.

Valkey Streams

import IORedis from 'ioredis'
 
const redis = new IORedis(process.env.REDIS_URL)
 
// producer
await redis.xadd('orders', '*', 'id', '42')
 
// consumer of the group «billing»
await redis.xgroup('CREATE', 'orders', 'billing', '0', 'MKSTREAM').catch((err) => {
  if (!String(err).includes('BUSYGROUP')) throw err // the group already exists
})
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()
 
// once: a stream for the subjects orders.* and a durable consumer
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 })
 
// producer
const js = nc.jetstream()
await js.publish('orders.created', jc.encode({ id: 42 }))
 
// consumer
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' } })
 
// producer
ch.sendToQueue('emails', Buffer.from(JSON.stringify({ userId: 42 })), { persistent: true })
 
// consumer: at most 10 unacknowledged messages at a time
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) // to the dead-letter exchange, if the queue has one
  }
})

ყოველმა სერვისმა, რომელიც რიგს აცხადებს, ის ერთი და იმავე არგუმენტებით უნდა გამოაცხადოს.

Python

Celery (Valkey ან RabbitMQ)

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

გაუშვით celery -A tasks worker --loglevel=info ფონურ ვორკერად. 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)

ვორკერი: 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"})
 
# producer
ch.basic_publish(exchange="", routing_key="emails",
                 body=json.dumps({"user_id": 42}),
                 properties=pika.BasicProperties(delivery_mode=2))
 
# consumer
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()

ერთზე მეტჯერ მიწოდება

რიგები და ბროკერები შეტყობინებას ხელახლა აწვდიან, როცა ვორკერი მის დადასტურებამდე ჩერდება — განთავსების, გადატვირთვის ან აღდგენის დროს. დაწერეთ მომხმარებლები ისე, რომ ერთი და იმავე შეტყობინების ორჯერ დამუშავებამ ზიანი არ მოიტანოს: შეინახეთ ყოველი დამუშავებული შეტყობინების ID ან გახადეთ თავად მოქმედება განმეორებადი (მაგალითად, «სტატუსის დაყენება: გადახდილია» ნაცვლად «გადახდის დამატებისა»).

რესურსები და ფასი

სერვისისაწყისი რესურსებიმინიმალური მეხსიერება
NATS256 MB მეხსიერება · 1 CPU ბირთვი · 5 GB დისკი256 MB
RabbitMQ1 GB მეხსიერება · 1 CPU ბირთვი · 10 GB დისკი512 MB

თითოეულის ფასი, როგორც ნებისმიერი სერვისის, მისი მეხსიერების, CPU-სა და დისკის მიხედვით ითვლება — იხილეთ პროექტის სერვისები. რესურსების შეცვლა მოგვიანებით სერვისის პარამეტრებში შეიძლება.

სარეზერვო ასლები და აღდგენა

NATS და RabbitMQ ყოველდღე რეზერვდება; ვინახავთ ბოლო 7 დღისა და 4 კვირის ასლებს, ისევე როგორც სხვა სერვისებისთვის.

  • სარეზერვო ასლი სერვისის მონაცემთა ფაილებს მისი მუშაობის დროს აკოპირებს. RabbitMQ-ის შემთხვევაში იმავე ასლში მისი განსაზღვრებების ექსპორტიც შედის: მომხმარებლები, ვირტუალური ჰოსტები, რიგები, exchange-ები, ბმები და პოლიტიკები.
  • ზუსტ მომენტზე აღდგენა არ არის — ეს მხოლოდ PostgreSQL-ისა და MySQL-ისთვისაა. აღადგენთ ერთ-ერთ ყოველდღიურ ასლს.
  • აღდგენა სერვისს მცირე ხნით აჩერებს, ფაილებს უკან აბრუნებს და მას ხელახლა უშვებს. შეტყობინებები, რომლებიც სარეზერვო ასლის შექმნის დროს შემოვიდა ან დადასტურდა, შეიძლება დაიკარგოს ან ხელახლა მიიწოდოს — ესეც ერთი მიზეზია, რომ მომხმარებლები განმეორებისთვის უსაფრთხო გახადოთ.
  • RabbitMQ-ის შემთხვევაში, თუ კოპირებული ფაილებით გაშვება ვერ ხერხდება, სერვისი მხოლოდ განსაზღვრებებით ეშვება: რიგები, exchange-ები და მომხმარებლები ადგილზეა, მაგრამ სარეზერვო ასლის შეტყობინებები იკარგება.

ტექნიკური მომსახურება და გადატანა

NATS-სა და RabbitMQ-ს ტექნიკური მომსახურების დრო არ ეყენება. ისინი სხვა სერვერზე ავტომატურად არ გადაიტანება; თუ ეს ოდესმე დასჭირდება, მხარდაჭერა ამას თქვენთან შეთანხმებით მოაწყობს.

ჯერ კიდევ გაქვთ კითხვები?

მოგვწერეთ ჩატში — AI მაშინვე გპასუხობთ, საჭიროებისას კი ინჟინერი უერთდება, დღე-ღამის ნებისმიერ დროს.

მხარდაჭერასთან დაკავშირება