Hemen başlayın

Olaylar ve kuyruklar: Valkey, NATS ve RabbitMQ.

Bir uygulamanın servisleri arasında arka plan işleri, olaylar ve mesajlar: Valkey, NATS veya RabbitMQ ne zaman seçilir, bağlantı değişkenleri, Laravel, Node.js ve Python örnekleri, kaynaklar, yedekler ve sınırlar.

9 DK OKUMA

Bir site işi bir işçiye devrettiğinde — bir e-posta göndermek, bir görseli yeniden boyutlandırmak, bir siparişin ödemesini almak — ya da bir servis diğerlerine bir şey olduğunu bildirdiğinde, mesaj bir kuyruktan veya bir mesaj aracısından geçer. Bir projede üçü de olabilir; her biri bir servis olarak eklenir: Genel bakış → Servisler → Servis ekle.

ServisNe için seçilir
Valkeybasit iş kuyrukları (Laravel kuyrukları ve Horizon, BullMQ, Celery, RQ) ve Streams'teki olaylar — onu zaten önbellek ve oturumlar için kullanıyorsanız
NATSservisler arasında hafif mesajlaşma: olaylar, istek ve yanıt ve JetStream ile kalıcı akışlar
RabbitMQklasik bir mesaj aracısı: exchange'ler üzerinden yönlendirme, onaylar, yeniden denemeler ve dead-letter, quorum kuyrukları

Emin değilseniz arka plan işleri için Valkey ile başlayın: çoğu framework onu kutudan çıktığı gibi destekler. Mesajların birçok kuyruk arasında yönlendirilmesi ve hiçbirinin kaybolmaması gerektiğinde RabbitMQ'yu, servisler çok sayıda küçük mesaj alışverişi yaptığında veya birbirinden yanıt istediğinde NATS'i seçin.

Valkey: iş kuyrukları ve Streams

Valkey, Redis uyumlu bir depodur — Veritabanları bölümündekiyle aynı yönetilen servis. Uygulamanın ilk Valkey'i her kod servisine REDIS_URL, REDIS_HOST, REDIS_PORT ve REDIS_PASSWORD verir; her Valkey ayrıca kendi RIVERVO_<NAME>_URL değişkenini verir.

Onun üzerinden mesaj göndermenin üç yolu:

  • İş kuyrukları — redis sürücülü Laravel kuyrukları ve Horizon, BullMQ, Celery, RQ. Kütüphane işleri Valkey'de tutar; bir işçi onları tek tek alır ve başarısız olanları yeniden dener.
  • Tüketici gruplu Streams — XADD bir akışa olay ekler, bir grubun tüketicileri onu XREADGROUP ile okur ve XACK ile onaylar. Olaylar saklanır: durdurulmuş bir tüketici kaldığı yerden devam eder, onaylanmamış bir olay yeniden alınabilir ve yeni bir grup akışı baştan okuyabilir.
  • Pub/Sub — PUBLISH ve SUBSCRIBE, bir mesajı yalnızca o anda bağlı olan abonelere iletir. Mesaj saklanmaz: yeniden başlayan veya henüz bağlanmamış bir abone onu kaçırır. Pub/Sub'ı yalnızca kaybolan bir mesajın zarar vermediği yerlerde (örneğin bir «yenile» sinyali), geri kalan her şey için Streams'i veya bir kuyruğu kullanın.

Valkey diğer veritabanları gibi her gün yedeklenir; erişimi açtığınızda dışarıdan da ulaşılabilir. Bkz. Veritabanları.

NATS

NATS, JetStream açık olan hafif ve hızlı bir mesajlaşma sistemidir:

  • Yayınla ve abone ol — bir servis orders.created gibi bir konuya yayınlar, konunun her abonesi mesajı alır. JetStream olmadan bu, yukarıdaki Pub/Sub gibi gönder-ve-unut şeklindedir.
  • İstek ve yanıt — bir servis sorar, diğeri yanıtlar. Birkaç örnek bir kuyruk grubu olarak yanıtladığında NATS istekleri aralarında dağıtır.
  • JetStream — kalıcı akışlar: mesajlar servisin diskinde saklanır, bir tüketici neyi okuduğunu hatırlar ve her mesaj onaylanana kadar en az bir kez iletilir.
  • JetStream üzerine kurulu anahtar-değer ve nesne deposu — servisler arasında küçük ortak ayarlar, kilitler veya dosyalar için.

Değişkenler. Uygulamanın ilk NATS'i her kod servisine şunu verir:

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

Her NATS servisi ayrıca aynı biçimde bir adresle RIVERVO_<NAME>_URL verir — NAME, servisin büyük harflerle yazılmış, tireleri _ yapılmış adıdır: events adlı bir servis RIVERVO_EVENTS_URL verir.

JetStream akışlarını servisin diskinde tutar; bellekte tutulan akışlar servisin belleğinin yaklaşık dörtte birini kullanabilir.

RabbitMQ

RabbitMQ 4.1 klasik bir mesaj aracısıdır: üreticiler exchange'lere yayınlar, exchange'ler mesajları yönlendirme anahtarlarına göre kuyruklara yönlendirir, tüketiciler her mesajı onaylar ve reddedilen veya süresi dolan bir mesaj bir dead-letter exchange'ine gidebilir. Mesajları yeniden başlatmadan sonra korunması gereken kuyruklar için quorum kuyruklarını (x-queue-type: quorum argümanı) kullanın ve mesajları kalıcı olarak yayınlayın.

Değişkenler. Uygulamanın ilk RabbitMQ'su her kod servisine şunları verir:

DeğişkenDeğer
AMQP_URLamqp://<user>:<password>@<service name>:5672/%2f
RABBITMQ_HOSTservisin adı
RABBITMQ_PORT5672
RABBITMQ_USER, RABBITMQ_PASSWORDkullanıcı ve şifre
RABBITMQ_VHOST/

AMQP_URL sonundaki %2f, bağlantı adreslerinin gerektirdiği şekilde yazılmış varsayılan sanal sunucu /'dir. Her RabbitMQ servisi ayrıca aynı biçimde bir adresle kendi RIVERVO_<NAME>_URL değişkenini verir.

Yönetim API'si. Yönetim HTTP API'si uygulamanın özel ağı içinde 15672 portunda dinler: uygulamanın servisleri ona aynı kullanıcı ve şifreyle http://<service name>:15672 adresinden ulaşır, örneğin:

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

İnternette yönetim sayfası yoktur. Paneldeki servis sayfası kuyruklarının kısa, salt okunur bir listesini gösterir: hazır mesajlar, onaylanmamış mesajlar ve tüketiciler.

Yalnızca dahili

NATS ve RabbitMQ'nun herkese açık adresi yoktur ve uygulamanın dışından — bilgisayarınızdan, başka bir sunucudan veya başka bir uygulamadan — erişilemez. PostgreSQL, MySQL ve Valkey'den farklı olarak onlar için dışarıdan erişim sunulmaz. Mesaj yayınlayan ve tüketen servisler aynı uygulamanın servisleri olarak çalışır: web servisleri, arka plan işçileri ve zamanlanmış işler.

Aynı türden ikinci servis

Olağan adları (REDIS_*, NATS_URL, AMQP_URL ve RABBITMQ_*) yalnızca uygulamanın ilk Valkey'i, NATS'i ve RabbitMQ'su alır. Aynı türden sonraki yalnızca kendi RIVERVO_<NAME>_URL değişkenini ekler; kodunuzda o değişkeni okuyun ya da Değişkenler sekmesinde olağan adları onun değerlerine ayarlayın. Değişkenler bir servise bir sonraki yayına almasıyla ulaşır — bkz. Ortam değişkenleri.

Laravel

Valkey. Değişkenler sekmesinde ayarlayın:

QUEUE_CONNECTION=redis

php artisan queue:work'ü — ya da Horizon ile php artisan horizon'u — bir arka plan işçisi olarak çalıştırın. Bkz. Laravel.

RabbitMQ. Laravel'de yerleşik bir RabbitMQ sürücüsü yoktur ve Rivervo QUEUE_CONNECTION'ı kendiliğinden değiştirmez. Laravel kuyrukları için RabbitMQ kullanmak için:

  1. Paketi kurun: composer require vladimir-yuldashev/laravel-queue-rabbitmq.
  2. rabbitmq bağlantısını, paketin README'sinin sürümünüz için gösterdiği şekilde config/queue.php dosyasına ekleyin. Uygulamada zaten bulunan RABBITMQ_HOST, RABBITMQ_PORT, RABBITMQ_USER, RABBITMQ_PASSWORD ve RABBITMQ_VHOST değişkenlerini okur:
'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. Değişkenler sekmesinde QUEUE_CONNECTION=rabbitmq ayarlayın ve yayına alın. İşçi php artisan queue:work olarak kalır.

NATS. NATS için resmî bir Laravel kuyruk sürücüsü yoktur. Kendi kodunuzda PHP için bir NATS istemcisi kullanın — örneğin basis-company/nats — ve ona NATS_URL'deki sunucuyu, portu, kullanıcıyı ve şifreyi verin. Üzerine bir şey kurmadan önce istemcinin ihtiyaç duyduğunuz özellikleri (JetStream, anahtar-değer) desteklediğini kontrol edin.

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, işçilerinin kullandığı bağlantıda maxRetriesPerRequest: null gerektirir.

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)
    }
  }
}

Okunmuş ama onaylanmamış bir kayıt grupta beklemede kalır; XAUTOCLAIM onu başka bir tüketiciye verir.

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()
}

İstek ve yanıt: bir servis nc.subscribe('prices.get', { queue: 'prices', callback: (err, msg) => msg.respond(jc.encode(price)) }) ile yanıtlar, diğeri await nc.request('prices.get', jc.encode({ sku: 'A1' }), { timeout: 2000 }) ile sorar.

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
  }
})

Kuyruğu tanımlayan her servis onu aynı argümanlarla tanımlamalıdır.

Python

Celery (Valkey veya 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 komutunu bir arka plan işçisi olarak çalıştırın. Celery amqp:// adreslerini olduğu gibi kabul eder. RabbitMQ ile yeni Celery sürümleri quorum kuyrukları tanımlayabilir (task_default_queue_type = "quorum") — sürümünüz için Celery belgelerine bakın.

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)

İşçi: 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()

Birden fazla kez iletilen mesajlar

Kuyruklar ve aracılar, bir işçi mesajı onaylamadan önce durduğunda — bir yayına alma, bir yeniden başlatma veya bir geri yükleme sırasında — mesajı yeniden iletir. Tüketicileri aynı mesajı iki kez işlemenin zarar vermeyeceği şekilde yazın: işlenen her mesajın kimliğini saklayın ya da işlemin kendisini tekrarlanabilir yapın (örneğin «bir ödeme ekle» yerine «durumu ödendi yap»).

Kaynaklar ve fiyat

ServisBaşlangıçEn az bellek
NATS256 MB bellek · 1 CPU çekirdeği · 5 GB disk256 MB
RabbitMQ1 GB bellek · 1 CPU çekirdeği · 10 GB disk512 MB

Her biri herhangi bir servis gibi belleğine, CPU'suna ve diskine göre fiyatlandırılır — bkz. Bir projenin servisleri. Kaynaklar daha sonra servisin Ayarlar bölümünden değiştirilebilir.

Yedekler ve geri yükleme

NATS ve RabbitMQ diğer servisler gibi her gün yedeklenir; son 7 günü ve 4 haftayı saklarız.

  • Yedek, servis çalışırken veri dosyalarını kopyalar. RabbitMQ için aynı yedek tanımlarının bir dışa aktarımını da içerir: kullanıcılar, sanal sunucular, kuyruklar, exchange'ler, bağlamalar ve politikalar.
  • Tam bir ana geri yükleme yoktur — bu yalnızca PostgreSQL ve MySQL içindir. Günlük kopyalardan birini geri yüklersiniz.
  • Bir geri yükleme servisi kısa bir süre durdurur, dosyaları geri koyar ve yeniden başlatır. Yedek zamanı civarında gelen veya onaylanan mesajlar eksik olabilir ya da yeniden iletilebilir — tüketicileri tekrara karşı güvenli yapmak için bir neden daha.
  • RabbitMQ için kopyalanan dosyalar başlatılamazsa servis yalnızca tanımlarla başlar: kuyruklar, exchange'ler ve kullanıcılar oradadır, ancak yedekteki mesajlar kaybolur.

Bakım ve taşımalar

NATS ve RabbitMQ için ayarlanacak bir bakım zamanı yoktur. Otomatik olarak başka bir sunucuya taşınmazlar; bu bir gün gerekirse destek ekibi bunu sizinle birlikte düzenler.

Hâlâ takıldınız mı?

Bizimle sohbet edin — AI hemen yanıt verir, gerektiğinde günün her saati bir mühendis katılır.

Destekle iletişime geçin