消息队列 / 系统课时

模拟故障验证可靠投递链路

模拟故障验证可靠投递链路

可靠投递不能只看正常流程。本节用一个故障实验脚本依次制造生产端断连、消费者在 ACK 前崩溃、重复消息和业务失败,并观察 Confirm、手动 ACK、幂等记录与死信队列分别在哪个故障点发挥作用。

学习目标

  • 能为四类常见故障设计可重复的验证步骤,而不是只做正常收发测试
  • 能根据 redelivered、Confirm 结果、幂等记录和死信队列判断机制是否生效
  • 能区分消息可能重复、业务已经提交但 ACK 未到达和业务明确失败三种情况

先定义故障链路的预期行为

故障测试的价值在于先写清“应该发生什么”,再制造故障。生产端失去 Confirm 时不能武断认定消息一定没到;消费者在业务提交后、ACK 前崩溃时应允许重投;重复消息要被幂等层吸收;明确不可继续处理的业务失败则可 NACK 且 requeue=false,让消息进入配置好的死信链路。

订单可靠投递四类故障验证流程

这四类故障不能混成一个结论。Confirm 关注生产端是否获得 Broker 确认,ACK 关注一次消费是否完成,幂等关注重复执行是否改变业务结果,死信关注明确失败后消息去了哪里。

用一个脚本完成四类实验

下面脚本使用独立的 order.reliability.quorum 队列,避免和其他练习的队列参数冲突。它还用本地 SQLite 保存已处理的 message_id,模拟数据库唯一约束。真实项目应把幂等记录和业务状态更新放进同一个本地事务,避免只完成其中一步。

python
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:

bash
python fault_lab.py disconnect

预期输出:

text
forced disconnect: no confirm
publish <ID> confirm=ack

真实网络还存在“消息已经写到 Broker,但 Confirm 在返回途中丢失”的不确定窗口。此时生产者不能凭断线判断第一次一定失败,通常应使用同一个消息 ID重试,并让下游幂等处理可能产生的重复消息。

再模拟消费者已经提交业务结果,但在 ACK 前断开连接:

bash
python fault_lab.py crash

预期输出:

text
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,不能只检查重投标记。

bash
python fault_lab.py duplicate

预期输出:

text
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 把消息路由到失败队列:

bash
python fault_lab.py business-fail

预期输出:

text
publish <ID> confirm=ack
receive <ID> redelivered=False
business failed <ID> -> dead-letter
dlq <ID>

用结果判断链路是否达标

这组实验的验收标准不是“控制台都打印成功”,而是每种故障都落到正确机制:失去 Confirm 时发送方不假装已确认;ACK 前崩溃时消息能够重投;重复消息不会让业务重复生效;明确失败的消息不会悄悄消失,而是能够在死信队列中被定位。

当四条路径都符合预期时,才能说明 Confirm、ACK、幂等和死信不是分别“配置过”,而是在同一条订单异步链路上形成了可以反复验证的可靠性闭环。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

模拟故障验证可靠投递链路

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通