以下步骤 A/B/C、崩溃点与恢复方案均为教学假设,不构成对任何真实系统、供应商或生产环境的承诺。“发外部通知不可逆"是讲解用的例子,真实系统里很多通知其实可以补偿(撤回、更正),但"不可逆步骤只能对账"这一条不变。
2.2 讲了执行语义:事件溯源、持久化执行、幂等副作用。这一节问一个更残酷的问题:不管语义设计得多好,崩溃总会发生。崩溃之后怎么办?
答案不是"加重试”,而是分情况。崩溃发生在哪一步,决定了恢复手段:没执行的步骤可重放,副作用已发生但没确认的步骤需要幂等重试或补偿,不可逆的副作用只能对账。把恢复策略写死成一种,是崩溃恢复最常见的错误。
三种恢复手段的边界
崩溃恢复有三种基本手段,各管一段:
| 手段 | 适用情形 | 前提 | 示例 |
|---|---|---|---|
| 重放 | 步骤还没执行,或副作用幂等 | 副作用可重复执行 | 重试 B(B 幂等) |
| 补偿 | 副作用已发生,步骤不可重放但可撤销 | 有反向动作 | 撤销 A 的写操作 |
| 对账 | 不可重放也不可撤销 | 有外部事实可核对 | 人工核对通知清单 |
重放的前提是幂等。 如果步骤副作用可重复执行(比如"写入某个 key 的固定值"),崩溃后重放安全;如果不可重复(比如"发一次性通知"),重放就是二次副作用。
补偿是撤销。 补偿不撤销"重放",而是撤销"已经发生的事"。补偿的前提是每步都有反向动作:创建了资源就能销毁,改写了配置就能还原。
对账是最后的兜底。 有些副作用既不可重放也不可撤销:给第三方发了通知、向外部系统提交了无法撤回的请求。这种步骤只能靠对账——比较外部事实与内部记录,发现漏的补、多的查。
关键认知:对账越多,说明恢复自动化越弱。 设计的目标是把不可重放、不可撤销的步骤压到最少,让大部分崩溃都能靠重放或补偿自动恢复。
崩溃点矩阵:一个三步事务的五种死法
用一个三步事务 A→B→C 演示。A 可补偿不可重放(写库,重复会重复副作用),B 幂等且可补偿(写固定值),C 不可逆(发外部通知)。崩溃可能落在五个点,每种死法恢复方案不同:
| 崩溃点 | 发生了什么 | 恢复 |
|---|---|---|
| before-A | 什么都没发生 | 重放 A、B、C |
| after-A-commit | A 已确认 | 重放 B、C |
| mid-B-side-effect | B 副作用已发生未确认 | 重放 B(B 幂等) |
| after-B-commit | A、B 已确认 | 重放 C |
| mid-C-side-effect | C 副作用已发生未确认(不可逆) | 补偿 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
五行输出对应五种死法:
- before-A:retry=[A,B,C]。没发生任何副作用,从头重放,零补偿。
- after-A-commit:retry=[B,C]。A 已确认,从 B 继续。
- mid-B-side-effect:retry=[B]。B 的副作用已发生但没确认——这是最需要决策的一个点。因为 B 是幂等的(idempotent=True),所以重放 B 安全,不需要补偿 A,也不需要 reconcile。
- after-B-commit:retry=[C]。A、B 都确认了,只剩 C。
- 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 队列、优先级与公平调度 。
常见错误与边界
- 统一重试。 对不可逆步骤(mid-C)重试会制造二次副作用;恢复必须按崩溃点分派。
- 统一补偿。 对什么都没发生的步骤(before-A)补偿会撤销不存在的东西。
- 不声明副作用属性。 步骤幂等性、可补偿性要显式建模,恢复逻辑才有依据。
- 把对账当万能。 对账只能发现不一致,不能消除不一致;对账越多说明自动化越弱。
- 恢复逻辑不验证。 故障注入要进发布流程;没注入过就等于没验证过。
继续阅读
探索更多技术文章
浏览归档,发现更多关于系统设计、工具链和工程实践的内容。