消息队列 / 系统课时
模拟故障验证可靠投递链路
模拟故障验证可靠投递链路
可靠投递不能只看正常流程。本节用一个故障实验脚本依次制造生产端断连、消费者在 ACK 前崩溃、重复消息和业务失败,并观察 Confirm、手动 ACK、幂等记录与死信队列分别在哪个故障点发挥作用。
学习目标
- 能为四类常见故障设计可重复的验证步骤,而不是只做正常收发测试
- 能根据
redelivered、Confirm 结果、幂等记录和死信队列判断机制是否生效 - 能区分消息可能重复、业务已经提交但 ACK 未到达和业务明确失败三种情况
先定义故障链路的预期行为
故障测试的价值在于先写清“应该发生什么”,再制造故障。生产端失去 Confirm 时不能武断认定消息一定没到;消费者在业务提交后、ACK 前崩溃时应允许重投;重复消息要被幂等层吸收;明确不可继续处理的业务失败则可 NACK 且 requeue=false,让消息进入配置好的死信链路。

这四类故障不能混成一个结论。Confirm 关注生产端是否获得 Broker 确认,ACK 关注一次消费是否完成,幂等关注重复执行是否改变业务结果,死信关注明确失败后消息去了哪里。
用一个脚本完成四类实验
下面脚本使用独立的 order.reliability.quorum 队列,避免和其他练习的队列参数冲突。它还用本地 SQLite 保存已处理的 message_id,模拟数据库唯一约束。真实项目应把幂等记录和业务状态更新放进同一个本地事务,避免只完成其中一步。
import argparse
import json
import os
import sqlite3
import uuid
import pika
AMQP_URL = os.getenv(
"AMQP_URL",
"amqp://guest:guest@localhost:5672/%2F",
)
DB_PATH = os.getenv("IDEMPOTENCY_DB", "idempotency.db")
MAIN_QUEUE = "order.reliability.quorum"
DLX = "order.reliability.dlx"
DLQ = "order.reliability.failed"
def connect():
conn = pika.BlockingConnection(pika.URLParameters(AMQP_URL))
return conn, conn.channel()
def setup(channel):
# 失败消息经 direct DLX 路由到独立失败队列。
channel.exchange_declare(
exchange=DLX,
exchange_type="direct",
durable=True,
)
channel.queue_declare(queue=DLQ, durable=True)
channel.queue_bind(
queue=DLQ,
exchange=DLX,
routing_key="order.failed",
)
channel.queue_declare(
queue=MAIN_QUEUE,
durable=True,
arguments={
"x-queue-type": "quorum",
"x-dead-letter-exchange": DLX,
"x-dead-letter-routing-key": "order.failed",
},
)
def publish(message_id):
conn, channel = connect()
setup(channel)
channel.confirm_delivery()
body = json.dumps({"orderId": message_id}).encode("utf-8")
channel.basic_publish(
exchange="",
routing_key=MAIN_QUEUE,
body=body,
mandatory=True,
properties=pika.BasicProperties(
message_id=message_id,
delivery_mode=2,
content_type="application/json",
),
)
print(f"publish {message_id} confirm=ack")
conn.close()
def is_processed(message_id):
# 主键唯一约束模拟持久化幂等记录。
with sqlite3.connect(DB_PATH) as db:
db.execute(
"CREATE TABLE IF NOT EXISTS processed_messages "
"(message_id TEXT PRIMARY KEY)"
)
row = db.execute(
"SELECT 1 FROM processed_messages WHERE message_id = ?",
(message_id,),
).fetchone()
return row is not None
def mark_processed(message_id):
with sqlite3.connect(DB_PATH) as db:
db.execute(
"INSERT INTO processed_messages(message_id) VALUES (?)",
(message_id,),
)
def consume_once(crash_after_commit=False, business_fail=False):
conn, channel = connect()
setup(channel)
method, props, _ = channel.basic_get(
queue=MAIN_QUEUE,
auto_ack=False,
)
if method is None:
print("main queue empty")
conn.close()
return
message_id = props.message_id
print(
f"receive {message_id} "
f"redelivered={method.redelivered}"
)
if business_fail:
channel.basic_nack(
delivery_tag=method.delivery_tag,
requeue=False,
)
print(f"business failed {message_id} -> dead-letter")
conn.close()
return
if is_processed(message_id):
channel.basic_ack(delivery_tag=method.delivery_tag)
print(f"duplicate {message_id} -> ack")
conn.close()
return
mark_processed(message_id)
print(f"business committed {message_id}")
# 故意在业务提交后、ACK 前断开,制造重投窗口。
if crash_after_commit:
print("simulate crash before ack")
conn.close()
return
channel.basic_ack(delivery_tag=method.delivery_tag)
print(f"ack {message_id}")
conn.close()
def show_dlq():
conn, channel = connect()
setup(channel)
method, props, _ = channel.basic_get(queue=DLQ, auto_ack=False)
if method is None:
print("dlq empty")
else:
print(f"dlq {props.message_id}")
channel.basic_ack(delivery_tag=method.delivery_tag)
conn.close()
def simulate_disconnect(message_id):
conn, channel = connect()
setup(channel)
channel.confirm_delivery()
conn.close()
try:
channel.basic_publish(
exchange="",
routing_key=MAIN_QUEUE,
body=b"{}",
)
except pika.exceptions.AMQPError:
print("forced disconnect: no confirm")
publish(message_id)
parser = argparse.ArgumentParser()
parser.add_argument(
"mode",
choices=["disconnect", "crash", "duplicate", "business-fail"],
)
args = parser.parse_args()
mid = f"{args.mode}-{uuid.uuid4().hex[:8]}"
# 每种模式只改变一个关键故障条件,便于判断结果。
if args.mode == "disconnect":
simulate_disconnect(mid)
elif args.mode == "crash":
publish(mid)
consume_once(crash_after_commit=True)
consume_once()
elif args.mode == "duplicate":
publish(mid)
publish(mid)
consume_once()
consume_once()
else:
publish(mid)
consume_once(business_fail=True)
show_dlq()这个完整程序保存为 fault_lab.py,由下面四个命令分别选择故障模式;每条命令后都给出对应的预期输出。SQLite 仅用于展示“稳定消息 ID + 唯一约束”的幂等思路,并不是分布式事务方案。脚本每次生成新的 <ID>,因此可以反复实验。
验证生产端断连与消费者崩溃
先模拟连接已经断开时继续发送,再重新连接并正常发布。确定性结果是第一次没有获得 Confirm,第二次获得 Confirm:
python fault_lab.py disconnect预期输出:
forced disconnect: no confirm
publish <ID> confirm=ack真实网络还存在“消息已经写到 Broker,但 Confirm 在返回途中丢失”的不确定窗口。此时生产者不能凭断线判断第一次一定失败,通常应使用同一个消息 ID重试,并让下游幂等处理可能产生的重复消息。
再模拟消费者已经提交业务结果,但在 ACK 前断开连接:
python fault_lab.py crash预期输出:
publish <ID> confirm=ack
receive <ID> redelivered=False
business committed <ID>
simulate crash before ack
receive <ID> redelivered=True
duplicate <ID> -> ack第二次投递出现 redelivered=True,说明 RabbitMQ 没把第一次未 ACK 的投递视为完成。幂等表发现该 message_id 已处理,于是不重复执行业务,只补发 ACK,这正是“业务已成功但确认未到达”时需要的行为。
验证重复消息与业务失败
主动发布两次相同 message_id,可以验证重复消息并不依赖 redelivered=True 才会出现。两条独立发布的消息都可能是首次投递,因此幂等判断必须依据稳定的业务键或消息 ID,不能只检查重投标记。
python fault_lab.py duplicate预期输出:
publish <ID> confirm=ack
publish <ID> confirm=ack
receive <ID> redelivered=False
business committed <ID>
ack <ID>
receive <ID> redelivered=False
duplicate <ID> -> ack最后模拟明确的业务失败。脚本执行 basic_nack(..., requeue=False),RabbitMQ 根据队列配置的 DLX 把消息路由到失败队列:
python fault_lab.py business-fail预期输出:
publish <ID> confirm=ack
receive <ID> redelivered=False
business failed <ID> -> dead-letter
dlq <ID>用结果判断链路是否达标
这组实验的验收标准不是“控制台都打印成功”,而是每种故障都落到正确机制:失去 Confirm 时发送方不假装已确认;ACK 前崩溃时消息能够重投;重复消息不会让业务重复生效;明确失败的消息不会悄悄消失,而是能够在死信队列中被定位。
当四条路径都符合预期时,才能说明 Confirm、ACK、幂等和死信不是分别“配置过”,而是在同一条订单异步链路上形成了可以反复验证的可靠性闭环。