Ξεκίνα

Γεγονότα και ουρές: Valkey, NATS και RabbitMQ.

Εργασίες στο παρασκήνιο, γεγονότα και μηνύματα ανάμεσα στις υπηρεσίες μιας εφαρμογής: πότε να επιλέξεις Valkey, NATS ή RabbitMQ, οι μεταβλητές σύνδεσης, παραδείγματα για Laravel, Node.js και Python, πόροι, backup και όρια.

11 ΛΕΠΤΑ ΑΝΑΓΝΩΣΗΣ

Όταν μια ιστοσελίδα αναθέτει δουλειά σε έναν worker — να στείλει email, να αλλάξει μέγεθος σε μια εικόνα, να χρεώσει μια παραγγελία — ή όταν μια υπηρεσία λέει στις άλλες ότι κάτι συνέβη, το μήνυμα περνά από μια ουρά ή έναν message broker. Ένα project μπορεί να έχει τρία από αυτά, το καθένα ως υπηρεσία: Επισκόπηση → Υπηρεσίες → Προσθήκη υπηρεσίας.

ΥπηρεσίαΕπίλεξέ την για
Valkeyαπλές ουρές εργασιών (ουρές Laravel και Horizon, BullMQ, Celery, RQ) και γεγονότα σε Streams — όταν το χρησιμοποιείς ήδη για cache και sessions
NATSελαφριά ανταλλαγή μηνυμάτων ανάμεσα σε υπηρεσίες: γεγονότα, αίτημα και απάντηση, και μόνιμα streams με JetStream
RabbitMQκλασικός message broker: δρομολόγηση μέσω exchanges, επιβεβαιώσεις, επαναλήψεις και dead-lettering, quorum queues

Αν δεν είσαι σίγουρος, ξεκίνα με Valkey για εργασίες στο παρασκήνιο: τα περισσότερα frameworks το υποστηρίζουν έτοιμο. Επίλεξε RabbitMQ όταν τα μηνύματα πρέπει να δρομολογούνται ανάμεσα σε πολλές ουρές και κανένα δεν πρέπει να χαθεί, και NATS όταν οι υπηρεσίες ανταλλάσσουν πολλά μικρά μηνύματα ή ζητούν απαντήσεις η μία από την άλλη.

Valkey: ουρές εργασιών και Streams

Το Valkey είναι αποθήκευση συμβατή με Redis — η ίδια διαχειριζόμενη υπηρεσία με αυτήν στις Βάσεις δεδομένων. Το πρώτο Valkey της εφαρμογής δίνει σε κάθε υπηρεσία κώδικα τα REDIS_URL, REDIS_HOST, REDIS_PORT και REDIS_PASSWORD· κάθε Valkey δίνει επίσης το δικό του RIVERVO_<NAME>_URL.

Τρεις τρόποι να στέλνεις μηνύματα μέσα από αυτό:

  • Ουρές εργασιών — ουρές Laravel με τον driver redis και Horizon, BullMQ, Celery, RQ. Η βιβλιοθήκη κρατά τις εργασίες στο Valkey· ένας worker τις παίρνει μία-μία και ξαναδοκιμάζει όσες αποτυγχάνουν.
  • Streams με consumer groups — το XADD προσθέτει ένα γεγονός σε ένα stream, οι consumers μιας ομάδας το διαβάζουν με XREADGROUP και το επιβεβαιώνουν με XACK. Τα γεγονότα αποθηκεύονται: ένας consumer που σταμάτησε συνεχίζει από εκεί που έμεινε, ένα γεγονός που δεν επιβεβαιώθηκε μπορεί να ληφθεί ξανά, και μια νέα ομάδα μπορεί να διαβάσει το stream από την αρχή.
  • Pub/Sub — τα PUBLISH και SUBSCRIBE παραδίδουν ένα μήνυμα μόνο στους συνδρομητές που είναι συνδεδεμένοι εκείνη τη στιγμή. Το μήνυμα δεν αποθηκεύεται: ένας συνδρομητής που κάνει επανεκκίνηση ή δεν έχει συνδεθεί ακόμη το χάνει. Χρησιμοποίησε Pub/Sub μόνο όπου ένα χαμένο μήνυμα δεν κάνει ζημιά (για παράδειγμα ένα σήμα «ανανέωσης») και Streams ή ουρά για όλα τα υπόλοιπα.

Για το Valkey κρατάμε backup κάθε μέρα όπως και για τις άλλες βάσεις δεδομένων· είναι επίσης προσβάσιμο από έξω όταν ανοίξεις την πρόσβαση. Δες Βάσεις δεδομένων.

NATS

Το NATS είναι ένα ελαφρύ, γρήγορο σύστημα ανταλλαγής μηνυμάτων, με ενεργοποιημένο το JetStream:

  • Δημοσίευση και συνδρομή — μια υπηρεσία δημοσιεύει σε ένα subject όπως orders.created και κάθε συνδρομητής του subject παίρνει το μήνυμα. Χωρίς JetStream αυτό είναι fire-and-forget, όπως το Pub/Sub παραπάνω.
  • Αίτημα και απάντηση — μια υπηρεσία ρωτά, μια άλλη απαντά. Όταν πολλά instances απαντούν ως queue group, το NATS μοιράζει τα αιτήματα ανάμεσά τους.
  • JetStream — μόνιμα streams: τα μηνύματα αποθηκεύονται στον δίσκο της υπηρεσίας, ένας consumer θυμάται τι έχει διαβάσει και κάθε μήνυμα παραδίδεται τουλάχιστον μία φορά μέχρι να επιβεβαιωθεί.
  • Key-value και object store πάνω στο JetStream — για μικρές κοινές ρυθμίσεις, locks ή αρχεία ανάμεσα σε υπηρεσίες.

Μεταβλητές. Το πρώτο NATS της εφαρμογής δίνει σε κάθε υπηρεσία κώδικα:

NATS_URL=nats://<χρήστης>:<κωδικός>@<όνομα υπηρεσίας>:4222

Κάθε υπηρεσία NATS δίνει επίσης RIVERVO_<NAME>_URL με διεύθυνση της ίδιας μορφής — το NAME είναι το όνομα της υπηρεσίας με κεφαλαία, με τις παύλες να γίνονται _: μια υπηρεσία με όνομα events δίνει RIVERVO_EVENTS_URL.

Το JetStream κρατά τα streams του στον δίσκο της υπηρεσίας· τα streams που κρατιούνται στη μνήμη μπορούν να χρησιμοποιήσουν περίπου το ένα τέταρτο της μνήμης της υπηρεσίας.

RabbitMQ

Το RabbitMQ 4.1 είναι κλασικός message broker: οι producers δημοσιεύουν σε exchanges, τα exchanges δρομολογούν τα μηνύματα σε ουρές με βάση τα routing keys, οι consumers επιβεβαιώνουν κάθε μήνυμα, και ένα μήνυμα που απορρίπτεται ή λήγει μπορεί να πάει σε ένα dead-letter exchange. Για ουρές των οποίων τα μηνύματα πρέπει να επιβιώνουν μετά από επανεκκίνηση, χρησιμοποίησε quorum queues (το όρισμα x-queue-type: quorum) και δημοσίευε τα μηνύματα ως persistent.

Μεταβλητές. Το πρώτο RabbitMQ της εφαρμογής δίνει σε κάθε υπηρεσία κώδικα:

ΜεταβλητήΤιμή
AMQP_URLamqp://<χρήστης>:<κωδικός>@<όνομα υπηρεσίας>:5672/%2f
RABBITMQ_HOSTτο όνομα της υπηρεσίας
RABBITMQ_PORT5672
RABBITMQ_USER, RABBITMQ_PASSWORDο χρήστης και ο κωδικός
RABBITMQ_VHOST/

Το %2f στο τέλος του AMQP_URL είναι ο προεπιλεγμένος virtual host /, γραμμένος όπως απαιτούν οι διευθύνσεις σύνδεσης. Κάθε υπηρεσία RabbitMQ δίνει επίσης το δικό της RIVERVO_<NAME>_URL με διεύθυνση της ίδιας μορφής.

Management API. Το management HTTP API ακούει στη θύρα 15672 μέσα στο ιδιωτικό δίκτυο της εφαρμογής: οι υπηρεσίες της εφαρμογής φτάνουν σε αυτό στο http://<όνομα υπηρεσίας>:15672 με τον ίδιο χρήστη και κωδικό, για παράδειγμα:

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

Δεν υπάρχει σελίδα διαχείρισης στο internet. Η σελίδα της υπηρεσίας στο panel δείχνει μια σύντομη λίστα των ουρών της, μόνο για ανάγνωση: μηνύματα έτοιμα, μη επιβεβαιωμένα και consumers.

Μόνο εσωτερικά

Το NATS και το RabbitMQ δεν έχουν δημόσια διεύθυνση και δεν είναι προσβάσιμα από έξω από την εφαρμογή — από τον υπολογιστή σου, άλλον server ή άλλη εφαρμογή. Σε αντίθεση με την PostgreSQL, τη MySQL και το Valkey, η πρόσβαση από έξω δεν προσφέρεται γι' αυτά. Οι υπηρεσίες που δημοσιεύουν και καταναλώνουν μηνύματα λειτουργούν ως υπηρεσίες της ίδιας εφαρμογής: web services, workers στο παρασκήνιο και προγραμματισμένες εργασίες.

Δεύτερη υπηρεσία του ίδιου είδους

Μόνο το πρώτο Valkey, NATS και RabbitMQ της εφαρμογής παίρνουν τα συνηθισμένα ονόματα (REDIS_*, NATS_URL, AMQP_URL και RABBITMQ_*). Η επόμενη υπηρεσία του ίδιου είδους προσθέτει μόνο το δικό της RIVERVO_<NAME>_URL· διάβασε αυτή τη μεταβλητή στον κώδικά σου ή όρισε τα συνηθισμένα ονόματα με τις τιμές της στην καρτέλα Μεταβλητές. Οι μεταβλητές φτάνουν σε μια υπηρεσία με το επόμενο deploy της — δες Μεταβλητές περιβάλλοντος.

Laravel

Valkey. Όρισε στην καρτέλα Μεταβλητές:

QUEUE_CONNECTION=redis

Εκτέλεσε το php artisan queue:work — ή το php artisan horizon με Horizon — ως worker στο παρασκήνιο. Δες Laravel.

RabbitMQ. Το Laravel δεν έχει ενσωματωμένο driver για 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 στην καρτέλα Μεταβλητές και κάνε deploy. Ο worker παραμένει php artisan queue:work.

NATS. Δεν υπάρχει επίσημος driver ουράς για NATS στο Laravel. Χρησιμοποίησε έναν NATS client για PHP στον δικό σου κώδικα — για παράδειγμα basis-company/nats — και δώσε του τον host, τη θύρα, τον χρήστη και τον κωδικό από το NATS_URL. Έλεγξε ότι ο client υποστηρίζει τις λειτουργίες που χρειάζεσαι (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 })
 
// στο web service
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)
 
// producer
await redis.xadd('orders', '*', 'id', '42')
 
// consumer της ομάδας «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 τη δίνει σε άλλον consumer.

NATS (nats.js)

import { connect, JSONCodec, AckPolicy } from 'nats'
 
const nc = await connect({ servers: process.env.NATS_URL })
const jc = JSONCodec()
 
// μία φορά: ένα stream για τα subjects orders.* και ένας μόνιμος 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: το πολύ 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 queues (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"})
 
# 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()

Παράδοση περισσότερες από μία φορές

Οι ουρές και οι brokers παραδίδουν ξανά ένα μήνυμα όταν ένας worker σταματήσει πριν το επιβεβαιώσει — κατά τη διάρκεια ενός deploy, μιας επανεκκίνησης ή μιας ανάκτησης. Γράψε τους consumers έτσι ώστε η διπλή επεξεργασία του ίδιου μηνύματος να μην κάνει ζημιά: κράτα το ID κάθε μηνύματος που επεξεργάστηκες ή κάνε την ίδια την ενέργεια επαναλήψιμη (για παράδειγμα «όρισε την κατάσταση σε πληρωμένη» αντί για «πρόσθεσε μια πληρωμή»).

Πόροι και τιμή

ΥπηρεσίαΞεκινά μεΕλάχιστη μνήμη
NATS256 MB μνήμης · 1 πυρήνας CPU · 5 GB δίσκου256 MB
RabbitMQ1 GB μνήμης · 1 πυρήνας CPU · 10 GB δίσκου512 MB

Το καθένα τιμολογείται με βάση τη μνήμη, τη CPU και τον δίσκο του, όπως κάθε υπηρεσία — δες Υπηρεσίες ενός project. Οι πόροι μπορούν να αλλάξουν αργότερα στις Ρυθμίσεις της υπηρεσίας.

Backup και ανάκτηση

Για το NATS και το RabbitMQ κρατάμε backup κάθε μέρα· διατηρούμε τις τελευταίες 7 ημέρες και 4 εβδομάδες, όπως και για τις άλλες υπηρεσίες.

  • Το backup αντιγράφει τα αρχεία δεδομένων της υπηρεσίας ενώ λειτουργεί. Για το RabbitMQ το ίδιο backup περιέχει επίσης εξαγωγή των ορισμών του: χρήστες, virtual hosts, ουρές, exchanges, bindings και policies.
  • Δεν υπάρχει ανάκτηση σε ακριβή στιγμή — αυτή υπάρχει μόνο για PostgreSQL και MySQL. Ανακτάς ένα από τα ημερήσια αντίγραφα.
  • Μια ανάκτηση σταματά την υπηρεσία για λίγο, επαναφέρει τα αρχεία και την ξεκινά ξανά. Μηνύματα που έφτασαν ή επιβεβαιώθηκαν κοντά στη στιγμή του backup μπορεί να λείπουν ή να παραδοθούν ξανά — ακόμη ένας λόγος να είναι οι consumers ασφαλείς στην επανάληψη.
  • Για το RabbitMQ, αν τα αρχεία που αντιγράφηκαν δεν μπορούν να ξεκινήσουν, η υπηρεσία ξεκινά μόνο με τους ορισμούς: οι ουρές, τα exchanges και οι χρήστες υπάρχουν, αλλά τα μηνύματα από το backup χάνονται.

Συντήρηση και μεταφορές

Το NATS και το RabbitMQ δεν έχουν ώρα συντήρησης για ρύθμιση. Δεν μεταφέρονται αυτόματα σε άλλον server· αν χρειαστεί ποτέ, η υποστήριξη το κανονίζει μαζί σου.

Χρειάζεσαι ακόμα βοήθεια;

Γράψε μας στο chat — το AI απαντά αμέσως και ένας μηχανικός μπαίνει όταν χρειαστεί, οποιαδήποτε ώρα της μέρας.

Επικοινωνία με την υποστήριξη