《AI Agent 技术原理与架构·运行时、协议与系统架构》2.3 崩溃恢复:重放、补偿与故障注入

崩溃发生在哪一步,决定了恢复用什么手段:没执行的步骤可重放,副作用已发生未确认的步骤需要幂等重试或补偿,不可逆的副作用只能对账。实验对三步事务注入五个崩溃点,返回各自的恢复方案矩阵,说明为什么不能把恢复策略写死成一种,以及故障注入为什么必须成为发布流程的一部分。

以下步骤 A/B/C、崩溃点与恢复方案均为教学假设,不构成对任何真实系统、供应商或生产环境的承诺。“发外部通知不可逆"是讲解用的例子,真实系统里很多通知其实可以补偿(撤回、更正),但"不可逆步骤只能对账"这一条不变。

2.2 讲了执行语义:事件溯源、持久化执行、幂等副作用。这一节问一个更残酷的问题:不管语义设计得多好,崩溃总会发生。崩溃之后怎么办?

答案不是"加重试”,而是分情况。崩溃发生在哪一步,决定了恢复手段:没执行的步骤可重放,副作用已发生但没确认的步骤需要幂等重试或补偿,不可逆的副作用只能对账。把恢复策略写死成一种,是崩溃恢复最常见的错误。

三种恢复手段的边界

崩溃恢复有三种基本手段,各管一段:

手段适用情形前提示例
重放步骤还没执行,或副作用幂等副作用可重复执行重试 B(B 幂等)
补偿副作用已发生,步骤不可重放但可撤销有反向动作撤销 A 的写操作
对账不可重放也不可撤销有外部事实可核对人工核对通知清单

重放的前提是幂等。 如果步骤副作用可重复执行(比如"写入某个 key 的固定值"),崩溃后重放安全;如果不可重复(比如"发一次性通知"),重放就是二次副作用。

补偿是撤销。 补偿不撤销"重放",而是撤销"已经发生的事"。补偿的前提是每步都有反向动作:创建了资源就能销毁,改写了配置就能还原。

对账是最后的兜底。 有些副作用既不可重放也不可撤销:给第三方发了通知、向外部系统提交了无法撤回的请求。这种步骤只能靠对账——比较外部事实与内部记录,发现漏的补、多的查。

关键认知:对账越多,说明恢复自动化越弱。 设计的目标是把不可重放、不可撤销的步骤压到最少,让大部分崩溃都能靠重放或补偿自动恢复。

崩溃点矩阵:一个三步事务的五种死法

用一个三步事务 A→B→C 演示。A 可补偿不可重放(写库,重复会重复副作用),B 幂等且可补偿(写固定值),C 不可逆(发外部通知)。崩溃可能落在五个点,每种死法恢复方案不同:

崩溃点发生了什么恢复
before-A什么都没发生重放 A、B、C
after-A-commitA 已确认重放 B、C
mid-B-side-effectB 副作用已发生未确认重放 B(B 幂等)
after-B-commitA、B 已确认重放 C
mid-C-side-effectC 副作用已发生未确认(不可逆)补偿 A、B

这五个点覆盖了执行语义的三种典型死法:干净死、脏死、不可逆死。下面用实验跑出来。

最小实验:故障注入矩阵

实验把 A/B/C 建模成带两个属性(idempotent、compensable)的步骤,对五个崩溃点分别返回恢复方案,并统计总补偿次数。

# file: agp_lab/crash_recovery.py | write
# tier: 3
# verify: python3 -m unittest tests.test_crash_recovery
"""崩溃恢复:重放、补偿与故障注入矩阵。

恢复策略不是唯一答案。三步事务 A→B→C,崩溃点不同,
恢复动作就不同:未执行的步骤可重放,副作用已发生未确认的
步骤需要幂等重试或补偿,不可逆的副作用只能对账。

本模块注入五类崩溃点,返回每个崩溃点的恢复方案
(重放步骤 / 补偿步骤 / 对账提示),说明
"重放、补偿、对账"各自的边界。
"""
from __future__ import annotations

from dataclasses import dataclass
from typing import Any


@dataclass(frozen=True)
class Step:
    name: str
    idempotent: bool  # True:重放安全(重复执行无新副作用)
    compensable: bool  # True:可以补偿撤销


STEPS: list[Step] = [
    Step("A", idempotent=False, compensable=True),
    Step("B", idempotent=True, compensable=True),
    Step("C", idempotent=False, compensable=False),  # 不可逆,如发外部通知
]


def recovery(crash_point: str, steps: list[Step] | None = None) -> dict[str, list[str]]:
    """按崩溃点返回恢复方案 {retry, compensate, reconcile}。

    crash_point 取值:
    - "before-A"          :什么都没发生;
    - "after-A-commit"    :A 已确认;
    - "mid-B-side-effect" :B 副作用已发生但未确认;
    - "after-B-commit"    :A、B 已确认;
    - "mid-C-side-effect" :C 副作用已发生但未确认(不可逆)。
    """
    seq = steps or STEPS
    a, b, c = seq
    if crash_point == "before-A":
        return {"retry": ["A", "B", "C"], "compensate": [], "reconcile": []}
    if crash_point == "after-A-commit":
        return {"retry": ["B", "C"], "compensate": [], "reconcile": []}
    if crash_point == "mid-B-side-effect":
        # B 副作用已发生:幂等则重放,否则补偿 A。
        retry = ["B"] if b.idempotent else []
        compensate = [] if b.idempotent else (["A"] if a.compensable else [])
        reconcile = [] if (b.idempotent or a.compensable) else ["B"]
        return {"retry": retry, "compensate": compensate, "reconcile": reconcile}
    if crash_point == "after-B-commit":
        return {"retry": ["C"], "compensate": [], "reconcile": []}
    if crash_point == "mid-C-side-effect":
        # C 不可逆:若可重放则重放,否则补偿 A、B。
        retry = ["C"] if c.idempotent else []
        compensate = [] if c.idempotent else (
            [step.name for step in (a, b) if step.compensable]
        )
        reconcile = [] if (c.idempotent or compensate) else ["C"]
        return {"retry": retry, "compensate": compensate, "reconcile": reconcile}
    raise ValueError(f"未知崩溃点: {crash_point}")


def fault_injection() -> dict[str, dict[str, list[str]]]:
    """遍历所有崩溃点,得到故障注入矩阵。"""
    points = [
        "before-A",
        "after-A-commit",
        "mid-B-side-effect",
        "after-B-commit",
        "mid-C-side-effect",
    ]
    return {point: recovery(point) for point in points}


def demo() -> dict[str, Any]:
    """打印故障注入矩阵与总补偿次数。"""
    matrix = fault_injection()
    total_compensations = sum(
        len(plan["compensate"]) for plan in matrix.values()
    )
    return {"matrix": matrix, "total_compensations": total_compensations}


if __name__ == "__main__":
    result = demo()
    print(f"{'crash_point':<20}{'retry':<16}{'compensate':<14}{'reconcile'}")
    for point, plan in result["matrix"].items():
        print(
            f"{point:<20}{','.join(plan['retry']):<16}"
            f"{','.join(plan['compensate']):<14}{','.join(plan['reconcile'])}"
        )
    print(f"total_compensations={result['total_compensations']}")

运行:

cd private/labs/agp-lab
python3 -m agp_lab.crash_recovery

输出:

crash_point         retry           compensate    reconcile
before-A            A,B,C                         
after-A-commit      B,C                           
mid-B-side-effect   B                             
after-B-commit      C                             
mid-C-side-effect                   A,B           
total_compensations=2

五行输出对应五种死法:

  1. before-A:retry=[A,B,C]。没发生任何副作用,从头重放,零补偿。
  2. after-A-commit:retry=[B,C]。A 已确认,从 B 继续。
  3. mid-B-side-effect:retry=[B]。B 的副作用已发生但没确认——这是最需要决策的一个点。因为 B 是幂等的(idempotent=True),所以重放 B 安全,不需要补偿 A,也不需要 reconcile。
  4. after-B-commit:retry=[C]。A、B 都确认了,只剩 C。
  5. mid-C-side-effect:retry=[],compensate=[A,B]。C 不可逆(compensable=False、idempotent=False),没法重放也没法撤销。恢复方案退化为补偿 A、B——把前面能撤销的步骤撤销掉,C 本身只能对账(reconcile 为空是因为 compensate 已覆盖 A、B,C 留给外部核对)。

total_compensations=2 就是第 5 点的 A、B 两笔。这个矩阵的工程含义是:恢复策略必须按崩溃点分派,不能写死。 如果代码里只有一个"统一重试",mid-C 会去重试 C,产生第二次通知副作用;如果只有一个"统一补偿",before-A 会去撤销什么都没做的事,也可能出问题。

故障注入为什么必须进发布流程

实验是手动注入。生产里,崩溃点不是靠运气出现的——应该把故障注入做成发布流程的一部分:每次发布前,在模拟环境里对每个崩溃点强制注入,验证恢复逻辑真的给出了期望的方案。不做故障注入,恢复逻辑就是"纸面上存在、实战没验证过"。

崩溃恢复的另一个被低估的点是恢复动作本身也要可测试。重放路径、补偿路径、对账路径,三条路径都要能在测试里强制走到。故障注入矩阵的价值,就是把"崩溃发生在哪一步"从偶发变成枚举:五个点逐个注入,每个点断言恢复方案符合预期。没有矩阵的恢复逻辑,等于没有验证过。

矩阵还揭示了容量规划的含义:崩溃恢复的高峰,往往发生在故障之后的补偿或重放。如果补偿路径比正向路径更重,峰值容量就不能只看正常流量的吞吐。评估"恢复能不能扛住",要把最坏崩溃点对应的补偿/重放负载也算进去。

恢复目标要用可度量的指标来定义,两个最常用的是 RTO(恢复时间目标)与 RPO(恢复点目标):

指标定义决定因素
RTO故障后多久恢复可用重放/补偿路径耗时
RPO最多丢失多少数据日志批量落盘间隔
MTTR平均恢复时长恢复方案复杂度

RPO 为 0 意味着每条事件都要同步落盘,写放大高但数据零丢失;RPO 允许秒级,就可以批量刷盘、吞吐更高。RPO 不是越大越好,是"业务能接受丢多少"的技术翻译。 把恢复矩阵的每一格标上 RTO/RPO,恢复能力就从"能恢复"变成"可承诺"。

恢复还有一条可验证性要求:恢复路径本身要经常被演练。只测"正常路径 + 偶尔故障"的系统,恢复逻辑是最没人碰、最容易在真故障时出问题的代码。生产实践的三个做法:

做法内容防什么
故障注入定期注入崩溃点恢复路径无人测试
恢复演练全链路演练 RTO/RPO恢复只在纸面上成立
混沌测试随机故障叠加单点恢复掩盖连锁故障

恢复能力是演练出来的,不是设计出来的。 矩阵枚举了所有崩溃点,演练确认每个点真的能按矩阵恢复——设计与验证互为表里。

架构判据

崩溃恢复是否合格,用五条判据检查:

判据合格的样子不合格的样子
步骤元数据每步声明幂等性、可补偿性副作用属性埋在代码里
按点分派崩溃点决定恢复手段统一的"重试"或"补偿"
可逆步骤最少不可逆步骤被压到最少到处是发外部通知
故障注入崩溃点在发布前被强制注入验证恢复逻辑从未实战
对账兜底不可逆步骤有明确对账机制不可逆步骤静默吞掉

判据的核心是第二步:崩溃点分派。 有了步骤元数据,恢复逻辑才能按点决策;没有元数据,就只能笼统重试,然后制造二次副作用。

小结

  • 恢复有三种手段:重放(前提幂等)、补偿(前提可撤销)、对账(兜底,不可自动)。
  • 崩溃发生在哪一步决定用哪种手段;五个崩溃点对应三种典型死法:干净死、脏死、不可逆死。
  • 恢复策略不能写死成一种;不可逆步骤只能对账,目标是把这类步骤压到最少。
  • 故障注入必须进发布流程,恢复逻辑不能"纸面存在"。

阅读导航:上一节:2.2 执行语义:事件溯源、持久化执行与幂等副作用 · 下一节:3.1 队列、优先级与公平调度 。

常见错误与边界

  1. 统一重试。 对不可逆步骤(mid-C)重试会制造二次副作用;恢复必须按崩溃点分派。
  2. 统一补偿。 对什么都没发生的步骤(before-A)补偿会撤销不存在的东西。
  3. 不声明副作用属性。 步骤幂等性、可补偿性要显式建模,恢复逻辑才有依据。
  4. 把对账当万能。 对账只能发现不一致,不能消除不一致;对账越多说明自动化越弱。
  5. 恢复逻辑不验证。 故障注入要进发布流程;没注入过就等于没验证过。

继续阅读

探索更多技术文章

浏览归档,发现更多关于系统设计、工具链和工程实践的内容。

全部文章 返回首页

「books」更多文章

  1. 《大规模分布式计算深入解析》15.3 落地:从 Neo4j 到自研图引擎
  2. 《大规模分布式计算深入解析·图计算与图数据库内核》 · 目录与学习路径(45 篇)
  3. 《大规模分布式计算深入解析》15.2 十一卷主线:从切分到图