शुरू करें

इवेंट और क्यू: Valkey, NATS और RabbitMQ।

ऐप्लिकेशन की सर्विसों के बीच बैकग्राउंड जॉब, इवेंट और संदेश: Valkey, NATS या RabbitMQ कब चुनें, कनेक्शन वेरिएबल, Laravel, Node.js और Python के उदाहरण, रिसोर्स, बैकअप और सीमाएँ।

11 मिनट में पढ़ें

जब कोई साइट किसी वर्कर को काम सौंपती है — ईमेल भेजना, इमेज का साइज़ बदलना, ऑर्डर का पैसा लेना — या एक सर्विस दूसरी सर्विसों को बताती है कि कुछ हुआ है, तो संदेश क्यू या मैसेज ब्रोकर से होकर जाता है। एक प्रोजेक्ट में इनमें से तीन हो सकते हैं, हर एक सर्विस के रूप में जोड़ा जाता है: ओवरव्यू → सर्विस → सर्विस जोड़ें।

सर्विसइसे कब चुनें
Valkeyसरल जॉब क्यू (Laravel क्यू और Horizon, BullMQ, Celery, RQ), और Streams में इवेंट — जब आप इसे पहले से कैश और सेशन के लिए इस्तेमाल करते हैं
NATSसर्विसों के बीच हल्की मैसेजिंग: इवेंट, रिक्वेस्ट और रिप्लाई, और JetStream के साथ टिकाऊ स्ट्रीम
RabbitMQक्लासिक मैसेज ब्रोकर: एक्सचेंज से रूटिंग, एक्नॉलेजमेंट, दोबारा कोशिश और डेड-लेटरिंग, क्वोरम क्यू

अगर आप पक्का नहीं हैं, तो बैकग्राउंड जॉब के लिए Valkey से शुरू करें: ज़्यादातर फ़्रेमवर्क इसे शुरू से सपोर्ट करते हैं। RabbitMQ तब चुनें जब संदेशों को कई क्यू के बीच रूट करना हो और कोई भी खोना नहीं चाहिए, और NATS तब जब सर्विस बहुत सारे छोटे संदेशों का लेन-देन करती हैं या एक-दूसरे से जवाब माँगती हैं।

Valkey: जॉब क्यू और Streams

Valkey एक Redis-कम्पैटिबल स्टोर है — वही मैनेज्ड सर्विस जो डेटाबेस में है। ऐप्लिकेशन का पहला Valkey हर कोड सर्विस को REDIS_URL, REDIS_HOST, REDIS_PORT और REDIS_PASSWORD देता है; हर Valkey अपना RIVERVO_<NAME>_URL भी देता है।

इसके ज़रिए संदेश भेजने के तीन तरीके:

  • जॉब क्यू — redis ड्राइवर और Horizon के साथ Laravel क्यू, 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 — टिकाऊ स्ट्रीम: संदेश सर्विस की डिस्क पर सेव होते हैं, कंज़्यूमर याद रखता है कि उसने क्या पढ़ा है, और हर संदेश एक्नॉलेज होने तक कम से कम एक बार डिलीवर होता है।
  • JetStream पर बना की-वैल्यू और ऑब्जेक्ट स्टोर — सर्विसों के बीच छोटी साझा सेटिंग्स, लॉक या फ़ाइलों के लिए।

वेरिएबल। ऐप्लिकेशन का पहला NATS हर कोड सर्विस को देता है:

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

हर NATS सर्विस उसी तरह के पते के साथ RIVERVO_<NAME>_URL भी देती है — NAME कैपिटल अक्षरों में सर्विस का नाम है, जिसमें डैश _ में बदल जाते हैं: events नाम की सर्विस RIVERVO_EVENTS_URL देती है।

JetStream अपनी स्ट्रीम सर्विस की डिस्क पर रखता है; मेमोरी में रखी स्ट्रीम सर्विस की लगभग एक चौथाई मेमोरी इस्तेमाल कर सकती हैं।

RabbitMQ

RabbitMQ 4.1 एक क्लासिक मैसेज ब्रोकर है: प्रोड्यूसर एक्सचेंज पर पब्लिश करते हैं, एक्सचेंज रूटिंग की से संदेशों को क्यू तक भेजते हैं, कंज़्यूमर हर संदेश को एक्नॉलेज करते हैं, और रिजेक्ट या एक्सपायर हुआ संदेश डेड-लेटर एक्सचेंज में जा सकता है। जिन क्यू के संदेशों को रीस्टार्ट के बाद भी बचे रहना चाहिए, उनके लिए क्वोरम क्यू (आर्ग्युमेंट x-queue-type: quorum) इस्तेमाल करें और संदेशों को persistent के रूप में पब्लिश करें।

वेरिएबल। ऐप्लिकेशन का पहला RabbitMQ हर कोड सर्विस को देता है:

वेरिएबलवैल्यू
AMQP_URLamqp://<user>:<password>@<service name>:5672/%2f
RABBITMQ_HOSTसर्विस का नाम
RABBITMQ_PORT5672
RABBITMQ_USER, RABBITMQ_PASSWORDयूज़र और पासवर्ड
RABBITMQ_VHOST/

AMQP_URL के आखिर में %2f डिफ़ॉल्ट वर्चुअल होस्ट / है, उस तरह लिखा गया जैसा कनेक्शन पतों में ज़रूरी है। हर 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 के उलट, इनके लिए बाहर से एक्सेस नहीं दिया जाता। संदेश पब्लिश और कंज़्यूम करने वाली सर्विस उसी ऐप्लिकेशन की सर्विस के रूप में चलती हैं: वेब सर्विस, बैकग्राउंड वर्कर और शेड्यूल्ड जॉब।

उसी तरह की दूसरी सर्विस

ऐप्लिकेशन के सिर्फ़ पहले Valkey, NATS और RabbitMQ को सामान्य नाम (REDIS_*, NATS_URL, AMQP_URL और 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. config/queue.php में rabbitmq कनेक्शन वैसे जोड़ें जैसे आपके वर्ज़न के लिए पैकेज का 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 })
 
// वेब सर्विस में
const emails = new Queue('emails', { connection })
await emails.add('welcome', { userId: 42 }, { attempts: 3 })
 
// बैकग्राउंड वर्कर में
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)
 
// प्रोड्यूसर
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) // डेड-लेटर एक्सचेंज में, अगर क्यू में वह है
  }
})

क्यू घोषित करने वाली हर सर्विस को उसे उन्हीं आर्ग्युमेंट के साथ घोषित करना चाहिए।

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 को बैकग्राउंड वर्कर के रूप में चलाएँ। Celery amqp:// पते जैसे हैं वैसे ही स्वीकार करता है। RabbitMQ के साथ Celery के नए वर्ज़न क्वोरम क्यू घोषित कर सकते हैं (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"})
 
# प्रोड्यूसर
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()

एक से ज़्यादा बार डिलीवरी

जब कोई वर्कर पुष्टि करने से पहले रुक जाता है — डिप्लॉय, रीस्टार्ट या रीस्टोर के दौरान — तो क्यू और ब्रोकर संदेश फिर से डिलीवर करते हैं। कंज़्यूमर ऐसे लिखें कि एक ही संदेश को दो बार हैंडल करने से कोई नुकसान न हो: हर प्रोसेस हुए संदेश का ID रखें, या खुद काम को दोहराने लायक बनाएँ (जैसे «एक भुगतान जोड़ें» की जगह «स्टेटस को paid पर सेट करें»)।

रिसोर्स और कीमत

सर्विसशुरुआतन्यूनतम मेमोरी
NATS256 MB मेमोरी · 1 CPU कोर · 5 GB डिस्क256 MB
RabbitMQ1 GB मेमोरी · 1 CPU कोर · 10 GB डिस्क512 MB

हर एक की कीमत किसी भी सर्विस की तरह उसकी मेमोरी, CPU और डिस्क से तय होती है — देखें प्रोजेक्ट की सर्विस। रिसोर्स बाद में सर्विस की सेटिंग्स में बदले जा सकते हैं।

बैकअप और रीस्टोर

NATS और RabbitMQ का बैकअप हर दिन होता है; दूसरी सर्विसों की तरह हम पिछले 7 दिन और 4 हफ़्ते रखते हैं।

  • बैकअप सर्विस के चलते समय उसकी डेटा फ़ाइलें कॉपी करता है। RabbitMQ के लिए उसी बैकअप में उसकी डेफ़िनिशन का एक्सपोर्ट भी होता है: यूज़र, वर्चुअल होस्ट, क्यू, एक्सचेंज, बाइंडिंग और पॉलिसी।
  • किसी सटीक समय पर रीस्टोर नहीं होता — यह सिर्फ़ PostgreSQL और MySQL के लिए है। आप रोज़ की कॉपियों में से एक रीस्टोर करते हैं।
  • रीस्टोर सर्विस को थोड़ी देर के लिए रोकता है, फ़ाइलें वापस रखता है और उसे फिर से शुरू करता है। बैकअप के समय के आसपास आए या एक्नॉलेज हुए संदेश गायब हो सकते हैं या फिर से डिलीवर हो सकते हैं — कंज़्यूमर को दोहराने के लिए सुरक्षित बनाने की एक और वजह।
  • RabbitMQ के लिए, अगर कॉपी की गई फ़ाइलों से सर्विस शुरू नहीं हो पाती, तो वह सिर्फ़ डेफ़िनिशन के साथ शुरू होती है: क्यू, एक्सचेंज और यूज़र मौजूद रहते हैं, लेकिन बैकअप के संदेश खो जाते हैं।

मेंटेनेंस और ट्रांसफ़र

NATS और RabbitMQ में मेंटेनेंस का कोई समय सेट नहीं करना होता। इन्हें अपने आप दूसरे सर्वर पर नहीं ले जाया जाता; अगर कभी इसकी ज़रूरत पड़े, तो सपोर्ट टीम आपके साथ मिलकर इसका इंतज़ाम करती है।

अब भी कोई सवाल है?

हमसे चैट करें — AI तुरंत जवाब देता है और ज़रूरत पड़ने पर इंजीनियर जुड़ जाता है, दिन के किसी भी समय।

सपोर्ट से संपर्क करें