להתחיל

אירועים ותורים: Valkey, ‏NATS ו-RabbitMQ.

משימות רקע, אירועים והודעות בין השירותים של אפליקציה: מתי לבחור Valkey, ‏NATS או RabbitMQ, משתני החיבור, דוגמאות ל-Laravel, ל-Node.js ול-Python, משאבים, גיבויים ומגבלות.

9 דקות קריאה

כשאתר מעביר עבודה ל-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 עם קבוצות צרכנים — XADD מוסיף אירוע לזרם, צרכנים של קבוצה קוראים אותו עם XREADGROUP ומאשרים אותו עם XACK. האירועים נשמרים: צרכן שנעצר ממשיך מאיפה שהפסיק, אירוע שלא אושר אפשר לקחת שוב, וקבוצה חדשה יכולה לקרוא את הזרם מההתחלה.
  • Pub/Sub — PUBLISH ו-SUBSCRIBE מעבירים הודעה רק למנויים שמחוברים באותו רגע. ההודעה לא נשמרת: מנוי שמופעל מחדש או שעדיין לא התחבר מפספס אותה. השתמשו ב-Pub/Sub רק במקום שבו הודעה שאבדה לא מזיקה (למשל אות «רענון»), וב-Streams או בתור לכל השאר.

Valkey מגובה כל יום כמו שאר מסדי הנתונים; אפשר גם להגיע אליו מבחוץ כשפותחים גישה. ראו מסדי נתונים.

NATS

NATS היא מערכת הודעות קלה ומהירה, עם JetStream מופעל:

  • פרסום והרשמה — שירות מפרסם לנושא כמו orders.created, וכל מנוי של הנושא מקבל את ההודעה. בלי JetStream זה «שלח ושכח», כמו Pub/Sub למעלה.
  • בקשה ותשובה — שירות שואל, ושירות אחר עונה. כשכמה מופעים עונים כקבוצת תור, NATS מפזר ביניהם את הבקשות.
  • JetStream — זרמים עמידים: ההודעות נשמרות על הדיסק של השירות, צרכן זוכר מה הוא קרא, וכל הודעה נמסרת לפחות פעם אחת עד שהיא מאושרת.
  • מאגר מפתח-ערך ומאגר אובייקטים שבנויים על 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, צרכנים מאשרים כל הודעה, והודעה שנדחתה או שפג תוקפה יכולה לעבור ל-exchange מסוג dead-letter. לתורים שההודעות בהם צריכות לשרוד הפעלה מחדש, השתמשו בתורי 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 הוא ה-virtual host ברירת המחדל /, בכתיב שכתובות חיבור דורשות. כל שירות 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, גישה מבחוץ לא מוצעת להם. השירותים שמפרסמים וצורכים הודעות רצים כשירותים של אותה אפליקציה: שירותי web, ‏workers ברקע ומשימות מתוזמנות.

שירות שני מאותו סוג

רק ה-Valkey, ה-NATS וה-RabbitMQ הראשונים של האפליקציה מקבלים את השמות הרגילים (REDIS_*, NATS_URL, AMQP_URL ו-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, מפתח-ערך) לפני שאתם בונים עליו.

Node.js

BullMQ (Valkey)

import { Queue, Worker } from 'bullmq'
import IORedis from 'ioredis'
 
const connection = new IORedis(process.env.REDIS_URL, { maxRetriesPerRequest: null })
 
// בשירות ה-web
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 בחיבור שה-workers שלו משתמשים בו.

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) // ל-exchange מסוג dead-letter, אם יש לתור כזה
  }
})

כל שירות שמצהיר על התור צריך להצהיר עליו עם אותם ארגומנטים.

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 נעצר לפני שאישר אותה — במהלך פריסה, הפעלה מחדש או שחזור. כתבו צרכנים כך שטיפול באותה הודעה פעמיים לא יזיק: שמרו את המזהה של כל הודעה שעובדה, או הפכו את הפעולה עצמה לניתנת לחזרה (למשל «לקבוע את הסטטוס כשולם» במקום «להוסיף תשלום»).

משאבים ומחיר

שירותמתחיל עםזיכרון מינימלי
NATS256 MB זיכרון · ליבת מעבד אחת · 5 GB דיסק256 MB
RabbitMQ1 GB זיכרון · ליבת מעבד אחת · 10 GB דיסק512 MB

כל אחד מתומחר לפי הזיכרון, המעבד והדיסק שלו כמו כל שירות — ראו שירותים של פרויקט. אפשר לשנות את המשאבים מאוחר יותר בהגדרות של השירות.

גיבויים ושחזור

NATS ו-RabbitMQ מגובים כל יום; אנחנו שומרים את 7 הימים ו-4 השבועות האחרונים, כמו בשאר השירותים.

  • הגיבוי מעתיק את קובצי הנתונים של השירות בזמן שהוא רץ. ב-RabbitMQ אותו גיבוי מכיל גם ייצוא של ההגדרות שלו: משתמשים, virtual hosts, תורים, exchanges, ‏bindings ומדיניות.
  • אין שחזור לרגע מדויק — זה קיים רק ב-PostgreSQL וב-MySQL. משחזרים את אחד העותקים היומיים.
  • שחזור עוצר את השירות לזמן קצר, מחזיר את הקבצים ומפעיל אותו שוב. הודעות שהגיעו או אושרו בסביבות זמן הגיבוי עלולות לחסור או להימסר שוב — עוד סיבה לכתוב צרכנים שבטוח לחזור עליהם.
  • ב-RabbitMQ, אם אי אפשר להפעיל את הקבצים שהועתקו, השירות עולה עם ההגדרות בלבד: התורים, ה-exchanges והמשתמשים קיימים, אבל ההודעות מהגיבוי אובדות.

תחזוקה והעברות

ל-NATS ול-RabbitMQ אין זמן תחזוקה להגדרה. הם לא מועברים לשרת אחר אוטומטית; אם זה יידרש אי פעם, התמיכה תתאם זאת איתכם.

עדיין תקועים?

דברו איתנו בצ׳אט — AI עונה מיד, ומהנדס מצטרף כשצריך, בכל שעה ביממה.

פנייה לתמיכה