用 Rust 从零实现 Saga 编排器:补偿不是回滚
分布式事务里最容易被误解的一句话是"失败就回滚"。跨服务没有回滚,只有补偿。
回滚是"把数据改回去",它有原子性保证。补偿是"执行一个新的、方向相反的业务操作"——它可能失败、可能产生副作用、可能根本没法逆向。
这篇从零实现一个 Saga 编排器,重点讲清楚这条边界线。
为什么不能用两阶段提交
先从"为什么不用 2PC"说起,因为很多人第一反应是那个。
2PC 的思路是:所有参与者先"准备"(锁定资源),协调者确认全部就绪后再"提交"。它能提供原子性——但代价很大:
1. 同步阻塞:准备阶段所有参与者都要持有锁,等协调者决定
2. 协调者单点:协调者挂了,所有参与者一直卡在"准备完等决定"的状态
3. 无法容忍分区:网络分区时,参与者不知道该提交还是回滚根本问题在于它需要"跨服务的锁"。 在一组微服务之间维持一个分布式锁,既慢又脆。
Saga 换了个思路:不做准备阶段,直接执行。如果某一步失败,执行前面步骤的补偿动作。
正向: T1 -> T2 -> T3 -> T4
补偿: C1 <- C2 <- C3
失败在 T3 -> 执行 C2 -> C1没有锁,没有准备阶段,每一步本地提交。 代价是中间状态对外可见——T1、T2 已经真实生效了。
Saga 的核心权衡是"用中间的可见不一致,换取可用性和吞吐"。 接受这件事,才有 Saga。
第一步:把"步骤"和"补偿"配对
Saga 的基本单位是"一个正向操作 + 一个补偿操作":
#[async_trait::async_trait]
pub trait Step: Send + Sync {
/// 步骤名,用于日志和幂等键
fn name(&self) -> &str;
/// 正向执行
async fn execute(&self, ctx: &mut SagaContext) -> Result<(), StepError>;
/// 补偿(撤销)
async fn compensate(&self, ctx: &mut SagaContext) -> Result<(), StepError>;
}compensate 最常见的三个设计错误,都从签名上就能看出来。
错误一:compensate 返回 Result,但调用方忽略了 Err。
补偿失败是 Saga 里最难处理的情况。补偿失败 = 系统卡在一个"既没成功也没撤销"的中间状态,必须有人介入。忽略这个错误等于把问题藏起来。
错误二:补偿需要的数据没传进来。
比如"扣款"的补偿是"退款",而退款需要交易流水号——如果 execute 没有把这个号记录到上下文里,补偿就没法执行。
pub struct SagaContext {
/// 全局唯一的 Saga 实例 id
pub saga_id: String,
/// 业务标识(比如订单号)
pub business_key: String,
/// 每一步留下的数据,供补偿使用
values: std::collections::HashMap<String, serde_json::Value>,
}
impl SagaContext {
pub fn set<T: serde::Serialize>(&mut self, key: &str, value: &T) -> Result<(), StepError> {
let v = serde_json::to_value(value)
.map_err(|e| StepError::Context(e.to_string()))?;
self.values.insert(key.to_string(), v);
Ok(())
}
pub fn get<T: serde::de::DeserializeOwned>(&self, key: &str) -> Option<T> {
self.values
.get(key)
.and_then(|v| serde_json::from_value(v.clone()).ok())
}
}每个 execute 都必须把它"为了让补偿能执行"所需的最小信息写进上下文。 这是 Saga 设计里最需要自觉的一环。
错误三:以为补偿就是"反着做一遍"。
有些操作根本没有语义上合理的补偿:
| 正向操作 | 能补偿吗 |
|---|---|
| 扣款 | ✅ 退款 |
| 扣库存 | ✅ 加回库存 |
| 创建订单 | ✅ 取消订单 |
| 发送短信 | ❌ 发出去的短信收不回来 |
| 发送邮件 | ❌ 同上 |
| 调用外部支付网关 | ⚠️ 可能不支持退款,或者要人工 |
对于"不可补偿"的操作,有两条路:
- 改动设计,把它做成可补偿的——比如"发送短信"改成一个"待发送"记录,补偿就是"标记取消"(如果还没发出去)
- 把它放在 Saga 的最后一步——一旦成功,整个 Saga 就成功,不需要补偿
Saga 的设计顺序,本质上是"把不可补偿的操作尽量往后放"。 这是设计阶段就要做的决定,不是实现细节。
第二步:编排(Orchestration)还是编排(Choreography)
Saga 有两种组织方式:
编排式(Orchestration):有一个中心协调者,它知道整个流程,按顺序调用各服务。
┌──────────────┐
│ Orchestrator │
└──┬───┬───┬───┘
│ │ │
v v v
订单 库存 支付协同式(Choreography):没有中心,每个服务监听事件,自己决定下一步。
订单服务 --OrderCreated--> 库存服务 --StockReserved--> 支付服务
│
<--PaymentFailed----/
(订单服务监听 PaymentFailed,自己执行补偿)| 维度 | 编排式 | 协同式 |
|---|---|---|
| 流程可见性 | 集中,容易看清 | 分散在各服务 |
| 耦合度 | 服务之间不互相知道 | 服务要订阅彼此的事件 |
| 循环依赖风险 | 无 | 有(A 等 B,B 等 A) |
| 适用规模 | 步骤多(> 4-5 步) | 步骤少 |
我倾向编排式,主要理由是"可观测性"。 协同式在步骤一多的时候,想搞清楚"这个订单为什么卡住了"要翻五六个服务的日志。
而且编排式天然有一个"状态机"的落点——这正好可以用前面写过的 WAL 持久化。
第三步:Saga 状态机
一个 Saga 实例的状态:
#[derive(Debug, Clone, PartialEq)]
pub enum SagaState {
/// 刚开始
Started,
/// 正在执行第 n 步
Executing { step: usize },
/// 某一步失败,正在补偿
Compensating { step: usize },
/// 全部完成
Completed,
/// 补偿也全部完成(业务上视为"失败但一致")
Compensated,
/// 补偿失败,需要人工介入
Failed { step: usize, reason: String },
}Failed 这个状态必须有。 它是"补偿失败"的落点——系统必须能表达"我不一致,需要人管"这个事实,而不是假装成功或者假装失败。
impl SagaState {
pub fn is_terminal(&self) -> bool {
matches!(
self,
SagaState::Completed | SagaState::Compensated | SagaState::Failed { .. }
)
}
}第四步:执行引擎
pub struct SagaExecutor {
steps: Vec<Box<dyn Step>>,
store: std::sync::Arc<dyn SagaStore>,
}
#[async_trait::async_trait]
pub trait SagaStore: Send + Sync {
async fn save(&self, saga_id: &str, state: &SagaState, ctx: &SagaContext) -> Result<(), StoreError>;
async fn load(&self, saga_id: &str) -> Result<Option<(SagaState, SagaContext)>, StoreError>;
}SagaStore 这个抽象是 Saga 能"崩溃恢复"的基础。 每一次状态变更都落盘,进程重启后就能从上次的状态继续。
执行主流程:
impl SagaExecutor {
pub async fn run(&self, saga_id: &str, mut ctx: SagaContext) -> Result<(), SagaError> {
let mut state = SagaState::Started;
let mut completed = 0usize;
// ---------- 正向执行 ----------
for (i, step) in self.steps.iter().enumerate() {
state = SagaState::Executing { step: i };
self.store.save(saga_id, &state, &ctx).await?;
match step.execute(&mut ctx).await {
Ok(()) => {
completed += 1;
}
Err(e) => {
eprintln!("步骤 {} 失败: {e}", step.name());
// 进入补偿流程
return self.compensate(saga_id, &mut ctx, completed, &e.to_string()).await;
}
}
}
state = SagaState::Completed;
self.store.save(saga_id, &state, &ctx).await?;
Ok(())
}注意 save 在 execute 之前。 这个顺序很重要:
- 先保存"我要执行第 i 步",再执行
- 如果进程在执行中崩溃,恢复时知道"第 i 步可能执行了一半"
反过来先执行再保存,崩溃后就完全不知道有没有执行过。 这和前面 WAL 那篇的原则完全一致:先写日志,再做事。
第五步:补偿流程
async fn compensate(
&self,
saga_id: &str,
ctx: &mut SagaContext,
completed: usize,
reason: &str,
) -> Result<(), SagaError> {
// 逆序补偿已完成的步骤
let mut state = SagaState::Compensating { step: completed };
for i in (0..completed).rev() {
state = SagaState::Compensating { step: i };
self.store.save(saga_id, &state, ctx).await?;
let step = &self.steps[i];
// 补偿要重试!
match self.compensate_with_retry(step.as_ref(), ctx).await {
Ok(()) => continue,
Err(e) => {
// 补偿失败:进入 Failed,需要人工介入
let failed = SagaState::Failed {
step: i,
reason: format!("补偿失败: {e}; 原始失败: {reason}"),
};
self.store.save(saga_id, &failed, ctx).await?;
return Err(SagaError::CompensationFailed {
saga_id: saga_id.to_string(),
step: step.name().to_string(),
reason: e.to_string(),
});
}
}
}
let state = SagaState::Compensated;
self.store.save(saga_id, &state, ctx).await?;
Ok(())
}每一个补偿动作都要重试,而且要带退避:
async fn compensate_with_retry(
&self,
step: &dyn Step,
ctx: &mut SagaContext,
) -> Result<(), StepError> {
const MAX_ATTEMPTS: u32 = 5;
for attempt in 0..MAX_ATTEMPTS {
match step.compensate(ctx).await {
Ok(()) => return Ok(()),
Err(e) => {
// 最后一次失败就放弃
if attempt == MAX_ATTEMPTS - 1 {
return Err(e);
}
// 指数退避
let delay = std::time::Duration::from_millis(100 * 2u64.pow(attempt));
eprintln!(
"补偿 {} 第 {} 次失败:{e},{}ms 后重试",
step.name(), attempt + 1, delay.as_millis()
);
tokio::time::sleep(delay).await;
}
}
}
unreachable!()
}为什么补偿必须比正向更努力地重试?
因为正向失败是"预期内"的——业务规则不允许、库存不够等等,重试也没用。而补偿失败几乎总是暂时性的(网络抖动、下游重启),多试几次通常能成。
更关键的是:补偿失败的后果比正向失败严重得多。 正向失败只是"这单没做成";补偿失败是"钱扣了货没发,而且退款也失败了"。
Saga 里补偿的可靠性要求高于正向执行。 这是它和"业务失败重试"最重要的心态差异。
第六步:幂等——补偿和正向都必须幂等
网络重试意味着同一个操作可能被执行多次。所以每一步都必须幂等。
正向幂等靠业务唯一键:
pub struct DeductBalanceStep {
db: std::sync::Arc<Db>,
}
#[async_trait::async_trait]
impl Step for DeductBalanceStep {
fn name(&self) -> &str { "deduct_balance" }
async fn execute(&self, ctx: &mut SagaContext) -> Result<(), StepError> {
// 用(saga_id, step_name)作为幂等键
let idempotency_key = format!("{}:{}", ctx.saga_id, self.name());
// 唯一约束插入,冲突说明已经执行过
let inserted = self.db
.insert_if_absent("saga_operations", &idempotency_key)
.await?;
if !inserted {
return Ok(()); // 已经执行过,直接成功
}
// 真正的业务逻辑
let amount: u64 = ctx.get("amount").ok_or(StepError::MissingContext("amount"))?;
self.db.execute("UPDATE accounts SET balance = balance - ? WHERE id = ?", (amount, ctx.business_key)).await?;
Ok(())
}
}补偿幂等同理:
async fn compensate(&self, ctx: &mut SagaContext) -> Result<(), StepError> {
let idempotency_key = format!("{}:{}:compensated", ctx.saga_id, self.name());
if self.db.insert_if_absent("saga_operations", &idempotency_key).await?.is_false() {
return Ok(()); // 已经补偿过
}
let amount: u64 = ctx.get("amount").ok_or(StepError::MissingContext("amount"))?;
self.db.execute("UPDATE accounts SET balance = balance + ? WHERE id = ?", (amount, ctx.business_key)).await?;
Ok(())
}注意"幂等键"用的是 saga_id + step_name,而不是业务主键。
如果用的是业务主键(比如订单号),那么"同一订单发起两次不同的 Saga 流程"就会互相干扰。用 Saga 实例 id 才能正确区分"同一次流程的重试"和"两次不同的流程"。
第七步:悬空事务的处理
即使有幂等和重试,还是会遇到一个最难的情况:进程在"执行到一半"时崩溃。
具体说:
T+0 步骤 2 的 execute 已经发起了 RPC
T+1 进程崩溃
T+2 重启,恢复状态是 Executing { step: 2 }问题:步骤 2 到底执行了没有?
答案是:不知道。
这正是前面写过的"不确定状态",Saga 的解法分两种:
方案一:把状态记录在"业务操作"里(推荐)。让每个步骤自己维护"我执行到哪一步了"。恢复时去查业务状态:
async fn recover_step_2(ctx: &mut SagaContext) -> StepRecovery {
// 去业务侧查询:这个 saga 的扣款到底做了没有
match query_deduction_status(&ctx.saga_id).await {
DeductionStatus::Done => StepRecovery::AlreadyDone,
DeductionStatus::NotStarted => StepRecovery::NeedExecute,
DeductionStatus::Unknown => StepRecovery::NeedManual,
}
}方案二:把"执行中"这个状态细化。 记录 Executing { step: 2, phase: Phase::AfterRemoteCall }——但这需要步骤自己配合上报,复杂度高。
而且要接受一个现实:有些情况就是需要人工介入。 SagaState::Failed 和监控告警就是为这个准备的。
一个完整的例子:下单流程
pub fn build_order_saga(deps: Deps) -> SagaExecutor {
SagaExecutor::new(vec![
// 1. 创建订单(可补偿:取消订单)
Box::new(CreateOrderStep { db: deps.db.clone() }),
// 2. 扣库存(可补偿:加回库存)
Box::new(ReserveStockStep { inventory: deps.inventory.clone() }),
// 3. 扣款(可补偿:退款)
Box::new(DeductBalanceStep { db: deps.db.clone() }),
// 4. 发通知(不可补偿,放最后)
Box::new(NotifyStep { mq: deps.mq.clone() }),
])
}注意顺序设计:把不可补偿的"发通知"放在最后。
即使它失败了,前面的步骤都成功了,整个 Saga 也算成功(通知失败可以异步重试,不影响一致性)。这就避免了"通知失败要回滚订单、库存、扣款"这种荒谬的情况。
这就是为什么要"先设计补偿,再设计正向"。 一个步骤的补偿难度,直接决定了它该放在流程的哪个位置。
结论
Saga 的全部复杂度,都来自"补偿不是回滚"这一件事:
补偿是新的业务操作,可以失败,所以必须重试 + 告警 + 人工兜底;每个正向步骤都要把"补偿需要的数据"写进上下文;不可补偿的操作要尽量后置;进程崩溃导致的不确定状态必须由业务侧能查询、或者接受人工介入。
三条设计原则:
- 先设计补偿,再设计正向——补偿不了的步骤,要么改设计,要么放到最后
- 幂等键用
saga_id + step_name,不要用业务主键 - 补偿的可靠性要求高于正向——正向失败是预期内的,补偿失败是真事故
理解了这些,你再看 Seata、Temporal、Cadence 这些编排引擎,会发现它们提供的核心能力正是这几件事:状态持久化、幂等重试、补偿编排、以及给人看的失败状态。最后这一条最容易被忽略,但它是"能运维"和"不能运维"的分界线。