RabbitMQ服务器部署与优化指南:队列、连接与消息可靠性配置

某天早上,告警显示订单积压了 12 万条消息,消费者明明都在跑,但队列里的消息只增不减。登上管理界面一看:Unacked 那一列稳稳停在一个数字不动,而Ready 在持续上涨。这种情况几乎总是同一个原因——某个消费者拿到消息后处理卡住了,既没有 ack 也没有 reject,RabbitMQ 只能一直等。RabbitMQ 的部署和优化,说到底就是围绕三件事:消息别丢、消费别堵、资源别满。本文从安装部署讲到队列设计、连接管理和可靠性配置,把这三件事拆开讲。

一、部署:版本匹配与基础配置

RabbitMQ 是用 Erlang 写的,它对 Erlang/OTP 版本有严格的对应关系,装错版本是最常见的启动失败原因。安装前一定要去官方的 Erlang 版本兼容表核对。以 RabbitMQ 3.13 为例,它需要 OTP 25.3 到 26.2 之间。

1.1 在 RHEL 系安装

# 1. 添加 Erlang 与 RabbitMQ 官方源(以 Rocky 9 / RHEL 9 为例)
sudo tee /etc/yum.repos.d/rabbitmq.repo <<'EOF'
[rabbitmq_erlang]
name=rabbitmq_erlang
baseurl=https://yum1.rabbitmq.com/erlang/el/9/$basearch
repo_gpgcheck=1
gpgcheck=1
enabled=1
gpgkey=https://github.com/rabbitmq/signing-keys/releases/download/3.0/cloudsmith.rabbitmq-erlang.E495BB49CC4BBE5B.key

[rabbitmq_server]
name=rabbitmq_server
baseurl=https://yum2.rabbitmq.com/rabbitmq/el/9/$basearch
repo_gpgcheck=1
gpgcheck=1
enabled=1
gpgkey=https://github.com/rabbitmq/signing-keys/releases/download/3.0/cloudsmith.rabbitmq-server.9F4587F226208342.key
EOF

# 2. 安装(先 Erlang 后 RabbitMQ)
sudo yum install -y erlang-26.2.5.2-1.el9 rabbitmq-server-3.13.7-1.el9
sudo systemctl enable --now rabbitmq-server

# 3. 开启管理插件
sudo rabbitmq-plugins enable rabbitmq_management
sudo systemctl restart rabbitmq-server

1.2 关键目录、端口与配置文件

端口用途是否应对外开放
5672AMQP 0-9-1 协议(客户端主要连接端口)仅内网业务网段
5671AMQP over TLS跨公网时使用
15672HTTP 管理 API 与 Web UI仅限运维访问,务必改默认账号
25672Erlang 分布式通信(集群节点互联)仅集群节点之间
4369epmd(Erlang Port Mapper Daemon)仅集群节点之间

配置文件在 3.7 之后换成了新的 sysctl 风格(rabbitmq.conf),旧的 Erlang term 格式改名为 advanced.config:

# /etc/rabbitmq/rabbitmq.conf
listeners.tcp.default = 5672
listeners.tcp.local   = 10.0.0.41:5672          # 只监听内网网卡

# 内存水位线:默认 0.4,即使用超过物理内存 40% 时触发流控
vm_memory_high_watermark.relative = 0.4
# 或用绝对值:vm_memory_high_watermark.absolute = 4GB
# 流控解除比例(默认 0.5,即降到水位线的 50% 才解除)
vm_memory_high_watermark_paging_ratio = 0.75

# 磁盘水位线:默认 50MB,生产建议设为内存的 1-2 倍
disk_free_limit.relative = 2.0

# 连接与通道
num_acceptors.tcp = 10
channel_max = 2048
frame_max = 131072
heartbeat = 60
handshake_timeout = 10000

# 日志
log.file.level = info
log.dir = /var/log/rabbitmq

# 集群相关
cluster_name = prod_rmq
cluster_formation.peer_discovery_backend = classic_config

# 数据目录
# mnesia_base = /var/lib/rabbitmq/mnesia

vm_memory_high_watermark 和 disk_free_limit 是保护 broker 的两道闸门,触发时 RabbitMQ 会阻塞所有发布者(blocking publishers),这是防止内存或磁盘被彻底耗尽的自保机制。默认值 disk_free_limit = 50MB 对生产环境太小了,一次大的消息堆积就可能把磁盘写满导致节点崩溃,建议改成内存的 1-2 倍(relative = 2.0)。

1.3 用户与权限

# 默认 guest/guest 只允许 localhost 登录,必须删除或改密码
rabbitmqctl delete_user guest

# 创建管理员(用于 Web UI)
rabbitmqctl add_user rmq_admin 'AdminPass#2024'
rabbitmqctl set_user_tags rmq_admin administrator

# 创建应用用户并授权
rabbitmqctl add_vhost /order
rabbitmqctl add_user order_app 'AppPass#2024'
rabbitmqctl set_user_tags order_app management
# 权限三元组:配置权限 写权限 读权限(正则匹配资源名)
rabbitmqctl set_permissions -p /order order_app "^order-.*" "^order-.*" "^order-.*"

# 创建只读监控用户
rabbitmqctl add_user monitor 'MonPass#2024'
rabbitmqctl set_user_tags monitor monitoring
rabbitmqctl set_permissions -p / monitor "" "" ".*"

# 查看
rabbitmqctl list_users
rabbitmqctl list_permissions -p /order
rabbitmqctl authenticate_user order_app 'AppPass#2024'

权限的正则很值得注意:配置权限(configure)控制能否声明/删除队列和交换机,写权限(write)控制能否发布消息,读权限(read)控制能否消费。给消费者应用应该只给 read,给生产者只给 write,不要一律给 ".*" ".*" ".*"。

二、队列设计:durable、镜像队列与 quorum queue

2.1 持久化的两层含义

"消息不丢"在 RabbitMQ 里要分三层保证,缺一不可:

  1. 队列持久化:durable=true,broker 重启后队列本身(元数据)还在。注意它不保证消息不丢,只保证队列和交换机定义不丢。
  2. 消息持久化:发布时设置 delivery_mode=2(PERSISTENT),消息才会被写入磁盘。但注意 RabbitMQ 并不是每条消息都立即 fsync,而是在一定时间间隔或数量后批量刷盘,所以极端情况下(broker 硬宕机)仍可能丢失极少量消息。
  3. 发布确认(publisher confirm):这才是最关键的一层。开启 confirm 后,broker 在消息被写入磁盘(对持久化消息)后回送 basic.ack 给生产者。生产者没收到 ack 就知道要重发。
# Python pika 示例:可靠的发布端
import pika

conn = pika.BlockingConnection(
    pika.ConnectionParameters(host='10.0.0.41', heartbeat=60))
ch = conn.channel()

# 1. 声明持久化队列
ch.queue_declare(queue='order-create', durable=True,
                 arguments={'x-queue-type': 'quorum'})

# 2. 开启发布确认
ch.confirm_delivery()

try:
    ch.basic_publish(
        exchange='',
        routing_key='order-create',
        body='{"order_no":"A20241014001"}',
        properties=pika.BasicProperties(
            delivery_mode=2,          # 2 = 持久化消息
            content_type='application/json',
        ),
        mandatory=True)               # 不可路由时返回给生产者
    print('confirmed')
except pika.exceptions.UnroutableError:
    print('消息无法路由,需要告警')
except pika.exceptions.NackedError:
    print('broker 未确认,需要重发')

关于 confirm 的性能取舍:单条同步等待 ack 会把吞吐压到几百 TPS。生产环境应该用批量异步确认——发布一批(比如 100 条或 20ms 内的所有消息)后统一等待确认,失败时整批重发(要求消费端做幂等)。这能把吞吐提升到数万 TPS。

另外不要用 AMQP 事务(tx.select / tx.commit)来做可靠性,它是同步阻塞的,性能比 confirm 慢两个数量级以上,官方也不推荐。

2.2 镜像队列 vs Quorum Queue

在集群环境里,队列要跨节点复制才能抗住节点故障。RabbitMQ 提供过两代方案:

特性Classic Queue + Mirror(镜像队列)Quorum Queue(仲裁队列)
复制协议主副本异步同步给镜像Raft 共识协议,多数派确认
数据安全性主节点故障时可能丢未同步的消息已确认的消息不会丢
副本数通过 policy 配置,通常 ha-mode: all 或 exactly声明时指定(默认 3,可配 x-quorum-initial-group-size)
脑裂处理可能出现,需要 ha-promote-on-shutdown 策略Raft 天然防脑裂
支持的功能完整(TTL、优先级、DLX 全部支持)部分限制(不支持优先级队列、部分 TTL 行为不同)
内存/磁盘开销较低较高(要维护 Raft 日志),消息常驻磁盘
适用版本3.8 前主流,新版本已不推荐3.8+ 推荐,新项目首选

核心建议:新项目直接用 quorum queue,老项目的镜像队列(ha-mode policy)应该规划迁移。官方在 3.8 引入 quorum queue 后就明确表示镜像队列存在设计缺陷(无法保证数据安全),后续版本已逐步弱化支持。

# 镜像队列(老方式,仅作对照)
rabbitmqctl set_policy ha-all "^order-.*" \
  '{"ha-mode":"exactly","ha-params":2,"ha-sync-mode":"manual"}'

# Quorum queue(推荐)——通过客户端声明时指定
# arguments={'x-queue-type': 'quorum'}
# 或者用默认队列类型配置:
# default_queue_type = quorum   (3.13+ 支持在 rabbitmq.conf 中设置)

# 查看队列类型与副本分布
rabbitmqctl list_queues name type durable policy \
  messages messages_ready messages_unacknowledged \
  consumers memory state

quorum queue 的一个运维要点:它的副本数建议设为奇数(3 或 5),并且 RabbitMQ 集群节点数应不少于副本数。副本数不能超过集群节点数,设多了会报错。另外 quorum queue 的消息默认全部落盘,内存占用低但磁盘 IO 高,磁盘要给足。

2.3 其他队列类型与特性

  • Lazy Queue:消息尽可能早地写入磁盘,只在消费时才加载到内存。适用于消息堆积量大、消费慢的场景(比如百万级积压),代价是吞吐下降。传统 classic queue 用 x-queue-mode: lazy 声明,quorum queue 天然就是这个行为。
  • 死信交换机(DLX):消费失败、消息被 reject 且 requeue=false、或 TTL 过期的消息会被投递到 DLX,进入死信队列。这是排查消费问题的关键设施,生产队列必须配 DLX。
  • 消息 TTL 与队列 TTL:x-message-ttl 控制单条消息存活时间,x-expires 控制队列空闲多久自动删除。配合 DLX 可以实现延迟队列(消息过期后进 DLX)。
# 声明带 DLX 的队列(Python pika)
args = {
    'x-queue-type': 'quorum',
    'x-dead-letter-exchange': 'dlx.orders',
    'x-dead-letter-routing-key': 'order.dead',
}
ch.queue_declare(queue='order-create', durable=True, arguments=args)

ch.exchange_declare(exchange='dlx.orders', exchange_type='topic', durable=True)
ch.queue_declare(queue='order-create-dlq', durable=True,
                 arguments={'x-queue-type': 'quorum'})
ch.queue_bind(queue='order-create-dlq', exchange='dlx.orders',
              routing_key='order.dead')

三、连接与消费者:prefetch、ack 与堆积排查

3.1 Connection 与 Channel 的关系

这是 RabbitMQ 里最容易理解错的概念:Connection 是 TCP 连接(昂贵,一个连接一个 TCP + 一个 Erlang 进程),Channel 是连接内的逻辑通道(便宜,复用同一个 TCP)。正确用法是:一个应用进程维持一个 Connection,在里面开多个 Channel(比如一个 Channel 用于发布,一个用于消费)。

常见反模式:每次发消息都新建 Connection。这会导致 TCP 连接数暴涨、握手开销巨大,broker 侧 Erlang 进程数飙升。同样,一个 Connection 开几千个 Channel 也不合适,因为 Channel 在 broker 上也是独立进程。

经验值:单节点 Connection 数控制在几千以内(默认没有硬限制,但超过 5000 要关注内存),每个 Connection 的 Channel 数控制在 10-50 个。

# 查看连接与通道
rabbitmqctl list_connections name peer_host peer_port channels user state recv_cnt send_cnt
rabbitmqctl list_channels connection name number consumer_count prefetch_count unacked
rabbitmqctl list_consumers queue_name channel_pid ack_required prefetch_count active

# 统计连接数
rabbitmqctl list_connections -q name | wc -l

3.2 prefetch(QoS)调优

prefetch_count 控制"一个消费者最多可以持有多少条未确认(unacked)的消息"。这是吞吐与公平性之间最重要的调节旋钮。

  • prefetch = 0(不限):broker 会把队列里的消息全部推给消费者。看起来最快,实际上会导致消息全堆积在某个消费者的本地缓冲区里,其他消费者闲着;而且一旦消费者崩溃,全部 unacked 消息要重新入队,恢复代价大。
  • prefetch = 1:最公平,每条确认后才发下一条。但吞吐极低,因为每消费一条都要等一次网络往返。
  • 推荐值:先按 处理耗时 / 单条消息网络往返时间 粗算。比如单条处理 10ms、网络 RTT 1ms,prefetch 设 20 左右比较合适。实践中常用 20-300:消费快、处理均匀的设大值;消费慢、希望分布均匀的设小值。
# 全局 QoS(对整个 channel 生效)
ch.basic_qos(prefetch_count=50)

# 新版 pika 支持 per-consumer prefetch
ch.basic_qos(prefetch_count=50, global_qos=False)

ch.basic_consume(
    queue='order-create',
    on_message_callback=callback,
    auto_ack=False)          # 必须手动 ack

3.3 ack、nack、reject 的正确用法

def callback(ch, method, properties, body):
    try:
        process(body)
        # 单条确认
        ch.basic_ack(delivery_tag=method.delivery_tag)
    except RetryableError:
        # 可重试错误:requeue 重新入队(注意会回到队头,可能反复失败)
        ch.basic_nack(delivery_tag=method.delivery_tag,
                      requeue=True)
    except FatalError:
        # 不可处理:拒绝且不再入队 → 进入死信队列
        ch.basic_reject(delivery_tag=method.delivery_tag,
                        requeue=False)

# 批量确认(提升吞吐,multiple=True 确认该 delivery_tag 之前的所有消息)
ch.basic_ack(delivery_tag=method.delivery_tag, multiple=True)

三个必须记住的原则:

  • 永远用手动 ack(auto_ack=False)。auto_ack=True 意味着 broker 一把消息发给消费者就立即认为已确认并删除,消费者处理中崩溃则消息永久丢失。
  • requeue=True 要谨慎。一条反复失败的消息会在队列里无限循环,把消费者全部拖死。正确做法是失败计数,超过阈值就 reject 进死信队列。
  • 不要忘记 ack,也不要在耗时操作之外 ack。忘记 ack 是 unacked 堆积的头号原因;而在处理完成前就 ack 则等于放弃可靠性保证。

3.4 消息堆积的排查流程

当队列积压时,按这个顺序定位:

  1. 先看是 Ready 堆积还是 Unacked 堆积:rabbitmqctl list_queues name messages_ready messages_unacknowledged consumers。
  2. Ready 高、Unacked 低:说明消费者处理速度跟不上生产速度(或消费者太少)。解决:加消费者实例、优化处理逻辑、考虑 lazy queue。
  3. Unacked 高且长时间不动:说明消费者拿到消息后卡住或没 ack。看 list_consumers 的 active 字段,检查消费者进程是否假死(比如 HTTP 调用超时没设 timeout、数据库连接池耗尽)。
  4. Unacked 高但 consumers = 0:说明消费者全部断开,之前的 unacked 消息会在连接断开后自动 requeue(因为未 ack 的消息在 channel 关闭时会被 broker 重新投递)。
  5. 检查是否有流控:rabbitmqctl status 里看 blocked 状态,或管理界面上的 "blocked" 标记。内存/磁盘告警会导致发布被阻塞。
# 综合查看队列状态(最常用的一条)
rabbitmqctl list_queues name type durable \
  messages messages_ready messages_unacknowledged \
  consumers consumer_utilisation \
  message_bytes_persistent memory state

# 查看是否存在被流控的连接
rabbitmqctl list_connections pid name state channels blocked_by

# 查看节点级别的内存与磁盘告警
rabbitmqctl status | grep -A5 -E 'alarms|memory|disk_free'

四、集群部署要点

# 1. 所有节点使用相同的 Erlang cookie(必须在启动前配置)
#    文件路径 /var/lib/rabbitmq/.erlang.cookie,权限 400
sudo systemctl stop rabbitmq-server
echo 'SHARED_SECRET_COOKIE_STRING' | sudo tee /var/lib/rabbitmq/.erlang.cookie
sudo chmod 400 /var/lib/rabbitmq/.erlang.cookie
sudo chown rabbitmq:rabbitmq /var/lib/rabbitmq/.erlang.cookie
sudo systemctl start rabbitmq-server

# 2. 在要加入集群的节点上执行
rabbitmqctl stop_app
rabbitmqctl reset
rabbitmqctl join_cluster rabbit@rmq-node-1
rabbitmqctl start_app

# 3. 查看集群状态
rabbitmqctl cluster_status

# 4. 设置集群名称
rabbitmqctl set_cluster_name prod_rmq

# 5. 从集群中移除节点(在目标节点执行)
rabbitmqctl stop_app
rabbitmqctl reset
rabbitmqctl start_app
# 在存活节点上从远端摘除
rabbitmqctl forget_cluster_node rabbit@rmq-node-3

集群规划的几条硬规则:

  • 节点数用奇数(3 或 5)。Quorum queue 用 Raft,需要多数派,偶数节点容错能力和奇数一样但成本更高。
  • 不要用 ram 节点(--ram)。官方已不推荐,内存节点在重启后需要全量同步元数据,收益很小风险不小。全部用 disc 节点。
  • 集群内网络要低延迟稳定。Raft 对网络延迟敏感,跨机房部署 RabbitMQ 集群通常是个坏主意,跨地域应该用 federation 或 shovel 插件。
  • 队列不会自动跨节点均衡。Classic queue 的数据只在其声明时所在的节点上(镜像除外);quorum queue 的 leader 也固定在某个节点。节点负载不均要手工迁移队列 leader。
# 迁移 quorum queue 的 leader(均衡负载)
rabbitmqctl transfer_leader_for_queue -p /order order-create rabbit@rmq-node-2
# 或用 HTTP API
# POST /api/queues/%2Forder/order-create/transfer-leader {"node":"rabbit@rmq-node-2"}

五、监控与告警指标

指标获取方式告警阈值建议
队列消息总数list_queues messages 或 /api/queues持续 10 分钟 > 10000 且只增不减
Unacked 消息数list_queues messages_unacknowledged持续 5 分钟无变化(说明消费卡死)
消费者数量list_queues consumers等于 0 立即告警
死信队列深度DLQ 的 messages出现即告警(说明有消息处理失败)
内存水位rabbitmqctl status使用超过 40% 触发流控,超过 30% 预警
磁盘剩余rabbitmqctl status disk_free低于配置的水位线
连接数 / 通道数list_connections / list_channels突增检查是否连接泄漏
节点是否存活rabbitmqctl await_startup / 集群状态节点离线立即告警
流控状态连接上 blocked_by 字段出现即告警

RabbitMQ 自带 Prometheus 插件(rabbitmq_prometheus),强烈建议开启,它暴露 15692 端口,可以直接被 Prometheus 抓取,包含队列深度、消息速率、unacked 等全部关键指标。

rabbitmq-plugins enable rabbitmq_prometheus
curl -s http://localhost:15692/metrics | head -50

六、避坑清单

  • 必须删除或禁用默认 guest 账号。它只允许 localhost 登录,但如果有人配了代理绕过来就能拿到 administrator 权限。
  • 不要只靠 durable 就以为消息不丢。durable 只管队列元数据,消息要 delivery_mode=2,且必须开 publisher confirm。
  • 永远关闭 auto_ack。自动确认等于消息发出即删除,消费者崩溃就丢数据。
  • 磁盘水位线默认 50MB 太小,生产环境改成 disk_free_limit.relative = 2.0。
  • prefetch 不要设 0。无限制预取会让消息全堆在一个消费者身上,且崩溃恢复代价极大。
  • 生产队列必须配死信交换机,否则处理失败的消息要么无限重试要么无声消失。
  • requeue=True 要配失败计数,否则一条坏消息能让整个消费链路瘫痪。
  • 消费者处理逻辑必须设超时。HTTP 调用、数据库查询没设 timeout 是 unacked 堆积最常见的原因。
  • 不要跨机房组集群。Raft 和镜像同步都依赖低延迟网络,跨地域用 federation/shovel。
  • quorum queue 的副本数不能超过集群节点数,且建议奇数。
  • 注意 Erlang 版本匹配,装错版本 rabbitmq-server 会启动失败且报错信息不直观。
  • 备份要包含定义文件:rabbitmqctl export_definitions /backup/defs.json,它包含用户、vhost、权限、交换机、队列和 policy,恢复时用 import_definitions。

小结

RabbitMQ 的部署与优化可以归纳成三条主线。可靠性主线:队列 durable、消息 delivery_mode=2、开启 publisher confirm,三者缺一不可,并配合死信交换机兜底失败消息;新项目直接选 quorum queue,它用 Raft 保证已确认消息不丢,比老旧的镜像队列可靠得多。消费主线:一个应用一个 Connection、内部开多个 Channel,prefetch 按处理耗时设 20-300,必须手动 ack,用 Ready/Unacked 的分布判断堆积是"生产太快"还是"消费卡死"。资源主线:内存水位 0.4、磁盘水位设为内存的 1-2 倍,开启 Prometheus 插件把队列深度、unacked、消费者数、流控状态纳入告警。把这三条线都配置到位,RabbitMQ 就能稳定地承担起业务解耦和削峰填谷的职责;而其中最值得反复检查的一条是——你的消费者,到底有没有正确地 ack。