立即开始

事件与队列:Valkey、NATS 和 RabbitMQ。

应用各服务之间的后台任务、事件和消息:何时选择 Valkey、NATS 或 RabbitMQ,连接变量,Laravel、Node.js 和 Python 示例,资源、备份和限制。

4 分钟阅读

当网站把工作交给后台任务进程——发送邮件、调整图片尺寸、为订单扣款——或者一个服务通知其他服务发生了某件事时,消息会经过队列或消息代理。一个项目可以使用三种,各自作为服务添加:概览 → 服务 → 添加服务。

服务适用场景
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 驱动的 Laravel 队列和 Horizon、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),并以持久化方式发布消息。

**变量。**应用的第一个 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 不同,它们不提供外部访问。发布和消费消息的服务需作为同一应用的服务运行:Web 服务、后台任务进程和定时任务。

同类的第二个服务

只有应用的第一个 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。要将 RabbitMQ 用于 Laravel 队列:

  1. 安装扩展包:composer require vladimir-yuldashev/laravel-queue-rabbitmq。
  2. 按扩展包 README 中对应您版本的说明,在 config/queue.php 中添加 rabbitmq 连接。它会读取应用已有的 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 队列驱动。请在您自己的代码中使用 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 })
 
// 在 Web 服务中
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,或让操作本身可重复执行(例如“将状态设为已支付”,而不是“增加一笔付款”)。

资源与价格

服务初始配置最小内存
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 即时回答,需要时工程师加入,全天候在线。

联系技术支持