返回文章列表

用 Rust 从零实现 Saga 编排器:补偿不是回滚

537 字·4 分钟阅读
Rust从零造轮子分布式事务

分布式事务里最容易被误解的一句话是"失败就回滚"。跨服务没有回滚,只有补偿。

回滚是"把数据改回去",它有原子性保证。补偿是"执行一个新的、方向相反的业务操作"——它可能失败、可能产生副作用、可能根本没法逆向。

这篇从零实现一个 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 设计里最需要自觉的一环。

错误三:以为补偿就是"反着做一遍"。

有些操作根本没有语义上合理的补偿:

正向操作 能补偿吗
扣款 ✅ 退款
扣库存 ✅ 加回库存
创建订单 ✅ 取消订单
发送短信 ❌ 发出去的短信收不回来
发送邮件 ❌ 同上
调用外部支付网关 ⚠️ 可能不支持退款,或者要人工

对于"不可补偿"的操作,有两条路:

  1. 改动设计,把它做成可补偿的——比如"发送短信"改成一个"待发送"记录,补偿就是"标记取消"(如果还没发出去)
  2. 把它放在 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 的全部复杂度,都来自"补偿不是回滚"这一件事:

补偿是新的业务操作,可以失败,所以必须重试 + 告警 + 人工兜底;每个正向步骤都要把"补偿需要的数据"写进上下文;不可补偿的操作要尽量后置;进程崩溃导致的不确定状态必须由业务侧能查询、或者接受人工介入。

三条设计原则:

  1. 先设计补偿,再设计正向——补偿不了的步骤,要么改设计,要么放到最后
  2. 幂等键用 saga_id + step_name,不要用业务主键
  3. 补偿的可靠性要求高于正向——正向失败是预期内的,补偿失败是真事故

理解了这些,你再看 Seata、Temporal、Cadence 这些编排引擎,会发现它们提供的核心能力正是这几件事:状态持久化、幂等重试、补偿编排、以及给人看的失败状态。最后这一条最容易被忽略,但它是"能运维"和"不能运维"的分界线。