返回文章列表

用 Rust 从零搭一个集群调度器:期望状态和实际状态之间隔着什么

1118 字·9 分钟阅读
Rust从零造轮子集群调度

前面每个系统的形状都很清楚:

时序库:  数据进来 → 编码存下 → 查询出去
DNS:     问题进来 → 查缓存/上游 → 答案出去
IM:      消息进来 → 分配序号 → 投递出去
版本控制:操作进来 → 生成对象 → 更新引用

它们都有"处理完"这个状态。而调度器没有。

调度器的输入:你希望集群是"3 个副本、每个用 2 核 4G"
调度器的输出:集群实际是"2 个副本在跑,1 个在重启循环"
 
这两者之间的差距,是调度器唯一关心的东西。
而它的工作就是:永不停止地缩小这个差距。

这篇讲的就是这个循环怎么设计,以及为什么它必须是"永不停止"的。

第一步:为什么必须是声明式

假设你要"确保有三个副本在跑"。有两种 API 风格:

命令式: POST /replicas {"count": 3}
  → 服务器收到命令:嗯,现在有 1 个,我再启动 2 个
  → 启动第 1 个成功,启动第 2 个时控制进程崩溃了
  → 重启后:它不知道"我刚才想启动 2 个"
  → 结果:只有 2 个副本在跑,而且没有人知道少了 1 个
 
声明式: PUT /desired {"replicas": 3}
  → 服务器的职责变成:"让实际副本数等于 3"
  → 崩溃重启后:读一下 desired = 3,读一下实际 = 2
  → 继续启动 1 个
  → 结果:最终收敛到 3

关键差别在于"意图存在哪里":

命令式 声明式
意图的载体 一次网络请求 一个持久的对象(存的 desired state)
请求丢失后 意图永久丢失 意图还在,下次观察能发现差距
幂等性 难("再启动 2 个"重复执行会启动 4 个) 天然("让数量等于 3"重复执行结果不变)
重试 需要谁负责重试? 控制器自己会一直重试

这就是"为什么这类系统的 API 都是声明式"的根本原因——不是风格问题,而是声明式让"意图"变成了一个可以被反复读取的持久对象,从而让"重试"变得安全。

命令是关于"过去"的,状态是关于"现在"的。 一个命令如果丢了,你就永远不知道它发生过;而一个状态丢了,你只要重新读一次就知道了。所以任何需要"最终一定会生效"的系统,都必须把意图表达成状态。

第二步:控制循环——一个只有三个动作的无限循环

整个调度器的核心,就是一个函数:

/// 协调函数的全部形状:给定"期望",和"实际",产出"该做的动作"
pub trait Reconciler {
    type Desired;
    type Actual;
    type Action;
 
    /// ★ 注意这个签名:它不接收"上次执行了什么"
    ///    它只接收当前观察到的 desired 和 actual
    fn reconcile(&self, desired: &Self::Desired, actual: &Self::Actual)
        -> Result<Vec<Self::Action>>;
}

这个签名里有三条隐含的约束,每一条都是设计上的硬要求:

约束一:幂等——同样的输入必须产出同样的动作

// 好的实现:从状态推导动作
fn reconcile(deploy: &Deployment, pods: &[Pod]) -> Vec<Action> {
    let mut actions = Vec::new();
    let running = pods.iter().filter(|p| p.phase == Phase::Running).count();
 
    if running < deploy.replicas {
        // 要启动几个?直接算出来
        for _ in 0..(deploy.replicas - running) {
            actions.push(Action::CreatePod);
        }
    }
    actions
}
 
// 坏的实现:依赖"上次做了什么"
fn reconcile_bad(ctx: &mut ControllerContext, deploy: &Deployment, pods: &[Pod]) -> Vec<Action> {
    // ✗ 计数器只在内存里 —— 进程重启就丢了
    //   重启后它不知道"上次已经启动过 2 个",于是又启动 2 个
    if ctx.last_created < deploy.replicas {
        ctx.last_created += 1;
        return vec![Action::CreatePod];
    }
    Vec::new()
}

约束一的判据很清晰:reconcile 不能有可变状态。 一旦它需要"记住什么",那个"记住的东西"就必须被持久化——而一旦持久化,它就成了"实际状态"的一部分,应该由观察阶段读进来,而不是由控制器自己维护。

约束二:可重入——中途失败能继续

reconcile 产出了 5 个动作:[A, B, C, D, E]
执行到 C 时崩溃
 
重启后:
  重新观察 → 发现 A、B 的效果已经存在(因为动作是幂等的)
           → 差距变小了 → 只需要产出 [C', D', E'] 或更少
  而 [D, E] 里的某些可能已经被别的地方满足了
 
关键:控制器不需要知道"我执行到哪了",
      它只要重新观察一次就能知道当前该做什么。

注意这里有一个漂亮的性质:控制器不需要"断点续传"这个功能。 因为差距本身就是一个断点——你重新观察一次,差距就自动告诉你还差什么。

这也是为什么"控制器不能依赖自己上次的输出"这条约束如此重要:一旦依赖了,它就需要一套机制来持久化"执行到哪了",而这套机制本身又会成为新的故障点(它也会丢、也会不一致)。

约束三:无状态观察——判据永远是"重新读一遍"

这一条是整篇最重要的设计原则,值得单独展开。

// ✗ 靠事件驱动:只处理"变化通知"
async fn watch_loop(&mut self, mut events: EventStream) -> Result<()> {
    while let Some(ev) = events.next().await {
        match ev {
            Event::PodDeleted(pod) => {
                // 收到"有 pod 被删了" → 补一个
                self.create_pod().await?;
            }
            _ => {}
        }
    }
    Ok(())
}

这段代码的问题是:它把"通知"当成了"真相"。

如果这个事件因为队列满被丢弃了 → 少了一个 pod,而且没人知道
如果事件重复投递了两次 → 多创建了一个 pod
如果两个事件乱序(先收到"创建"再收到"删除")→ 状态算错
如果控制器在事件发生的那一瞬间崩溃 → 这个事件永久丢失

正确的做法:事件只用来触发,判据永远是重新读状态。

/// 通知:只表示"这个对象可能需要处理"
pub struct Notification {
    /// ★ 只有键,没有内容 —— 因为内容要重新去读
    pub key: ObjectKey,
    /// 版本号,用于去重和跳过无用处理
    pub version: u64,
}
 
async fn reconcile_loop(&mut self, mut notify: Receiver<Notification>) -> Result<()> {
    while let Some(n) = notify.recv().await {
        // ★ 事件只是触发信号,真实状态重新读
        let desired = self.store.get_desired(&n.key)?;
        let actual = self.store.get_actual(&n.key)?;
 
        let actions = self.reconciler.reconcile(&desired, &actual)?;
        for a in actions {
            self.execute(a).await?;
        }
    }
    Ok(())
}

这个设计带来的性质非常关键:

事件的问题 为什么不再是问题
事件丢失 只是这次没被触发,下次任何一次触发都会重新观察,发现同一个差距
事件重复 重新观察 + 幂等动作 → 重复触发不产生重复效果
事件乱序 事件里只有"键",顺序不影响结果
处理时崩溃 重新观察即可,不需要记住进度

换句话说:这个系统从"必须保证事件不丢"变成了"事件丢了只会晚一点"。

把"通知"和"状态"分开,是几乎所有可靠的控制器设计的分界线。 通知可以是不可靠的、可以丢、可以重复、可以乱序——因为它只是一个"去看看"的提示。唯一的判据永远是"重新读一遍当前状态"。 这一条的价值在于:它把一个"分布式消息可靠性"问题,换成了一个"最终会观察一次"的问题。

第三步:期望状态存哪里——为什么必须强一致

现在"重新读一遍"这句话有了重量:这个"读"必须是准确的。

如果两个控制器同时读,读到的期望状态不一样 → 它们会做出冲突的决定
如果期望状态的写入丢了一半 → 一个控制器看到的和另一个看到的不同

所以期望状态必须存在一个强一致的 KV 里。 而"强一致"的实现,前面已经写过:Raft 的复制日志。

pub struct DesiredStateStore {
    /// Raft 复制的 KV:key → (value, version)
    raft: RaftKv,
}
 
impl DesiredStateStore {
    /// ★ 写入必须带版本号 —— 乐观并发控制
    pub fn update(&mut self, key: &ObjectKey, value: Vec<u8>, expected_version: u64)
        -> Result<u64>
    {
        // Raft 保证这个"读-比较-写"是原子的吗?
        // 不一定 —— 所以要么在同一个 Raft 提交里做,
        // 要么用版本号让冲突的一方失败重来
        match self.raft.compare_and_swap(key, expected_version, value) {
            Ok(new_version) => Ok(new_version),
            Err(Conflict { current_version }) => Err(Error::VersionConflict {
                key: key.clone(),
                expected: expected_version,
                actual: current_version,
            }),
        }
    }
}

expected_version 的用法,和版本控制系统里那个"引用 CAS"是完全同一个模式:

控制器 A:
  ① 读 deploy,version = 100,replicas = 3
  ② 算差距,决定把 replicas 改成 5
  ③ 写:CAS(key, expected=100, value={replicas: 5})
 
控制器 B 同时:
  ① 读 deploy,version = 100,replicas = 3
  ② 决定改成 4
  ③ 写:CAS(key, expected=100, ...)
 
只有一个人能成功。另一个人拿到 Conflict,必须:
  重新读 → 重新算 → 再写

"重新读、重新算、再写"这个循环是必须的,而它非常容易被简化成一个错误的东西:

// ✗ 错误:冲突后直接重试写入,不重新计算
loop {
    match self.raft.compare_and_swap(key, expected, &value) {
        Ok(v) => return Ok(v),
        Err(Conflict { current_version }) => {
            // 只更新版本号,但 value 还是基于旧版本算出来的!
            expected = current_version;
            // ← 这里就错了:value 必须重算
        }
    }
}

为什么必须重算? 因为新版本里的数据可能已经改变了"应该做什么"这个判断——比如别人把 replicas 从 3 改成了 10,那么"改成 5"这个决定已经过时了。

乐观并发控制的"重试"必须是"重读 + 重算 + 重写"这个完整循环。 只重试写入等于在用旧世界的决策去修改新世界——而这个 bug 的特点是它几乎总是能成功,所以永远不会被发现,只会在某个并发时刻产生一个错误的最终状态。

读也要走 Raft 吗?——lease read 的取舍

严格方案:所有读都经过 Raft 的日志复制确认 → 一致,但延迟高
优化方案:Leader 在自己的租约期内,可以本地读 → 快,但依赖时钟假设

Leader 租约读的原理是:如果 Leader 在租约期内,那么不会有新的 Leader 被选出来(因为其他节点会等租约过期才能竞选),所以本地数据一定是最新的。

代价是"依赖时钟"——租约是一个基于时间的不变量,而分布式系统里的时间是不可信的。所以租约必须留出足够的余量(通常租约长度远小于时钟漂移的容忍上限)。

但注意:对于调度器来说,读路径用不用 lease read,影响其实不大。 因为期望状态的变化频率很低(人不会每秒改一次副本数),而控制器本身是"重新读一遍"的模式——它的正确性不依赖于"读到的是不是最新的",而是依赖于"迟早会读到最新的一次"。

在"最终一定会收敛"的系统里,读延迟的优化价值远低于写一致性。 因为读晚一点只意味着"晚一点发现差距",而写不一致意味着"两个控制器基于不同的现实做决定"。 分清这两者的权重,是设计这类系统的第一步。

第四步:实际状态怎么收集——以及"失联"这个判断有多难

期望状态好办(写进去就行),实际状态要靠上报。

为什么不能"控制器主动去查"

朴素方案:控制器定期去每个节点问"你上面有哪些容器在跑"
问题:
  控制器数量 × 节点数量 = 查询总数
  3 个控制器 × 1000 个节点 = 每秒 3000 次查询
  而且大部分查询的答案是"没有变化" —— 纯粹浪费

所以改成"节点主动上报":

/// 节点定期上报自己的状态
pub struct NodeHeartbeat {
    pub node_id: NodeId,
    /// 这个节点上跑着什么(只报"我负责的那部分")
    pub pods: Vec<PodStatus>,
    /// 节点自身的资源情况
    pub allocatable: Resources,
    /// 序列号:防止旧的心跳覆盖新的(网络乱序)
    pub sequence: u64,
}

sequence 这个字段是必须的。 因为心跳走网络,旧的心跳可能在新的心跳之后到达——如果没有序列号做去重,节点的状态会"回退"到一个旧值。

impl NodeRegistry {
    pub fn on_heartbeat(&mut self, hb: NodeHeartbeat, now: Instant) {
        let node = self.nodes.entry(hb.node_id).or_default();
 
        // ★ 只接受更新的心跳 —— 网络乱序的防护
        if hb.sequence <= node.last_sequence {
            return;
        }
 
        node.last_sequence = hb.sequence;
        node.pods = hb.pods;
        node.last_seen = now;
    }
}

这是"状态型更新必须带版本号"的又一个实例(和第三步的 expected_version、版本控制的 CAS,是同一类问题的不同表现)。

"没有心跳"意味着什么——这是最难的部分

现在到了这个问题:如果某个节点超过一段时间没有上报,应该怎么判断?

可能性一:节点死了(进程崩溃、机器断电)
可能性二:网络分区(节点活着,但到控制平面的链路断了)
可能性三:节点很忙(GC 卡住、CPU 被占满,心跳发不出来)
 
这三种情况的正确应对完全不同:
  情况一:应该把它的容器调度到别处
  情况二:调度到别处 → 会出现"两个实例同时在跑"(脑裂)
  情况三:调度到别处 → 白折腾,一会儿它自己就恢复了

而"没有心跳"这一个观察,无法区分这三种情况。 这是分布式系统的基础困难之一。

所以必须用租约把这个模糊的观察变成一个明确的不变量:

pub struct Lease {
    pub holder: NodeId,
    /// 租约到期时刻(用控制平面的时钟)
    pub expires_at: Instant,
}
 
impl LeaseManager {
    /// 节点续约
    pub fn renew(&mut self, node: NodeId, ttl: Duration) -> Result<()> {
        // ★ 续约时租约只能延长,不能缩短 —— 单调性
        let new_expiry = Instant::now() + ttl;
        let lease = self.leases.entry(node).or_insert(Lease {
            holder: node,
            expires_at: new_expiry,
        });
        lease.expires_at = lease.expires_at.max(new_expiry);
        Ok(())
    }
 
    /// 租约过期 → 可以安全地认为这个节点不再持有什么了
    pub fn expired(&mut self, now: Instant) -> Vec<NodeId> {
        let mut out = Vec::new();
        self.leases.retain(|node, lease| {
            if lease.expires_at <= now {
                out.push(*node);
                false    // 删除过期租约
            } else {
                true
            }
        });
        out
    }
}

租约的语义价值在于:它把"我们已经很久没收到它的消息了"变成了"它保证自己不再做任何事"。

节点自己的规则:只要租约还在有效期内,我就继续正常做事;
                一旦发现租约过期(比如我联系不上控制平面很久了),
                我必须主动停止(否则就是脑裂)
 
控制平面的规则:租约过期后,我可以认为这个节点"已经停止了",
                于是可以安全地把它的工作交给别人

这两条规则合起来构成一个不变量:任意时刻,对任意一份工作,最多只有一个节点认为自己在负责它。

而租约长度是这个不变量的唯一调节参数:

租约长度 误判(节点还活着却被判失联) 故障发现速度
短(几秒) 频繁发生(网络抖动、GC 停顿) 快
长(几分钟) 罕见 慢

而这个取舍还有个隐藏的约束:租约长度必须远大于"时钟漂移 × 宽容度"。 如果两台机器的时钟差 30 秒,而租约只有 10 秒,那么控制平面会认为租约早过期了,而节点还认为自己有效——直接脑裂。

租约是"用时间换确定性"最经典的用法。 它把一个无法观察的事实("那个节点还在工作吗")转换成一个可以本地判定的事实("时间到了吗")。而代价是整个系统引入了对时钟的依赖——这也是为什么所有的租约实现都要讨论时钟漂移,而所有的分布式教程都要强调"不要相信时钟"。

第五步:调度——过滤和打分是两件不同的事

现在到了那个经典问题:一个容器应该放到哪台机器上。

它被拆成两个独立的阶段,而且这两个阶段的"严格程度"完全不同:

pub trait Scheduler {
    /// 阶段一:过滤 —— 硬约束,不满足就绝对不能放
    fn filter(&self, pod: &Pod, nodes: &[Node]) -> Vec<NodeId>;
 
    /// 阶段二:打分 —— 软约束,在所有可行的里面挑"最好"的
    fn score(&self, pod: &Pod, candidates: &[NodeId]) -> Vec<(NodeId, i64)>;
}

过滤阶段:为什么必须是"绝对"的

impl Scheduler {
    fn filter(&self, pod: &Pod, nodes: &[Node]) -> Vec<NodeId> {
        nodes.iter()
            .filter(|n| {
                // ① 资源够不够(请求量 <= 可分配量)
                n.allocatable.fits(&pod.requests)
 
                // ② 节点选择器(用户显式指定"我要 SSD 节点")
                && pod.node_selector.matches(&n.labels)
 
                // ③ 污点与容忍(节点说"别放我这儿",pod 说"我不在乎")
                && n.taints.iter().all(|t| pod.tolerates(t))
 
                // ④ 亲和性(要和某个 pod 在一起 / 不能在一起)
                && self.affinity_ok(pod, n)
            })
            .map(|n| n.id)
            .collect()
    }
}

这四个条件有一个共同点:它们都是"事实判断",不是"偏好"。

  • 资源不够 → 放上去会 OOM,这是会坏事的
  • 污点不容忍 → 节点明确拒绝,尊重它是契约
  • 亲和性冲突 → 用户显式要求,违反了就是错的

所以"过滤"的输出是一个"允许集合",而不在集合里的节点是绝对不行的。 而如果过滤后集合为空,调度器必须拒绝这个 pod(并让它保持 Pending 状态)——而不是"挑一个凑合"。

"不能凑合"这一点很重要:如果把一个资源不够的 pod 放上去,故障会延迟发生——pod 起来了,跑了一会儿,然后被 OOM 杀掉。而"一直 Pending"是一个可以被人看见、可以告警的状态。

打分阶段:为什么必须可解释

pub struct ScoreBreakdown {
    /// 各个维度的得分 —— ★ 必须能被汇报出去
    pub balance: i64,
    pub spread: i64,
    pub image_locality: i64,
    pub packing: i64,
    pub total: i64,
}

打分必须能回答"为什么这个 pod 落在那个节点上"。 因为:

  1. 运维会质疑——"为什么它没落到那台空机器上"
  2. 资源不均衡时无从排查——不知道是哪个维度在起作用
  3. 调优需要依据——权重改了之后效果如何

而且各个维度的方向经常是冲突的:

维度 偏好 和谁冲突
均衡(balance) 把负载摊开 和"打包"冲突
打包(packing) 把容器挤在一起,空出整台机器 和均衡冲突
分散(spread) 同一个服务的副本不要在同一台机器 和均衡部分一致
镜像本地性 放到已经有这个镜像的机器 和均衡冲突

"均衡"和"打包"的冲突是最本质的:

均衡策略:负载摊到所有机器
  好处:单机故障影响小、资源利用率曲线平滑
  坏处:所有机器都处于"半忙"状态 → 空闲时也无法关掉机器省电
 
打包策略:尽量把容器挤满少数机器
  好处:可以关掉空闲机器(省成本)、腾出整机给大任务
  坏处:单机故障影响大、资源碎片化严重

调度策略的"最优"是没有定义的,因为它取决于你的目标函数是"成本"还是"可用性"。 所以成熟的做法是:把权重做成可配置的,并且把每个维度的得分暴露出来。 这样"为什么这样调度"永远能有一个可查的答案——而一个无法解释的调度决定,在运维眼里就是一个随机行为。

一个反直觉的点:调度器不"执行"调度

调度器做完决定之后,它做的事情是:往期望状态里写一个字段。

impl Scheduler {
    fn schedule(&mut self, pod: &Pod, node: NodeId) -> Result<()> {
        // ★ 不是"在节点上启动这个容器"
        //    而是"把这个 pod 的期望状态改成 nodeName = X"
        self.store.update_pod(pod.key(), |p| {
            p.spec.node_name = Some(node);
        })?;
 
        // 之后:
        //   该节点上的 agent 观察到这个变化 → 自己去拉镜像、起容器
        //   agent 上报实际状态 → 调度器观察到"这个 pod 起来了"
        Ok(())
    }
}

这是声明式的自洽性:连"调度决定"本身也是一个声明。

为什么这么做? 因为如果调度器直接去节点上启动容器:

调度器 → RPC → 节点 A: "启动这个容器"
网络超时 → 调度器不知道成功了没有
  → 重试 → 节点上起了两个容器
  → 不重试 → 可能一个都没起

而"写一个字段"是幂等的:写十次 nodeName = A,结果就是 A。节点上的 agent 读这个字段,然后自己去达成——它也可以失败、重试,而所有重试都是安全的。

所以整个系统里没有一个"命令",只有"状态"和"观察状态的循环"。 这就是为什么它能自愈:任何一个环节挂了,重启后它读一遍状态就知道自己该做什么。

第六步:状态机 vs 条件——不要用一个字段表达状态

这是实际写控制器时最容易犯的错误:

// ✗ 错误:用一个枚举表达状态
pub struct PodStatus {
    pub phase: PodPhase,
}
 
pub enum PodPhase {
    Pending,
    Running,
    Failed,
    Succeeded,
}

它的问题不是"字段太少",而是"一个字段无法表达多个独立的维度":

一个 pod 同时是:
  ✓ 已经被调度到节点 A(调度维度)
  ✓ 容器已经启动了(运行时维度)
  ✗ 但是 readiness 探针一直失败(就绪维度)
  ✗ 而且镜像拉取报过一次错(历史维度)
 
用一个 phase 字段,你必须选一个"最重要"的状态来填。
→ 而这个选择是丢失信息的。
→ 而且当"最重要"的那个状态在两种之间来回切时,
  你看不出它到底卡在哪。

正确的做法是用一组独立的"条件":

pub struct PodConditions {
    pub conditions: Vec<Condition>,
}
 
pub struct Condition {
    /// 条件类型:"Scheduled" / "ContainersReady" / "Initialized"
    pub type_: String,
    /// 布尔值:现在这个条件成立吗
    pub status: bool,
    /// 为什么?(机器可读的原因码)
    pub reason: String,
    /// 给人看的信息
    pub message: String,
    /// ★ 这个条件的 status 上次变化的时刻
    pub last_transition: Instant,
}

注意 last_transition 这个字段的价值:它让"卡了多久"变得可观测。

impl PodConditions {
    /// 报告"某个条件已经处于当前状态多久了" —— 这是排障的第一手信息
    pub fn stuck_for(&self, type_: &str) -> Option<Duration> {
        self.conditions.iter()
            .find(|c| c.type_ == type_ && !c.status)
            .map(|c| c.last_transition.elapsed())
    }
}

"一个 pod 卡在 Scheduled=false 已经 5 分钟" 这句话,比"pod 状态是 Pending"要有用得多——前者告诉你"是什么卡住了、卡了多久",后者只是告诉你"还没好"。

而且条件必须是"当前观察",不是"历史事件":

✓ 条件:`ContainersReady = false, reason = "ImagePullFailed"`
   → 语义是"现在,容器没就绪,原因是上次尝试拉镜像失败了"
   → 如果镜像后来拉成功了,这个条件应该变成 true
 
✗ 事件:`ImagePullFailed at 10:00:05`
   → 语义是"10:00:05 的时候拉失败了"
   → 但它不告诉你"现在怎么样了"

这就是第二步那条原则的又一次应用: 判据必须是"重新读一遍就能得到的事实",而不是"沿着时间累积的日志"。

一个字段表达不了"当前状态的多个独立维度",而一组条件可以。 而且条件天生带"原因"和"时间"——这两个东西恰恰是排障时最需要的。 用单一状态字段的系统,最后都会被迫在旁边加一堆 reason、message、lastError 字段——而这其实就是条件,只是没被组织好。

第七步:幂等——所有动作都必须能被重复执行

因为 reconcile 会重复执行同一个决定,所以它产出的每个动作都必须是幂等的。

有三种实现幂等的方式,选哪一种取决于"这个动作能不能从当前状态推导出'做过了'":

方式一:天生幂等(设置字段为某值)

// 幂等:设十次都一样
store.update(key, |obj| obj.spec.replicas = 3)?;

大部分"修改期望状态"的动作都是这一类。

方式二:用确定性的名字去重

// 创建一个子对象时,名字必须是"确定性地算出来的"
fn pod_name(deploy: &Deployment, index: u32) -> String {
    // ★ 包含父对象的 id 和索引 —— 同一个 index 永远算出同一个名字
    format!("{}-{}", deploy.name, index)
}
 
fn ensure_pod(&mut self, deploy: &Deployment, index: u32) -> Result<()> {
    let name = pod_name(deploy, index);
 
    match self.store.create_if_absent(&name, build_pod_spec(deploy, index)) {
        Ok(_) => Ok(()),
        // ★ AlreadyExists 不是错误 —— 说明"已经做过了",这正是不变式要的
        Err(Error::AlreadyExists) => Ok(()),
        Err(e) => Err(e),
    }
}

"AlreadyExists 不是错误"这一条看起来很别扭,但它是这类系统的核心技巧。 它把"创建"这个动作变成了"确保存在"——而"确保存在"是幂等的。

如果名字是随机生成的(比如带一个 uuid),那么这个动作永远不幂等:每次 reconcile 都会创建一个新 pod,然后数量无限增长。

方式三:让"做过了"这个标记和动作原子地完成

这是最难的一类,也是最容易出错的一类。

// ✗ 错误:分配 IP 和记录"已分配"是两个动作
fn allocate_ip_bad(&mut self, pod: &Pod) -> Result<IpAddr> {
    let ip = self.pool.allocate()?;          // 动作
    self.store.set_pod_ip(pod.key(), ip)?;   // 记录
    Ok(ip)
}
 
// 如果在这两步之间崩溃:
//   IP 已经从池子里拿走了,但 pod 上没有记录
//   → 重启后重新 reconcile:发现 pod 没有 IP → 又分配一个
//   → 第一个 IP 永久泄漏
// ✓ 正确:让"分配"和"记录"在同一个原子操作里
fn allocate_ip(&mut self, pod: &Pod) -> Result<IpAddr> {
    // 用一个 CAS 把两件事绑在一起:
    //   expected = {pod 无 IP, 池子里有 ip 可用}
    //   new      = {pod 有 IP = x, 池子里 x 被占用}
    self.store.compare_and_swap(
        &AllocationKey::new(pod.key()),
        Expected::NoIpAssigned,
        New::AssignIp { auto_select: true },   // ★ 让存储自己选一个 —— 一次原子操作
    )
}

"让存储自己选一个"这个设计是关键:如果由控制器先算出一个 IP 再写进去,那"算出 IP"和"写进去"之间就有窗口。而如果让存储在一次原子操作里完成"选 + 写",窗口就消失了。

这就是接口设计上的一个原则:把"需要原子性的复合操作"下沉到支持原子的那一层。

幂等的本质是"这个动作的结果只依赖于当前的输入状态"。 一旦动作需要"记住我做过什么",它就不幂等了——而这正是为什么要尽力把它变成"看当前状态就能判断做没做过"。 如果实在做不到(比如必须消耗一个稀缺资源),那就必须让"消耗"和"记录"成为同一个原子操作。**

第八步:并行 reconcile——工作窃取与"同一个对象不能并发处理"

一个控制器可能要管几万个对象,串行处理来不及。 所以需要多个 worker:

pub struct ReconcileQueue {
    /// 环形缓冲 + 位置标记(就是前面写过的无锁队列结构)
    ring: SegQueue<ObjectKey>,
    /// ★ 去重集合:同一个对象在队列里只应该有一份
    queued: DashSet<ObjectKey>,
}
 
impl ReconcileQueue {
    pub fn push(&self, key: ObjectKey) -> bool {
        // ★ 去重:如果已经在队列里了,就不要重复入队
        //    否则一个频繁变化的对象会占满整个队列
        if !self.queued.insert(key.clone()) {
            return false;
        }
        self.ring.push(key);
        true
    }
 
    pub fn pop(&self) -> Option<ObjectKey> {
        let key = self.ring.pop()?;
        // 出队时才从去重集合里删 —— 这样在"处理期间"新的变化还能再入队
        self.queued.remove(&key);
        Some(key)
    }
}

注意 push 时加入去重集合、pop 时移除这个顺序:

对象 X 的变化:
  T1  push(X) → queued = {X}, 队列 = [X]
  T2  X 又变了 → push(X) → queued 里已有 X → 不入队 ✓(避免重复)
  T3  worker pop(X) → queued 里删掉 X
  T4  处理 X 期间,X 又变了 → push(X) → 成功入队 ✓
      → 这个"第二次入队"保证了"处理期间的变化不会被漏掉"

如果反过来(pop 时不删,或者处理完才删),就会漏掉"处理期间的变更"。 这是一个非常典型的时序 bug:功能上能用,但在高频变更的场景下会静默地丢事件。

同一个对象不能被两个 worker 同时处理

因为 reconcile 会"读状态 → 算决定 → 写状态",两个 worker 同时做就可能互相覆盖。

pub struct Reconciler {
    /// 分片:同一个对象永远路由到同一个 worker
    shards: Vec<ReconcileQueue>,
}
 
impl Reconciler {
    fn shard_of(key: &ObjectKey) -> usize {
        // 按 key 的哈希分片 —— 同一个对象永远落到同一个分片
        hash(key) % SHARD_COUNT
    }
}

"按 key 哈希分片"就能解决并发问题——因为同一个对象的所有处理都在同一个 worker 上,天然串行。而不同对象之间并行,正是需要并行的部分。

这个方案比"对象粒度的锁"更好,因为它没有锁的开销,也没有死锁的可能。

代价是"热点分片"——如果所有对象都哈希到同一个分片(比如 key 的哈希分布不均),那么一个 worker 忙死、其他闲死。这就是工作窃取要解决的问题:繁忙的分片可以把任务让给空闲的 worker。

但注意:一旦引入工作窃取,"同一个对象只在一个 worker 上"这个不变量就有被破坏的风险——窃取时必须保证"正在被处理的对象不会被偷走"。

pub struct WorkStealingScheduler {
    /// 每个 worker 自己的队列
    local_queues: Vec<ReconcileQueue>,
    /// 窃取时只偷"还没开始处理"的条目
    in_progress: DashSet<ObjectKey>,
}
 
impl WorkStealingScheduler {
    fn steal(&self, from: usize, to: usize) -> Option<ObjectKey> {
        loop {
            let key = self.local_queues[from].pop()?;
 
            // ★ 关键:如果这个对象正在被处理,不要偷 —— 放回去
            if self.in_progress.contains(&key) {
                continue;
            }
 
            return Some(key);
        }
    }
}

并行化的第一步永远是"划出不可并行的边界"。 在这个系统里,边界是"同一个对象的 reconcile 必须串行"——而这条边界必须在引入任何并行机制(分片、窃取、锁)之前就明确下来。 先加并行再考虑边界,一定会得到偶发的、无法复现的状态覆盖。

第九步:反压、退避与"热循环"

队列不能无界,这一点前面已经反复说过。 但这里还有一个特有的问题:一个永远失败的对象。

对象 X 因为配置错误,reconcile 永远失败
  → 失败 → 重新入队 → 失败 → 重新入队 → ...
  → 每秒钟失败几百次
  → 日志被打爆、CPU 被占满、真正的有问题的对象排不上队

这被称为"热循环"(hot loop),而解法是指数退避:

pub struct RateLimiter {
    /// 每个对象的失败次数
    failures: DashMap<ObjectKey, u32>,
    /// 下一次允许处理的时间
    next_allowed: DashMap<ObjectKey, Instant>,
}
 
impl RateLimiter {
    pub fn on_failure(&self, key: &ObjectKey) {
        let mut count = self.failures.entry(key.clone()).or_insert(0);
        *count += 1;
 
        // ★ 指数退避:5ms, 10ms, 20ms, ... 上限 1000s
        //    基础值是"正常的重试间隔",上限是"别让它永远不被重试"
        let base = Duration::from_millis(5);
        let delay = (base * 2u32.saturating_pow((*count).min(20)))
            .min(Duration::from_secs(1000));
 
        self.next_allowed.insert(key.clone(), Instant::now() + delay);
    }
 
    /// 成功时清零 —— 否则一个偶尔失败的对象会永远被退避
    pub fn on_success(&self, key: &ObjectKey) {
        self.failures.remove(key);
        self.next_allowed.remove(key);
    }
 
    pub fn ready(&self, key: &ObjectKey, now: Instant) -> bool {
        self.next_allowed.get(key).map(|t| *t <= now).unwrap_or(true)
    }
}

两个细节容易漏:

细节一:上限必须存在。 如果只有指数增长没有上限,一个失败了 30 次的对象会被退避到"几百万秒之后"——相当于永久放弃它,而没有人知道。

细节二:成功时必须清零。 否则一个"前 10 次失败、第 11 次成功"的对象,会带着 10 次的退避惩罚继续跑——它的下一次正常重试会被无缘无故地推迟很久。

而这里有一个"队列该不该丢弃"的问题:

reconcile 队列满了 → 应该丢事件还是阻塞生产者?
策略 后果
阻塞生产者 生产者的"状态变更"也被卡住 → 整个系统响应变慢
丢弃事件 安全 —— 因为事件只是触发信号,丢了只是"晚一点发现"

"丢弃事件是安全的"这个结论,直接来自第二步的那个设计(事件不含内容、判据靠重新读)。 而这也是"声明式"带来的又一个红利:在高负载下,它可以降级——降低观察频率,而不是丢数据。

"能不能安全地丢弃事件"是一个系统设计质量的试金石。 如果一个系统的事件不能被丢(丢了就错),那么它必须依赖一个可靠的队列——而这把复杂度推向了一个更难保证的组件。 而如果事件可以被丢(丢只是变慢),那么它的可靠性基础就变成了"最终会重新观察一次"——而这一条是几乎无法被破坏的。

第十步:怎么知道调度器工作正常

这个系统最反直觉的地方:它的正确性指标不是"有没有报错",而是"差距有没有在缩小"。

pub struct ConvergenceMetrics {
    /// 期望副本数 vs 实际副本数
    pub desired_replicas: i64,
    pub actual_replicas: i64,
    /// ★ 差距 —— 这是最重要的指标
    pub gap: i64,
    /// 这个差距持续了多久
    pub gap_duration: Duration,
    /// reconcile 队列深度
    pub queue_depth: usize,
    /// 每个对象从"期望变化"到"实际达成"的耗时分布
    pub convergence_time_p99: Duration,
}

为什么"差距"比"错误数"更重要:

场景一:reconcile 每秒报 100 个错误,但差距在 30 秒内收敛
  → 正常。错误是暂时的(比如资源紧张时创建失败重试)
 
场景二:reconcile 零错误,但差距已经持续存在 2 小时
  → 严重故障!而且比场景一严重得多
  → 但因为"没有错误",告警不会响

场景二是最危险的一类故障: 调度器一直在"正常工作"(没报错、队列在处理),但它永远无法达成期望状态。

典型原因:

原因 表现
期望状态不可满足 要求 3 个副本,但集群资源只够 2 个
有 pod 卡在过滤器里 没有任何节点满足硬约束,且没有人注意到
一个 bug 导致的"反复创建又删除" 差距看起来在波动,但永远收敛不了
权限/配额限制 创建请求被拒绝,但拒绝被当成"临时失败"重试

这四种情况下,系统的日志都可能在报"重试中",而只有"差距持续存在"这个指标能揭示它们。

收敛性指标(期望 vs 实际的差距)是这类系统唯一不可省略的观测。 因为它的"错误形态"不是崩溃,而是**"永远差一点"**——而"永远差一点"在传统的错误率和延迟指标上完全看不出来。

结论

把这个循环拆开之后,它的形状是:

                    ┌─ 意图持久化在期望状态里(不是一次请求)
声明式的根基 ────────┴─ 动作可以从意图重新推导 → 重试永远是安全的
 
                    ┌─ 幂等:不依赖"上次做了什么"
控制循环的三条约束 ──┼─ 可重入:差距本身就是断点
                    └─ 事件只触发,判据永远是重新读状态
 
                    ┌─ 写:CAS + 版本号(乐观并发)
期望状态的存储 ──────┼─ 冲突后必须"重读 + 重算 + 重写"
                    └─ 用 Raft 保证强一致
 
                    ┌─ 上报要带序列号(防乱序覆盖)
实际状态的收集 ──────┴─ "失联"要用租约表达(用时间换确定性)
 
                    ┌─ 过滤(硬约束,不能违反)→ 打分(软约束,必须可解释)
调度决策 ───────────┴─ 调度器不执行调度,它只写一个声明字段
 
                    ┌─ 条件而不是单一状态字段(多维 + 原因 + 时间)
状态表达 ───────────┴─ 条件是"当前观察",不是"历史事件"
 
                    ┌─ 同一对象串行(按 key 分片)
并发的边界 ──────────┼─ 队列去重(处理期间的变化不能漏)
                    └─ 热循环用指数退避(有上限,成功清零)
 
                    └─ 最重要的指标是"差距持续了多久",不是"错误数"

五条最值得记住的判断:

  1. 事件只用来触发,判据永远是重新读状态。 这让事件可以被安全地丢弃——系统从"必须保证不丢消息"降级为"晚一点发现"。
  2. 乐观并发的重试是"重读 + 重算 + 重写"。 只重试写入,会用旧世界的决策去修改新世界。
  3. "AlreadyExists 不是错误"。 把"创建"变成"确保存在",是幂等的关键技巧。
  4. 同一对象的处理必须串行。 这条边界必须在引入任何并行机制之前就明确。
  5. 收敛性比错误率更重要。 这类系统的典型故障是"永远差一点",而它在错误指标上完全不可见。

这五条的共同点是:它们都在把"一个必须精确的时刻"换成"一个可以容忍误差的过程"。 调度器不追求"一次做对",它追求**"错了也能自己修回来"**——而这恰恰是它和前面所有系统最本质的差别。

下一篇换到"不可变数据的分布式摆放"(对象存储),会看到"内容寻址"在一个多节点的环境里如何变成一种数据放置策略。