《AI Agent 技术原理与架构·运行时、协议与系统架构》5.3 补偿、回滚与 Saga

单点幂等解决重试不重复,跨多步事务需要 Saga:每步声明正向动作与反向补偿,中间任一步失败就逆序补偿已完成的步骤。实验实现 Saga 编排器,注入第 3 步失败,统计补偿次数与回滚路径。结论是补偿必须显式声明,逆序执行,无全局锁靠每步可补偿逼近原子性。

以下部署 Saga 的步骤与补偿动作均为教学假设,不构成对任何真实系统、供应商或生产环境的承诺。“provision→reroute→notify"是讲解用的三步流,真实系统有自己的补偿语义,但"失败后逆序补偿已完成的步骤"这一条不变。

2.3 讲了崩溃恢复的三种手段:重放、补偿、对账。这一节展开补偿:当一次任务跨多步(不止一个工具调用、不止一个外部系统),某一步失败时,怎么把前面已完成的步骤撤销掉。

答案是 Saga。单点幂等(5.2)解决"重试不重复”,Saga 解决"多步失败怎么收场"。Saga 的核心不是技术,是纪律:每步声明正向动作与反向补偿,中间任一步失败,就逆序补偿已完成的步骤。 没有全局锁,靠"每步可补偿 + 逆序回滚"逼近原子性。

为什么多步任务需要 Saga

一个 W3 部署流程是三步:provision(开通资源)→ reroute(切换流量)→ notify(通知用户)。这三步没有全局事务——数据库回滚救不了已经发给用户的资源。

步骤正向反向补偿说明
provision开通资源销毁资源可补偿
reroute切换流量切回原流量可补偿
notify发送通知(无)不可补偿

如果 notify 失败(外部系统拒绝),已经做掉的 provision、reroute 怎么办?Saga 的答案是:逆序补偿——先撤销 reroute(切回原流量),再撤销 provision(销毁资源)。notify 本身不可补偿,留给对账(见 2.3)。

补偿必须显式声明、逆序执行

Saga 的两条纪律:

  1. 补偿显式声明。 每一步要么声明"我能怎么撤销"(compensate),要么声明"我不可补偿"。不可补偿的步骤在编排里就是透明的事实,失败时只能对账。
  2. 逆序执行。 失败发生在第 N 步,补偿顺序是 N−1, N−2, …, 1——先撤销最后成功的,一路退回去。逆序保证"后做的先撤",避免依赖顺序错乱。

没有全局锁是 Saga 与两阶段提交的区别。两阶段提交靠锁定让所有参与者"要么都成功要么都不做";Saga 不锁,靠补偿让"做过的能撤销"。代价是中间态可见(用户可能短暂看到已开通的资源),收益是没有锁的伸缩性。

最小实验:Saga 编排器

实验实现 Saga 编排器(add 注册步骤、execute 顺序执行、fail_at 注入失败),跑成功与失败两条路径。

# file: agp_lab/saga.py | write
# tier: 3
# verify: python3 -m unittest tests.test_saga
"""补偿、回滚与 Saga:多步事务的补偿编排。

单点幂等解决"重试不重复";跨多步事务需要 Saga:每步声明
正向动作与反向补偿,中间任一步失败,就逆序补偿已完成的步骤。
没有全局锁,靠"每步可补偿 + 逆序回滚"逼近原子性。

本模块实现一个 Saga 编排器,注入第 N 步失败,统计补偿次数
与回滚路径。
"""
from __future__ import annotations

from dataclasses import dataclass
from typing import Any, Callable


class SagaError(Exception):
    pass


@dataclass
class SagaStep:
    name: str
    run: Callable[[], None]
    compensate: Callable[[], None] | None = None


class Saga:
    def __init__(self) -> None:
        self.steps: list[SagaStep] = []
        self.log: list[str] = []

    def add(self, step: SagaStep) -> None:
        self.steps.append(step)

    def execute(self, fail_at: int | None = None) -> tuple[bool, str]:
        """按序执行;fail_at 指定第几步失败(1-based),失败后逆序补偿。"""
        done: list[SagaStep] = []
        for index, step in enumerate(self.steps, start=1):
            if fail_at == index:
                for compensation_step in reversed(done):
                    if compensation_step.compensate is not None:
                        compensation_step.compensate()
                        self.log.append(f"compensate {compensation_step.name}")
                self.log.append(f"rollback after {step.name}")
                return False, f"failed at {step.name}, compensated {len(done)}"
            step.run()
            done.append(step)
            self.log.append(f"done {step.name}")
        self.log.append("commit")
        return True, "committed"


def w3_saga() -> Saga:
    """W3 部署 Saga:provision → reroute → notify。"""
    saga = Saga()
    events: list[str] = []

    def provision() -> None:
        events.append("provision:on")

    def deprovision() -> None:
        events.append("provision:off")

    def reroute() -> None:
        events.append("reroute:on")

    def unreroute() -> None:
        events.append("reroute:off")

    def notify() -> None:
        events.append("notify:sent")

    saga.add(SagaStep("provision", provision, deprovision))
    saga.add(SagaStep("reroute", reroute, unreroute))
    saga.add(SagaStep("notify", notify, None))
    return saga


def demo() -> dict[str, Any]:
    success_saga = w3_saga()
    ok, message = success_saga.execute()
    failed_saga = w3_saga()
    ok2, message2 = failed_saga.execute(fail_at=3)
    return {
        "success": {"ok": ok, "message": message, "log": success_saga.log},
        "fail_at_3": {"ok": ok2, "message": message2, "log": failed_saga.log},
    }


if __name__ == "__main__":
    for key, value in demo().items():
        print(f"{key}: ok={value['ok']} message={value['message']}")
        print(f"  log={value['log']}")

运行:

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

输出:

success: ok=True message=committed
  log=['done provision', 'done reroute', 'done notify', 'commit']
fail_at_3: ok=False message=failed at notify, compensated 2
  log=['done provision', 'done reroute', 'compensate reroute', 'compensate provision', 'rollback after notify']

两段输出对应两条路径:

  1. success:三步全部成功,log 按序记录 done provision → done reroute → done notify,最后 commit。Saga 正常提交。
  2. fail_at_3:第 3 步 notify 失败。log 显示 done provision → done reroute 之后,立刻逆序补偿:compensate reroute → compensate provision,最后 rollback after notify。补偿次数 = 2,正好是 notify 之前成功且可补偿的两步。

两个值得点破的细节:

  • 补偿是逆序的。 compensate reroute 在 compensate provision 之前——先撤最后成功的(reroute),再撤更早的(provision)。顺序不能反,反了就破坏依赖。
  • notify 没被补偿。 notify 是第三步、没有补偿函数(compensate=None),所以失败时它自己不会被"撤销",只会触发对已成功步骤的补偿,然后留给对账。message='failed at notify, compensated 2' 精确表达了"谁失败、补偿了多少步"。

Saga 的编排器本身也要考虑崩溃。编排器在执行第 2 步补偿时崩溃了怎么办?如果补偿日志没有持久化,重启后不知道补偿到哪一步,只能重新枚举——而重新补偿一个已补偿的步骤,可能产生第二次撤销副作用。补偿日志要和正向事件一样持久化、可重放,这跟 2.2 的事件溯源是同一个要求。

编排器状态崩溃后果缓解
正向步骤重放正序事件日志
补偿步骤补偿到一半补偿日志持久化
提交提交成功与否终态判定幂等

还有一个边界认知:不是所有失败都值得补偿。如果失败发生在最后一步且该步骤不可补偿(如 notify),前面步骤全部补偿掉的代价可能大于保留——比如已经开通的资源,撤销要付违约金。Saga 不是"一律回滚",而是"按成本决定回滚多少"。实验里的 compensated 2 是机械决策,生产里这个数字应该由策略评估,而不是固定逻辑。

Saga 与两阶段提交(2PC)的对比,是选型时绕不开的。 2PC 保证强一致:所有参与者要么全提交、要么全回滚;但协调者是单点,参与者要长时间持有锁。Saga 用补偿换取可用性:没有全局锁、没有单点协调,但中间态对外可见,且"回滚"是补偿式的撤销而非真实的回退。

维度2PCSaga
一致性强一致最终一致
可用性协调者单点无单点
锁全程持锁无锁
回滚真实回退补偿撤销

选 Saga 的前提是"补偿存在"。 如果某个参与者的事务没有可用的补偿(比如不可撤销的外部动作),Saga 就不成立,只能考虑别的方案(预留资源、幂等重试)。实验里每个步骤都有补偿,是 Saga 适用的前提;选型第一步就是清点"每个步骤有没有补偿"。

补偿动作本身要幂等,这是 Saga 最容易被忽略的设计要求。补偿可能执行一次、两次或多次(网络重试、编排器重放),每次执行的结果必须相同——重复撤销不能产生重复副作用。幂等补偿靠"补偿以终态为准":补偿前查目标资源当前状态,已撤销就跳过,未撤销才执行撤销。

补偿执行次数幂等补偿非幂等补偿
1 次正常撤销正常撤销
2 次第二次跳过副作用重复
多次始终跳过不可恢复

补偿的终态判定还要考虑"并发补偿"。 编排器重启重放时,旧补偿可能还没跑完、新补偿又启动。用状态机的守卫(2.1)加"补偿中"状态互斥:同一资源同一时刻只允许一个补偿事务。补偿与正向一样要走状态机,而不是裸的 try/except 序列。

Saga 的编排方式也有两种选择:编排式(orchestration,中央编排器一步步指挥)与编舞式(choreography,参与者靠事件互相触发)。实验用的是编排式——补偿路径集中在编排器,好理解、好测试。编舞式把步骤散在参与者事件里,扩展性强但补偿路径分散,出了事难追溯。小规模用编排式,规模大到编排器成为瓶颈再谈编舞。

编排方式补偿控制扩展性可追溯性
编排式集中低高
编舞式分散高低

编排式还有一个好处:补偿顺序由编排器统一决定。 Saga 的补偿通常是反向序(先撤销最后成功的步骤),编排器持有步骤列表就能算出反向序;编舞式要参与者各自维护"谁依赖我",顺序容易错。补偿顺序是 Saga 正确性的另一半,值得显式维护而不是隐式推断。

架构判据

Saga 实现是否合格,用五条判据检查:

判据合格的样子不合格的样子
每步可补偿声明每步声明补偿或不可补偿补偿散落、无显式声明
逆序补偿失败后逆序撤销已成功步骤顺序补偿或跳过
失败定位消息说清失败步与补偿数失败后静默
不可补偿兜底不可补偿步骤留给对账不可补偿步骤被忽略
无全局锁靠补偿逼近原子性依赖全局锁

判据第一条是 Saga 的地基:补偿不显式声明,逆序就无从谈起。 判据第四条提醒:不可补偿的步骤(如 notify)不是 Saga 的失败,是 Saga 的边界——它触发补偿已成功步骤,自己留给对账。

小结

  • 单点幂等解决重试不重复,Saga 解决多步失败怎么收场。
  • Saga 两条纪律:每步显式声明补偿,失败后逆序补偿已完成的步骤。
  • 无全局锁,靠"每步可补偿 + 逆序回滚"逼近原子性;中间态可见是代价。
  • 不可补偿的步骤触发对已成功步骤的补偿,自己留给对账。

阅读导航:上一节:5.2 校验、幂等与重试 · 下一节:6.1 Function Calling 与 MCP 。

常见错误与边界

  1. 补偿不显式声明。 没有 compensate 声明的步骤,失败时无法撤销;要每步都回答"能怎么撤"。
  2. 顺序补偿。 补偿必须逆序:先撤最后成功的;顺序错了会破坏依赖。
  3. 以为 Saga 是原子事务。 Saga 不锁,中间态可见;它逼近原子性,不等于两阶段提交。
  4. 忽略不可补偿步骤。 notify 这种不可补偿的步骤不是 Saga 的失败,是边界;要留给对账。
  5. 失败后不定位。 失败信息要说清"哪步失败、补偿了多少",否则运维无法对账。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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