เริ่มต้นใช้งาน

อีเวนต์และคิว: Valkey, NATS และ RabbitMQ

งานเบื้องหลัง อีเวนต์ และข้อความระหว่างบริการของแอปพลิเคชัน: ควรเลือก Valkey, NATS หรือ RabbitMQ เมื่อใด ตัวแปรการเชื่อมต่อ ตัวอย่างสำหรับ Laravel, Node.js และ Python ทรัพยากร การสำรองข้อมูล และข้อจำกัด

6 นาทีในการอ่าน

เมื่อเว็บไซต์ส่งงานให้เวิร์กเกอร์ เช่น ส่งอีเมล ย่อขนาดรูปภาพ หรือเรียกเก็บเงินคำสั่งซื้อ หรือเมื่อบริการหนึ่งแจ้งบริการอื่นว่ามีบางอย่างเกิดขึ้น ข้อความจะผ่านคิวหรือ Message Broker โปรเจกต์มีได้สามแบบ แต่ละแบบเพิ่มเป็นบริการ: ภาพรวม → บริการ → เพิ่มบริการ

บริการเลือกเมื่อต้องการ
Valkeyคิวงานแบบง่าย (คิวของ Laravel และ Horizon, BullMQ, Celery, RQ) และอีเวนต์ใน Streams — เมื่อคุณใช้ Valkey สำหรับแคชและเซสชันอยู่แล้ว
NATSการส่งข้อความแบบเบาระหว่างบริการ: อีเวนต์ คำขอและการตอบกลับ และสตรีมแบบถาวรด้วย JetStream
RabbitMQMessage Broker แบบคลาสสิก: การส่งต่อผ่าน Exchange การยืนยันรับ การลองใหม่ และ Dead-lettering รวมถึง Quorum Queue

หากไม่แน่ใจ ให้เริ่มด้วย Valkey สำหรับงานเบื้องหลัง เฟรมเวิร์กส่วนใหญ่รองรับในตัว เลือก RabbitMQ เมื่อข้อความต้องส่งต่อระหว่างหลายคิวและห้ามสูญหาย และเลือก NATS เมื่อบริการแลกเปลี่ยนข้อความเล็กๆ จำนวนมาก หรือขอคำตอบจากกันและกัน

Valkey: คิวงานและ Streams

Valkey เป็นที่เก็บข้อมูลที่เข้ากันได้กับ Redis เป็นบริการแบบมีการจัดการตัวเดียวกับใน ฐานข้อมูล Valkey ตัวแรกของแอปพลิเคชันจะให้ REDIS_URL, REDIS_HOST, REDIS_PORT และ REDIS_PASSWORD แก่ทุกบริการโค้ด และ Valkey ทุกตัวให้ RIVERVO_<NAME>_URL ของตัวเองด้วย

ส่งข้อความผ่าน Valkey ได้สามวิธี:

  • คิวงาน — คิวของ Laravel ด้วยไดรเวอร์ redis และ Horizon, BullMQ, Celery, RQ ไลบรารีเก็บงานไว้ใน Valkey เวิร์กเกอร์หยิบงานทีละงานและลองใหม่กับงานที่ล้มเหลว
  • Streams พร้อม Consumer Group — XADD เพิ่มอีเวนต์ต่อท้ายสตรีม ผู้บริโภคในกลุ่มอ่านด้วย XREADGROUP และยืนยันด้วย XACK อีเวนต์ถูกจัดเก็บไว้: ผู้บริโภคที่หยุดไปจะทำต่อจากจุดที่ค้างไว้ อีเวนต์ที่ยังไม่ยืนยันจะถูกหยิบใหม่ได้ และกลุ่มใหม่อ่านสตรีมตั้งแต่ต้นได้
  • Pub/Sub — PUBLISH และ SUBSCRIBE ส่งข้อความเฉพาะให้ผู้สมัครรับที่เชื่อมต่ออยู่ในขณะนั้น ข้อความไม่ถูกจัดเก็บ ผู้สมัครรับที่กำลังรีสตาร์ตหรือยังไม่เชื่อมต่อจะพลาดข้อความนั้น ใช้ Pub/Sub เฉพาะเมื่อข้อความที่หายไปไม่สร้างความเสียหาย (เช่น สัญญาณ “รีเฟรช”) และใช้ Streams หรือคิวสำหรับกรณีอื่นทั้งหมด

Valkey สำรองข้อมูลทุกวันเหมือนฐานข้อมูลอื่น และเข้าถึงจากภายนอกได้เมื่อคุณเปิดการเข้าถึง ดู ฐานข้อมูล

NATS

NATS เป็นระบบส่งข้อความที่เบาและเร็ว โดยเปิดใช้ JetStream ไว้:

  • เผยแพร่และสมัครรับ — บริการเผยแพร่ไปยัง Subject เช่น orders.created ผู้สมัครรับทุกรายของ Subject นั้นจะได้รับข้อความ หากไม่ใช้ JetStream จะเป็นแบบส่งแล้วจบ เหมือน Pub/Sub ข้างต้น
  • คำขอและการตอบกลับ — บริการหนึ่งถาม อีกบริการตอบ เมื่อหลายอินสแตนซ์ตอบในฐานะ Queue Group ระบบ NATS จะกระจายคำขอให้อินสแตนซ์เหล่านั้น
  • JetStream — สตรีมแบบถาวร: ข้อความถูกเก็บบนดิสก์ของบริการ Consumer จดจำว่าอ่านถึงไหนแล้ว และทุกข้อความจะถูกส่ง อย่างน้อยหนึ่งครั้ง จนกว่าจะได้รับการยืนยัน
  • Key-value และ Object Store ที่สร้างบน JetStream — สำหรับการตั้งค่าที่ใช้ร่วมกันขนาดเล็ก ล็อก หรือไฟล์ระหว่างบริการ

ตัวแปร NATS ตัวแรกของแอปพลิเคชันจะให้ตัวแปรนี้แก่ทุกบริการโค้ด:

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

บริการ NATS ทุกตัวยังให้ RIVERVO_<NAME>_URL ที่มีที่อยู่รูปแบบเดียวกัน — NAME คือชื่อบริการเป็นตัวพิมพ์ใหญ่ โดยเปลี่ยนขีดเป็น _: บริการชื่อ events จะให้ RIVERVO_EVENTS_URL

JetStream เก็บสตรีมไว้บนดิสก์ของบริการ สตรีมที่เก็บในหน่วยความจำใช้ได้ประมาณหนึ่งในสี่ของหน่วยความจำของบริการ

RabbitMQ

RabbitMQ 4.1 เป็น Message Broker แบบคลาสสิก: ผู้ผลิตเผยแพร่ไปยัง Exchange แล้ว Exchange ส่งต่อข้อความไปยัง คิว ตาม Routing Key ผู้บริโภค ยืนยันรับ แต่ละข้อความ และข้อความที่ถูกปฏิเสธหรือหมดอายุไปยัง Dead-letter Exchange ได้ สำหรับคิวที่ข้อความต้องอยู่รอดหลังรีสตาร์ต ให้ใช้ Quorum Queue (อาร์กิวเมนต์ 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 บริการเหล่านี้ไม่มีตัวเลือกการเข้าถึงจากภายนอก บริการที่เผยแพร่และรับข้อความทำงานเป็นบริการของแอปพลิเคชันเดียวกัน ได้แก่ เว็บเซอร์วิส เวิร์กเกอร์เบื้องหลัง และงานตามกำหนดเวลา

บริการประเภทเดียวกันตัวที่สอง

เฉพาะ 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 เป็นเวิร์กเกอร์เบื้องหลัง ดู 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 ในแท็บ ตัวแปร แล้วดีพลอย เวิร์กเกอร์ยังคงเป็น php artisan queue:work

NATS ไม่มีไดรเวอร์คิว Laravel อย่างเป็นทางการสำหรับ NATS ให้ใช้ไคลเอนต์ NATS สำหรับ PHP ในโค้ดของคุณเอง เช่น basis-company/nats และกำหนดโฮสต์ พอร์ต ผู้ใช้ และรหัสผ่านจาก NATS_URL ตรวจสอบว่าไคลเอนต์รองรับฟีเจอร์ที่คุณต้องการ (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 })
 
// 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"])  # หรือ 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 Queue ได้ (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()

ข้อความที่ส่งมากกว่าหนึ่งครั้ง

คิวและ Broker จะส่งข้อความซ้ำเมื่อเวิร์กเกอร์หยุดก่อนยืนยันข้อความ เช่น ระหว่างการดีพลอย การรีสตาร์ต หรือการกู้คืน ให้เขียนผู้บริโภคให้การจัดการข้อความเดียวกันสองครั้งไม่สร้างความเสียหาย: เก็บ ID ของทุกข้อความที่ประมวลผลแล้ว หรือทำให้การกระทำนั้นทำซ้ำได้ (เช่น “ตั้งสถานะเป็นชำระแล้ว” แทน “เพิ่มการชำระเงิน”)

ทรัพยากรและราคา

บริการเริ่มต้นที่หน่วยความจำขั้นต่ำ
NATSหน่วยความจำ 256 MB · CPU 1 คอร์ · ดิสก์ 5 GB256 MB
RabbitMQหน่วยความจำ 1 GB · CPU 1 คอร์ · ดิสก์ 10 GB512 MB

แต่ละบริการคิดราคาตามหน่วยความจำ CPU และดิสก์เหมือนบริการอื่น ดู บริการของโปรเจกต์ เปลี่ยนทรัพยากรภายหลังได้ใน การตั้งค่า ของบริการ

การสำรองข้อมูลและการกู้คืน

NATS และ RabbitMQ สำรองข้อมูล ทุกวัน เราเก็บ 7 วันล่าสุดและ 4 สัปดาห์ล่าสุด เหมือนบริการอื่น

  • การสำรองข้อมูลคัดลอกไฟล์ข้อมูลของบริการขณะที่บริการทำงาน สำหรับ RabbitMQ ข้อมูลสำรองชุดเดียวกันยังมีการส่งออกนิยามของบริการด้วย ได้แก่ ผู้ใช้ Virtual Host คิว Exchange Binding และ Policy
  • ไม่มีการกู้คืนไปยังช่วงเวลาที่ระบุ ซึ่งมีเฉพาะสำหรับ PostgreSQL และ MySQL คุณกู้คืนจากข้อมูลสำรองรายวันชุดใดชุดหนึ่ง
  • การกู้คืนจะหยุดบริการช่วงสั้นๆ นำไฟล์กลับมา แล้วเริ่มบริการอีกครั้ง ข้อความที่เข้ามาหรือถูกยืนยันในช่วงเวลาใกล้กับการสำรองข้อมูลอาจหายไปหรือถูกส่งซ้ำ ซึ่งเป็นอีกเหตุผลที่ควรทำให้ผู้บริโภคทำซ้ำได้อย่างปลอดภัย
  • สำหรับ RabbitMQ หากเริ่มบริการจากไฟล์ที่คัดลอกไม่ได้ บริการจะเริ่มด้วยนิยามเท่านั้น: คิว Exchange และผู้ใช้ยังอยู่ แต่ข้อความจากข้อมูลสำรองจะสูญหาย

การบำรุงรักษาและการย้าย

NATS และ RabbitMQ ไม่มีช่วงเวลาบำรุงรักษาให้ตั้งค่า บริการเหล่านี้จะไม่ถูกย้ายไปเซิร์ฟเวอร์อื่นโดยอัตโนมัติ หากจำเป็นต้องย้าย ทีมซัพพอร์ตจะนัดหมายกับคุณ

ยังติดปัญหาอยู่ใช่ไหม

แชทกับเรา AI ตอบทันที และวิศวกรจะเข้ามาช่วยเมื่อจำเป็น ได้ทุกเวลา

ติดต่อฝ่ายซัพพอร์ต