Apache YuniKorn技术深潜 封面
DAT401 · Technical Deep Dive · 2026-09
Containers & Data Analytics
Apache YuniKorn 技术深潜
把 YARN 的队列语义搬到 Kubernetes:它解决什么、怎么工作、在 EKS 上怎么协同,以及在什么规模下才值得做。
问题 › 机制 › AWS 协同 › 决策 Why · How · On EKS · Decide
Neo SUN
Solutions Architect Amazon Web Services

⏱ 本页 2.7 分钟 · 主线 559 字 · 深潜层另有 947 字

(等大家坐定,屏幕停在封面,不要急着翻页 —— 这一页讲一分半到两分钟) 大家好,我是 Neo,AWS 的解决方案架构师。今天这场是技术深潜, 抬头这行写的是 DAT401 · Technical Deep Dive, 归在 Containers 和 Data Analytics 这两个方向下面。

(顺手解释一下为什么挂两个方向,这句能拉近距离) 为什么是两个?因为它是个 Kubernetes 组件,但真正在用它的人几乎全是数据平台的人 —— 这也基本预示了今天在座的构成。

主题是 Apache YuniKorn,一个替换 Kubernetes 默认调度器的批处理调度器。

(这句是开场第一句,建议照念) 今天不讲「YuniKorn 有哪些 feature」。 功能列表你们上官网十分钟就能看完,我讲那个没有价值。 (指着标题下面那条 问题 › 机制 › AWS 协同 › 决策) 屏幕上这条线就是全场的顺序,今天走这四步:

第一,问题 —— 它声称解决的那些问题,在你们那儿是不是真的存在; 第二,机制 —— 它到底凭什么能做到; 第三,AWS 协同 —— 在 EKS 上,跟 EMR、跟 Karpenter 放在一起,具体怎么落; 第四,决策 —— 在你们的规模下,这件事值不值得做。

下面那行英文 Why · How · On EKS · Decide 是同一件事,给不看中文的同事看的。

(指着副标题,前后两句都要念,它是这份材料的主线)

副标题的前半句是这份材料的主线:把 YARN 的队列语义搬到 Kubernetes。

这句不是修辞,是它的身世 —— 这个项目是 Cloudera 造的, 目的就是把他们在 YARN 上攒下来的那套队列经验搬到 Kubernetes 上来。 所以第四章有一整页是 YARN 到 YuniKorn 的概念对照, 在座跑过 Hadoop 的同事到那一页会觉得很亲切,而没跑过 YARN 的可以当作一页参考。 副标题的后半句「在什么规模下才值得做」同样不是修辞 —— 第四章我会给一条具体的节点数门槛,而且低于那条线,我的建议是别做。

先交代基准,因为这个话题里版本对不上就等于说错话。 今天全部内容对齐 v1.9.0,这是 2026 年 7 月 29 日发布的当前 GA 版本; 我们的研究基准日是 2026 年 9 月 16 日。

(这一句要说重)为什么强调版本? 因为网上大量材料还在讲「YuniKorn 有两种部署形态」—— plugin 模式在 1.9.0 已经从代码库里删掉了。 你按那些材料做架构设计,会设计一个不存在的东西。

材料来源三条: 官方文档当前版全部 91 页,全读了; 五个仓库的源码 —— 核心调度逻辑 8.8 万行 Go,加上 Kubernetes shim 一共约 14 万行; 我们自己的实测 —— 本地 kind 集群,一个 control-plane 加四个 worker, K8s v1.33.4,arm64,真的装了 1.9.0 上去跑。

(这一段是信用声明,建议放慢、照念) 关于实测数字我先立一条规矩:凡是我们自己测出来的数,我都会同时说明它的失真源。 举个例子:我们那套环境跑在 OrbStack 上,每个 kind 节点都上报整台宿主机的容量, 相当于四倍超卖 —— 所以所有跟容量有关的结论都受这个影响,我会在页面上标出来。 一个只报数字、不报失真源的实测,等于没测。

还有一句我想在封面就说:这份材料会主动告诉你它做不到什么。 第一章最后一页专门讲「它的能与不能」,列了七条它做不到的事,每条都有官方文档或源码依据; 第四章会主动指出最常见的那种成本夸大方式。 (这句可以说得直接一点) 研究过程里我们推翻或修正了七处流行说法,包括官方文档自己的表述 —— 其中一处是 AWS 官方教程里的参数名写错了,第三章会讲。 我把这些放进来不是为了显得客观,而是如果我不说,你们上线之后自己会撞到。

最后说今天会重点讲的一类东西:三个「会静默失效」的坑。 「静默」我定义清楚 —— 不报错、不告警、pod 全部 Running、监控看板全绿, 只有账单或者业务方会告诉你出了问题。 这类坑是这场分享我认为最值钱的部分,因为它们不会出现在任何一份 feature 列表里。

(这个问题往往有人开场就问,可以先接一句) 可能已经有人在想:「我们已经在用 Karpenter 了,还需要这个吗?」 这正是第四章要回答的,而且答案可能是「不需要」。 我们先看议程。

Agenda · 本次分享的四条主线

四章分别回答四个问题 为什么 · 怎么工作 · 在 AWS 上怎么用 · 该不该做

Ⅰ

为什么需要它

The Problem
  • 批处理 vs 在线服务
  • 资源死锁
  • 它的能与不能
Ⅱ

它怎么工作

Mechanism
  • 队列 · Gang · 抢占
  • 调度循环与吞吐模型
  • 三个静默失效的坑
Ⅲ

在 AWS 上怎么用

On EKS
  • EMR on EKS 官方路径
  • Karpenter 协同真相
  • 生态集成矩阵
Ⅳ

怎么决策

Decide
  • 成本模型与盈亏平衡
  • 选型对比
  • 迁移剧本

How to read this deck · 怎么用这份材料

  • 如果你的问题是「Spark 作业互相等死」,看第 Ⅱ 章的 Gang 部分——那是它最硬的价值。
  • 如果你的问题是「多团队抢资源」,看第 Ⅱ 章的队列与抢占,以及第 Ⅲ 章的身份链路。
  • 如果你要决定做不做,可以直接跳到第 Ⅳ 章——那里有盈亏平衡点,而它可能会劝你别做。
Apache YuniKorn 技术深潜 · Agenda04 章 · 65 页 · 120 分钟2

⏱ 本页 2.3 分钟 · 主线 478 字 · 深潜层另有 847 字

这一页我只花四十秒到一分钟,但有一句必须说清: (这句建议照念) 这四章是一个决策顺序,不是知识分类。 先确认问题真实存在,再看机制,再看在 AWS 上怎么落地,最后算账。 顺序倒过来讲,第四章的成本模型是讲不通的 —— 一会儿我说为什么。

(从左到右指四张卡) 第一章「为什么需要它」,回答的是:这个问题在我这儿真的存在吗。

三个小标题:批处理和在线服务对调度器的要求为什么是相反的;什么叫资源死锁; 以及它的能与不能。

这一章有个特点:从头到尾不会出现一个 YuniKorn 的功能名字,我只讲问题。

第二章「它怎么工作」,回答的是:它凭什么能做到。

队列、Gang、抢占是三根主线;然后是调度循环与吞吐模型 —— 这一节既解释了它为什么比默认调度器快,也解释了它的规模上限在哪; 最后是三个静默失效的坑,这是全场我最建议做笔记的地方。

第三章「在 AWS 上怎么用」,回答的是:在 EKS 上具体怎么落。

EMR on EKS 的官方提交路径、Karpenter 协同的机制真相、生态集成矩阵。 Karpenter 那一节我提前说一句:两者的耦合其实就是一个魔法字符串 —— 很多人以为那是深度集成。

第四章「怎么决策」:成本模型与盈亏平衡点、选型对比、迁移剧本。 (这句要说)这一章会劝一部分人别做,而且我把那条线画成了具体的节点数。

(指下面这个「How to read this deck」的框)这个框是给不同听众的路由表,三条我快速念一遍:痛点是「Spark 作业互相等死」的,重点听第二章的 Gang;要评估「该不该做」的,直接跳第四章的盈亏平衡点;已经在用 Karpenter 的,第三章那一页是你最该看的。

第一条:如果你的问题是「Spark 作业互相等死」, 重点看第二章的 Gang 部分 —— 那是它最硬的价值,也是最不可替代的一块。 第二条:如果你的问题是「多团队抢资源」, 看第二章的队列与抢占,加上第三章的身份链路 —— 身份链路很多人会忘,因为队列 ACL 配对了但组信息没带进来,结果是全部作业被拒。 第三条:如果你今天来就是为了决定做不做, 可以直接跳到第四章,那里有盈亏平衡点,而它可能会劝你别做。

(页脚这三个数字要交代,讲者和听众都需要知道预期) 页脚写着 4 章、65 页、120 分钟 —— 这三个数是页面上写着的。两个小时,中间会有一次休息。

下面这个分法是我自己排的、页面上没有: 第一章 10 分钟、第二章 16 分钟、第三章 14 分钟、第四章 10 分钟, 加起来正好把 50 分钟用满。 (所以提问是额外的时间,不在这 50 分钟里 —— 开场前跟主持人对一句) (这句是给讲者自己的)时间不够时的压缩顺序:先压第一章前两节,再压第三章的生态矩阵; 第一章最后那页「能与不能」和第四章的盈亏平衡点不要压 —— 它们是这份材料可信度的两个支点。

(这里做一次举手调查,20 秒,它会直接决定后面的节奏) 开始之前我想先问两个问题: 在场有多少人现在在 Kubernetes 上跑 Spark 或者其他批处理作业? ……好。有多少人遇到过「几个作业互相等资源、谁都跑不完」的情况? ……(举手多 → 第二章 Gang 部分讲细;举手少 → 压缩前三章,把时间给第四章的成本模型) 另外两条也说出来,让听众知道你在为他们调:如果在座主要是数据平台团队, 第三章的 Karpenter 部分我会多花 5 分钟;如果有管理层或 FinOps 的同事在, 第四章的成本页我会提前讲。

(这个追问很常见,而且回答里藏着整份材料的逻辑,建议照念) 可能有人会说:「能不能只讲第四章,直接告诉我们该不该用?」 可以,但先给我五分钟讲第一章的死锁问题。 原因是:成本节省的 70% 来自「敢不敢让多个团队共享同一个集群」, 而那取决于你信不信配额真的会生效 —— 不讲机制,第四章那张 ROI 表你没有理由相信。

好,我们进第一章 —— 从第一性原理开始:批处理和在线服务,对调度器的要求其实是相反的。

01
The Problem
为什么需要它
这一章不讲 YuniKorn,只讲问题。如果这些问题你没有,后面三章都不用听。
批处理与在线服务的分歧 资源死锁 ResourceQuota 不是配额 它的能与不能
Apache YuniKorn 技术深潜
3

⏱ 本页 1.4 分钟 · 主线 285 字 · 深潜层另有 207 字

好,我们进第一章。这一章我要先说清楚它的定位:这一章不会出现任何一个 YuniKorn 的 功能名字。我只讲问题。

为什么这么安排?因为我不想让各位听完之后,是因为「AWS 的人说这个东西好」才觉得它好。 我希望这一章结束的时候,你们能自己得出「我需要」或者「我不需要」的结论。 这两个结论对我来说是等价的 —— 如果你们听完说「我们不需要」,那这场分享同样是成功的。

这一章分四小节,顺序是:先讲原理上的分歧,再讲两个具体的失效,然后讲配额这个词 被误解的地方,最后主动泼一盆冷水。前三节建立需求,第四节讲它做不到什么。

(这里可以停 20 秒,做一次举手调查) 在开始之前我想先问两个问题:在座有多少人的 Kubernetes 集群上现在跑着批处理作业? ……好。那有多少人遇到过「几个作业互相等资源,谁都跑不完」的情况? ……(根据举手情况调整后面三章的时间分配:举手多 → 第二章可以讲细;举手少 → 压缩前三章,把时间给第四章的成本模型)

最后特别说一下第四小节,也就是这一章的最后一页 —— 那一页讲的是它做不到什么,是这一章最重要的一页。 如果今天时间不够,前面三节我都可以压缩,但我不会跳过那一页。 原因很简单:后面三章的可信度全建立在那一页上。 一份技术材料如果从头到尾没有那一页,它就是销售材料。

我们从第一性原理开始 —— 批处理和在线服务,对调度器的要求其实是相反的。

Ch.1 · 为什么需要它 · First Principle

批处理与在线服务对调度器的要求是相反的 这是抽象层次的错配,不是性能问题

维度在线服务(Deployment)批处理(Spark / 训练作业)
调度单位单个 pod,彼此独立一组 pod,必须同生共死
资源不足时扩容或降级,pod 可以一直 Pending必须排队,而且要公平地排
生命周期长期运行,几乎不结束分钟到小时,跑完就走
延迟目标单 pod 调度延迟要低整个作业的完成时间要短,单 pod 慢一点无所谓
资源利用目标留余量应对流量峰值尽可能榨干,别浪费
失败语义重启这个 pod一个成员失败可能整个作业重来
所以问题不是「默认调度器写得不好」——它为左边那一列设计,而且设计得很好。 问题是它的调度单位(pod)与批处理的调度单位(作业)不匹配。这是抽象层次的错配,调参解决不了。
结论:kube-scheduler 的核心循环是「取一个 pod → 过滤节点 → 打分 → 绑定」,这个循环里没有任何「作业」的概念。
做法:判断自己要不要换调度器,先问一句:我的负载的最小有意义单位是一个 pod,还是一组 pod?
注意:如果你的批处理是「很多互相独立的单 pod 任务」,那你在左边这一列,不需要 YuniKorn。
Ch.1 · 为什么需要它 — 第一性原理4

⏱ 本页 1.7 分钟 · 主线 366 字 · 深潜层另有 892 字

这一页只建立一个认知,而且我希望它能替换掉一个很常见的误解。 很多人的第一反应是「Kubernetes 默认调度器不够好,所以要换」。 这个说法是错的。正确的说法是:默认调度器的调度单位和批处理的调度单位不匹配。 这是抽象层次的错配,不是性能问题 —— 所以它不是调参能解决的。

我们一行一行看这张表,因为每一行都是一个真实的分歧。

(指着第一行) 第一行,调度单位。在线服务是一个一个的 pod,彼此独立,谁先起来谁后起来无所谓。 批处理是一组 pod,必须同生共死。 这一行是所有后续问题的根源,我一会儿会回来讲它。

第二行,资源不足的时候会怎样。在线服务的正确行为是扩容,或者降级, pod 一直 Pending 也不算大事故 —— 反正流量会被别的副本接走。 批处理的正确行为是排队,而且要公平地排。注意「公平」这个词, 它在默认调度器里根本没有对应概念,因为默认调度器不知道「租户」是什么。

第三行,生命周期。在线服务是长期运行、几乎不结束的; 批处理是几分钟到几小时,跑完就走。 这一行看起来最无害,其实它决定了一件事:批处理场景下,资源的归属是高频变化的, 所以你需要一个能持续做再分配决策的东西。

第四行是我认为最容易被忽略的一行,延迟目标。 在线服务追求的是单个 pod 的调度延迟要低;批处理追求的是整个作业的完成时间要短, 也就是 makespan。 这两个目标在资源紧张的时候是冲突的 —— 为了让整体完成得快, 你应该让一部分 pod 等更久。 先把一个作业完整跑完,比让五个作业各跑 20% 要好得多, 因为后者的结果是五个作业都没结果。

第五行,资源利用目标。在线服务要留余量应对流量峰值;批处理是尽可能榨干,别浪费。 第六行,失败语义。在线服务失败就重启这个 pod; 批处理里一个成员失败,可能整个作业要重来 —— 这也是为什么「一半 pod 起来了」在批处理里往往等于「零进展」。

(指着表格最下面那一栏,这句建议照念) 所以这一页的落点是这句话:问题不是「默认调度器写得不好」—— 它是为左边那一列设计的,而且设计得很好。 问题是它的调度单位是 pod,而批处理的调度单位是作业。 这是抽象层次的错配,调参解决不了。

下面三个框是这一页的三个行动含义。

左边这个「结论」:kube-scheduler 的核心循环是「取一个 pod、过滤节点、打分、绑定」, 这个循环里没有任何「作业」的概念。它每一步都做了局部最优的决定,合起来是全局灾难。 中间这个「做法」是我建议你们回去问自己的那个问题: 我的负载的最小有意义单位,是一个 pod,还是一组 pod?

右边这个「注意」要主动说:如果你们的批处理是「很多互相独立的单 pod 任务」, 那你其实在左边这一列,你不需要 YuniKorn。

(这里大概率会被追问,准备好这个回答) 可能有人会问:「那给 kube-scheduler 加个插件不就行了?」 答案是:社区试过,而且是 YuniKorn 自己试的。 官方给的数字是:plugin 模式的吞吐等于 kube-scheduler,比独立模式慢 16 倍, 最后在 1.9.0 里被删掉了。这个故事第三章会展开讲。

下一页我们看这个错配的第一个具体后果 —— 一个我猜在座有人已经遇到过的现象: 集群显示 100% 满载,但一个作业都没有在推进。

Ch.1 · 为什么需要它 · Deadlock

失效一:资源死锁 集群 100% 满载,零个作业能推进

默认调度器 · 5 个 Spark 作业进同一个 10 slot 集群
T0:5 个 driver 全部被调度成功 → 占 5/10
T1:每个 driver 各申请 4 个 executor → 需要 20 slot,只剩 5
T2:5 个剩余 slot 被瓜分(各拿 1 个)
T3:每个作业都在等剩下 3 个 executor → 集群满载、零进展、没有任何 pod 会自己退出
→
YuniKorn Gang 调度 · 同样的 5 个作业
按 taskGroups 声明的 minMember × minResource 先创建 placeholder pod 把坑占满;
占满了才把真实 pod 换进去;占不满就整体排队。
⇒ 第 2 个作业根本拿不到 driver 的坑,它会排队
⇒ 第 1 个作业能完整跑完,然后释放全部资源给第 2 个
100%
死锁时的集群占用率
0
死锁时推进的作业数
人工
默认调度器下的唯一解法

这里有一个反直觉的结论,也是整份材料最值得带走的一句

  • 限制并发反而提高吞吐。Gang 让第 2 个作业排队,看起来是「少跑了一个作业」,实际是消除了死锁——这是排队论里的经典结果。
  • 但 Gang 也会引入新的死锁形态:如果队列配额本身就小于 gang 的最小需求,它永远凑不齐。YuniKorn 用「入队前静态可行性检查」来防这个,第二章会给实测证据。
Ch.1 · 为什么需要它 — 资源死锁5

⏱ 本页 1.7 分钟 · 主线 365 字 · 深潜层另有 952 字

这一页是我讲这个话题时最容易让人「哦」的一页。核心是一句话: 集群 100% 满载,但零个作业在推进,而且没有任何一个 pod 会自己退出。 (重一点)这是死锁,不是繁忙。这两件事的区别是:繁忙等一会儿就好了,死锁永远不会好。

我们看左边这个例子。5 个 Spark 作业,进同一个只有 10 个 slot 的集群。

T0 时刻:5 个 driver 全部被调度成功,占掉 5 个 slot。 注意这一步是「成功」的 —— 默认调度器认为自己干得很好, 因为从它的视角看,它成功放下了 5 个 pod。 T1:每个 driver 各自去申请 4 个 executor,一共需要 20 个 slot,但只剩 5 个。 T2:这 5 个剩余 slot 被瓜分,每个作业各拿到 1 个。 T3:每个作业都在等剩下的 3 个 executor。

(这里停一下,把问题抛给听众 —— 这个停顿很有效) 接下来会发生什么? ……多数人的第一反应是「等一会儿就好了」。 不会。driver 会一直等下去。它不会超时退出,也不会释放自己占的那个 slot, 因为从 Kubernetes 的角度看,它是一个健康的、Running 的 pod。 这就是死锁。

看中间这三个数字。集群占用率 100% —— 所以你的监控看板是绿的,甚至是「利用率优秀」。 推进的作业数 0 —— 但业务在等结果。 唯一的解法是「人工」 —— 得有个人半夜起来,手动 kill 掉几个作业,让剩下的能跑完。 (如果现场有人做过这件事,这里通常会有反应)

右边是 YuniKorn 的做法,机制我讲慢一点,因为第二章要在这上面展开。 它按你在 taskGroups 里声明的 minMember 和 minResource, 先创建一批 placeholder pod 把坑占满;占满了,才把真实的 pod 换进去; 占不满,就整体排队,一个都不放进来。

「placeholder」这个词我解释一下,因为它是个真实存在的东西,不是抽象概念。 它是一个真实的 Kubernetes pod,跑的镜像是 registry.k8s.io/pause:3.7, 什么事都不干,唯一作用是占住资源。 我们实测它只活 2.1 秒 —— 短到用 8 秒间隔的 kubectl get pods 完全看不到它。 (这一点值得提,因为它解释了为什么很多人排障时说「我没看到 placeholder」)

所以同样这 5 个作业,结果变成:第 2 个作业根本拿不到 driver 的坑,它会排队; 第 1 个作业能完整跑完,然后把全部资源释放给第 2 个。

(下面这一段是这一页真正的价值所在,建议放慢) 这里有一个反直觉的结论,也是我认为整份材料最值得带走的一句: 限制并发反而提高了吞吐。 Gang 让第 2 个作业排队,表面上看是「少跑了一个作业」, 实际上是消除了死锁 —— 这是排队论里的经典结果,不是 YuniKorn 的发明。

但我必须同时说另一半,否则就是在卖东西:Gang 也会引入新的死锁形态。 如果你的队列配额本身就小于这个 gang 的最小需求,那它永远凑不齐。 YuniKorn 用「入队前的静态可行性检查」来防这个, 第二章我会给你们看实测证据 —— 我们真的把这个坑踩出来过。

(这里第二个高频追问) 可能被问:「我们用 Kubernetes 的 PriorityClass 加抢占能不能解决?」 不能。Kubernetes 的抢占是 pod 级的 —— 它会把某个作业的一个 executor 杀掉,让给另一个作业。 结果是两个作业都跑不完,死锁变成了震荡,而震荡比死锁更难查。 要做到「要么全给、要么不给」,就必须有「作业」这个概念。

下一页看第二个失效,而这个失效我认为是最被低估的一条: 你们现在用的 ResourceQuota,它其实不是配额。

Ch.1 · 为什么需要它 · Quota Semantics

失效二:ResourceQuota 不是配额,是准入拒绝 最被低估的一条差异

维度K8s ResourceQuotaYuniKorn 队列
超额时会怎样 pod 创建失败准入期拒绝,kubectl apply 直接报错 pod 创建成功,在队列里排队等
结构 扁平,一个 namespace 一份 层级树,父队列约束所有子孙之和
由谁执行准入控制器(apiserver)调度器(调度时判断)
有「顺序」概念吗 没有,谁先 apply 谁占 FIFO / Fair / 优先级排序
能借用空闲容量吗 不能 能,借到 max 为止🔴 headroom 公式里没有 guaranteed —— 它不参与准入
能保障最低量吗 只有上限,没有下限 guaranteed 是抢占的锚点
「配额」这个词在两个系统里含义不同。K8s 的是硬门禁(超了不让进), YuniKorn 的是调度约束 + 排队(超了就等)。批处理平台需要的是后者——你不会希望半夜的 ETL 因为白天的作业还没跑完就 apply 失败。
YuniKorn 自己的原话:"In most of the cases, YuniKorn queue can be used to replace the namespace resource quota, in order to provide more scheduling features."
注意:两者可以并存,而且并存时 K8s 的 ResourceQuota 先生效(它在准入期)。混用会得到「YuniKorn 说可以排队、apiserver 说不许创建」的矛盾。要么迁移,要么放宽 ResourceQuota。
Ch.1 · 为什么需要它 — ResourceQuota 语义6

⏱ 本页 1.9 分钟 · 主线 402 字 · 深潜层另有 959 字

这一页要打破一个具体的误解,我几乎每次都会遇到。 当我说「YuniKorn 提供多租户配额」,很多团队的反应是 「我们已经用 ResourceQuota 做了配额了」。 核心区别是一句话:ResourceQuota 超额的时候是「拒绝创建」,不是「排队等待」—— 而批处理需要的正是排队。 (表格第五行那条红字请一起念,它是这一页最容易被讲错的地方)另外注意:能借用空闲容量,但上限是 max —— guaranteed 压根不参与准入判定。

我们看这张对比表,六行,一行一行来。

(指着第一行,这是最关键的一行) 超额时会怎样。左边:pod 创建失败,因为 ResourceQuota 是在 准入期生效的,kubectl apply 会直接给你报错。 右边:pod 创建成功,然后在队列里排队等。

这一行的分量,我举个具体例子你们就明白了 —— 半夜的 ETL 作业。 假设此刻配额被白天的作业占着。 用 ResourceQuota,你的 apply 会失败, 然后 Airflow 或者 Argo 会把这个任务标记成失败并且告警 —— 而正确的行为本该是「排着,等资源」。 (这一句可以强调)为了绕开这个问题,很多团队会在提交侧写一个重试循环。 那本质上是在应用层重新实现了一个调度器的排队队列。

第二行,结构。ResourceQuota 是扁平的,一个 namespace 一份。 所以你没法表达这样一句话:「整个数据平台最多 100 核, 其中 ETL 团队保障 30 核、最多可以借到 70 核」。 这种表达在 YARN 时代是标配,在 Kubernetes 原生里没有。 右边是任意深度的层级树,父队列约束所有子孙之和。

第三行,由谁执行。左边是准入控制器,也就是 apiserver 那一层; 右边是调度器,在调度的时候判断。这一行解释了为什么两者的行为差这么多 —— 执行的时机根本不同。

第四行,有没有「顺序」的概念。左边没有,谁先 apply 谁占上。 右边有 FIFO、Fair、优先级排序。 第五行,能不能借用空闲容量。左边不能,上限就是上限。 右边可以:在 guaranteed 之上、max 之内都能借。

第六行是我认为最重要的一行,能不能保障最低量。 ResourceQuota 只有上限,没有下限。 它能防止一个团队吃掉全部,但不能保证另一个团队一定拿得到。 而 guaranteed 这个下限,是整个抢占机制的锚点 —— (这句很重要)没有 guaranteed,抢占什么都不会做。 这一点第二章会用实测证明。

(指着表格底栏) 所以落点是:「配额」这个词在两个系统里含义不同。 Kubernetes 的是硬门禁,超了不让进; YuniKorn 的是调度约束加排队,超了就等。 批处理平台需要的是后者。

下面两个框补两件事。

左边是 YuniKorn 自己的原话,我念一下: "In most of the cases, YuniKorn queue can be used to replace the namespace resource quota"。

右边这条是必须主动说的:两者可以并存, 而且并存的时候 ResourceQuota 先生效,因为它在准入期。 混用会得到一个很难查的现象:YuniKorn 说可以排队,apiserver 说不许创建。

(这里的高频追问) 可能被问:「上了 YuniKorn 之后,ResourceQuota 还要不要留?」 我的建议是:留一个宽松的兜底 —— 防止有人绕过 YuniKorn 直接创建海量 pod 把 etcd 打满; 但真正的配额逻辑放到队列里。 两套都收紧,排障时你会分不清是谁在拦。

下一页我把剩下两个失效一次说完,然后立刻讲边界 —— 我不想在建立需求上停留太久。

Ch.1 · 为什么需要它 · The Other Two & The Answer

另外两个失效,以及 YuniKorn 给出的三个答案 公平性 · 作业级能力

失效三 · 租户之间没有公平性

默认调度器没有「租户」概念,也没有「这个用户已经比别人用得多」这种状态。 一个配错的作业能吃掉整个 namespace,把同 namespace 的其他作业饿死——而这不会触发任何告警,因为从 K8s 视角看一切正常。

失效四 · pod 级视角看不到「作业」

一旦调度器有了 Application 这个一等对象,下面这些能力才成为可能: Gang(要知道这一组 pod 属于同一作业且最少要 N 个)、作业级排队与排序、作业级配额(maxapplications)、 动态优先级、历史用量追踪。这些不是 feature 清单,是同一个抽象带来的推论。

答案 ①
层级队列

解决配额与公平

  • 任意深度的队列树 + guaranteed / max
  • 队列 / 应用 / 用户三层公平共享
  • ACL 多租户 + 放置规则自动路由
答案 ②
Gang 调度

解决资源死锁

  • placeholder 先占位,凑齐再换手
  • 凑不齐则整体排队或整体失败
  • 实测:占位 2.1 秒、换手 0.15 秒
答案 ③
抢占

让保障量真的兑付

  • 七条定律,锚点是 guaranteed
  • 实测:精确停在 guaranteed,不多抢
  • 可用围栏限制在租户子树内
Ch.1 · 为什么需要它 — 另外两个失效与三个答案7

⏱ 本页 1.7 分钟 · 主线 357 字 · 深潜层另有 699 字

这一页节奏可以快一点,左边两个失效说完就转到右边。

右边三张卡是这一页的重点,而且它们的关系很重要: 三个答案对应三个失效,不是三个独立的功能。

左边失效三,租户之间没有公平性。

默认调度器没有「租户」这个概念,也不记录「这个用户已经比别人用得多」这种状态。

所以一个配错的作业能吃掉整个 namespace,把同 namespace 的其他作业饿死。 (这一句要说)而这件事不会触发任何告警 —— 因为从 Kubernetes 的视角看,一切正常。

左边失效四,这一段我认为是这一页最有价值的: pod 级的视角看不到「作业」。

一旦调度器有了 Application 这个一等对象,下面这些能力才成为可能: Gang,因为要知道这一组 pod 属于同一个作业且最少要 N 个; 作业级的排队和排序;作业级配额,也就是 maxapplications; 动态优先级;历史用量追踪。

(这句建议照念) 这五个能力不是五个功能,是「有了 Application 这个一等对象」这一个抽象带来的推论。 为什么要强调这一点?因为理解了它,你就能自己判断某个新需求 YuniKorn 能不能做 —— 你不需要去翻功能列表,只要问「这件事需不需要知道作业的存在」。

右边三张卡快速过。答案一,层级队列,解决配额与公平: 任意深度的队列树、guaranteed 与 max、 队列/应用/用户三层公平共享、ACL 多租户加放置规则自动路由。

答案二,Gang 调度,解决资源死锁:placeholder 先占位、凑齐再换手、 凑不齐则整体排队或整体失败。 这里两个数字是我们本地实测的:占位 2.1 秒、换手 0.15 秒。 换手能这么快,原因是 placeholder 上设了 terminationGracePeriodSeconds: 0 —— 删它的时候不等优雅退出。

答案三,抢占,让保障量真的兑付:七条定律,锚点是 guaranteed。 实测我们看到它精确停在 guaranteed 上,不多抢; 另外它可以用「围栏」限制在某个租户子树内。

(这个故事很值得讲,如果时间允许) 刚才「历史用量追踪」那一条背后有个真实的故事: Pinterest 在 AWS EKS 上用 YuniKorn 管 Spark 的时候, 发现它完全无状态、只知道此刻的用量, 而他们的配额分配方法依赖历史用量。 于是他们把这个能力做进了上游 —— 今天官方文档里有 design/historical_usage_tracking 这一页, REST 里有 /ws/v1/history/apps 这个端点。 一个大用户的真实需求,变成了两个 API。

下一页非常重要,而且我是故意把它放在建立完需求之后的:它做不到什么。 如果我不先说这个,后面三章你们就该怀疑我在卖东西了。

Ch.1 · 为什么需要它 · Honest Boundary

它做不到什么 这一页决定后面三章的可信度

❌ 它不能做(全部有官方文档或源码依据)

  • 拓扑 / NUMA / NVLink 感知调度 —— GPU 大规模训练的关键能力,它没有,路线图上也没有
  • 多集群 —— 一个调度器 = 一个 shim = 一个集群 = 一个 partition,硬编码(K8s shim 只支持 default,YUNIKORN-22)
  • DAG 依赖编排 —— 「A 完成后起 B」是 Argo / Airflow 的职责
  • 任何写操作 API —— 25 条路由里唯一非 GET 的是 POST /ws/v1/validate-conf,只做校验 ⇒ 配额变更只能改 ConfigMap,GitOps 是唯一正规通道
  • 主备高可用 —— 单副本 + 重启后状态重建,没有 leader election
  • 闲置回收 —— notebook 挂着不用照样占配额,那是别的工具的事
  • Red Hat 认证 / OperatorHub 上架 —— YUNIKORN-354「改用 UBI 基础镜像」= Closed / Won't Fix

⚠️ 三条「看起来像 bug 其实是设计」

  • 装上之后所有 pod 的 schedulerName 都被改写 —— mutating webhook 默认作用于全集群所有工作负载类型,包括显式写了 default-scheduler 的。这是设计行为,第三章会讲唯一的正确出口。
  • 抢占之后有一批 pod 永远 Pending —— 官方设计文档专门分析过 ReplicaSet 场景并预期了这个结局。它防住了抢占循环,代价是永久 Pending。
  • 调度器挂着的时候新 pod 全部 Pending —— 已运行的 pod 不受影响(它们已 bind)。这是单副本模型的必然,不是故障。
对客户的正确表述:它是单副本 + 快速重建模型,不是 active-active。 不要说成「高可用」。
Ch.1 · 为什么需要它 — 诚实边界8

⏱ 本页 1.8 分钟 · 主线 379 字 · 深潜层另有 1116 字

这一页是整份材料的信用基础。我先说这一页的用意: 我先把它做不到的说完,你们再决定要不要听后面三章。 (这句可以照念)一份技术材料如果从头到尾没有这一页,它就是销售材料。

左边七条是它不能做的,全部有官方文档或者源码依据。我挑最该强调的讲,其余快速带过。

第一条,没有拓扑感知、没有 NUMA、没有 NVLink 感知。 (这条要说重)如果你们的主力负载是 GPU 大规模分布式训练,这是硬伤, 而且我查了路线图,上面也没有。这不是「还没做」,是没打算做。

第二条,不支持多集群。一个调度器等于一个 shim、一个集群、一个 partition, 而且这是硬编码的 —— Kubernetes shim 只支持 default 这一个 partition, 对应的 issue 是 YUNIKORN-22。

第三条,不做 DAG 依赖编排。「A 完成后起 B」是 Argo 或 Airflow 的职责,不是它的。 这一条其实是好事 —— 它没有越界。

第四条我认为最有实际影响:没有任何写操作 API。 25 条 REST 路由里,唯一一个不是 GET 的是 POST /ws/v1/validate-conf,而它只做校验、不做变更。 (推论要说出来)所以配额变更只能改 ConfigMap,GitOps 是唯一的正规通道。 这不完全是坏事 —— 它强制你走 GitOps; 但它意味着「给业务团队一个自助改配额的界面」这个需求做不了,只能做成 PR 流程。

第五条,没有主备高可用 —— 单副本,重启后靠状态重建,没有 leader election。 第六条,没有闲置回收 —— notebook 挂着不用照样占配额,那是别的工具的事。 第七条比较小众但对某些客户是硬性的:没有 Red Hat 认证、没上 OperatorHub。 对应的 issue 是 YUNIKORN-354「改用 UBI 基础镜像」,状态是 Closed / Won't Fix。

右边三条是「看起来像 bug 其实是设计」,这三条排障的时候特别值钱。

第一条,装上之后所有 pod 的 schedulerName 都被改写。 mutating webhook 默认作用于全集群所有工作负载类型, 包括那些你显式写了 default-scheduler 的。 这是设计行为,不是 bug。第三章我会讲唯一的正确出口。

(下面这个是我们自己踩的坑,当场讲效果最好) 这一条我们真的撞到了。我们做性能 A/B 的时候, 一批 pod 写 schedulerName: default-scheduler,一批写 yunikorn, 两组结果漂亮地一致 —— 0.495 秒对 0.470 秒。 (停一下)后来才发现1000 个 pod 全部被改写成了 yunikorn —— 我们测的是「YuniKorn 对 YuniKorn」。 这个坑最恶劣的地方是:它不报错,而且会给你一个看起来像结论的结果。

右边第二条,抢占之后有一批 pod 会永远 Pending。 官方设计文档专门分析过 ReplicaSet 这个场景,并且预期了这个结局 —— 它防住了抢占循环,代价是永久 Pending。 第三条,调度器挂着的时候新 pod 全部 Pending, 但已经运行的 pod 不受影响,因为它们已经 bind 完了。这是单副本模型的必然,不是故障。

(对客表述很关键,这段建议照念) 关于单副本,正确的对外说法是: 「调度器不可用期间,已运行的作业不受影响,新作业排队等待。」 这个表述客户是能接受的。 但不要说成「高可用」 —— 被追问的时候会很难看。 它是单副本加快速重建模型,不是 active-active。

(高频追问) 可能被问:「没有多集群,那我们多个集群怎么办?」 短期只能每个集群一套 YuniKorn,配额各自独立; 要做跨集群配额,得看 MultiKueue 或者 Karmada,第四章的选型对比里有。

第一章结束。如果到这里你觉得这些问题在你们那儿不成立,那后面你可以只听第四章 —— 第四章是算账的,对不做这个决定同样有用。 下一章我们看它到底是怎么做到的。

02
Mechanism
它怎么工作
这一章全部有源码或实测支撑。三个「会静默失效」的坑都在这里。
三仓库一条接口契约 队列模型 Gang 调度 抢占七定律 可观测性
Apache YuniKorn 技术深潜
9

⏱ 本页 2.0 分钟 · 主线 429 字 · 深潜层另有 406 字

好,我们进第二章。这一章的组织方式跟第一章不一样,我先说清楚: 先讲一个机制,紧接着讲那个机制对应的坑。 为什么这么排?因为这些坑几乎都不是 bug —— 它们是「机制正确、但默认值危险」造成的,所以不讲机制就讲不清坑。

看隔页上这几个标签,就是这一章的路线: 三仓库一条接口契约、队列模型、Gang 调度、抢占七定律、可观测性。

展开成小节是六段:架构与调度循环 → 队列模型加上命名坑 → 放置规则加上头号坑 → Gang 加上参数坑 → 抢占 → 可观测性加上 1.9.0 的那个 bug。

隔页副标题两句我都念一下。前半句:「这一章全部有源码或实测支撑」 —— 我给的每个数字,要么来自源码、我会念文件路径和行号,要么来自我们自己那套本地实验。后半句:「三个会静默失效的坑都在这里。」

我先把坑的名字给你们,这样你们知道自己听到哪了: 坑一,两套资源命名;坑二,放置规则短路,这是头号坑; 坑三,Gang 的默认值会给你半个 gang;还有坑四,是 1.9.0 这个当前 GA 版本上的活跃 bug。 (隔页写「三个」,这一章实际讲四个 —— 别在台上纠正这个数字,直接往下讲)

它们的共同点只有一条,正是最要命的那一条:全都不报错。

副标题前半句请各位记着:这一章全部有源码或实测支撑。 我给的每个数字,要么来自源码 —— 我会念文件路径和行号; 要么来自我们自己那套 kind 集群的实测 —— 我会同时说明失真源。 这一章没有「据说」,也没有「业界普遍认为」。

(这句要主动说,它决定了后面所有实测数字怎么被理解) 失真源我现在就交代一条:我们的实验床是 kind 一个控制面加四个 worker, 跑在 OrbStack 上,而 OrbStack 下每个 kind 节点都上报整台宿主机的容量 —— 调度器以为有 71.2 核,物理上只有 18 核,大约四倍超卖。 所以我们的行为类结论是可靠的,容量类数字要打折看。

先从架构开始。它只有三个组件,说起来很简单 —— 但中间那条接口契约解释了这个项目的很多行为,包括为什么它的 PR 周期那么长。(这里要先破一个流行误解)注意我说的是「接口契约」,不是 gRPC 网络跳 ——v1.9.0 里这三者编译进同一个二进制、跑在同一个进程里,si.proto 只是「合约的书写语言」。整条链上没有一次 gRPC 网络调用。

Ch.2 · 它怎么工作 · Architecture

三个仓库,一条接口契约 🔴 不是 gRPC 网络跳 —— v1.9.0 里三者在同一个进程里

三件套与职责(官方原话摘要)

组件Go 行数职责
yunikorn-core87,925全部调度算法;与平台无关,只通过 SI 通信
yunikorn-k8shim53,063与 K8s 对话:informer、翻译资源与请求、把 pod bind 到节点、admission controller
yunikorn-scheduler-interface3,469抽象层,gRPC / protobuf。只有 Go binding
yunikorn-release2,487Helm chart(values.yaml 仅 166 行)
核心两件合计140,988—
口径提醒:官方自称 "light-weight",指的是运行时开销(镜像 35.5 MB、requests 200m CPU), 不是代码规模。核心逻辑 8.8 万行 Go。演讲时别把这两件事混着讲。

SI 这层的收益与代价

  • ✅ 收益 ① core 完全不依赖 K8s 类型,可独立单测
  • ✅ 收益 ② 平台细节(informer / bind / webhook)全在 shim,边界清晰
  • ✅ 收益 ③ 理论上可换平台
  • 🔴 代价 ① 一个改动要跨三个仓库:改 SI protobuf → 重新生成 binding → core 与 shim 各自适配、各自发版
  • 🔴 代价 ② 多一次序列化 / 反序列化
  • 🔴 代价 ③ 排障要跨两个进程边界看日志
「universal」到哪一步了:架构上留了 shim 抽象, 但实际只有一个 shim(Kubernetes)。PMC 成员原话: "We focused purely on the Kubernetes side of things. We left the Yarn thing to the side."
Ch.2 · 它怎么工作 — 架构10

⏱ 本页 1.9 分钟 · 主线 391 字 · 深潜层另有 1196 字

这一页有两件事要传达,而且两件都是用来纠正印象的: 第一,「universal」这个自我描述今天已经不准确了; 第二,中间那条 SI 边界解释了为什么这个项目的 PR 周期长。 行数表只是背景,别在上面停太久。 (标题小字那句红字要念,它是这一页最容易被误解的地方)而且请注意:那是一条接口契约,不是 gRPC 网络跳 —— v1.9.0 里这三者跑在同一个进程里。

(指着表格第一行) yunikorn-core,八万七千九百二十五行 Go。全部调度算法都在这里, 而它完全与平台无关 —— 它不 import 任何一个 Kubernetes 类型,只通过 SI 说话。 第二行,yunikorn-k8shim,五万三千零六十三行。 它负责跟 Kubernetes 对话:起 informer、把节点资源和 pod 请求翻译成 SI 的语言、 最后把 pod bind 到节点,admission controller 也在这个仓库里。 (这一点值得点出来)注意 bind 这个动作是 shim 做的,不是 core 做的 —— core 只出决定,不碰 apiserver。

第三行,scheduler-interface,3,469 行,就是那层抽象:gRPC 加 protobuf。 (这个细节后面会用到)它只有 Go binding —— 所以「理论上可以接别的平台」这句话,成本比听起来高。 第四行,yunikorn-release,2,487 行,就是 Helm chart, 而它的 values.yaml 只有 166 行 —— 这个数字后面讲部署时还会出现。

最后一行,核心两件合计十四万零九百八十八行 —— 你们就记「十四万行」。

这几个数字都是去掉 vendor、去掉测试之后的,口径要跟着数字一起说。

(指着下面那个红框,这段建议照念,它是这一页的口径) 官方自称 "light-weight",指的是运行时开销,不是代码规模。

运行时确实很轻:我们实测镜像 35.5 MB,requests 是 200 毫核。 但核心逻辑八万八千行 Go。 演讲的时候别把这两件事混着讲 —— 有人听到「轻量」会以为是个小工具, 然后自己去读代码的时候会觉得被骗了。

右边这张卡是 SI 这层的账,收益三条、代价三条,我一起说。 收益一,core 完全不依赖 Kubernetes 类型,所以它可以独立单测。 收益二,平台细节 —— informer、bind、webhook —— 全在 shim 里,边界很清晰。 收益三,理论上可以换平台。 (「理论上」这个词要念出来,下面就要打它)

代价一,这一条对打算贡献上游的团队最重要:一个改动要跨三个仓库。 你要改 SI 的 protobuf,重新生成 binding,然后 core 和 shim 各自适配、各自发版。

(这句建议照念)想加一个需要新 SI 字段的特性,你要动三个仓库、协调三次发布。 这是 PR 周期长的结构性原因,不是社区不积极。

如果客户打算自己改代码,这条要提前说,否则他们会低估排期。

代价二,多一次序列化和反序列化。这在毫秒级的调度周期里不是零成本。 代价三,排障要跨两个进程边界看日志 —— shim 一段、core 一段, 你得自己把它们对上。好消息是有个办法:用 Pod UID 去 grep, 因为同一个 UUID 会从 Task.TaskID 一路贯穿到 AllocationKey。

(指着右下角那个框,里面那句英文建议直接念出来) 最后说「universal」。官方文档到今天还写着,它的架构允许接入 Apache Hadoop YARN 或者其他系统。但 PMC 成员在 KubeCon 的访谈里说得很清楚: "We focused purely on the Kubernetes side of things. We left the Yarn thing to the side." 理由是需求在 Kubernetes 这一侧,而YARN 本来就有好的批调度器。 源码侧也印证了:五个仓库里没有任何 YARN shim。

(这句要说重) 所以别把「universal」讲成「能同时管 YARN 和 Kubernetes」 —— 会被懂行的人当场问倒。 它现在的准确含义是:同一个调度器同时服务批处理和长运行服务,也就是混合负载。

这一层它确实做到了,而且这也是 PMC 自己给的选用理由 —— 原话是「当你有混合负载的时候才该选 YuniKorn」。

下一页是这一章技术含量最高的一页,也是理解它性能模型的唯一钥匙:调度主循环。

Ch.2 · 它怎么工作 · 图解 · Architecture

三个仓库,一条接口契约(不是 gRPC 网络跳) 同一个二进制 · 同进程 · si.proto 只是合约的书写语言

Kubernetes API ServerPod / Node 事实来源 —— shim 的 informer 把它们转成 si.NodeInfo / si.AllocationRequest 再交给 coregRPC 在 v1.9.0 只是合约的书写语言,不是运行时传输实线 = 真实调用路径  虚线 = 合约定义存在、运行时零调用yunikorn-scheduler(单一二进制):shim 与 core 编译进同一进程,用 Go 接口互调 —— 无 dial / 无 endpoint / 无 gRPC 端口yunikorn-k8shimyunikorn-scheduler-interfaceyunikorn-coreKubernetesShimshim 主控与注册cache.Contextcache.Application · cache.TaskAsyncRMCallback实现 api.ResourceManagerCallback 全 8 个方法api.SchedulerAPIshim 调 core:4 个同名方法 + UpdateConfiguration(合约外)api.ResourceManagerCallbackcore 回调 shim:8 个方法4 个方法在 gRPC 合约之外si.protoservice Scheduler4 RPC 未启用RMProxycore 的 RM 网关pendingAllocEventspendingNodeEventspendingInfraEventsScheduler.HandleEvent 扇出三队列Scheduler / ClusterContextcore 调度主循环pendingRMEvents反方向队列 · RMProxy 自持RMProxy.HandleEvent 写入plugins 注册表RegisterSchedulerPlugink8shim 侧没有 gRPC 客户端K8s informer 事件RegisterResourceManager1UpdateNode / UpdateApplication / UpdateAllocation2同进程直调 · 无 dial / 无序列化3456handleRMEvents → triggerUpdateAllocation7同进程回调,不经网络89GetResourceManagerCallbackPlugin()10▸① 合约不对称:Go 接口比 si.proto 的 service Scheduler 多 5 个方法 —— UpdateConfiguration、Predicates、PreemptionPredicates、SendEvent、UpdateContainerSchedulingState;真要远程部署得先补齐这 5 个 RPC▸② 注册要同步等结果:RMProxy 发 RMRegistrationEvent 进 pendingInfraEvents,阻塞等 *rmevent.Result,Succeeded 才落地 rmIDToCallback + RegisterSchedulerPlugin(rmproxy.go:238,245,247,251)▸③ 全仓唯一 grpc.NewServer = NonBlockingGRPCServer(core/pkg/common/server.go:129,si.RegisterSchedulerServer 在 :133),只被 core/cmd/simplescheduler 用 —— gRPC 参考实现 / dev 命令、非部署件Pod / Node 事实来源;k8shim 用 informer 订阅,shim 侧不直接调度,只把事实转成 si.* 结构交给 corek8shim/pkg/cmd/shim/main.go:54 serviceContext := entrypoint.StartAllServicesWithLogger(...) 在本进程拉起 core 全部服务;:57 NewShimScheduler(serviceContext.RMProxy, ...),该字段静态类型即 api.SchedulerAPI(core/pkg/entrypoint/service_context.go:33)。Makefile:69-70 只产 yunikorn-scheduler 与 yunikorn-admission-controllerk8shim/pkg/shim/scheduler.go:78 rmCallback := cache.NewAsyncRMCallback(context);:133 registerShimLayer();:148 构造 si.RegisterResourceManagerRequest(rmID / version / policyGroup / buildInfo / config / extraConfig 全 6 字段);:162 SchedulerAPI.RegisterResourceManager(...)。Run() :187 顺序 dispatcher → phManager → apiFactory → registerShimLayer:203 → initSchedulerState:210 → doScheduling步骤 6 cache.Context.registerNodesInternal(context.go:1543,上报走 :1577;cordon/uncordon :238 用 si.NodeInfo_DRAIN_NODE / si.NodeInfo_DRAIN_TO_SCHEDULABLE;容量更新 :1597/:1602/:1623);步骤 7 cache.Application.handleSubmitApplicationEvent(application.go:425,提交 :430、移除 :752);步骤 8 cache.Task(task.go:319 CreateAllocationForTask → :330,释放 :502 与 context.go:421/451/505)。7 与 8 是稳态事件驱动,无固定先后;步骤 4 早于步骤 6 成立k8shim 侧唯一的回调实现体,另外还实现 api.StateDumpPlugin:GetStateDump(interface.go:81),core 侧调用方是 REST handler core/pkg/webservice/handlers.go:1098,1105 —— 它同样不在 si.proto 的 service Scheduler 里lib/go/api/interface.go —— RegisterResourceManager / UpdateAllocation / UpdateApplication / UpdateNode 与 si.proto 同名,另有 :36 UpdateConfiguration 在 gRPC 合约之外。serviceContext.RMProxy 的静态类型就是这个接口lib/go/api/interface.go:56 Predicates / :61 PreemptionPredicates / :65 SendEvent / :74 UpdateContainerSchedulingState —— 这 4 个都不在 si.proto 的 service Scheduler 里。core 侧反向调用点:core/pkg/scheduler/objects/node.go:502 Predicates、predicates.go:140 PreemptionPredicatessi.proto:29-49 service Scheduler:RegisterResourceManager(unary)+ UpdateAllocation / UpdateApplication / UpdateNode(三个双向 stream)。lib/go/si 已生成 si.pb.go / si_grpc.pb.go,但 k8shim/pkg 对 grpc. / NewSchedulerClient / RegisterSchedulerServer 零命中,k8shim/go.mod:117 grpc 标着 // indirect ⇒ 4 个 RPC 一行都没被启用core/pkg/rmproxy/rmproxy.go:247 rmp.rmIDToCallback[request.RmID] = callback、:251 plugins.RegisterSchedulerPlugin(callback);:280 UpdateAllocation 先归一化 partition 名再 HandleEvent;UpdateApplication → RMUpdateApplicationEvent、UpdateNode → RMUpdateNodeEvent 同理core/pkg/scheduler/scheduler.go:38-40,53-57,133-141 —— pendingAllocEvents 1024*1024 / pendingNodeEvents 100*1000 / pendingInfraEvents 1000。注册也走这里:RMProxy 发 RMRegistrationEvent{Registration, Channel} 后 :245 result := <-c 阻塞等 *rmevent.Result;重注册路径 :220-231 先发 RMPartitionsRemoveEvent 清分区再等。上行三队列与下行 pendingRMEvents 是两条反方向队列,不要混core/pkg/scheduler —— 消费三队列做调度;产出经 RMProxy 回写。另外 core/pkg/scheduler/objects 会绕过事件泵,直接用 plugins 注册表里的回调做同步反向调用(node.go:502、predicates.go:140)core/pkg/rmproxy/rmproxy.go:46,77 pendingRMEvents(1024*1024)—— :70 RMProxy.HandleEvent 写入,:187 handleRMEvents 消费,处理 RMNewAllocationsEvent / RMApplicationUpdateEvent / RMReleaseAllocationEvent / RMRejectedAllocationEvent / RMNodeUpdateEvent 五类,再由 :146 triggerUpdateAllocation → :148 callback.UpdateAllocation 下行。它是下行队列,与上行的 pendingAllocEvents 等三队列方向相反core/pkg/plugins/plugins.go:34-45 用 Go type assertion 把 callback 分流到 ResourceManagerCallbackPlugin / StateDumpPlugin 等;写入方是 RMProxy(rmproxy.go:251),读取方是 core 调度对象(plugins.GetResourceManagerCallbackPlugin())
这张图的一句话:v1.9.0 里 gRPC 只是「合约的书写语言」,不是运行时传输 —— k8shim 与 core 编译进同一个 yunikorn-scheduler 二进制、同进程用两个 Go 接口互调(main.go:54/57 把 core 的 *RMProxy 直接当 SchedulerAPI 注入)。整条链上没有一次 gRPC 网络跳。
Ch.2 · 图解 — Architecture11

⏱ 本页 2.6 分钟 · 主线 545 字 · 深潜层另有 1572 字

先说这张图怎么看,不然十几个方框一上来是懵的。 它分三条横带,从上到下就是三个仓库:最上面 yunikorn-k8shim, 中间 yunikorn-scheduler-interface,最下面 yunikorn-core。 但请你们先看整张图外面那个大框,和它右上角那行字 —— yunikorn-scheduler(单一二进制)。 (用手把整张图圈一下) 意思是:你在这张图上看到的所有方框,运行时都在同一个进程里。

走图的方向是一个来回:左边这一列往下,是 shim 调 core; 到最下面那条 core 带以后向右横穿;再在右边这一列往上折回, 是 core 回调 shim。

这张图存在的唯一理由,是纠正一个几乎所有二手材料都写错的说法: 「core 和 shim 是两个进程,之间走 gRPC」。 在 v1.9.0 里这是错的。 证据就在中间那条带里 —— 整张图只有一个方框是虚线画的, 就是 si.proto,上面写着 service Scheduler、 4 RPC 未启用。

(指右上角图例)右上角我写了口径:实线 = 真实调用路径, 虚线 = 合约定义存在、运行时零调用。 为什么敢画虚线:si.proto 里那 4 个 RPC —— 一个 unary 的 RegisterResourceManager 加三个双向 stream —— 一行都没被启用; k8shim 的 pkg 目录下 grep grpc.、 NewSchedulerClient、RegisterSchedulerServer 零命中, go.mod 里 grpc 还标着 // indirect。 所以 gRPC 在这个版本里只是「合约的书写语言」,不是运行时传输。

那真正在调的是什么?看中间那条带左右两个实线方框,它们才是运行时的东西: 左边 api.SchedulerAPI,是 shim 调 core 的方向; 右边 api.ResourceManagerCallback,是 core 回调 shim 的方向。 两个普通的 Go 接口,一次调用就是一次函数调用。

(指 si.proto 正上方那块空白) 还有一件事我是故意留白的:si.proto 正上方那一格是空的, 我在那里写了一行 —— k8shim 侧没有 gRPC 客户端。 这个空白本身就是本页的证据。

顺着编号走上行。① shim 主控 KubernetesShim 调 RegisterResourceManager 把自己注册进去; ② cache.Context 这一路把节点、应用、请求分别用 UpdateNode / UpdateApplication / UpdateAllocation 送进去。 ③ 是本页唯一一段会动的蚂蚁线,从合约层落到 RMProxy, 上面写着「同进程直调 · 无 dial / 无序列化」—— 这一步的机制是:k8shim 的 main 先在自己进程里 StartAllServicesWithLogger 把 core 的全部服务拉起来, 然后把 serviceContext.RMProxy 这个指针直接传进 shim, 而那个字段的静态类型就是 api.SchedulerAPI。 没有 dial,没有 endpoint,也没有 gRPC 端口。

进了 core 带,重点是两个方向相反的队列,图上画成两个格子符号,别看反。 ④ RMProxy 把请求交给 Scheduler.HandleEvent, 它扇出三个上行队列:pendingAllocEvents、 pendingNodeEvents、pendingInfraEvents; ⑤ 主循环 Scheduler / ClusterContext 消费它们。 产出往右走:⑥ 进右边那个 pendingRMEvents, 我在它下面专门标了「反方向队列 · RMProxy 自持」; ⑦ handleRMEvents 取出来交给 triggerUpdateAllocation;⑧ 回调落到 AsyncRMCallback,标着「同进程回调,不经网络」。 (这句值得强调)同进程不等于同步 —— 上下行中间各隔着队列, 它是解耦的。

右下角那条橙色线是本页第三条路径,也是最容易被跳过的一个分区。 ⑨ 从主循环底部横过去到 plugins 注册表, ⑩ 再往上取 GetResourceManagerCallbackPlugin() 直接回调 shim —— 这条不经事件泵,是同步的。 它对应的是右边那行橙字:4 个方法在 gRPC 合约之外 —— Predicates、PreemptionPredicates、SendEvent、 UpdateContainerSchedulingState。

最后交代图下面三条脚注。▸① 合约是不对称的:Go 接口比 si.proto 的 service Scheduler 多 5 个方法 —— 刚才那 4 个,再加 UpdateConfiguration。 含义很实际:真有人要做远程部署,得先把这 5 个 RPC 补齐。 ▸② 注册这一步是同步等结果的: RMProxy 发 RMRegistrationEvent 进 pendingInfraEvents,阻塞等结果,成功了才落地回调。 ▸③ 全仓唯一的 grpc.NewServer 确实存在, 在 NonBlockingGRPCServer 里, 但唯一调用者是 simplescheduler —— 它是 gRPC 参考实现、dev 命令,不是部署件。

(这一句可以说)图上每个方框鼠标悬停能看到对应的源码位置, 投屏也能用,会后各位可以自己核。 下一页我们把这条链拉直,看一个 pod 从 kubectl apply 到被绑定,中间到底卡在哪里。

Ch.2 · 它怎么工作 · 图解 · Submit Path

从 kubectl apply 到 pod 被绑定:完整时序 延迟不来自网络,来自两个独立时钟

同一个 Pod / 同一个进程 yunikorn-scheduler:k8shim ⇄ core 是 Go 直调 + channel,si.proto 只是接口契约K8s 控制面SI 边界(同进程调用)kubectl提交 Podkube-apiserverwatch 事件源admission-controller改写 schedulerNameshim Contextpkg/cache · Informershim App / Task FSMschedule() · dispatcherRMProxycore · SI 入口ClusterContextPartitionContextQueue→App→Node100ms 兜底主循环si.proto v1.9.0 · 接口契约,不是网络协议(字段节选)AddApplicationRequest{ applicationID, queueName, ugi, tags, executionTimeoutMilliSeconds, placeholderAsk, gangSchedulingStyle}Allocation{ allocationKey, resourcePerAlloc, nodeID, applicationID, taskGroupName, placeholder, originator, allocationTags }nodeID 为空 ⇒ 这是一个请求(1.9.0 已删 AllocationAsk:reserved "asks")apply Pod / Deployment1POST /mutate2JSONPatch: add /spec/schedulerName = yunikorn3watch 全部 Pod(无 FieldSelector)PodInformerHandlers: AddPod / UpdatePod / DeletePod4AddPod → updateYuniKornPod → SchedulerCacheensureAppAndTaskCreated:建 Application(New) + Task5tick #1 · service.schedulingInterval = 1s(默认值)schedule() 扫到 New app → SubmitApplicationapp FSM:New → Submitted6UpdateApplication(ApplicationRequest{ new })经 RMProxy → RMUpdateApplicationEvent → PlaceApplication(放置规则 → 挂队列)78ApplicationResponse{ accepted: AcceptedApplication }shim app FSM:Submitted → Accepted9每个 tick 只推进一个状态 ⇒ 冷启动是秒级,不是毫秒级≥1s(第二个 tick)Accepted 分支:postAppAccepted → skipReservationStage无 taskGroup ⇒ RunApplication → Running;有 ⇒ TryReserve → Reserving再下一 tick 的 Running 分支:scheduleTasks → InitTask → Pending → Scheduling9bUpdateAllocation(AllocationRequest{ allocations })nodeID 为空 = 请求 · RMUpdateAllocationEvent → partition.UpdateAllocation10tryAllocate 选节点11plugin.Predicates(si.PredicatesArgs)12同步返回:这个节点能不能放 —— 整条链唯一一次 core → shim 反向同步调用shim scheduler_callback.go:196 → context.go:675 IsPodFitNode → :690 predManager.Predicates(kube-scheduler 原生 framework 插件)AllocationResponse{ new } → AsyncRMCallbackRMNewAllocationsEvent(context.go:797 发、:803 同步等 channel)· AssumePod 重试 30×1s13bind Pod 到 nodeIDTaskBound · K8s event reason:Scheduling / Scheduled / PodBindSuccessful14带走这一句这条链上没有一次 gRPC 网络跳:k8shim 与 core 同进程(main.go:54 起 core、:57 直接注入 *RMProxy),si.proto 只是接口契约。延迟来自两个独立时钟:· shim:每 1s 一个 tick,每 tick 只推进一个状态· core:事件驱动 + 100ms 兜底,每个 partition 每轮只产出 1 个 allocationAC 的 FailurePolicy 默认 Ignore ⇒ AC 挂了,Pod会被 default-scheduler 起走,而不是被拒绝。v1.9.0 里确实存在 grpc.NewServer()(core/pkg/common/server.go:129、:133 si.RegisterSchedulerServer),但唯一调用方是 core/cmd/simplescheduler/simplescheduler.go:38 这个独立 demo 二进制,默认的 yunikorn-scheduler 部署从不启它 ⇒ 这条链上没有一次网络跳。kubectl apply -f pod.yaml / Deployment —— 用户侧唯一动作对象存进 etcd,并把 Pod 变化以 watch 事件推给所有 informer完整名 yunikorn-admission-controller(独立 Pod)。MutatingWebhookConfiguration yunikorn-admission-controller-mutations,webhook admission-webhook.yunikorn.mutate-pods,path=/mutate,Operations=[Create,Update]。收 POST 的是 cmd/admissioncontroller/main.go:153 → admission_controller.go:631 Serve → :125 mutate → :157 processPod → :197。Deployment/StatefulSet/Job 等 workload 只被打 user-info annotation(:220 processWorkload),不改 schedulerName。k8shim/pkg/cache/context.go —— informer 回调 PodInformerHandlers(:146-150)、SchedulerCache、Application/Task 对象、AssumePod 与 Predicates 回调都在这里两个不同的执行体:KubernetesShim.schedule() 每 1s 扫一遍所有 app(shim/scheduler.go:128、:171-185);Task 状态机跑在 dispatcher goroutine 上(task.go:339 Dispatch(NewSubmitTaskEvent) 是异步分界)yunikorn-core/pkg/rmproxy —— Scheduler Interface 的实现方。k8shim/pkg/cmd/shim/main.go:54 在同进程里起 core、:57 把 *RMProxy 直接注入 SchedulerAPI ⇒ 全程 Go 直调 + channelcore/pkg/scheduler/context.go + partition.go —— 放置规则、队列挂载、ask 记账,并把新 allocation 以 RMNewAllocationsEvent 同步回传core/pkg/scheduler/scheduler.go:89 internalSchedule —— 事件驱动 + 100ms 兜底(:96-98);context.go:120 tryReservedAllocate → tryPlaceholderAllocate → tryAllocate(:135-141);partition.go:822 起逐层挑队列/应用/节点,每个 partition 每轮只产出 1 个 allocationsi.proto v1.9.0 = 1edd16cd。AllocationRequest 字段 1 被 reserved "asks":请求与已分配统一用 message Allocation,靠 nodeID 空/非空区分(core/pkg/scheduler/partition.go:1218 if node == nil)。1.5/1.6 时代博客里的 AllocationAsk 已不存在。用户侧唯一动作。Deployment 走 workload webhook,只被打 user-info annotation;被改 schedulerName 的是它创建出来的 Podwebhook admission-webhook.yunikorn.mutate-pods,Operations=[Create,Update],FailurePolicy 默认 Ignoreadmission_controller.go:197 patch = updateSchedulerName(patch) → :370-377 追加 {Op:"add", Path:"/spec/schedulerName", Value: constants.SchedulerName}。FailurePolicy 默认 Ignore (webhook_manager.go:636) ⇒ AC 挂掉时 Pod 会被 default-scheduler 起走,而不是被拒绝。k8shim/pkg/client/apifactory.go:98 podInformer 没有 FieldSelector ⇒ shim 监听集群里全部 Pod。schedulerName != "yunikorn" 的 Pod 走 updateForeignPod(context.go:327) 只记账(si_helper.go:117 CreateAllocationForForeignPod),不进调度。context.go:325 utils.GetApplicationIDFromPod(先卡 schedulerName,utils.go:143)→ :329 updateYuniKornPod → :362 schedulerCache.UpdatePod → :368 ensureAppAndTaskCreated → :379 addApplication → :975 NewApplication。pod.Spec.SchedulingGates 非空时(:355-364)只进 cache,不建 Application/Task。shim/scheduler.go:128 go wait.Until(ss.schedule, GetSchedulingInterval(), stopChan);:171-185 schedule() 逐个 app 调 app.Schedule()(application.go:353-393)—— 每个 tick 每个 app 只走一个 case,也就是只推进一个状态。shim application.go:430 handleSubmitApplicationEvent 组装 &si.ApplicationRequest{New: []*si.AddApplicationRequest{...}};SchedulerAPI 就是同进程的 *RMProxy。core context.go:489 handleRMUpdateApplicationEvent → :526 objects.NewApplication → :527 partition.AddApplication → partition.go:331 getPlacementManager().PlaceApplication(app)AcceptedApplication 在 core/pkg/scheduler/context.go:539 构造,rmproxy.go:110-120 装进 si.ApplicationResponse 并回调;shim 侧 scheduler_callback.go:120 收到、:132 发 NewSimpleApplicationEvent(AcceptApplication)k8shim/pkg/cache/application.go:353-393 Schedule():Accepted 分支(:361-366)只调 postAppAccepted(:482),它按 skipReservationStage(:457) 派 RunApplication 或 TryReserve;scheduleTasks(:397) 只在 Running / Reserving 分支里跑 ⇒ 又要等下一个 tick。task.handle(InitTask)(:407) → task_state.go:325-327 New→Pending → postTaskPending(task.go:338) → SubmitTask → :330-332 Pending→Scheduling。gang 场景 Reserving 只调度 placeholder。task.go:330 SchedulerAPI.UpdateAllocation —— 跑在 dispatcher goroutine 上,不在 schedule() 调用栈里。rmproxy.go:265 → :280 RMUpdateAllocationEvent → core context.go:708 / :720 / :745 → partition.go:1223(:1218 if node == nil 判定这是 ask)scheduler.go:89 internalSchedule:事件驱动 + 100ms 兜底(:96-98);context.go:120 schedule() → tryReservedAllocate → tryPlaceholderAllocate → tryAllocate(:135-141);partition.go:822 起按 队列 → 应用 → 节点 逐层挑,每 partition 每轮只出 1 个 allocationcore objects/application.go:1654 → node.go:484 → :499-508 plugin.Predicates(&si.PredicatesArgs{})返回 core 后 objects/application.go:1659 TryAddAllocation → :1674 newAllocatedAllocationResult —— nodeID 这时才落定ClusterContext context.go:150 notifyRMNewAllocation → :794-801 RMNewAllocationsEvent{Allocations: [alloc.NewSIFromAllocation()]},:803 result := <-c 同步等;rmproxy.go:94-100 组装 si.AllocationResponse{New: ...} → :148 callback.UpdateAllocationscheduler_callback.go:49-77 遍历 response.New:getTask → setAllocationKey → retry.OnError(Backoff{Steps:30, Duration:1s, Cap:30s}) 调 context.AssumePod → TaskAllocated → 后台绑定 → TaskBound。注意 TaskGroupMatch 是 Eventf(regarding, related, eventtype, reason, action, note) 的 action 参数(task.go:302-304),kubectl describe pod 的 Reason 列里永远不会出现它;gang 场景的 reason 是 GangScheduling。v1.9.0 里确实存在 grpc.NewServer()(core/pkg/common/server.go:129、:133 si.RegisterSchedulerServer),但唯一调用方是 core/cmd/simplescheduler/simplescheduler.go:38 这个独立 demo 二进制,默认的 yunikorn-scheduler 部署从不启它 ⇒ 这条链上没有一次网络跳。
一句话:延迟不来自网络(整条链同进程),来自两个独立时钟 —— shim 每 1 秒一个 tick。
Ch.2 · 图解 — Submit Path12

⏱ 本页 2.4 分钟 · 主线 503 字 · 深潜层另有 1721 字

这是一张时序图,看法是:八条竖着的泳道从左到右, 左边三条在 K8s 控制面 —— kubectl、kube-apiserver、 准入控制器;右边五条全被一个框圈在一起,框上写着 「同一个 Pod / 同一个进程」,那就是 shim 和 core。 消息从上往下按编号 1 到 14 读。 另外图上有三样东西要先认出来:两条横着的橙色虚线是 shim 的时钟刻度, 标着 tick #1 和 tick #2;左边中段那个方框是「带走这一句」; 右上角那张便签是 si.proto 的字段节选。

先看 1 到 3,准入这一段。kubectl apply 进 apiserver, apiserver 发一个 POST /mutate 给准入控制器, 控制器回一个 JSONPatch:给 /spec/schedulerName 加上 yunikorn。 (这条必须说,客户会问)这个 webhook 的 FailurePolicy 默认是 Ignore,不是 Fail —— 所以准入控制器挂掉的时候,pod 不会被拒绝, 而是会被 default-scheduler 直接起走。 还有一个常见的画错:Deployment、StatefulSet、Job 这些 workload 只被打了 user-info 的 annotation,schedulerName 没被改; 被改的是它们创建出来的 pod。

4 和 5,事实进 shim。注意箭头上那句话: watch 全部 Pod(无 FieldSelector)。 也就是说 shim 的 informer 监听集群里所有 pod,不是只看自己的。 schedulerName 不是 yunikorn 的那些, 走 updateForeignPod 这一路只记账、不进调度 —— (这一点值得说)所以 default-scheduler 调度的普通 pod, 在 YuniKorn 眼里是 foreign 占用,它是知道的。 5 这一格里干的事是:进 SchedulerCache, 然后 ensureAppAndTaskCreated 建出 Application 和 Task, 此刻应用状态是 New。

接着是第一条橙色刻度线:tick #1, service.schedulingInterval 默认 1 秒。 6 这一秒的 tick 扫到那个 New 的应用,发 SubmitApplication,状态 New → Submitted。 7 走 UpdateApplication 进 core, 经 RMProxy 变成内部事件,8 在 core 侧跑放置规则、挂上队列。 9 回来一个 ApplicationResponse,里面是 AcceptedApplication,shim 侧状态 Submitted → Accepted。

(这一段是全页最重要的,放慢) 接下来是这张图唯一带脉冲圈的那一格,编号 9b, 也是最容易被漏掉、一漏就算错延迟的一跳。 很多人会以为 Accepted 之后就立刻发请求了。 不是。你看 9 到 9b 之间那道竖着的门闸,上面写着 「≥1s(第二个 tick)」 —— 因为 schedule() 每个 tick 对每个应用只推进一个状态。

第二个 tick 里做的是 postAppAccepted 加 skipReservationStage:没有 taskGroup 就 RunApplication 进 Running;有 taskGroup 就 TryReserve 进 Reserving, 而 Reserving 只调度 placeholder。 然后还要等再下一个 tick,走 Running 分支才 scheduleTasks → InitTask → Pending → Scheduling。 右边那行橙字就是结论:每个 tick 只推进一个状态 ⇒ 冷启动是秒级,不是毫秒级。

10 和 11 请求进 core。这里顺便念一下右上角那张便签, 因为它纠正了一个过期说法:1.9.0 已经删掉了 AllocationAsk, 字段被 reserved "asks" 占住了; 现在请求和已分配统一用 Allocation, 靠 nodeID 为空来表示「这是一个请求」。 1.5、1.6 时代的博客里那个 AllocationAsk,今天已经不存在了。 11 到最右边那条泳道,那是 core 的主循环 —— 事件驱动加 100 毫秒兜底, 逐层挑队列、应用、节点,而且每个 partition 每一轮只产出一个 allocation。 (这是第二个时钟,要点明)所以这条链上有两个独立时钟: shim 每 1 秒一个 tick,core 是毫秒级事件驱动。

12 这两条橙色线是全图最特殊的一跳,请注意方向 —— 它是从右往左的,core 反过来调 shim。

core 拿着 si.PredicatesArgs 问 shim 一个问题: 这个节点到底能不能放这个 pod? shim 侧 IsPodFitNode 转给 predManager.Predicates, 那是 kube-scheduler 原生的 framework 插件,答完同步返回。 (这句要说)这是整条链上唯一一次 core → shim 的同步反向调用 —— 一个很实际的含义是:predicate 的成本落在 shim 上,而 core 的主循环在等它。

最后 13 和 14。13 分配结果回传给 AsyncRMCallback,注意 AssumePod 这一步是 带重试的:30 步、每步 1 秒、上限 30 秒。 14 绑定,pod 落到 nodeID 上,任务状态 TaskBound; kubectl describe pod 里能看到的 reason 是 Scheduling / Scheduled / PodBindSuccessful。

(指底部结论框,这句照念) 所以这一页的落点就是下面这句:延迟不来自网络,来自两个独立时钟; 算冷启动延迟时漏掉 Accepted 之后那一跳,结果会偏小一整个 tick。 下一页我们钻进 shim 内部,看它把状态放在哪里 —— 答案是:哪儿都没放。

Ch.2 · 它怎么工作 · 图解 · State Rebuild

k8shim 内部:零持久化,把 apiserver 当唯一状态库 重启后靠 informer 全量重放 · 8 步

Informer 层 · 适配层shim 核心 · 全部状态只在内存边界 · yunikorn-core(同进程)Kuberneteskube-apiserver唯一的状态持久层零 CRD无本地持久化APIFactory建并启动 informerClients16 informer 的持有者16 个 Informer · resync=0PodInformer有回调,无 filterNodeInformer有回调,无 filterConfigMapInformer有回调 + filterPriorityClassInformer有回调 + filter其余 12 个 Informer仅 ListerContext事件入口 · UpdatePod 分叉 foreign / YuniKornSchedulerCache · 七张内存 mapnodesMappodsMappcMapassignedPodsassumedPodsorphanedPodspvcRefCountsDispatcher单通道事件总线AsyncRMCallback接收 core 回调api.SchedulerAPI同进程 Go 接口调用 · 不是 gRPCRegisterResourceManagerUpdateAllocationUpdateNodeUpdateApplicationUpdateConfigurationRMProxyyunikorn-core 入口 · 同进程List/WatchLister / 事件同进程调用response.NewKubernetesShim.Run() 启动顺序:dispatcher.Start() → apiFactory.Start()(16 informer + WaitForSync)→ registerShimLayer() → initSchedulerState() → doScheduling()initSchedulerState() → Context.InitializeState():8 步从 informer Lister 全量重放,全程不读任何自有存储1Step 1registerPriorityClassesPriorityClass 全量 List灌进 pcMap,必须最先做2Step 2loadNodes全量读 NodeInformer只登记,不参与调度3Step 3registerPods按 CreationTimestamp 升序跳过已终止 pod4Step 4enableNodes放开为可调度节点filterSchedulableNodes5Step 5AddSchedulingEventHandlers生产代码唯一挂 handler 处只注册 4 组回调6Step 6-8finalizePriorityClassesfinalizeNodes / finalizePods二次 List 对账,补初始化窗口两阶段防超卖:si.NodeInfo_CREATE_DRAIN 注册 → 灌完存量占用 → si.NodeInfo_DRAIN_TO_SCHEDULABLE 放开稳态:schedulerName ≠ yunikorn ⇒ foreign;orphan ⇒ 不发 allocationk8shim 不建 CRD、不落本地存储:进程重启后全部状态从 apiserver 经 informer Lister 全量重放(pod UID 即 AllocationKey,spec.nodeName 即已绑定节点)。resync=0 ⇒ 靠 watch 而非周期性 relist;除 Step6-8 的一次性 finalize 对账外,未发现周期性主动 relist 的路径。NewAPIFactory(apifactory.go)建 16 个 informer;apiFactory.Start() 是 Run() 的第 2 步(scheduler.go:200 → apifactory.go:254-255),随后 Clients.WaitForSync(clients.go:70-99)等同步。⚠ WaitForSync 是无限 for + 1s sleep,未找到超时/退出机制(未穷尽搜索,不宜作结论)。ConfigMapInformer 来自 NewAPIFactory 内的局部变量 namespaceInformerFactory(apifactory.go:95)——限命名空间、只建 ConfigMap informer。clients.go:40-68:KubeClient、SchedulerAPI、InformerFactory、16 个 informer、VolumeBinder。Run 全部 informer 见 clients.go:101-118,HasSynced 见 :70-99。三个数别混:16 = 声明且 Run 的(apifactory.go:40 + clients.go:101-118);7 = addEventHandlers switch 支持的 case(apifactory.go:204-235);4 = 生产代码实际注册的(context.go:114/125/136/146)。StorageInformerHandlers / PVInformerHandlers / PVCInformerHandlers 是无调用者的死分支。ConfigMapInformer:由 NewAPIFactory 内的局部变量 namespaceInformerFactory (apifactory.go:95)建,限命名空间;filterConfigMaps(context.go:514)只放行 yunikorn-configs / yunikorn-defaults 两个 configmap。PriorityClassInformer:注册 PriorityClassInformerHandlers,带 filterPriorityClasses;全量灌进 SchedulerCache 的 pcMap。Context.UpdatePod(context.go:325);AddPod 只是 UpdatePod(nil, obj)(:295-297)。分叉判据:utils.GetApplicationIDFromPod 先判 pod.Spec.SchedulerName != "yunikorn" ⇒ 直接返回 "" 走 foreign 路,与有无 app-id label 无关;取 app-id 的真实顺序是 Label yunikorn.apache.org/app-id → Annotation 同 key → Label applicationId → Label spark-app-selector。Context.lock 是粗粒度互斥,注释明说它「还确保多种事件类型不并发执行」(context.go:74)⇒ Pod/Node/ConfigMap/PriorityClass 事件串行处理。predManager(PredicateManager,context.go:110)复用 K8s predicates;NewSharedLister 在 :107。pkg/cache/external/scheduler_cache.go —— 全部在内存,无持久化。assumedPods 的 value 语义是「该 pod 的 volumes 是否全部 bound」(:48 注释),不是「是否 assumed」:key 存在才表示 assumed。orphanedPods:IsAssignedPod 且未终止、但 nodesMap 里没有 pod.Spec.NodeName 时置入(:336-346,日志 Marking pod as orphan),此时 updatePod 返回 false。另有 3 个派生视图 nodesInfo / nodesInfoPodsWithAffinity / nodesInfoPodsWithReqAntiAffinity 供 predicates 用。dispatcher.Start() 是 Run() 的第一步(scheduler.go:194),源码注释逐字:the dispatcher handles the basic event dispatching, it needs to be started at first。Step2 的 registerNodesInternal 等 NodeAccepted / NodeRejected、以及 core 回调投递的 EventTypeApp / EventTypeTask / EventTypeNode 都依赖它已在跑。AsyncRMCallback.UpdateAllocation(response *si.AllocationResponse)(scheduler_callback.go:49)处理三个 slice:response.New → retry.OnError(backOff Steps:30 / Duration:1s / Cap:30s,:69-73)包裹 context.AssumePod(:78) → dispatcher.Dispatch(:90);response.RejectedAllocations :94-100;response.Released :103-116。6 个方法(另有 Stop)。三条证据:pkg/cmd/shim/main.go:54-57 在 entrypoint.StartAllServicesWithLogger 后把 serviceContext.RMProxy 直接当 api.SchedulerAPI 传入;k8shim/pkg 下 grep google.golang.org/grpc 零命中;core 的 NewNonBlockingGRPCServer 唯一调用者是 core/cmd/simplescheduler/simplescheduler.go:38 这个独立示例二进制。si.proto 的 message 仍在用,但只作进程内 DTO。RegisterResourceManager 的请求体是 si.RegisterResourceManagerRequest{RmID, Version, PolicyGroup, BuildInfo, Config, ExtraConfig}(scheduler.go:148-155),调用点 scheduler.go:162-163。调用点 context.go:1362,实现 :1434-1445:PriorityClassInformer.Lister().List(labels.Everything()) 全量读,逐个 schedulerCache.UpdatePriorityClass(pc)。源码注释说明放第一步是为了后续注册用得上优先级。context.go:1370-1380:loadNodes(:1476) → RegisterNodes → registerNodes 为每个 node 造 si.NodeInfo{NodeID, Action: si.NodeInfo_CREATE_DRAIN, Attributes:{DefaultNodeAttributeHostNameKey / DefaultNodeAttributeRackNameKey …}}(Action @ :1513,实际 key 是 si.io/hostname、si.io/rackname,constants.go:38-39),并等 NodeAccepted / NodeRejected 回执。context.go:1384,实现 :1670-1697:PodInformer.Lister() 全量读,按 CreationTimestamp.Unix() 升序排(:1681-1683,为与上次运行的队列顺序一致),IsPodTerminated 的跳过并置 nil(:1688-1691),其余逐个 ctx.AddPod(pod);已绑定 pod 经 getExistingAllocation(:1737-1765) 还原占用。context.go:1392:enableNodes(filterSchedulableNodes(acceptedNodes)) —— 为每个 node 发 si.NodeInfo{NodeID, Action: si.NodeInfo_DRAIN_TO_SCHEDULABLE, Attributes:{}},一次 SchedulerAPI.UpdateNode(&si.NodeRequest{...})(实现 :1609,Action @ :1617)。context.go:1400,实现 :113-157 —— 生产代码中唯一的 AddEventHandler 调用点,只注册 4 组:ConfigMapInformerHandlers(+filterConfigMaps)、PriorityClassInformerHandlers(+filterPriorityClasses)、NodeInformerHandlers、PodInformerHandlers。全部用 AddEventHandlerWithResyncPeriod(handler, 0)。handler 挂在批量重建之后 ⇒ 才需要 Step6-8 对账。context.go:1409 / :1417 / :1425。因为 handler 是在批量重建之后才挂的,存在一个初始化窗口:窗口内被删的对象不会有 delete 事件。三个 finalize 各自重新 List 一遍建 map、比对并补删(实现 :1447-1472 / :1643-1668 / :1699-1734,日志 :1465 / :1661 / :1725)。先以 si.NodeInfo_CREATE_DRAIN 把节点登记成不可调度,灌完 Step3 的存量 pod 占用后,再用 si.NodeInfo_DRAIN_TO_SCHEDULABLE 放开 —— 防止存量占用还没录入 core 就被超卖。两条 UpdateAllocation 路径:foreign pod → CreateAllocationForForeignPod(si_helper.go:117-141,tags[common.Foreign])→ SchedulerAPI.UpdateAllocation(context.go:420-421);YuniKorn pod → ensureAppAndTaskCreated(context.go:368) → Task 状态机 → Task.updateAllocation(task.go:311) → CreateAllocationForTask(task.go:319) → UpdateAllocation(task.go:330)。门:SchedulerCache.updatePod 返回 false(进 orphanedPods)时,foreign 路直接 return(context.go:428,日志 skipping updating allocation for assigned orphaned pod)、YuniKorn 路不调 ensureAppAndTaskCreated(context.go:362)。
这张图的一句话:k8shim 零持久化、零 CRD —— 重启后靠 InitializeState 的 8 步从 informer Lister 全量重放(pod UID 即 AllocationKey、spec.nodeName 即已绑定节点)。所以「调度器重启」不丢账,但重放期间新 pod 会排队。
Ch.2 · 图解 — State Rebuild13

⏱ 本页 2.4 分钟 · 主线 494 字 · 深潜层另有 1876 字

这张图请分上下两半看,它们讲的是两件不同的事。 上半是稳态的结构:最左边那个高框是 kube-apiserver, 下面写着三行 —— 唯一的状态持久层、零 CRD、无本地持久化; 从它出来一条会动的蚂蚁线,标着 List/Watch, 这是本页唯一的动画,而且它是单向的 —— 状态只从 apiserver 流进来,shim 不往任何地方写。 往右三个分区:Informer 层加适配层、shim 核心、边界通向 core。 下半是重启时的重放序列:一行 Run() 启动顺序, 加下面六个编号方块。

先看 Informer 那一栏,标题是「16 个 Informer · resync=0」。 resync=0 的意思是关掉了周期性 relist,全靠 watch。 这里有三个数字很容易被混起来,我在悬停说明里写清了: 16 个是声明并且真的 Run 了的;7 个是代码里 switch 支持挂回调的; 而生产代码真正注册回调的只有 4 组 —— PodInformer 和 NodeInformer 无 filter, ConfigMapInformer 和 PriorityClassInformer 有 filter,其中 ConfigMap 那个只放行 yunikorn-configs 和 yunikorn-defaults 两个。 其余 12 个我合成了一行,写「仅 Lister」 —— 措辞是「当前实现未注册回调」,不是「不支持事件」。

中间这一栏是 shim 核心,标题我写的是「全部状态只在内存」。 Context 是事件入口,所有 pod 事件从这里分叉。 它下面是 SchedulerCache,七张内存 map,名字都印在图上: nodesMap、podsMap、pcMap、 assignedPods、assumedPods、 orphanedPods、pvcRefCounts。 (这个坑值得提一句)assumedPods 有个反直觉的地方: 它的 value 不是「是否 assumed」,而是「这个 pod 的 volume 是否都已绑定」—— key 存在才表示 assumed。 再往下两个方框:Dispatcher 是单通道事件总线, AsyncRMCallback 负责接 core 的回调。 还有一件对排障有用的事:Context 的锁是粗粒度互斥的, 源码注释明说它还负责「确保多种事件类型不并发执行」—— 所以 Pod、Node、ConfigMap、PriorityClass 的事件是串行处理的, 图上我也没画成多路并发流入。

右边这一栏是通向 core 的边界。api.SchedulerAPI 那个框的副标题 我特意写在图上:同进程 Go 接口调用 · 不是 gRPC。 框里列了 5 个方法,加上一个 Stop,一共 6 个; 下面 RMProxy 就是 core 的入口。 再看回来的那条线:response.New 从 RMProxy 回到 AsyncRMCallback,再投给 Dispatcher。

现在看下半张图,这是本页真正值钱的部分:它重启之后怎么恢复。 先念那行启动顺序,它在源码里是被注释钉死的: dispatcher.Start() → apiFactory.Start() (16 个 informer 加等同步)→ registerShimLayer() → initSchedulerState() → doScheduling()。 (这个顺序有讲究)事件总线是第一个起的, 源码注释原话就是「it needs to be started at first」; 而真正开始调度是最后一步 —— 先把账重建完,再开始分配。

六个方块是 InitializeState 的 8 步,我一个一个说机制。 Step 1 registerPriorityClasses:把 PriorityClass 全量读进来 灌进 pcMap,必须最先做,因为后面注册节点和 pod 要用到优先级。 Step 2 loadNodes:把所有节点读出来注册进 core, 但此刻只登记、不参与调度。 Step 3 registerPods:全量读 pod, 按 CreationTimestamp 升序排 —— (这个细节很漂亮)为什么要排?为了让重建出来的队列顺序和上次运行时一致。 已终止的 pod 跳过;已经绑定的 pod 靠它的 spec.nodeName 还原占用。 Step 4 enableNodes:这才把节点放开成可调度。

(指 Step2 到 Step4 下面那条橙色括线) Step 2 和 Step 4 是配对的,图上我用一条橙线把它们括起来, 写的是:si.NodeInfo_CREATE_DRAIN 注册 → 灌完存量占用 → si.NodeInfo_DRAIN_TO_SCHEDULABLE 放开。

这是一个两阶段防超卖的设计:先把节点登记成不可调度, 等 Step 3 把存量 pod 的占用全灌进 core 了,再放开 —— 否则存量占用还没录进去,调度器就会把这些资源又分出去一次。

Step 5 是这张图的灵魂,我把它画成了高亮框: AddSchedulingEventHandlers —— 事件回调是到这一步才挂上的,而且是生产代码里唯一挂 handler 的地方,只挂 4 组。 为什么灵魂?因为它在批量重建之后才挂, 中间就存在一个初始化窗口:窗口里被删掉的对象,不会有 delete 事件送来。 所以才需要最后那个方块,Step 6 到 8 的三个 finalize —— finalizePriorityClasses、finalizeNodes、 finalizePods,各自再 List 一遍对账、补删。 (指右下角那行小字)右下角我还留了稳态的两条判据: schedulerName 不等于 yunikorn 就走 foreign; 被标成 orphan 的 pod 不发 allocation。

所以这一页对客户的落点,就是底下结论框那句: k8shim 零持久化、零 CRD,重启后靠 8 步从 informer 全量重放。 (这个正反两面都要说)好的一面是「调度器重启」不丢账, 也不需要你去备份任何它自己的存储; 代价是重放期间新 pod 会排队,而且它完全依赖 apiserver 可达 —— 等 informer 同步那一步是死等的。 下一页我们进 core,看它拿到这些请求之后,一个调度周期里到底做了什么。

Ch.2 · 它怎么工作 · Scheduling Cycle

每个调度周期只产出一个 allocation 理解吞吐的唯一钥匙 · 源码级

// core/pkg/scheduler/context.go:120 —— 每个 partition 一个 result
func (cc *ClusterContext) schedule() bool {
  for _, psc := range cc.GetPartitionMapClone() {
    // ① 预留优先
    result := psc.tryReservedAllocate()
    if result == nil {
      // ② placeholder 置换(gang swap)
      result = psc.tryPlaceholderAllocate()
      if result == nil {
        // ③ 常规分配
        result = psc.tryAllocate()   // ← 返回单个 result
      }
    }
    ObserveSchedulingLatency(schedulingStart)
    if result != nil { /* 通知 RM */ activity = true }
  }
  ObserveSchedulingCycle(scheduleCycleStart)
  return activity
}

三条推论

  • ① K8s shim 只支持一个 partition(YUNIKORN-22)⇒ 每周期全集群一个 allocation
  • ② 吞吐 = 1 / 单周期耗时。官方文档独立印证:周期延迟落在 0.001–0.01 秒 ⇒ 100–1000 allocations/s
  • ③ 官方还指出:predicate 评估占了一个周期的绝大部分,是其他部分的 10 倍
做法:因此最该盯的指标是 yunikorn_scheduler_scheduling_cycle_milliseconds。它从 ~2ms 涨到 ~20ms,吞吐就从 ~600/s 掉到 ~50/s。
顺序有讲究:placeholder 置换的优先级高于新的常规分配—— 已凑齐的 gang 应尽快换手,不该让新来的普通 pod 抢走它占好的坑。
Ch.2 · 它怎么工作 — 调度主循环14

⏱ 本页 1.8 分钟 · 主线 385 字 · 深潜层另有 1457 字

这一页请不要逐行念代码,我建议你只做一个动作: (指着高亮那一行)指着这一行说 —— 「这里返回的是单个 result。一个周期,一个 allocation。」 然后立刻给出推论:吞吐等于一除以周期耗时。 这一句话是理解它全部性能数字的钥匙,也是这一页存在的唯一理由。

代码的位置我念一下,因为这一页的可信度就靠它: core/pkg/scheduler/context.go 第 120 行,函数 schedule() —— 遍历每一个 partition,每个 partition 拿一个 result。

(按注释里的编号顺序讲这三步) 第一步,tryReservedAllocate() —— 预留优先。 如果它返回空,才走第二步,tryPlaceholderAllocate(),也就是 gang 的 placeholder 置换。 还是空,才走第三步,tryAllocate(),常规分配。 关键是这三个函数各自只返回一个 AllocationResult。 中间那两行是埋点:ObserveSchedulingLatency 记的是单次分配尝试的延迟, ObserveSchedulingCycle 记的是整个周期 —— 待会儿要盯的就是后面这个。

右边三条推论,第一条把这件事推到了全集群规模。 推论一:Kubernetes shim 只支持一个 partition,对应的 issue 是 YUNIKORN-22。 (把这两件事合起来说)一个周期每 partition 一个 allocation, 而全集群只有一个 partition ⇒ 每个调度周期,全集群产出一个 allocation。

推论二,吞吐等于一除以单周期耗时。 (这个算术当场做一遍,效果最好) 社区宣称 2000 节点上 610 allocations 每秒。 那反过来算:一秒除以 610,每个周期约 1.64 毫秒。 而官方性能文档在另一个地方独立写着:周期延迟落在 0.001 到 0.01 秒之间, 也就是 1 到 10 毫秒,对应 100 到 1000 allocations 每秒。 两个来源自洽。 (落点这句建议照念)所以它的高吞吐不是靠批量绑定,是靠把单次周期压到毫秒级。

推论三,官方指出 predicate 评估占了一个周期的绝大部分,是其他部分的 10 倍, 也就是差不多九成的时间都花在这上面。这一条有两个后果,都要说。 第一,节点越多越慢 —— 早期实现是每个周期对全集群节点全量排序, 后来在 YUNIKORN-807 里改成用 B-Tree 存节点、做增量更新, 官方给的改善是:500、1000、2000、5000 节点上分别快 35 倍、42 倍、51 倍、74 倍。 (这个细节值得点一句)改善倍数随规模上升,说明原来那个实现是每周期全量排序。

第二个后果对读 benchmark 的人很重要:在 KWOK 假节点上测出来的吞吐会显著偏高, 因为假节点上 predicate 极其廉价 —— 没有真实的 kubelet、没有真实的卷和网络要判定。 我们自己的实测也受这个影响。

(指着那个「做法」框) 所以这一页最实用的产出是一个指标名,请照抄,不要凭记忆写: yunikorn_scheduler_scheduling_cycle_milliseconds。

它从大约 2 毫秒涨到大约 20 毫秒,吞吐就从大约每秒 600 掉到大约每秒 50 —— 十倍的退化,而且队列会立刻积压。 这是我建议你们第一个上告警的指标,理由就是上面那个除法。

(指着最下面那个红框) 最后说三个 try 的顺序,这个顺序不是随便排的: placeholder 置换的优先级高于新的常规分配。

为什么这是对的?因为一个已经凑齐的 gang 应该尽快把真实 pod 换进去, 不该让新来的普通 pod 抢走它辛苦占好的坑。 (这句可以带一下)另外每个 try 前面都有很便宜的短路检查 —— 没有预留就跳过第一步,没有 placeholder 就跳过第二步, 没有 pending 资源就整个跳过,避免无谓遍历。

(下面这个源码细节容易被问,先备好) 还有一件事值得提:它不是固定间隔轮询。 主循环等在一个 activity channel 上,配 100 毫秒的超时兜底; 一旦有产出就立刻再转一圈,所以忙的时候是背靠背连续跑,闲的时候每 100 毫秒空转一次。 别把它和 shim 侧那个默认 1 秒的 DefaultSchedulingInterval 混淆 —— 那是另一回事,在另一个仓库里。

(这个追问几乎一定会来) 可能被问:「一个周期只出一个 allocation,那不是很慢吗?」 回答两层:第一,关键在周期本身是毫秒级的; 第二,社区自己也看到了这个瓶颈 —— 1.10.0 的路线图里有 YUNIKORN-3118「Implement Parallel TryNode Evaluation」 和 YUNIKORN-3122「预过滤 taint 节点」两项,正对着这里。 (这句可以加,它显示我们的分析和社区对上了)我们独立分析出的瓶颈,和社区路线图指向同一个地方。

下一页进队列模型 —— 那是它 90% 的实际价值所在, 也是绝大多数团队真正会动手改的地方。

Ch.2 · 它怎么工作 · 图解 · Scheduling Cycle

调度主循环:四层深度优先剪枝,每层第一个成功就返回 源码级 · 理解吞吐的唯一钥匙

分区层 · 三顺位严格短路:本轮该 partition 至多 1 个 AllocationResult四层深度优先剪枝:queue → app → ask → node每层都在第一个成功处立刻返回 ⇒ 每 partition 每轮至多 1 个 AllocationResult瓶颈不在排序算法,而在「每次成功重走全树 + 阻塞一次 RM 往返」internalSchedule① 事件驱动 · 100ms 兜底ClusterContext.schedule② 遍历每个 partitiontryReservedAllocate③ 第1顺位 · 兑现预留tryPlaceholderAllocate③ 第2顺位 · 换占位符tryAllocate③ 第3顺位 · 常规调度触发一轮取分区nil ⇒nil ⇒Queue.TryAllocate④ DFS · queue.go:1681IsLeafQueue?sortApplications⑥ leaf 分支 · 排应用sortQueues⑤ parent 分支 · 递归下探leafparentDFS 递归两道 continue 闸门yunikorn-coreyunikorn-k8shimApplication.tryAllocate⑦ 逐 ask 过配额闸门Application.tryNodes⑧ 跳过不可调度节点treeIterator.ForEachNode⑨ B-Tree 快照 · score 升序Node.preAllocateCheck⑩ 纯本地快检 · 零成本AsyncRMCallback.Predicates⑩ 同进程调用 · 非 SI gRPC遍历逐节点plugins.GetResourceManagerCallbackPlugin()newReservedAllocationResult⑪ reservationDelay=2s 后预留PartitionContext.allocate⑪ Reserved ⇒ return nilnotifyRMNewAllocation⑫ result := <-c 阻塞等回执notifyRMAllocationReleased⑫ Replaced ⇒ 换占位符无节点可容纳ReservedAllocated ⇒ result 冒泡回 ClusterContextReplaced跨 cycle:本轮无 allocation ⇒ 下轮由 tryReservedAllocate 优先兑现pkg/scheduler/scheduler.go:89 —— select 三路:<-s.stop 退出;<-s.activityPending 立即触发(cap=1 的 chan bool,scheduler.go:58,由 registerActivity() scheduler.go:218 置位);<-time.After(100 * time.Millisecond) 兜底。不是 1ms 轮询。pkg/scheduler/context.go:120 —— for _, psc := range cc.GetPartitionMapClone();跳过 psc.root.GetMaxResource()==nil(:126) 与 psc.isStopped()(:130);整轮 ObserveSchedulingCycle 计时(:155),单分区 ObserveSchedulingLatency。context.go:135 → partition.go:837;reservationCount==0 直接跳过;内部走 Queue.TryReservedAllocate。context.go:138 → partition.go:855;phAllocationCount==0 跳过;该路径不过 PartitionContext.allocate(partition.go:864-873 直接 return result)。context.go:141 → partition.go:822;从 root 队列开始深度优先下探。三者严格顺序:前一个返回 nil 才试下一个。queue.go:1681。注释原文(queue.go:1676):This is a depth first algorithm: descend into the depth of the queue tree first. leaf 走 sortApplications(:1689),parent 走 sortQueues(:1717),两者互斥。取 headRoom=getHeadRoom()(:1684)、GetPreemptionDelay(:1685)、maxPreemptionsPerQueue=10(:1686/queue.go:48)。queue.go:1682 if sq.IsLeafQueue() → sortApplications(:1689);queue.go:1715 } else { → sortQueues(:1717)。一个 cycle 不可能先后各跑一次 —— 这两条是互斥分支。queue.go:1429 → sorters.go:101。先 filterOnPendingResources(sorters.go:181),再四分支(fair+prio / fair / prio+submitTime / submitTime+prio)。switch 无 default ⇒ Undefined 时完全不排序。withPlaceholdersOnly=true 时只留 HasPlaceholderAllocation() 的 app(queue.go:1435)。queue.go:1454。过滤 child.IsStopped()(:1462) 与 pending<=0(:1466),同时收集 GetFairMaxResource()。排序委托 sortQueue()(sorters.go:30);FifoSortPolicy 且不考虑优先级时完全不排序(sorters.go:38-42),遍历顺序 = GetCopyOfChildren() 的 Go map 随机序。parent 队列 sortType 硬设 FairSortPolicy(queue.go:682-685)。queue.go:1693/1694 canRunApp(queue maxApplications) 与 ugm.GetUserManager().CanRunApp(user/group 限额) 合并判断 ⇒ continue;queue.go:1697/1698 GetBackoffDeadline() 退避未到 ⇒ continue。源码只有这两处 continue。application.go:1030。遍历 sa.sortedRequests —— 顺序由插入维持(sorted_asks.go:29),比较用 Allocation.LessThan(allocation.go:540) = priority 降序 + createTime 升序;全程无 per-cycle ask 排序,也没有对应 metric。逐 ask 短路:unschedulable 超限、NotEnoughUserQuota、NotEnoughQueueQuota 等。application.go:1542。回调内先跳过 !node.IsSchedulable()(:1553) 与 !node.FitInNode()(:1560),再 sa.tryNode(node, ask)(:1564)。循环走完仍无节点时,才在 :1599-1612 判断是否转预留。node_iterator.go:38 —— getTree().Ascend(...)。取 iterator 时 cloneSortedNodes() 克隆整棵 B-Tree 做快照(node_collection.go:177,持写锁,无任何 metric)。nodeRef.Less(:59-71) 先比 nodeScore 升序,同分比 NodeID 字典序;score 由 ScoreNode 增量维护,调度周期内不重排 —— 所以 node_sorting_latency 那个 metric 其实不记录节点排序。node.go:526 —— 纯本地判断:请求资源 > 0、节点未被他人预留(isReservedForAllocation)、availableResource.FitIn。只有过了这一关才会往 shim 发 predicate ⇒ 不是每个节点都跨仓调一次。yunikorn-k8shim/pkg/cache/scheduler_callback.go:196 → Context.IsPodFitNode(k8shim/pkg/cache/context.go:675) → predManager.Predicates(context.go:690)。core 侧入口是 Node.preConditions(core/.../node.go:499,:504 构造 si.PredicatesArgs{AllocationKey, NodeID, Allocate});无 plugin 时一律放行(node.go:520)。application.go:1638。条件(:1599-1612):该 ask 尚未预留(reserved==nil) 且 askAge > reservationDelay(=2 * time.Second, application.go:51);遍历中记录 GetFitInScoreForAvailableResource 最小的节点为候选(:1606-1611);落定前再跑一次 preReserveConditions(predicates allocate=false, :1634)。partition.go:878。ResultType==Reserved 时 :916-919 调 pc.reserve(:971) 后 return nil ⇒ ClusterContext.schedule 拿到 nil:不置 activity、不调用任何 notifyRM*。本轮该 partition 无产出。context.go:794 —— 发 rmevent.RMNewAllocationsEvent 后 :803 result := <-c 阻塞等 shim 回执。主循环在此同步等待,这是「每 partition 每轮至多一个 allocation」的真实成本。ResultType==Replaced 走这条:context.go:148 调用 / :814 实现,带 si.TerminationType_PLACEHOLDER_REPLACED —— 真实 Pod 顶掉占位符。
这张图的一句话:一个 cycle = 「每 partition 至多一个 AllocationResult」的深度优先剪枝,queue→app→ask→node 四层每层都在第一个成功处立刻返回,而且末端还要同步等 shim 回执。⇒ 吞吐瓶颈不在排序算法,在「每次成功分配都要同步等一次回执」。
Ch.2 · 图解 — Scheduling Cycle15

⏱ 本页 2.3 分钟 · 主线 478 字 · 深潜层另有 1832 字

这张图是一个流程图,看法是:四条横带从上到下,就是四层深度 —— 第一带触发和分区,第二带队列,第三带应用和节点,第四带产出。 左上角那个方框是本页结论,一会儿我回来念。 编号 ① 到 ⑫ 就是读图顺序,但有两处不是直线,请先认出来: ④ 那里有一个菱形分支,还有一条绕回自己的蚂蚁线,那是递归; 第四带最左边那条橙色的,是终止分支 —— 它不产出任何东西。 另外第一带右边那个虚线框是分区层,框上写着口径: 本轮该 partition 至多一个 AllocationResult。

第一带 ① ② ③。① internalSchedule: 它不是定时轮询,是 事件驱动加 100 毫秒兜底 —— 有活立刻跑,没活最多等 100 毫秒再空跑一圈。 (这条要主动纠正)网上流传的「每 1 毫秒跑一次」在 1.9.0 不成立。

② ClusterContext.schedule 遍历每个 partition, 每个 partition 独立取一个结果。 ③ 是三顺位严格短路:先 tryReservedAllocate 兑现已有预留, 返回 nil 才试 tryPlaceholderAllocate 做占位符换手, 还是 nil 才走 tryAllocate 常规调度。 箭头上我就写着「nil ⇒」,这个顺序是硬的。

第二带是队列层,也是这张图最容易画错的地方,所以我特意画了菱形。 ④ Queue.TryAllocate,源码注释原话就是深度优先: 先往队列树的深处走。 菱形问的是 IsLeafQueue?, 两条分支是互斥的,一个周期里不可能两个都跑: ⑤ parent 分支走 sortQueues,排完子队列递归回自己 —— (指那条动的线)那条蚂蚁线标着「DFS 递归」,是本页的焦点; ⑥ leaf 分支走 sortApplications,在叶子队列里排应用。 两个 sort 都会先把 pending 小于等于 0 的过滤掉 —— 没有待调度的东西就连试都不试。 (这个细节值得说)还有一个反直觉点: 在 FifoSortPolicy 且不考虑优先级的时候, 子队列其实完全不排序,遍历顺序就是 Go map 的随机序。

从 leaf 分支下来,路上有一个橙色的小框:两道 continue 闸门。 第一道是队列和用户的可运行数合并判断 —— 队列的 maxApplications,加上用户或组的限额, 不过就 continue,直接跳过这个应用; 第二道是退避:GetBackoffDeadline 还没到,也跳过。 (口径要准)源码里只有这两处 continue, 所以我把原来「三道闸门」的说法改掉了 —— 数三道得把一个合并判断拆开数才成立。

第三带 ⑦ 到 ⑩,这一带解释了它的性能到底花在哪。 ⑦ Application.tryAllocate 逐个 ask 过配额闸门。 这里有个很省事的设计:sortedRequests 是插入时就有序的, 顺序是优先级降序加创建时间升序 —— 调度周期里完全没有对 ask 排序这件事,也就没有对应的耗时。 ⑧ Application.tryNodes 逐节点试, 先跳过不可调度的、跳过整体放不下的。 ⑨ treeIterator.ForEachNode —— (顺序别讲反)它是 ⑧ 调用的被调方,不是它先遍历完再交给应用。 它按节点得分升序走一棵 B-Tree 的快照, 得分是增量维护的,一个调度周期内节点不重排; 代价是每次取迭代器都要克隆整棵树,而这件事没有任何指标能看到。

⑩ 这一步是两个方框,我是故意拆开的,因为合起来会讲出一个错的性能结论。 左边 Node.preAllocateCheck 是纯本地快检、零成本: 请求资源大于零、节点没被别人预留、可用资源装得下。 只有过了这一关,才会往 shim 发 predicate —— (这句要说重)所以不是每个节点都要跨仓调一次 predicate。 右边紫色那个框就是 shim 侧的 AsyncRMCallback.Predicates, 中间那条紫色虚线是跨仓边界,上面标着 plugins.GetResourceManagerCallbackPlugin(), 并注明同进程函数调用、不是 SI 的 gRPC 往返。 很多架构图把这一步画成 core 和 shim 之间的 gRPC 请求,在 K8s 部署下是错的。

第四带是产出,请注意它有三个出口,不是一个。 橙色那条 ⑪ 是终止分支:所有节点都试完还是放不下, 而且这个 ask 已经等够了预留延迟,也就是 2 秒, 那就预留一个节点 —— 挑的是可用资源适配得分最小的那个, 落定前还要再跑一次预留条件检查。 然后 PartitionContext.allocate 拿到「已预留」这个结果, 直接 return nil ⇒ 本轮这个 partition 没有任何产出。 所以图上从这里出来的是一条橙色虚线,跨周期绕回 ③ —— 下一轮由第一顺位的 tryReservedAllocate 来兑现它。

另外两个出口在右边。绿色那条是成功:结果冒泡回 ClusterContext,交给 ⑫ notifyRMNewAllocation。 (这一格是本页的落点,放慢)请看这个框的副标题: 发出事件之后,主循环停在这里阻塞等 shim 的回执。 这就是「每 partition 每轮至多一个 allocation」的真实成本 —— 不是排序慢,是每成功一次就要同步等一次往返,然后重走一遍全树。 青色那条是另一个分支:结果类型是「被替换」的时候, 走 notifyRMAllocationReleased, 带 si.TerminationType_PLACEHOLDER_REPLACED —— 那就是真实 pod 顶掉占位符的那一刻,我们下一章讲 gang 会回到它。

(左上角那个结论框,建议照念) 所以这一页的结论是:四层深度优先剪枝,queue → app → ask → node, 每层都在第一个成功处立刻返回;瓶颈不在排序算法, 而在「每次成功都要重走一遍全树,加阻塞一次 RM 往返」。 (这句对客户最有用)它有一个很实际的推论: 你要提高吞吐,该盯的是单个周期的耗时,不是去调排序策略。 下一页我们看队列模型 —— 也就是这棵被反复下探的树,到底该怎么设计。

Ch.2 · 它怎么工作 · Queue Model

guaranteed 与 max:两个数字定义整个多租户 90% 的实际价值来自把这棵树设计对

语义(官方原话)

guaranteed(min)max(quota)
作用参与份额计算与分配决策该队列任意时刻所有分配的硬上限
与抢占抢占的锚点:队列不可跌破它与抢占无关
设成 0无保障禁止该队列使用该资源(如 nvidia.com/gpu: 0)
root 队列root 不能设任何资源限制,设了 parsing error。它的 max 自动等于集群大小
实测原文:给 root 设 resources 时 POST /ws/v1/validate-conf 直接返回 {"allowed":false,"reason":"root queue must not have resource limits set"}

一条最容易配错的设计原则

≤ 容量
Σ guaranteed
> 容量
Σ max

guaranteed 之和应 ≤ 集群容量(否则保障是空头承诺); max 之和可以、且通常应该 > 集群容量——这正是「允许借用空闲容量」的表达方式。

反面:如果你把所有队列的 max 加起来正好等于集群容量, 你就退化成了静态切分,丢掉了 YuniKorn 相对「多个专用集群」的主要好处——而那个好处占成本节省的约 70%(第四章)。
做法:调 max 通常安全(只放宽借用上限); 调 guaranteed 会改变抢占行为。优先调 max,谨慎调 guaranteed。
Ch.2 · 它怎么工作 — 队列模型16

⏱ 本页 1.8 分钟 · 主线 378 字 · 深潜层另有 1093 字

这一页只要传达一件事,而且是两个方向相反的不等式: guaranteed 之和要小于集群容量,max 之和要大于集群容量。 (停一下)方向是反的,而配错任何一个,整套东西都会失去意义 —— 前者失去意义是因为保障兑付不了,后者失去意义是因为退化成静态切分。

左边这张表是官方对这两个词的定义,四行,一行一行来。

(指着第一行) 第一行,作用。guaranteed 参与份额计算与分配决策; max 是该队列任意时刻所有分配的硬上限。 注意「任意时刻」这四个字 —— 它是瞬时约束,不是累计额度。

第二行,跟抢占的关系,这一行是全场最容易被忽略的一行。 guaranteed 是抢占的锚点,官方原话是:抢占把队列的 guaranteed 当作一条不可跌破的底线。而 max 跟抢占完全无关。 (这句要说重)推论是:如果你不设 guaranteed,抢占基本什么都不会做 —— 因为抢占的触发条件就是「某个队列低于它的 guaranteed」。 这是「抢占配了没反应」的第一大原因,后面讲抢占那一页会展开。

第三行,设成 0 会怎样 —— 这一行两边的语义完全不同,别搞反。 guaranteed 设 0,意思是没有保障,很温和。 max 设 0,意思是禁止该队列使用这种资源。 (这个用法很实用,值得讲)所以想让某个队列一张 GPU 都碰不到, 正确写法就是 nvidia.com/gpu: 0 写在它的 max 里。 这是个正规用法,不是 hack。

第四行,root 队列。root 不能设任何资源限制,设了直接 parsing error, 而且是整份配置被拒绝,不是只拒这一个队列。 它的 max 自动等于集群大小,而且它没有 guaranteed。

(指着左下那个实测框,这个 JSON 建议照念) 这一条是我们实测撞到的第一个硬约束。我们给 root 加了 resources, 然后 POST /ws/v1/validate-conf 直接返回 {"allowed":false,"reason":"root queue must not have resource limits set"}。 (这里可以自嘲一句)给整个集群设一个总闸,几乎是所有人的第一直觉 —— 而它是不允许的。 如果你要人为造出「全局稀缺」,比如做抢占实验, 必须插一个带 max 的中间父队列。这个技巧本身值得记住。

右边这张卡就是刚才那两个不等式,我把它做成了两个方块。 (指着左边那个方块)上面那个写的是 Σ guaranteed,念出来就是 所有队列的 guaranteed 加起来,要小于等于集群容量 —— 否则你的保障是空头承诺。 (指着右边那个方块)下面这个是 Σ max, 所有队列的 max 加起来,可以、而且通常应该大于集群容量 —— 这正是「允许借用空闲容量」在配置里的表达方式。

先讲 max 之和为什么应该大于容量,举个具体例子。 三个团队各自 20 个节点的专用集群,一共 60 个节点。现在合池。 如果你给每个队列的 max 都设 20,加起来正好 60 —— (停一下)那你只是把三个集群叠在了一起,一点都没省。 正确的做法是:每队 guaranteed 给 12、max 给 50。 空闲的时候任何一队都能借到 50,忙的时候各自保底 12。

(指着那个「反面」框,这句建议照念) 如果你把所有队列的 max 加起来正好等于集群容量,你就退化成了静态切分 —— 丢掉的正是 YuniKorn 相对「多个专用集群」的主要好处, 而那个好处占全部成本节省的大约 70%,第四章会算给你们看。 (这句要说)统计复用才是省钱的来源;YuniKorn 的作用是让这个复用变得「可执行」—— 也就是给团队一个他们信得过的配额。

(指着最下面那个「做法」框) 最后是一条运维建议,很实用:调 max 通常是安全的, 因为你只是放宽或收紧借用上限; 但调 guaranteed 会改变抢占行为 —— 你可能在不知情的情况下触发一轮抢占。 所以顺序是:优先调 max,谨慎调 guaranteed。

下一页是这一章的第一个静默失效的坑,而且它就藏在你刚才看的这份队列配置里: 同一套系统里有两套资源命名。

Ch.2 · 它怎么工作 · 图解 · Queue Accounting

四个量在队列树上怎么传播 并且:guaranteed 不参与准入 3 层树实例 · 两个 headroom 算例

示例:3 层队列树,数字单位 vcore(内部存毫核 int64)记账机制 · yunikorn-core v1.9.0L1rootL2父 / 叶L3叶队列totalPartitionResource所有节点可分配量之和 = 100root 自己不配额度,否则报:root queue must not have resource limits setrootmax 由节点注册动态给guaranteed—max100allocated64pending18root.prod父队列,只夹紧不存和guaranteed60max80allocated52pending15root.dev叶队列,独立分支guaranteed20max40allocated12pending3root.prod.etlheadroom 0guaranteed40max48allocated48pending9root.prod.bi未用满 guaranteedguaranteed20max60allocated4pending6SetMaxResource↓ max 夹紧↑ allocated / pending↓ 每次现算,不落盘↑ 逐层累加root.prod.etl:headroom = min(48−48, 80−52, 100−64) = 0 —— 卡在自己的 max,与 guaranteed 40 无关root.prod.bi:headroom = min(60−4, 80−52, 100−64) = 28 —— 可长到 32 > guaranteed 20,准入不看 guaranteed橙 ↓ max:仅校验期夹紧、运行期现算 · 主色 ↑ allocated(used)/ pending:实时逐层累加 · 紫 guaranteed:纯本地字段,不入准入① max:自顶向下,只在校验期夹紧一次checkQueueResource :130 拒 child.max > parent.max:133 ComponentWiseMin 夹紧后递归传子 —— 但 setResources 只写本节点⇒ 夹紧值不落盘;并集语义:父未定义的资源类型不受夹紧② used / pending:自底向上,真实字段incPendingResource 先递归父再加自己 ⇒ 每节点 pending = 子树之和TryIncAllocatedResource 逐层过 max 才加 allocatedResourcesortQueues:pending = 0 ⇒ 整棵子树被剪掉,不再下降③ 准入只看 max:headroom 里没有 guaranteedinternalHeadRoom = SubOnlyExisting(maxResource, allocatedResource)再与父队列 ComponentWiseMin 取 min;全函数不读 guaranteedResourceFitInMaxUndef:max 未定义的资源类型视为无限(= 不设限)④ guaranteed 的三条路径(都不管准入)① getFairShare 排序分母(本地值,嵌在 sortQueues 内)② 常规抢占快照 preemption.go:761(+ve = over utilized)③ quota 变更抢占 GetPreemptableResource(1.9.0 新增,−ve 才可抢)yunikorn_queue_resource:state 里没有 headroom 这一项/ws/v1/partition/:partition/queues:maxResource = 本地配置值partition.go:598 updatePartitionResource 把节点 delta 累加进 pc.totalPartitionResource,Prune() 后 :610 pc.root.SetMaxResource(pc.totalPartitionResource)。queue.go:1611-1621 显式拒绝非 root 调用(Warn: Max resources set on a queue that is not the root)。root 的 max 不是配置值,是集群总量:partition.go:610 pc.root.SetMaxResource(pc.totalPartitionResource)。allocated 64 = 52 + 12、pending 18 = 15 + 3,都是子树累加出来的。注意 root 的 allocatedResFits 用 FitIn(不 skipUndef):集群未注册的资源类型在 root 直接被拒(queue.go:1332-1336)。校验期 configvalidator.go:141 sumG.AddTo(childG) 累加子队列 guaranteed(40+20=60 ≤ 60 ✓)、:146 校验 Σchild.guaranteed ≤ parent.max;但这个和不落盘 —— queue.go:591 setResources 全段(591-645)对 children 零命中,只赋值 sq.maxResource / sq.guaranteedResource。dev 的 headroom = min(40−12, 100−64) = 28,只受自己和 root 的 max 约束,与 prod 子树互不影响。internalHeadRoom(queue.go:1505)::1517 SubOnlyExisting(maxResource, allocatedResource) = 48−48 = 0,:1524 再与父 ComponentWiseMin ⇒ min(0, 28, 36) = 0。allocated 48 > guaranteed 40 —— 借用超出 guaranteed 没有任何检查阻止,因为准入只判 headRoom.FitInMaxUndef(application.go:1069)。headroom = min(60−4, 80−52, 100−64) = 28 ⇒ bi 可以长到 32,远超自己的 guaranteed 20。反过来它也不因为 used < guaranteed 就被优待,guaranteed 只影响 getFairShare 的排序分母(resources.go:540)。configvalidator.go:125 checkQueueResource;:130 !parentM.FitInMaxUndef(curM) 拒;:133 curM = ComponentWiseMin(curM, parentM) 后 :137 递归传子。运行期靠 GetMaxResource() 每次逐层现算(queue.go:1532 起,doc comment 说 the missing quantity will be seen as a limit of 0,与 FitInMaxUndef 的「未定义=无限」是两套口径,别混讲)。ComponentWiseMin(resources.go:999-1024) 是并集;交集版是 ComponentWiseMinOnlyExisting(resources.go:1052)。入口 application.go:673(AddAllocationAsk, 637)→ queue.go:969-972 (*Queue).incPendingResource 先 sq.parent.incPendingResource(delta) 再加自己;decPendingResource 用 SubErrorNegative,负值打 Warn「Pending resources went negative」。两阶段可回滚:tryNode(application.go:1645) 先 :1659 node.TryAddAllocation,再 :1660 TryIncAllocatedResource(queue.go:1262 查自己 → :1268 递归查全链 → :1285 才写 allocatedResource),队列侧失败则 :1663 node.RemoveAllocation 回滚。剪枝在 queue.go:1467 StrictlyGreaterThanZero(child.GetPendingResource())。queue.go:1505-1525 internalHeadRoom:sq.maxResource == nil 时(:1511-1513)直接返回 parentHeadRoom。application.go:1069 逐 ask 判 !headRoom.FitInMaxUndef(request.GetAllocatedResource()),不过则尝试抢占,仍不过就 LogAllocationFailure(NotEnoughQueueQuota) + setHeadroomCheckFailed。user/group 配额是并列的第二道门(ugm Headroom, application.go:1055-1064,本图未展开)。排序链:queue.go:1454 sortQueues → sorters.go:30 sortQueue → :69-70 CompUsageRatioSeparately → resources.go:540 getFairShare,传的是 GetGuaranteedResource()(本地原始配置值);父队列默认 FairSortPolicy(queue.go:682-684)。GetActualGuaranteedResource(queue.go:838) 在 v1.9.0 零调用方、连测试都没有,是死代码 —— 所以图上没有「guaranteed 自顶向下取 min」这条箭头。抢占快照里的『有效 guaranteed』规则是 MergeIfNotPresent 继承父级(preemption.go:819),与 min 夹紧相反。Prometheus 侧 state 枚举只有 guaranteed/max/allocated/pending/preempting/maxRunningApps(metrics/queue.go:44-51),headroom 只在 REST 里有。REST 的 maxResource 用 sq.maxResource.DAOMap()(queue.go:924),没调 GetMaxResource(),所以它不是自顶向下夹紧后的有效上限;absUsedCapacity 同样基于本地值,只有 :914 的 HeadRoom 字段反映有效余量。
这张图的一句话:used/pending 自底向上实时累加;max/guaranteed 只存本节点、自顶向下每次现算取 min,从不写回子队列。🔴 而 headroom 公式里完全没有 guaranteed —— 所以「借用到 max」不是一个开关,是 guaranteed 压根不参与准入判定。
Ch.2 · 图解 — Queue Accounting17

⏱ 本页 1.8 分钟 · 主线 388 字 · 深潜层另有 987 字

这张图怎么看:中间竖线分两半,左边是一棵三层队列树的实例,右边是四张机制说明卡。 左边按 L1、L2、L3 三层往下:root、root.prod 与 root.dev、再往下 root.prod.etl 与 root.prod.bi; 每个框里都是同样四个格子:guaranteed、 max、allocated、pending。 (看图的钥匙,照念)颜色就是方向:橙色是 max,自顶向下; 主色是 allocated 和 pending,自底向上;紫色 guaranteed 一根箭头都不连,它是旁路。

左上角虚线框是集群层:totalPartitionResource,节点可分配量之和, 这里是 100,经灰线 SetMaxResource 打到 root —— root 的 max 不是你配的。而且 root 自己不许配额度,配了就报 root queue must not have resource limits set。

主链上有两条竖轨道:橙色虚线往下,标「max 夹紧」「每次现算,不落盘」; 主色实线往上,标「allocated / pending」「逐层累加」。 prod 到 root 那段是动画蚂蚁线,本页焦点:往上这个方向才是真实字段。 可以当场对账:root 的 allocated 64 = 52 加 12、pending 18 = 15 加 3。 兄弟分支只有向上箭头,guaranteed 不向下传播。

(左下角那两行算式,逐字念) root.prod.etl:headroom = min(48−48、80−52、100−64)= 0 —— 它卡在自己的 max 上,跟 guaranteed 40 没关系;它 allocated 48 已经超过 guaranteed 40,没有任何检查阻止它借过去。

root.prod.bi:headroom = min(60−4、80−52、100−64)= 28, 能长到 32,远超自己的 guaranteed 20。

右边四张卡。① max 是自顶向下、只在校验期夹紧一次: checkQueueResource 先拒掉 child.max 大于 parent.max,再夹紧后递归传子; 但 setResources 只写本节点,夹紧值不落盘; 而且它是并集语义,父队列没定义的资源类型不受夹紧。 ② used 和 pending 是自底向上的真实字段:incPendingResource 先递归父再加自己, 所以每个节点的 pending 都是子树之和;pending 为 0 的子树在 sortQueues 里被整棵剪掉。

③ 是本页落点、唯一高亮那张卡:准入只看 max,headroom 里没有 guaranteed。 internalHeadRoom 就是 max 减 allocated 再与父取 min, 全函数不读 guaranteedResource;

而 FitInMaxUndef 把 max 里未定义的资源类型视为无限,等于不设限。 ④ 那 guaranteed 干什么?三条路径都不管准入:排序分母、抢占快照、quota 变更抢占。 图上故意没有「guaranteed 自顶向下取 min」这条箭头 —— 那个函数在 v1.9.0 是零调用方的死代码。

右下角小条是观测出口:Prometheus 的 yunikorn_queue_resource 没有 headroom 这一项;REST 返回的 maxResource 是本节点配置值, 只有 headroom 字段反映真实余量。

一句话带走:「借用到 max」不是开关,是 guaranteed 压根不参与准入判定。 下一页看出厂默认的放置规则。

Ch.2 · 它怎么工作 · Trap #1

坑一:同一套系统里有两套资源命名 写错不报错、不生效

写在哪CPU 该写什么依据写错的后果
队列配置 resources.guaranteed / .max / limits.maxresources vcore 官方队列配置页全部示例都是 vcore: 10;core 内部常量 CPU = "vcore" 写 cpu ⇒ 被当成「一个名叫 cpu 的自定义资源」⇒ 对真实 CPU 完全不限流
Pod 注解 task-groups 的 minResource cpu 官方 gang 页示例是 "cpu": "100m"(这里是 K8s 资源名,由 shim 翻译) 写 vcore ⇒ 同样不报错、同样不生效
Pod 的 resources.requestscpuK8s 原生规范—
 官方原话(这是唯一的例外说明):"YuniKorn tracks CPU resources internally as the vcore resource type. This maps to the Kubernetes resource type cpu. All other resource types have consistent naming."
单位后缀 k/M/G/T/P/E(10 的幂)与 Ki/Mi/Gi/Ti/Pi/Ei(2 的幂); vcore 可用 m 表示 millicore;memory 默认单位是字节
🔴 1.0 起的行为变更 1.0 之前 memory 按 100 万字节解释、vcore 按 millicore 解释 ⇒ 从 0.x 迁上来的旧配置,数值含义会整体漂移,必须重算
为什么这个坑特别危险:它不报错。队列看起来配好了、API 里能读回来、pod 正常 Running—— 只有当某天一个作业吃掉整个集群时你才会发现那个配额从来没生效过。 ⚠️ 而且不能简化成「一律用 vcore」——那样讲会让听众把 gang 注解写错。必须讲清是分场景的。
Ch.2 · 它怎么工作 — 坑一:两套资源命名18

⏱ 本页 1.7 分钟 · 主线 350 字 · 深潜层另有 1395 字

这一页我建议用提问开场,因为反转能让人记住。 (先问,等一两个人回答,再说答案) 「CPU 在 YuniKorn 里该写 cpu 还是 vcore?」 ……答案是:都对,取决于你写在哪。 (停一下)而写错的后果不是报错,是不生效。

先说机制,一句话:YuniKorn 内部把 CPU 记作 vcore, 其余所有资源类型都和 Kubernetes 同名。 这个 vcore 是 YARN 时代的遗留命名。

(这句可以带一下,别展开,第三章讲生态时会正式说到) 这个项目是 Cloudera 造出来的,目的就是把 YARN 的经验搬到 Kubernetes 上 —— 知道这一点,vcore 这个名字就不奇怪了。

(这一条是最好的证据,建议念出来 —— 它让「内部形态」变成看得见的东西) 这不是我推的,日志里直接能看到内部形态。我们实测抓到的一行是: allocatedResource: "map[memory:343932928 vcore:200]"。 注意里面就是 vcore 这个键,而 vcore:200 是 200 millicore。 也就是说,pod 上写的 cpu,进到 core 里就变成了 vcore —— 是 shim 在中间翻译。

我们看表,四种场合,一行一行。 (指着第一行) 第一行,队列配置 —— 也就是 resources.guaranteed、resources.max、 还有 limits.maxresources —— 这里必须写 vcore。

依据有两条:官方队列配置页全部示例都是 vcore: 10; core 内部有个常量就是 CPU = "vcore"。

写错的后果:你写 cpu,它不报错, 但会被当成「一个名叫 cpu 的自定义资源」—— (这句说重)结果是这个队列对真实 CPU 完全不限流。

第二行,pod 注解里的 task-groups,它的 minResource —— 这里反过来,必须写 cpu。

依据是官方 gang 页的示例写的是 "cpu": "100m"。 为什么反过来?因为这个字段是给 shim 读的,用的是 Kubernetes 的资源名,由 shim 负责翻译。 写错的后果对称:写 vcore 同样不报错、同样不生效。

第三行是参照行,pod 自己的 resources.requests,那是 Kubernetes 原生规范,写 cpu, 这一行没有坑,我列出来是为了让对比完整 —— 三个地方,两套名字。

(指着第四行那句英文,这是唯一的官方说明,建议照念) 官方原话只有一句: "YuniKorn tracks CPU resources internally as the vcore resource type. This maps to the Kubernetes resource type cpu. All other resource types have consistent naming." 最后那半句很重要:只有 CPU 这一个例外,内存、GPU、hugepages 都是同名的。

再下面一行是单位后缀,这一行很容易踩。 两套后缀都支持:k、M、G、T、P、E 是 10 的幂;Ki、Mi、Gi、Ti、Pi、Ei 是 2 的幂。 两条要点:vcore 可以用 m 表示 millicore, 500m 就是半核;memory 的默认单位是字节 —— (这句要强调)不是 MB,是字节。写个 memory: 1000,你给的是一千字节。

(指着最后一行,这一行对做迁移的团队是硬信息) 最后一行是 1.0 起的行为变更,它影响所有从老版本迁上来的团队。 1.0 之前:memory 按一百万字节解释、vcore 按millicore解释。 1.0 之后:memory 是字节、vcore 是核。 (落点这句建议照念)同一份 YAML 在 0.x 和 1.x 上含义不同 —— 数字没变,含义变了。这类漂移最难查,因为配置文件的 diff 是空的。 所以从 0.x 迁上来,必须重算,不能照搬。

(指着底下那个提示框,这是这一页的落点) 为什么这个坑特别危险?因为它不报错。 队列看起来配好了、API 里能读回来、pod 全部正常 Running —— 只有当某天一个作业吃掉整个集群时,你才会发现那个配额从来没生效过。

(这一段是我自己的错,当场承认效果最好) 框里还有一句警告,是我写这份材料时踩的: 不能把这一页简化成「一律用 vcore」。 我最初就是这么总结的 —— 如果我照那个版本讲出去, 听众回去照着写 gang 注解,会全部失效,而且不报错。 所以这一页我特意保留了「分场景」这个说法,虽然它不好记。

(这个追问一定会来,答案是「没有」,要正面回答) 可能被问:「有没有办法让它报错?」没有。 POST /ws/v1/validate-conf 会校验结构, 但不会校验资源名是不是它认识的类型 —— 因为自定义资源,比如 GPU、hugepages,本来就允许任意名字,它没法判断。 (这个自检方法请让听众记下来) 唯一的自检方式是:配完之后从 REST 把配置读回来,看里面有没有 vcore 这个键。

下一页是头号坑,比这一页更严重 —— 这一页失效的是一个队列, 下一页失效的是你的整套配额体系。

Ch.2 · 它怎么工作 · Trap #2 · 头号陷阱

坑二:放置规则短路 ⇒ 你的整套配额被静默绕过 🔴 而这就是 v1.9.0 的出厂默认 —— 不是示例,是你什么都不配时的行为

# 官方文档给 tag 规则的示例,一字未改
placementrules:
  - name: tag
    value: namespace
    create: true

# 官方原话:
# "The order that the rules are defined in is the
#  order in which they are executed. If a rule
#  matches the policy will STOP executing the
#  remaining rules."
修法(三道防线全上): ① provided 规则放最前 + create: false; ② root.childtemplate 兜底给动态队列一个上限; ③ 巡检 isManaged==false。

✅ 实测:它做了什么

配好 root.{prod,dev,streaming}, root.dev 的 max_vcore=3000。提交一个 minMember=8 × 500m = 4000m 的 gang, pod 上明确打了 queue: root.dev。预期被配额拦住。实际 8 个 pod 全部 Running。

队列isManagedmax_vcorealloc
root.prodtrue80000
root.devtrue30000 ← 指定的队列,一点没用上
root.streamingtrue40000
root.gang-hardfalseunlimited4000

根因四步:① 规则链只有 tag,它第一个就匹配 ⇒ ② pod 上的 queue label 从未被查看 ⇒ ③ create:true 用 namespace 名自动创建了 root.gang-hard ⇒ ④ 该动态队列 isManaged=false、max 为 unlimited,继承 root ⇒ 等于没有配额。

诚实划界(必须说清,否则是冤枉文档):官方文档对机制的描述完全正确——短路求值、create 语义、动态队列都写了。 问题是它从未说明后果:不会说这让 queue label 失效,也不会说自动创建的队列无配额。而它给的示例恰恰就是这个危险组合。 ⇒ 正确说法是:「文档没写错,但它没告诉你后果。」
Ch.2 · 它怎么工作 — 坑二:放置规则19

⏱ 本页 1.6 分钟 · 主线 341 字 · 深潜层另有 1643 字

(这一页请放慢,如果全场只能记住一页,是这一页) 核心一句,我建议照念: 任何人只要 kubectl create namespace foo, 就自动获得一个「无配额、不受管」的队列 root.foo, 而你精心设计的配额体系被完整绕过 —— 不报错、不告警、pod 全部 Running。

(指着左边那段 YAML) 我们先看这段配置。这是官方文档给 tag 规则的示例,一字未改。 三行:name: tag、value: namespace、create: true。 (这里问一句,让他们看几秒)「这段配置有什么问题吗?」 ……看起来毫无问题。按 namespace 自动分队列,这是多租户的标准做法, 所以这段配置被大量复制。

(然后念下面那段官方原话,它就是全部的机制) 机制全在下面这句官方原话里: "The order that the rules are defined in is the order in which they are executed. If a rule matches the policy will stop executing the remaining rules."

(重一点)「匹配即终止」—— 后面的规则根本不执行。 而 Kubernetes 上的应用一定带 namespace 这个 tag, 所以这条 tag 规则永远第一个就匹配。

右边是我们的实测,价值在于「预期」和「实际」的落差。 配好 root.prod、root.dev、root.streaming, root.dev 的 max_vcore 是 3000。 提交一个 gang,minMember=8、每个 500m,一共 4000m, 故意超过那个 3000;pod 上还明确打了 queue: root.dev。

预期:被配额拦住。 (停一下)实际:8 个 pod 全部 Running。

(指着这张表,四行都要念,这个对比是这一页的冲击力所在) 然后我们去查队列树,看到这个: root.prod,isManaged 是 true,max 8000,用量 0。 root.dev,isManaged true,max 3000,用量 0 —— (这一行要停)注意,这是我们明确指定的队列,它一点都没用上。 root.streaming,isManaged true,max 4000,用量 0。 最后一行,root.gang-hard,isManaged 是 false, max 是 unlimited,用量 4000。

(这句说重)这个队列我们从来没有配置过。它是自动创建的,名字就是那个 namespace 的名字。

根因四步,我按框里的顺序念,因为每一步都是必要的: 第一步,规则链里只有 tag 这一条,它第一个就匹配。 第二步,因为匹配即终止 —— 而且 provided 规则根本不在链里 —— 所以 pod 上那个 queue: root.dev label 从来没有被查看过。 第三步,create: true 拿 namespace 的名字自动创建了 root.gang-hard。 第四步,这个动态队列 isManaged=false、max 是 unlimited, 因为它继承 root,而 root 的 max 等于集群大小 ⇒ 等于没有配额。

(这一段必须主动说,否则是冤枉文档 —— 它决定了这一页是「技术发现」还是「抱怨」) 下面这个框是诚实划界。官方文档对机制的描述完全正确 —— 短路求值写了、create 的语义写了、动态队列也写了。 问题是它从未说明后果:不会说这让 queue label 失效, 也不会说自动创建出来的队列没有配额。而它给的示例恰恰就是这个危险组合。 (这句是正确口径)所以正确的说法是:「文档没写错,但它没告诉你后果。」不要说成文档 bug。

(指着左下那个「修法」框,三道防线都要讲,建议全上) 第一道防线:把 provided 规则放最前面,并且写 create: false。

意思是「先尊重用户显式指定的队列,但不许它凭空造队列」。 第二道:在 root 上放一个保守的 childtemplate。 这样即使真有动态队列被造出来,它也会带上一个有限的 max,而不是无限。 第三道:巡检 isManaged==false。

(这条命令建议让听众记下来,它是这一页最实用的产出) 第三道防线具体是一条命令: curl -s .../ws/v1/partition/default/queues | jq -r '.children[]? | select(.isManaged==false) | .queuename'。 输出非空,就说明有人绕过了你的配额体系,去查是谁建的 namespace。 (这句要说)这条应该做成告警 —— 它是「配额体系是否完整」的单一最有效检查。

(这个副产品值得讲,它是关于「归因」的教训) 还有一件事,是我们自己在实验里犯的错,我保留下来: 我们最初把「队列被正确选中」这件事归因于 queue label, 后来发现那个归因是错的 —— 真实原因是那个 namespace 恰好也叫 dev, 两条完全不同的路径碰巧指向了同一个队列。 (落点这句建议照念)所以:当 namespace 名和队列名一致时, 这两种机制的区别会被完全掩盖 —— 直到某天不一致时突然爆炸。

(这个追问几乎一定会来,而且它是个好问题) 可能被问:「那我们把队列名和 namespace 名保持一致,不就没事了?」 那确实能规避这个坑,而且第四章讲计费的时候你会发现还有另一个好处 —— AWS 的成本分摊只给到 namespace,不给到队列,所以一一对应反而省事。 但要清楚这是「用约定规避机制」:一旦有人建了一个没有对应队列的 namespace, 坑还在原地。

下一页进 Gang 调度 —— 也就是第一章里那个 placeholder 机制, 这次我们看它的完整时序,还有它的参数坑。

Ch.2 · 它怎么工作 · 图解 · Placement Rules

放置规则求值链:出厂默认就会造出无上限队列 头号陷阱的完整机制 · 而且校验器不查它

配置期 · LoadSchedulerConfigFromByteArray → buildRulescheckPlacementRulestag 打头 ⇒ <dynamic> ⇒ 整条不校验,零 warningbuildRulesplacementrules 空 ⇒ 隐式 provided + create:falserecoveryRule永远追加为链上末条(不可配)运行期 · PlaceApplication 单次迭代出厂默认 tag/namespace/create:true ⇒ 每个 namespace 必然匹配 ⇒ 无上限队列静默路径 · 未提供 queues.yaml 时的出厂默认(只有 create:true 能进这里)PlaceApplication按序遍历 · 首个命中即停规则内部(tag 为例)不过 ⇒ 下一条① tag 存在性(tag 独有)② filter ⇒ 不通过=不匹配③ parent rule 递归求值④ create:false ⇒ 须已存在queue == nil ?CheckSubmitAccesswalk-up 祖先 · 仅这一项partition.createQueue复查:名字 / ACL / 祖先非 leafNewDynamicQueueunmanaged · maxResource=nilnil三道检查(queue ≠ nil)IsLeafQueue / CheckSubmitAccess / IsDrainingSetQueuePath成功出口 :215≠ nil无配额 ⇒ 运行期 annotation 补救yunikorn.apache.org/namespace.quota兜底 · 末条仍空(仍在同一次迭代内,:127 早于后置检查)root.@recovery@app forced ⇒ :145 break,跳过后置检查root.default须已存在 · 不会被创建 · 仍过后置检查ErrorRejectedapplication rejected: no placement rule matched非 forced都不成123configvalidator.go:814 checkQueueHierarchyForPlacement —— getLongestStaticPath 一遇到非 fixed 规则就把 staticPath 置为 "<dynamic>"、foundDynamicRule=true(:843-849);随后 if strings.Index(path, RootQueue) != 0 { continue } ⇒ 整条规则链跳过队列存在性与 leaf 校验,errNonExistingQueue / errQueueNotLeaf 都不会触发。调用链 LoadSchedulerConfigFromByteArray → checkPlacementRules(:315) → getLongestPlacementPaths(:806),发生在 buildRules 之前(context.go:181 / :227)。第二陷阱:checkPlacementFilter(:446-450) 用 strings.EqualFold,所以 type: Deny 能过校验,但运行时 filter.go:138 是精确 != filterDeny("deny") ⇒ deny 静默变 allow,两处之间无任何 ToLower 归一化。✅实测已三层确证:四种大小写全过校验;只有精确小写 deny 仍渲染为 deny,Deny/DENY/dEnY 三种在 /placementrules 上全部渲染成 allow;路由结果不同。巡检:/ws/v1/config 保留原文、/placementrules 显示生效语义,两者不一致即中招。placement.go:229-232:placementrules 为空时隐式补 {Name: types.Provided, Create: false}。规则名大小写不敏感(rule.go:139-141 normalise=ToLower);写 recovery 直接报错 recovery rule cannot be part of the config, failing placement rule config(rule.go:118-119)。可写类型 5 个:fixed / user / provided / tag / test(types.Test 在 newRule 的 switch 里是可达分支,只有注释说别在测试外用)。未提供 queues.yaml 时才走 core 的 DefaultSchedulerConfig —— Helm values.yaml:119 yunikornDefaults: {} 且 templates/ 内无 queues.yaml;客户若用 --set-file 或独立 ConfigMap 提供了 queues.yaml,默认配置不生效。placement.go:244 newRules = append(newRules, &recoveryRule{}) —— 无论用户配了什么,recoveryRule 永远是最后一条。单分区规则链看 GET /ws/v1/partition/:partition/placementrules(routes.go:84 → getPartitionRules → handlers.go:883);全量 dump 在 /ws/v1/fullstatedump(routes.go:290)与 /debug/fullstatedump(routes.go:205),不在 /ws/v1/scheduler/ 下。placement.go:113 for _, checkRule := range m.rules;:114 remainingRules--;:118 checkRule.placeApplication —— 返回 err 则 SetQueuePath("") 整体失败(:119-125),不再试下一条;返回 "" 则 continue 下一条(:139-141)。tag_rule.go:80-83 if tagVal == "" { return "", nil } —— tag 规则的第一闸是 tag 存在性,在 filter 之前,这是 tag 独有的顺序:user_rule.go:72 / fixed_rule.go:93 的 filter 才是第一件事,provided_rule.go:80 在 :75 空检查之后。出厂默认用的 tag 名是 namespace(AppTagNamespace),k8shim 一定会填。tag_rule.go:85-91 → filter.allowUser(filter.go:50-73):空 filter 直接返回 filter.allow;否则用户列表/正则先匹,再逐 group,首个命中即返回 filter.allow,都不命中返回 !filter.allow。注意它「不通过」等于「本规则不匹配」,不是拒绝应用 —— 会继续试下一条规则。tag_rule.go:96-102 若 tag 值已是 root. 全限定名则跳过父规则;否则 replaceDot 把 . 换成 _dot_(rule.go:143-146,configvalidator.go:39-41 DOT/DotReplace),再递归父规则(:110-111)。父规则返回空 ⇒ 本规则返回空(:117-119);父队列若已存在且是 leaf ⇒ 报错 parent rule returned a leaf queue。tag_rule.go:143 if !tr.create && queue == nil { return "", nil } —— create 的语义只在这一行:false = 队列必须已存在,否则视为未匹配;true = 跳过存在性检查,直接把不存在的队列名当匹配结果返回(:149)。四条规则同构:tag_rule.go:143 / provided_rule.go:138 / user_rule.go / fixed_rule.go。它本身不创建队列 —— 创建在 partition.createQueue;recovery 路径完全绕过它(partition.go:348 createRecoveryQueue)。placement.go:151 queue := m.queueFn(queueName),:153 在此分岔。queue == nil 只有 create:true 的规则才可能走到 —— create:false 在规则内部就已经视为未匹配了。placement.go:155-159 往上找最近一个已存在的祖先队列;:161-169 只做 CheckSubmitAccess,失败则 queueName="" 后 continue。出厂默认 root 的 submitacl 是 '*',所以这一项也必然通过。此分支没有 IsLeafQueue、没有 IsDraining —— 但这个「少两项」只在 placement.go 内成立,下游 createQueue / addChildQueue / AddApplication 还有 4 层复查。拒绝日志 Submit access denied on queue 是 Debug 级(:162),默认级别看不到。partition.go:353 AddApplication 里 queue == nil 且非恢复队列 ⇒ createQueue(:346-357)。createQueue(:532-568)::535 illegal queue name passed in → :548 CheckSubmitAccess → :551 祖先已是 leaf 则 creation of queue %s failed parent is already a leaf: %s → 逐级 NewDynamicQueue(:560);addChildQueue 还会查父队列 IsDraining(queue.go:1145);建完回到 partition.go:361 再 IsLeafQueue。newDynamicQueueInternal 只设 Name / QueuePath / parent,isManaged=false,maxResource / guaranteedResource / maxRunningApps 全为 nil ⇒ 无上限、无模板配额。运行期确有 Info 日志 dynamic queue added to scheduler(queue.go:224)与 SendNewQueueEvent(:226)—— 「静默」指的是配置期零 warning,不是运行期无记录。placement.go:170-201:IsLeafQueue(:172) → CheckSubmitAccess(:182) → IsDraining(:192),任一失败都 queueName="" 后 continue 下一条规则;全过则 :207 break。三个拒绝分支的日志 Submit access denied on queue / Rule returned parent queue / Cannot place application in draining queue 全是 Debug 级(:162/:173/:193),默认级别下看不到 —— 这反而强化了「静默」。CheckSubmitAccess 自身向上递归(queue.go:876-888)。placement.go:215 app.SetQueuePath(queueName) —— 唯一的成功出口。partition.go:365-378:AddApplication 用 tag namespace.resourcequota / namespace.resourceguaranteed / namespace.resourcemaxapps 给刚建出的动态队列补配额(k8shim 把 annotation yunikorn.apache.org/namespace.quota 等转成这些 tag)。这是运行期的补救,不是唯一出路 —— 配置期的正路是给父队列配 childtemplate(queue.go:1159-1164 → applyTemplate,Debug 日志 applying child template to new leaf queue)。recovery_rule.go:59 if !app.IsCreateForced() { return "", nil };:63 返回 common.RecoveryQueueFull = root.@recovery@(constants.go:29-30)。placement.go:145-149 命中后直接 break,跳过所有后置检查。IsCreateForced 看 tag application.create.force —— k8shim metadata.go:90-93 对任何已被调度的 pod(含 static/mirror、DaemonSet)都置 True,所以这条路在真实集群比想象中常触发。placement.go:127 if remainingRules == 0 && queueName == "" ⇒ common.DefaultPlacementQueue = root.default(constants.go:31),且 :133 要求 queueFn 返回非 nil —— 它不会被创建。因 recoveryRule 必然是末条,remainingRules == 0 就是 recoveryRule 那次迭代,所以 root.default 只在 app 非 forced 时才有机会生效。日志 No rule matched, placing application in default queue 用的 logger 是 log.Config。placement.go:210-213:三个兜底全不成才拒绝应用。真实优先级是 root.@recovery@(forced 时在 :118 就命中并 break)→ root.default(须已存在)→ ErrorRejected;二手资料常把前两个写反。
这张图的一句话:v1.9.0 的出厂默认就是 tag/namespace/create:true + root submitacl '*':每个 namespace 必然匹配、必然造出一个 unmanaged 且 maxResource=nil 的无上限队列;而配置校验器只验证 fixed 规则链,对 tag 规则不验证。 🔴 同一个 '*' 的第二个后果(✅实测):submit ACL 向上求并⇒ 子队列的 submitacl 全是装饰品,除非先收紧 root。
Ch.2 · 图解 — Placement Rules20

⏱ 本页 1.2 分钟 · 主线 258 字 · 深潜层另有 2237 字

(这一段是本页后来补上的,因为实测撞出了同一个默认值的第二个后果 —— 而这一条属于安全范畴,比配额那条更该说) 刚才那个出厂默认里还有 root submitacl: '*' 这一项。 它的第二个后果是:你在子队列上写的任何 submitacl,开箱状态下全都是装饰品。

机制是这样的:YuniKorn 的 submit ACL 是沿队列树向上求并,不是向下求交 —— (这一句是官方文档自己写的,可以念原文) 「This recursive check is repeated until an ACL provides access」。 也就是说:只要沿途任何一级放行,就放行。而 root 出厂就是 '*', 所以它永远第一个放行 —— 子队列写什么都不再被问到。

(实测证据,两轮 A/B,值得给出来) 我们做了一次干净的对照:三个子队列分别写 submitacl: 'deny'、'Deny'、空值。 root 是 '*' 时,三个全部 Running —— ACL 完全没起作用。 然后只改一处:把 root 的 submitacl 换成一个不存在的用户,其余不动, 三个立刻全部变成 ApplicationRejected。 (停一下)根因就此坐实:不是子队列的 ACL 写错了,是 root 把它们全部短路了。

(这条排障时特别值钱,因为报错指向了错误的方向) 还有一个附带发现:ACL 拒绝时,报错说的是「no placement rule matched」。 机制上能理解 —— rule 的 ACL 检查不通过,这条 rule 就被视为「不匹配」,规则链走完就报没有规则匹配。 但用户侧完全看不出这是权限问题,会跑去查放置规则的配置,而真正要改的是 ACL。 所以:看到「no placement rule matched」,先怀疑 ACL,再怀疑规则。

(这一条后来我们端到端实测了,可以说得更硬) 图上那个「type: Deny 大写会静默变成 allow」,我们在集群上从三个层面验证过。

第一,配置校验通过 —— 校验器用 strings.EqualFold,所以 deny、 Deny、DENY、dEnY 四种写法全都返回 {"allowed":true}。 第二,REST 渲染出来的语义反转了 —— 只有精确小写的 deny 还是 deny, 其余三种全部渲染成 allow。第三,路由结果真的不同。

(这里给一条能直接抄回去用的巡检方法,很实用) 怎么自查有没有中招?/ws/v1/config 保留你写进去的原文, 而 /placementrules 显示的是实际生效的语义 —— 两者不一致就是中招了。 (这个判据很干净,因为不用提交任何 pod 就能看出来)

(这条为什么值得单独强调,建议照念) deny 是一个「限制」语义。把它静默反转成 allow,属于 fail-open —— 也就是「配置写错的方向,恰好是权限放开的方向」。

而且校验器还给了你一个「配置没问题」的正面确认,让你以为限制已经生效。 (停一下)这是访问控制机制里最不该出现的失败模式。

(诚实边界仍要说) 两点限定:我们只测了 provided 规则上的 filter、只测了 users 过滤; 其他规则类型走的是同一份 filter.go 代码,机制上推断同样受影响,但我们没测。 另外这一条和前面讲的 submitacl 是两条不同的代码路径 —— submitacl 上我们实测过,'Deny' 与 'deny' 行为一致、 没有变成 allow。两者别混起来讲。

这张图有三条横泳道,从上往下读。最上面是配置期; 中间最大那条是运行期,是 PlaceApplication 单次迭代的真实顺序; 最下面是兜底,三个框带 1、2、3 编号。 中间那条泳道里还套着一个红框,我叫它「静默路径」。 红色在这张图上就是「出厂默认会走的那条路」,而它的终点是一个无上限队列。

配置期三个框。checkPlacementRules 最狠: 校验器只验证 fixed 打头的规则链,一遇到非 fixed 就把静态路径置成 <dynamic> 然后跳过 —— 整条链不查队列存在性、不查 leaf,配置期零 warning。 buildRules:规则为空时隐式补一条 provided 加 create:false。 第三个:recoveryRule 永远被追加成末条,配不了也删不掉。

(这句措辞很重要,重一点) 我说的不是「官方示例」,是 v1.9.0 的「出厂默认」 —— 你没自己提供 queues.yaml 时,默认就是 tag 取 namespace 加 create:true,再配上 root 的 submitacl 是一个星号。 每个 namespace 都必然匹配、必然被放行。

运行期从 PlaceApplication 开始,按序遍历、首个命中即停。 下面那个小框是规则内部四道闸,以 tag 为例从上往下: ① tag 存在性 —— 这道 tag 独有,别的规则第一件事是 filter; ② filter,它「不通过」等于本规则不匹配,不是拒绝应用,会继续试下一条; ③ 父规则递归求值,父规则空则本规则空; ④ 是唯一高亮那行 —— create:false 时队列必须已存在。 create 的全部语义就在这一行,而且它本身并不创建队列。

接着是菱形 queue == nil ?,检查强度的分岔点。 下面那条标「≠ nil」的正常路径:队列已存在,要过三道检查 —— IsLeafQueue、CheckSubmitAccess、IsDraining, 全过才到绿色成功出口 SetQueuePath。 上面那条红的标「nil」:只有 create:true 走得到,这里只查一项 —— 往上找最近的已存在祖先做一次 CheckSubmitAccess。 (这句要补)「少两项」只在 placement.go 里成立, 下游 createQueue 还会复查名字、ACL、祖先是不是 leaf。

红线终点、也是那段会动的蚂蚁线指向的框:NewDynamicQueue —— unmanaged, maxResource 是 nil。无上限、无模板、无配额。

往下那条虚线是运行期唯一补救:用 yunikorn.apache.org/namespace.quota 事后补;配置期的正路是给父队列配 childtemplate。

(口径要澄清,否则会被打脸)「静默」指配置期零 warning,不是运行期毫无记录 —— 运行期确有一条 Info 日志 dynamic queue added to scheduler, 但那三个拒绝分支的日志全是 Debug 级,默认看不到。

最下面兜底那条,编号 1、2、3 的顺序正好和二手资料写的相反: 先是 root.@recovery@ —— app 被标了 forced 就命中并 break, 跳过所有后置检查;而 k8shim 对任何已被调度过的 pod都会把 forced 置 true, 这条路比你想的常走。非 forced 才落 root.default, 它必须已存在、不会被创建,命中后还要过后置检查; 都不成才 ErrorRejected。

下一页进 gang。

Ch.2 · 它怎么工作 · Gang Scheduling

Gang:先用 placeholder 占坑,再换成真实 pod 三个阶段 · 三个注解

① PREPARE
创建 placeholder

按每个 taskGroup 的 minMember 创建等量 pause pod,资源精确等于 minResource

›
② RESERVE
占位

placeholder 是真实 K8s pod,只跑 pause,被 kubelet 真正启动,占住节点上的坑

›
③ SWAP
换手

凑齐 minMember ⇒ 发 RunApplication ⇒ 真实 pod 换进 placeholder 占好的位置

›
✗ TIMEOUT
凑不齐

Hard ⇒ 整个应用失败;Soft(默认) ⇒ 退化成普通逐 pod 调度

三个注解(缺一不可)

注解放在哪
yunikorn.apache.org/task-groups只放应用的第一个 pod(Spark 场景 = driver);若无「第一个」概念则所有 pod 都带同样内容
.../task-group-name每个 pod 都要,声明自己属于哪个组
.../schedulingPolicyParameters与 task-groups 同一个 pod。空格分隔的 k=v
没有集群级开关:官方原话 "There is no cluster-wide configuration needed to enable Gang Scheduling." 调度器看到有效的 taskGroups 就走 gang 路径。

怎么划分 task group

判据(官方):「同资源规格 + 同放置约束」为一组—— 不是按角色分组。如果 executor 分大小两档,那就是两个 task group。

框架分组minMember
Sparkdriver + executor1 + 最小 executor 数
FlinkJobManager + TaskManager1 + 最小并行度
Rayhead + worker1 + 最小 worker 数
MPIlauncher + worker1 + 全部(最典型的 all-or-nothing)
Ch.2 · 它怎么工作 — Gang 机制21

⏱ 本页 1.9 分钟 · 主线 401 字 · 深潜层另有 1576 字

这一页把 Gang 的机制讲清就够了。我先给一句总结,它是后面第三章讲 Karpenter 成本时的地基: placeholder 是真实的 Kubernetes pod,占的是真实的资源。 (重一点)所以 gang 不是「调度器在内部记个账」 —— 它在你的集群里是看得见的、会被 kubelet 真正启动的、在云上是会计费的。

这一点等第三章讲弹性扩容的时候会变得非常重要。

左上这条流水线四个格子,我一个一个说。 第一格,PREPARE,创建 placeholder。调度器按你每个 taskGroup 里写的 minMember, 创建等量的 pause pod,而且这些 pod 的资源精确等于你写的 minResource —— 注意「精确等于」这四个字,它一会儿会变成一个很容易踩的坑。

第二格,RESERVE,占位。placeholder 是真实的 K8s pod,里面只跑一个 pause 命令,什么事都不干,被 kubelet 真正启动, 唯一的作用是占住节点上的那个坑。 第三格,SWAP,换手。一旦凑齐 minMember, core 就发一个 RunApplication,真实 pod 换进 placeholder 占好的位置。 第四格,TIMEOUT,凑不齐。这里分两条路: Hard 就是整个应用失败;Soft —— 也就是默认值 —— 退化成普通的逐 pod 调度。 (停一下)第四格我不在这一页展开,因为它值得单独一页,就是下下页。

左下那个框我建议念一下官方原话,因为它有一个很实际的含义: "There is no cluster-wide configuration needed to enable Gang Scheduling." 调度器是主动去看每个应用的元数据的,看到有效的 taskGroups 就走 gang 路径。 (这句要说出它的价值)这意味着你不需要为了试一下 gang 而去改集群配置 —— 给一个作业加注解就行。所以灰度非常容易:一个作业一个作业地加,不合适就把注解去掉。

(指着左边那张「三个注解」的表)

三个注解,缺一不可,而且它们放的位置不一样,这是最容易配错的地方。

第一个,yunikorn.apache.org/task-groups,值是一个 JSON 数组, 只放在应用的第一个 pod 上 —— Spark 场景就是 driver。 官方对这一条有个补充,我照念:如果你的应用没有「第一个 pod」这个概念, 那就所有 pod 都要带同样的内容。 第二个,task-group-name,每个 pod 都要有,声明自己属于哪个组。 第三个,schedulingPolicyParameters,与 task-groups 放在同一个 pod 上, 格式是空格分隔的 k=v —— 不是 JSON,不是逗号分隔。

右边这张卡是这一页我最想让你们带走的一条,因为它是个高频错误。 (指着判据那句)官方划分 task group 的判据是 「同资源规格 + 同放置约束」为一组, 不是按角色分组。 常见的错法是按 driver、executor 这种角色思维去分; 但如果你的 executor 有大小两档 —— 比如 shuffle 阶段用大内存机型 —— 那就必须拆成两个 task group。

否则会发生什么?placeholder 是按 minResource 占坑的,真实 pod 是按 requests 要资源的,规格不匹配,换手就装不进去,作业卡住。 (顺带说一句,这是 Spark 上的经典翻车点)还有一个相关的: Spark 一定要把 memoryOverhead 算进 minResource.memory, 官方文档专门提醒过这一条,默认 overhead 是 384 MB 和 executor 内存的 10% 里取大的那个。

下面那张四行的小表快速过,但每一行都要念到 minMember 该填什么。 Spark:driver 加 executor 两组,minMember 是 1 加上你要的最小 executor 数。 Flink:JobManager 加 TaskManager,1 加上最小并行度所需。 Ray:head 加 worker,1 加上最小 worker 数。 (MPI 这一行值得单独说) MPI:launcher 加 worker,而 worker 那一档是「全部」,不能打折。 为什么?因为 MPI 是 all-or-nothing 的教科书案例 —— 少一个 worker, 整个 MPI_Init 就一直阻塞在那里。所以 MPI 的 minMember 必须等于全部 worker 数。

(这个追问几乎一定会来) 可能被问:「placeholder 会不会被计费?」会。 它是真实 pod,带真实的 request,所以在云上会触发节点扩容、会占住节点。 这正是第三章要讲的成本风险。 (顺带一条冷知识,时间紧可跳)还有一个反直觉的: placeholder 镜像拉不下来,gang 其实照样能成立 —— 因为预留在 placeholder 被 bind 的那一刻就算完成了,不需要容器真的跑起来。 但如果是私有仓库缺 pull secret 导致 placeholder 根本创建不出来,那 gang 就真起不来了 —— 对应的 issue 是 YUNIKORN-1344。

下一页给我们自己实测的完整时序,七行带时间戳的真实观测 —— 而且里面有一个细节,让我们第一次做实验的时候得出了完全错误的结论。

Ch.2 · 它怎么工作 · 图解 · Gang Lifecycle

Placeholder 完整生命周期:占位 → 换手 → 回收 含超时计时器的真实起点

K8skube-apiserverPod 的唯一真相来源shimApplication (shim FSM)影子应用状态机shimPlaceholderManager建删占位 Pod 的服务coreobjects.Application核心应用 + 占位账本originating Pod解析 yunikorn.apache.org/task-groups校验失败 → Event action TaskGroupsError,退化普通调度1AddApplicationRequest(shim 此刻在 Submitted)placeholderAsk = Σ(MinResource×MinMember) · executionTimeoutMilliSeconds2AcceptApplication:Submitted → Accepted3TryReserve:Accepted → Reserving4onReserving() → go func()异步 · 失败不重试即退化5placeholder Podregistry.k8s.io/pause:3.7KubeClient.Create × MinMember(只补差额,幂等)tg-<appID:28>-<taskGroupName:20>-<nonce:10>6经 shim:占位 ask(placeholder=true + taskGroupName)占位 Pod 被 bind ⇒ core addAllocationInternal 记账7initPlaceholderTimer()首个占位记账才起表8Bound 占位 == MinMember9占位齐 ⇒ RunApplication9core 与 shim 各自独立判定 Running —— 无 RPC调用 / 请求回程(core → shim)异步 · 经 shim 中转自驱状态转换(无 RPC)换手四跳握手 —— 任一跳断掉,占位就挂到超时scheduling cycle:预留 → 占位换手 → 普通分配10PLACEHOLDER_REPLACED(只通知删占位)真实 allocation 此刻不下发11删占位 Pod:ForgetPod + ReleaseAppAllocation12回同一枚举 PLACEHOLDER_REPLACEDcore 才 ReplaceAllocation 并 notifyRMNewAllocation 下发真实 allocation13placeholderTimer首个占位落地才起表超时分叉:先分 Case(IsRunning ‖ IsCompleting) && 占位非零Case 1 成立?Case 1 · 与 style 无关只以 TIMEOUT 释放剩余占位应用继续跑,Hard 也不失败core application.go:410-437是Case 2 · 才分 Soft/HardSoft → ResumeApplicationHard → FailApplicationcore application.go:438-491否占位被取消也报 TIMEOUT真实 pod 任一资源维度 > 占位⇒ 取消该占位,type=TIMEOUT不是 PLACEHOLDER_REPLACEDHard ≠ 超时必失败两支共用 clearPlaceholderTimer()placeholderTimeoutInSeconds ×1000 =executionTimeoutMilliSeconds默认 defaultPlaceholderTimeout = 15 minK8s Event:gang 相关 reason 恒为 GangScheduling(action 共 8 项,含 TaskGroupMatch);ApplicationFailed 的 reason=action=ApplicationFailedtask-groups 内 name / minMember / minResource 是文档约定 key(无 json tag,解析大小写不敏感);Go 字段为 Name / MinMember / MinResourcev1.9.0 · core 257fdef7 · k8shim 1a59488dPod 的唯一真相来源:真实 Pod 与 placeholder Pod 都在这里创建/删除12 状态 / 13 事件:New Submitted Accepted Reserving Running Rejected Completing Completed Killing Killed Failing Failed Resuming Expired(k8shim/pkg/cache/application_state.go)k8shim/pkg/cache/placeholder_manager.go:createAppPlaceholders 按 taskGroup 只补差额(幂等,支持恢复)core/pkg/scheduler/objects/application.go:84 type Application struct;占位账本字段 :105-119(placeholderAsk / allocatedPlaceholder / hasPlaceholderAlloc / placeholderData)带 yunikorn.apache.org/task-groups 注解的真实 Pod(originator);另有 app-id / queue / task-group-name / internal.yunikorn.apache.org/placeholder 等 keyGetTaskGroupsFromAnnotation(pod)(k8shim/pkg/cache/utils.go:31),调用点 metadata.go:111/118;DisableGangScheduling=false 才走。注意 name/minMember/minResource 只是文档约定 key —— TaskGroup struct(amprotocol.go:47-57)无任何 json tag,Go 字段为 Name/MinMember/MinResource,解析大小写不敏感handleSubmitApplicationEvent()(k8shim/pkg/cache/application.go:425-455),placeholderAsk 见 :174;还带 gangSchedulingStyle(Soft / Hard),executionTimeoutMilliSeconds = placeholderTimeoutInSeconds × 1000W2 补:Step2 与 TryReserve 之间必经此跳。FSM 边 k8shim/pkg/cache/application_state.go:373-376postAppAccepted()(k8shim/pkg/cache/application.go:482-502);skipReservationStage()(:457)为真则直接 RunApplication,不建占位W3:enter_Reserving 回调(application_state.go:462-464)在 goroutine 里调 createAppPlaceholders(application.go:528-542)。建占位不阻塞 FSM,且失败不重试 —— cleanUp + NewRunApplicationEvent + Event action PlaceholderCreateFailed,整个 gang 退化为普通调度Container Name=pause · ImagePullPolicy=PullIfNotPresent · RestartPolicy=Never · Requests==Limits=MinResource(Guaranteed QoS)· terminationGracePeriodSeconds: 0(placeholder.go:154)· 镜像值 k8shim/pkg/common/constants/constants.go:76,使用点 placeholder.go:131(service.placeholderImage 可覆盖)真正发起 K8s 调用的是 placeholder_manager.go:90 KubeClient.Create(placeholder.pod)(:86 是 MinMember 循环);名字来自 GeneratePlaceholderName,letterBytes = "abcdefghijklmnopqrstuvwxyz0123456789",3+28+1+20+1+10=63 恰好 K8s 名字上限占位 pod 走普通 ask,ask 带 Placeholder=true + TaskGroupName(si_helper.go:81-82);灰虚线表示中间经 shim 中转,不是 apiserver 直连 corecore/pkg/scheduler/objects/application.go:1796 —— resources.IsZero(allocatedPlaceholder) 时置 hasPlaceholderAlloc=true 并调 initPlaceholderTimer()。全仓唯一非测试调用点,三个 no-op 守卫在 :382(须 app 正好在 Accepted 态、execTimeout>0)⇒ 一个占位都起不来的应用,placeholderTimeoutInSeconds 永不触发W1 shim 侧自驱:onReservationStateChange()(k8shim/pkg/cache/application.go:547-583)数每个 taskGroup 的 Bound 态占位 task,全部 MinMember 归零 → NewRunApplicationEvent → FSM 边 Reserving→Running(application_state.go:398-402)W1 core 侧自驱:resources.Equals(allocatedPlaceholder, placeholderAsk) 成立即 HandleApplicationEvent(RunApplication)(core application.go:1804-1805)→ FSM 边 Accepted→Running(core application_state.go:105-107)shim 的 response.Updated switch(scheduler_callback.go:153-165)只有 Completed / Resuming / Failing+Failed 三个 case —— core 进 Running 从不通知 shimW4:core/pkg/scheduler/context.go:135-142 顺序为 tryReservedAllocate(135) → tryPlaceholderAllocate(138) → tryAllocate(141),占位换手是第二位不是第一位;partition 层短路门 if pc.getPhAllocationCount() == 0 { return nil }(partition.go:855-856);匹配成功得 ResultType=Replaced(application.go:1209)。换手不保证同节点(application.go:1305 起遍历 node iterator)core/pkg/scheduler/context.go:148 —— result.ResultType == objects.Replaced 时只发 notifyRMAllocationReleased(…, si.TerminationType_PLACEHOLDER_REPLACED, "replacing allocationKey: "+key)scheduler_callback.go:107-113 遍历 response.Released → ForgetPod + 非 STOPPED_BY_RM 就 dispatch ReleaseAppAllocation;handleReleaseAppAllocationEvent 记 terminationType 后删占位 Pod(k8shim/pkg/cache/application.go:652)占位 task 进 Completed → beforeTaskCompleted → releaseAllocation → CreateReleaseRequestForTask 用同一个枚举回传(si_helper.go:150-168,双向复用);core processAllocationRelease 命中后 swap(core/pkg/scheduler/partition.go:1460;同节点/跨节点两支见 :1539-1545)execTimeout 到期后调 timeoutPlaceholderProcessing()(core/pkg/scheduler/objects/application.go:407-493);defaultPlaceholderTimeout = 15 * time.Minute;事件记录统一用 proto 名 REQUEST_TIMEOUT(102) / APP_RESUMING(211) / ALLOC_REPLACED(503)W6:timeoutPlaceholderProcessing() 是 if/else 而不是 Soft/Hard 二分。Case 1 条件 (IsRunning() || IsCompleting()) && !resources.IsZero(allocatedPlaceholder)(application.go:410-437)Case 2(application.go:438-491)::441 event := ResumeApplication,:442-443 gangSchedulingStyle=Hard 时改为 FailApplication;两支共用 clearPlaceholderTimer()(:492)W5:core application.go:1240-1256 —— delta.HasNegativeValue() ⇒ ph.SetReleased(true) + notifyRMAllocationReleased(…, si.TerminationType_TIMEOUT, "cancel placeholder: resource incompatible")。排障时最易误读为「超时了」
一句话:超时计时器从「第一个占位真正被核心记账」起算 ⇒ 一个占位都起不来的应用永远不会超时。
Ch.2 · 图解 — Gang Lifecycle22

⏱ 本页 2.0 分钟 · 主线 413 字 · 深潜层另有 956 字

这是时序图,从左到右是三个仓,从上到下是时间。 左边 Kubernetes —— 真实 Pod、kube-apiserver、placeholder Pod; 中间 yunikorn-k8shim —— 影子状态机与 PlaceholderManager; 右边 yunikorn-core —— 调度主循环和本页主角 placeholderTimer。 时间轴四段:提交 → 占位 → 换手 → 超时回收。红色是失败与回收路径。

第一段,提交。shim 解析 yunikorn.apache.org/task-groups, 四项校验任一失败就发 K8s Event、gang 退化成普通调度。 PlaceholderCreateFailed 这类名字 是 Event 的 action,reason 恒等于 GangScheduling。 然后提交 placeholderAsk = 每个 task group 的 MinResource 乘 MinMember 之和。

第二段,占位。进 Reserving 触发 onReserving(), 它在 goroutine 里调 createAppPlaceholders —— 异步、失败不重试,直接退化成普通调度;创建幂等只补差额。 占位 Pod:镜像 registry.k8s.io/pause:3.7, requests 等于 limits 等于 MinResource,以及 terminationGracePeriodSeconds: 0。 名字模板 tg- 加 appID、task group 名、随机后缀,恰好 63 字符 —— K8s 上限。

(这段是整页最该带走的,放慢照念) 计时器什么时候起表?在 addAllocationInternal 里, 第一个占位真正被核心记账那一刻,才调 initPlaceholderTimer —— 这是全仓唯一一个调用点。 推论要说出来:一个占位都起不来的应用,它的 placeholderTimeoutInSeconds 永远不触发,会无限期停在 Accepted。

(强调拼写)参数名中间有个 In,Seconds 复数。默认 15 分钟。

凑齐进 Running 是两条互不相干的自环:core 判 allocatedPlaceholder 等于 placeholderAsk,shim 自己数占位 task,两边没有 RPC。

第三段,换手 —— 它不是「一次替换」,是四跳握手。

第一跳 core 判定 Replaced,只发 PLACEHOLDER_REPLACED 让 shim 删占位 —— 真实 allocation 此刻还不下发;第二跳 shim 删掉占位 Pod; 第三跳 shim 用同一个枚举回传确认;第四跳 core 才 swap 并下发真实 allocation。 任一跳断掉,占位就挂到超时。 主循环顺序是预留 → 换手 → 普通分配,换手是第二位。

红色失败边:真实 pod 任一资源维度大于占位,这个占位就被取消, 而日志里的 termination type 是 TIMEOUT,不是 PLACEHOLDER_REPLACED。 (照念)明明是资源不兼容却像超时,最容易误判。

最后一段,超时回收,先看菱形判据。

Case 1:应用已在 Running 或 Completing、手里还握着占位 —— 这一支与 gangSchedulingStyle 无关,只以 TIMEOUT 释放剩余占位、应用继续跑。Case 2 才分叉:Soft 发 ResumeApplication,Hard 走 FailApplication。

(纠正)「Hard 等于超时必失败」不准确。下一页看状态机。

Ch.2 · 它怎么工作 · Measured

✅ 实测:placeholder → 真实 pod 的完整时序 0.5 秒间隔紧密轮询 · 本地 kind 集群

时刻Δ(T0)观测到什么
19:32:00.15T0kubectl apply 发出(minMember=4 × 500m = 2000m,队列 max 4000m 空闲)
19:32:00.52+0.37s4 个真实 pod 创建完毕,全部 Pending
19:32:02.68+2.53s🔵 4 个 placeholder 出现(tg-gang-fit-app-worker-group-*),全部 Pending
19:32:04.04+3.89s第 1 个 placeholder 变 Running
19:32:04.74+4.59s🔴 4 个 placeholder 全部消失,第 1 个真实 pod Running(swap 完成)
19:32:05.44+5.29s2 个真实 pod Running
19:32:06.15+6.00s✅ 4 个真实 pod 全部 Running
6.0 s
提交 → 全部 Running
2.1 s
placeholder 存活时长
~0.15 s
swap 耗时
🔴 一个必须知道的观测陷阱:placeholder 只活 2.1 秒。 我们第一次用 8 秒间隔看 kubectl get pods,完全没看到 placeholder,一度误判为「没有创建 placeholder」。 ⇒ 要看到它,必须用 kubectl get pods -w 或亚秒轮询,或者故意让 gang 装不下。 ⇒ swap 能这么快的原因是 placeholder 的 terminationGracePeriodSeconds: 0——删除时不等优雅退出。
Ch.2 · 它怎么工作 — 实测 swap 时序23

⏱ 本页 1.7 分钟 · 主线 366 字 · 深潜层另有 1144 字

这一页的价值在于它把一个抽象机制变成了七行带时间戳的真实观测。 我先交代口径:这是我们自己在本地 kind 集群上跑出来的,用 0.5 秒间隔紧密轮询采到的, 命令和原始输出都在配套材料里。不是文档上抄的,也不是厂商给的。 核心一句:整个 gang 从提交到全部跑起来只用 6 秒,而 placeholder 只存在 2.1 秒。

(指着表格,从上往下一行一行走) T0,19 点 32 分 00.15 秒,kubectl apply 发出。 这次实验的设置是 minMember=4、每个 500m,一共 2000m, 提到一个 max 是 4000m、而且当时空闲的队列上 —— 也就是说资源是够的, 这一页测的是「顺利情况下要多久」。

加 0.37 秒:4 个真实 pod 创建完毕,全部 Pending。 注意这一步 —— 真实 pod 先出现,placeholder 还没影。 加 2.53 秒:4 个 placeholder 出现了,名字是 tg-gang-fit-app-worker-group- 后面跟一串随机字符, (这个前缀值得记)所有 placeholder 都是 tg- 开头, 所以 kubectl get pods -A | grep '^tg-' 是最快的排查手段。 这时候它们也全是 Pending。

加 3.89 秒:第 1 个 placeholder 变成 Running —— 它被真正地启动了, 这就是我上一页强调「它是真实 pod」的实证。 加 4.59 秒,这是最关键的一行:4 个 placeholder 全部消失, 同时第 1 个真实 pod 变成 Running —— swap 完成。 加 5.29 秒:2 个真实 pod 在跑。 加 6.00 秒,最后一行:4 个真实 pod 全部 Running。

(指着下面三个大数字,这三个数是可以直接引用的) 第一个,6.0 秒,提交到全部 Running 的端到端时间。 第二个,2.1 秒,placeholder 的存活时长 —— 从 加 2.53 秒出现, 到 加 4.59 秒消失,也就是墙上时间 19:32:02.68 到 19:32:04.74。 (这两个口径别混着念 —— 表格第二列是相对 T0 的增量,第一列才是墙上时间) 第三个,大约 0.15 秒,swap 本身的耗时。 (这三个数字都要说清是这套设置下的,不要说成通用值) 这是 4 个 pod、每个 500m、资源充足的小实验的数字; 你们自己的作业规模不同,绝对值会变,但数量级是这个数量级。

下面那个红框是这一页最实用的一条,而且我建议当场承认我们踩过。 (照念这句,效果最好) placeholder 只活 2.1 秒。我们第一次是用 8 秒间隔去看 kubectl get pods 的, 结果完全没看到 placeholder,一度误判成「YuniKorn 根本没创建 placeholder」。 (停一下) 这个坑的恶劣之处和第一章那个 A/B 测试一样:它不报错,而且给你一个看起来像结论的结果。

所以如果你们要自己验证,或者要给别人演示,有两条路。 第一条,用 kubectl get pods -w 或者亚秒级轮询。 第二条更聪明,也是我推荐的:故意让 gang 装不下 —— 先用别的负载把队列容量占掉大部分,只留下不足以凑齐一个 gang 的余量。 这样一部分 placeholder 落地、一部分卡住,placeholder 会长期停在那里,你随便看。 (如果现场有条件,这一页最好配一段真的 -w 录屏 —— 七行时间戳不如三秒的画面)

框里最后那一句解释了 swap 为什么能这么快: placeholder 上设了 terminationGracePeriodSeconds: 0, 删它的时候不等优雅退出。 (这是个设计上的巧思,值得点出来) placeholder 里跑的是 pause,没有任何需要优雅退出的东西,所以设 0 是安全的。 反过来想:如果它带默认的 30 秒宽限期,每一次 swap 都要等 30 秒, gang 的开销就完全不可接受了。

(这个追问很常见) 可能被问:「6 秒里有 2.5 秒花在创建 placeholder 上,这个开销大不大?」 我的回答是:相对于 Spark 作业动辄几分钟到几小时,2.5 秒可以忽略; 但如果你的作业本身只跑 10 秒,那这个开销占比就很高了。 一句话:gang 适合「大而慢」的作业,不适合「小而快」的。

下一页看凑不齐的时候会怎样 —— 那才是选型时你真正要做决定的地方, 而且默认值在那里是错的。

Ch.2 · 它怎么工作 · 图解 · State Machine

Application 状态机:两套 FSM,core 10 态 / k8shim 12 态 6 事件 18 条边 · 唯一终态是 Expired

expireApplication · 72h(terminatedTimeout)rejectApplication声明·不可达resumeApplicationrunApplicationcompleteApplicationrunApplication(自环)runApplication(复活)failApplicationexpireApplication · 72hNew唯一初态Accepted等首个分配Running运行中Completing收尾 30sCompleted正常结束Expired唯一终态Rejected准入被拒Resuminggang 软超时Failing失败中Failed已失败runApplicationrunApplicationcompleteApplicationcompleteApplication30s 或分配清零expireApplication72hfailApplicationREST 上的 :state 不是 FSM 状态名路径段只接受 active / rejected / completedFSM 状态走 ?status=running —— 必须全小写,否则 400进入 Expired ≠ 对象被删还需 cleanupExpiredApps(≤24h)从三张 map 摘除v1.9.0 core 侧恰好 10 态 / 6 事件(事件名小驼峰)/ 18 条声明边 —— 本图全部画出;虚线 New → Resuming 声明存在,实践大概不可达core 没有 Reserving(那属 k8shim 独立的 12 态 FSM),也没有 Starting(si.proto reserved 205 / reserved "APP_STARTING" 已除名)唯一初态。10 这个数字有四处互相独立的证据:applicationState iota 常量块(application_state.go:64-75)、String() 数组字面量(:90)、stateEvents map(:77-88)、Application 上的 Is<State>() 方法(application.go:219…255) —— 全部 = 10。已准入,等第一个分配落地。声明:runApplication 的 Dst=Accepted(application_state.go:100-103,Src = New / Resuming)。enter_Accepted 做 IncQueueApplicationsAccepted / DecQueueApplicationsNew。两个触发点:普通分配落地(application.go:1819,addAllocationInternal 非 placeholder 分支);gang 场景占位全部凑齐 —— resources.Equals(sa.allocatedPlaceholder, sa.placeholderAsk)。声明 :104-107。资源计数器归零后的收尾态(RemoveAllocationAsk 里 resources.IsZero(sa.pending) && resources.IsZero(sa.allocatedResource) && !sa.IsFailing() && !sa.IsCompleting())。completingTimeout = 30s 生产不可配:唯一 setter SetCompletingTimeout 的注释逐字为 // SetCompletingTimeout should be used for testing only.(application.go:2260-2263)。正常结束,但不是终态:enter_Completed(application_state.go:252)setStateTimer(terminatedTimeout = 3*24h, …, ExpireApplication)(application.go:54)⇒ 72h 后进 Expired。唯一终态:全仓 grep Expired.String() 确认它只作 Dst 出现。它没有任何 enter_/leave_ 专属回调;真正把对象摘除的是 partition.go:1131-1148 的 cleanupExpiredApps,从 applications / rejectedApplications / completedApplications 三张 map 删,轮询间隔 DefaultCleanExpiredAppsInterval = 24h(partition_manager.go:32,goroutine :66,循环 :171-183) ⇒ 实际可见期 72h~96h。唯一入口 Application.RejectApplication(rejectedMessage)(application.go:2061-2066,走 HandleApplicationEventWithInfo),实际调用点只有 PartitionContext.AddRejectedApplication。它是唯一不向 shim 发 RMApplicationUpdateEvent 的目标状态(判断在 application.go:286,注释逐字:The only state that does not generate an event is Rejected),但仍经 stateEvents 发 APP_REJECT 进事件流 —— 两个通道别混。唯一触发源是 gang placeholder 超时的软分叉:application.go:441 event := ResumeApplication,紧接 :442-445 if sa.gangSchedulingStyle == Hard { event = FailApplication } + "ResourceReservationTimeout"。默认 defaultPlaceholderTimeout = 15 * time.Minute(application.go:55,包级 var 块,生产不改),可用 K8s annotation 覆盖:placeholderTimeoutInSeconds / gangSchedulingStyle(k8shim constants.go:89 / :91)。注意 core 侧事件叫 resumeApplication,ResumingApplication 是 k8shim 的事件名。三个触发点:gang placeholder 超时且 gangSchedulingStyle == Hard(application.go:442-445,信息串 "ResourceReservationTimeout");partition 被移除时 partitionManager 对任意状态的 app 调 FailApplication("PartitionRemoved")(partition_manager.go:153);以及 shim 侧上报失败。声明 application_state.go:116-119,Src = New / Accepted / Running。Failing → Failed 是单独一条声明(Src 仅 Failing,:120-123)。触发点 application.go:1960-1962:removeAllocationInternal 清完占位后 if sa.IsFailing() { event = FailApplication }。enter_Failed(:257)再 setStateTimer(terminatedTimeout) ⇒ 72h 后进 Expired。handlers.go:66-68 定义 AppStateActive/AppStateRejected/AppStateCompleted(全小写 active/rejected/completed);真正的 FSM 状态走 query 参数 ?status=,且仅在 :state == "active" 时生效(:791-804),比较前双侧都 strings.ToLower ⇒ ?status=Running 会 400。可查的 active 状态只有 6 个(New/Accepted/Running/Completing/Failing/Resuming,:82-88);另外 4 个(Rejected/Completed/Failed/Expired)走 GetRejectedApplications() / GetCompletedApplications() 两张独立 map。Running 自环声明在 application_state.go:105-107(Dst=Running 的 Src 列表含 Running)。同态转移 looplab/fsm 返回 "no transition",被 HandleApplicationEvent 按成功吞掉(application.go:264,官方测试 application_state_test.go:89 钉住);enter_Running 整体被 if event.Src != Running.String() 包住(:201)、leave_Running 被 if event.Dst != Running.String() 包住(:210)⇒ 无论回调是否触发,自环都不改 startTime、不动 metrics。非法事件(如 Running 收到 rejectApplication)返回 InvalidEventError,不被 noTransition 吞掉,会打日志(:92-95)。Accepted --completeApplication--> Completing:声明 application_state.go:108-111 的 Src 第 1 个元素。真实可达 —— application.go:619-620,RemoveAllocationAsk 里 pending/allocated 双零、非 Failing/Completing、无 placeholder 时 Accepted 直接进 Completing ⇒ 收尾不必先经 Running。Completing --runApplication--> Running:图上最反直觉的一条边,同一条 fsm.Events(Dst=Running,:104-107)的 Src 含 Completing(Src 列表在 :106)。触发点 application.go:661,注释逐字:2) all asks and allocation have been removed: state is Completing / Move back to Running。Completing --completeApplication--> Completed(:112-115)不只靠定时器:enter_Completing(application_state.go:239)调 setStateTimer(completingTimeout = 30s, …, CompleteApplication);还有三条同步路径立即触发 —— application.go:1957-1959(placeholder 分支,IsCompleting && stateTimer == nil)、:1982-1984(hasZeroAllocations)、:2049(RemoveAllAllocations)。expireApplication 声明在 application_state.go:128-131,Src = {Completed, Failed, Rejected},Dst = Expired —— 三个「看起来像终态」的状态全部经此边汇入。全部由定时器触发:enter_Rejected(:192)、enter_Completed(:252)、enter_Failed(:261)各自 setStateTimer(terminatedTimeout = 72h)。New --resumeApplication--> Resuming:声明确实存在(:124-127,Src = New / Accepted),但唯一触发源是 placeholder 超时(application.go:441),有 placeholder 时 app 早已离开 New ⇒ 实践中大概不可达,故画虚线。
这张图的一句话:core 侧恰好 10 态、6 事件、18 条边,唯一终态是 Expired —— Rejected/Completed/Failed 都只是「72 小时待清理」。🔴 Reserving 不在 core,它属于 k8shim 那套独立的 12 态 FSM;Starting 则已被删除。
Ch.2 · 图解 — State Machine24

⏱ 本页 2.5 分钟 · 主线 521 字 · 深潜层另有 847 字

看图:中间横排是主干 —— New、Accepted、 Running、Completing、Completed、Expired; 上排是 Rejected 和 Resuming,下排是失败链。 最右边 Expired 上那个脉动的光环是本页焦点:全图唯一终态。 颜色按事件分:主色 runApplication、青色 completeApplication、 红色 failApplication、灰色 expireApplication。

数字念清楚:10 个状态、6 个事件、18 条声明边,本图 18 条全画出来了。

10 这个数有四处互相独立的证据:状态常量块、String() 数组、 stateEvents map、Is 系列断言 —— 全是 10。

(最值钱的纠正,照念) 网上很多资料说 Application 状态机里有 Reserving。core 里没有。 因为 v1.9.0 有两套完全独立的 FSM:core 这套 10 态,k8shim 那套12 态、13 事件, 有 Reserving,但没有 Completing、没有 Expired。

说 core 有 Reserving 的,都是把 shim 的图挂在了 core 标题下。 Starting 则是被删掉并在 proto 里显式封存 —— reserved 205 加 reserved "APP_STARTING"。

(指着箭头上的字)箭头上的事件名是小驼峰 runApplication, 日志打出来就是这个。三个长得像的别混:Resuming 是状态, resumeApplication 是 core 的事件, ResumingApplication 是 k8shim 的。

主干挑重点。Running 那个小自环声明里真有, 但同状态转移在 FSM 里返回「no transition」,被上层按成功吞掉, 进出回调又被守卫包住 —— 自环不动任何计数器。 Completing 那条青线写着「30s 或分配清零」:那 30 秒生产里改不了, 唯一的 setter 注释写着 testing only;但它也不只靠定时器。

两条反直觉的边,听众会记住。第一条,从 Completing 拐回 Running 的复活边 —— 收尾中的应用来了新 ask,会被拉回运行态。 第二条,从 Accepted 绕过 Running 直到 Completing 的上弓形边: 双零又没 placeholder 时,收尾不必先经过 Running。 下排 failApplication 是三入一:New、Accepted、Running 都能直接掉进 Failing。从 New 到 Resuming 那条虚线标「声明·不可达」—— 虚线就是「声明存在但实践走不到」。

唯一终态这件事有运维含义。(指顶上那条长边) Rejected、Completed、Failed 这三个像终点的, 全部经 expireApplication 汇进 Expired,都是 72 小时定时器。

而进入 Expired 不等于对象被删 —— 还要等 cleanupExpiredApps 摘除, 轮询间隔 24 小时,实际可见 72 到 96 小时。

右上角那个小框,是另一个二手资料几乎全写错的口径: REST 路径上的 :state 不是 FSM 状态名,只接受 active、rejected、completed;FSM 状态走 ?status= 且全小写,写 ?status=Running 直接 400。

带走两句:唯一终态是 Expired,其余三个只是「72 小时待清理」; 而你看到的 Reserving 来自另一套 FSM。下一页看 Allocation。

Ch.2 · 它怎么工作 · 图解 · Allocation

Allocation 对象:AllocationAsk 在 v1.9.0 已不存在 三个 bool 表达全部状态

yunikorn-core · objects.Allocation 无 FSM,状态由 3 个 bool 派生yunikorn-k8shim · Task / App 都是 looplab/fsmAllocation 的派生状态(bool 组合,非 FSM)askAge > 2stryReservedAllocateunReserve(多触发点)tryAllocate 直接分配(不经预留)bool 翻转notifyRMNewAllocation恢复:跳过 AllocatedBind 成功KubeClient.BindUpdateReservationplaceholder is boundBound 数 == MinMember只数 Task Bound,不看 podUpdateAllocation(gRPC)Allocationallocated=false待调度请求(俗称 ask)1reservationnode+app 双 map 写入被预留节点移出迭代器2Allocationallocated=true已定 nodeID 与 bindTime3Task: Allocatedshim 收到分配,正在绑postTaskAllocated 起 goroutine4Task: BoundBind API 已返回成功PodBindSuccessful5App: Reserving只调度 placeholderonReservationStateChange 计数6App: Running只调度真实 pod放行真身进 core7released=true占位已交出,等 shim 确认preempted=true与 released 互斥(各返回 error)placeholderUsed=true真身已替换掉占位AddAllocationAskpod event(k8shim)Reason 统一 = GangSchedulingAction = CreatingPlaceholders / PlaceholderAllocated /GangReservationComplete / GangSchedulingFailed / PlaceholderCreateFailed⚠ gang「就位」判据 = 全部 placeholder 的 Task 到达 Bound(KubeClient.Bind 返回成功),从不读 pod.Status.Phase⇒ bind 成功但容器起不来(镜像拉不动 / CSI attach 卡住)时,YuniKorn 依然认为 gang 就位并放行真实 podv1.9.0 无独立的 AllocationAsk 调度对象、也无 AllocationAsk protobuf message(已并入 objects.Allocation;si.proto:271 留有 reserved "allocationAsksToRelease");但 REST DAO 仍有 AllocationAskDAOInfounReserve 多触发点:wait-timeout(60min) / requiredNode 让位 / ask 删除 / 抢占取消 / AllocatedReserved 顺清 · reservationDelay=2s 不可配,但可用环境变量 DISABLE_RESERVATION 整体关闭objects.Allocation(allocation.go:39)。v1.9.0 无独立的 AllocationAsk 调度对象,也无 AllocationAsk protobuf message;ask 只是同一对象的一个阶段。AddAllocationAsk(application.go:637)校验 !IsAllocated() 后插入 sa.requests 与 sa.sortedRequests;唯一调用点 partition.go:1223reservation.go:29 包私有对象、从不 mutate、不用锁;不扣资源。tryNodes(application.go:1600)在 askAge > reservationDelay(2s) 且无节点可放时,按 GetFitInScoreForAvailableResource 选最优候选,过 preReserveConditions 后返回 newReservedAllocationResult(:1638)。双写顺序 node 先(node.go:571→:615,发 si.EventRecord_NODE_RESERVATION)再 app(application.go:895→:898)。被预留节点从默认迭代器消失:acceptUnreserved(node_collection.go:32-34)+ GetNodeIterator 返回 unreservedIterator(:167-168)。Reserved 结果在 partition.go:918 直接 return nil —— 预留状态从不告知 shimtryReservedAllocate(application.go:1402)每个调度轮次第一个跑(context.go:135 顺序 tryReservedAllocate → tryPlaceholderAllocate → tryAllocate)。AllocatedReserved 分支里 pc.unReserve(partition.go:936)严格早于 SetBindTime(time.Now())(:949)与 SetNodeID(:950)⇒ bindTime 是 core 侧时间戳,此刻 shim 还没调 Bind,用它算 bind 延迟不含 apiserver 往返task.go:348 postTaskAllocated 在独立 goroutine 里:bindPodVolumes(:363,失败发 PodVolumesBindFailure :366)→ KubeClient.Bind(task.pod, task.nodeName)(:373,失败发 PodBindFailure :375)→ 仅成功才 NewBound。恢复路径:scheduler_callback.go:84-86 若 IsAssignedPod 则 MarkPreviouslyAllocated → task.go:266 直接 SetState(Bound),跳过本状态postTaskBound(task.go:411)仅当 task.placeholder 时 dispatch NewUpdateApplicationReservationEvent(:417)→ App FSM UpdateReservation: Reserving→Reserving(application_state.go:384-386)。k8shim Task 共 10 态:New Pending Scheduling Allocated Rejected Bound Killing Killed Failed Completed(task_state.go:274-287)onReservationStateChange(application.go:547)用 desireCounts[tg.Name]=tg.MinMember(:554)逐个扣减 for _, t := range app.getTasks(TaskStates().Bound)(:557)—— 数的是 Bound,不是 pod Running;差一个就 return。IsPodRunning 在整个 gang 路径零引用。k8shim App 共 12 态:New Submitted Accepted Reserving Running Rejected Completed Killing Killed Failing Failed Resuming(无 Completing)Reserving→Running 后真实 pod 才被提交调度。core 侧 tryPlaceholderAllocate(application.go:1278)做占位换真身:双向指针 request.SetRelease(ph)(:1274)+ ph.SetRelease(request)(:1276)→ ph.SetReleased(true)(:1278,若已 preempted 则整段回滚 :1281-1296)→ 自行 SetBindTime/SetNodeID(:1298-1300)→ newReplacedAllocationResult;释放走 notifyRMAllocationReleased + si.TerminationType_PLACEHOLDER_REPLACED(context.go:148)allocation.go:72 / SetReleased() :298;由 tryPlaceholderAllocate (application.go:1278)在占位换真身时写入allocation.go:74 / MarkPreempted() :358。SetReleased 见 preempted 报错、MarkPreempted 见 released 报错,代码层强制互斥allocation.go:70。Replaced 结果里真实 Allocation 自行 SetBindTime/SetNodeID(application.go:1298-1300)yunikorn-k8shim/pkg/cache/application.go:557 数的是 TaskStates().Bound;IsPodRunning 唯一使用点 external/scheduler_cache.go:331 只是缓存记账
一句话:AllocationAsk 在 v1.9.0 已不存在 —— 只有一个 Allocation,三个 bool 表达状态。
Ch.2 · 图解 — Allocation25

⏱ 本页 2.4 分钟 · 主线 514 字 · 深潜层另有 838 字

先说这张图怎么看。它是一个 U 字形,不是一条直线。 上面那条泳道是 yunikorn-core,下面那条是 yunikorn-k8shim。 从左上角 ① 号往右走三步,到右边掉进下面那条泳道,再从右往左走四步,回到左上角。 为什么是闭环?因为 placeholder 绑上之后,真实 pod 会作为一个新的请求再进 core 一次。 右上角那个虚线小框是旁挂的,不在链路上。

上面泳道的标题就是第一个反直觉点:objects.Allocation 没有状态机, 它只是三个 bool 的组合。图上左右这两个橙色盒子不是两个类型,是同一个对象的两个阶段。

(口径要精确,建议照念)v1.9.0 里没有独立的 AllocationAsk 调度对象, 也没有这个 protobuf message,si.proto 只留了 reserved "allocationAsksToRelease" 作为拆除痕迹。 但别说成「它不存在」 —— REST 的 DAO 里还有 AllocationAskDAOInfo。 凡是画着「AllocationAsk → Allocation」两个盒子的博客,讲的都是 1.4 以前的模型。

core 三步。第一段箭头写 askAge > 2s: 调度器不是一上来就预留节点的,只有请求等过 2 秒、当轮又没节点放得下, 它才挑一个最优节点占位。第二个盒子那句「被预留节点移出迭代器」是机制真身: 预留不扣资源,是把节点从默认迭代器里摘掉。 盒子上方那条橙色回边是 unReserve,脚注列全了触发点; 下方那条灰虚线是「不经预留的直接分配」——橙色是主链路,灰虚线一律是旁路。

右上角旁挂那个小框是三个 bool,只记两条: released 和 preempted 强制互斥,两个 setter 互相返回 error; bindTime 是 core 自己写下的时间戳,那一刻 shim 还没调 Bind —— 用它算 bind 延迟,不含 apiserver 往返。

往下掉那条橙线是 notifyRMNewAllocation, 旁边一条灰虚线「恢复:跳过 Allocated」,是重启后已绑好的 pod 走的支线。 下面泳道从右往左:Task: Allocated 起独立 goroutine 去绑,成功才进 Task: Bound;是 placeholder 的话,它给 App 状态机丢一个 UpdateReservation 让 App: Reserving 重数一次; 数够了才进 App: Running,真实 pod 这时才被放行。

(指那条会动的蚂蚁线 —— 本页唯一动画,也是全页焦点) 它写着 Bound 数 == MinMember,小字是「只数 Task Bound,不看 pod」。 这就是 gang 就位的全部判据:拿 MinMember 当目标扣减,差一个就返回。 而 Bound 只意味着 KubeClient.Bind 返回了成功。 (指红框,放慢)它从不读 pod.Status.Phase, IsPodRunning 在整个 gang 路径零引用 ⇒ bind 成功但容器起不来,YuniKorn 依然认为 gang 就位,照样放行真实 pod。

左下角三行给排障用:pod event 的 Reason 统一是 GangScheduling,区分事情的是 Action,五个值印在图上。 脚注还有一条开关:那 2 秒不可配,但整个预留机制能用环境变量 DISABLE_RESERVATION 整体关掉。

方框悬停有源码位置。下一页把 gang 收到一个能当场改的参数上: 默认是 Soft,而 Soft 会给你「半个 gang」。

Ch.2 · 它怎么工作 · Trap #3 · Hard vs Soft

坑三:默认是 Soft,而 Soft 会给你「半个 gang」 ✅ 实测 A/B:只改一个参数

行为HardSoft(默认)
入队时 gang 需求 > 队列 max立即 ApplicationRejected,不建 placeholder相同(该检查与 style 无关)
超时后应用状态Failed,从队列消失Running
超时后pod状态全部 Failed装得下的 Running,其余 Pending
pod 的 .status.reasonResourceReservationTimeout无(走正常调度)
关键 event(实测原文)ApplicationFailedresuming as non-gang application (SOFT)
语义全有或全无,宁可失败尽力而为,允许部分启动
适合Spark / MPI / 分布式训练——凑不齐就没意义的作业可弹性伸缩、能容忍部分副本的负载
🔴 需要真 gang 的作业必须显式写 gangSchedulingStyle=Hard。 默认值 Soft 对「真 gang」场景是错的默认值——它会产生「2 个 Running + 2 个 Pending」: 占着资源、干不了活、还不报错(应用状态是 Running,监控上一切正常)。
实测时序(Hard):T+48s 仍在等 → T+63s 全部 Failed。 设定 60 秒,吻合。超时后队列立刻归还全部资源。
另一个坑:参数名是 placeholderTimeoutInSeconds(有 In)。 键写错会被静默忽略——零日志、零告警,然后套用默认值 15 分钟。第三章有一个真实受害者。
Ch.2 · 它怎么工作 — 坑三:Hard vs Soft26

⏱ 本页 1.5 分钟 · 主线 310 字 · 深潜层另有 1763 字

(这一页是第二章杀伤力最大的一页,建议放慢,而且建议在座各位当场记下来) 核心一句:默认值是 Soft,而 Soft 对「真 gang」场景是错的默认值 —— 它会给你「半个 gang」。页面上写的那句我念一下:它给你的是 「2 个 Running 加 2 个 Pending」 —— 而半个 gang 是所有结果里最坏的一个:占着资源、干不了活、还不报错。

这张表是我们自己做的 A/B,口径先交代: 同一套设置 —— 队列只剩 1000m 余量、minMember=4 乘 500m、 placeholderTimeoutInSeconds=60 —— 只改一个参数 gangSchedulingStyle,跑两遍。七行行为,一行一行看。

第一行,入队的时候 gang 需求就大于队列 max。 这一行两边是一样的:立即 ApplicationRejected,不建任何 placeholder。 (这一行要说清它为什么重要)这个静态可行性检查与 style 无关 —— 也就是说「需求超过队列上限」这种配错,Hard 和 Soft 都会快速失败, 我们实测是 3 秒内就判完,不会占着资源慢慢超时。这是个好设计。

第二行和第三行是这一页的要害,请一起看。 超时之后应用的状态:Hard 是 Failed,从队列里消失; Soft 是 Running。 超时之后 pod 的状态:Hard 是全部 Failed; Soft 是「装得下的 Running,其余 Pending」。 (停一下,然后把这两行合起来讲透) 把这两行合起来是什么画面?应用状态写着 Running,一半 pod 在跑,一半 pod 在 Pending。 从 Prometheus 上看不出异常,从 kubectl get applications 看是 Running, 从任何监控视角看都「正常」。 但对 MPI 来说,少一个 worker 就是 MPI_Init 一直阻塞; 对 Spark 来说,就是 driver 一直在等 executor。 你会看到一个「运行中」的作业永远不产出结果 —— 而没有任何告警会响。

第四行,pod 的 .status.reason:Hard 是 ResourceReservationTimeout,Soft 没有 —— 因为它走的是正常调度路径。 第五行,关键 event,这是实测原文,我念一下:Hard 是 ApplicationFailed;Soft 是 resuming as non-gang application (SOFT)。 (这一行值得强调)这一行就是 Soft 的全部语义 —— 放弃 gang 保证, 退化成普通的逐 pod 调度。 如果你在事件流里看到这句话,就知道那个作业已经不是 gang 了。

第六行,语义:Hard 是全有或全无,宁可失败;Soft 是尽力而为,允许部分启动。 第七行,各自适合什么:Hard 适合 Spark、MPI、分布式训练 —— 也就是凑不齐就没意义的作业;Soft 适合可弹性伸缩、能容忍部分副本的负载。

(指着表格最下面那一栏,这句建议照念) 所以这一页的落点是:需要真 gang 的作业,必须显式写 gangSchedulingStyle=Hard。 (然后说这句)

而且别指望每个人记得加 —— 这一条要写进你们的作业模板、写进 Helm chart、写进 Airflow 的 operator 默认值。 依赖人的记性,你早晚会在生产上收到一个「跑了三小时没结果」的作业。

左下这个框是 Hard 的实测时序,它证明超时是准的: 我们设 60 秒,T 加 48 秒的时候还在等,T 加 63 秒的时候全部 Failed —— 吻合。而且超时之后队列立刻归还全部资源,不留残留占用。 (这一点可以对客户承诺)

(右下这个框是全场最贵的一行字,我建议逐字念) 参数名是 placeholderTimeoutInSeconds —— 中间有一个 In。 键写错会被完全静默地忽略:零日志、零告警、零事件, 然后套用默认值 15 分钟。

为什么这么隐蔽?因为 placeholderTimeoutSeconds=30 是一个合法的 k=v, 不触发「格式错误」的告警,但在源码的 switch 里匹配不上任何一个 case, 而那个 switch 没有 default 分支 —— 它静静地什么都不做。 (然后说这句,第三章会展开)这个坑有一个真实的受害者, 而且是 AWS 自己的官方文档 —— 第三章我会给你们看具体是哪两处。差 30 倍。

(补一条容易被忽略的边界,时间紧可跳) 还有一件事我必须补上,因为它是真正的运维缺口: 官方文档写得很清楚,超时计时器是在「调度器分配出第一个 placeholder」的时候才开始走的, 原话是 "The timeout timer starts to tick when the scheduler allocates the first placeholder pod"; 接着还有一句 —— "If non of the placeholders can be allocated, this timeout won't kick-in." (注意那个 "non of" 是官方文档的原文,不是我念错了,也别在自己的材料里替他改掉) (说清后果)所以如果一个 placeholder 都落不下来,超时永远不会触发, 应用会无限期停在 Accepted。 这一档 placeholderTimeoutInSeconds 兜不住,你得自己外部监控 「长期停在 Accepted 且 placeholder 分配数为 0」的应用。

(这个追问一定会来) 「那为什么默认是 Soft 而不是 Hard?」 我的理解是「安全默认值」的考虑:Soft 的最坏情况是部分启动,Hard 的最坏情况是作业失败, 对不了解 gang 的用户,前者看起来更温和。 但对真正需要 gang 的用户,这个默认值是反的。

下一页讲抢占。抢占是 YuniKorn 里设计得最严谨、文档写得最好的一部分 —— 但也是「配了没反应」投诉最多的一部分。

Ch.2 · 它怎么工作 · Preemption

抢占:七条定律 设计来自 Apache YARN 的经验 · 锚点是 guaranteed

七条定律(官方原文编号)

  1. 抢占策略是强建议,不是保证(DaemonSet 场景会破例)
  2. 抢占不能把受害队列压到 guaranteed 以下
  3. 任务不能抢占同一应用内的任务(目前只做队列间抢占)
  4. 队列不低于 guaranteed ⇒ 不能触发抢占
  5. 队列不高于 guaranteed ⇒ 不能被抢
  6. 只能抢占优先级更低或相等的任务(K8s 只允许更低)
  7. 不能抢占围栏之外的任务(单向围栏)
目标定调(官方):"Preemption is used to get the usage of a queue to at least its guaranteed resource capacity. … Preemption is not the tool to get a queue to its full maximum."
🔴 定律 4 的直接后果: 如果你不设 guaranteed,抢占基本什么都不会做——因为「队列低于 guaranteed」这个前提永远不成立。 这是「抢占配了没反应」的第一大原因。
🔴 定律 2 的反直觉后果: 队列虽然超了 guaranteed,但如果它上面每个 pod 都很大(杀掉任何一个都会跌破 guaranteed), 那它一个 pod 都不会被抢。⇒ pod 粒度越粗,抢占越难生效。
🔴 定律 3 的配置含义: 同队列内高优抢不了低优。想让高优作业压过低优,必须放在不同队列(用 priority.offset 区分), 不是靠同队列内的 PriorityClass。这是很常见的配置错误。
方向别搞反: preemption.policy: fence = 我不能往外抢; disabled = 我不能被抢。 想保护在线服务,用 disabled,不是 fence。
Ch.2 · 它怎么工作 — 抢占七定律27

⏱ 本页 1.5 分钟 · 主线 317 字 · 深潜层另有 1611 字

先说这一页怎么听。七条定律我不会逐条念 —— 逐条念是最没有信息量的讲法。 我只讲三条:定律 4、定律 2、定律 3。 为什么是这三条?因为它们分别对应三个最常见的实际问题: 「抢占配了没反应」「大 pod 抢不动」「同队列里不生效」。 其余四条你们照着页面看一眼就够。

(先交代来源,这一条对可信度有帮助) 标题下面那句是官方自己说的:这套设计来自 Apache YARN 上实现抢占的经验, 它构成了所谓的「laws of preemption」。 所以这不是新发明的东西,是一个在 YARN 上被验证过十年的模型搬过来。

(指着左边那个引文框,这段建议照念,它是整页的定调) "Preemption is used to get the usage of a queue to at least its guaranteed resource capacity. … Preemption is not the tool to get a queue to its full maximum." 翻成人话就是两句:抢占只帮你的队列回到 guaranteed,不帮你冲到 max; 而且它连「回到 guaranteed」都不保证。 官方举的反例很直白:如果一组队列的 guaranteed 加起来大于集群现有资源, 那数学上就不可能都满足。

(指着右上第一个红框,这是最该讲的一条) 定律 4 说:队列不低于 guaranteed,就不能触发抢占。 它的直接后果是:如果你不设 guaranteed,抢占基本什么都不会做 —— 因为「队列低于 guaranteed」这个前提永远不成立。 (这句要说重)这是「抢占配了没反应」的第一大原因。

我见过的典型现场是:客户配了 preemption.policy、建了 PriorityClass、 等了半小时,什么都没发生 —— 然后我们一看队列,只设了 max,没设 guaranteed。这一条能省掉好几天的排查。

(第二个红框,这是七条里最反直觉的一条) 定律 2 说:抢占不能把受害队列压到 guaranteed 以下。 听起来很温和,但它的后果非常反直觉,我举个具体数字: 假设一个队列 guaranteed 是 10 核,现在用了 16 核 —— 理论上有 6 核可以被抢。但如果它上面跑的是8 核的大 executor, 杀掉任何一个都会让它掉到 8 核,低于 guaranteed 的 10 核。 (停一下)结果是:这个队列虽然超了保障量,但一个 pod 都不能被抢。 结论:pod 粒度越粗,抢占越难生效。 所以如果你希望某类负载是「可被回收」的,就别用太大的 pod 粒度。

(第三个红框,这是配置错误的高发区) 定律 3 说:任务不能抢占同一个应用内的任务 —— 而且官方补了一句更重要的:目前只实现了队列之间的抢占,队列内部的抢占没做。 它的配置含义是:同一个队列里,高优应用抢不了低优应用。 所以你想让高优作业压过低优作业,必须把它们放到不同队列, 用 priority.offset 去区分 —— 而不是靠同队列内的 PriorityClass。 这是一个很常见的配置错误。

(最后那个框,方向问题,这个几乎人人搞反) preemption.policy: fence 的意思是「我不能往外抢」; disabled 的意思是「我不能被抢」。

(照念这一句)所以想保护你的在线服务不被批处理抢走资源, 要用 disabled,不是 fence。

fence 是给多租户用的 —— 官方原话是不该把一个租户的负载抢掉、 把资源给另一个租户,围栏挡住的是「往围栏外找受害者」这个动作, 它是单向的,不挡外面的人进来抢你。

剩下的四条我快速带过,但有一条值得单独点出来。 定律 1,抢占策略是强建议、不是保证 —— DaemonSet 场景会破例, 所以 yunikorn.apache.org/allow-preemption: "false" —— (顺带说一句,这个注解是打在 PriorityClass 上的,不是打在 pod 上) —— 不是免死金牌, 对客户承诺「这个队列绝对不会被抢」是不严谨的。 定律 5 是定律 4 的另一半:队列不高于 guaranteed 就不能被抢。 定律 7 就是刚才说的围栏 —— 官方原话是「单向围栏」,它挡住的是往围栏外找受害者。 (定律 6 这条差异值得讲,因为它会让人误判) 定律 6:只能抢优先级更低或者相等的任务 —— 而 Kubernetes 原生只允许更低。 官方给的理由是它还要用抢占来让队列拿到 guaranteed。 实际含义:即使你们所有 pod 都用同一个 PriorityClass,跨队列抢占依然会发生。 很多人以为「不设 PriorityClass 就不会被抢」,这是错的。

(这个追问很常见) 可能被问:「抢占会不会造成雪崩?」 这七条定律的存在目的就是防这个,官方原话是 "prevent a preemption storm or loop"。 而且还有一条硬限制帮忙:它不支持跨节点抢占 —— 官方原话是 "Cross node preemption is not supported", 受害者必须在同一个节点上凑出来。 这限制了爆炸半径,但有个副作用:碎片化的集群里抢占更难成功 —— 你需要 4 核,集群里 4 个节点各能腾 1 核,抢占不会发生。 (这句要说清口径)这个副作用是机制推论,不是我们实测的 —— 我们实测的只有下一页那一次,是在同节点上完成的。 (顺手回扣前面)这也是 binpacking 节点排序的又一个好处。

下一页给实测取证 —— 我们真的把抢占跑出来了,而且它精确停在了 guaranteed 上。

Ch.2 · 它怎么工作 · 图解 · Preemption

抢占决策链:guaranteed 账本 + 围栏,两把锁串联 每一步都在虚拟账本上先验算

① 入口与三道闸 · core 调度循环② 子过程 checkPreemptionQueueGuarantees · guaranteed 账本③ 选节点 → 送 shim 校验 → 最后一公里PartitionContext.TryAllocate分区开关放行 · YAML preemption: enabledApplication.tryPreemptionheadroom 装不下,或没节点放得下maxPreemptionsPerQueue = 10每队列每轮 10 次预算,先于前置检查Preemptor.CheckPreconditions前置五查 = 3 状态闸 + 2 时间窗findPreemptionFenceRoot定律 7:向上递归定围栏根findEligiblePreemptionVictims围栏内八重筛 · 同队列一律不抢prunePreemptionSnapshots剪掉无 victim 的快照 · 1.9.0 新增isAskQueueUnderGuaranteed定律 4:虚拟移除后能否爬过 guaranteedtryNodes → calculateVictimsByNode两轮筛:victim 队列须超 guaranteedcheckPreemptionPredicates循环后只调 1 次 · 每批 10 并发,满意即早停Context.IsPodFitNodeViaPreemptionk8shim 跑 K8s 谓词 → success / indexcalculateAdditionalVictims补 victim → 查缺口 PreemptionShortfallIncPreemptingResource标记 · 逐级上记 · 事件 · 通知 RM 释放SchedulerKubeClient.Delete裸 DELETE → kube-apiserver,绕过 PDBcore → k8shim1234567891011121314最后一公里:实际驱逐是裸 Pod DELETE,不走 pods/evictionCoreV1().Pods(pod.Namespace).Delete(context.Background(), pod.Name, apis.DeleteOptions{})不是 policy/v1 的 pods/eviction 子资源 ⇒ PodDisruptionBudget 对 YuniKorn 抢占完全无效空 apis.DeleteOptions{} ⇒ 仍走 Pod 自身 terminationGracePeriodSeconds(优雅终止,只是不看 PDB)抢占成功也只 newReservedAllocationResult 预留节点,等 victim 真的 released 才在下一轮分配「七定律」不在源码里:全仓 grep 只命中 Apache License 的 applicable law。它只存在于官方设计文档 design/preemption 的「## The Laws of Preemption」(1.9.0 逐字)。本图沿用该文档的定律编号,但判据一律以源码为准。partition.go:828 root.TryAllocate(..., pc.IsPreemptionEnabled())|开关读 partition.go:169-171 PartitionPreemptionConfig.Enabled / .QuotaPreemptionEnabled(Go 字段路径)|YAML 键全小写:preemption: { enabled: true, quotapreemptionenabled: true } —— quotapreemptionenabled 是一个词、无驼峰;写成 Preemption.Enabled 这类驼峰会被 yaml 静默忽略。两个触发点,差别只在 nodesTried:application.go:1074(headroom 装不下,nodesTried=false)与 :1110(headroom 够但没节点放得下,nodesTried=true)|延迟度量 ObserveTryPreemptionLatency ⚠ 源码缺陷:metric 名是 yunikorn_scheduler_trypreemption_latency_milliseconds,但实测调的是 SinceInSeconds(),Help 也写 in seconds ⇒ 值的单位是秒,照名字做 dashboard 会差 1000 倍。queue.go:1686 每轮把 preemptAttemptsRemaining 置回 maxPreemptionsPerQueue = 10|application.go:1484 判 ==0 直接返回 common.PreemptionMaxAttemptsExhausted|这道闸先于 CheckPreconditions(NewPreemptor 在 :1492,CheckPreconditions 在 :1495),所以它是独立一道门,不是 tryPreemption 的注脚。preemption.go:96/101/106/111/116 共 5 个 return false:!IsAllowPreemptOther() / HasTriggeredPreemption() / GetRequiredNode()!=""(交给 required-node 抢占通道)/ createTime+preemptionDelay(DefaultPreemptionDelay 30s)未到 / GetPreemptCheckTime()+preemptAttemptFrequency(15s)未到|失败事件 common.PreemptionPreconditionsFailed。queue.go:2258-2285 向上递归。三种情况成为围栏根:root 队列 / preemption.policy=fence / shouldFenceByMax(:2271-2276)|max 构成围栏不是 1.9.0 新特性:v1.8.0 queue.go:2134 已有一支严格相等(maxResource == allocatedResource);v1.9.0 是泛化 —— 加 askResource 做投影、改 StrictlyGreaterThanOrEqualsOnlyExisting 按已定义资源型逐型判,即「当前用量 + ask 的投影达到或超过 max 即成围栏」。queue.go:2140-2196 深度优先,八道筛依次:①跳过 ask 自己的队列(:2144) ②DisabledPreemptionPolicy 跳过 ③队列未超 guaranteed 则 delete 快照(定律 5,:2156-2161)④ask 与 victim 资源型 MatchAny ⑤GetRequiredNode()!="" 跳过 ⑥IsReleased 跳过 ⑦IsPreempted 跳过 ⑧fenced || priority ≤ askPriority(:2188)|第①条比文档定律 3 更严:整个 ask 所在队列直接 return ⇒ 同队列不同 application 之间也不能互抢(文档自己承认 intra-queue 抢占尚未实现)。queue.go:2106 调用,实现 :2227-2256。剪掉「无 victim 的叶快照」与「不在 ask 路径、也不在任何 victim 路径上的非叶快照」|这是 v1.9.0 真正新增的三样之一(另两样:SortAllocationsBasedOnAsk / scoreAllocationBasedOnAsk,以及 initWorkingState 从无返回值改为返回撤销数)。checkPreemptionQueueGuarantees preemption.go:223-252:先看 ask 队列 GetRemainingGuaranteedResource() 能否直接装下 ask;否则逐个虚拟移除 PotentialVictims,只要某刻 isAskQueueUnderGuaranteed(:942-951) 为真即通过;全程失败 → common.PreemptionDoesNotGuarantee(:606-609)|⚠ 步 5-7 都嵌在这一步里::224 initQueueSnapshots → :132 FindEligiblePreemptionVictims → queue.go:2079 定围栏根 → :2102 八重筛 → :2106 剪枝。preemption.go:568 tryNodes 是外层循环,:579 对每个节点调 calculateVictimsByNode(:259-391)|:264-267 节点本就够则短路 return -1|第一轮 :284-332 过定律 2 闸 GetPreemptableResource()>=Zero && isVictimQueueOverGuaranteed,按缺口是否变小分 head/tail;第二轮 :340-383 定 index(:372)|节点过滤与排序在 initWorkingState(:137)::203-209 删掉不可调度 / 被他人预留 / FitInNode 失败的节点,:214 sortVictimsForPreemption。preemption.go:437。⚠ 不是每个节点调一次:整个 tryNodes 循环结束后只调一次(:597)|组装 si.PreemptionPredicatesArgs{allocationKey, nodeID, preemptAllocationKeys, startIndex}(proto 小驼峰,si.proto);按 startIndex 升序排 :409-415|batchPreemptionChecks 按 preemptCheckConcurrency=10 切块,每个 check 一个 goroutine(:447),批与批之间串行,bestResult.isSatisfactory 成立即 break(:465-467)。k8shim 侧跑真正的 K8s 调度谓词,回 si.PreemptionPredicatesResponse{success, index}|无 RM plugin 注册时 core 侧会假通过(preemption.go:419-434) ⇒ core 的抢占判定不是自足的安全网|定律 1 只影响排序、不排除 victim:scoreAllocation(:887) 对 IsAllowPreemptSelf()==false 只加 scoreNoPreempt(1<<34),批循环后无条件 return bestResult(:470) ⇒ annotation 里 opt-out 的 Pod 在没有更好解时仍会被抢(这就是 "Preemption policies are strong suggestions, not guarantees" 的机制实现)。补 victim = preemption.go:474-564(调用点 :622):按 compareAllocationLess 排序补充,判据是 ask 队列 remaining guaranteed 是否变化,末尾用 isAskQueueUnderGuaranteed 决定成败|查缺口是另一处 —— preemption.go:663 if p.ask.GetAllocatedResource().StrictlyGreaterThanOnlyExisting(victimsTotalResource) → common.PreemptionShortfall。preemption.go:674 逐个 MarkPreempted(),任一已释放则全部 MarkUnPreempted() 回滚并报 PreemptionVictimsReleased(:672-691)|:694-696 victimQueue.IncPreemptingResource() 递归向上(queue.go:1389-1399)|:707 SendPreemptedBySchedulerEvent(Allocation 层;AskEvents 层的文案函数叫 SendPreemptedByScheduler,无 Event 后缀)|:717 MarkTriggeredPreemption|:720 notifyRMAllocationReleased(finalVictims, si.TerminationType_PREEMPTED_BY_SCHEDULER = 3)|:729 newReservedAllocationResult。链路:scheduler_callback.go:102-112(Released 且 != STOPPED_BY_RM → NewReleaseAppAllocationEvent)→ application.go:643-652 handleReleaseAppAllocationEvent → task.go:183-185 DeleteTaskPod → kubeclient.go:140-141 SchedulerKubeClient.Delete|quota 变更抢占(QuotaPreemptionContext / TryQuotaPreemption,独立后台 goroutine 每秒一次、独立排序与谓词族)共用同一条裸 DELETE 出口。证据:k8shim v1.9.0 对 pkg cmd 做 git grep -icE "eviction|\.Evict\(" 零命中;kubeclient.go:140-141 确为 core/v1 Pod DELETE + 空 apis.DeleteOptions{}(apis 是本文件对 apimachinery meta/v1 的别名,kubeclient.go:28,本仓库不写 metav1)|逻辑上确定,但未做 E2E 实测(造 PDB minAvailable 卡死后触发抢占、观察 Pod 是否仍被删);写进风险章节建议补一次 kind 实测。
这张图的一句话:抢占是「guaranteed 账本 + 围栏」两把锁串起来的 —— 每一步都在虚拟账本上验证「抢完之后 victim 队列不掉到 guaranteed 之下、ask 队列能爬到 guaranteed 之上」。没有 guaranteed,抢占什么都不会做。
Ch.2 · 图解 — Preemption28

⏱ 本页 2.3 分钟 · 主线 491 字 · 深潜层另有 869 字

这张图分三列,每列自上而下是步序,一共 14 步。 左列往下四步,顺橙色折线拐到中间列顶部,再往下四步,再拐到右列,往下六步。 右列最后那个红框是终点,性质跟前十三步完全不同;左下角红色大框就是把它拆开看。 中间那列标题底色是橙的,因为那四步全嵌在同一个函数里。

左列是四道闸,一道不过这轮抢占就不发生。第一道是分区开关。 (这条会被抄进 YAML)键全是小写:preemption: 下面是 enabled 和 quotapreemptionenabled —— 后者一个词、没有驼峰, 写成驼峰 yaml 会静默忽略。

第二道是两个触发点:headroom 装不下,或够但没节点放得下。 第三道:每队列每轮只有 maxPreemptionsPerQueue = 10 次预算, 用完报 PreemptionMaxAttemptsExhausted。 第四道是前置五查 = 3 个状态闸加 2 个时间窗,两个窗是 30 秒和 15 秒。

中间这列是账本。「七定律」不在源码里,只在官方设计文档那一节 The Laws of Preemption,我沿用编号方便对照,判据一律以源码为准。 一、这本账翻到哪层为止,就是围栏根:root 队列、 显式写 preemption.policy=fence、 或用量加上这个请求的投影已触到该队列的 max —— 第三条别打「1.9.0 新增」的标记,1.8.0 已有严格相等那一支。 二、围栏里谁能当 victim,八重筛,第一道就是跳过请求自己所在的整个队列, 比定律 3 更严:同队列不同 application 也不能互抢。 三是剪枝,这才是 1.9.0 真新增的。四是定律 4 的预检:逐个虚拟移除候选, 某刻能爬过 guaranteed 就通过,否则报 PreemptionDoesNotGuarantee。

右列前四步把账本落到节点上。这里的层级最容易画错: tryNodes 是外层循环,每节点算一份 victim 名单, 但送 shim 跑 K8s 谓词只有一次 —— 循环结束后统一送,每批 10 个并发 goroutine, 批间串行,有满意解就早停。青绿那个盒子是 k8shim 的活。 (这条必须主动说)文档说策略是 "strong suggestions, not guarantees", 实现是 opt-out 只给这个 victim 加一个很大的排序分、并不排除它 ⇒ 没有更好解时,标了不许被抢的 pod 仍会被抢。

(指那条会动的红色蚂蚁线,落到红框) 这是本页唯一动画,也是最该带走的一跳:真正的驱逐是 k8shim 干的,它调的是 CoreV1().Pods(pod.Namespace).Delete(context.Background(), pod.Name, apis.DeleteOptions{}) —— 裸的 Pod DELETE,不是 pods/eviction ⇒ PodDisruptionBudget 对 YuniKorn 的抢占完全无效。 但证据强度要说清:全仓搜 eviction 零命中,我们没做端到端实测。

另两行:DeleteOptions 是空的, 仍走 pod 自己的 terminationGracePeriodSeconds; 抢占成功也只是预留节点,等 victim 真释放才分配。

悬停里还有一条给做监控的:抢占延迟那个指标名叫 trypreemption_latency_milliseconds,但代码观测的是秒 —— 照名字做 dashboard 会差 1000 倍。

下一页是实测取证:抢占真实发生,而且精确停在 guaranteed 上。

Ch.2 · 它怎么工作 · Measured

✅ 实测:抢占真实发生,且精确停在 guaranteed 4 个 pod 被抢 · 完整取证

布置:怎么在「不缺资源」的集群上造出稀缺

难点:集群有 89 core,随便提交都能满足,永远不会触发抢占。 而 root 队列不允许设 resources,所以「给全集群设总闸」这条路堵死。
解法:插一个带 max 的中间父队列。

root
└── tenant          max = 4 vcore  ← 稀缺点
    ├── hi   guar 2, offset +1000, delay 10s
    └── lo   guar 1, offset −1000

先让 lo 提交 8 × 500m = 4000m,正好吃满 tenant:
lo alloc=4000 / guar=1000 ⇒ 超出,可被抢
hi alloc=0 / guar=2000 ⇒ 低于,可触发
⇒ 这正是定律 4 + 5 的教科书式配置。

结果

时刻lohi
T+10s8 Running4 Pending(pending=2000)
T+25s4 Running / 4 Pendingalloc 4000→20004 Runningalloc 0→2000
T+45s ~ T+130s状态稳定,不再变化
🔵 关键观察:hi 拿到恰好 2000m(= 它的 guaranteed)就停了, 没有继续往 max=4000 抢 ⇒ 完美印证「抢占只回到 guaranteed,不冲 max」。
🔴 连带问题:被抢占的 4 个 pod 被删后, ReplicaSet 立刻补了 4 个新 pod,而它们永远 Pending(持续到实验结束)。 ⇒ 抢占在 Deployment 语义下不是「缩容」,是「制造永久 Pending」。
Ch.2 · 它怎么工作 — 抢占实测29

⏱ 本页 1.8 分钟 · 主线 381 字 · 深潜层另有 1629 字

这一页是实测,口径同样先交代:本地 kind 集群,我们自己跑的,队列配置、时序、 原始输出都在配套材料里。 这一页有两个要点,我希望你们分别带走: 第一,抢占精确停在 guaranteed —— 这说明机制是可预测的,可以对客户承诺; 第二,抢占加 Deployment 等于制造永久 Pending —— 这是一个必须提前告知运维的行为。

(先讲左边这张卡,因为这个技巧有普适价值) 我们做这个实验时先撞了一个墙,值得说出来。 难点是:集群在调度器视角有 89 个 core,随便怎么提交都能满足,永远不会触发抢占。 抢占的前提是稀缺,所以我们得先造出稀缺。 第一个念头是给全集群设一个总闸 —— 但这条路是堵死的:root 队列不允许设 resources。

(这就是那个值得记住的技巧) 解法是:插一个带 max 的中间父队列,把稀缺造在子树内部。 (指着那段队列树) root 下面挂一个 tenant,max 设成 4 个 vcore —— 这就是稀缺点; tenant 下面两个子队列:hi,guaranteed 2、 priority.offset 加 1000、preemption.delay 10 秒; lo,guaranteed 1、offset 减 1000。 (这句建议照念,它对听众有直接用处) 想在任何层级造资源稀缺,就在那一层插一个带 max 的 parent 队列。

(指着左下那三行) 然后铺垫:先让 lo 提交 8 乘 500m,也就是 4000m, 正好把 tenant 的 4000m 吃满。 这时候两边的账是这样的: lo 的 alloc 是 4000,guaranteed 是 1000 ⇒ 它超出了保障量,可以被抢; hi 的 alloc 是 0,guaranteed 是 2000 ⇒ 它低于保障量,可以触发抢占。 (点出这一句)这正是上一页定律 4 加定律 5 的教科书式配置 —— 我们是照着定律去构造条件的,不是碰巧撞出来的。

(指着右边那张结果表) 然后提交 hi:4 乘 500m,也就是 2000m,正好等于它的 guaranteed。 T 加 10 秒:lo 是 8 个 Running,hi 是 4 个 Pending, pending 量 2000。这时候还什么都没发生 —— 因为 preemption.delay 是 10 秒。 T 加 25 秒,这一行是结论:lo 变成 4 个 Running、4 个 Pending, 它的 alloc 从 4000 掉到 2000;hi 变成 4 个 Running, alloc 从 0 涨到 2000。抢占完成了。 T 加 45 秒一直到 T 加 130 秒:状态稳定,不再变化 —— (这一行也要讲)这说明没有震荡、没有反复抢来抢去, 它抢一次就收手了。

(指着右边第一个蓝框,这是这一页最该带走的观察) hi 拿到的是恰好 2000m —— 正好等于它的 guaranteed —— 然后就停了, 没有继续往 max 的 4000 抢。

(停一下)这完美印证了上一页那句官方定调: 抢占只回到 guaranteed,不冲 max。 还有一个细节值得说:lo 被砍到了 2000m,而不是砍到它自己的 guaranteed 1000m —— 因为抢占只拿走 hi 需要的那 2000m 就停了,没必要抢更多。 (这句可以对客户说)也就是说抢占不是「有多少抢多少」,而是「抢到够为止」。 这个精确性是可以承诺的。

(指着右下那个红框,这一条必须讲,而且要说清它不是 bug) 连带问题来了:被抢占的那 4 个 pod 被删掉之后,ReplicaSet 立刻补了 4 个新 pod —— 而它们永远 Pending,一直持续到我们实验结束。 (然后说这句,它是这一条的价值所在) 这不是 bug,是设计预期的结果。 官方设计文档的「Preemption Loop Prevention」一节专门分析过 ReplicaSet 这个场景, 并且明确预期了这个结局:被重建的那个 pod 不能反过来抢,因为那会让对方队列跌破 guaranteed, 所以它只能等。 设计上是对的 —— 它防住了抢占循环;但运维上是个惊喜 —— 你会看到一批永远 Pending 的 pod,它们既不该被清理,也不会自己好。

所以这一页的结论,和 Gang 那一页的结论是同一条: (这句建议照念) 批处理语义 —— gang 和抢占 —— 应该配 Job 或者框架的 CRD,不要配 Deployment。 Deployment 的「副本数恒定」语义,和「资源可被回收」语义,在根本上是冲突的。

(最后,三条我们没能验证的,如实说 —— 这一段建议照念,别删) 这个实验有三点我们没有验证,我说清楚: 一是 PriorityClass 和 priority.offset 的独立贡献度 —— 我们两个都设了,没做单变量对照,所以「到底是哪一个起了作用」我们答不上来; 二是围栏那两个字段 —— isPreemptionFence 和 isPriorityFence —— 本次实测里它们都是 false,作用完全没有测试; 三是 preemptingResource 这个字段,我们 6 次采样恒为 0 —— 不是它不动,是抢占在两次采样之间就完成了,采样窗口是 15 秒,而实际抢占约 1 秒。 (顺带一个有价值的观察)另外有一条值得说: 这次抢占是在 quotaPreemptionEnabled 为 false 的情况下发生的 —— 说明基于 guaranteed 的抢占不需要动那个开关,它是另一条路径。

(这个追问一定会来,而且答案会让运维紧张) 可能被问:「我们的在线服务是 Deployment,会不会被抢?」 会。而且你的 PodDisruptionBudget 保护不了它 —— 第三章我会给源码证据。 正确的保护方式是给那个队列设 preemption.policy: disabled。

下一页讲两个观测缺口。它们都是我们实测发现的,而且都影响审计 —— 如果你们要能回答「上周谁抢了谁」,下一页是必须听的。

Ch.2 · 它怎么工作 · Observability Gaps

抢占的两个观测缺口 都是实测发现的 · 都影响审计

缺口一 · K8s event 会丢,YuniKorn 事件流不丢

1 / 4
kubectl get events 剩下
4 / 4
/ws/v1/events/batch

4 个 pod 被抢占,kubectl get events 里只剩 1 条 Preempted by … (其余随 pod 删除 / event TTL 消失),而 YuniKorn 的事件 API 里 4 条全在。

做法:抢占审计 / 计费 / 事后复盘必须读 /ws/v1/events/batch,不能依赖 kubectl get events。 事件四要素齐全:被抢的 allocation UUID、受害应用、抢占方的 request UUID + 应用名 + 队列名。

缺口二 · 抢占方不知道自己抢了别人

# 抢占方 pod 的完整 event(实测)
Normal  Scheduling         is queued and waiting…
Normal  Informational      Request '…' does not fit
                           in queue 'root.tenant.hi'
                           ← 中间「我抢占了别人」完全没有记录
Normal  Scheduled          Successfully assigned…
Normal  PodBindSuccessful  is successfully bound…
后果:只有受害者有 Preempted by 事件。 能查「谁杀了我」,查不到「我杀了谁」。排查「这个作业抢了谁」只能从受害方事件反查 (按抢占方的 request UUID 在事件流里搜)。
还有一条相关的:「配额不足在排队」这个事件的级别是 Normal 而不是 Warning ⇒ 只报 Warning 的告警规则会漏报配额不足。
Ch.2 · 它怎么工作 — 观测缺口30

⏱ 本页 1.6 分钟 · 主线 336 字 · 深潜层另有 1266 字

这一页对做平台运维的人最有价值。核心一句我先说: 如果你要能回答「上周谁抢了谁的资源」,就必须把 YuniKorn 自己的事件流接进你的日志系统 —— kubectl 的事件是留不住的。 这两个缺口都是我们实测撞出来的,都影响审计和计费。

(指着左边那两个数字) 缺口一,先看数字,这是同一个抢占实验里同一时刻的两份记录: 4 个 pod 被抢占,kubectl get events 里只剩 1 条 Preempted by …;而 YuniKorn 自己的 /ws/v1/events/batch 里,4 条全在。 (停一下)1 比 4。这不是采样误差,这是结构性的丢失。

为什么会丢?两个原因叠加。 第一,pod 被删除之后,它的 event 会随之被清理 —— 而抢占干的事情正是删 pod,所以这是必然的。 第二,Kubernetes 的 event 本身有 TTL,默认一个小时。 而 YuniKorn 保留了完整的 4 条,因为它有自己独立的 ring buffer, 跟 apiserver 的 event 生命周期无关。

(指着左下那个框,这是这半页的行动项) 所以做法很明确:抢占审计、计费、事后复盘,必须读 /ws/v1/events/batch,不能依赖 kubectl get events。 好消息是这个端点给的信息是够用的,事件四要素齐全: 被抢占的 allocation UUID、受害的应用、 以及抢占方的 request UUID 加应用名加队列名。 (这句要说出价值)有这四样,你就能完整还原一次抢占的因果链 —— 谁抢了谁、为了哪个请求、在哪个队列。

(转到右边,指着那段 event 输出) 缺口二更有意思,而且更麻烦:抢占方不知道自己抢了别人。 这是我们抓到的抢占方 pod 的完整 event 列表,一共就这么几行: 第一行 Scheduling,「排着队等分配」; 第二行 Informational,「这个 Request 在 root.tenant.hi 里放不下」; (指着那行高亮)然后 —— 中间「我抢占了别人」这一步,完全没有记录; 接着直接就是 Scheduled,「成功分配到节点」; 最后 PodBindSuccessful,「绑定成功」。 从「放不下」到「调度成功」,中间隔了 6 秒,而这 6 秒里发生了什么,事件里一个字都没有。

(指着右边那个红框,说清它的实际后果) 后果是:只有受害者那边有 Preempted by 事件。 换句话说:你能查「谁杀了我」,查不到「我杀了谁」。

(这个场景很具体,值得讲) 这在做「资源纠纷仲裁」的时候会很痛。 某个团队来投诉「我的作业被杀了」——这个你查得到,从受害方的事件里看得清清楚楚。 但反过来,某个团队问「我这个作业是不是影响了别人」——你查不到。 变通办法是拿抢占方的 request UUID 去事件流里反查, 但那需要你先知道要查哪个 UUID,这在事后复盘时往往不成立。 (顺带一句)这是一个可以给上游提的改进点。

(右下那个框,这一条最容易漏,而且几乎每家都会中)

还有一条相关的:「配额不足在排队」这个事件的级别是 Normal,不是 Warning。

(说清后果)而大多数团队的告警规则只看 Warning 及以上 —— 于是最需要被看到的那个状态,恰好在你的告警视野之外。 所以你们的告警要专门针对 PodUnschedulable 这个 reason 去写, 不能只按级别过滤。

(这里再补一条排障口径,时间紧可跳,但很实用) 顺手说一个相关的坑:真正的原因不在 Event 里,在 PodCondition 的 Message 里。 Event 的文案是固定字符串 —— 比如「the queue quota has been exceed」这种泛泛的话; 具体诊断在 PodScheduled 这个 condition 的 message 字段。 所以 kubectl describe pod 给你的是泛泛的一句, -o jsonpath 才给你真实原因。

(这个追问会来) 可能被问:「YuniKorn 的事件流保留多久?」 它是内存 ring buffer,容量可配, event.RESTResponseSize 默认是 10000 条; 要长期保留必须自己拉出来落盘。 顺带给一个很有用的数字:已经结束的应用在 REST 里保留 72 小时 —— 源码里是 terminatedTimeout = 3 × 24h —— 之后转成 Expired 被清理。 所以事后复盘你有 3 天窗口,超过就没了。

下一页是这一章最后一个坑,而且我要说清楚: 它影响到在座每一个正在跑最新 GA 版本的人。

Ch.2 · 它怎么工作 · Trap #4 · 当前 GA 上的活跃 bug

坑四:v1.9.0 的 /ws/v1/metrics 被双重 gzip 默认的 Prometheus 抓取全部失败,且静默

版本gzip.goContent-Encoding 出现次数
v1.7.0不存在— 无中间件,不受影响
v1.8.0不存在— 不受影响
v1.9.0(当前 GA)存在1 只 Set,从不读 ⇒ 无保护
master(→1.10.0)存在7 含穿透保护 ⇒ 已修
因果链:/ws/v1/metrics 由 promhttp.Handler() 提供, 它自己已经 gzip 并设了 Content-Encoding: gzip;1.9.0 的中间件不检查就再压一次, 而 header 仍只宣告一层编码 ⇒ 客户端按一层解压 ⇒ 拿到 gzip 帧不是指标文本。 Prometheus 默认发 Accept-Encoding: gzip ⇒ 指标静默消失、target 掉线。
// master 的修复注释(它自己把失败模式讲清了)
// A handler is allowed to encode the response body
// itself … Compressing again would produce a doubly
// encoded body advertised by a single Content-Encoding,
// which NO CLIENT CAN DECODE. Hand the response over
// untouched instead.
if !d.decided && d.Header().Get("Content-Encoding") != "" {
  d.passThrough()
}

# 缓解 ①:原生 Prometheus
- job_name: yunikorn
  enable_compression: false

# 缓解 ②:prometheus-operator
spec:
  endpoints:
    - port: yunikorn-core
      path: /ws/v1/metrics
      enableCompression: false
影响面:只有这一个端点。 只有它的 handler 预先编码过;/ws/v1/events/stream 被中间件按精确路径排除; 其余路由主动加 --compressed 反而有益(因为 API 没有分页)。
Ch.2 · 它怎么工作 — 坑四:metrics 双 gzip31

⏱ 本页 1.5 分钟 · 主线 309 字 · 深潜层另有 1898 字

(这一页是全场最有行动价值的一条,建议大家现在就拍照) 核心一句:如果你现在跑的是最新 GA,也就是 v1.9.0,并且用默认配置抓指标, 那你的调度器指标是拿不到的 —— 而且它不报错,只是 target 悄悄掉线。

(指着左边那张表,四行,一行一行念,这是版本分水岭) 这张表是我逐版本用 git show <tag>:pkg/webservice/gzip.go 查出来的。

v1.7.0:这个文件根本不存在 —— 没有 gzip 中间件,不受影响。 v1.8.0:同样不存在,同样不受影响。 v1.9.0,也就是当前 GA:文件存在,而 Content-Encoding 在里面 只出现 1 次 —— 而且是只 Set、从不读。 (这就是问题所在)只写不读,就等于没有任何保护。 master,也就是将来的 1.10.0:出现 7 次,含穿透保护 ⇒ 已经修好了。 (点出这个结论) 所以 gzip 中间件是 1.9.0 全新引入的,这个 bug 是它自带的回归。

(指着左下那个因果链框,这段建议慢一点讲,因为它解释了为什么是「静默」失败) 因果链四步。 第一步,/ws/v1/metrics 这个端点是由 promhttp.Handler() 提供的, 而它自己已经做了 gzip,并且自己设了 Content-Encoding: gzip。 第二步,1.9.0 的 compressResponse 中间件包住整个 router, 它不检查这个 header 就再压一次 —— 触发条件是客户端发了 Accept-Encoding: gzip、并且响应体超过 minCompressionSize,也就是 1400 字节。 第三步,压了两层,但 header 仍然只宣告一层编码。 第四步,客户端按一层解压 ⇒ 拿到的是一个 gzip 帧,不是指标文本。 (然后说这句,它是这一条的杀伤力所在) 而 Prometheus 默认就是发 Accept-Encoding: gzip 的 ⇒ 所以在 1.9.0 上,调度器指标静默消失、target 掉线。

(指着右上那段注释,念一句英文原文) 右边上半是 master 的修复代码。社区自己把失败模式写得非常清楚,我念关键那半句: "Compressing again would produce a doubly encoded body advertised by a single Content-Encoding, which no client can decode." (重复一下那三个词)"no client can decode" —— 不是「某些客户端有问题」,是没有任何客户端能解。 修复本身很简单,就是高亮那两行:如果还没决定压缩方式、而且响应头里 Content-Encoding 已经非空,那就 passThrough, 原样交出去、不要碰它。

(下面这两段配置是这一页的全部行动价值,建议念清每一个键名) 缓解方式有两种写法,取决于你怎么配 Prometheus。 第一种,原生 Prometheus:在那个 job 下面加一行 enable_compression: false —— 注意是下划线风格, 这是 Prometheus 自己的配置项,默认值是 true。 第二种,如果你们用 prometheus-operator,改的是 ServiceMonitor 或 PodMonitor: 在 spec.endpoints 那一项下面, port 写 yunikorn-core、path 写 /ws/v1/metrics, 然后加 enableCompression: false —— 注意这里是驼峰风格。

(这句要说,因为它是最容易出错的地方) 两个键名长得像但拼法不同:原生是 enable_compression, operator 是 enableCompression。写错了不会报错,只是不生效。

(指着右下那个框,讲影响面,这一条能让人放心) 影响面只有这一个端点。

为什么?因为只有它的 handler 是预先编码过的; /ws/v1/events/stream 被中间件按精确路径排除了; (这一句反过来讲,是个额外的建议) 而其余的路由,主动加 --compressed 反而是有益的 —— 原因是这套 API 没有分页,忙集群上一次 GET 应用列表 可能就是几十 MB 的响应,压缩帮很大。 唯一不能加 --compressed 的就是 /ws/v1/metrics。

(给一个现场就能做的验证方法) 验证很简单,而且可以当场演示: curl -s .../ws/v1/metrics | head -3,应该看到 # HELP 开头的行; 然后加上 --compressed 再来一次 —— 如果拿到的是二进制乱码,那你就撞上了。

修复的状态我也说清楚,因为它决定你现在能做什么: 对应的 JIRA 是 YUNIKORN-3341,状态是已修复, 但 fixVersion 只有 1.10.0,没有 1.9.x 的回移 —— YuniKorn 最近几个版本都没有出过 patch 版本。 所以在 1.10 GA 之前,你唯一能做的就是改抓取配置。

(这一页还有一层意义,我认为比这条 bug 本身更值得带走) 它说明「跟最新版」这件事,需要你自己有一条核实链路。 这不是社区不行 —— bug 已经修好了、时间表也是公开的; 但如果你不自己验证关键路径,你的监控会在你完全不知道的情况下失效。 (这句建议照念)这个态度,比这条 bug 本身更值得带走。

(这个追问一定会来,答案要给得干脆) 可能被问:「那我们该用 1.8.0 还是 1.9.0?」 取决于你更怕哪一个。 1.8.0 有两个已知的调度正确性 bug,都是 1.8.0 自己引入、1.9.0 修掉的: 一个是预留释放时的死锁,对应 YUNIKORN-3318; 一个是 foreign allocation 追踪缺失 —— informer 在某些情况下只给 update 不给 create, 导致非 YuniKorn 的分配没进 core,节点看起来利用率偏低,然后调度失败 —— 对应 YUNIKORN-3317。 1.9.0 有这个 metrics bug,但一行配置就能绕过。 (给出立场)所以我倾向 1.9.0 加改抓取配置 —— 我宁可自己改一行 YAML,也不愿意在生产上带两个调度正确性的 bug。

第二章到这里结束。我们看完了它怎么工作,也看完了四个坑。 下一章进 AWS —— 讲它在 EKS、Karpenter、EMR on EKS 上会发生什么, 包括我们在 AWS 自己的官方文档里发现的那个缺陷。

Ch.2 · 它怎么工作 · 图解 · The gzip Bug

双重 gzip 的完整成因:两层各压了一次 v1.9.0 活跃 bug · 任何客户端都解不开

① 进程启动期 · 每项只做一次(不在 scrape 路径上)pkg/metrics init()once.Do 注册全部指标prometheus.Register失败只 Warn,不 fatalStartAllServicesWithLogger起采集器与 WebAppnewRouter() httprouter注册 40 条路由http.Server :9080Handler: compressResponse12345进程启动期 ↑ / 每次 scrape ↓② 每次 scrape · 请求进 →Prometheus scrapeAccept-Encoding: gzipcompressResponse/ws/v1/metrics 无豁免deferredGzipResponseWriter缓冲 1400 字节再决定httprouter → loggingHandler路由派发并记耗时getMetrics同步采 runtime 后转交678910③ 响应回程 ←promhttp 在写 body 前就把 Content-Encoding 设到底层 w;dw 没覆写 Header() ⇒ 中间件看不见,又压了第二次promhttp.Handler()第 1 层 gzip · 自己协商switchToGzip第 2 层 gzip · buf ≥ 1400finalize() → gz.Close()封尾,冲上线路Prometheus 解一层得 gzip 流,非文本ServeHTTP(w, r)又压一次14131211线路上的响应体 = gzip(gzip(text))第 2 层 gzip · switchToGzip第 1 层 gzip · promhttpOpenMetrics 文本Content-Encoding: gzip只有一个值 ⇒ 客户端只解一层switchToGzip 用 Set 覆盖成同值唯一规避(v1.9.0 侧无任何压缩开关):Prometheus 别发 Accept-Encodingscrape_configs[].enable_compression: false(默认 true)spec.endpoints[].enableCompression: false(ServiceMonitor,需 Prometheus ≥ v2.49.0)上游修复:master 加 passThrough() —— master only,v1.9.0 未修handler 已设 Content-Encoding 就整段直通(master:gzip.go:67-73 / 97)yunikorn-core/pkg/metrics/init.go:49 · 构造 Metrics{scheduler, queues, event, runtime};Namespace="yunikorn"、SchedulerSubsystem="scheduler"、EventSubsystem="event"、Runtime="runtime"(init.go:27-36 / runtime.go:37)pkg/metrics/scheduler.go:186 循环注册 10 个 Collector;其余注册点 scheduler.go:422 / queue.go:105 / runtime.go:243,注销 prometheus.Unregister (queue.go:123)。失败仅 log.Log(log.Metrics).Warn ⇒ 重复注册会静默丢指标。队列名被编进 subsystem:yunikorn_<队列名>_queue_container(queue.go:81 Subsystem: replaceStr)⇒ 每加一个队列多一个 metric family;yunikorn_queue_app / yunikorn_queue_resource 则用 ConstLabels{queue=...}k8shim/pkg/cmd/shim/main.go:54 → StartAllServicesWithLogger → startAllServicesWithParameters(pkg/entrypoint/entrypoint.go:78,实际代码 99-113)。metricsHistorySize != 0 时建 InternalMetricsHistory + NewInternalMetricsCollector(1 分钟 ticker,metrics_collector.go:43),默认 1440 = 24h × 1min,只存 totalAppsRunning / totalContainersRunningpkg/webservice/webservice.go:44 · 遍历 webRoutes,每条先被 loggingHandler 包裹再 router.Handler(Method, Pattern, handler)。40 = 25 条现役 /ws/v1(Cluster 4 + Scheduler 21)+ 13 条 /debug + 2 条 deprecated 重定向pkg/webservice/webservice.go:69-70 · Addr 硬编码 ":9080",ReadHeaderTimeout 10s,compressResponse 是全局唯一中间件。Helm 的 service.port 只改 Service/containerPort 声明(端口名 http1 / yunikorn-core),改了打不通;values.yaml:128 的 enableWebService gate 的是另一个容器 yunikorn-scheduler-web(http2 / 9889),与 9080 的 metrics 无关Prometheus 默认就发 Accept-Encoding: gzip(scrape_configs 的 enable_compression 默认 true)—— 这是触发缺陷的前提pkg/webservice/gzip.go:134 · 唯一豁免路径是 SSE 的 /ws/v1/events/stream;!clientAcceptsGzip(r)(判据 161-175)则 135-136 直通。压缩级别 gzip.BestSpeed(gzip.go:139)。引入方 YUNIKORN-2249(CHANGELOG:82,标题只说 "queue applications API",实现却落成全局中间件 —— 这正是它意外套上 /ws/v1/metrics 的原因)gzip.go:74-77 · d.buf.Write(b) 后 if d.buf.Len() >= minCompressionSize → switchToGzip()。minCompressionSize = 1400(gzip.go:37;注释里的 1500 只是 Ethernet MTU,v1.9.0 自己的测试注释也写错成 1500)。构造在 gzip.go:149,defer dw.finalize() 在 153。🔴 只覆写 WriteHeader(55) / Write(66),没覆写 Header() ⇒ handler 设的响应头直接落到底层 w,中间件看不见 —— 这是缺陷的结构性根因webservice.go:44-51 建链、53 loggingHandler 记 name/method/uri/duration(log.REST,Debug 级)pkg/webservice/handlers.go:1123 · metrics2.GetRuntimeMetrics().Collect() 在请求线程里同步读 runtime.MemStats(runtime.go:57-60、:71)。getMetrics 不调 writeHeaders(对比 handlers.go:188-197)⇒ /ws/v1/metrics 缺 Access-Control-Allow-Origin 等 4 个头(Content-Type 有,promhttp 用 expfmt.Negotiate 设)handlers.go:1124 · = InstrumentMetricHandler(prometheus.DefaultRegisterer, HandlerFor(prometheus.DefaultGatherer, HandlerOpts{}))(client_golang v1.23.2 promhttp/http.go:96-99);DisableCompression 默认 false(:146),offers {Identity, Gzip, Zstd}(:68-74);先设头后编码:rsp.Header().Set("Content-Encoding", encodingHeader)(:212-214),gz.Reset(rw) 直接包住传入的 writer(:481-484)。每次 scrape 都新建一个 Handler(靠 AlreadyRegisteredError 兜住)gzip.go:91 · Write(66-79)对 Content-Encoding 无任何检查;Set("Content-Encoding","gzip") 把已有值覆盖成同值(头仍是单值)、Add("Vary","Accept-Encoding"),然后 d.gz.Write(d.buf.Bytes()) 把 promhttp 已经 gzip 过的字节再压一次。更坏的变体:客户端发 Accept-Encoding: zstd 时 promhttp 设 Content-Encoding: zstd,这里的 Set 把它改写成 gzip ⇒ 头说 gzip、body 是 gzip(zstd(text))gzip.go:112-117 · defer 在 153 注册;d.useGzip 为真 ⇒ d.gz.Close() 把 gzip(gzip(text)) 冲上线路。若 promhttp 输出不足 1400B,finalize 走 !d.decided 分支原样写出 buffer,反而是正确的 —— 真实调度器 metrics 远超 1400B,所以实际必然踩中客户端按 Content-Encoding: gzip 只解一层,拿到的是二进制 gzip 流而非 OpenMetrics 文本 ⇒ 抓取解析失败。(未实测复现:无 K8s 环境。为什么 1.9.0 没测出来:handlers_test.go:957-964 的 TestMetricsNotEmpty 直接调 promhttp.Handler() 绕过 compressResponse 且不设 Accept-Encoding;5 个 gzip 测试全打 /ws/v1/clusters 或 events/stream)两层各压一次:内层 promhttp(client_golang promhttp/http.go:212-214 先设头再编码)、外层 compressResponse(gzip.go:86 Set 覆盖成同值 + 91 再压)。Content-Encoding 只有一个值 gzip ⇒ 任何客户端都只会解一层YuniKorn v1.9.0 全仓没有压缩开关(grep compression 只命中 gzip.go 的 minCompressionSize;k8shim constants.go:134 的 Compression 是 ConfigMap gzip+base64,无关)。旁路点是 gzip.go:134 的 || !clientAcceptsGzip(r) → 135-136 直通,判据函数 gzip.go:161-175。验证:curl -sH 'Accept-Encoding: gzip' localhost:9080/ws/v1/metrics | gunzip | file -passThrough 与 TestCompressResponseSelfEncodedHandler / -SmallBody / -PreservesStatus 在 v1.9.0 全仓 0 命中,只在 master:pkg/webservice/gzip.go:97 与 master:pkg/webservice/gzip_test.go:95/119/140。master 修复 commit 的注释逐字点名 promhttp("for example promhttp, which performs its own gzip content negotiation")。修复对应的 JIRA 号无法确认(depth-1 shallow clone),故不上图
这张图的一句话:v1.9.0 新加的全局 gzip 中间件不检查 handler 是否已自己压缩,而 /ws/v1/metrics 的 promhttp 会自己 gzip 并设 Content-Encoding —— 结果是「双层 gzip 体 + 单值 Content-Encoding」,任何客户端都解不开。
Ch.2 · 图解 — The gzip Bug32

⏱ 本页 1.6 分钟 · 主线 338 字 · 深潜层另有 984 字

这张图分三行读,中间那条虚线分割线是关键。 第一行是进程启动期,每项只做一次、不在抓取路径上,所以步序牌是灰的。 第二行是每次 scrape 请求进来,从左到右五步,橙牌 6 到 10。 第三行是响应回程,方向从右往左,橙牌 11 到 14 —— 缺陷发生在这一行。 左下角三层套盒是线路上真实的响应体;右下角绿框是规避,灰虚线框是上游修复。

第一行只挑两点。指标注册失败只打一条 Warn,不 fatal ⇒ 重复注册会静默丢指标。 最后那个盒子:端口 :9080 硬编码,外面包了全局唯一的一个中间件 compressResponse —— 「全局唯一」就是整个故事的起点。

第二行请求进来。Prometheus 默认就发 Accept-Encoding: gzip,这是前提。 然后是关键事实:/ws/v1/metrics 没有被豁免 —— 中间件只豁免 SSE 那条 /ws/v1/events/stream。 接着那个 writer 先缓冲,累到 1400 字节才决定压不压。 (口径要说清)是 1400,不是 1500;1500 只是注释里提的以太网 MTU, 连 v1.9.0 自己的测试注释都写错成 1500。

(指第三行标题那句话 —— 这是整页的钥匙) 根因不是「有人多压了一次」,而是这个 writer 只覆写了 WriteHeader 和 Write,没覆写 Header() ⇒ handler 设的响应头直接落到底层 writer,中间件看不见; 而 promhttp 恰好先设好 Content-Encoding 再编码。 两件事一撞,就是那条会动的橙色蚂蚁线,标签三个字:「又压一次」。

回程四步:11,promhttp 自己协商,压了第一层; 12,外层 switchToGzip 完全不检查 Content-Encoding, 把已是 gzip 的字节又压一层,还用 Set 把那个头覆盖成同一个值; 13,gz.Close() 封尾冲上线路; 14 是红框:客户端只解一层,拿到二进制 gzip 流而非 OpenMetrics 文本,抓取解析失败。 左下角那个套盒就是它:外层中间件的 gzip、里面 promhttp 的 gzip、最里面才是文本, 而头只有一个值 ⇒ 任何客户端都只会解一层。

两句诚实话。一、有阈值前提:只有 promhttp 输出≥ 1400 字节才触发, 真实 metrics 远超 1400,所以必然踩中。二、我们没有实测复现。 验证命令:curl -sH 'Accept-Encoding: gzip' localhost:9080/ws/v1/metrics | gunzip | file - —— 它要还说是 gzip compressed data,那就是它。

(指右下绿框,这是客户最需要的一句) v1.9.0 侧没有任何压缩开关,规避只能让抓取方别发 Accept-Encoding —— scrape_configs 下面写 enable_compression: false, 这个值默认是 true;用 ServiceMonitor 则是 spec.endpoints[].enableCompression: false,要求 Prometheus 不低于 v2.49.0。

灰虚线框请说清:上游 master 已加了 passThrough, handler 设过 Content-Encoding 就整段直通,但这修复不在 1.9.0 里; 修复的 JIRA 号我查不到,所以图上没写,我也不编。

下一页看另一条同样「不会报错」的链路:配置热加载。

Ch.2 · 它怎么工作 · 图解 · Hot Reload

ConfigMap 热加载:每一层失败都只记日志、保留旧配置 informer WATCH 推送 · resync=0 · 零轮询

① Kubernetes:写入前 ValidatingWebhook 校验(FailurePolicy=Ignore ⇒ fail-open)kubectl / 用户改 ConfigMapkube-apiserver配置的唯一存储Admission ControllerFailurePolicy=IgnorePOST /ws/v1/validate-confcore validateConf改 ConfigMap1拦 CREATE/UPDATE2POST 校验请求3allowed / reason只认两个名字常量写死,第三个不生效0yunikorn-defaultsindex 0 · helm 创建1yunikorn-configsindex 1 · 用户自建index 1 覆盖 index 0不可达 / 非 2xx / 解析失败 →assuming configmap is valid(放行)唯一真拒绝:Configmap validation failed, aborting② k8shim(scheduler Pod)ConfigMap InformerWATCH,resync=0ContextsetConfigMap(index)SchedulerConfFlattenConfigMaps → 解析handleNonReloadableConfig15 项若变则回退 + WARN分派 index 0/15扁平合并 + 解析6内嵌自调用7解析失败 → Unable to update configmap, ignoring changes(旧配置原样保留)4WATCH 事件(resync=0,无轮询)③ yunikorn-coreClusterContextprocessRMConfigUpdateEventPartitionContextupdatePartitionDetailsGET /ws/v1/config读回规范化配置8RMConfigUpdateEvent + Result chan(同步阻塞)干跑后就地更新9验证读回checksum 相同 → 短路ApplyConf → updateQueues 递归yaml.Marshal 后的对象,非原文配置改了没生效?· 全程 WATCH 推送,无轮询· 每层失败只记日志· 旧配置原样保留· 不崩、不重试、Pod 仍 Running· 查日志 + GET /ws/v1/config 读回值kubectl edit cm yunikorn-configs -n yunikorn(或 yunikorn-defaults)ValidatingWebhookConfiguration: yunikorn-admission-controller-validations;无 NamespaceSelector ⇒ rule 覆盖全集群 configmaps,namespace 过滤在 validateConfigMap 首行做webhook 名 admission-webhook.yunikorn.validate-conf,Operations{Create,Update} / Resources{configmaps}(k8shim/pkg/admission/webhook_manager.go:596,FailurePolicy=Ignore :600)。唯一真拒绝路径:Configmap validation failed, aborting(admission_controller.go:612)core/pkg/webservice/handlers.go:170 validateConf → LoadSchedulerConfigFromByteArray 解析+校验,回 ValidateConfResponse{allowed, reason}(dao/config_info.go:23)。只有 responseData.Allowed == false 才真正拒绝写入const DefaultConfigMapName = "yunikorn-defaults"(k8shim/pkg/common/constants/constants.go:68);helm chart 只渲染这一份,带 annotation "helm.sh/resource-policy": keepconst ConfigMapName = "yunikorn-configs"(k8shim/pkg/common/constants/constants.go:67);不在 helm chart 里,用户自建。两份都缺不报错(GetConfigMap 吞 IsNotFound 返回 nil)FlattenConfigMaps 顺序遍历 []*v1.ConfigMap 并 result[k] = v ⇒ index 1 的同名 key 覆盖 index 0(k8shim/pkg/conf/schedulerconf.go:508)独立的 namespace 级 factory:informers.NewSharedInformerFactoryWithOptions(clientSet, 0, informers.WithNamespace(configs.Namespace))(k8shim/pkg/client/apifactory.go:95);注册 handler 时 resyncPeriod 也传 0 ⇒ 源码里没有任何配置轮询间隔filterConfigMaps(context.go:515)双条件放行(两个名字 + 本 namespace)→ addConfigMaps(:527) / updateConfigMaps(:542) / deleteConfigMaps → triggerReloadConfig(index) → setConfigMap(index)(:657)。0/1 索引在 scheduler 与 admission 两处各自写死,没有共享常量UpdateConfigMaps(k8shim/pkg/conf/schedulerconf.go:170):CreateDefaultConfig 铺默认值 → FlattenConfigMaps 扁平合并 → parseConfig → handleNonReloadableConfig → SetSchedulerConf。队列配置只认 <policyGroup>.yaml(默认 queues.yaml),其余 key 作为 extraConfig 送 coreschedulerconf.go:210-226 共 15 个 checkNonReloadableXxx:CMSvcClusterID / CMSvcPolicyGroup / CMSvcSchedulingInterval / CMSvcVolumeBindTimeout / CMSvcEventChannelCapacity / CMSvcDispatchTimeout / CMKubeQPS / CMKubeBurst / CMSvcDisableGangScheduling / CMSvcNodeInstanceTypeNodeLabelKey / AMFilteringGenerateUniqueAppIds / CMSvcPlaceholderRunAsUser / CMSvcPlaceholderRunAsGroup / CMSvcPlaceholderFSGroup / CMSvcPlaceholderImage。不同则 *new = *old 改回去并打 WARN:ignoring non-reloadable configuration change (restart required to update)core/pkg/scheduler/context.go:205。先 configs.SetConfigMap(ExtraConfig)(:219,在短路之前 ⇒ extra 总会更新)→ LoadSchedulerConfigFromByteArray 解析+Validate+sha256 checksum → :234 if conf.Checksum == oldConf.Checksum 直接返回成功。校验失败只回 Result{Succeeded:false},shim 打 reload configuration failed,调度器不崩updateSchedulerConfig(context.go:370)先 newPartitionContext(p, rmID, nil, true) 干跑校验,通过后才 part.updatePartitionDetails(p)(partition.go:173):UpdateRules → root.ApplyConf → updateQueues(partition.go:229) 递归 → 未访问的子队列 MarkQueueForRemoval()(标记,不是立即删)。队列树就地更新,不重建getClusterConfig(core/pkg/webservice/handlers.go:566)返回 yaml.Marshal(ConfigDAOInfo),默认 application/x-yaml; charset=UTF-8,Accept: application/json 才给 JSON。子队列键是 queues,不是 children —— children 只属 PartitionQueueDAOInfo(dao/queue_info.go:43),服务 /ws/v1/partition/:partition/queues(routes.go:90)。maxapplications / adminacl / submitacl / childtemplate / deadlockdetectionenabled / deadlocktimeoutseconds 是 YAML 默认输出的小写键;JSON 时是 CamelCaseContext 组装 si.UpdateConfigurationRequest{rmID, policyGroup, config, extraConfig}(scheduler-interface/si.proto:415,reserved "configs")→ RMProxy.UpdateConfiguration(core/pkg/scheduler/rmproxy.go:321-339):建 chan *rmevent.Result → HandleEvent → result := <-c,同步阻塞等结果唯一会 Fatal 退出的是进程启动时的 bootstrap(k8shim main.go:45 / :50);热加载失败没有任何 retry,resync=0 也不会有周期性 resync 兜底 ⇒ 恢复只能靠下一次 ConfigMap 变更或重启
一句话:每一层失败都只记日志 + 保留旧配置 ⇒ 「改了没生效」只能查日志与 GET /ws/v1/config。
Ch.2 · 图解 — Hot Reload33

⏱ 本页 2.4 分钟 · 主线 506 字 · 深潜层另有 856 字

这张图三条横带、三个层,一共 9 个步序牌。 最上面是 Kubernetes 这侧:改 ConfigMap、apiserver 拦下、送去校验、再放行 —— 标题写着 FailurePolicy=Ignore,也就是 fail-open。 中间那条带是 k8shim,最下面是 yunikorn-core。 连接上两条带的是那条会动的橙色蚂蚁线「WATCH 事件」 —— 本页唯一动画。 左下角橙框最后念。

这条带的第一个事实就能救人:它只认两个 ConfigMap 名字 —— yunikorn-defaults 是 index 0,helm 渲染的就是这份; yunikorn-configs 是 index 1,helm 不管,给你自己建。 中间那条橙色短箭头是「index 1 覆盖 index 0」,同名 key 覆盖 ⇒ 你自建那份赢。 这个 0 和 1 在源码里写死了两遍 ⇒ 加第三个 ConfigMap,不改代码办不到。

(指这条带右侧的红字)别以为准入校验能拦住坏配置。 FailurePolicy 是 Ignore,代码里还有四条 "assuming configmap is valid" —— 调度器不可达、非 2xx、解析失败,一律放行。 唯一真拒绝的路径日志是 Configmap validation failed, aborting。

(指蚂蚁线)这一跳值得单独说: informer 的 resync 是 0,源码里没有任何配置轮询间隔 —— 变更是 apiserver 推给它的。快,但这次推送失败了没有周期性兜底。

中间这条带三步:按名字分派 index、铺默认值、扁平合并、解析。 队列配置只认 queues.yaml 那个 key,其余作为 extra 送去 core。 最右那个虚线框是嵌在里面的自调用,不是新一步: 15 个配置项逐个比对,你改了它就把值改回去再打一条 WARN。 它不是拒绝整份配置,是把这 15 项悄悄回退,其他项照常生效。 下面那行红字:解析失败只打一条 Unable to update configmap, ignoring changes。

最下面是 core。第一个盒子是 checksum 短路:跟旧的 sha256 一样就直接返回成功; 而 extra 配置的写入在短路判断之前 ⇒ 队列 YAML 没变时 extra 照样更新。 第二个盒子先做干跑:拿新配置构造一个临时 partition 校验一遍,通过了才落到真身上, 而且就地更新、不重建:更新放置规则、逐级 apply、递归走队列树, 这轮没访问到的子队列只是被标记待删,不是立刻删。

第三个盒子是虚线的,因为它是旁路、不占步号:GET /ws/v1/config。 它返回的不是你写的原文,是内存里已校验对象重新序列化出来的 YAML。 (一个流行说法是错的)这个端点里子队列的键仍然是 queues, 不会变成 children —— children 属于另一个端点 /ws/v1/partition/:partition/queues。

(念左下角橙框) 每层失败只记日志;旧配置原样保留;不崩、不重试、pod 状态永远是 Running ⇒ 只能查日志加 GET /ws/v1/config 的读回值。

唯一会让进程退出的是启动时的 bootstrap 加载;热加载失败没有任何 retry, 恢复只能靠下一次 ConfigMap 变更或者重启 —— 所以「看 pod 状态判断配置生效没有」在这里完全失效。

方框悬停有源码位置。第二章到这里结束,下一章回到现实: 在 EKS 上装出来到底是什么,以及它跟 Karpenter 的协同靠一个未成文的魔法字符串。

03
On Amazon EKS
在 AWS 上怎么用
AWS 是唯一把 YuniKorn 写进产品文档的公有云。但它是「官方记录、自行运维」——而与 Karpenter 的协同靠的是一个未成文的魔法字符串。
AWS 的官方立场 EKS 版本矩阵 Karpenter 协同 生态集成矩阵
Apache YuniKorn 技术深潜
34

⏱ 本页 1.1 分钟 · 主线 230 字 · 深潜层另有 256 字

进第三章。这一章对在座各位是最直接有用的,理由很简单:你们的集群跑在 AWS 上。 前两章讲「它是什么、怎么工作」,这一章讲「在你们的环境里它到底会怎么样」。

核心一句我先放在这里: YuniKorn 在 AWS 上有官方文档背书,和 Volcano 并列;但它是「官方记录、自行运维」—— 没有 EKS add-on,没有托管版本,运维全在你身上。 (隔页副标题那句请照念)而它跟 Karpenter 的协同,靠的是一个未成文的魔法字符串。

(指着下面四个 chip) 四块内容:一,AWS 的官方立场 —— 给了什么,更重要的是没给什么; 二,EKS 版本矩阵 —— 有一个现存缺口,而且会在每个 EKS 小版本上重演; 三,Karpenter 协同的机制真相,这是全章、可能也是全场技术含量最高的一页; 四,生态集成矩阵 —— 哪些组件真的支持它。

(这一段涉及分寸,建议照念) 提前说明:这一章会点出 AWS 自己两份官方材料里的两处缺陷 —— 一处是官方教程的参数名少了两个字母,一处是参考架构里一个超时参数方向配反了,两处都有完整证据链。 我的目的不是挑错,我自己就是 AWS 的人,挑错对我没好处。 目的是说明一件事:照抄参考架构也需要自己核实。

我们先看 AWS 给了什么、没给什么 —— 这一页是你们开选型会时最有用的一张图。

Ch.3 · 在 AWS 上怎么用 · Vendor Position

AWS 是唯一把它写进产品文档的公有云 但是「官方记录、自行运维」

云 / 平台官方推荐的批调度方案官方文档提及 YuniKorn托管组件
AWS EKS / EMR on EKSYuniKorn 与 Volcano 并列,各有一篇官方 tutorial✅ 有专门教程页❌ 非 add-on,仍装社区 Helm chart
阿里云 ACK自研增强 kube-scheduler(内建 Gang + Capacity)⚠️ 仅「计算巢」货架,不在 ACK 组件中心⚠️ 中立货架,非产品团队背书
腾讯云 TKE自研 Extender 系插件❌ 未找到❌
华为云 CCEVolcano(一等公民;xGPU 虚拟化硬依赖 Volcano ≥1.10.5)❌ 未找到❌
火山引擎 VKE自研增强调度器 + Kueue❌ 未找到❌
Google GKEKueue(拓扑感知调度 TAS 直接建在其 CRD 上)❌ site:cloud.google.com yunikorn 返回 0 条❌
Azure AKSKueue(≥4 篇官方文档)❌ 未找到❌
Red Hat OpenShift无支持声明⚠️ 仅 YuniKorn 自己的本地开发指南❌ 无 Operator、无 UBI 镜像
Cloudera CDP / CDEYuniKorn(唯一把它做成商业产品核心的厂商)✅✅ CDE 由 YuniKorn 驱动
AWS 给了什么:EMR on EKS 官方教程(Spark Operator + spark-submit 两条路径)、 AWS Big Data 博客、aws-samples 示例仓库、awslabs/data-on-eks 参考架构(无条件安装 YuniKorn)。
AWS 没给什么:❌ 不是 EKS add-on ❌ 无托管版本 ❌ 无支持 SLA ❌ 从未发布任何 YuniKorn 的性能数字 ❌ 官方教程未覆盖 StartJobRun API 路径。
三阵营看清谁在推: YuniKorn = Cloudera(娘家)+ AWS;Volcano = 华为 + CNCF + Spark 主干内建; Kueue = Google + Microsoft + 字节 + K8s SIG 官方子项目(动能最强)。
Ch.3 · 在 AWS 上怎么用 — AWS 的官方立场35

⏱ 本页 1.6 分钟 · 主线 342 字 · 深潜层另有 1448 字

这一页建议单独截出来带回去。核心一句: 在 AWS 上,YuniKorn 是有官方文档背书的一等选项;在其他任何云上,你是自带方案。 标题后半句也要说:「官方记录、自行运维」 —— documented but self-managed,有文档,没托管。

(指着第一行,这是整页的锚) 第一行,AWS EKS 和 EMR on EKS。给的是「YuniKorn 与 Volcano 并列」—— 两家各有一篇官方 tutorial,在 EMR on EKS 开发指南里是同一个目录下的两页。 这意味着在 AWS 上「选 YuniKorn 还是 Volcano」是一个真实的技术选择, 不是「哪个被支持」的问题 —— 两个都被支持。 第三列有专门教程页;但第四列是个叉:它不是 EKS add-on,你装的还是社区 Helm chart。

中间四行是中国的云,快一点过,但每行结论不一样。 阿里云 ACK 用的是自研增强 kube-scheduler,Gang 和 Capacity 都内建;YuniKorn 只在 「计算巢」货架上,不在 ACK 组件中心里 —— 计算巢是中立货架,不代表产品团队背书, 所以第四列我给的是一个黄色的警告,不是勾。 腾讯云 TKE 是自研 Extender 系插件。 华为云 CCE 是Volcano 的主场,有一条很硬的证据: 它的 xGPU 虚拟化硬依赖 Volcano 1.10.5 以上 —— 硬依赖,不是推荐。 火山引擎 VKE 是自研增强调度器加 Kueue。

(这一句把这四行的后两列一次交代完,不要漏) 这四行里,除了阿里云那个黄色警告,腾讯、华为、火山这三行的第三列和第四列全是叉 —— 意思是:官方文档里搜不到 YuniKorn,也没有任何托管组件。

Google GKE 和 Azure AKS 这两行答案是同一个:Kueue。 GKE 的拓扑感知调度 TAS 直接建在 Kueue 的 CRD 上,这是地基级绑定; AKS 那边 Kueue 至少有四篇官方文档。 而这两行的第三列同样是叉:两家官方文档都没提过 YuniKorn,也都没有托管组件。 (GKE 那一格值得念)我用的判据是 site:cloud.google.com yunikorn 返回 0 条。零条。

OpenShift 那一行有一条决定性证据。 Red Hat 没有任何支持声明;YuniKorn 自己有一个 OpenShift 页面,但那是本地开发指南。 根因是:JIRA YUNIKORN-354「把基础镜像改成 UBI」= Closed / Won't Fix,2020 年 8 月。 镜像不是 UBI 就走不通 Red Hat 认证流程 —— 这就是 OperatorHub 上至今没有它的根因。 (说重)客户在 OpenShift 上又要厂商支持,这是硬拦路虎。

(指着最后一行,这一行是整张表的对照点) 最后一行,Cloudera 的 CDP 和 CDE,这是娘家 —— 唯一把 YuniKorn 做成商业产品核心的厂商。 第二列写的就是 YuniKorn 本身,第三列有官方文档,第四列是勾:CDE 这个产品就是它驱动的。 整张表九行,只有这一行的后三列全是绿的。

左边「AWS 给了什么」:EMR on EKS 官方教程,覆盖 Spark Operator 和 spark-submit 两条路径;一篇 AWS Big Data 博客; aws-samples 示例仓库;还有 awslabs/data-on-eks 参考架构 —— 注意,它是无条件安装 YuniKorn 的。

(中间这个框要主动说,不要等被问) 「AWS 没给什么」:不是 add-on、无托管版本、无支持 SLA,加上一条我每次都主动说的: AWS 从未发布过任何 YuniKorn 的性能数字。 那些著名的「5.37 倍更快、成本降 61%」是 EMR 的 Spark 运行时对比开源 Spark,与调度器无关 —— 说成 YuniKorn 的效果,FinOps 审阅者一定抓到你。 正确口径:EMR 运行时买的是查询速度,YuniKorn 买的是排队、原子性和公平性,而第二样你必须自己测。 最后一条:官方教程没覆盖 StartJobRun API 这条路径。

右边这个框是这一页的落点:看清三个阵营谁在推。 YuniKorn 是 Cloudera 加 AWS —— 一个娘家,一个唯一把它写进产品文档的公有云。 Volcano 是华为加 CNCF,而且 Spark 主干里内建了它。 Kueue 是 Google 加 Microsoft 加字节,而且它是 Kubernetes SIG 的官方子项目。 (这句要说出来)三个阵营里动能最强的是 Kueue,而且还在加速。

(这个追问几乎一定会来) 「既然 Kueue 动能最强,我们是不是该等 Kueue?」—— 好问题,第四章的选型对比正面回答它,这里不展开。 (有中国区业务补一句)在中国的云上选 YuniKorn,等于放弃厂商工单支持,只能回 Apache 社区。

下一页看版本 —— 那里有一个缺口,是你们现在就需要知道的。

Ch.3 · 在 AWS 上怎么用 · 图解 · Topology

在 EKS 上装出来到底是什么:2 个 Deployment、2 个 Pod、3 个容器 无 DaemonSet · 硬编码 replicas: 1 · 零 leader election

EKS 托管控制平面(AWS 托管)namespace: yunikornEC2 工作节点 —— kubelet / 业务 Pod 是 K8s 机制,YuniKorn 源码无此逻辑APIkube-apiserver唯一状态源 · AWS 托管集群级 · AC 运行时自建(不在 chart 里)yunikorn-admission-controller-mutationspatch /spec/schedulerName · Ignoreyunikorn-admission-controller-validations/validate-conf · IgnoreK8sdefault-scheduler仍在跑,管非 YK PodIgnore ⇒ 回落failurePolicy: Ignore ×2AC 挂了 → Pod 照样创建成功只是不再被打 schedulerName⇒ 静默滑回 default-scheduler队列 / 配额 / gang 全部失效Helm chart(14 文件 / 10 模板)① pre-install hook 建 SA/Role/Binding weight 0→1→2 —— 权限先于 workload② 建 2 个 Deployment · 2 Pod · 3 容器 0 个 DaemonSet / StatefulSet / Job借用内置 ClusterRole:system:kube-schedulersystem:volume-scheduleryunikorn-admission-controller-service443 → webhook-api 9089yunikorn-admission-controllerDeployment · 1 副本 · hostNetwork4webhook-api 9089yunikorn-servicehttp1 9080 · http2 9889http1 9080 上的 REST(节选)/ws/v1/scheduler/healthcheck/ws/v1/metrics · /ws/v1/config/ws/v1/validate-confyunikorn-schedulerDeployment · replicas: 1(字面量)· 无 leader election9080 / 9889Pod ×1 · 2 容器 · 无任何探针YKyunikorn-scheduler-k8score + shim 同一进程,不走网络5UIyunikorn-scheduler-webPROXY_URL → 127.0.0.1:9080 · LISTEN :9889yunikorn-configs外部创建 · Helm 完全忽略3yunikorn-defaultsHelm 渲染 · policy: keep覆盖admission-controller-secretsAC 运行时自签 CA 并 update7POST /mutate8patch /spec/schedulerName故障域:scheduler 挂掉 ≠ 业务中断⑥ 重启后 InitializeState() 8 步重建状态 —— 已绑定 Pod 按「既成分配」恢复(Step 8: Finalize pods)新 Pod 停在 Pending,运行中 Pod 归 kubelet,零中断;scheduler 无任何探针,不会被 K8s 自动重启EC2kubelet已绑定 Pod 归它管Pod业务 Pod被打 schedulerName写 v1.Binding9拉起容器10唯一状态源。scheduler 的 informer 与 Bind 都走 in-cluster :443(k8shim/pkg/shim/scheduler.go:70;k8shim/pkg/client/kubeclient.go:117-126)AC 用自己的 ClusterRole 在运行时 MutatingWebhookConfigurations().Create()(webhook_manager.go:339/:366;cmd/admissioncontroller/main.go:132 InstallWebhooks)。failurePolicy: Ignore(:615,:636);覆盖 3 apiGroup × 7 资源(:633-634)。范围 = 除 ^kube-system$ 外全部命名空间(am_conf.go:71-72)ValidatingWebhookConfigurations().Create()(webhook_manager.go:266/:293);failurePolicy: Ignore(:580,:600)。逐字 webhook 名:admission-webhook.yunikorn.mutate-pods / admission-webhook.yunikorn.validate-confEKS 自带调度器,YuniKorn 装上后它并没有被停掉:只要 Pod 上没有 schedulerName: yunikorn,就由它调度 —— 队列/配额/gang 全部不生效两个 webhook 的 failurePolicy 都是 Ignore:validating webhook_manager.go:580,600;mutating :615,636。AC 不可用时 apiserver 直接放行,Pod 创建成功但不带 schedulerName: yunikorn,于是安静地由 default-scheduler 调度 —— 没有任何报错,只有队列/配额/gang 失效chart 共 14 个文件,templates/ 下 10 个(9 个 manifest + _helpers.tpl)。RBAC 走 helm.sh/hook: pre-install,pre-upgrade,helm.sh/hook-weight 0→1→2(rbac.yaml:24-25,33-34,74-75;admission-controller-rbac.yaml:25-26,33-34,70-71)。scheduler 借用 system:kube-scheduler 与 system:volume-scheduler(rbac.yaml:99,116);SA 模板无 annotations 字段 ⇒ 要挂 IRSA 必须自己 patch SAadmission-controller-service.yaml:22 name、:31 port: 443、:32 targetPort: webhook-api、:33-36 selector(app=yunikorn, component=yunikorn-admission-controller)。ClusterIP。webhook clientConfig 用 ServiceReference 而非 IP(am_conf.go:67)admission-controller-deployment.yaml:33 副本数 = .Values.admissionController.replicaCount。hostNetwork 默认 true(values.yaml:43)⇒ Pod IP = Node IP,且 :29-32 用 strategy.type: Recreate。🔴 启动顺序:main.go:122 LoadCACertificates → :127 GenerateServerCertificate → :132 InstallWebhooks(注册 webhook)→ 之后才 :92 webhook.Startup 起 9089 HTTPS ⇒ 注册早于监听就绪,这个启动窗口靠 failurePolicy: Ignore 兜底。镜像 apache/yunikorn:admission-1.9.0service.yaml:29 ClusterIP;port 9080 → targetPort http1、port 9889 → targetPort http2(values.yaml:76-79)。selector: app=yunikorn, component=yunikorn-scheduler。REST(routes.go):/ws/v1/metrics /ws/v1/config /ws/v1/validate-conf /ws/v1/partitions /ws/v1/partition/:partition/queues /ws/v1/partition/:partition/nodes /ws/v1/events/stream /ws/v1/scheduler/healthcheck /ws/v1/fullstatedump /ws/v1/stackdeployment.yaml:31 replicas: 1 是字面量,不是 .Values.replicaCount —— 副本数无法通过 values 调整。全仓库 grep leaderelect|leader election|LeaseLock 零命中 ⇒ 单副本是设计约束,不是保守默认值:手动 scale 到 2 会得到两个都在主动调度、彼此不知情的 scheduler(各自 in-memory 队列与节点视图)→ 双重分配 / 超卖scheduler 容器确实没有任何探针(deployment.yaml:82-136 只有 ports/env/resources/securityContext)⇒ 进程僵死不会被 K8s 自动重启;对比 AC 有 startupProbe(:121)+readinessProbe(:128)。v1.9.0 已彻底删除 plugin mode(Makefile:548 只剩 image: sched_image adm_image;YUNIKORN-3210 / YUNIKORN-3273)⇒ 只有 standard mode 可画cmd/shim/main.go:54 entrypoint.StartAllServicesWithLogger()(yunikorn-core 静态链接进 shim 二进制)→ entrypoint.go:82-83 RMProxy + Scheduler、:108-112 REST 硬编码 :9080。启动前先 main.go:43 LoadBootstrapConfigMaps → :48 UpdateConfigMaps。镜像 apache/yunikorn:scheduler-1.9.0web/pkg/cmd/web/main.go:38 PROXY_URL 默认 http://127.0.0.1:9080、LISTEN_ADDRESS 默认 :9889。它是 scheduler Pod 内的 sidecar 容器(deployment.yaml:112-118),不是独立 Deployment,由 enableWebService 控制。镜像 apache/yunikorn:web-1.9.0constants.go:67 ConfigMapName="yunikorn-configs"。chart README:126 原文:yunikorn-configs is entirely ignored by Helm —— 它由外部创建,运行时作为 yunikorn-defaults 的 override。shim main.go:43 LoadBootstrapConfigMaps → :48 UpdateConfigMaps 都在 :54 StartAllServicesWithLogger 之前;AC main.go:56 同理 ⇒ 读配置是最早发生的事constants.go:68 DefaultConfigMapName="yunikorn-defaults"。yunikorn-defaults.yaml:20 name、:27 "helm.sh/resource-policy": keep ⇒ helm uninstall 后该 ConfigMap 残留(未实测 uninstall 行为)admission-controller-secrets.yaml:22 name、:24 type: Opaque —— chart 只建一个空 Secret,没有 data 段。CA 由 AC 进程运行时生成并写回(webhook_manager.go:739 Secrets(namespace).Update;cmd/admissioncontroller/main.go:122 LoadCACertificates)。内含 cacert1.pem / cacert2.pem / cakey1.pem / cakey2.pem,挂到 /run/secrets/webhook⑦ 用户建 Pod → kube-apiserver 按 mutating webhook configuration 调 yunikorn-admission-controller-service:443 → 容器 9089 的 /mutate(cmd/admissioncontroller/main.go:44 mutateURL、:153 mux.HandleFunc(mutateURL, wh.ac.Serve))。⑧ AC 回 JSON Patch op=add path=/spec/schedulerName value="yunikorn"(admission_controller.go:370-377;constants.go:69 SchedulerName)⑥ InitializeState() 是 8 步不是 7 步(context.go:1357-1432):Step 1 priority classes → Step 2 register nodes(初始 disabled)→ Step 3 register pods(按创建顺序;已落在存量节点上的 pod 视为 allocations 而非 asks)→ … → Step 8 finalize pods(context.go:1423-1429 ctx.finalizePods(pods))。⇒ 故障恢复靠重建状态,不是热备🔴 K8s 机制推论,YuniKorn 源码里没有任何 kubelet 代码。shim 一次性写 v1.Binding 后即脱手,不在数据路径上(k8shim/pkg/client/kubeclient.go:117-126)默认范围 = 除 ^kube-system$ 之外的全部命名空间(am_conf.go:71-72;可用 admissionController.filtering.processNamespaces / bypassNamespaces 或 yunikorn.apache.org/namespace.enableYuniKorn 调整)
这张图的一句话:它只是 2 个 Deployment、共 2 个 Pod、3 个容器 —— 没有 DaemonSet。scheduler 是硬编码 replicas: 1 且全仓库零 leader election,所以它不能扩副本;但它挂掉只会让新 pod 堆在 Pending,已写入的绑定不受影响。
Ch.3 · 图解 — Topology36

⏱ 本页 1.7 分钟 · 主线 356 字 · 深潜层另有 1220 字

(先教怎么看图) 这张图横着五个区,竖着按编号 1 到 10 走一遍。最上面是 EKS 托管控制平面, apiserver 和仍然在跑的 default-scheduler —— 这两个不是我们装的。 第二个区是集群级对象,标注写着「非 Helm」,一会儿解释。 第三个区是 yunikorn 命名空间;第四个区是套在里面的小框, scheduler 这个 Pod 的内部;最下面是 EC2 工作节点。

先给结论:整张图只有 2 个 Deployment、2 个 Pod、3 个容器,没有 DaemonSet。 三个容器是 AC 里 1 个、scheduler 里 2 个 —— 本体加一个 UI 边车。 很多人一听「调度器」就按节点数估成本 —— 不用,它就是两个 Pod。

第 1 步,Helm 先建 ServiceAccount、Role、Binding —— 权限先于工作负载, 顺序反了就是一片 Forbidden。第 2 步才建那 2 个 Deployment。 请记住:scheduler 的 replicas: 1 是字面量写死在模板里的, values.yaml 里没有对应参数;而 leaderelect、 LeaseLock 这些词全仓库零命中。 所以「不能扩副本」不是我们的建议,是它的物理约束。

第 3 步,两个进程各自读 ConfigMap,yunikorn-configs 覆盖 yunikorn-defaults —— chart README 原话是 Helm 完全不管前者。 以后谁说「改了配置没生效」,先看改的是不是会被覆盖的那一份。

第 4 步是 AC 的启动序列,最容易被忽略。它运行时自己生成 CA 写进 Secret, 再用自己的权限把两个 webhook configuration 写进 API Server —— 就是第二个区那两个对象, 它们不在 chart 里,卸载和排障要单独想着。 而注册 webhook 发生在 9089 开始监听之前,所以有个启动窗口: 靠 failurePolicy: Ignore 兜住,代价是那段时间的 Pod 悄悄不被改写。

第 5、6 步是 scheduler 侧,和第 7 步没有因果,两个 Deployment 并行启动。 第 5 步 shim 在同一个进程内把 core 拉起来:一个进程、一个容器,不走网络。 第 6 步重建状态是 8 步 —— 上游写 7 步,复核数出来 8 步。 它第 3 步的注释最值得念:已经和节点关联的 Pod,被当成已有分配、不是新请求 —— 这就是「重启后已跑着的作业不受影响」的依据。

第 7、8 步是准入,下一页整页展开。第 9 步是关键动作:shim 写 v1.Binding, 一次性写入,写完 Pod 就归 kubelet,scheduler 不在数据路径上。 第 10 步 kubelet 拉起容器,图上标了这是 Kubernetes 的机制、YuniKorn 源码里没这段。 还有一根反向箭头:AC 打 /ws/v1/validate-conf 问 scheduler 配置合法吗, 问不到就「假定它合法」放过 —— 又一个 fail-open。

两条运维事实。scheduler 容器没有任何探针,AC 反而有两个。 hostNetwork 默认值是反的:scheduler false、AC true。 由此两条推论 —— 我明确说是推论:节点安全组要放通控制平面到节点的 9089; AC 用 Recreate,升级期间有完全不可用的窗口。

(对着底部那个框念) scheduler 挂掉,新 Pod 堆在 Pending,已经绑定的 Pod 归 kubelet,业务零中断。 但真正安静的风险在 admission controller —— 两个 webhook 都是 Ignore, 它挂了 Pod 照样创建成功,只是不再被打上 schedulerName: yunikorn, 于是安静地滑回 default-scheduler,队列、配额、gang 全部失效,而没人报错。 图上每个方框悬停都能看到源码位置,会后自己核。

下一页把那条改写路径整页拆开 —— 它有一个几乎所有人都答错的问题: 我在 Pod 里显式写 default-scheduler,能不能绕开 YuniKorn?

Ch.3 · 在 AWS 上怎么用 · 图解 · Admission

schedulerName 改写路径:为什么写 default-scheduler 也没用 含唯一会真正拒绝 Pod 的那条分支

① K8s 控制面 —— rules 命中就调用② AC HTTP 入口(TLS)③ AC 内部:mutate() → processPod() 判据链(Pod CREATE)④ 降级支路 —— AC 不可达时 failurePolicy: Ignore 让 Pod 照样入库:安静地错,不是大声地停kubectl / Controller提交 Pod 或工作负载kube-apiserver匹配 7 资源 × {CREATE, UPDATE}admission-webhook.yunikorn.mutate-podsfailurePolicy: Ignore ‧ 无 selector ⇒ 全集群POST /mutate :9089只收 application/jsonServe() 三道前置校验400 / 415 / 4041234TLS 443 → 解码 AdmissionReview → mutate()5mutate() → processPod()CREATE 的 Pod 走这里checkUserInfoAnnotation()无权设 user.info → 拒绝label app=yunikorn ?出口一:自身 Pod 放行shouldProcessNamespace()出口二:唯一 namespace 级豁免updateSchedulerName()无条件写 yunikorn有权非自身TRUE6789改写是无条件的函数签名里没有 pod 参数写 default-scheduler 也白写allowed = falseAC 唯一会拒绝 Pod 的业务路径patch 为空 · 原样放行出口一 app=yunikorn ‧ 出口二 bypassing namespaceadd /spec/schedulerNameadd 覆盖已有值(RFC 6902)无权 ⇒ 拒绝app=yunikornFALSE10shouldLabelNamespace():管 /metadata/labels 与 /metadata/annotations(else 分支写 yunikorn.apache.org/ignore-application),不影响 schedulerNamekube-apiserverAC 不可达 / 超时 10s只记 warning 就入库用户侧无任何错误default-schedulerk8s 默认值,k8shim 无此常量YuniKorn / foreign pod管或不管的分岔口不接管接管11任何创建者:kubectl、Deployment/Job 控制器、Spark Operator 等webhook_manager.go:631-635 operations=[CREATE, UPDATE];apiGroups=["", "apps", "batch"];apiVersions=[v1];resources=[pods, deployments, replicasets, statefulsets, daemonsets, jobs, cronjobs]。AC 内部只有 Pod 走 UPDATE 分支AC 启动时自己把 MutatingWebhookConfiguration yunikorn-admission-controller-mutations 写进 API Server(helm 不发此对象):ignore := v1.Ignore(webhook_manager.go:615)、FailurePolicy: &ignore(:636)、sideEffects: None、admissionReviewVersions: ["v1"]。checkMutatingWebhook:523 会把人工改成 Fail 的配置改回 Ignore。grep NamespaceSelector/ObjectSelector 在 k8shim/pkg/ 零命中 ⇒ 拦截全集群yunikorn-admission-controller-service 443 → targetPort webhook-api → 容器 9089(main.go:42);mux 只注册 /health、/mutate、/validate-conf(main.go:152-154,/mutate 在 :153);TLS 最低 1.2、优先 h2admission_controller.go:637-657 ① body 空或读失败 → 400 "empty or invalid body"(:637-641)② Content-Type != application/json → 415(:645-650)③ urlPath ∉ {/mutate, /validate-conf} → 404 "request is neither mutation nor validation"(:652-657)mutate() admission_controller.go:141:空 namespace 归一为字面量 "default";UPDATE + Pod → processPodUpdate(只拒绝篡改 yunikorn.apache.org/user.info,不改 schedulerName);UPDATE + 其余 6 类资源直接放行;CREATE + 非 Pod → processWorkloadadmission_controller.go:169-175(实现 :349-368),位置在 app=yunikorn 检查之前。提交者不在 accessControl.systemUsers / externalUsers / externalGroups 允许范围内却设置了 yunikorn.apache.org/user.info → allowed=false。这是 Pod CREATE 唯一会被 AC 拒绝的业务路径(另一条是 json.Unmarshal 失败 :162-165)。反之若未设且 bypassAuth=false,AC 会替它补上 user-info patch(:177-184)utils.GetPodLabelValue(&pod, constants.LabelApp) == "yunikorn" → log "ignore yunikorn pod"、allowed=true、patch 为空(admission_controller.go:186-191)。只读 pod.Labels,不看 annotationadmission_controller.go:539 三级判据:① namespace annotation yunikorn.apache.org/namespace.enableYuniKorn 三态 —— 只有字面量 "true" 算 TRUE,"True"/"yes" 等任何其它值算 FALSE(namespace_cache.go:163-175)② admissionController.filtering.processNamespaces ③ admissionController.filtering.bypassNamespaces(默认 ^kube-system$ 来自 am_conf.go:72,不在 helm chart 里 ⇒ 必须改 configmap)updateSchedulerName(patch []common.PatchOperation) —— 签名里连 pod 都没有,物理上不可能读现有 schedulerName;恒 append {Op: add, Path: /spec/schedulerName, Value: constants.SchedulerName},constants.SchedulerName = "yunikorn"(admission_controller.go:370-377)。grep SchedulerName k8shim/pkg/admission/ 只有 :197/:370/:375 三处,零处读取 pod.Spec.SchedulerName坊间说法「Pod 里显式写 schedulerName: default-scheduler 即可绕过 YuniKorn」在 v1.9.0 是错的:updateSchedulerName 不接收 pod,恒发 add /spec/schedulerName=yunikorn,RFC 6902 的 add 会替换已存在的值CREATE 路径由 checkUserInfoAnnotation 拒绝;UPDATE 路径的对应消息是 "user info annotation change is not allowed"(processPodUpdate,admission_controller.go:317-319)两条出口都返回空 patch ⇒ Pod 不带 /spec/schedulerName,落到 k8s 默认 default-scheduler,shim 视为 foreign pod。日志分别是 "ignore yunikorn pod" 与 "bypassing namespace"json.Marshal(patch) → admissionResponseBuilder(uid, true, "", patchBytes),PatchType=JSONPatch(admission_controller.go:117-121, 217)。依据是 RFC 6902 §4.1「add 命中已存在成员时替换其值」+单测 admission_controller_test.go:514/515(no-label namespace 也照改成 yunikorn,且 labels 长度为 0),不是源码里的某一行AC Pod 挂 / Service 无 endpoint / 证书过期 / 超默认 timeoutSeconds 10s。populateMutatingWebhook 未设 timeoutSeconds、matchPolicy、reinvocationPolicy,走 k8s 默认(10s / Equivalent / Never)failurePolicy: Ignore(webhook_manager.go:615,636)⇒ API Server 忽略 webhook 失败,Pod 原样入库,提交者看不到任何报错 —— 风险是「安静地错」,不是「大声地停」Pod 没有拿到 /spec/schedulerName patch,于是取 kube-apiserver 的默认值 default-scheduler。这个值由 k8s 定义,k8shim 里没有对应常量shim 唯一接管闸门:strings.Compare(pod.Spec.SchedulerName, constants.SchedulerName) != 0 → GetApplicationIDFromPod 返回 ""(pkg/common/utils/utils.go:141-145),appID 为空后走 updateForeignPod(context.go:196-201, 325-329, 483-487)—— 不进队列、不受 quota 约束
这张图的一句话:改写是无条件的(那个函数连 pod 都不传参),所以你显式写 default-scheduler 也会被静默覆盖成 yunikorn。而 failurePolicy: Ignore 意味着 AC 挂掉时 pod 照样创建、只是悄悄退回 kube-scheduler —— 是 fail-open,不是全集群瘫痪。
Ch.3 · 图解 — Admission37

⏱ 本页 1.8 分钟 · 主线 379 字 · 深潜层另有 1321 字

(先给视线路径) 这张图四个框:最上面一行五个方框从左往右,是请求怎么进来; 顺着中间那根折线掉到第二行,那条横框是 AC 进程内部的判据链; 第三行是三个出口 —— 红色是拒绝、灰色是原样放行、右边是真的改写; 最下面那个红色虚线框是降级支路。 整张图:红色 = 出问题的路径,橙色 = 主链路,虚线 = 降级或可选。

第 1 步,apiserver 为什么会调它。operations 是 CREATE 和 UPDATE 两个,resources 是 7 个 —— pods、deployments、replicasets、statefulsets、daemonsets、jobs、cronjobs。 (本图最有价值的事实)它没有 namespaceSelector、也没有 objectSelector, grep 零命中 —— 所以它拦全集群。 第 2 步那个 failurePolicy: Ignore 也不容商量:你改成 Fail, AC 会给你改回来。

第 3、4 步是入口:容器端口 9089,Service 上 443 转过来; Serve() 三道校验的顺序是 body 空 400、Content-Type 不对 415、 URL 不在白名单 404。 第 5 步就是那根折线,进 mutate() 这个分流器: UPDATE 的 Pod 只查有没有篡改 user.info,不动 schedulerName; 另外 6 类资源的 UPDATE 直接放行;只有 CREATE 的 Pod 才走 processPod()。

第 6 步那个红框请特别讲。提交者不在允许名单里、却自己设了 yunikorn.apache.org/user.info,AC 直接 allowed = false —— 这是 Pod CREATE 上 AC 唯一一条真会拒绝你的业务分支。 反过来你没设,AC 会替你补上 user-info,那是配额归属的信息来源。 它不只是个改名字的钩子,它是这套系统的身份边界。

第 7、8 步是两条「不改写」的合法出口。出口一:Pod 带 label app=yunikorn, 而且只读 label,写 annotation 没用。 出口二是唯一的 namespace 级豁免,判据里那个 namespace.enableYuniKorn 注解是三态的 —— (这个坑一定要讲)只有小写字面量 "true" 算 TRUE, "True" 或 "yes" 全算 FALSE,你以为开了、其实关了。 默认豁免值 ^kube-system$ 来自 Go 代码、不在 chart 里 —— 必须改 configmap。

第 9 步是题眼。updateSchedulerName() 的签名里只有一个 patch 数组, 连 pod 都不传参 —— 物理上不可能去看你现在的 schedulerName 是什么。 它恒定 append add /spec/schedulerName = "yunikorn", 第 10 步那条动画线就是它落地;RFC 6902 的 add 命中已存在的成员就替换掉。 所以「写 default-scheduler 就能绕开」在 1.9.0 是错的 —— 第一章那个「YuniKorn 对 YuniKorn」的 A/B 实验,根因就是这个函数。

图上那行小字讲 shouldLabelNamespace():它只决定打不打标签和注解, 完全不影响 schedulerName。 else 分支写的 ignore-application 注解在 1.9.0 里「被写但从来没人读」, 单测反而钉住了「设了它照样返回 appID」—— 别拿它当豁免手段。

最后看红色虚线那一整条。AC 挂了、证书过期、或者超过默认 10 秒超时 —— 这 10 秒是 k8s 默认值,代码里压根没设。 于是apiserver 只记一条 warning 就把 Pod 原样入库,提交者看不到任何报错, Pod 取 k8s 默认的 default-scheduler。 最后那个岔口:shim 的唯一闸门就是比一下 schedulerName, 不相等就返回空 appID,Pod 变成 foreign pod —— 不进队列、不受配额约束。

(落点,照念) 真实风险不是「AC 挂了全集群瘫痪」,而是「AC 挂了没人知道,作业照样跑, 但配额和 gang 全都不生效」—— 安静地错,不是大声地停。 所以监控要盯的不是 AC 的存活,而是有多少 Pod 的 schedulerName 不是 yunikorn。 下一页是全场最重要的一张图:为什么有时候 Karpenter 给你加机器、有时候一台都不加。

Ch.3 · 在 AWS 上怎么用 · 图解 · Identity

身份链路:IAM → K8s group → YuniKorn ACL 五环 · 断一环则组 ACL 全部匹配不上

身份链路 · 五环,断一环则组 ACL 全部匹配不上IAMIAM 身份用户 / 角色 / IRSAEKSEKS 映射aws-auth / access entryAPIAdmissionReviewuserInfo{username,groups}ACAC 注入注解user.info队列 ACL组匹配映射认证注入匹配🔴 最常断在这一环自检:组到底带进来了没有kubectl get pod <pod> -o jsonpath= '{.metadata.annotations.yunikorn\.apache\.org/user\.info}'curl -s :9080/ws/v1/partition/default/usage/groups | jq .组为空 ⇒ 没带进来 ⇒ 组 ACL 全部匹配不上🔴 但在配好这条链之前,你并没有在隔离「ACL 默认拒绝」只在「单队列孤立」看时成立。实际检查沿队列树向上求并 —— 只要沿途任一级放行就放行,而 v1.9.0 出厂默认 root submitacl: '*'。⇒ 开箱净行为是「默认放行」,不是「默认拒绝」落点:先把 IAM→K8s group 映射配对、再收紧 root.submitacl,队列上的组 ACL 才开始有意义 —— 两件事都做完之前,隔离是假的。🔷 链路本身是推论(每一环已由文档/源码确认);「开箱默认放行」是 ✅实测。IAM 用户、角色、IRSA、或 EKS Pod Identity —— 链路的起点。YuniKorn 完全不认识 IAM,它只看最后一环传进来的组名两条等价通路:aws-auth ConfigMap 的 groups,或 EKS access entry 的 kubernetesGroups。🔴 这一环是整条链最常断的地方 —— 没配组映射,后面全白搭apiserver 发给 webhook 的 AdmissionReview 里带 request.userInfoYuniKorn admission controller 把 userInfo 写进 pod 注解 yunikorn.apache.org/user.info。🔵 因 groups 非空 ⇒ 不触发 YuniKorn 自己的组解析队列的 submitacl / limits 的组匹配,用的就是上一环带进来的组两条自检:① pod 注解里的 user.info 有没有 groups ② REST 的 usage/groups 是否非空。任一为空,队列上写的组 ACL 就永远匹配不上,而且没有报错指向这件事✅实测(两轮 A/B):三个子队列写 'deny'/'Deny'/空,root 为 '*' 时三个全 Running;只把 root 换成不存在的用户、其余不动 ⇒ 三个立刻全部 ApplicationRejected。⇒ 要让队列 ACL 真生效,必须先收紧 root.submitacl
一句话:在 EKS 上 submitacl: ' dataeng' 能不能匹配上,取决于你的 IAM→K8s group 映射。🔴 而在这条链配好之前,你以为在做隔离,其实是全放行 —— 出厂默认 root submitacl '*'。
Ch.3 · 图解 — Identity38

⏱ 本页 2.3 分钟 · 主线 476 字 · 深潜层另有 483 字

这张图从左往右看,一共五环 —— 它回答的是一个在 EKS 上一定会撞到的问题: 我在队列上写了 submitacl: ' dataeng',为什么它不生效?

链路是这样的:IAM 身份 → EKS 的组映射 → apiserver 发出的 AdmissionReview → YuniKorn 的 admission controller 把它写成 pod 注解 → 队列 ACL 拿这些组来匹配。 (指着第二环)最常断的是第二环 —— 也就是 aws-auth 或者 access entry 里的组映射。没配组,后面三环全白搭。

(下面这段是这一页真正的价值,建议照念) 但比「配不上」更危险的是另一件事:在这条链配好之前,你并不是「隔离失败」, 而是「根本没有隔离」。 因为「ACL 默认拒绝」只在单看一个队列时成立;实际检查是沿队列树向上求并的 —— 只要沿途任何一级放行就放行,而出厂默认 root submitacl 就是 '*'。 (停一下)所以开箱状态下的净行为是「默认放行」,不是「默认拒绝」。

所以落点是两件事,顺序不能反:先把 IAM 到 K8s group 的映射配对, 再收紧 root.submitacl —— 这两件都做完,队列上的组 ACL 才开始有意义。

(自检命令值得抄回去,左边框里有) 怎么确认组到底带进来了没有?两条: 第一条看 pod 注解 —— kubectl get pod <pod> -o jsonpath 取 yunikorn.apache.org/user.info,看里面 groups 是不是空的。 第二条看 REST —— curl :9080/ws/v1/partition/default/usage/groups。 任一为空,就说明组没带进来,而这件事不会有任何报错指向它。

(证据边界要说清) 这条链路本身我标的是推论 —— 每一环都已由第 10 章的文档或源码确认, 但我们没有在真实 EKS 上端到端跑过(没有凭证)。 而「开箱默认放行」这一条是实测:两轮 A/B,三个子队列分别写 'deny'、'Deny'、空值,root 为 '*' 时三个全部 Running; 只把 root 换成一个不存在的用户、其余一字不动,三个立刻全部 ApplicationRejected。根因就此坐实。

(这个追问很常见) 可能被问:「那 IRSA 和 Pod Identity 有区别吗?」—— 对这条链来说没有区别,它们都只是第一环的不同形态; 决定成败的是第二环有没有把组映射出来。 YuniKorn 完全不认识 IAM,它只看最后传进来的组名字符串。

下一页回到 Spark,看它在这条路径上的介入点。

Ch.3 · 在 AWS 上怎么用 · Version Matrix

EKS 版本 × YuniKorn 版本:有一个现存缺口 而且它会在每个 EKS 小版本上重演

EKS K8sEKS 支持状态最低 YuniKorn(官方矩阵)结论
1.36标准支持无 —— 没有任何 GA 版本声明支持 1.36🔴 缺口。只能:① 非官方地跑 1.9.0(官方说它已通过 e2e 测试,只是不在矩阵里)② 跑 1.10.0-beta
1.35标准支持1.9.0✅ 完美匹配,跑 1.9.0
1.34标准支持1.8.0✅ 推荐 1.9.0
1.33扩展支持1.8.0🟡 可跑,但没有「精确匹配」的构建
1.32扩展支持1.7.0🟡 1.7.0 精确匹配,但已落后两个小版本、不再收补丁
1.31扩展支持(2026-11 到期)1.6.0🔴 精确匹配的 1.6.3 已 EOL;且 AWS 会自动升级该集群
 YuniKorn 的支持窗口极宽:K8s 1.24 至今未终止支持。所以问题从来不是「太老不支持」,而是「太新还没声明」。
为什么会重演:EKS 大约在上游发布后 ~4 个月跟进一个新 minor; YuniKorn 大约 一年 2 个 minor(实算:近三次间隔 10.4 / 6.2 / 5.8 个月) ⇒ EKS 总会先于 YuniKorn 声明支持某个 K8s 版本。
做法:① 不要用 EKS 的最新 minor 跑 YuniKorn,等矩阵覆盖它; ② 升级顺序:先升 YuniKorn,再升 EKS(它向后兼容窗口宽,反过来会出现空档)。
本地也踩过同一个坑:我们实测时 kind v0.33.0 默认给的是 K8s v1.37.0, 超出支持上限,必须显式 pin kindest/node:v1.33.4。「自动升级把你推到未测试版本上」这个模式在托管 K8s 上同样成立。
Ch.3 · 在 AWS 上怎么用 — 版本矩阵39

⏱ 本页 1.8 分钟 · 主线 369 字 · 深潜层另有 1129 字

这一页传达的是结构性结论,不是一次性的版本信息 —— 版本号会过期,这一页的结构不会。 核心一句:EKS 总会先于 YuniKorn 声明支持某个 Kubernetes 版本, 所以「EKS 最新 minor 加 YuniKorn」这个组合永远处在缺口里。

先交代 EKS 侧口径,这是 2026 年 9 月 16 日读的 AWS 文档: 标准支持 1.36、1.35、1.34;扩展支持 1.33、1.32、1.31。 标准支持是发布起 14 个月,扩展支持再 12 个月、默认开启且额外计费; (这句很关键)扩展期结束时 AWS 会自动把你升到最老的仍受支持版本 —— 不问你。

(指着第一行,这是红格子) 1.36,标准支持,而 YuniKorn 那一列是「无」—— 没有任何 GA 版本声明支持 1.36。 你只有两条路:非官方地跑 1.9.0,或者跑 1.10.0-beta。 (这里有一个缓和的事实,一定要给,否则风险被夸大) 官方 1.9.0 的发布公告里有一句原话: "K8s 1.36 is not supported in this release but has passed the standard e2e test suites"。 所以它不是「没测过」,是「测过但没进矩阵」 —— 这个区别对风险评估很重要:你可以在非生产上先跑,但拿不到官方支持声明。

第二行,1.35 对 YuniKorn 1.9.0,完美匹配 —— 你们要上,这就是那个甜点组合。 第三行,1.34,矩阵里最低要求 1.8.0,我的建议仍然是跑 1.9.0。

下面三行是扩展支持区,取舍各不相同。 1.33 对 1.8.0:可以跑,但没有精确匹配的构建。 1.32 对 1.7.0:1.7.0 精确匹配,但已落后两个小版本、不再收补丁。 (这一行最需要行动)1.31 这一行是红的,还带日期:扩展支持 2026 年 11 月到期。 矩阵里对它的最低要求是 1.6.0,而精确匹配的 1.6.3 已经 EOL, 而且到期时 AWS 会自动升级这个集群。 谁的生产集群还在 1.31 上跑 YuniKorn,这一行是你回去第一件要处理的事。

(表格最下面那一栏要念出来,它是落点) 「YuniKorn 的支持窗口极宽:K8s 1.24 至今未终止支持。 所以问题从来不是『太老不支持』,而是『太新还没声明』。」

左下这个框解释为什么会重演,节奏算给你们听: EKS 大约在上游发布后 4 个月跟进一个新 minor; YuniKorn 大约一年 2 个 minor —— 这是实算的: 近三次间隔是 10.4 个月、6.2 个月、5.8 个月。 两个节奏错开,缺口就是常态,不是这一次的意外。 一个佐证:1.10.0 的目标发布日期原本是 2026 年 8 月,现在 9 月中还只到 beta —— 社区节奏是会滑的,做计划要算进去。

中间这个框两条运维规则,建议照念。第一,不要用 EKS 的最新 minor 跑 YuniKorn,等矩阵覆盖它。 第二,升级顺序是先升 YuniKorn,再升 EKS。 (理由要说,否则会被当成随口建议)理由就是刚才那句落点: 向后兼容到 1.24,新版 YuniKorn 一定能跑旧 K8s;反过来会出现「EKS 升了、YuniKorn 还不支持」的空档, 而扩展支持到期是自动升级,它不等你。

右边这个框是我们自己踩的同一个坑,可以当轻松点的插曲: 本地实测时 kind v0.33.0 默认给的节点镜像是 K8s v1.37.0, 直接超出 1.9.0 的支持上限,必须显式 pin 成 kindest/node:v1.33.4。 (这是插曲的价值)「自动升级把你推到未测试版本上」,在托管 Kubernetes 上是同一件事的另一个表现。

(若有人问 1.36 什么时候能被支持,照这个答) 对应的 JIRA 是 YUNIKORN-3295「K8s 1.36 支持」,它在 1.10.0 的官方路线图上 —— 所以这个缺口会填上,问题只是 1.10.0 什么时候 GA。 而刚才那句「目标 8 月、现在只到 beta」就是我不敢给你们时间点的原因。

下一页是这一章、我认为也是全场技术含量最高的一页: YuniKorn 和 Karpenter 到底是怎么协同的。 我先给你们一个悬念:它们之间没有 API。

Ch.3 · 在 AWS 上怎么用 · Karpenter · 机制真相

整个协同就是一个魔法字符串 我 clone 了 Karpenter 源码复核过

// kubernetes-sigs/karpenter/pkg 下 grep schedulerName
// (排除测试)⇒ 命中数 0。它结构上不认调度器。

// pkg/utils/pod/scheduling.go —— 唯一的门
func IsProvisionable(pod *corev1.Pod) bool {
  return FailedToSchedule(pod) &&
    !IsScheduled(pod) && !IsPreempting(pod) &&
    !IsOwnedByDaemonSet(pod) && !IsOwnedByNode(pod)
}

func FailedToSchedule(pod *corev1.Pod) bool {
  for _, c := range pod.Status.Conditions {
    if c.Type == corev1.PodScheduled &&
       c.Reason == corev1.PodReasonUnschedulable {
      return true   // ← 就这一个字符串
    }
  }
  return false
}

🔵 而 YuniKorn 刻意写两种 Reason

pod 为什么 pendingYuniKorn 写的 ReasonKarpenter 扩容?
队列配额超了不写任何条件🔴 shim 有 SchedulingSkipped 分支,但 v1.9.0 core 走不到❌ 不会连门都没有
集群容量真的不够Unschedulable✅ 会

源码注释原文——意图写得一字不差:
· 配额超了:// we do not trigger the auto-scaling
· 容量不够:// set pod condition to Unschedulable in order to trigger auto-scaling

⇒ 结论要说准:这不是「两个系统互不知情、碰巧能用」, 而是一个未成文但设计正确的隐式契约。「队列限额」与「节点弹性」两套限流器被正确衔接了—— 不会为一个队列本来就不让跑的作业去买节点。
但它仍然脆弱:无 API 定义、双方文档都没写、无跨项目集成测试。 Volcano 就曾把这个 Reason 字符串写错,导致 Karpenter 完全不为它扩容,直到 volcano-sh/volcano#2602 修好。这是发生过的真事。
Ch.3 · 在 AWS 上怎么用 — Karpenter 机制真相40

⏱ 本页 1.8 分钟 · 主线 376 字 · 深潜层另有 1717 字

(这一页请放慢,是全场我最想让各位带走的技术洞察) 核心一句:YuniKorn 和 Karpenter 之间没有 API、没有文档、没有跨项目集成测试 —— 它们靠一个字符串对话,而这个字符串叫 "Unschedulable"。 标题后半句也说一下:这不是从文档里读来的,是我 clone 了 Karpenter 源码亲自复核的。

先看左边,Karpenter 这一侧。 我在 kubernetes-sigs/karpenter 的 pkg/ 下 grep schedulerName,排除测试 —— 命中数 0。 (停一下)零。它结构上压根不认调度器这回事。 你用 kube-scheduler、YuniKorn、Volcano,对它没区别,因为它不看这个字段。

那它看什么?唯一的门是一个叫 IsProvisionable 的函数, 文件路径就在屏幕上:pkg/utils/pod/scheduling.go。 (指着代码块)它是五个条件的与:FailedToSchedule 为真, 而且不是已调度、不在抢占中、不属于 DaemonSet、不属于 Node。 第一条是关键,下面那个函数就是它的定义:遍历 pod 的 status.conditions, 找 type 等于 PodScheduled、reason 等于 Unschedulable 的那一条。 (指着高亮行的注释)就这一个字符串。Karpenter 扩容的触发条件,是且仅是这个。

(下面这段最精彩,也是我最想纠正一个流行说法的地方 —— 而且我自己先讲错过一次) 再看右边。集群容量真的不够时,pod 上写的是 Unschedulable,Karpenter 会扩容 —— 这一半没有争议。 而队列配额超了的时候呢?流行说法是「写的是 SchedulingSkipped,所以门匹配不上」。 (停一下)结论对,机制错 —— 这个说法我自己也写过,后来被核验推翻了。

真实机制更彻底:v1.9.0 的 core 在配额受限这条路径上,根本不写任何 pod 条件。

pod 压根不进 outstanding 列表,getOutstandingRequests 直接把它丢掉, pod 上连 PodScheduled 这个条件都没有。 (这个区分为什么重要)因为它决定了你回去怎么验: 别去找 SchedulingSkipped,你找不到 —— 全树零命中。 要验就验「pod 停在 Pending 且没有任何 PodScheduled 条件」。

而证明「这是刻意的」的证据,是源码注释本身。 (这两句英文请照念,它们是这一页的证据) 配额超了那一支的注释是 "we do not trigger the auto-scaling"; 容量不够那一支是 "set pod condition to Unschedulable in order to trigger auto-scaling"。 (停一下)两边严丝合缝 —— 一边只匹配一个字符串,另一边刻意在两种情形写不同的字符串,还在注释里说明了为什么。 (但这里要补一句限定,否则就成了我前面纠正过的那个错) 这两条注释证明的是「意图是刻意的」,不是「那条分支在 v1.9.0 里会跑」。 写着 "we do not trigger the auto-scaling" 的分支在 shim 侧, 而 v1.9.0 的 core 走不到它 —— 全树 SKIPPED 零命中。 (这个区分反而让结论更强)实现走的是一条更彻底的路: 压根不写任何条件。意图有据、实现更保守,两者都指向同一个正确结果。

(指着结论框,这一句的分寸很重要,建议照念) 结论必须说准:这不是「两个系统互不知情、碰巧能用」,而是一个未成文、但设计正确的隐式契约。 「队列限额」和「节点弹性」这两套限流器,是被正确衔接起来的。 它带来一个很好的性质:因为撞队列配额而 pending 的 pod,不会让 Karpenter 去开节点 —— 你不会为一个队列本来就不允许跑的作业付节点钱。这是值得表扬的设计。 我最初写材料时把这一条写错了,我以为 Karpenter 会为队列受限的 pod 开节点 —— 是上面那段源码把我纠正过来的。

(指着红框) 但它仍然脆弱,这两件事不矛盾:无 API 定义、双方文档都没写、无跨项目集成测试。 而且不是理论担忧 —— 出过一次真事:Volcano 曾经把这个 Reason 字符串写错, Karpenter 完全不为它扩容,一直到 volcano-sh/volcano#2602 才修好。 (落点)一个没有契约、没有测试的耦合点,出过一次事故,就说明它会再出。

(这个追问几乎一定会来) 「那 Karpenter 官方到底支持不支持自定义调度器?」—— 有个 issue 专门问这件事,kubernetes-sigs/karpenter#742, 提出人是 vara-bonthu,AWS 的人、data-on-eks 的作者,2022 年 9 月 16 日提的。 到今天还是 open,四年无人 assign、没有 PR,优先级是最低档 priority/awaiting-more-evidence —— 官方对这个标签的定义是「Lowest priority… not yet enough support to actually get it done」。 今年 8 月 28 日还被机器人以「超过一年未更新」退回 needs-triage。 这就是当前状态,不用替它美化。

(时间紧可跳)还有一条:IsProvisionable 里那个 !IsPreempting —— pod 若有 status.nominatedNodeName, Karpenter 直接跳过它。YuniKorn 抢占不设这个字段,正常无影响; 但任何会设它的控制器都会静默抑制 Karpenter 扩容。

既然协同靠一个字符串,下一个问题就是:Karpenter 会不会反过来把你的 gang 拆了? 下一页看 consolidation 怎么杀你正在跑的作业。

Ch.3 · 在 AWS 上怎么用 · 图解 · Karpenter

两条路径对照:什么时候扩容,什么时候一台都不加 全场最重要的技术洞察 · 双方源码均已复核

① 集群真的缺资源 ⇒ 写上唯一契约 PodScheduled=False + Reason=Unschedulable ⇒ Karpenter 扩容② 队列/用户配额用满 ⇒ 连 pod 条件都不写 ⇒ Karpenter 的门不匹配 ⇒ 一台机器都不加yunikorn-scheduler 单进程Gang Job Pod带 yunikorn.apache.org/task-groups 注解yunikorn-k8shim为 MinMember 补齐 placeholderyunikorn-core SchedulertryAllocate → 配额闸 → outstanding1提交 ask2进程内回调 FAILED3kube-apiserver唯一的信息交汇点provisioner.trigger.podIsProvisionable → Triggerprovisioner(singleton)1s/10s 批窗 → ScheduleNodeClaim CRkarpenter core 到此为止provider-aws → EC2实例 running ⇒ 开始计费shim registerNodesCREATE_DRAIN → 启用绑定始终由 YuniKorn 做AssumePod;Karpenter 不 bindpause 占住整机等 gang默认 15min 超时才回收45678计费从这里开始91011新节点带 karpenter.sh/unregistered:NoExecute(由 provider 摘除)—— 它只挡 pod 放置(TaintToleration),不挡 shim 注册节点user quota 不足SetSchedulingAttempted 不执行queue headroom 不足FitInMaxUndef = false不进 outstanding 列表getOutstandingRequests 丢弃pod 上无 PodScheduled连 Unschedulable 都没有一台机器都不加FailedToSchedule = false3a3b常见误说「配额超限写 SchedulingSkipped」:shim 确有该分支(context.go:1213),但 v1.9.0 core 全树 SKIPPED 零命中 —— 真实机制是根本不写任何 pod 条件两边没有一行互相认识的代码Karpenter 全仓 schedulerName 命中 0YuniKorn 全仓 karpenter 只在 helmREADME 出现 1 次唯一契约 = pod 的一个 condition✅ EKS 实测(B5 · Karpenter 1.14.1 · 16×m6i.2xlarge · NodePool 无 taint · scripts/21-bench-b5-karpenter.sh)路径 A · 真缺资源(配额充足)conditions=[{reason:"Unschedulable"}] → +1.3s 感知 → +3.8s EC2 已启动NodeClaim 2 · Karpenter 节点 2 · pod 3 Running路径 B · 队列配额受限(root.tiny max=1 vcore)conditions= ← 空。不是 SchedulingSkipped,是什么都没有NodeClaim 0 · Karpenter 节点 0 · pod 3 永久 Pending🔴 shim 的 SKIPPED 分支注释原文 “we do not trigger the auto-scaling”(配额超限时)⇒ 不扩容是**刻意设计**;但 core 从不发 SKIPPED ⇒ 实际是「什么都不写」,而非「写 SchedulingSkipped」。净效果一致,可观测性完全不同。core→shim 是同进程 Go 回调 ResourceManagerCallback.UpdateContainerSchedulingState(scheduler.go:262)—— si.proto 的 4 个 RPC 不含它;绑定始终由 YuniKorn 做,Karpenter 只发 NominatePodEvent。版本:YuniKorn v1.9.0(core 257fdef7 / k8shim 1a59488)× Karpenter 1.14.1(bde0065);EKS 1.33 / us-east-1(账号已隐去)。TryReserve k8shim/pkg/cache/application.go:497 → onReserving :516 → createAppPlaceholders :530;shim 只为每个 task group 的 MinMember 补齐缺的那些 placeholderplaceholder 是真 pod:SchedulerName="yunikorn"(k8shim constants.go:69)、image registry.k8s.io/pause:3.7(constants.go:76)、restartPolicy Never、Requests==Limits==taskGroup.MinResource(placeholder.go:133-135);创建动作在 placeholder_manager.go:90 KubeClient.CreatetryAllocate 先查 userHeadroom(core/pkg/scheduler/objects/application.go:1060-1066);internalInspectOutstandingRequests 独立 goroutine 每秒一轮(scheduler.go:83,112);getOutstandingRequests 入选需 headRoom.FitInMaxUndef && userHeadRoom.FitInMaxUndef && !HasTriggeredScaleUp && requiredNode==common.Empty && !canReplace(application.go:1002)si.proto service Scheduler 的 UpdateAllocation:shim 把 app + placeholder ask 注册进 core,core 才可能 tryAllocateResourceManagerCallback.UpdateContainerSchedulingState(State=si.UpdateContainerSchedulingStateRequest_FAILED, Reason="request is waiting for cluster resources become available"):core/pkg/scheduler/scheduler.go:262,进程内实现 k8shim/pkg/cache/scheduler_callback.go:218-220。si.proto 的 4 个 RPC(RegisterResourceManager / UpdateAllocation / UpdateApplication / UpdateNode)不含它HandleContainerStateUpdate 的 FAILED 分支写 v1.PodCondition{Type: PodScheduled, Status: ConditionFalse, Reason: v1.PodReasonUnschedulable} 并发 Event PodUnschedulable(k8shim/pkg/cache/context.go:1227)。Karpenter 全仓 schedulerName 命中 0,YuniKorn 全仓 karpenter 只在 helm README 出现 1 次 —— 两边没有一行互相认识的代码FailedToSchedule 只认 condition.Type==PodScheduled && condition.Reason==PodReasonUnschedulable(karpenter pkg/utils/pod/scheduling.go:122-124);IsProvisionable 在 scheduling.go:100-106 再叠 !IsScheduled / !IsPreempting / !IsOwnedByDaemonSet / !IsOwnedByNode。PodController 只做 provisioner.Trigger(p.UID)(controller.go:70)+ AckPods + RequeueAfter 10s(:77)—— 它不建任何机器。另一入口 GetProvisionablePods(pkg/utils/node/node.go:167)用于批量拉取第三个 singleton controller,Name()="provisioner"(provisioner.go:111-113):Reconcile(:122) → batcher.Wait(:126)(batch-idle-duration 默认 1s / batch-max-duration 默认 10s,pkg/operator/options/options.go:128,129)→ Schedule(:309) → Create(:413)Provisioner.Create 先查 NodePool Limits.ExceededBy,再 p.kubeClient.Create(ctx, nodeClaim)(provisioner.go:425);metric 名 karpenter_nodeclaims_created_total(labels: reason / nodepool / min_values_relaxed)。kubernetes-sigs/karpenter v1.9.1 全仓无 EC2 代码NodeClaim→EC2 由 karpenter-provider-aws 完成(该仓未 pin、未逐行核)。计费从实例 running 起算 —— 早于 placeholder 落地,浪费窗口比「placeholder 上机才计费」更长新 Node 一出现 shim 就 SchedulerAPI.UpdateNode 报给 core:registerNodes Action=si.NodeInfo_CREATE_DRAIN(k8shim/pkg/cache/context.go:1503,1513)→ enableNodes DRAIN_TO_SCHEDULABLE(:1617)。唯一的门是 context.go:205 if !node.Spec.Unschedulable(cordon,不是 taint)k8shim AssumePod(context.go:807)+ bindPodVolumes(context.go:726)。Karpenter 只发 NominatePodEvent(provisioner.go:462),从不 bind podpause 容器不干活,却按 taskGroup.MinResource 占住 Requests==Limits(k8shim/pkg/cache/placeholder.go:133-135)。超时参数字面值 placeholderTimeoutInSeconds(k8shim constants.go:89,注意 In),core 默认 defaultPlaceholderTimeout = 15 * time.Minute(core/pkg/scheduler/objects/application.go:55);gang 凑不齐时按 gangSchedulingStyle 处理tryAllocate 查 userHeadroom 不通过就 LogAllocationFailure(NotEnoughUserQuota) 并 continue,SetSchedulingAttempted(true) 根本不会执行(core/pkg/scheduler/objects/application.go:1060-1066);常量字面值 "Not enough user quota"getOutstandingRequests 要求 headRoom.FitInMaxUndef && userHeadRoom.FitInMaxUndef(application.go:1002);常量字面值 "Not enough queue quota"if request.IsAllocated() || !request.IsSchedulingAttempted() { continue }(application.go:997)。既然不进列表,就没有任何 UpdateContainerSchedulingState 回调不是写了 SchedulingSkipped,而是 pod 上根本不出现 PodScheduled 这个 condition —— Karpenter 的判据无从命中Karpenter 与 YuniKorn 之间唯一的契约就是那一个 pod 条件:Karpenter 全仓 schedulerName 命中 0,YuniKorn 全仓 karpenter 只在 helm README 出现 1 次Karpenter 与 YuniKorn 之间没有任何互相认识的代码:Karpenter 全仓 schedulerName 命中 0,YuniKorn 全仓 karpenter 只在 helm README 出现 1 次。唯一的契约就是 pod 上的 PodScheduled=False + Reason=Unschedulable 这一个条件t=02:44:12 YuniKorn 写下 PodScheduled=False / reason=Unschedulable、message="request is waiting for cluster resources become available";t=02:44:13.293 Karpenter found provisionable pod(s);t=02:44:15.783 launched nodeclaim m6i.xlarge us-east-1c。⇒ 协同是真的,而且只用 3.8 秒配额受限的 ask 进不到 inspectOutstandingRequests(那里的注释写明"they can fit into the max head room"),所以回调根本不被调用 ⇒ 不写任何条件。shim 里确实有一个 SKIPPED 分支会写 SchedulingSkipped,但 core 全仓只发 FAILED ⇒ 那个分支在 v1.9.0 是死代码
Ch.3 · 图解 — Karpenter41

⏱ 本页 1.6 分钟 · 主线 328 字 · 深潜层另有 1455 字

(这张图多给时间,视线路径先讲清) 左边窄的一列是 YuniKorn 自己,右边宽的是两条命运不同的泳道。 左边那个框叫「yunikorn-scheduler 单进程」,这个框本身就是事实: shim 和 core 真的是同一个进程。 右边上面那条泳道标题是橙色的,是「真的缺资源」,扩容真的发生;下面那条是红色的, 是「配额用满」,一台都不加。 上面这条是折返的:走到 NodeClaim 再顺着那条会动的橙色蚂蚁线掉下去、往回走 —— 那条唯一会动的线,就是钱开始流出去的那一步。

第 1 步,带 task-groups 注解的作业进来,shim 按每个 task group 的 MinMember 补齐缺的那些 placeholder;第 2 步把这些 ask 提交给 core。 placeholder 是真 Pod:registry.k8s.io/pause:3.7, Requests 和 Limits 都等于 taskGroup.MinResource —— 它占的是真资源, 在 Karpenter 眼里跟真作业一模一样。

第 3 步是那条青色虚线,从 core 回到 shim。它不是 gRPC,是进程内的 Go 回调 —— si.proto 那个 service 只有 4 个 RPC,这个方法不在其中。 第 4、5 步:core 每秒扫一遍 outstanding 请求,把装得进 headroom 的挑出来, 再通过那个回调让 shim 在 Pod 上写 PodScheduled = False、Reason Unschedulable。 (照念)两者之间的全部接口,就是 Pod 上这一个条件。没有别的。

第 6 步是 Karpenter 一侧。它只认两件事:condition 的 Type 是 PodScheduled、 Reason 是 Unschedulable,再叠四个「不是」—— 没被调度过、不在被抢占中、不属于 DaemonSet、不属于 Node。 这个框是「发现不可调度 Pod 并唤醒」,不是「扩容」:它只 Trigger 一下、10 秒后重新入队。 第 7 步才真的建机器 —— 单例的 provisioner,先等一个批窗, idle 1 秒、上限 10 秒。

第 8 步建的是 NodeClaim 这个 CR,karpenter core 到此为止 —— 我 pin 的 karpenter v1.9.1 全仓库没有一行 EC2 代码,真实例是 provider-aws 建的, 那个仓我没 pin、没逐行核。 第 9 步就是那条会动的线:计费起点是 EC2 实例 running 那一刻,不是 placeholder 落到机器上那一刻 —— 浪费窗口比很多人想的更长。我不给美元数字。

第 10 步新节点回到 YuniKorn:shim 一看到新 Node 就注册进 core、再启用它。 那行小字请念:新节点带着 karpenter.sh/unregistered:NoExecute,由 provider 摘除, 它只挡「往上放 Pod」,不挡 shim 注册节点。第 11 步是全图的 punchline:绑定始终是 YuniKorn 做的,Karpenter 从不 bind 任何 Pod。 最后 pause 占住整机等 gang,超时参数逐字是 placeholderTimeoutInSeconds,注意那个 In,默认 15 分钟。

(进下半张图 —— 本页真正的洞察) 下面那条红色泳道:一样是 Pod 起不来,但一台机器都不加。两个入口标成 3a 和 3b: 3a 是用户配额不足,记一条 "Not enough user quota" 就 continue, 关键是 SetSchedulingAttempted 这一行根本不会被执行; 3b 是队列 headroom 不足。 两条汇到一起:不进 outstanding 列表 → 没有回调 → Pod 上根本不出现 PodScheduled → Karpenter 无从命中 → 一台机器都不加。

(这段照念,最容易说错) 常见误说是「配额超限时写 SchedulingSkipped,所以不扩容」—— 效果对,机制错。 shim 里确实有这个分支,但 v1.9.0 的 core 全树 grep SKIPPED 零命中; 真实机制是根本不写任何 Pod 条件 —— 信了错的版本,你会去翻日志,而那里什么都没有。

左下角那个框是最该带走的一句:这两个系统之间没有一行互相认识的代码。 Karpenter 全仓 grep schedulerName 命中 0;YuniKorn 全仓 grep karpenter, 只在 helm 的 README 里出现 1 次。

两面都说:好消息是因配额受限而 pending 的 Pod 不会让你多开机器;坏消息是这个契约 没有测试、没有文档,而 placeholder 恰恰满足全部触发条件。

下一页看 Spark。

Ch.3 · 在 AWS 上怎么用 · 图解 · Spark

Spark 作业全路径:YuniKorn 只介入两个点 driver → executor · gang 如何覆盖两侧

spark-submitDriver 内 ExecutorPodsAllocatorkube-apiserver集群 API 与对象存储admission-controlleryunikorn-admission-controlleryunikorn-scheduler (k8shim)+ PlaceholderManager(同进程)yunikorn-core队列排序 / gang 换位创建 driver podSpark Driver Pod | 外部:Spark 上游1patch /spec/schedulerName无条件;标签改写仅当 ns 被 label2Pod ADDED → AddPod / UpdatePod门禁:schedulerName ≠ yunikorn ⇒ GetApplicationIDFromPod 返回空3取 appID/queue → 建 App + Task解析 yunikorn.apache.org/task-groups4UpdateApplicationplaceholderAsk | executionTimeoutMilliSeconds5ApplicationResponse.Accepted6PlaceholderManager 建 pause 占位 Podtg-<appID>-<taskGroupName>-<nonce> × minMember | registry.k8s.io/pause:3.77占位 Pod 回到 informer 再走一遍 3-6UpdateAllocation(placeholder=true) → AssumePod + Bind → postTaskBound8占位齐 → RunApplicationReserving 期间只放 placeholder,driver 也在等9swap → ReplacedTerminationType_PLACEHOLDER_REPLACED10AssumePod(30 步 backoff)→ Bind 真实 PodScheduled / PodBindSuccessful;失败留 AssumePodError11ExecutorPodsAllocator 建 executor podExecutor Pod | 带 task-group-name,回到 3 重走12YuniKorn 只认 PodSpark Driver Pod | Placeholder Pod (tg-*)Executor Pod —— 全靠 Pod informer 认识①②① schedulerName 在这一步生效spark.kubernetes.scheduler.name=yunikorn(driver/executor 专用项可覆盖),或由 AC 无条件 patch不是 yunikorn ⇒ 该 Pod 被当外人,YuniKorn 全程不介入② gang 注解在这一步生效driver pod 上的 yunikorn.apache.org/task-groups(annotation only)只在建 Application 那一刻读一次executor 靠 yunikorn.apache.org/task-group-name 认领占位gang 同时覆盖 driver 与 executordriver 与所有 executor 共享 spark-app-selector⇒ 同一个 Application;Reserving 期间只放 placeholder,driver 也在等;真实 Pod 只能换同名 taskGroup 且 ≤ 占位超时(placeholderTimeoutInSeconds / gangSchedulingStyle):Case 1 已 Running/Completing ⇒ 只用 TerminationType_TIMEOUT 清剩余占位,不看 style;Case 2 ⇒ Hard=失败 / Soft=Resuming外部:Spark 上游(apache/spark v4.0.0),非 YuniKorn 代码。cluster 模式下 spark-submit 直接建 driver pod;走 spark-operator 的 SparkApplication CR 最终也是一份 driver pod —— k8shim 只注册 ConfigMap/PriorityClass/Node/Pod 四个 informer,没有任何 CRD informer。Spark Driver Pod / Placeholder Pod (tg-*) / Executor Pod 都是这里的对象;YuniKorn 只通过 Pod informer 认识它们。可选组件。admission_controller.go:197 无条件 patch /spec/schedulerName;:199 shouldLabelNamespace 才 updateLabels + updatePreemptionInfo,:202 else 走 disableYuniKorn(只加 yunikorn.apache.org/ignore-application 注解,不撤 schedulerName)。注:该注解在 v1.9.0 从未被 shim 读取。对 Pod 的门禁只有 app != yunikorn(:186-191) + shouldProcessNamespace(:193-196)。k8shim/pkg/cache/context.go:295 AddPod → :325 GetApplicationIDFromPod → :368 ensureAppAndTaskCreated → metadata.go:62 getAppMetadata。PlaceholderManager 在同一进程内:pkg/cache/placeholder_manager.go:90。v1.9.0 里 k8shim 与 core 同进程:pkg/cmd/shim/main.go:57 传 serviceContext.RMProxy,走 SI 的 Go 接口调用,不是跨网络 gRPC —— core/pkg/common/server.go 有完整 gRPC server 但生产代码从不调用。--deploy-mode cluster(spark_jobs.sh:40 只能证明 e2e 用 cluster 模式;「spark-submit 直接调 K8s API」的实现在 Spark 上游,不是 YuniKorn 侧证据)updateSchedulerName 打 JSONPatch add /spec/schedulerName = "yunikorn"(admission_controller.go:370,调用点 :197)。装了 AC 就不必自己设 schedulerName。utils.go:143 第一件事就是比 schedulerName;不等于 yunikorn 直接返回空字符串,该 Pod 被当外人,YuniKorn 全程不介入。appID 取值顺序(utils.go:147-171):1 label yunikorn.apache.org/app-id → 2 annotation 同名 → 3 label applicationId → 4 label spark-app-selector。Spark 给 driver 与所有 executor 打同一个 spark-app-selector ⇒ 归入同一个 YuniKorn Application —— 这与 admission controller 无关。task-groups / schedulingPolicyParameters 在 metadata.go:111 解析,只在 driver 建 Application 那一刻读一次。application.go:430 handleSubmitApplicationEvent 发 si.ApplicationRequest{New: []*si.AddApplicationRequest{...}};gang 三个字段在此过界:PlaceholderAsk(:442)、ExecutionTimeoutMilliSeconds、GangSchedulingStyle。scheduler_callback.go:120-135:for _, app := range response.Accepted { dispatcher.Dispatch(NewSimpleApplicationEvent(appID, AcceptApplication)) } —— shim 的 Accepted 状态是 core 回传的,不是本地凭空转的。Accepted → postAppAccepted(application.go:482) → 有 taskGroups 且未 skipReservationStage 则 TryReserve(:497) → Reserving 触发 onReserving → placeholder_manager.go:90 createAppPlaceholders。占位 Pod restartPolicy: Never。占位 Pod 自带 SchedulerName: constants.SchedulerName(placeholder.go:148),过得了步骤 3 的门禁;task.updateAllocation(task.go:311-334) 带 placeholder=true,bind 成功后 postTaskBound(task.go:411-419) 才 Dispatch NewUpdateApplicationReservationEvent —— 步骤 9 的「占位齐」由此而来。Reserving 期间 Application.Schedule() 只放 t.placeholder==true 的 task(application.go:367-372 return t.placeholder),连 driver pod 自己都排在 pause 占位后面等。application.go:583 是 gang 的真正闸门。core/pkg/scheduler/objects/application.go:1301 tryPlaceholderAllocate:真实 Pod 只能换掉同名 taskGroup、且资源不大于自己的占位;context.go:146 判 result.ResultType == objects.Replaced → :148 notify RM。SI 枚举值 4(si.pb.go:48)。scheduler_callback.go:68-78 AssumePod(Steps:30 / Duration:1s / Cap:30s,失败发 AssumePodError:80)→ :88 NewAllocateTaskEvent → postTaskAllocated(task.go:348) → Event(Scheduled)(:356) → bindPodVolumes(:364) → KubeClient.Bind(:373) → Event(PodBindSuccessful)(:380)。这 5 个才是合法 K8s Event reason;gang 那 7 个(TaskGroupMatch 等)reason 一律是 GangScheduling,它们只是 action 字段。外部:Spark 上游 ExecutorPodsAllocator 按 spark.executor.instances 分批建 pod(本地唯一相关依据 spark_jobs.sh:42 --conf spark.executor.instances=$EXEC_COUNT)。executor pod 也继承 schedulerName,并靠 annotation yunikorn.apache.org/task-group-name 认领对应占位。k8shim 只注册 ConfigMap / PriorityClass / Node / Pod 四个 informer(context.go:113-155),没有任何 CRD informer —— 所以 spark-operator 的 SparkApplication CR 与 spark-submit 的介入点完全一致,都从 driver pod 起。core/pkg/scheduler/objects/application.go:407-445 是 if/else 两侧,不是先后顺序::437 Case 1(app 已 Running/Completing 且有已分配占位)只用 TerminationType_TIMEOUT 清剩余占位,完全不看 Hard/Soft;:442 else 才判 style —— Hard ⇒ FailApplication,否则 HandleApplicationEventWithInfo(ResumeApplication, "ResourceReservationTimeout"),shim 的 Resuming 经 ApplicationResponse.Updated 回传,且仅当 shim 当前是 Reserving 才转(scheduler_callback.go:153-160)。
一句话:YuniKorn 只认 Pod —— 只介入两点:schedulerName,与 driver 上的 task-groups 注解。
Ch.3 · 图解 — Spark42

⏱ 本页 1.4 分钟 · 主线 297 字 · 深潜层另有 1747 字

(先给视线路径) 这是时序图,五条竖着的生命线从左到右:spark-submit、 kube-apiserver、admission controller、k8shim、yunikorn-core; 然后从上往下读 12 根箭头。 最左那条是灰虚线,代表「这是 Spark 上游的事,不是 YuniKorn 的代码」;AC 那条是橙色虚线, 因为它可选。那两个粉紫色标记 ① 和 ②,就是这一页的全部内容 —— 它只介入这两个点。

第 1 步是灰虚线:spark-submit 建 driver pod,标成「外部」因为实现在 Spark 上游。 顺便答一个高频问题:走 spark-operator 的 SparkApplication CR 有什么不同?没有 —— k8shim 只注册 4 个 informer:ConfigMap、PriorityClass、Node、Pod,没有任何 CRD informer, 介入点一样都从 driver pod 起。这就是中间那张便签的意思:YuniKorn 只认 Pod。

第 2 步就是标了 ① 的那一步:要么自己写 spark.kubernetes.scheduler.name=yunikorn,要么让 AC 无条件替你 patch。 第 3 步是最该记住的门禁:shim 取 appID 时第一件事就是比 schedulerName, 不等于 yunikorn 就直接返回空字符串 —— 这个 Pod 于是成了外人: 不进队列、不受配额约束、gang 也管不到。

第 4 步是标了 ② 的那个会脉动的标记:取 appID 和 queue、建 App 和 Task。 appID 有四级顺序:label yunikorn.apache.org/app-id → 同名 annotation → applicationId → spark-app-selector。 Spark 给 driver 和所有 executor 打同一个 spark-app-selector,它们因此归入 同一个 Application —— 这跟 admission controller 无关。task-groups 也在这一步解析: annotation only,写成 label 不生效,而且只在这一刻读一次。

第 5 步 shim 把应用交给 core,gang 的三个字段在这里过界: placeholderAsk、executionTimeoutMilliSeconds、 gangSchedulingStyle。 第 6 步那个青色回头箭头 Accepted,说明 shim 这个状态是 core 回传的。 第 7 步建 pause 占位 Pod,名字逐字是 tg-<appID>-<taskGroupName>-<nonce>。

第 8 步是那条容易被跳过、缺了就讲不通的自环:占位 Pod 建出来之后要回到第 3 到 6 步 再走一遍 —— 因为它自己也是真 Pod。它自带 schedulerName: yunikorn, 被分配、AssumePod、Bind,绑成功了才算「一个坑真占住」。 第 9 步是 gang 的真正闸门:Reserving 期间只放 placeholder,连 driver pod 都排在占位后面等 —— 说「gang 只管 executor」在源码里不成立。

第 10 步换手有两个约束:真实 Pod 只能换掉同名 taskGroup 的占位, 而且资源不能大于那个占位。第 11 步真实 Pod 落地:AssumePod(30 步退避、 上限 30 秒)→ Scheduled → 绑卷 → Bind → PodBindSuccessful。 (这条口径是核验抓出来的)这几个才是真的 Event reason;gang 那 7 个 —— 比如 CreatingPlaceholders —— 是 action,reason 一律是 GangScheduling, 所以 kubectl describe 里要搜 GangScheduling。

第 12 步又回到灰虚线:ExecutorPodsAllocator 按 spark.executor.instances 分批建 executor pod。executor 继承 schedulerName,靠注解 task-group-name 认领自己那个占位, 再回到第 3 步重走一遍 —— 这就是第三张卡「gang 同时覆盖 driver 与 executor」的来历。

最下面那条红色虚线的超时条是 if/else 两侧,不是先后两步:Case 1 应用已经 Running 或 Completing,只按超时清掉剩余占位、完全不看 gangSchedulingStyle;Case 2 才判风格, Hard 失败、Soft 转 Resuming。「我设了 Soft 为什么没 resume」,八成落在 Case 1 里。

(收尾)再提醒一句:仓库自带那份 Spark 示例里的 label spark-app-id 在 1.9.0 代码里根本不存在,别照抄;官方 e2e 的 Spark 用例也是 非 gang 的,所以不能说「官方验证过 Spark 加 gang」。

落点:YuniKorn 只认 Pod,只碰 schedulerName 和那份 task-groups 注解。 下一页回到 Karpenter 的另一面:consolidation 会怎么在你毫不知情时, 把一个正在等 gang 的节点收走。

Ch.3 · 在 AWS 上怎么用 · Karpenter · Consolidation

Karpenter 的默认配置会驱逐运行中 gang 的成员 五种保护机制,按强度排序

为什么会发生

# Karpenter 的默认值(kubebuilder 默认)
spec:
  disruption:
    consolidationPolicy: WhenEmptyOrUnderutilized
    consolidateAfter: 0s   # 零宽限期

官方对该策略的定义:"Any node that can be removed or replaced to reduce cost / … willing to accept the pod disruption."
失败模式:Karpenter 驱逐一个 executor → gang 已经 Running、placeholder 已消失 → YuniKorn 把它当普通 ask 重新调度 → 不会重新走 all-or-nothing → 若无 headroom,作业永远卡在 N−1。

选谁下手:官方文档说优先终止 「pod 少的节点」「即将过期的节点」「低优先级 pod 的节点」—— 而「低优先级」看的是 K8s PriorityClass,不是 YuniKorn 队列优先级。 ⚠️ 且「pod 少的节点优先」对一节点一 executor 的 GPU gang 来说,意味着 gang 里每个节点都是首选目标。
#机制强度 / 代价
1NodePool spec.replicas(静态 NodePool)最强:设了它 consolidation 相关字段被忽略。🔴 需 feature gate StaticCapacity=true(Alpha,默认关)
2consolidateAfter: Never强且 GA,一行搞定。但不阻止 Drift 与 Expiration ⇒ 要配 expireAfter: Never
3karpenter.sh/do-not-disrupt中。官方原话「可当成单 pod 的 PDB」。🔴 必须也打在 placeholder 上
4PodDisruptionBudget🔴 对 Karpenter 有效,对 YuniKorn 抢占无效(见下)
5独立 NodePool + taints隔离爆炸半径,代价是容量碎片
🔵 独家:怎么给 placeholder 打注解。 真实 pod 上的注解不会传给 placeholder。必须写进 task group 的 annotations 字段——而这个字段官方文档从未提及(源码里 TaskGroup 有 9 个字段,文档只展示 7 个):
{"name":"exec","minMember":4,"annotations":{"karpenter.sh/do-not-disrupt":"true"}}
Ch.3 · 在 AWS 上怎么用 — consolidation 与保护43

⏱ 本页 1.8 分钟 · 主线 376 字 · 深潜层另有 1596 字

这一页讲一个默认值造成的问题。核心一句: Karpenter 的默认配置是最激进的那一档 —— consolidateAfter: 0s,零宽限期, 为省钱随时驱逐正在跑的 pod。而它不知道你的 gang 是一个整体。

(指着左边代码块)先看默认值,这是 Karpenter 自己的 kubebuilder 默认: consolidationPolicy: WhenEmptyOrUnderutilized、 consolidateAfter: 0s —— 注意第二个,零秒,没有任何宽限期。 官方对这个策略的定义我念一下,态度写得很清楚: "Any node that can be removed or replaced to reduce cost / … willing to accept the pod disruption." (重一点)willing to accept the pod disruption —— 这是它明说的取舍,不是意外行为。

失败模式讲慢一点,这是这一页真正的内容。四步。 一,Karpenter 驱逐了 gang 里的一个 executor。 二,注意这里 —— gang 一旦 Running,placeholder 就已经消失了, 那个「全有或全无」的装配过程已经结束了。 三,所以 YuniKorn 把这个 executor 当成一个普通的资源请求重新调度, 它不会重新走 all-or-nothing。 四,如果此刻队列没有 headroom、或者没有节点放得下它, 这一个 executor 就永远 Pending,作业卡在 N 减 1。 (后果按框架分开说)对 Spark 是丢一个 executor,还能跑、只是慢;对 MPI 是整个作业挂住。

(这个口径必须给,否则就是把推论说成了事实) 这里我要标一句:刚才那四步是机制推论,不是我们实测跑出来的 —— 链条上每一环都有源码或官方文档依据,但「Karpenter 驱逐一个 executor、作业最后卡在 N 减 1」 这个完整过程我们没有在集群上复现过。 (建议照念)所以正确的说法是「机制上会这样」,不是「我们见过它这样」。

(指着左下这个框,对 GPU 用户特别重要) 那 Karpenter 挑谁下手?官方文档说优先终止三类节点: 「pod 少的节点」、「即将过期的节点」、「有低优先级 pod 的节点」。 (第三条有陷阱)「低优先级」看的是 Kubernetes 的 PriorityClass,不是 YuniKorn 的队列优先级 —— 两套优先级体系互不知情。 (第一条对 GPU 场景是致命的)而「pod 少的节点优先」, 对一节点一个 executor 的 GPU gang 来说,意味着 gang 里每一个节点都是首选目标。 这是一个很不幸的组合。

右边是五种保护机制,按强度排序,五条我都说,因为强度和代价都不一样。

(时间紧可跳 —— 机制 1 现在还不能用在生产上) 第一,NodePool 的 spec.replicas,也就是静态 NodePool,这是最强的一条 —— 设了它,consolidation 相关的字段直接被忽略。 (前提必须说,否则听众会当场去配)但它需要一个 feature gate StaticCapacity=true,而这个 gate 是 Alpha、默认关闭。 所以它最强,但现在还不能当生产方案。

第二,consolidateAfter: Never —— 强,而且 GA,一行就把整个 NodePool 的 consolidation 关掉。 (这一行有个必须补的坑)但它不阻止 Drift 和 Expiration,这两个都是强制的 —— 还得配 expireAfter: Never,否则节点照样因为过期被换掉。

第三,karpenter.sh/do-not-disrupt 注解,强度中。官方原话很好懂: 「可以把它当成单个 pod 的 PDB」。 (关键在后半句)它必须也打在 placeholder 上,否则 gang 在装配期就被打断 —— 马上展开。 第四,PodDisruptionBudget,这一行是红的:对 Karpenter 有效,对 YuniKorn 抢占无效,下一页整页讲它。 第五,把 gang 负载放到独立 NodePool 加 taints —— 作用是隔离爆炸半径, 代价是容量碎片,你会多买一点余量。

(指着右下角这个框 —— 本页的独家内容,是读源码才发现的) 怎么给 placeholder 打注解?你打在真实 pod 上的注解不会传给 placeholder —— 因为 placeholder 不是你创建的,是 YuniKorn 自己造的。 它的注解来自 task group 定义里的 annotations 字段。 而这个字段官方文档从来没提过 —— 源码里 TaskGroup 结构体有 9 个字段,官方示例始终只展示 7 个, 从不提 labels 和 annotations。写法就是屏幕上这一行: {"name":"exec","minMember":4,"annotations":{"karpenter.sh/do-not-disrupt":"true"}}。 ⇒ 想保护 gang 的装配期不被打断,你必须用这个未文档化的字段,没有别的路。

(实践建议,一句就够)10 分钟以内的短作业,机制 3 就够,配个 consolidateAfter: 5m 给点缓冲;长训练作业用机制 2, consolidateAfter: Never 加专用 NodePool。机制 1 最强,等它 GA 再说。 刚才第 4 行那个 PDB 的问题下一页展开 —— 它是这一章里我最想让你们的运维同事听到的一条。

Ch.3 · 在 AWS 上怎么用 · Two Surprises

两个反直觉:PDB 保护不了你,而 CA 在这件事上比 Karpenter 好 都有源码依据

🔴 反直觉一 · PDB 被 YuniKorn 抢占静默绕过

谁在回收 pod走什么 APIPDB 生效?
Karpenter consolidationEviction API(pods/eviction)✅ 生效
YuniKorn 抢占Pods().Delete() —— 裸 DELETE❌ 不生效
// k8shim/pkg/client/kubeclient.go —— 全文件搜 Evict:0 命中
nc.clientSet.CoreV1().Pods(pod.Namespace).
    Delete(context.Background(), pod.Name, apis.DeleteOptions{})

PDB 只由 eviction 子资源的准入检查执行;直接 DELETE 不受 PDB 约束。
⇒ 同一个集群里,两种「回收 pod」的机制对 PDB 的态度完全不同。
⇒ 保护负载不被抢占,唯一有效手段是队列的 preemption.policy: disabled 或 PriorityClass 上的 allow-preemption: "false"。

🔵 反直觉二 · Cluster Autoscaler 在这件事上更好

能力KarpenterCluster Autoscaler
认自定义调度器隐式(靠魔法字符串)✅ 显式开关
--bypassed-scheduler-names=yunikorn
用什么做装箱模拟自己重写的语义✅ 真正的 kube-scheduler framework
(--scheduler-config-file 可配插件)
可观测性—✅ scheduler_unprocessed 标签可证明生效
 推荐配置:--bypassed-scheduler-names=yunikorn --allowed-scheduler-names=default-scheduler,yunikorn
要说准:Karpenter 在速度、实例选型、consolidation 上更强。 但在「认自定义调度器」这一项上,Karpenter 是隐式契约,CA 是显式开关。 ⇒ 选型时应把这一点摆出来,而不是默认「Karpenter 一定更好」。
共同边界:两者都不理解 gang。 可能出现「开了 2 台节点里 1 台成功、另一台容量不足失败」⇒ gang 仍凑不齐,而你已付了 1 台的钱。 这是 gang 在云上的结构性缺口,两家都没解决。
Ch.3 · 在 AWS 上怎么用 — 两个反直觉44

⏱ 本页 1.9 分钟 · 主线 393 字 · 深潜层另有 1756 字

这一页两条都是「你以为的和实际不一样」,而且两条都有源码依据,不是推测。 核心一句:你给在线服务配的 PodDisruptionBudget,对 Karpenter 有效, 对 YuniKorn 抢占完全无效 —— 因为它走的是裸 DELETE,不走 eviction。

(指着左边那张两行的表) 第一行,Karpenter 的 consolidation 走 Eviction API,也就是 pods/eviction 子资源,PDB 生效 —— 这是符合直觉的那一行。 第二行,YuniKorn 的抢占走 Pods().Delete(),裸 DELETE,PDB 不生效。 (说重)不是「效果差一点」,是完全不生效,而且是静默绕过。

这一条能用一行源码证明。 (指着代码块)k8shim/pkg/client/kubeclient.go 里就是这一句: clientSet.CoreV1().Pods(pod.Namespace).Delete(...), 整个文件搜 Evict,零命中。 再对上 Kubernetes 的规范:PDB 是由 eviction 子资源的准入检查执行的, 所以直接 DELETE 天然不受 PDB 约束。 (这句要说)这不是 bug,是一个实现选择 —— 但后果必须让运维知道。

(诚实边界,请照念,不要省) 我核实的是「抢占删 pod 走哪个 API」,没有实测「配了 PDB 的负载被抢时 PDB 确实没拦住」。 机制上的结论是确定的;但要在正式场合断言,建议补一个 5 分钟实测 —— 给一个 Deployment 配 minAvailable: 100% 的 PDB,触发一次抢占,看它有没有被删掉。

(这半页的落点,照念) 同一个集群里,两种「回收 pod」的机制对 PDB 的态度完全不同。 保护负载不被 YuniKorn 抢占,唯一有效的手段不是 PDB,是队列侧的 preemption.policy: disabled,或 PriorityClass 上的 allow-preemption: "false"。

(转到右边,口径先立好)反直觉二:在这件事上,Cluster Autoscaler 比 Karpenter 更好。 注意我说的是「在这件事上」,不是「CA 比 Karpenter 好」 —— 这句话太容易被引用成后者。

第一行,认自定义调度器。Karpenter 是隐式的 —— 就是刚才那个魔法字符串; CA 有显式开关 --bypassed-scheduler-names=yunikorn。 你把 yunikorn 列进去,CA 就直接为这些 pod 模拟并扩容,不等任何 condition。 一个是「我猜你写了那个字符串」,一个是「你告诉我了」。

第二行,用什么做装箱模拟 —— 这一行比第一行更重要。 Karpenter 用的是它自己重写的调度语义;CA 跑的是真正的 kube-scheduler framework, 还能用 --scheduler-config-file 加载 KubeSchedulerConfiguration 改它模拟用的插件。

(这段原话很有分量,建议照念;出处也要给,被追问时能落地。时间紧可跳 —— 上一段已经把这一行讲完了,这段是加强证据) Karpenter 维护者 njtran 在 aws/karpenter-provider-aws#7265 里说过这么一段, 时间是 2024 年 10 月 28 日: "we don't actually use the kube-scheduler's code to schedule pods, and we implement our own code. This seems to be a natural gap in our scheduling is that we aren't aware of custom scheduler plugins, and thus could fail to actually schedule as the cluster expects." (说清分寸)「natural gap」是他们自己用的词 —— 这不是我在批评它。 不过这是维护者在 issue 里的评论,不是官方文档的声明,引用时把出处一起给。

第三行,可观测性。CA 的 unschedulable-pods 那个 gauge 上有 scheduler_unprocessed 这个标签,你能用它证明 bypass 真的在生效。 (Karpenter 那一格是一条横线,这也要交代)横线不是说它没有指标, 是说在「认自定义调度器」这件事上,它没有一个能证明「生效了」的观测点 —— 那件事本身就是隐式的,没有开关,自然也没有开关的状态可看。

(表格最下面那一栏请照念,可以直接抄走)推荐配置是两个参数一起给: --bypassed-scheduler-names=yunikorn --allowed-scheduler-names=default-scheduler,yunikorn。 必须满足 bypassed 是 allowed 的子集,否则 CA 直接拒绝启动 —— 只写第一个,你的 CA 起不来。

(指着右边第一个框,分寸最重要) Karpenter 在速度、实例选型、consolidation 上更强,这三项没有争议。 但在「认自定义调度器」这一项上,Karpenter 是隐式契约,CA 是显式开关。 ⇒ 选型时应该把这一点摆出来,而不是默认「Karpenter 一定更好」。 这是机制推论,不是我们的实测对比。

(最后这个框是两家都没解决的问题) 共同边界:两个 autoscaler 都不理解 gang,所以没有「要么全开、要么不开」的扩容。 具体长成什么样:它决定开 2 台节点,1 台成功、另一台因容量不足失败 —— gang 还是凑不齐,但那 1 台的钱已经付了。 (落点)这是 gang scheduling 在云上的结构性缺口,两家都没解决。 CA 那种 atomic scale-up 的类型在这个场景下也会静默退化。

下一页看 AWS 官方材料里的两处缺陷 —— 第一处的后果可以精确量化:你以为是 30 秒,实际是 15 分钟。

Ch.3 · 在 AWS 上怎么用 · Documentation Defects

两处需要自己核实的地方 都在 AWS 官方材料里 · 都有完整证据链

① EMR on EKS 教程的参数名 (两处都是)

# AWS 官方教程原文(tutorial-yunikorn.html)
yunikorn.apache.org/schedulingPolicyParameters:
  "placeholderTimeoutSeconds=30 gangSchedulingStyle=Hard"
#  ↑ 漏了 In

// k8shim 唯一接受的键(constants.go:83)
const SchedulingPolicyTimeoutParam =
      "placeholderTimeoutInSeconds"
// 全仓搜无 In 的拼写:零命中
你以为实际倍数
超时 30 秒超时 15 分钟30×

为什么静默:解析函数的 switch 只有两个 case、没有 default 分支。 键写错是合法的 k=v,不触发 malformed 告警,但匹配不上任何 case ⇒ timeout 保持初值 0 ⇒ core 套用默认 15 分钟。零日志、零告警、零事件。 叠加同文档里的 Hard:凑不齐的 gang 会占着 placeholder 15 分钟, 而 placeholder 在 Karpenter 下已经把节点开出来并计费了。

② data-on-eks 的 volumeBindTimeout

# awslabs/data-on-eks · helm-values/yunikorn.yaml(main 分支原文)
yunikornDefaults:
  # The default volume bind timeout value of
  # 10 SECONDS may be too short for EBS
  service.volumeBindTimeout: "60s"
项值
注释声称的默认值10 秒
✅ 源码 + 官方文档的实际默认值10 分钟(Default: 10m,官方示例调整方向是调大到 15m)
注释的意图「对 EBS 太短」⇒ 想调大
实际效果10 分钟 → 60 秒,调小了 10 倍

⇒ 做的事与注释的意图正好相反。EKS 上 EBS attach 本就可能慢;把 bind 超时压到 60 秒更容易中止分配, 而对 gang 来说一次 bind 中止意味着整个 gang 重试。
同一份参考架构另外三点:chart 钉在 1.7.0(落后两个小版本);namespace 用 yunikorn-system 而 AWS 自己的 EMR 教程用 yunikorn(两份官方材料不一致); 用 ArgoCD 且 selfHeal: true ⇒ 手改 ConfigMap 会被回滚。

态度:目的不是挑 AWS 的错,而是说明照抄任何参考架构都需要自己核实关键参数。两处都有完整证据链,也都该作为 issue 反馈。 诚实标注:性能后果未在 AWS 实测(无凭证),标为推论;「值缩小 10 倍」与「参数名不被接受」是确定的。
Ch.3 · 在 AWS 上怎么用 — 两处文档缺陷45

⏱ 本页 2.0 分钟 · 主线 410 字 · 深潜层另有 1090 字

(这一页的讲法要专业,不要幸灾乐祸 —— 这一点很重要,因为我们是 AWS 的人) 核心一句:我不是来挑 AWS 文档的错的。我要说明的是 —— 照抄任何参考架构都需要自己核实关键参数,而这两个例子恰好说明了为什么。

左边第一条,我认为是整份研究里含金量最高的一个发现, 因为它必须同时读 AWS 文档和 YuniKorn 源码才可能发现 —— 只看一边永远看不出来。

AWS 的 EMR on EKS 教程里,两处都写的是 placeholderTimeoutSeconds。 而 k8shim 唯一接受的键是 placeholderTimeoutInSeconds —— (把这个词重一点)中间多一个 In。

我在全仓搜了不带 In 的那个拼写,零命中。

(指着右上那个小表) 净效果在这张表里:你以为超时是 30 秒,实际是 15 分钟,差 30 倍。

接下来这段是这一页最该讲透的,因为它决定了这个坑有多危险 —— 为什么它是静默的。 解析函数的 switch 只有两个 case,没有 default 分支。

所以:少了等号会告警;值写错也会告警; 但键写错什么都不打 —— 因为它是一个合法的 k=v, 只是匹配不上任何一个 case。 (这个推论要说出来)三档失败模式里,键写错是最隐蔽的那一档。

而这个坑还会叠加:同一份文档里还设了 gangSchedulingStyle=Hard。 Hard 模式下凑不齐的 gang 会占着 placeholder 整整 15 分钟 —— 而 placeholder 在 Karpenter 下已经把节点开出来并且在计费了。 所以这不只是一个配置不生效的问题,它是一个会产生真实账单的问题。

右边第二条,是 awslabs/data-on-eks 这个参考架构里的 service.volumeBindTimeout。

我是直接 curl 它的 main 分支拿到原文的,所以这是当前状态,不是历史问题。

(念这段注释,因为它的自相矛盾是重点) 它的注释写的是:「默认的 volume bind 超时值 10 秒对 EBS 来说可能太短」—— 然后把它设成了 60s。 但源码常量是 10 * time.Minute,官方文档也明确写着 Default: 10m, 而且官方示例的调整方向是调大到 15 分钟。

(停一下,让这个反转落地) 所以这个「修复」实际做的事是:把超时从 10 分钟缩小到 60 秒,缩小了 10 倍 —— 与它注释里声明的意图正好相反。

后果要说清楚:EKS 上 EBS 的 attach 本来就可能慢。把 bind 超时压到 60 秒, 更容易中止分配;而对 gang 来说,一次 bind 中止意味着整个 gang 重试。

同一份参考架构还有另外三点值得一并提,因为你们大概率会直接抄它: 第一,chart 钉在 1.7.0,落后两个小版本。 第二,namespace 用的是 yunikorn-system, 而 AWS 自己的 EMR 教程用的是 yunikorn —— (这一句值得说)两份 AWS 官方材料互相不一致,抄的时候要选一个。 第三,它用 ArgoCD 而且开了 selfHeal: true —— 意味着你手改 ConfigMap 会被自动回滚,排障时这个会让人非常困惑。

(诚实边界必须主动说,这段建议照念) 最后我要把话说清楚:这两条的性能后果,我没有在真实 AWS 上实测过 —— 我们没有凭证,全部实测都是在本地 kind 上做的。 所以我说的是:「值被缩小了 10 倍」和「参数名不被接受」,这两件事是确定的; 而「因此更容易导致 gang 重试」是机制推论,不是实测。 这个区分我希望你们也带回去用 —— 它是判断一份材料可不可信的最快方法。

(高频追问) 可能被问:「那 data-on-eks 到底还能不能用?」 能用,而且它有三项值得抄:binpacking 节点排序(这是官方推荐的云上正确值)、 operatorPlugins 里加上 spark-k8s-operator、以及显式指定 placeholder 镜像的思路。 但队列配额那部分不要抄 —— 它的 max 值大到 1.1 PB、15 万核, 那是「形状示例」不是「配额示例」,照抄等于没有配额。

下一页看生态 —— 也就是各位一定会问的那个问题:它到底支持哪些组件。

Ch.3 · 在 AWS 上怎么用 · Ecosystem

它到底支持哪些大数据组件 官方覆盖 5 类,其余靠通用机制

三档判据(先看这个)

  • ✅ 原生支持 —— 对方有为 YuniKorn 写的代码或官方文档页
  • 🟡 通用机制可用 —— 对方完全不知道 YuniKorn 存在,但它的 CR 暴露了完整 PodSpec,你能塞 schedulerName + label
  • ❌ 不可用 —— 对方 CRD 是手写字段白名单,没有 schedulerName、没有 podTemplate ⇒ 只能靠 admission controller 按 namespace 强行接管
🔵 理解的钥匙:YuniKorn 的设计取向是不引入新 CRD ⇒ 它不需要对方为它写代码,只需要对方肯让你设 schedulerName。 ⇒ 所以支持面的边界不在 YuniKorn 这边,在对方的 CRD 有没有留口子。
对比 Volcano:它有自己的 PodGroup CRD,所以对方必须为它写代码(如 Spark 的 VolcanoFeatureStep)。 门槛更高,但一旦集成就是一等公民。
组件判定关键事实
 官方文档覆盖的全部 5 类(/docs/user_guide/workloads/ 只有 9 页)
Apache Spark✅spark.kubernetes.scheduler.name(Spark 3.3.0 起);有官方专节,但最新 GA(4.2.0)钉的是 1.8.0,1.9.0 只在 master;🔴 只有文档与集成测试,src/main/ 下零生产代码
Kubeflow Spark Operator✅一等公民,有官方 YuniKorn 集成文档页
Ray / KubeRay✅🔵 整个生态里唯一会自动生成 YuniKorn task-groups 的 operator
Apache Flink✅有官方页,经 podTemplate 打注解(⚠️ 该页已陈旧)
TF / MPI(Kubeflow)✅ 页面⚠️ 官方那两页只演示队列路由,零 gang scheduling
 其余全部靠通用机制或不可用
Argo Workflows / Airflow / Tekton / Dagster🟡都有 schedulerName 旋钮。🔴 共同大坑:YuniKorn 的 ACL 看到的是「编排器的 SA」,不是 DAG 所有者 ⇒ 队列 ACL 无法按最终用户区分
Trino / Presto / StarRocks / Doris / ClickHouse / Druid / Pinot🟡/❌🔴 零个查询引擎有 YuniKorn 集成。但它们是长运行服务——队列配额与抢占保护适用,gang 与公平共享不适用
Kubeflow Trainer / LeaderWorkerSet❌🔴 gang API 是 coscheduling|volcano 的封闭联合,没有 YuniKorn。LWS 的 KEP 点了 YuniKorn 的名而代码只支持 Volcano。NVIDIA NeMo 让你用 KAI Scheduler
Ch.3 · 在 AWS 上怎么用 — 生态集成矩阵46

⏱ 本页 1.3 分钟 · 主线 279 字 · 深潜层另有 1847 字

这一页回答一个必被问到的问题。核心一句: 官方文档覆盖的是 5 类负载 —— Spark、Flink、TensorFlow、MPI、Ray。 其余一切都取决于「你能不能设 schedulerName」, 而那取决于对方的 CRD,不取决于 YuniKorn。

(先讲左边那把钥匙,它能让听众自己判断任何一个新组件) 左边这个判据我建议你们记住,因为它比任何清单都有用。

YuniKorn 的设计取向是不引入新 CRD。 这意味着它不需要对方为它写代码,只需要对方肯让你设一个 schedulerName。

(这个推论是这一页的核心) 所以支持面的边界不在 YuniKorn 这一边,在对方的 CRD 有没有留口子。 三档判据就是从这里来的: 原生支持 = 对方有为 YuniKorn 写的代码或官方文档页; 通用机制可用 = 对方完全不知道 YuniKorn 存在,但它的 CR 暴露了完整 PodSpec; 不可用 = 对方 CRD 是手写字段白名单,没有 schedulerName、没有 podTemplate, 这时只能靠 admission controller 按 namespace 强行接管。

(这个对比很值得讲,因为它解释了一个反直觉现象) 拿 Volcano 对比就清楚了:Volcano 有自己的 PodGroup CRD, 所以对方必须为它写代码 —— 比如 Spark 里的 VolcanoFeatureStep。 门槛更高,但一旦集成就是一等公民。 这也解释了为什么Spark 主干里有 Volcano 的 feature step,是生产代码; 而 YuniKorn 只有集成测试。 (这是双刃剑,两面都要说)YuniKorn 的集成成本极低 —— 打个注解就行; 但你永远拿不到一等公民待遇,因为一等公民恰恰意味着「对方为你写了代码」。

右边这张表我按分组讲,不逐行念。 上半部分是官方文档覆盖的 5 类,注意 /docs/user_guide/workloads/ 整个目录只有 9 页 —— 这个数字本身就说明了覆盖面。

Spark:spark.kubernetes.scheduler.name,从 Spark 3.3.0 起可用; Spark 官方文档有专节 —— 但这里我要给一个精确的限定,因为它常被说错: 最新 GA 的 Spark 4.2.0,文档里钉的是 YuniKorn 1.8.0,不是 1.9.0; 钉 1.9.0 的那个提交还只在 master 上,没有进入任何 GA 版本。 (不过这个限定不影响可用性)那个 pin 只是文档示例里的 helm chart 版本, Spark 与 YuniKorn 之间没有代码耦合 —— 没有 CRD client、没有 jar 依赖 —— 所以 Spark 3.3 以上配 YuniKorn 1.9.0 机制上是可行的,(这一条是推论,不是实测)。 还有一个更值得说的限定:Spark 仓库里 YuniKorn 相关的东西全部落在文档、测试和构建配置里, src/main/ 下一行生产代码都没有。而 Volcano 在 Spark 主干里有 98 行生产代码, 而且那个 maven profile 默认就是打开的 —— 也就是说官方发行包里就带着它。 这就是「一等公民」和「能用」的差别。 Kubeflow Spark Operator:一等公民,有官方 YuniKorn 集成文档页。 Ray / KubeRay:(这是正面例子,值得点出来) 它是整个生态里唯一会自动生成 YuniKorn task-groups 的 operator —— 别的都要你手写注解。 Flink:有官方页,经 podTemplate 打注解,但那一页已经陈旧。 TensorFlow 和 MPI:(这一条要说清) 官方那两页只演示了队列路由,零 gang scheduling —— 所以「有文档页」不等于「gang 能用」。

下半部分是其余的。编排器这一行 —— Argo、Airflow、Tekton、Dagster —— 都有 schedulerName 旋钮,所以通用机制可用。 但它们有一个共同的大坑,对做平台的人特别实用: (这一条建议照念) YuniKorn 的 ACL 看到的是「编排器的 ServiceAccount」,不是 DAG 的所有者。 所以「按用户配额」在 Airflow 场景下天然失效 —— 所有任务在 YuniKorn 眼里都是同一个用户。 解法是在编排器侧把队列作为 DAG 参数传下来,而不是指望 YuniKorn 认出用户。

查询引擎那一行:Trino、Presto、StarRocks、Doris、ClickHouse、Druid、Pinot —— 零个查询引擎有 YuniKorn 集成。 (但这一行的结论不是「不能用」,这个区分很重要) 它们是长运行服务,所以:队列配额和「不被批处理抢占」这两条对它们很有价值; 而 gang 和作业间公平共享对它们没有意义。 用不用 YuniKorn 要看负载形态,不是看组件名。

(最后一行是最刺眼的对比,值得停一下) 最后一行:Kubeflow Trainer 和 LeaderWorkerSet。 同一个 Kubeflow 项目下 —— Spark Operator 对 YuniKorn 是一等公民支持, 而 Trainer 走不通:它的 gang API 是 coscheduling 与 volcano 的封闭联合,没有任何办法填进 YuniKorn。 更刺眼的是:LeaderWorkerSet 的 KEP 文档明确把 YuniKorn 列为目标, 而发布的代码只支持 Volcano。 而 NVIDIA 的 NeMo 平台文档,则让你把 scheduler 设成 KAI Scheduler。

(这个结论要说得很明确,因为它直接影响选型) 所以:YuniKorn 在「大数据 Spark」生态里是一等公民,在「AI 训练」生态里不是。 如果客户的主力负载是分布式训练,这是必须正面回答的选型问题, 不要绕过去。

接下来几页我把这 34 个组件逐个的判定结果摆出来 —— 包括具体怎么调用、gang 能不能用、以及每个的坑。

Ch.3 · 生态支持矩阵 · Criteria & Coverage

三档判据,与 34 个组件的分布 先给判据,再给结论;判据比结论更耐用

✅ 原生
7
对方有为 YuniKorn 写的代码,或有官方文档页专讲 YuniKorn
🟡 通用
20
对方不知道 YuniKorn 存在,但暴露了 schedulerName
❌ 不可用
6
CRD 是手写字段白名单 ⇒ 只剩 AC 按 namespace 接管
— 不适用
1
不产生 Pod、也不需要集成点(Iceberg / Hudi / Delta)

「通用」不是降级说法 它有三条确切的通路

  • ① 在 CR 里直接设 —— schedulerName: yunikorn 写进对方暴露的 PodTemplateSpec
  • ② 让 admission controller 按 namespace 接管 —— yunikorn.apache.org/namespace.enableYuniKorn: "true",对 ❌ 档是唯一路
  • ③ 队列与身份靠 label —— yunikorn.apache.org/app-id、…/queue
反面的硬门槛:utils.go:140-143 先比对 SchedulerName != "yunikorn",不匹配直接返回空 appID ⇒ 没设或写错,所有 label 全白打且不报错。
🔵 钥匙:YuniKorn 不引入新 CRD ⇒ 不需要对方写代码,只要对方肯让你设 schedulerName ⇒ 边界不在 YuniKorn 这边,在对方 CRD 有没有留口子。

对照 Volcano:两种取向,两种代价

维度YuniKornVolcano
要不要对方写代码不要(只认 pod annotation)要(须建 PodGroup CR)
一旦集成的待遇永远是「通用旋钮」一等公民

实测同一份 Spark 主干:Volcano 有 98 行生产代码 VolcanoFeatureStep.scala,YuniKorn 侧为 0。

本页要带走的:判定档位说的是「集成深度」,不是「能不能用」——真正决定你拿到哪些能力的是负载形态与对方 CRD 的口子。
Ch.3 · 生态支持矩阵 — 总览与判据47

⏱ 本页 2.1 分钟 · 主线 432 字 · 深潜层另有 1143 字

我们进生态支持矩阵,一共八页、34 个组件。

先说这一节怎么听: 我不会逐行念。一张 30 行的表逐行念要十分钟,各位一行都不会记住。 我的做法是每页先给分组结论,再挑两三行展开讲透,其余的留在表里, 各位回去当查询表用。还有一点请注意:页面上每格只写了一句结论, 完整的字段路径、版本旁证、命名陷阱都在我嘴里 —— 需要细节的会后跟我要讲稿。

这一页先交代判据,因为判据比结论耐用 —— 结论随版本变,判据不变。 三个符号我一次说明白,后面几页就直接用了。 ✅ 原生,7 个:对方有为 YuniKorn 写的代码,或者有官方文档页专讲 YuniKorn。 🟡 通用,20 个:对方完全不知道 YuniKorn 存在,但它暴露了 schedulerName 或者完整的 PodSpec。 ❌ 不可用,6 个:对方的 chart 是手写字段白名单,物理上没有 schedulerName 这个位置。 另外还有一个「— 不适用」,是表格式那一行,它不产生 Pod。

(这句是全节最重要的一句,建议照念) 判定档位说的是「集成深度」,不是「能不能用」。 🟡 那 20 个里绝大多数是生产可用的,❌ 那 6 个也照样能靠 admission controller 纳进队列配额。看到 🟡 就以为「这个不行」,是误读。

左边卡片是「通用」的三条确切通路,页面上省掉的例子我补上。 第一条,在 CR 里直接写 schedulerName: yunikorn —— 走这条的有 Flink Kubernetes Operator、Dask、StarRocks、Strimzi、ECK, 后面几页各位会看到它们全在 🟡 档; 第二条,给 namespace 打 yunikorn.apache.org/namespace.enableYuniKorn: "true", 让 admission controller 接管 —— 零改动、可单独回滚, 而这对 ❌ 档是唯一的路; 第三条,队列和身份靠两个 label —— yunikorn.apache.org/app-id 和 yunikorn.apache.org/queue, 几乎每个 chart 都留了 podLabels 或者 podAnnotations 的口子。

(这个门槛必须念,它是后面七页共同的第一道判据) utils.go 第 140 到 143 行,第一件事就是比对 pod.Spec.SchedulerName != "yunikorn",不匹配直接返回空的 appID。

所以 schedulerName 没设、或者写错了,你后面打的所有 label 全部白打, 而且不报任何错。

这是 POC 第一天最常翻车的地方, 等一下讲 Airflow 那个全小写参数名时我们还会回到这里。

右上那个蓝框是理解整张表的钥匙: YuniKorn 的取向是不引入新 CRD —— 它不需要对方为它写代码, 只需要对方肯让你设一个 schedulerName ⇒ 支持面的边界不在 YuniKorn 这一侧,在对方的 CRD 有没有留口子。

这一句解释了表里几乎所有异常:Trino、Doris、Pinot、Pulsar 判 ❌, 不是 YuniKorn 缺功能,是它们的 chart 或 CRD 是手写字段白名单 —— 物理上没有 schedulerName 这个位置可以写。

右下是和 Volcano 的取向对比,三行:要不要对方写代码 —— YuniKorn 不要,只认 pod annotation;Volcano 要对方建 PodGroup CR;

接入成本 —— 一个打注解,一个要往上游合一份 feature step; 代价在第三行 —— YuniKorn 永远是那个通用旋钮,Volcano 是一等公民。 实测同一份 Spark 主干:Volcano 有 98 行生产代码 VolcanoFeatureStep.scala,还带一个默认激活的 maven profile; 而 YuniKorn 这一侧 src/main 底下零命中,只有 docs 和集成测试。

所以真正决定你拿到哪些能力的是负载形态和对方 CRD 的口子,不是这个符号。 下一页从主场开始 —— 批处理引擎,Spark 系和 Flink 系, 全表唯一有官方 gang 配方的一类。

Ch.3 · 生态支持矩阵 · Batch Engines

计算引擎与作业框架(一)批处理引擎 · Spark 系与 Flink 系 · 4 个

组件判定gang怎么调用(字段路径)关键事实 / 坑
 YuniKorn 的主场,也是全表唯一有官方 gang 配方的一类—— 但「原生」在这四行里的含金量差别极大
Apache Spark
(原生提交)
✅ 原生部分 spark.kubernetes.scheduler.name Spark 3.3.0 起。src/main/** 零命中 ⇒ ✅ 只来自文档专节 + 集成测试
Kubeflow Spark Operator✅ 原生是 spec.batchScheduler · spec.batchSchedulerOptions.queue v2.0.0 引入,gang 全自动。🔴 minResource 零 GPU,手写 task-groups 被覆盖
Apache Flink
(原生模式)
✅ 原生部分 kubernetes.pod-template-file.jobmanager Flink ≥ 1.13。🔴 官方 gang 配方照抄必失败(4096M vs Mi)。🔴 Flink 仓库 0 处 yunikorn ⇒ native 只是(YuniKorn 自己的)文档页,且该页两条外链实测 404
Flink Kubernetes Operator🟡 通用部分 spec.podTemplate.spec.schedulerName 自 1.0.0 即含 3 处 podTemplate。🔴 JM 被替换 ⇒ placeholder 被 GC 且无重建路径
🔴 Spark Operator 的 GPU gang 是个坑,不是小瑕疵:它算出的 minResource 只含 cpu + memory,GPU 零命中 ⇒ placeholder 不申请 GPU、能占住没有 GPU 的节点; 而你手写的 task-groups 会被 operator 无条件覆盖,想补也补不进去。 ⇒ GPU gang 场景建议不要用它的自动模式。
🔵 「原生」要分含金量:Spark 与 Flink 的 ✅ 都只来自 YuniKorn 一侧的文档页—— Flink 那页两条外链实测 404、Flink 全仓 0 命中,对抗复核认为按严格判据实为通用; Flink Operator 判 🟡 的证据同样干脆:Apache JIRA 搜 yunikorn 命中 0,搜 volcano 95。
Ch.3 · 生态支持矩阵 — 批处理引擎48

⏱ 本页 1.8 分钟 · 主线 380 字 · 深潜层另有 1369 字

这一页只有四行,但它是全节最重要的一页:Spark 系和 Flink 系, YuniKorn 的主场,也是全表唯一有官方 gang 配方的一类,四行里三行判 ✅。

而我要花时间讲的恰恰是:「原生」在这四行里的含金量差别极大。

(Spark 客户一定会问,这一行逐字讲) Apache Spark 原生提交,✅ 原生、gang 部分支持, 字段路径只有一条 spark.kubernetes.scheduler.name,Spark 3.3.0 起。 但 native 的来源要说准:官方文档确实有专节,可是 src/main 底下零命中 ⇒ 这个 ✅ 来自「文档专节加集成测试」,不是生产代码。 还有两个页面上没写的细节:把版本钉到 1.9.0 的那个 commit 尚未进任何 GA —— 最新 GA 4.2.0 的文档里仍然写 1.8.0; 而 gang 是 Spark 侧的空白,task-groups 要你自己整份手写。

Kubeflow Spark Operator,✅ 原生、gang 是「是」,全表含金量最高的一行: spec.batchScheduler: yunikorn 加 spec.batchSchedulerOptions.queue。 版本口径我照实说:operator 侧是 v2.0.0 引入的,而 YuniKorn 文档写 ≥ 2.1.0 —— 两边口径冲突,保守起见对客户报 2.1.0。 它的价值是替你自动生成 driver 和 executor 两个 task group, 你一行 gang 配置都不用写。

(左下红框,这个坑要当场说清,它不是小瑕疵) 它算出来的 minResource 只含 cpu 和 memory、GPU 零命中 ⇒ placeholder 不申请 GPU,于是能占住一台根本没有 GPU 的节点, gang 显示凑齐了、真作业却起不来; 而你手写的 task-groups 会被 operator 无条件覆盖,想补也补不进去。 所以结论很硬:GPU gang 场景不要用它的自动模式 —— 要么退回裸 spark-submit 自己写 task-groups,要么走 KubeRay 那条路。

(Flink 这一行最需要说准:判定照页面念,但复核意见也要说) Apache Flink 原生模式,页面判 ✅ 原生,唯一旋钮是 pod template —— kubernetes.pod-template-file.jobmanager 和 kubernetes.pod-template-file.taskmanager,两个都要给, Flink ≥ 1.13。这个 ✅ 的依据只有 YuniKorn 自己那个 run_flink 文档页; 我们的对抗复核认为按严格判据它其实是「通用」 —— Flink 那一侧全仓 0 命中,而那一页的两条外链实测 404。 再提醒一句:task-groups 这段 JSON 不能走 kubernetes.*.annotations —— 那是 mapType,格式装不下 JSON, 必须写在 pod template 文件的 metadata.annotations 里。

(Flink 的 gang 配方这一条务必念,它是「照抄官方文档就失败」) 官方那份 gang 配方照抄一定失败:minResource 里写的是 十进制的 4096M,而 Flink 自己算出来的容器 request 一定是二进制的 Mi ——

两个数对不上,placeholder 和真 pod 的资源画像不一致,gang 永远换不了手。

把 4096M 改成 4096Mi 这一个字,是 Flink 上线的必做动作。

Flink Kubernetes Operator,🟡 通用,字段是 spec.podTemplate.spec.schedulerName, 另外 spec.jobManager 和 spec.taskManager 底下还各有一处, 一共三处 podTemplate,自 1.0.0 首个 GA 就都有。 判「通用」的证据很干脆 —— Apache JIRA 搜 yunikorn 命中 0,搜 volcano 命中 95。 (坑说全)placeholder 的 ownerRef 指向 JobManager 的 pod, 而且 BlockOwnerDeletion=true ⇒ JM 一被替换,placeholder 全被 GC, 而 v1.9.0 没有任何原地重建路径 ⇒ 整个 application 只能推倒重来。

(这一页的落点) 这四行给客户的实操结论:Spark 走 Spark Operator、非 GPU 场景开自动 gang; GPU 场景自己写 task-groups;Flink 无论哪条路径都要把 minResource 的单位改成 Mi, 并且要接受「JM 重启等于整个 application 重来」这个前提。 下一页还是计算引擎,换成分布式训练 —— 那一批我要正面回答一个客户必问的问题。

Ch.3 · 生态支持矩阵 · Distributed Training

计算引擎与作业框架(二)分布式训练与并行计算 · 4 个

组件判定gang怎么调用(字段路径)关键事实 / 坑
 「AI 训练」生态里 YuniKorn 不是一等公民—— 这一页正面回答,并给出唯一的例外
Ray / KubeRay✅ 原生是 batchScheduler.name=yunikorn · ray.io/gang-scheduling-enabled 🔵 全生态唯一自动生成 task-groups 的 operator(268 行生产代码)
MPI Operator✅ 原生部分 spec.mpiReplicaSpecs.<Role>.template.spec.schedulerName 对方仓库 0 处 yunikorn(volcano 177 处)⇒ native 只是文档页
Kubeflow Trainer
(TFJob / PyTorchJob / TrainJob)
🟡 通用部分 spec.<x>ReplicaSpecs.<Role>.template.spec.schedulerName 🔴 PodGroupPolicySource 是封闭联合,写 yunikorn 被 apiserver 静默 prune
Dask(dask-kubernetes)🟡 通用部分 spec.worker.spec.schedulerName · spec.scheduler.spec.schedulerName 2022.9.0 起;task-groups 放 CR 级 annotation 会自动透传到全部 pod
🔴 KubeRay 那个必须先拆掉的坑:worker 的 minReplicas CRD 默认是 0 ⇒ 产出 minMember: 0,被 k8shim 拒掉整份注解 —— 连 head 的 gang 一起丢,只留一条 Warning Event,pod 照样起来、看着像生效了。
另外三条一句话红线:MPI Operator 绝不要传 --gang-scheduling=yunikorn(catch-all, 缺 PodGroup CRD 时 operator 直接起不来);Trainer 的 gang 只能自己手写 pod annotation(队列路由自 v2.0.0、 per-job task-group 注入自 v2.1.0);Dask 的 KubeCluster(image=…, n_workers=…) 没有 scheduler_name 参数 ⇒ 静默回落默认调度器。
Ch.3 · 生态支持矩阵 — 分布式训练与并行计算49

⏱ 本页 1.9 分钟 · 主线 390 字 · 深潜层另有 1447 字

这一页四行,分布式训练与并行计算。 先正面回答一句客户必问的话:在「AI 训练」这个生态里,YuniKorn 不是一等公民。 Volcano 在这一批里的存在感明显更强,我等一下给各位几个数字。 但有一个例外,而且是全表最亮的一行 —— KubeRay。

Ray / KubeRay,✅ 原生、gang 是「是」—— 全生态唯一会自动替你生成 task-groups 的 operator, 268 行生产代码,这是实打实的。

装的时候有三种等价写法,最常见的是 --set batchScheduler.name=yunikorn; 然后给 RayCluster 打一个 label ray.io/gang-scheduling-enabled。 它生成的 task group 是head 一组、每个 worker group 各一组, 如果是 RayJob,还会多一个 submitter 组 —— 这一点很多人漏掉, submitter 也是真 pod、也占配额。

(左下红框,这个坑必须先拆掉,否则你以为生效了其实没有) worker 的 minReplicas 在 CRD 里默认是 0 ⇒ operator 照实算出 minMember: 0 ⇒ k8shim 认为这是非法值,而它拒掉的是「整份注解」,不是那一个组 —— 连 head 的 gang 一起丢,最后只留一条 Warning Event。 而 pod 照样起来了、作业照样跑,看着完全像生效了。 所以上线前必须显式把每个 worker group 的 minReplicas 设成 ≥ 1, 并且去 Event 里确认没有那条 warning。

MPI Operator 判 ✅ 原生,字段是 spec.mpiReplicaSpecs.<Role>.template.spec.schedulerName, Launcher 和 Worker 两个 Role 都要写。 但它的 native 含金量要说准:只是「YuniKorn 一侧的文档页加一份示例 YAML」—— 对方仓库 0 处 yunikorn,而 volcano 是 177 处; 更说明问题的是,那一页从 1.8.0 到 1.9.0 是 IDENTICAL,一个字没改。

(MPI 这条红线一定要念,它会让 operator 起不来) 绝不要传 --gang-scheduling=yunikorn。

那个参数是个 catch-all:只要值不是它认识的那几个, 它就当成 scheduler-plugins 处理,于是去找 PodGroup CRD —— 你集群里没装 scheduler-plugins 的话,MPI operator 直接起不来。 正确做法是这个参数完全不传,gang 全靠 pod annotation。

Kubeflow Trainer,也就是 TFJob、PyTorchJob、新的 TrainJob,判 🟡 通用, 字段是 spec.<x>ReplicaSpecs.<Role>.template.spec.schedulerName。 换调度器可以,但走 operator 自己的 gang API 走不通: PodGroupPolicySource 是 coscheduling 和 volcano 的封闭联合类型 —— 你写 yunikorn 进去,apiserver 会静默 prune 掉,不报错、字段就消失了。 ⇒ gang 只能自己手写 pod annotation。 版本上:队列路由自 v2.0.0,per-job 的 task-group 注入自 v2.1.0。

Dask,也就是 dask-kubernetes,判 🟡 通用, spec.worker.spec.schedulerName 和 spec.scheduler.spec.schedulerName,2022.9.0 起 CRD 就有, 而且三个 CRD 都是完整的 core/v1 PodSpec,没有任何裁剪。 它有个很舒服的性质:task-groups 放在 CR 级的 annotation 上, 会自动透传到 scheduler 和全部 worker pod —— 天然满足 YuniKorn 要求的「一个 app 里所有 pod 带同一份 taskGroups」。 (但有个静默陷阱)Python 里最标准的 KubeCluster(image=…, n_workers=…) 这种用法, 根本没有 scheduler_name 这个参数 ⇒ 静默回落默认调度器, 必须改成传完整的 spec,或者直接用 CRD 建。

(这一页的落点,建议照念) 同一个 Kubeflow 项目下,Spark Operator 是一等公民、Trainer 走不通 —— 这不是成熟度问题,是「对方的 gang API 是不是封闭联合类型」的问题。 而要在训练侧拿到真正好用的 gang,今天最短的路是 KubeRay, 代价就是那个 minMember: 0 必须先拆掉。 下一页换成交互式和在线推理 —— 那一类的失效方式完全不同。

Ch.3 · 生态支持矩阵 · Interactive & Serving

计算引擎与作业框架(三)交互式网关 · 在线推理与多节点服务 · 6 个

组件判定gang怎么调用(字段路径)关键事实 / 坑
 交互式与网关—— 共同特征:提交者不是最终用户,且会话超时会与排队打架
Apache Kyuubi / Livy🟡 通用部分 spark.kubernetes.scheduler.name=yunikorn Kyuubi 任意版本;Livy 需 0.9.0-incubating。🔴 引擎初始化超时默认 180s
JupyterHub (z2jh)
Kubeflow Notebooks
🟡 通用部分 singleuser.extraPodConfig.schedulerName chart 0.9.0 起。🔴 YuniKorn 无任何闲置回收 ⇒ 闲置 notebook 永久占配额
 在线推理与多节点服务—— gang 的卖点只在多节点大模型;单副本推理服务不要开 gang
vLLM on Ray Serve
(RayService)
✅ 原生部分 metadata.labels 三行(gang / app-id / queue) 继承 KubeRay 生产代码。🔴 蓝绿升级两个 RayCluster 同 app-id ⇒ 静默丢弃
KServe / Seldon Core🟡 通用部分 spec.predictor.schedulerName(多节点另设 …workerSpec) 🔴 v0.20.0 默认 Knative 模式硬拒该字段,须加 deploymentMode: Standard
LeaderWorkerSet (LWS)🟡 通用部分 spec.leaderWorkerTemplate.{leader,worker}Template.spec.schedulerName 代码里只认 volcano。🔴 设 schedulerProvider: yunikorn 是硬失败
NVIDIA NeMo / KAI Scheduler🟡 通用部分 jobs.executors[].config.scheduler_name 🔴 多节点分布式 GPU 只走 volcano_job;KAI 是互斥竞品
本页要带走的:共同失效模式不是「设不上」,而是「设上了但被别人接手」—— Knative 的 podspec 白名单、LLMInferenceService 的 label 前缀白名单、LWS 的 provider 白名单、NeMo 的 volcano_job 硬路径, 四种白名单、四种静默方式;上线前必须逐 pod 核验 {.spec.schedulerName}。
Ch.3 · 生态支持矩阵 — 交互式网关与在线推理50

⏱ 本页 1.4 分钟 · 主线 289 字 · 深潜层另有 2381 字

这一页 6 个组件,两批。 上面两行是交互式与网关,共同特征是这一批所有坑的根源: 提交者不是最终用户,而且会话超时会跟排队打架 —— 两行都是 🟡 通用。

Kyuubi 和 Livy 走 Spark 那条透传, spark.kubernetes.scheduler.name=yunikorn。 写在哪里页面上省了,我补全:Kyuubi 写 kyuubi-defaults.conf、Livy 写 spark-defaults.conf; 想让用户改不掉,服务端强制走 kyuubi.batchConf.spark.* 这个前缀。 Kyuubi 任意版本都行 —— 透传能力自始存在,我们在 v1.12.0 上逐行核实过, 两端都有上游单测背书; Livy 必须 0.9.0-incubating —— 0.8.0 上根本没有 SparkKubernetesApp 这个文件。

(这个坑很典型,值得展开) kyuubi.session.engine.initialize.timeout 默认 180 秒: 你一开 gang,driver 就要排队;一超过 180 秒,Kyuubi 直接放弃引擎并报错, 而 placeholder 还占着资源没走 —— 于是你既没拿到引擎、又赔掉了资源。 必须让 placeholderTimeoutInSeconds 明显小于它, 让 YuniKorn 先认输、先把资源退回来。

JupyterHub 的 z2jh 加 Kubeflow Notebooks,🟡 通用: singleuser.extraPodConfig.schedulerName,队列和身份走 singleuser.extraLabels 和 extraAnnotations。 chart 0.9.0 起,我们实测 bisect 过、0.8.2 没有。 能力上很干净:那段 schema 是 additionalProperties: true, 真 PodSpec 直通,而且实测能覆盖掉 z2jh 自带的 user-scheduler。

(下面这条建议主动说,它是最容易踩的运营坑) YuniKorn 没有任何闲置回收机制 —— 它全部的超时只有三个: 30 秒、72 小时、15 分钟,而这三个都跟闲置 pod 无关 ⇒ 闲置的 notebook 永久占着配额, 只能靠 JupyterHub 自己的 cull;而 cull 是按 last_activity 算的, 一个持续忙的 kernel 永远不会被杀。 ⇒ 数据科学团队的 notebook 必须单独切一个队列并给死上限, 不能和批作业共池。

第二批,在线推理,共同结论先给: gang 的卖点只在「多节点大模型」这一种场景 —— 单副本的推理服务不要开 gang。

vLLM on Ray Serve,也就是 RayService,✅ 原生 —— 它继承 KubeRay 那 268 行代码,只要三行 label 就够: ray.io/gang-scheduling-enabled、 yunikorn.apache.org/app-id、yunikorn.apache.org/queue。 机制上是 RayService 的 labels 和 annotations 被 maps.Copy 全量复制给它管的 RayCluster。 但要说准:Ray 官方那个 yunikorn 文档页只点名 RayCluster 和 RayJob, 从没提过 RayService ⇒ 源码级可用、文档级空白。

(RayService 最阴的坑,蓝绿升级时才暴露) 蓝绿升级时 active 和 pending 两个 RayCluster 拿到完全相同的 app-id, 而 YuniKorn 遇到已存在的 appID 会直接 return ⇒ 新集群那份 task-groups 被静默丢弃, 也就是说升级路径上 gang 是失效的 —— 而这恰恰是你最需要它的时候。

(KServe 这一行我最建议各位当场记下来,它是 POC 第一天最容易翻车的点) KServe 和 Seldon Core,🟡 通用。KServe 是 spec.predictor.schedulerName,多节点还要另设 spec.predictor.workerSpec.schedulerName; Seldon 是 Server.spec.podSpec.schedulerName,路径完全不同。 坑在这里:KServe v0.20.0 出厂默认是 Knative 模式,而 Knative 直接拒绝 schedulerName —— feature flag kubernetes.podspec-schedulername 默认 Disabled,webhook 报 must not set the field(s)。 它不是静默忽略,是硬拒绝。 解法是给 CR 加注解 serving.kserve.io/deploymentMode: Standard。

还有一条 KServe 的:LLMInferenceService 的 metadata.labels 有 prefix 白名单,yunikorn.apache.org/* 会被静默丢弃, 得改用 spec.labels。 LeaderWorkerSet:leader 和 worker 两个 template 都要写 schedulerName,漏一个就是半接管。 KEP-407 里三次点名 YuniKorn,但代码是 SupportedSchedulerProviders = sets.New("volcano") ⇒ 你设 gangSchedulingManagement.schedulerProvider: yunikorn 是硬失败 —— 白名单校验不过,controller 起不来,不是静默忽略。 而且 LWS 侧的 gang 只能做到「一个 LWS 对象等于一个 application」这个粒度。

NVIDIA NeMo 与 KAI:旋钮是 jobs.executors[].config.scheduler_name, 前提是 backend: kubernetes_job, NeMo Platform v0.3.0 起有这个旋钮。 它的官方立场很清楚:文档索引里 yunikorn 出现 0 次, 被点名的第三方调度器是 Volcano(有独立安装页)和 KAI。 而多节点分布式 GPU 只走 volcano_job 后端 —— 最需要 gang 的那条路被 Volcano 的 CRD 硬占了; KAI 跟 YuniKorn 是互斥竞品,因为 schedulerName 是单值字段, 它不是集成对象。

(这一页的落点,建议照念) 这一类的共同失效模式不是「设不上」,而是「设上了但被别人接手」 —— Knative 的 podspec 白名单、LLMInferenceService 的 label 前缀白名单、 LWS 的 provider 白名单、NeMo 的 volcano_job 硬路径,四种白名单、四种静默方式。 下一页是编排器 —— 五行判定完全一致,但它们共享一个结构性大坑。

上线前请逐个 pod 跑一次 kubectl get pod -o jsonpath='{.spec.schedulerName}' 核验 —— 这是唯一一个能同时兜住这四种静默的检查动作。

Ch.3 · 生态支持矩阵 · Orchestrators

编排器与流水线 5 个全是 🟡 通用,且共享同一个结构性大坑

组件判定gang怎么调用(字段路径)关键事实 / 坑
 判定一致(🟡 通用 / gang 部分)· 差别全在「哪个字段名会静默失效」
Apache Airflow🟡 通用部分 KubernetesPodOperator(schedulername=…) 参数名全小写、无下划线;写成 scheduler_name 不报错、pod 静默回落
Argo Workflows🟡 通用部分 spec.schedulerName · spec.templates[].schedulerName spec.parallelism < minMember ⇒ 死锁到 placeholder 超时
Tekton Pipelines🟡 通用部分 spec.taskRunTemplate.podTemplate.schedulerName v0.11.0 起。🔴 Affinity Assistant 的 template 没有 SchedulerName(见右下)
Dagster🟡 通用部分 runLauncher.config.k8sRunLauncher.schedulerName 1.0.8 起。step pod 默认不继承 job 级 tag ⇒ 半接管,配额算不准
Prefect🟡 通用部分 work pool base job template 的 spec.template.spec.schedulerName {{ name }} 只对 generateName 有效 ⇒ 拿不到逐 run app-id
🔴 5 个编排器共享的结构性大坑:ACL 看到的是编排器的 ServiceAccount,不是 DAG 所有者。 确证链五跳全在 v1.9.0 源码里:admission_controller.go:169 取 req.UserInfo.Username → 写入 yunikorn.apache.org/user.info → GetUserFromPod 读回 (metadata.go:106 注释原文「user info is retrieved via service account」)→ core 的 CheckSubmitAccess。⇒ 「按用户配额 / 按 DAG owner 分队列」在 YuniKorn 侧物理上不可能。 更糟:默认配置下自己塞 user.info 会被 webhook 拒绝而不是忽略 ⇒ 任务直接失败。 修法是把编排器 SA 加进 accessControl.externalUsers —— 代价是任何能改 DAG 的人都能冒充任意租户,真正的边界必须放在编排器一侧。

Tekton 那条要说准 对抗复核已修正口径

❌ 不要说成「PVC 亲和失效」—— 共置保证本身不失效。
✅ 真实危害:AffinityAssistantTemplate 结构里没有 SchedulerName 字段 ⇒ 用 workspace + PVC 时 AA Pod 走 default-scheduler ⇒ 整条流水线的落点被它钉死,YuniKorn 失去队列与装箱的话语权; 落点不佳时 TaskRun 的硬亲和无法降级,长时间 Pending。
⚠️ 触发条件在真实 CI 默认满足:AA 默认开着。

Ch.3 · 生态支持矩阵 — 编排器与流水线51

⏱ 本页 2.0 分钟 · 主线 420 字 · 深潜层另有 2196 字

这一页 5 个编排器,好消息是判定完全一致 —— 五个全是 🟡 通用、gang 全是部分支持。 所以我不逐行讲判定,差别全在「哪一个字段名会静默失效」; 挑两行展开,然后把下面那个共享的大坑讲透 —— 那才是这一页的重点。

(Airflow 这个坑很小,但它一定会咬人) Apache Airflow:单任务写 KubernetesPodOperator(schedulername="yunikorn"), 全局走 pod_template_file,单个任务想覆盖走 pod_override。

注意那个参数名 —— schedulername,全小写、没有下划线。 (停一下)写成 scheduler_name 会怎样? 不报错,pod 静默回落默认调度器 —— 接上我刚才说的 utils.go 那道门槛,你打的 queue label 也一起白打。

另外 schedule_timeout_seconds 需要 provider 10.5.0, 而且默认仍回落到 120 秒 —— 它会直接杀掉正在 YuniKorn 队列里排队的任务, 这一条和 Kyuubi 那个 180 秒是同一类问题。

Argo Workflows:旋钮全在 CRD schema 里 —— spec.schedulerName、spec.templates[].schedulerName, 元数据走 spec.podMetadata; 集群级强制走 controller configmap 里的 workflowDefaults, 这是最推荐的做法。template 级优先于 workflow 级,而且有上游单测钉住。 三条坑:一,podSpecPatch 只作用于 PodSpec,改不了 label 和 annotation,所以别指望用它补 app-id; 二,spec.parallelism 小于 minMember 会死锁 —— Argo 不肯再起 pod、gang 永远凑不齐,一直卡到 placeholder 超时,默认 15 分钟; 三,placeholder 的 minResource 必须算上 Argo 注入的 wait 容器, 漏算就是 placeholder 比真 pod 小,换手时资源不够。

剩下三行给一句话结论,细节我补在这里。Tekton: spec.taskRunTemplate.podTemplate.schedulerName,v0.11.0 起, 实测 v0.10.1 没有;v1beta1 的位置是 spec.podTemplate, 逐个 task 覆盖走 spec.taskRunSpecs[].podTemplate。 官方文档已经认可换调度器,但它举的例子是 schedulerName: volcano —— 这个细节很能说明生态位。 Dagster:runLauncher.config.k8sRunLauncher.schedulerName, 1.0.8 起;每个 step 还要单独设 execution.config.scheduler_name, 因为 step pod 默认不继承 job 级 tag,include_run_tags=False ⇒ 只设一处就成了「run pod 在 YuniKorn 队列、step pod 走 default-scheduler」的 半接管,配额算不准。 而且 run pod 是编排进程,跟 step 共用一个吃紧的队列会互相等到死锁,必须分队列。

Prefect:写在 work pool 的 base job template 里, spec.template.spec.schedulerName; job_manifest 是自由字典,校验器只做下界检查, 所以我们实测过注入是存活的 —— label、annotation、整段 task-groups JSON 全部原样保留。 (但模板变量是个坑){{ name }} 只对 metadata.generateName 有效:写进 pod label 时如果没设 name 会被静默删除;而写 {{ ctx.flow_run.id }} 会变成字面量字符串 ⇒ 你拿不到逐 run 唯一的 app-id, 只能去开 YuniKorn 侧的 generateUniqueAppIds=true 让它自己编。

(下面这个红框是这一页真正的重点,建议逐字念 —— 很多 POC 到中期才发现) 五个编排器共享同一个结构性大坑:YuniKorn 的 ACL 看到的是编排器的 ServiceAccount, 不是 DAG 的所有者。

确证链五跳全在 v1.9.0 源码里:admission_controller.go:169 取 req.UserInfo.Username → 写进 yunikorn.apache.org/user.info → GetUserFromPod 读回,metadata.go:106 的注释原文就是 「user info is retrieved via service account」→ 喂给 core 的 CheckSubmitAccess。

结论:「按用户配额」「按 DAG owner 分队列」在 YuniKorn 这一侧物理上不可能。

(更糟的一层,一定要说) 你可能想「那我自己塞一个 user.info 进去」—— 默认配置下自己塞会被 webhook「拒绝」,不是被忽略: bypassAuth=false、externalUsers="",三档全不中 ⇒ 任务直接失败。 修法是把编排器的 SA 加进 accessControl.externalUsers, 但代价必须说明白:之后任何能改 DAG 的人都能冒充任意租户, 用户维度的隔离退化成「DAG 代码库的写权限」。 所以真正的用户边界必须放在编排器那一侧。

右下卡片是 Tekton 的口径修正,对抗复核改过,要说准。 不要说成「PVC 亲和失效」—— 共置保证本身不失效:

TaskRun Pod 的硬 podAffinity 是由 YuniKorn 的 InterPodAffinity 谓词执行的, Affinity Assistant 的 Pod 也被 YuniKorn 记成 foreign allocation,它看得见。 真实危害是 AffinityAssistantTemplate 这个结构里根本没有 SchedulerName 字段 —— 是显式丢弃 ⇒ 一用 workspace 加 PVC,AA Pod 就走 default-scheduler ⇒ 整条流水线的落点节点被 default-scheduler 钉死,YuniKorn 只能接受, 失去队列和装箱的话语权;落点不好时 TaskRun 的硬亲和无法降级, 一直 Pending 并吃掉 TaskRun timeout —— 默认 60 分钟,而且含排队时间。 触发条件在真实 CI 里默认满足:coschedule 默认就是 workspaces,AA 默认开着。

下一页换个画风 —— 查询引擎和 OLAP,零个组件有 YuniKorn 集成, 但我要说清为什么这不等于「不能用」。

Ch.3 · 生态支持矩阵 · Query Engines & OLAP

查询引擎与 OLAP 零个有 YuniKorn 集成 —— 但这不是「不能用」

组件判定gang怎么调用(字段路径)关键事实 / 坑
 双向零集成(两边仓库互相 grep 都是 0 命中)· 差别只在「chart 有没有留口子」
Trino❌ 不可用否 只剩 ns 注解 …/namespace.enableYuniKorn(queue 走 coordinator.labels) 🔴 coordinator: replicas: 1 硬编码 ⇒ 队列 max 卡死 = Trino 整体不可用
PrestoDB❌ 不可用否 coordinator.podAnnotations / worker.podAnnotations 仅 main 分支;🔴 --set schedulerName= 被 helm 静默吞掉、退出码 0
StarRocks🟡 通用部分 spec.starRocksFeSpec.schedulerName(+ BE / CN / FE-Proxy) operator v1.7.0 起。⚠️ Helm chart 漏渲染 fe-proxy 那一处
Apache Doris❌ 不可用部分 CR 里写不了;只有 spec.feSpec.podLabels / annotations schema 逐属性穷举 ⇒ 字段不存在的正面证明。🔴 AC webhook failurePolicy=Ignore
ClickHouse (Altinity)🟡 通用部分 spec.templates.podTemplates[].spec.schedulerName 该字段的 Go 类型就是 core.PodSpec 本体 —— 最干净的一个
Apache Druid🟡 通用部分 面 B 才可用:customTemplateAdapter + pod template 的 spec.schedulerName 三面分开看:常驻 CRD 不可用 / peon Job 可用(26.0.0 起)/ 经典 MM 不适用
Apache Pinot❌ 不可用部分 只剩 AC 接管 + <component>.podAnnotations(实测渲染有效) chart 是手写 PodSpec 白名单,已发布版与 master 全部 0 命中
🔵 这一页的落点(必须原样讲):它们是长运行服务,所以「适用」与「不适用」要分开说。 ✅ 适用:队列 max 配额、guaranteed + 抢占、preemption fence、allow-preemption: "false" 保护。 ❌ 不适用:gang scheduling、查询间公平共享 —— 查询级公平只能由 Trino / Presto 自己的 resource groups 在进程内做。 ⇒ 用不用要看负载形态,不是看组件名。
Ch.3 · 生态支持矩阵 — 查询引擎与 OLAP52

⏱ 本页 1.3 分钟 · 主线 276 字 · 深潜层另有 2388 字

这一页 7 个查询和 OLAP 引擎,共同结论一句话给完: 双向零集成 —— 两边仓库互相 grep 都是 0 命中,没有一个引擎知道 YuniKorn 存在。

所以判定的差别只在一件事:它的 chart 有没有留口子 —— 留了的判 🟡 通用,手写白名单的判 ❌ 不可用。

(Trino 是客户问得最多的一个,这一行我讲透) Trino,❌ 不可用、gang 是「否」。

为什么?官方 chart 的 pod spec 是手写字段白名单 —— 跑 helm template 渲染出来,schedulerName 零行。 只剩一条路:给 namespace 打 yunikorn.apache.org/namespace.enableYuniKorn: "true" 让 AC 接管, 队列和 app-id 走 coordinator.labels 和 worker.labels, 我们 helm template 实测过,这两个能落到 pod template 上; 提醒一句务必用 -f 传 values 而不是 --set。

(下面两条坑是 Trino 专属的,很致命) 第一,coordinator: replicas: 1 是硬编码、values 调不了 ⇒ 队列 max 一卡死,coordinator 就 Pending ⇒ 整个 Trino 不可用,不是变慢 —— 这是可用性事件,不是性能事件。 第二,chart 默认 priorityClassName: ~,也就是空 ⇒ AC 把 allow-preemption 写成 true ⇒ 批处理一饿就抢掉 Trino worker,正在跑的查询直接失败。 所以 Trino 上线的两个必做动作:给它的队列留死额度,并且显式把 allow-preemption 打成 "false"。

另外两个 ❌ 一起说,因为证据类型不同。 Apache Doris:我们把三份 CRD 的 OpenAPI schema 逐属性穷举, 确认 schedulerName、podTemplate、 priorityClassName 三个都不存在 —— 这是「字段不存在」的正面证明,不是「我 grep 不到」。 它另有一条运维坑:AC 的 webhook 是 failurePolicy=Ignore —— AC 挂了或者证书过期时,新 pod 静默落回 default-scheduler, 不报错、也不在任何队列里,你的配额账本会凭空少掉一整个集群。

Apache Pinot:chart 同样是手写 PodSpec 白名单,已发布版和 master 全部 0 命中,而且 Apache 没有官方 operator、第三方的都停更了。 Pinot 还有两个陷阱:别用 additionalMatchLabels 打 YuniKorn 的 label, 它会同时喂给 spec.selector.matchLabels, 在已运行的 release 上会撞不可变限制; 还有个命名陷阱 —— controller.task.scheduler.enabled 是 Helix minion 的任务调度器,跟 k8s 调度毫无关系。

四个 🟡 我给结论加关键旁证。 PrestoDB:(这一个我们改过判定,值得说一句)我们最初判它「通用机制可用」,但对抗复核把这个判定推翻了 —— 我们把它判成「不可用」。理由一会儿说。它名义上只能走 coordinator.podAnnotations 和 worker.podAnnotations,而且只在 chart 的 main 分支有效 —— 已发布的 presto-0.4.0 上是空操作;chart 完全没有 podLabels, 所以只能退到 annotation。 --set schedulerName=yunikorn 会被 helm 静默吞掉 —— 渲染零命中、退出码 0,也就是「设置成功但完全无效」。 再一个命名陷阱:Presto 自己也有个 schedulerName, 那是 Router 的查询路由器,跟 pod 的字段毫无关系,别搞混。

StarRocks:spec.starRocksFeSpec.schedulerName、 starRocksBeSpec,加上 CN、FE-Proxy、Warehouse, operator v1.7.0 起;我们做了 CRD schema 实解, 确认四个组件全有,而且真消费点唯一、不是死字段。 operator 默认 podManagementPolicy=Parallel,这对 gang 凑齐有利。 但 Helm chart 漏渲染了 fe-proxy 那一处 —— CRD 有、模板没有, 是个半接管的账目黑洞。 ClickHouse,Altinity operator:最干净的一个 —— spec.templates.podTemplates[].spec.schedulerName, 那字段的 Go 类型就是 core.PodSpec 本体, CRD 里是 x-kubernetes-preserve-unknown-fields: true, 运行时整份 DeepCopy 无过滤,绑定点是 spec.defaults.templates.podTemplate 等四处。 但有一条要提醒:只要装了 AC,即使你完全不想让它调度 ClickHouse, 它也会往 StatefulSet 注入 user.info ⇒ 触发一次滚动重启。

(Druid 单独展开,它是全表唯一「一个组件三种判定」的) 面 A,常驻服务的 CRD:不可用 —— schema 里没这个字段,又没有开 preserve-unknown, 写了会被静默 prune。 面 B,MM-less 的 peon Job:可用而且很干净 —— 设 druid.indexer.runner.k8s.adapter.type=customTemplateAdapter, 然后在 pod template 里写 spec.schedulerName, Druid 26.0.0 起,走的是 fabric8 强类型反序列化,不会被吞。 面 C,经典 MiddleManager 和 Indexer:不产生 pod,不适用。 还有一条:默认那个 adapter 会让 peon「自动继承」父进程的 yunikorn, 却是零 queue、零 app-id 控制 —— 看着在用,其实全挤在一个默认队列里。

(蓝框是这一页的落点,建议原样讲) 零个查询引擎有 YuniKorn 集成 —— 但它们是长运行服务, 所以「适用」和「不适用」必须分开说。 ✅ 适用:队列 max 配额、guaranteed 加抢占、preemption fence、 以及 allow-preemption: "false" 这种保护。 ❌ 不适用:gang scheduling,以及查询之间的公平共享

—— 因为查询级公平只能由 Trino 或 Presto 自己的 resource groups 在进程内做, YuniKorn 看到的是一坨常驻 worker pod,它不知道里面跑了几个查询。

所以用不用要看负载形态,不是看组件名 —— 同一个 Druid,常驻那面不可用、peon 那面很干净,就是这个道理。

下一页是流、检索和表格式 —— 有三个共性代价,还有那个唯一的「不适用」要说清。

Ch.3 · 生态支持矩阵 · Streaming, Search & Table Formats

流、检索与表格式 长驻有状态服务的三个共性代价 + 一个「不适用」要说清

组件判定gang怎么调用(字段路径)关键事实 / 坑
 流与检索—— 共性:接入 = 一次全量滚动重启;队列打满对它们不是排队,是可用性事件
Apache Kafka (Strimzi)🟡 通用部分 KafkaNodePool.spec.template.pod.schedulerName Strimzi 0.15.0 起、NodePool 路径自 0.36.0。🔴 template.pod 整块替换
Apache Pulsar❌ 不可用部分 只剩 AC 接管;元数据走 .Values.labels + <component>.annotations helm template 出 11176 行,schedulerName 命中 0
Elasticsearch (ECK)
OpenSearch Operator
🟡 通用部分 ECK:spec.nodeSets[].podTemplate.spec.schedulerName(须 …/v1) 判定分裂:ECK 可用;OpenSearch Operator 到 v2.8.0 / main 仍无该字段 ⇒ 不可用
 表格式—— 唯一的「— 不适用」,但它不是「用不上」,是调度问题在另一层已经解决了
Iceberg / Hudi / Delta— 不适用否 本体无字段;维护作业走 spec.batchScheduler: yunikorn(spark-operator ≥ 2.1.0) 不含 Operator / CRD、不产生 Pod ⇒ 无集成点;维护作业 100% 走 Spark 路径
🔴 这一批共有的两条硬约束:① 首次接入必然触发全量滚动重启(schedulerName 进 PodRevision 的 SHA1,无字段级豁免);② gang 只在 day-0 首次创建生效 —— 扩容 / 滚动重启 / 单 pod 重建都不建 placeholder。 OpenSearch 另有致命坑:issue #1364(OPEN)点名「改 schedulerName 的 mutating webhook」会让 bootstrap pod 每 ~2 秒 delete+recreate 死循环 ⇒ 整个集群完全不可用。
🔵 「不适用」≠「用不上」:表格式的调度需求全部落在维护作业上, 而维护作业最适合放低优先级可抢占队列。但要配套:抢占会留 orphan files ⇒ 必须周期性 remove_orphan_files / VACUUM,否则对象存储成本反向上升。 而「作业间互斥」是一致性语义,YuniKorn 不提供 —— 得靠 Airflow / Argo 依赖或表级锁。
Ch.3 · 生态支持矩阵 — 流、检索与表格式53

⏱ 本页 1.9 分钟 · 主线 404 字 · 深潜层另有 1815 字

这一页两批:上面三行是流与检索,下面一行是表格式,也就是全表唯一那个「— 不适用」。 第一批的共性三句话:一,接入等于一次全量滚动重启; 二,队列打满对它们不是排队、是可用性事件; 三,它们都是长驻有状态服务,gang 的价值非常有限。

(Kafka 这一行的坑最隐蔽,我讲透) Apache Kafka,Strimzi,🟡 通用。主字段是 KafkaNodePool.spec.template.pod.schedulerName; 另外 Kafka.spec 底下的 kafka、entityOperator、cruiseControl、 kafkaExporter 也各有一处 template.pod.schedulerName, 一个都不能漏。 Strimzi 0.15.0 起有这个字段,KafkaNodePool 这条路径自 0.36.0, 而 node pool 从 0.48.0 起默认启用 —— 也就是说新集群默认走的就是那条新路径。

(下面这句是这一页最值得记的) KafkaNodePool 的 template.pod 是整块替换,不是深合并

—— 某个 pool 只要为了 zone affinity 写过 template.pod, 你在 Kafka CR 级设的 schedulerName 就被静默丢弃、没有任何 warning

⇒ 必须逐个 pool 写。

还要提前跟客户打招呼:首次接入必然触发全 broker 滚动重启 —— schedulerName 会进 PodRevision 的 SHA1,没有字段级豁免, 所以这件事要排在维护窗口里做,不能顺手改。

Apache Pulsar,❌ 不可用。

决定性证据不是 grep,而是渲染产物: helm template 出 11176 行、 7 个 StatefulSet 加 6 个 Job 加 3 个 Deployment 加 1 个 DaemonSet, schedulerName 命中 0。 broker.schedulerName: yunikorn 这种直觉写法被静默忽略, 而且 helm 退出码是 0 —— 你以为设上了。所以只剩 AC 按 namespace 接管。 元数据的写法:全局走 .Values.labels, 它经 pulsar.template.labels 落到每个 pod; 逐组件走 <component>.annotations。 注意别用 appAnnotations —— 那个打在 STS 对象上、不传给 pod; 另外那 2 个 cleanup hook Job 连 label 入口都没有,它们永远进不了队列。

Elasticsearch 这一行判定是分裂的,必须分开讲,不能笼统说「可用」。

ECK 可用:spec.nodeSets[].podTemplate.spec.schedulerName, apiVersion 必须是 …/v1,写 v1beta1 会被 prune; 机制上 ECK 那份 CRD 是 PreserveUnknownFields, 而且 ECK 自己既不设也不清空这个字段,所以你写进去就是你的。 但 OpenSearch 的 k8s Operator 到 v2.8.0 和 main 仍然没有这个字段 ⇒ 该路径不可用 —— 客户如果用的是 OpenSearch Operator, 今天只能走 AC 接管那条路。

(左下红框,两条硬约束加一个致命坑) 第一,首次接入必然触发全量滚动重启,理由就是刚才那个 PodRevision SHA1; 第二,gang 只在 day-0 首次创建生效 —— 扩容、滚动重启、单 pod 重建 都不建 placeholder,所以别指望 gang 能保护扩容过程。 而 OpenSearch 有一个致命坑:issue #1364 目前还是 OPEN, 点名说「改 schedulerName 的 mutating webhook」会让 bootstrap pod 每两秒 delete 加 recreate 死循环 ⇒ 整个集群完全不可用。 ⇒ OpenSearch Operator 上千万不要用 AC 自动注入,先在测试集群验证。

(表格式这一行按下面的顺序讲,因为客户第一反应往往是「那这个不用聊了」) Iceberg、Hudi、Delta 判「— 不适用」:它们是「文件布局加元数据协议加引擎侧的库」, 不含 Operator、不含 CRD、不产生任何 Pod ⇒ 跟 YuniKorn 没有也不需要集成点。

(但下半句才是重点) 它们的维护作业 100% 是 Spark 或 Flink 作业: Iceberg 的 rewrite_data_files 和 expire_snapshots 是 Spark SQL 的 stored procedure,Hudi 的 HoodieCompactor 是 standalone 的 Spark main 类,Delta 的 OPTIMIZE 和 VACUUM 是 Catalyst 命令 ⇒ 走 Spark 那条路径,前面讲的判定和坑全部继承过去: spec.batchScheduler: yunikorn 加 spec.batchSchedulerOptions.queue,spark-operator ≥ 2.1.0, 裸提交要 Spark ≥ 3.3.0。

(这一页的落点,建议照念) 「不适用」不等于「用不上」 —— 表格式的调度需求全部落在维护作业上, 而维护作业恰恰最适合放进低优先级可抢占队列。

但要配套两件事。 第一,抢占会留下 orphan files —— Iceberg 官方文档明说 job failures can leave unreferenced files, 所以必须周期性跑 remove_orphan_files、HoodieCleaner 或者 VACUUM,否则对象存储成本反向上升,省了 EC2 赔进 S3。 第二,「作业之间互斥」是一致性语义,YuniKorn 不提供 —— 它调度资源、不管一致性, 得靠 Airflow 或 Argo 的依赖,或者表级锁。

最后一页回到 AWS —— 四条路,判定跨了三档,是这一节唯一值得逐条讲透的一页。

Ch.3 · 生态支持矩阵 · On AWS

AWS 侧的四条路 一条官方背书、一条是竞品、一条机制互斥、一条要看 NodePool

组件判定gang怎么调用(字段路径)关键事实 / 坑
 4 个 AWS 侧对象 · 判定跨了三档 —— 这一页值得逐条讲透
EMR on EKS✅ 原生是 spec.batchScheduler: yunikorn + spec.batchSchedulerOptions.queue AWS 有 YuniKorn 专属文档页(2023-08-06)+ data-on-eks 52 处命中
SageMaker HyperPod
task governance
🟡 通用部分 HyperPodPyTorchJob.spec.replicaSpecs[].template.spec.schedulerName 它就是 AWS 托管的 Kueue ⇒ 与 YuniKorn 是竞争而非无关
AWS Batch on EKS❌ 不可用否 唯一该做的是排除:admissionController.filtering.bypassNamespaces AWS 原文:Batch 预绑 nodeName ⇒ 任何调度器都不被调用
EKS Auto Mode / Karpenter
Fargate
🟡 通用部分 spec.template.spec.schedulerName + karpenter.sh/do-not-disrupt: "true" Auto Mode 允许自定义调度器(AWS sample 装 chart 1.9.0);Fargate 互斥

① EMR 教程的参数名缺陷

教程两处都写 placeholderTimeoutSeconds=30,漏了 In; k8shim 唯一接受的键是 placeholderTimeoutInSeconds。解析 switch 无 default 分支 ⇒ 连 warn 都不打,timeout 回落 15 分钟(30 倍偏差)。
而同行的 gangSchedulingStyle=Hard 解析正确 ⇒ 真实症状是 placeholder 占着节点 15 分钟然后作业失败。

② HyperPod 走的是另一条路线

官方原文:add-on installs Kueue(v1.6.0-eksbuild.1 → Kueue v0.19.2)。 分层不同:Kueue = admission gate,YuniKorn = 替换 kube-scheduler 的 placement 层。
🔴 add-on 强制独占 Kueue、SageMaker 会覆写你手改的 Kueue 资源; 若在 labels 里手抄了 kueue.x-k8s.io/queue-name, placeholder 被加 gate ⇒ gang 永久死锁。

③ Fargate 为什么是互斥

Fargate 的调度身份就是 spec.schedulerName == fargate-scheduler, 由控制面 mutating webhook 注入。AWS OFFICIAL KB 明说 pod spec 里设了 schedulerName 会让 fargate-scheduler skip the pod ⇒ 一个字段,两个主人,无解。
就算能设价值也≈0:无 GPU、无 Spot、不能挂 EBS。

Ch.3 · 生态支持矩阵 — AWS 侧54

⏱ 本页 1.8 分钟 · 主线 370 字 · 深潜层另有 2718 字

最后一页,AWS 侧四个对象。只有四行,但判定跨了三档,每一行性质都不同: 一条是官方背书、一条其实是竞品、一条机制上互斥、一条要看你的 NodePool 怎么配。

所以这一页我逐条讲。

第一行,EMR on EKS,✅ 原生、gang 是「是」—— AWS 侧唯一真有官方背书的,

路径就是 Spark Operator 那一套:spec.batchScheduler: yunikorn 加 spec.batchSchedulerOptions.queue。 提醒一句:AWS 那份教程漏了 batchScheduler 那一行, 只写了 batchSchedulerOptions;data-on-eks 的示例才是全的。 背书有三份证据:AWS 有 YuniKorn 专属官方文档页,2023 年 8 月 6 日发的; 有 Big Data 博客;还有组织维护的 IaC —— terraform-aws-eks-data-addons 里有 yunikorn.tf, data-on-eks 里 52 处命中。

(下面这个不对等必须主动说,别让客户自己发现) Volcano 写进了 EMR 6.11.0 release note 的 Notable features, 而 YuniKorn 从未出现在任何一份 release note 里。 而且官方只背书 Spark Operator 和 spark-submit 两条路径 —— 最常用的 StartJobRun 不在教程覆盖内, 也就是说客户如果走 StartJobRun API,这条路要自己验。

(左下卡片,这个强烈建议逐字念,它是一个 30 倍的偏差) EMR 教程两处都写 placeholderTimeoutSeconds=30 —— 漏了中间那个 In;k8shim 唯一接受的键是 placeholderTimeoutInSeconds。 而那段解析的 switch 没有 default 分支 ⇒ 连 warn 都不打, timeout 回落到 15 分钟。 (更阴的是下面这半句) 同一行里的 gangSchedulingStyle=Hard 解析是正确的 ⇒ 照抄教程的真实症状是:placeholder 占着 EC2 节点 15 分钟,然后作业直接失败, 不是你预期的 30 秒。 生产上我建议 Soft 加 300 秒量级 —— 这个量级要配合 Karpenter 的扩容时间来定,不是拍脑袋。

第二行,SageMaker HyperPod 的 task governance,🟡 通用,

训练侧字段是 HyperPodPyTorchJob.spec.replicaSpecs[].template.spec.schedulerName, 推理侧是 InferenceEndpointConfig.spec.kubernetes.schedulerName。

但重点不是字段,是它的身份:

它就是 AWS 托管的 Kueue。

官方原文写的是 add-on installs Kueue, 最新 v1.6.0-eksbuild.1 对应 Kueue v0.19.2。

所以它跟 YuniKorn 的关系是「竞争」,不是「无关」 —— 队列、配额、抢占、gang 四个功能全重叠,

但分层不同:Kueue 是 admission gate,YuniKorn 是替换 kube-scheduler 的 placement 层。 两条硬约束:add-on 强制独占 Kueue,已装的必须先卸掉; SageMaker 还会覆写你手改的 Kueue 资源。

中间卡片那条最阴的坑是推论级的,我标明是推论: HyperPod 的 KueueManagerConfig 里 integrations.frameworks 含 "pod", 覆盖除 kube-system 和 kueue-system 之外的全部 namespace —— 你要是在 task-groups 的 labels 里手抄了 kueue.x-k8s.io/queue-name, Kueue 就会接管 placeholder 并给它加 scheduling gate ⇒ placeholder 永远起不来 ⇒ YuniKorn 的 gang 永久死锁。 另外有个双重配额账本风险:placeholder 是真 pod、真占资源, 而 Kueue 完全不计它的账 ⇒ 两边各算一套,谁都不准。

第三行,AWS Batch on EKS,❌ 不可用 —— 这一行唯一该做的事是「排除」。

EksPodProperties 是手写白名单、全集只有 9 项, 没有 schedulerName、也没有 podTemplate, 你在 RegisterJobDefinition 里写会被直接拒。 更根本的是 AWS 自己的原文:Batch 预先绑定 nodeName, 原话是 bypassing much of the scheduler placement logic ⇒ 任何调度器都不会被调用,这不是 YuniKorn 的问题。

(下面这条才是真正会伤到你的) YuniKorn 的 AC 默认还是会去改 Batch 的 pod —— pod 照样跑,因为 nodeName 已经定了, 但 UI 里会凭空出现一堆 aws-batch.<uuid> 应用, 实实在在吃掉队列配额,把你真正的 Spark 作业挤到 pending。 正确动作两个都行:要么把它的 namespace 加进 admissionController.filtering.bypassNamespaces(推荐,不碰 Batch 自己拥有的对象),要么给那个 namespace 打注解 yunikorn.apache.org/namespace.enableYuniKorn=false。

第四行,EKS Auto Mode、Karpenter、Fargate,🟡 通用。

业务侧字段就是 spec.template.spec.schedulerName, 再加 karpenter.sh/do-not-disrupt: "true" 保护 gang 成员不被整合掉。 YuniKorn 侧还有一条:AWS Solutions Library 的 sample 是 embedAdmissionController: false,chart 1.9.0,原样照抄即可。 Auto Mode 上是允许自定义调度器的 —— 那个 sample 就在 Auto Mode 上装 YuniKorn chart 1.9.0,2026 年 9 月 14 日仍在维护。 Karpenter 从来没有原生支持过,feature request #742 从 2022 年 open 到现在; 但那个通用契约从 v0.20.0 到 v1.14.1 逐字未变 —— 这句是给客户的信心: 它不支持,但也从没变过,你不会被升级打断。

两个 Auto Mode 专属限制,都要主动说:强制 21 天节点最大寿命 —— 对 Spark batch 无感,但对长跑的 Flink 是一个强制中断源, Flink 的 checkpoint 与恢复策略必须先验过; 还有 GPU 只能走 device plugin,DRA 不兼容 —— 客户要是已经在规划 DRA,这一条要提前说。

(最后这张卡片,Fargate 为什么互斥,机制很干净,值得念) Fargate 的调度身份本身就是 spec.schedulerName == fargate-scheduler, 由控制面的 mutating webhook 0500-amazon-eks-fargate-mutation.amazonaws.com 注入。 AWS 的 OFFICIAL KB 明说:你在 pod spec 里设了 schedulerName, fargate-scheduler 就会 skip the pod。一个字段,两个主人 —— 这个无解。 就算能设价值也接近 0,理由独立成立:一个 pod 一个 node、node 大小与 pod 容量无关、 全是 guaranteed QoS、没有 DaemonSet,而且没有 GPU、没有 Spot、不能挂 EBS。

(整节收口,建议照念) 这八页的落点就一句:你能不能用 YuniKorn,问的不是「我的组件在不在名单里」, 而是「我的负载是批还是长驻」,加上「对方的 CRD 有没有给我留 schedulerName 这个位置」。 接下来我们把话题从「能不能接」转到「接了之后怎么算账」。

3.5
Measured
真机实测
前面三章的结论,有一部分只有源码依据。这一章把它们搬到真的 EKS 上跑一遍 —— 其中有几条被推翻了,包括我自己刚说过的话。
五个框架跑通 Karpenter 实测闭环 四例静默失败 被推翻的结论
Apache YuniKorn 技术深潜
55

⏱ 本页 0.7 分钟 · 主线 149 字 · 深潜层另有 286 字

好,进第三点五章。前面三章有一部分结论只有源码依据, 这一章把它们搬到真的 EKS 上跑一遍。

(停一下,这句要认真说) 先给各位一个心理准备:有几条被推翻了,其中一条是我今天已经说过的话。

四个标签就是四块内容:五个框架跑通、Karpenter 闭环、四例静默失败、被推翻的结论 —— (指着最后一个标签)最后这块是这一章存在的理由。第一页先说为什么要重测。

我会明确说「原来错在哪」,而不是悄悄换掉数字。 (如果有人好奇编号)为什么是「三点五」而不是第四章? 因为它不是新内容,是对前三章的复核 —— 我刻意没做成独立的章, 就是想让各位把它读成「前面那些话的证据附录」。

集群交代一次,后面每一页都建立在它上面:yk-eks-lab,EKS 1.33, us-east-1,实测日期 2026 年 9 月 18 日。 不是 kind、不是 KWOK、不是推论。

(关于这一章的态度,值得多说一句) 我做这一章的时候有个心理门槛:把「我原来说错了」写进讲稿,比把它悄悄改掉难得多。 但如果我不写,各位就没有办法判断剩下那些我没能实测的结论该打几折。 (这句是关键)一份材料的可信度,不来自它有多少条对的, 而来自它有没有诚实标注哪几条是错的。

Ch.3.5 · 真机实测 · Why Redo

为什么前面的数字必须在真 EKS 上重测一遍 三个失真源,每一个都会让结论朝「看起来更好」的方向偏

本机 kind + KWOK 的三个失真源
OrbStack 上报整机容量每节点约 4× 超卖 ⇒ 装箱与配额实验全部失真
schedulable 不反映 taint可用容量虚高 25%
KWOK 假节点 predicate 极廉价吞吐数字不可外推到真集群
共同方向:三者都让 YuniKorn 显得更快、更省。没有一个是往坏的方向偏的 —— 这本身就是该警惕的信号。
这一章跑在什么上面
集群yk-eks-lab · EKS 1.33 · us-east-1
节点16 × m6i.2xlarge on-demand(不用 Spot:基准要确定性)
每节点 allocatablecpu 7910m · mem 29.8Gi · pods 58
YuniKorn1.9.0(helm chart 1.9.0)
Karpenter1.14.1 · NodePool yk-default
跑通的框架Spark ×2 通路 · Flink · Ray · Trino
pods 58 这个数很重要:它是 VPC CNI 的 ENI 上限(4 ENI × 15 IP − 2),不是算力限制。压测小 pod 时先撞到的是它。
本章的诚实标准:凡在真 EKS 上跑出来与前面不同的,一律按实测改口并说明原来错在哪;凡没跑的(EMR on EKS、Tier B 九个框架、B2/B4/B7/B8)一律明说没跑,不用「预期如此」代替。
Ch.3.5 · 真机实测 — 为什么重做56

⏱ 本页 1.0 分钟 · 主线 215 字 · 深潜层另有 1028 字

这一页解释一件事:前面的数字为什么不能直接用。 左边三个失真源 —— OrbStack 报整机容量、四倍超卖; schedulable 不反映 taint、虚高 25%;KWOK 吞吐不可外推。 (指着左下那个红框,照念)三者方向一致,都让 YuniKorn 显得更好。

右边是环境:EKS 1.33、16 台 m6i.2xlarge、五个框架全跑通; 那行 pods 58 是 ENI 上限,不是算力限制。

(底栏这条是这一章的诚实标准,建议照念) 跟前面不一样的按实测改口、并说明错在哪;没跑的明说没跑。 下一页看:装完之后集群变成了什么样。

(没跑的清单要能随口报出来,被问到时不能含糊) 这一轮没有跑的是:EMR on EKS(要开新集群、本轮没做)、 Tier B 那九个框架、以及四组基准 B2、B4、B7、B8。 另外还有一条子路径没测:gang 的 placeholder 会不会触发 Karpenter 扩容(B5 路径 C)。 这些我一律不用「预期如此」代替。

三个失真源逐条展开一下,因为它们决定了前面哪些数字能用、哪些不能用。 第一个,OrbStack 给每个节点上报的是整机容量 —— 也就是同一份物理 CPU 被 N 个 kind 节点各自声明了一遍,实测约 4 倍超卖。 (推论)⇒ 装箱和配额这两类实验在本机全部失真, 因为它们量的就是「容量边界在哪」。 第二个,schedulable 字段不反映 taint ⇒ 我算出来的可用容量虚高 25%。 第三个,KWOK 的假节点没有 kubelet、没有真实 predicate 计算, 所以吞吐测出来好看,但那个数字不能外推到真集群。

(补一句方法论,这句其实比三条本身重要) 「所有误差方向一致」这件事本身就是一个该停下来的信号。 如果三个独立的失真源恰好都朝着有利于结论的那一侧偏, 那通常不是运气,是你的测量装置和你的期望共线了。 这也是我坚持要在真 EKS 上重跑一遍的唯一理由 —— 不是为了拿更漂亮的数字,是为了拿一个误差方向不确定的数字。

右边那张卡逐行念全(时间够时用这版):集群 yk-eks-lab、 EKS 1.33、us-east-1;16 台 m6i.2xlarge 按需实例 —— 不用 Spot, 因为基准要确定性;YuniKorn 1.9.0(helm chart 也是 1.9.0); Karpenter 1.14.1,NodePool 叫 yk-default; 跑通的框架是 Spark 两条通路,加 Flink、Ray、Trino。

环境细节补齐:每节点 allocatable 是 cpu 7910m、内存 29.8Gi、 pods 58。58 乘 16 等于 928,这是全集群的 pod 数硬上限。 pods 58 的来历是 VPC CNI 的 ENI 上限:4 个 ENI × 15 个 IP − 2。 ⇒ 在 EKS 上压 YuniKorn 吞吐时,光加节点没用,你会先撞到 ENI; 要真正提高 pod 密度得开 VPC CNI 的前缀委派,那是另一件事,本轮没做。

(为什么用按需不用 Spot,可能被问) Spot 会在测量过程中被回收,节点数在测的过程里变动 —— 那样测出来的曲线里混着一个我控制不了的变量。 同样的理由,Karpenter 的 limits.cpu 我压了一个封顶值: 测吞吐的时候必须让集群规模不动。 Karpenter 的 NodePool 叫 yk-default,实例族是 m6i 的 large / xlarge / 2xlarge,不加 taint。

Ch.3.5 · 真机实测 · 图解 · Topology

装完之后集群里到底变成了什么样 数字全部取自实跑集群 —— 注意右下角那 7 个无上限队列

AWS 账号 8357…6093 · us-east-1EKS 1.33EXTENDED_SUPPORT(已脱标准支持)authenticationMode: API_AND_CONFIG_MAPVPC 10.199.0.0/16 · 2 AZ · 单 NAT 网关 nat-0172aeb8… (🔴 清理时最容易漏的持续计费项)us-east-1c公有子网NAT / IGW 出口私有子网全部工作节点在此us-east-1d公有子网NAT / IGW 出口私有子网全部工作节点在此算力:一个托管节点组 + 一个 Karpenter NodePool(两套并存)EC2托管节点组 ng-bench · 16 × m6i.2xlarge每节点 allocatable:cpu 7910m · mem 29.8Gi · pods 58 ⇒ 全集群 928 pod 上限KPKarpenter 1.14.1 NodePool yk-defaultm6i.{large,xlarge,2xlarge} · on-demand · limits.cpu 封顶防失控同一集群,互不知情🔴 AC webhook 默认 processNamespaces 为空 = 全集群接管(bypassNamespaces 默认只有 ^kube-system$)YKns yunikorn2 Deploy · 2 Pod · 3 容器 · 0 DSspark-operator2 podflink-operator1 podkuberay4 podtrino3 podcert-manager3 podns amazon-guardduty —— AWS 安全代理也被接管了kube-system · 38 pod(含 karpenter 本体)队列树实况:18 个队列里 7 个是放置规则**现场造**的,全部无上限11 个我配置的托管队列(isManaged=true)bench · spark · flink · trino · ray · tiny · small · acl-{upper,lower,empty}7 个 autogen 队列(isManaged=false · maxResource 为空 = 无上限)kuberay · spark-operator · flink-operator · cert-manager · amazon-guardduty · yk-test · yk-req落点:这张图上「跑起来了」的东西全都跑起来了 —— 而右下角那 7 个无上限队列说明治理并没有生效。装 YuniKorn 的同一天必须做完两件事:① 收紧 admissionController.filtering.processNamespaces ② 给放置规则链兜底(或让每个作业自带 queue label)。🔴 1.33 的标准支持在 2026-07-29 结束 —— 恰好是 YuniKorn 1.9.0 的 GA 日。而 YuniKorn 1.9.0 的兼容矩阵上限就是 1.33 ⇒ 今天必须在「超出 YuniKorn 矩阵」与「脱离 EKS 标准支持」之间二选一on-demand(基准要确定性,不用 Spot)。🔴 pods=58 是 VPC CNI 的 ENI 上限(4 ENI × 15 IP − 2),不是 CPU 限制 ⇒ 跑小 pod 压测时先撞到的是这个数,不是算力实测(B5 路径 A):YuniKorn 写下 PodScheduled=False/reason=Unschedulable 后 1.3 秒 Karpenter 感知、3.8 秒 EC2 已启动。🔴 但配额受限时 YuniKorn 不写任何条件 ⇒ Karpenter 一台都不加(路径 B:NodeClaim=0)。🔴 测吞吐时必须把 limits.cpu 压到 0 —— 否则集群规模在测量过程中变动yunikorn-scheduler(容器 yunikorn-scheduler-k8s + yunikorn-scheduler-web)与 yunikorn-admission-controller,两者 replicas 都硬编码 1、零 leader election ⇒ 单副本 + 快速重建,不是高可用🔴 这是「webhook 默认全集群」最生动的后果:我从没配置过 GuardDuty,但它的 agent pod 进了 YuniKorn 的队列账本,并现造出 root.amazon-guardduty 这个 maxResource 为空(无上限)的队列。装 YuniKorn 的第一件事应该是收紧 processNamespaces,而不是装完再想出厂放置规则链是 provided(create=false) → tag(namespace, create=true) → recovery。pod 没带 queue label ⇒ 退到 tag 规则,**按 namespace 名现场创建队列**,而现造的队列 maxResource 为空 = 无上限 ⇒ 你精心配的配额,对这些 pod 一个都没管到
Ch.3.5 · 图解 — EKS 拓扑57

⏱ 本页 1.4 分钟 · 主线 300 字 · 深潜层另有 1853 字

这张图全部取自实跑集群。最上面:EKS 1.33 已脱离标准支持, 而 YuniKorn 1.9.0 的兼容上限恰好就是 1.33 —— (停一下)你必须二选一。 第二、三层一句话:Karpenter 和托管节点组互不知情。

(指着第四层那条红色横条,这是这张图的核心) 第四层是被接管的一切:webhook 的 namespace 过滤默认空 = 全集群接管, 五个 operator 控制面全进了队列账本 —— 最生动的是 amazon-guardduty, 我从没配过它。

(这是落点,建议照念) 最下面:18 个队列里 7 个是放置规则现造的,全无上限 —— 没带队列标签就按 namespace 现造,而现造的没有配额。 图上「跑起来了」的都跑起来了,那 7 个队列说明治理没生效。 收紧过滤、规则兜底,要在装的同一天做完。下一页把它拆开看。

(关于那个「二选一」的表态,被追问时这样说) 先说清楚:这不是我们配错了,是当下的客观状态。 1.33 已经进 EXTENDED_SUPPORT(要另外付费), 而 YuniKorn 1.9.0 的兼容矩阵上限就是 1.33 —— 升 EKS 就超出 YuniKorn 的矩阵,不升就一直付延长支持费。 这张图不是示意图,这一行是我在真集群上读出来的,所以这个两难是现在就要做的决定, 不是「以后再说」。另外补上第四层横条的后半句: bypassNamespaces 默认只放过 kube-system 一个。

上面那一行还有两个字段没交代。authenticationMode 是 API_AND_CONFIG_MAP —— access entry 和 aws-auth 两条路都开着, 这一点在讲队列 ACL 时有用:组映射走哪条路,决定你要改哪个东西。 另外那个日期巧合我核过两遍:1.33 的标准支持结束于 2026-07-29, 而 YuniKorn 1.9.0 的 GA 日就是同一天。

第二层和第三层的完整口播,时间允许时照这个讲: 第二层 VPC,两个可用区、一个 NAT 网关 —— 这是清理实验环境时最容易漏掉的持续计费项;工作节点全部在私有子网。 第三层算力两套并存:托管节点组加 Karpenter 的 NodePool, 中间那句「同一集群,互不知情」是故意的 —— 我要看它们在没人协调的情况下会不会自己搭上,那就是下一页 B5 的实验。

VPC 那一层的具体数字:网段 10.199.0.0/16, 两个 AZ 分别是 us-east-1c 和 us-east-1d, 每个 AZ 一个公有子网做 NAT / IGW 出口、一个私有子网放全部工作节点。 NAT 网关那条我特意写在图上,因为它是实验环境拆完之后最常见的「幽灵账单」 —— 节点删了、集群删了,NAT 还在按小时计费。

算力两套的确切配置:托管节点组叫 ng-bench, 16 台 m6i.2xlarge、on-demand;Karpenter 1.14.1 的 NodePool 叫 yk-default,实例族 m6i 的 large / xlarge / 2xlarge, limits.cpu 封顶防失控。 (一条踩坑)测吞吐时必须把 limits.cpu 压到 0, 否则集群规模会在测量过程中自己变动,测出来的数没法解释。

ns yunikorn 那个框里的数字和高可用那一节对得上: 2 个 Deployment、2 个 Pod、3 个容器、0 个 DaemonSet。 scheduler 那个 pod 里是 yunikorn-scheduler-k8s 加 yunikorn-scheduler-web 两个容器,另一个 pod 是 admission controller。 两者的 replicas 都硬编码为 1、零 leader election —— 所以正确说法是「单副本加快速重建」,不是高可用。 这一行是 ✅实测(E1),不是读文档读出来的。

被接管的那一排逐个念一下,因为这个名单本身就是结论: spark-operator 2 个 pod、flink-operator 1 个、 kuberay 4 个、trino 3 个、cert-manager 3 个, 加上那个红框里的 amazon-guardduty;右边还有 kube-system 的 38 个 pod,里面包含 Karpenter 本体。 (这个推论值得说)连你后续装的 operator 控制面都由 YuniKorn 调度 —— 这是 ✅实测(E10)。它的意思是:装 YuniKorn 不是「给批处理加一个调度器」, 是把整个集群的调度权换掉。

队列名单也念一遍。7 个现造的(isManaged=false、无上限): kuberay、spark-operator、flink-operator、 cert-manager、amazon-guardduty、yk-test、 yk-req —— 后两个是我自己的测试 pod 造的, 连做这个实验的人自己都会踩到,这大概是这条缺陷最真实的样子。 11 个我配的托管队列:bench、spark、flink、 trino、ray、tiny、small, 加三个测 ACL 的 acl-upper、acl-lower、acl-empty。

出厂放置规则链的确切内容(✅实测,取自 /ws/v1/partition/default/placementrules): provided(create:false)→ tag(tagName:namespace、create:true)→ recovery。 (关键在第二条的 create:true)⇒ 没带 queue label 的 pod 会命中第二条, 而第二条被允许创建队列,于是按 namespace 名现造一个 —— 现造的没有 maxResource。 这条链解释了这张图上全部 7 个 autogen 队列的来历,一个不剩。

Ch.3.5 · 真机实测 · 图解 · Framework Paths

七条提交通路,以及每条在 pod 上真正落地了什么 七行全部 Running、schedulerName 全部是 yunikorn —— 而治理只有四行生效

提交通路怎么配(确切字段)pod 上真正落地了什么YuniKorn 眼里的结果schedappIdqueuegangSpark 原生 spark-submitspark.kubernetes.scheduler.name=yunikorn+ driver/executor 两侧 label 与注解✓✓✓✓每作业一个独立应用四判据全过 · gang 生效Kubeflow Spark OperatorbatchScheduler: yunikornoperator 代你拼全部注解✓✓✓✓每作业一个独立应用driver SucceededFlink Operator(generic)spec.podTemplate.spec.schedulerName+ labels: {queue: root.flink}✓✗autogen✓✗JM + 全部 TM 合成一个应用同 ns 多作业继续合并Ray / KubeRay · 默认装RayCluster 上写 gang-scheduling-enabled与 yunikorn.apache.org/queue —— 都不生效✓✗autogen✗现造队列✗落进现造的 root.kuberay🔴 无上限 · 配额被绕过Ray / KubeRay · 开旋钮helm --set batchScheduler.name=yunikorn(注意 enabled:true 会装成 Volcano)✓✗autogen✓✓queue 与 task-groups 都对了但 appId 仍是 ns 级 autogenTrino · AC 按 ns 接管什么都不配 —— webhook 无条件改写chart 里 schedulerName 命中 0 次✓✗autogen✗现造队列✗整个 namespace 一个应用🔴 队列靠撞名,改名即失效Trino · 注入 label(推荐)--set-string worker.labels.applicationId=…labels 会渲染进 pod template,零 chart 改动✓✓✓~不适用trino-bi 独立应用 3 podsgang 对长驻服务无意义🔴 全部 7 行的 pod 都是 Running,schedulerName 都是 yunikorn ——「跑起来了」这件事完全无法区分上面 4 行和下面 3 行。只有 Spark 天然免疫:它自带每次提交都不同的 spark-app-selector,恰好满足 YuniKorn 的应用识别契约 ——巧合式兼容,不是有意集成。⇒ 除 Spark 之外的每个框架,上线前都必须回答一句:我的 applicationId 从哪来? ✅ 全部 EKS 实测(EKS-RESULTS E11/E12/E14/E19/E23/E24)schedulerName —— 由 AC webhook 无条件注入 ⇒ 任何 chart 都不需要提供这个字段。我原先拿 grep schedulerName==0 当判据,测的是错的东西applicationId —— 缺它 ⇒ 同 namespace 所有 pod 合并成一个应用 yunikorn-<ns>-autogen ⇒ 配额/gang/抢占全按错粒度记账queue —— 缺它 ⇒ 放置规则退到 tag 规则按 namespace **现场创建**队列,而现造的队列 maxResource 为空 = 无上限 ⇒ 配额被绕过task-groups —— 缺它 ⇒ 没有 gang,pod 各自调度。注意 minResource 里 CPU 的键是 cpu,队列配置里是 vcore
Ch.3.5 · 图解 — 框架通路58

⏱ 本页 0.6 分钟 · 主线 134 字 · 深潜层另有 3632 字

七行是七条提交通路,中间四列是判据 —— pod 上真正落地了什么: 调度器名、应用 ID、队列、gang 组,缺一样治理就在某个维度失效。

(完整版,做长版本时把下面两段提回主线) (先指第一个窄列,这是这张图的机关所在) 第一列七行全是勾,因为 schedulerName 由 webhook 无条件注入。 (停一下)而我原先判 Trino「不支持」,依据正是它在 chart 里 0 命中 —— 那个 0 是对的,但我拿它当判据、测错了东西:真判据是能不能往 pod 注入 label, 而这几乎所有 chart 都能 ⇒ Trino 改判可用。

按行看:Spark 两行四列全绿;Flink 缺应用 ID、合成一个应用; KubeRay 默认装最坏 —— CRD 上的 label 没传到 pod、落进无上限队列, 开旋钮后应用 ID 仍是 ns 级;Trino 不配就靠撞名,注入 label 后才独立。

(落点,一定要说出来) 七行 pod 全 Running、调度器名全是 yunikorn —— 「跑起来了」完全无法区分上四行和下三行,零报错。 Spark 唯一免疫,最后一页讲。

(原主线的过渡句,本轮插页后指错了页,保留在这里) 下一页看 Karpenter。

(Trino 那六条命令值得抄回去,这是可直接落地的部分) 确切做法:helm upgrade trino trino/trino --reuse-values, 然后给 coordinator 和 worker 两侧各打三样 —— --set-string coordinator.labels.applicationId=trino-bi、 --set-string worker.labels.queue=root.trino、 以及 --set-string worker.annotations.yunikorn.apache.org/allow-preemption=false。 ✅实测结果:应用 ID 从 yunikorn-trino-autogen 变成 trino-bi, Running 3 pods,旧应用转 Completing 排空。 踩坑一条:annotation 的值必须用 --set-string —— 写 --set ...=false 会被 Helm 当成布尔,报 expected string, got …valueUnstructured{Value:false},整个 upgrade 失败。

(源码依据:Trino 的口子究竟在哪) ✅源码 —— trinodb/charts 的 templates/deployment-worker.yaml 把 worker.labels 渲染进 spec.template.metadata.labels (缩进 8,在 template: → metadata: 里面), 不是只打在 Deployment 顶层 —— 这一点是成败关键,打在顶层对 pod 没用。 worker.annotations 同理,而且两者都过了 tpl ⇒ 值里可以写 Helm 模板表达式,比如 queue: "root.bi.{{ .Release.Namespace }}"。 (一个否证)任务书里问到的 coordinator.additionalConfigFiles 不存在,别写它。

(一个我特意去排除的阻塞风险) 往 Deployment 打 label 有个经典陷阱:如果污染了 selector.matchLabels, 后续 helm upgrade 会永久失败,因为 Deployment 的 selector 不可变。 我查了:trino-worker 的 matchLabels 只有三个标准的 app.kubernetes.io/* 键,worker.labels 不污染它 ⇒ 升级安全。 但 commonLabels 会不会污染,我没验 —— 所以我推荐的是 coordinator.labels / worker.labels 这条已验证的路。 这是「没实测就说没实测」的一个具体例子。

(KubeRay 的第二个坑,讲 Ray 的客户一定要提醒) 修 KubeRay 的确切命令是 helm upgrade kuberay-operator --set batchScheduler.name=yunikorn。 🔴 chart 里还有一个已废弃的 batchScheduler.enabled, 官方 values 注释原文是 "for backwards compatibility. When it sets to true, it enables volcano scheduler integration" —— 写 enabled: true 会给你装成 Volcano,不是 YuniKorn,而且它会覆盖 name。 根因链三步全部可复现:helm get values 显示 USER-SUPPLIED VALUES: null ⇒ operator 的 args 里没有 --batch-scheduler ⇒ chart 默认 batchScheduler.name: ""。

(Ray gang 生效的验证方法,比查注解可靠) 旋钮打开后 worker pod 的 event 里会出现 GangScheduling Pod belongs to the taskGroup small, it will be scheduled as a gang member —— 它点名了 taskGroup 的名字。注解在只能证明「生成了」, 这条 event 证明调度器真的按 gang 处理了。 ⚠️ 排障提示:我当时看到 worker 一直 Pending,以为 gang 卡住; 真实原因是拉 746MB 的 rayproject/ray:2.9.0 用了 20.5 秒。 在 EKS 上判断 gang 卡不卡,先排除镜像拉取 —— 看 event,不要看 phase。

(Spark 原生通路的完整判据,A1 那一行的底账) ✅实测:镜像 apache/spark:3.5.3、SparkPi 300、 1 driver + 2 executor、gang 两组。四条判据 —— 作业 exit code: 0、schedulerName=yunikorn、 应用落在我显式指定的 root.spark、队列用量有变化。 gang 的完整时序也拿到了:creating placeholders → placeholder has been allocated(×2)→ all placeholders are allocated. Transitioning to running state., 全程 ≈1 秒(本机 kind 上记录的是 2.1 秒,EKS 上 pause 镜像已缓存所以更快)。 🔵 顺带确证了材料里那条踩坑:task-groups 的 minResource 里 CPU 的键是 cpu,而队列配置里是 vcore —— 这个不一致是真的。 ⚠️ 副产物:我那个 sleep 3600 的 launcher pod 自己落进了现造的 root.spark-native,无上限 —— 又一个实例,这次是我自己造的。

(为什么 Trino 只有四分之一的卖点成立,被追问时用这段) 逐条过:队列配额,加了 pods 维度之后成立(下一页展开); 排队,结构性无效 —— Trino 的负载在 query 层,query 在已有 worker 上跑、不新建 pod, ✅实测跑一个 tpch.sf100 的关联,worker 真实吃到 1485m CPU, 而 YuniKorn 三次采样全是 pods=3,一动不动; gang,对长驻 Deployment 无意义;抢占,有害且默认开着。 ⇒ 正确用法是「只用队列配额,把 Trino 的 pod 用量纳入与 Spark 同一本账」, query 级的排队和优先级交回 Trino 自己的 resource groups 和 Trino Gateway。 任何试图用 YuniKorn 治理 Trino「查询」的方案都是层级错配。

(为什么不敢标 supported,这条对客要说清) 口子实测可用,但我只标 generic,四个理由: ① 零公开案例 —— trinodb/charts 与 apache 三个 YuniKorn 仓库交叉检索 全 0 命中,dev@yunikorn.apache.org 搜 trino 只有一个假命中。 这是「无人验证」,不是「已知可用」。 ② chart 默认三重不利:worker.gracefulShutdown.enabled 默认 false、 terminationGracePeriodSeconds 默认 30、 默认 access control 还不允许调 shutdown API。 ③ PDB 无效 —— 抢占走 DELETE 不走 pods/eviction, 「配个 PDB 就安全」在这里是虚假安全感。 ④ 四大卖点只有四分之一成立。

(一条现实的生产事故路径,✅实测出等价现象) processNamespaces 默认空字符串,官方原文: "If this setting is an empty string, pods created in all namespaces will be scheduled by YuniKorn";bypassNamespaces 默认只有 ^kube-system$。 ⇒ 在一个已经跑着 Trino 的 EKS 上装 YuniKorn,Trino 会被静默接管, 而此时队列里可能没有它的配额 ⇒ 全量 Pending,而且 pod 上没有任何 condition ⇒ Karpenter 也不扩容 ⇒ 集群看起来空着,而服务全挂。 这条我在 EKS 上已经测出等价现象了。 ⇒ 装 YuniKorn 的第一件事就是收紧 processNamespaces,不是装完再想。

(反向信号,讲选型时很有说服力) 三家都没有选 batch scheduler 这条路: Trino 社区自己在 gateway 层造队列(trino-gateway#801,Open); Presto 官方 chart 把 resource groups 做成一等公民; Starburst 商业版用 HPA 加双重宽限期。 ⇒ 三个独立的当事人都把答案放在查询层,这比我的任何论证都有力。 Presto 还比 Trino 差三点:完全没有 graceful shutdown、 没有 podLabels(只能走 annotation 路径)、 没有 priorityClassName(抢占七律里「只抢同等或更低优先级」这条防线用不上)。 另外 Presto 的 chart 版本号不可信:main 在 0.4.0 发布之后新增了 podAnnotations 却没有 bump 版本号。

Ch.3.5 · 真机实测 · 图解 · Taxonomy

26 个框架,接入通路只有六种形态 而坑是按形态聚集的 —— 知道属于哪一形态,就知道该防什么

接入形态机制属于这一形态的框架🔴 这一形态特有的坑① CRD 显式字段9 个schema 里有 schedulerNamespec…template.spec.schedulerNameKafka/Strimzi · Argo · Dask · MPIJobSet · LWS · Tekton · Volcano · Milvus🔴 层级会随 CRD 版本迁移:Milvus v1alpha1 在spec 顶层,v1beta1 挪进 spec.components⇒ 且开了 strict decoding,写错层级直接被拒② chart 旋钮4 个values 里有 schedulerName / podLabelshelm --set schedulerName=yunikornAirflow · StarRocks · JupyterHub · Trino🔴 **子 chart 不继承父 chart 的 common labels**(4 例:Airflow/Druid/Milvus/Pulsar 的捆绑库)🔴 JupyterHub 自带 kube-scheduler,默认开③ preserve-unknown 逃生舱2 个schema 零显式字段,但该节点不校验podTemplates[] · nodeSets[].podTemplateClickHouse(90 处逃生舱)· ECK(3 处)🔴 写错的字段被**静默丢弃**(schema 不校验)🔴 逃生舱**按路径**,不是全局 ——写在舱外照样被 strict decoding 拒掉④ 只有 annotation4 个无 schedulerName、无 pod label 口子podAnnotations.yunikorn.apache.org/{app-id,queue}Druid · Pinot · Doris · Pulsar🔴 这几个 chart 常**零 resource requests**⇒ vcore/memory 用量恒为 0⇒ 只写 vcore/memory 的配额**永不生效**⑤ conf 透传3 个上游把 spark.kubernetes.* 转发给 Sparkspark.kubernetes.scheduler.name=yunikornSpark 原生 spark-submit · Spark Operator · Kyuubi🔴 Kyuubi 三个陷阱:cluster 模式要对象存储 ·kyuubi 镜像不能当 Spark 镜像 ·client 模式要 headless service⑥ 共存(非接入)1 个两者在时间上根本不重叠Kueue 用 Job suspend/resume,pod 尚不存在Kueue(+ YuniKorn 双层配额)🔵 实测 pod 的 schedulingGates 是**空的** ——对 batch/v1 Job,Kueue 走 Job 级 suspend,不走 Pod 级 gates。两条路别混起来讲落点:**形态只有 6 种,而坑是按形态聚集的** —— 知道一个框架属于哪一形态,就知道该防什么。判据 schedulerName==yunikorn 对这 26 个**几乎没有区分力**(AC webhook 无条件注入它);真正有区分力的是「工作负载能不能进你指定的队列」。✅ 26 个框架全部 EKS 实测 · 唯一来源是 eks-poc/tools/fwrun.py 的 REGISTRY(矩阵由 fwrun.py report 生成)最干净的一类。但「有显式字段」不等于「路径稳定」—— Milvus v1alpha1 的 spec.schedulerName 到 v1beta1 变成 spec.components.schedulerName,而 CRD 开了 strict decoding,写错层级 apiserver 直接报 unknown field。好在它是**大声失败**最大的陷阱是子 chart:Airflow 的 labels 注释明写 “applies to all objects and pods”,但 bitnami postgresql 子 chart 不继承 ⇒ 捆绑的数据库跑在 autogen 无上限队列里,而它往往最吃资源grep schedulerName == 0 会把这两个误判成 unsupported。必须用 CRD schema 递归找出 x-kubernetes-preserve-unknown-fields 节点,并且**只能写在舱内**。代价是写错不报错 ⇒ 必须回到 pod 上核对能接进来完全依赖 YuniKorn 的应用识别优先级链第②级(annotation)。若只记住「用 applicationId label」这一种写法,这 4 个会被误判成接不进去。配额必须额外带 pods 维度这一类自动继承 Spark 那条通路(含 gang)。Spark 还因自带 spark-app-selector 而天然免疫「ns 级 autogen 合并」—— 这是巧合式兼容,不是有意集成流程:Job 以 suspend=true 提交(pod 还不存在)→ Kueue 准入 → 解除 suspend → pod 才被创建 → YuniKorn 调度。⇒ 不冲突的原因比「YuniKorn 尊重 gates」更强:它们压根不同时在场
Ch.3.5 · 图解 — 接入形态分类59

⏱ 本页 1.6 分钟 · 主线 336 字 · 深潜层另有 3153 字

上一页是「怎么接」。这一页测了 26 个框架 —— 要念 26 行字段路径吗? (停一下)不要,那是查表,不是洞察。 洞察是:形态只有六种,而坑按形态聚集。

数量:CRD 显式字段 9、chart 旋钮 4、逃生舱 2、 annotation 4、conf 透传 3、共存 1 —— 正好 26。

(点两种,指第二行)chart 旋钮那一类,坑在子 chart 不继承: 父 chart 说给所有 pod 都打了 label,捆绑的 postgresql 照样逃出队列,4 例。 (指第四行)只有 annotation 那 4 个,坑在配额:它们零 requests ⇒ vcore/memory 恒为 0 ⇒ 只写这两维的配额永不生效。

(底下两行是落点,照念) 判据「schedulerName=yunikorn」几乎没有区分力 —— webhook 无条件注入;有区分力的是「能不能进你指定的队列」。 (过渡)下一页:我上一轮就是拿它判错了框架。

(主线为了配速压过一轮,这是完整版,做长版本时换回这版) 开场:能带走的是这张图 —— 26 个框架的接入通路只有六种形态,而坑是按形态聚集的; 知道一个框架属于哪一形态,你就知道该防什么。 六行的完整口播是「CRD 显式字段 9 个、chart 旋钮 4 个、 preserve-unknown 逃生舱 2 个、只有 annotation 的 4 个、conf 透传 3 个、共存 1 个, 加起来正好 26,右边那一列是每种形态特有的坑」。 两个坑各补一句:子 chart 那条要加上「而捆绑的数据库往往是整套系统里最吃资源的那个」, 配额那条要加上「补救是给队列配额额外带一个 pods 维度」。 落点还有第三句:这 26 个全部 EKS 实测,矩阵是从登记表生成的、不是手写的 —— 也就是说这张图上没有一个数字是我拍出来的。

(六行的框架名单,被追问「具体哪些」时逐行念 —— 顺序与图上一致) 形态①,CRD 显式字段,9 个:Kafka/Strimzi、Argo Workflows、Dask、MPI Operator、 JobSet、LeaderWorkerSet、Tekton、Volcano、Milvus —— 它们的 schema 里直接有 schedulerName,写法是 spec…template.spec.schedulerName。 形态②,chart 旋钮,4 个:Airflow、StarRocks、JupyterHub、Trino —— values 里有 schedulerName 或 podLabels, 一条 helm --set schedulerName=yunikorn 就进去了。 形态③,preserve-unknown 逃生舱,2 个:ClickHouse 和 ECK。 形态④,只有 annotation,4 个:Druid、Pinot、Doris、Pulsar。 形态⑤,conf 透传,3 个:Spark 原生 spark-submit、Spark Operator、Kyuubi。 形态⑥,共存而非接入,1 个:Kueue —— 它是下一步要专门讲的那一页。

(形态①的坑,图上第一行的右列,时间够时补上) CRD 显式字段是最干净的一类,但「有显式字段」不等于「路径稳定」。 最生动的例子是 Milvus:v1alpha1 的 spec.schedulerName 到了 v1beta1 变成 spec.components.schedulerName —— 层级随 CRD 版本迁移。 好消息是这一类普遍开了 strict decoding,写错层级 apiserver 直接报 unknown field ⇒ 它是大声失败。 (这个对比值得点出来)整张图上,只有形态①和形态③是一对镜像: ①写错大声失败,③写错静默丢弃 —— 同样是「写字段」,风险完全不同档。

(形态③的坑,这条是本轮工具换代的直接产物) preserve-unknown 逃生舱的意思是:schema 里一个显式的 schedulerName 都没有,但那个节点不做校验,所以你写什么它都收。 ClickHouse 有 90 处这样的逃生舱、ECK 有 3 处。 ⇒ 拿 grep schedulerName 去数,这两个会被误判成 unsupported —— 而实测它们都跑通了(ClickHouse 走 podTemplates[], ECK 走 nodeSets[].podTemplate)。 两条注意:一,写错的字段被静默丢弃,不报错,所以必须回到 pod 上核对; 二,逃生舱按路径生效,不是全局 —— 写在舱外照样被 strict decoding 拒掉。

(为什么我把工具从 grep 换成 schema 递归,讲方法学时用这段) 上一轮生态调研用的是 grep schedulerName,本轮换成两个递归工具: crdpath.py 递归遍历 CRD 的 openAPIV3Schema 输出完整路径、 并标出所有 x-kubernetes-preserve-unknown-fields 节点; valpath.py 递归遍历 helm values 输出能写进 --set 的点分路径。 grep 的三个失效模式都实测撞到了: ① 误命中 —— 把「别人字段的 description 里提到 schedulerName」算成命中; ② 给不出路径 —— 能写进 YAML 的是路径,不是行号; ③ 漏掉隐式逃生舱 —— preserve-unknown 节点下任何字段都能写,grep 永远看不见。 抓到的具体成果:ClickHouse 的 90 处逃生舱、 starrocks.starrocksFESpec.schedulerName 这类深层路径、 以及 Druid 的 labels 其实是 ServiceAccount 的 labels、不是 pod 的。

(子 chart 那 4 例的完整名单,客户如果自己装过捆绑 chart 一定会关心) 四个实例:Airflow 的 airflow-postgresql-0; Druid 的 druid-postgresql-0 和 druid-zookeeper-0; Milvus 的 milvus-yk-etcd-0 和 milvus-yk-minio; Pulsar 的 pulsar-grafana、pulsar-kube-state-metrics、 pulsar-prometheus-node-exporter。 四个不同的父 chart、同一个现象 ⇒ 这已经不是个别问题,是通用规律。 ⇒ 一条五秒钟就能做完的检查,各位可以直接抄: kubectl -n <ns> get pods -o custom-columns='P:.metadata.name,Q:.metadata.labels.queue' | grep '<none>' —— 凡 <none> 的,它跑在放置规则现造的 autogen 无上限队列里。 最稳的做法是 postgresql.enabled=false、把捆绑依赖改成外部依赖, 移出这套 chart 的管辖。

(形态④为什么必须靠 annotation,以及它和前面章节的呼应) Druid、Pinot、Doris、Pulsar 这四个,既没有 schedulerName、 也没有 pod label 的口子,能接进来完全依赖 YuniKorn 应用识别优先级链的第②级 —— 也就是 annotation 那一级。 ⇒ 推论很实际:如果你只记住「用 applicationId label」这一种写法, 这 4 个会被你误判成接不进去。 具体路径各不相同:Druid 是 spec.{feSpec,beSpec}.annotations 那一族、 Pinot 是六个组件各自的 podAnnotations、 Pulsar 的旋钮叫 <组件>.annotations,全 chart 有 42 处。 (Pulsar 这条我担心的事没发生,值得一提) 它的旋钮不叫 podAnnotations,我原本预判它可能打在 StatefulSet 而不是 pod 上; 实测 pulsar-bookie-0 和 pulsar-broker-0 的 pod 上确实有 yunikorn.apache.org/queue ⇒ 命名不规范,但行为正确。 这次核对的结果是好消息,但流程一步都不能省。

(形态⑤的三个,以及 Kyuubi 的三个陷阱) conf 透传这一类是白捡的:上游把 spark.kubernetes.* 原样转发给 Spark, 所以你写 spark.kubernetes.scheduler.name=yunikorn 就行, 而且它自动继承 Spark 那条通路,包括 gang。 Spark 还因为自带 spark-app-selector 而天然免疫「namespace 级 autogen 合并」—— 这是巧合式兼容,不是有意集成,这一点最后一页会专门讲。 Kyuubi 的三个陷阱(都是实测撞的,与 YuniKorn 无关但会被误记成 YuniKorn 的问题): cluster 模式要对象存储;kyuubi 的镜像不能直接当 Spark 镜像用; client 模式要 headless service。

(登记表那件事,讲工程做法时用,它也是这张图的数据来源) 这 26 行不是我手写的表格。本轮把框架矩阵从 Markdown 表格改成了 代码登记表:eks-poc/tools/fwrun.py 里的 REGISTRY 是 26 条 dataclass,它是唯一来源, FRAMEWORK-MATRIX.md 由 fwrun.py report 生成。 它还替换掉了三个一次性脚本 ⇒ 再加第 27 个框架时只加一条登记项,不是再写一个脚本。 (为什么值得这么做)因为登记表是代码,有 --check 回源核验; 而 Markdown 表格只会静默腐化 —— 半年后没人知道哪一行还是真的。 凡对外的数字一律生成,不手写。

Ch.3.5 · 真机实测 · Overturned

真机跑完之后,我自己错了三处 而且三处是同一个错:把「仓库里有 volcano/kueue 字样」当成「别的调度器进不去」

框架我原来的判定(只有源码依据)EKS 实测
Volcano Job conflict「vc-controller 在 PodGroup 未离开 Pending 前一个 pod 都不建」 genericpod 由 vc-controller 建、YuniKorn 调度、Completed(36s);且不建 PodGroup —— 那正是共存机制
LeaderWorkerSet 「provider 白名单只认 volcano」 3 pod 全 yunikorn、落进预期队列、Running白名单只影响 LWS 自己的 gang 集成,不挡 schedulerName
KServe 「白名单里有 Kueue」暗示 yunikorn 进不去 CRD 里有四处显式 schedulerNamespec.{predictor,transformer,explainer}.schedulerName + predictor.workerSpec
Trino(上一轮已改) unsupported依据是 grep -ci schedulerName == 0 generic那个字段本该由 AC webhook 填;真判据是「能不能往 pod template 注入 label」
四处的共同错法:我把「该项目自己的 gang 集成默认值」当成了「调度器准入白名单」。 而 schedulerName 是一条正交的通路 —— 它由 K8s 本身定义,任何项目都无权拦。 ⇒ 判据必须是「实际提交一个工作负载,回到 pod 上看」,而不是在对方仓库里 grep 竞品名字。
Ch.3.5 · 真机实测 — 被推翻的判定60

⏱ 本页 1.5 分钟 · 主线 319 字 · 深潜层另有 2525 字

(语气坦诚但不自贬,平铺直述就好) 这是自我更正页。标题写三处、表格四行 —— Trino 那行上一轮已改, 四行错在同一处。

左列原判、右列实测 —— 四行全翻过来了: Volcano Job 36 秒跑完、没建 PodGroup,那正是共存机制; LWS 和 KServe 我以为「白名单挡着」,实测都能进, KServe 还有四处显式字段;Trino 从 unsupported 改成 generic。

(底栏这段是这一页存在的理由,请照念) 四处是同一个错:我把「对方仓库里有 volcano 或 kueue 字样」 当成了「别的调度器进不去」。那些字样只是它自己 gang 集成的默认值; 而 schedulerName 是 K8s 定义的正交通路,任何项目都无权拦。

(停一下,这句是要带走的那句) ⇒ 判据必须是「实际提交一个工作负载,回到 pod 上看」,不是 grep 竞品名字。 下一页是唯一一个真的「共存」。

(主线压过一轮,这是四行逐行念的完整版,时间够时换回这版) 开场补一句:上面三行是这一轮新推翻的,最后 Trino 那行是上一轮已经改过的, 所以我把四行放在一起讲。落点也补一句:下一页那个「共存」的例子, 它同样纠正了我一处机制。 左边一列逐行念:Volcano Job 判 conflict、 LeaderWorkerSet 说「provider 白名单只认 volcano」、 KServe 说「白名单里有 Kueue、暗示我们进不去」、 Trino 判 unsupported。 右边一列逐行念:Volcano Job 的 pod 由 vc-controller 建、YuniKorn 调度、 36 秒 Completed,而且它压根没建 PodGroup —— 那正是共存机制; LWS 的 3 个 pod 全是 yunikorn、落进预期队列、Running; KServe 的 CRD 里有四处显式 schedulerName,也就是 predictor、transformer、explainer 再加 predictor.workerSpec;Trino 改判 generic。 开场那句完整版是:四行错在同一个地方,所以我把它们放在一起讲。

(Volcano 那一行的完整原判与推翻证据,被追问时展开) 我原来的判定原文是:Job.spec.schedulerName 可以写 yunikorn, 但 vc-controller 在 PodGroup 的 phase 未离开 Pending 前一个 pod 都不建 (var syncTask bool 默认 false)⇒ 判 conflict。 实测怎么推翻的:提交一个 batch.volcano.sh/v1alpha1 的 Job, spec.schedulerName 和 tasks[].template.spec.schedulerName 两处都写 yunikorn。 结果 pod 的 ownerReferences 明确指向那个 Volcano Job ⇒ pod 确实是 vc-controller 建的;事件流是 Scheduling → Scheduled → PodBindSuccessful → TaskCompleted,四条全部由 yunikorn 发出; Job 状态 Pending → Running → Completed, runningDuration 36 秒,minAvailable 是 2。 (这一步是关键证据)kubectl get podgroup 的输出是空的。

(Volcano 的机制,以及必须带的那句限定 —— 对客时这句不能省) 机制是:schedulerName != volcano 时,vc-controller 跳过 PodGroup、 直接建 pod。那条「PodGroup 未就绪就不建 pod」的分支只在用 Volcano 自己调度时才走。 ⇒ 判定从 conflict 改成 generic。 但要带一句限定:这样用会失去 Volcano 自己的 gang —— 没有 PodGroup 就没有 Volcano 的 all-or-nothing;想要 gang 得改用 YuniKorn 的 task-groups 注解。 (这个措辞差别很重要)这是「可共存」,不是「两者的能力都保留」。 如果对客说成后者,客户上线后会发现自己的 gang 语义悄悄没了。

(LWS 与 KServe 两行的完整实测数字) LeaderWorkerSet:3 个 pod,1 个 leader 加 2 个 worker, 全部 schedulerName=yunikorn、落进 root.tierc.lws、Running。 权威路径是 spec.leaderWorkerTemplate.{leader,worker}Template.spec.schedulerName。 ⇒ 那个 provider 白名单只影响 LWS 自己的 gang 集成,不挡 schedulerName。 KServe:CRD schema 递归出四处显式字段 —— spec.predictor.schedulerName、spec.transformer.schedulerName、 spec.explainer.schedulerName, 再加 spec.predictor.workerSpec.schedulerName。 ⇒ 它是逐组件的一等公民旋钮,与白名单毫无关系。

(Trino 那一行为什么算「上一轮已改」,以及那个 0 究竟错在哪) Trino 我原来判 unsupported,依据是 grep -ci schedulerName == 0。 那个 0 本身是对的 —— 错的是我拿它当判据。 schedulerName 这个字段本该由 AC webhook 来填, chart 里有没有它与能不能接入无关。 真判据是「能不能往 pod template 注入 label」,而这几乎所有 chart 都能。 ⇒ 改判 generic。 (这条和这一页的主结论是同一件事)四行里三行是「看错了别人仓库里的字样」, Trino 这一行是「看对了字样、用错了判据」—— 合起来指向同一个动作:回到 pod 上看,别在源码里数字符串。

(这三例合起来的那条规律,讲选型方法论时可以单独拿出来用) 「某个仓库里有 volcano 或 kueue 字样」≠「别的调度器进不去」。 出现那些字样,通常是因为该项目为某一个 batch scheduler 做了专门的 gang 集成, 于是在代码里维护了一张 provider 名单。 而 schedulerName 是 Kubernetes 自己的字段 —— 它决定「哪个调度器来处理这个 pod」,这个决定权在 pod spec 上,不在框架手里。 上一轮我把这两件事混为一谈,一次判错三个框架。 (顺带一条同类修正)调研还写过「Dask 的 KubeCluster(...) 没有 scheduler_name 参数 ⇒ 静默回落」。 实测:那是 Python API 的限制,DaskCluster 这个 CRD 本身有 spec.{scheduler,worker}.spec.schedulerName,而且已经跑通。 ⇒ 正确表述是「走 CRD 可以,走 Python KubeCluster 不行」,两者别混着讲。

(如果有人问「那你怎么保证这次不再错」——这段是诚实的回答) 我不能保证判断不出错,但我可以换掉产生判断的方式。这一轮做了三件事: ① 判据从「源码里有没有这个字符串」改成「pod 上真正落地了什么」, 而且拆成四条分别记录 —— 这样「框架自己的配置问题」和「YuniKorn 接入问题」不会混成一条。 ② 路径用 schema 递归拿,不用 grep 猜。 ③ 结论存进有 --check 的登记表,不存进 Markdown 表格。 (一个具体的受益例子)MPI 第一次跑 worker 全部 Failed, 根因是镜像要求以 UID 1000 运行而我没设 securityContext —— 但判据②③ 全程是过的(schedulerName=yunikorn、落进 root.tierc.mpi),只有判据① 没过。 如果只有一条「跑通了吗」,这次就会被误记成「MPI 接不进 YuniKorn」。

Ch.3.5 · 真机实测 · Coexistence

Kueue + YuniKorn 是唯一的双层配额组合 共存确证 —— 但机制和我原来说的不一样,而且更强

我原来的解释(源码依据)
「Kueue 从不写 schedulerName,只改 label / annotation / nodeSelector / schedulingGates;而 YuniKorn v1.9.0 的 shim 尊重 schedulingGates(gated pod 不建 task)」⇒ 所以能共存。
实测把机制否证了
# pod 上的 schedulingGates 是空的 kueue-yk-g4lmf gates= sched=yunikorn kueue-yk-lltxc gates= sched=yunikorn
真实机制:两者时间上根本不重叠
①Job 以 suspend: true 提交🔴 pod 还不存在
②Kueue 准入 —— Workload Admitted=True解除 suspend
③pod 这才被创建 ⇒ YuniKorn 调度落进 root.tierc.kueue,2 pod Succeeded
⇒ 不冲突的原因比「尊重 gates」更强:它们压根不同时在场。schedulingGates 是给裸 Pod / 非 Job 工作负载用的另一条路 —— 两条别混起来讲。
对客口径:Kueue 管 Job 级准入(配额够了才放行),YuniKorn 管 Pod 级调度(放哪台机器 + 队列记账)。层级不同、时间不重叠 ⇒ 可以同时用,而且互补。⚠️ 代价是两套配额要各自维护,写不一致时较紧的那个生效,而没有任何工具会告诉你它们不一致。
Ch.3.5 · 真机实测 — Kueue 共存61

⏱ 本页 1.2 分钟 · 主线 243 字 · 深潜层另有 2072 字

Kueue 加 YuniKorn 共存确证,是唯一的「双层配额」组合。 左边那句解释「shim 尊重 schedulingGates」 (指那段代码)被实测否证:gates= 是空的。

真机制三步:suspend: true 时 pod 还不存在 → 准入后解除 suspend → pod 才被创建,才轮到 YuniKorn。 (停一下)⇒ 它们压根不同时在场 —— 这比「尊重 gates」更强。

(对客口径,照念)⇒ Kueue 管 Job 级准入、YuniKorn 管 Pod 级调度, 互补;代价是两套配额各自维护,较紧的生效, 而没有工具会告诉你不一致。下一页看它和 Karpenter。

(主线压过一轮,这是完整版的三段,做长版本时换回这版) 第一段的完整版:Kueue 加 YuniKorn 是唯一的「双层配额」组合 —— 共存这个结论 实测确证了,但机制和我原来说的不一样,而且更强。 第二段要补的两处:Kueue 准入的标志是 Workload 变成 Admitted=True; 以及 schedulingGates 那句的全文是「它是给裸 Pod、非 Job 的工作负载 用的另一条路,两条别混起来讲」。 第三段要补的是层级那半句:「层级不同、时间不重叠,所以可以同时用」。 左边那张卡的完整原话:Kueue 从不写 schedulerName, 它只改 label、annotation、nodeSelector 和 schedulingGates; 而 YuniKorn v1.9.0 的 shim 尊重 schedulingGates —— 被 gate 住的 pod 不建 task ⇒ 所以能共存。 实测那两行的完整读法是:kueue-yk-g4lmf 和 kueue-yk-lltxc, 两个 pod 的 gates= 后面都是空的,而 sched= 都是 yunikorn —— 也就是说它俩根本没被 gate 过。 第三步的完整口播:pod 这才被创建 ⇒ YuniKorn 调度,两个 pod 落进 root.tierc.kueue、最终 Succeeded。 对客那句的完整版:Kueue 管 Job 级准入(配额够了才放行), YuniKorn 管 Pod 级调度(放到哪台机器 + 在队列上怎么记账)。

(完整配置,被问「你到底怎么测的」时照念) Kueue 侧三件:一个 ResourceFlavor、一个 ClusterQueue 额度是 4 CPU / 8Gi、一个 LocalQueue 叫 yk-lq。 工作负载是一个普通的 batch/v1 Job,带 kueue.x-k8s.io/queue-name: yk-lq 和 suspend: true; pod template 里写 schedulerName: yunikorn 加 queue: root.tierc.kueue。 三条证据链:job -o jsonpath='{.spec.suspend}' 返回 false ⇒ Kueue 已放行;get workload 显示 ADMITTED=True、队列 yk-lq ⇒ 准入成功; 两个 pod 最终 Succeeded、落进 root.tierc.kueue, 四条判据全过。

(为什么「机制被否证但结论更强」值得单独说一句方法学) 这一页是本轮最舒服的一个结果,因为它是结论保住、理由换掉。 原来的理由是「YuniKorn 主动做了一件好事 —— 它的 shim 尊重 schedulingGates」;真实情况是「两者根本没有机会冲突」。 (区别在哪)前者是一个会随版本变化的实现细节 —— 哪天 shim 改了对 gates 的处理,共存就可能坏掉; 后者是一个结构性事实:batch/v1 Job 在 suspend 状态下没有 pod, 没有 pod 就没有调度这件事可做。 结构性的理由比实现细节的理由稳,所以我说结论更强。 ⇒ 一条更一般的话:当你发现自己的解释被否证、而结论还站着, 别急着庆幸 —— 先确认新理由是不是比旧理由更结构化。这次是,所以可以放心用。

(那两套配额的代价要讲到能落地,客户真正会踩的是这个) 「两套配额」具体是:Kueue 的 ClusterQueue 里写一份, YuniKorn 的队列树里写一份。它们互不知情。 ⇒ 三种后果都要交代: ① Kueue 松、YuniKorn 紧 —— Job 被准入了、pod 建出来了, 然后卡在 YuniKorn 的队列配额上,而那种卡法我们前面讲过: pod 的 conditions 是空的,所以连 Karpenter 都不会去扩容; ② Kueue 紧、YuniKorn 松 —— 这种相对安全,Job 在准入层就排队,pod 压根不建; ③ 两边都改过、但没人对账 —— 这是最常见的,因为两套配额通常由不同的人维护。 ⇒ 我的建议:把 Kueue 那一层当成唯一的「准入闸门」, YuniKorn 的队列 max 设得略宽于它, 让「资源不足」而不是「配额不足」成为常态触发路径 —— 理由和 Karpenter 那一页是同一条。

(可能被问:那什么时候才用 schedulingGates 那条路) schedulingGates 是 K8s 1.26 之后的通用机制, 它的用法是给一个已经创建出来的 pod 挂一道闸,闸不撤调度器就不看它。 Kueue 对裸 Pod、以及非 Job 的自定义工作负载用的是这条路 —— 因为那些场景里它没有 suspend 字段可用。 ⇒ 所以两条路是互补的,不是同一件事的两种说法: 有 suspend 就走 Job 级 suspend(pod 不存在), 没有就退到 Pod 级 gates(pod 存在但被挂闸)。 (一条待测,必须明说)「裸 Pod + gates + YuniKorn」这条组合我这一轮没有测。 源码依据说 shim 会尊重 gates,但我这次的实测没有覆盖它 —— 我不拿源码推论当实测结论。

(为什么说它是「唯一」的双层配额组合,这个措辞有人会较真) 26 个框架里,其余 25 个的关系都是「怎么把工作负载接进 YuniKorn」—— 也就是形态①到⑤。只有 Kueue 不是接入,是共存: 它不需要、也从不写 schedulerName, 它管的是「这个 Job 现在该不该被放出来」, 而 YuniKorn 管「放出来的 pod 去哪台机器、记在哪个队列」。 ⇒ 这是整份材料里唯一一处「两个调度类组件同时装、而且两者的能力都保留」的组合 —— 对比一下 Volcano 那一行:那是可共存但会失去 Volcano 的 gang。 「互补」和「能同时装」是两个不同的结论,Kueue 是前者,Volcano 只是后者。

Ch.3.5 · 真机实测 · Karpenter B5

全场最重要那条洞察,现在有实测了 而且它同时纠正了我先前两个版本的说法

观测项路径 A · 真缺资源(配额充足)路径 B · 队列配额受限
队列root.bench(max 160 vcore)root.tiny(max 1 vcore),pod 要 2 核
.status.conditionsreason:"Unschedulable"message: request is waiting for cluster resources become available空不是 SchedulingSkipped,是什么都没有
Karpenter NodeClaim20
新增 EC22 台(m6i.xlarge + m6i.2xlarge)一台都没有
pod 最终状态3 个全 Running3 个永久 Pending
反应速度条件写入 → +1.3s Karpenter 感知 → +3.8s EC2 已启动—
实验设计必须交代的一点:两条路径的 pod 都带 nodeSelector: karpenter.sh/nodepool=yk-default。因为集群有 128 vCPU 富余,不加约束的话 pod 会直接落在现有节点上,根本走不到「需要扩容」这一步。加了之后,「是否扩容」就成了唯一的自由变量。
机制(源码注释原文):inspectOutstandingRequests() 的文档写着 “in order to trigger the auto-scaling”,而它的入选条件是 “they can fit into the max head room” ⇒ 配额受限的 ask 进不到这个函数,回调根本不被调用。
我先前两个说法都要改:① 「写 SchedulingSkipped」—— shim 里确实有这个分支,但 core 全仓只发 FAILED ⇒ 那是死代码。② 「全树 SKIPPED 零命中」—— 对 core 成立,过度概括到了 shim。
对客最准确的一句话:「配额受限不触发扩容」是 YuniKorn 写在注释里的刻意设计(we do not trigger the auto-scaling);但它的实现方式与代码自己的计划不同 —— 计划是写一个带原因的条件,现实是什么都不写。净效果一致,可观测性完全不同。
Ch.3.5 · 真机实测 — Karpenter B562

⏱ 本页 1.6 分钟 · 主线 332 字 · 深潜层另有 2604 字

(先讲实验设计,这一步不能跳,不然听众会怀疑我挑了个有利的场景) 两条路径都是 3 个 2 核 pod,唯一差别是队列配额:A 充足,B 只有 1 核。 而两条都用 nodeSelector 钉在 Karpenter 的 NodePool 上 —— 集群有 128 个 vCPU 富余,不钉住就走不到「需要扩容」, 钉住后「是否扩容」是唯一变量。

路径 A:YuniKorn 写下 Unschedulable,Karpenter 开 2 个 NodeClaim、买 2 台 EC2,pod 全 Running。 (时间戳一定要念出来 —— 这条结论的可信度就来自它能逐条对齐) 02:44:12 写条件 → 13.293 感知(+1.3 秒) → 15.783 EC2 启动(+3.8 秒)。协同是真的,很快。

路径 B 是价值所在:配额受限时条件是空的 —— (说重)不是写了个跳过原因,是什么都没写 ⇒ NodeClaim 0、EC2 一台没加、pod 永久 Pending。 机制见左下框:这种 ask 进不到通知函数。

(右下这个框是我的自我更正,请照念) 我先前两个说法都要改。一,「配额受限写 SchedulingSkipped」—— shim 有这个分支,但 core 只发 FAILED,那是死代码。 二,「全树零命中」——对 core 成立,我过度概括到了 shim。 (对客口径)不扩容是刻意设计,但实现与计划不同。下一页看静默失败四例。

(「对客最准确的一句话」的完整版,那个框里的原话,值得整段照念) 「配额受限不触发扩容」是 YuniKorn 写在注释里的刻意设计 —— 原文就是 we do not trigger the auto-scaling。 但它的实现方式与代码自己的计划不同:计划是写一个带原因的条件 (SchedulingSkipped),现实是什么都不写, 因为 core 从不发 SKIPPED、那个分支是死代码。 净效果一致,可观测性完全不同 —— 计划里你能看到一个带原因的条件, 现实里你只能看到一条 Event。 ⇒ 凡把「看到 SchedulingSkipped」当验收判据的文档都是错的, 客户照着做永远看不到。

(正确的验收判据,这条要写进客户的检查清单) 既然 SchedulingSkipped 永远看不到,那验收该看什么?两条,都实测过: ① .status.conditions 为空(不是「有个别的原因」,是空); ② kubectl describe pod 里有一条 Informational event, 而且它点名了爆掉的维度。 两条同时成立 ⇒ 这是「配额挡的」;如果 conditions 里有 reason=Unschedulable ⇒ 这是「真缺资源」,Karpenter 会去买机器。 这两种情况的处置完全不同:前者要改配额,后者要改 NodePool。 顺带补上两个队列的确切配额:路径 A 的 root.bench 是 max 160 vcore,路径 B 的 root.tiny 是 max 1 vcore, 而 pod 每个要 2 核 —— 连一个都放不进去。

(那个函数的完整依据,讲机制时展开) ✅源码:函数名是 inspectOutstandingRequests(), 它的文档注释写着 "in order to trigger the auto-scaling" —— 也就是说这个函数本来就是为自动扩容而写的,不是我借来解释现象的。 而它挑选 ask 的条件是 "they can fit into the max head room, but they are pending because lack of partition resources"。 (这句是关键)⇒ 「装得进 max headroom」是一道闸门: 配额受限的 ask 连这个函数都进不去,所以回调不被调用、没有任何条件可写。 shim 那边 SKIPPED 分支的注释原文是 "if the pod is skipped because the queue quota has been exceeded, we do not trigger the auto-scaling" —— 意图写得非常明确。

路径 A 的 pod 条件原文(✅实测,4 秒间隔采样在 t≈4s 抓到): type: PodScheduled、status: "False"、 reason: "Unschedulable"、 message 是 request is waiting for cluster resources become available。 Karpenter 那边买的两台是 m6i.xlarge 加 m6i.2xlarge,在 us-east-1c。 时序还有一段值得看:02:44:18.323 它打出 computed unready node(s) will fit pod(s) —— 它已经把在途的那台节点算进去了,所以第二个 NodeClaim 只装剩下的 2 个 pod。 这说明 Karpenter 不会因为 YuniKorn 的重复上报而超买。

(开场那句定位,时间够时加回主线) 这一页是全场最重要的一条洞察,而它只能在真 EKS 上验 —— kind 上没有 Karpenter, 所以在本机怎么测都测不出这条。前面三章我给它的证据一直只有源码; 今天它从「源码推论」升级成「EKS 实测」。

(这条自我更正比较小,但它是「不给自己放水」的示范) 路径 B 我还有一个子判据必须撤回。脚本里原本有一条 「Karpenter 的日志里提到这些 pod 了吗」,两条路径都返回 2。 后来查明是我 --tail=200 的窗口撞到了路径 A 的残留日志。 ⇒ 这个子判据不可靠,我不能拿它说「Karpenter 连感知都没有」。 能站住的只有 NodeClaim 计数和 conditions 内容 —— 这两个是干净的。

(三处源码位置,被追问时给出) ✅源码,三处一起给:core 侧 core/pkg/scheduler/scheduler.go:239-268, 只在通过队列 headroom 检查之后才调回调,发的是 UpdateContainerSchedulingStateRequest_FAILED, Reason 就是那句 request is waiting for cluster resources become available; shim 侧 k8shim/pkg/cache/context.go:1198-1237 的 HandleContainerStateUpdate(),两个 case 分支都在, SKIPPED 那支的注释直接写着 "if the pod is skipped because the queue quota has been exceeded, we do not trigger the auto-scaling"; 第三处是 grep —— core 全仓非测试代码里 SKIPPED|FAILED 只有一处命中,就是 scheduler.go 第 262 行的 FAILED。

(路径 A 那个字符串值得单独强调) Karpenter 匹配的是 PodScheduled=False 加 reason=Unschedulable 这个组合,它是一条未成文的字符串契约 —— 没有任何一方的文档写着「双方约定用这个字符串」,两个独立项目靠一个 reason 字段对上了。 (推论)所以任何一方改这个字符串,协同就会静默断开, 而且不会有报错 —— 你只会看到「pod Pending、集群不扩容」。 这条值得写进你们的升级检查清单。

(还有一条没做的路径,必须主动交代) 路径 C 我没有测:gang 的 placeholder 会不会触发扩容? placeholder 是真 pod,如果它们也能走到 inspectOutstandingRequests, Karpenter 就会为占位符去买节点 —— 那是提前计费,会直接改变成本模型。 这条待测。我不猜它的结果。

(可能被问:那我该怎么配,才既有配额又有扩容) 我的建议是把队列 max 设得略高于你愿意扩容到的规模, 让「资源不足」而不是「配额不足」成为常态触发路径; 真正的成本刹车放在 Karpenter 的 limits.cpu 上,而不是队列 max 上。 理由就是这一页:队列 max 卡住的 pod 是「静默 Pending」, 而 NodePool limits 卡住的 pod 至少有条件、也有 Karpenter 侧的事件。

Ch.3.5 · 真机实测 · Silent Failures

真机上撞出的四例静默失败 它们的共同点:失败和成功长得一模一样

缺陷你会看到什么实际发生了什么
KubeRay 默认装不传播 queuehelm 装 kuberay-operator 不传 values 时 Ray head + worker 全 Running,schedulerName=yunikorn,零报错零 event pod 没拿到 queue label ⇒ 放置规则退到 tag 规则,按 namespace 现场造出 root.kuberay,而现造队列 maxResource 为空 = 无上限 ⇒ 你配的 root.ray 拿到 0 个 pod
Trino 的队列配额数学上不可能生效 把 max 写成多小都拦不住,扩到 13 个 worker 全部 Running chart 默认 resources: {} ⇒ pod 零 requests ⇒ 用量在 vcore/memory 两维上恒为 0,而 max 只写了这两维 ⇒ 两者永不相交。补救:max 必须带 pods 维度
每个成功的 gang 作业都留下假 Warning 作业 exit 0,但 driver pod 上有 Warning: placeholder has been timed out core 在应用正常完成时用 TerminationType_TIMEOUT 释放剩余 placeholder(reason 原文 releasing placeholders on app complete),而 shim 只判类型 ⇒ 无法区分「真超时」与「完成清理」⇒ 会污染按 type=Warning 告警的监控
六个延迟指标的名字都写错了单位 yunikorn_scheduler_scheduling_cycle_milliseconds Observe(SinceInSeconds(start)) ⇒ 值是秒,Help 也写着 in seconds ⇒ 谁按名字写 > 100(想表达 100ms)实际表达的是 100 秒,永远不触发
加上前面章节的四条(cpu vs vcore、放置规则造无配额队列、gang 参数键写错零日志、/ws/v1/metrics 双重 gzip),这个清单已经有八条了 —— 而它们没有一条会让你的部署失败,只会让你的治理悄悄不生效。
Ch.3.5 · 真机实测 — 四例静默失败63

⏱ 本页 1.9 分钟 · 主线 402 字 · 深潜层另有 2494 字

四行的共同点是失败和成功长得一样:中间是你会看到什么,右边是实际发生了什么。

第一行,KubeRay 默认装不传播队列标签:你看到 Ray 全 Running、零报错; 实际是按 namespace 现造出无上限队列 ⇒ 我配好配额的队列拿到 0 个 pod。

第二行最该记住:Trino 的队列配额数学上不可能生效。 (这条是我自己推翻自己,放慢)我今天说过「套个队列上限是唯一站得住的用途」—— 被我自己的实测证伪了。

chart 默认无 requests,用量在 vcore 和 memory 上恒为 0,而配额只写这两维 ⇒ 永不相交;补救是加 pods 维度。

第三行,每个成功的 gang 作业都留下假 Warning: 作业 exit 0,driver 上却有「placeholder 超时」—— core 正常完成时也用超时类型清理 placeholder、shim 分不出真假 ⇒ 污染 Warning 告警。另外三条要配错才出现,这条每次成功都出现。

第四行,六个延迟指标的名字都写错单位:名字写毫秒、值是秒 ⇒ 按名字写的告警永远不触发。

(底栏这句是落点,建议照念)加上前面章节的四条,清单已经有八条 —— 没有一条会让部署失败,只会让治理悄悄不生效。最后一页收口。

(底栏说的「前面四条」,念全了效果更好 —— 八条一起听很有冲击力) 前面章节那四条是:① 队列配置里 CPU 的键是 vcore, 而 gang 的 minResource 里是 cpu,写混了不报错; ② 放置规则会现造出没有配额的队列(就是这一页第一行的机制); ③ gang 的参数键写错时零日志 —— 你只会看到「gang 没生效」,没有任何提示; ④ /ws/v1/metrics 双重 gzip —— 带 --compressed 抓会拿到乱码。 加上这一页四条,一共八条。 (这句是这一整章的总落点,值得说)八条里没有一条会让部署失败。 它们全都表现为「装好了、跑起来了、看起来正常」—— 所以「上线成功」这个判据在 YuniKorn 上是无效的判据。

(Trino 那条推论要外推,它不只关于 Trino) 这个缺陷不限于 Trino:任何 chart 默认 resources: {} 的组件都中招。 ⇒ 对客检查项:kubectl get pod -o custom-columns 把 requests.cpu 打出来,凡是 <none> 的组件, 它在 YuniKorn 里的 vcore 和 memory 用量就是 0, 只写 vcore/memory 的队列配额对它完全无效。 这是一条五秒钟就能做完、但没人会想到去做的检查。 ✅实测的原始数字:helm show values trino/trino | grep resources 在第 668 行(coordinator)和第 864 行(worker)各命中一个 resources: {}; pod 上 REQ_CPU / REQ_MEM 都是 <none> (对照 Flink 是 500m / 1Gi);YuniKorn 侧 used = {'pods': 3},而 max = {'memory': …, 'vcore': 32000}。

(补救的确切写法与一个陷阱) 队列配置改成 max: {vcore: "32", memory: 128Gi, pods: "5"}, 用 kubectl create configmap yunikorn-configs --from-file=queues.yaml … | kubectl apply -f - 下发。结果 5 Running / 8 Pending,used = {'pods': 5} —— 精确卡在 5,也就是 coordinator 加 4 个 worker。 ⚠️ 配额收紧不追溯:已经 bind 的 13 个 pod 不会被回收, 你必须 scale 0 再扩才观测到效果。 这一点在做变更窗口计划时很重要 —— 改配额不会立刻生效在存量上。

(配额受限时到底看得到什么,这里要给两层口径) 我原先写「配额受限时静默」,这个说法过强。准确的两层是: pod 条件面静默 —— .status.conditions 为空, 所以 Karpenter 的判据无从匹配、一台机器都不加; 事件面不静默 —— K8s Event 里有一条 Informational, 而且点名了爆掉的维度,原文是 Request '…' does not fit in queue 'root.trino' (requested map[pods:1], available map[… pods:0 vcore:32000])。 ⇒ 这个区分决定排障时该看哪里:只看 conditions 会以为毫无线索。

(假 Warning 怎么分辨真假,运维一定会问) 两个办法:一,看是否同时存在 all placeholders are allocated. Transitioning to running state. —— 有它就说明 gang 成功了、那条 Warning 是误报;二,直接看 TaskCompleted 事件或者作业的 exit code。 ✅源码三步:core 侧 application.go:333-359, 条件是 sa.IsCompleting() && !resources.IsZero(sa.allocatedPlaceholder), reason 字符串原文就是 releasing placeholders on app complete; shim 侧 k8shim/pkg/cache/application.go:674-684, 判据是 == TIMEOUT —— 而「真超时」用的是同一个类型 ⇒ 两者在 shim 侧不可区分,一律发 EventTypeWarning。 第三步最讽刺:core 自己的 log 行写「application is getting timed out」, 而紧下一行传的 reason 是「on app complete」—— log 和 reason 自相矛盾。

(Spark 用户会同时看到第二类假 Warning,一起提醒) 还有一条:k8shim/pkg/cache/task.go 第 536 和 544 行, 形参和格式串都把 finalValue 拼成了 fianlValue, 而这个 typo 会原样出现在 K8s event 里 —— 我在 EKS 上抓到了原文。 但这条 event 其实很有用:它明确告诉你 「多个 app-id 键并存时,最终用了哪个、忽略了哪些」。 排查「作业为什么没落进我指定的应用」时,这是第一条该看的 event。 副作用是 Spark 作业每次都会产生它,因为 Spark 必然同时带 spark-app-selector ⇒ Spark 加 gang 的成功作业会稳定产生两类假 Warning。

(指标那条的完整名单与正确用法) 六个受影响的指标念一遍,方便各位回去 grep 自己的告警规则: scheduling_latency、scheduling_cycle、 node_sorting_latency、trynode_latency、 trynode_evaluation、trypreemption_latency —— 六个后缀都是 _milliseconds,六个的值都是秒。 ✅源码在 core/pkg/metrics/scheduler.go: Name 写 milliseconds、Help 写 in seconds、 Buckets 从 0.0001 开始(注释说 start from 0.1ms ⇒ 单位是秒)。 (顺带一个基线,但它有严格的使用边界) 空载 59,427 个样本,均值 11.1 微秒, 99.86% 落在第一个桶(≤0.1ms)之内,超过 1ms 的是 0 次。 🔴 我不给 p50/p90/p99 —— 首桶边界就是 0.1ms,在首桶里插值等于凭空编一个数。 而且这批样本以空载周期为主,拿它当「调度延迟」会严重误导 —— 它只能是基线,加载态待测。 ⇒ 这也修正了我材料里引用的官方数字(0.001–0.01 秒/周期): 真机空载比它快 100–1000 倍,但空载不可外推,所以我不拿它去替换那个数。

Ch.3.5 · 真机实测 · Application Identity

除 Spark 之外,每个框架上线前都得回答一句:我的 applicationId 从哪来 因为「应用」是配额、gang、抢占、公平的基本单位

出厂默认:整个 namespace 合并成一个应用
# /ws/v1/partition/default/queue/root.flink/applications yunikorn-flink-jobs-autogen Running pods=3 ← JM + 2 TM 合成一个 yunikorn-trino-autogen Running pods=3 ← 整个 ns 一个 yunikorn-kuberay-autogen Running pods=4
同 namespace 再起 5 个 Flink 作业,6 个作业仍是同一个 YuniKorn 应用。这不是显示问题,是记账粒度问题。
那个开关是个两难,不是修复
generateUniqueAppId: false出厂默认3 个 pod → 1 个应用多租户隔离失效
generateUniqueAppId: true3 个 pod → 3 个应用gang 直接失效 —— driver 与 executor 被拆成不同应用,minMember 永远凑不齐
而且它还有可观测性陷阱:开了之后 pod label 是哨兵值 <ns>-uniqueautogen,所有 pod 完全相同,真实应用 ID 只在 scheduler 内存里 ⇒ kubectl get pod -L applicationId 会骗你。
正解既不是 false 也不是 true,而是「每个作业显式打 applicationId」。Spark 之所以是唯一免疫的,是因为它自带每次提交都不同的 spark-app-selector —— 那是它为自己的 executor 发现机制准备的,恰好满足了 YuniKorn 的应用识别契约。这是巧合式兼容,不是有意集成(Spark src/main/ 下零 YuniKorn 生产代码)。
Ch.3.5 · 真机实测 — 应用身份64

⏱ 本页 1.5 分钟 · 主线 311 字 · 深潜层另有 1718 字

收口:这些静默失败的共同根是「应用」这个身份 —— 配额、gang、抢占、公平的基本单位。 左边是出厂默认:Flink 的 JM 加两个 TM 合成了一个应用,Trino 整个 ns 一个。 (说重)再起 5 个作业,6 个仍是同一个应用 —— 这是记账粒度问题。

右边那个开关是两难,不是修复:关着 3 个 pod 变 1 个应用 ⇒ 隔离失效; 打开变 3 个应用 ⇒ (停一下)gang 直接失效。 而它的 pod label 全都相同 ⇒ 拿 kubectl 看会骗你。

(落点,这段建议照念) 正解既不是关也不是开,而是「每个作业显式打 applicationId」。 Spark 唯一免疫,靠它自带每次都不同的 spark-app-selector —— 那本是为 executor 发现准备的,恰好满足了识别契约:巧合式兼容,不是集成。 这一章结束。

左边那份清单的完整原文(✅实测, /ws/v1/partition/default/queue/<q>/applications): root.spark-operator 有 yunikorn-spark-operator-autogen 2 个 pod、 root.trino 有 yunikorn-trino-autogen 3 个、 root.cert-manager 3 个、root.kuberay 4 个、 root.flink 有 yunikorn-flink-jobs-autogen 3 个。 yunikorn-<namespace>-autogen 是 YuniKorn AC 的兜底生成格式, 不是任何 operator 生成的 —— 这一点我专门做了 A/B 确认。

(那个开关的机制很巧,值得讲) 它是一个跨进程的哨兵接力(✅源码 k8shim/pkg/common/utils/utils.go:123-137 与 :174-176): AC 在准入时想生成唯一 ID,但那个时刻 pod 还没有 UID, 所以它先写一个哨兵 —— namespace 名截到 26 个字符,加后缀 -uniqueautogen;然后 shim 检测到这个后缀,再把真的 pod UID 补上去。 (推论)所以你在 pod label 上看到的永远是哨兵,真值只在 scheduler 里。 排查必须走 REST:GET /ws/v1/partition/default/queue/<q>/applications。

(开关的下发方式,注意它不能热加载) kubectl -n yunikorn patch cm yunikorn-defaults 把 admissionController.filtering.generateUniqueAppId 设成 true, 然后必须 rollout restart admission controller —— ✅源码 schedulerconf.go:222 走 checkNonReloadableBool, 改了 ConfigMap 不重启没有任何效果,也没有任何提示(默认值在同文件 L96)。 ✅实测:同一个 3 副本 Deployment,false 时 1 个应用、 true 时 3 个应用,三个应用 ID 各带自己的 pod UID, 而三个 pod 的 label 依然完全相同。

(app-id 的完整优先级链,这是最常被追问的一条) ✅源码 utils.go:147-152 的注释逐字,四级从高到低: ① label yunikorn.apache.org/app-id;② 同名 annotation; ③ label applicationId;④ label spark-app-selector,最低。 队列是三级(utils.go:103-107):label yunikorn.apache.org/queue、同名 annotation、然后裸 label queue 最低。 (一处措辞更正)我原来把这两条链混在一句话里说了 —— 「最低优先级」用在 app-id 上应该指 spark-app-selector,不是 queue; 裸 queue 虽然优先级最低,但它确实有效, Flink 那一行就是只写了它、队列照样落对了。

(一处源码内部不一致,讲给会去读源码的人) constants.go:138 的 AppIdLabelKeys 把 spark-app-selector 排在 applicationId 之前, 而 utils.go:161-163 真正的解析顺序是反过来的。 前者只用于生成「哪些键被忽略了」的告警文案,不影响解析结果 ⇒ 不是功能 bug, 但它会误导读源码的人。我列出来是为了说明一件事: 我读的是实现,不是那张常量表。

(还有一条 AC 的危险默认,和应用身份一起处理效果最好) allow-preemption: true 是 AC 给每一个 pod 无条件加的, 不是任何 operator 加的 —— 我拿三个和 KubeRay 毫无关系的 namespace 做过 A/B: trino、flink-jobs、spark-operator, 三个的 pod 上都有 allow-preemption 和 user.info。 对长驻 MPP 服务尤其危险:YuniKorn 抢占走 DELETE 而不是 pods/eviction,绕过 PDB;Trino worker 被删, 正在那个 worker 上跑的 query 直接失败,因为 Trino 没有 query 迁移能力。 (最刺的一点)而这个「允许被抢占」是出厂默认打开的 —— 用户什么都没配,就已经同意了。 ⇒ 长驻服务所在的队列必须显式关抢占,别依赖默认。

04
Decide
怎么决策
这一章会算一笔账,而这笔账可能会劝你别做。这是我们能放在 CFO 面前最可信的一件事。
成本模型 盈亏平衡点 选型对比 迁移剧本
Apache YuniKorn 技术深潜
65

⏱ 本页 1.4 分钟 · 主线 285 字 · 深潜层另有 183 字

进最后一章。这一章的态度我想在隔页上就说出来,因为它决定了你们怎么听后面四页: 我会把最容易被夸大的地方主动指出来,并且给出一个盈亏平衡点。 如果你们的规模不到那条线,我的建议是别做。

这一章四个小节:先讲成本模型,也就是四个机制里其实只有两个值钱; 再讲最常见的那个夸大;然后给盈亏平衡点,包括香港区的价格; 最后是选型对比和迁移剧本。

这个顺序是刻意的:先说清哪些省钱是真的、哪些是假的,再给平衡点。 如果反过来 —— 先甩一个漂亮的 ROI 数字,后面再说「哦其中这部分不算」—— 可信度会打折,而且是不可逆的打折。

(看现场构成决定这一章的时间) 如果现场有管理层或者 FinOps 的同事在,这一章值得多花时间,前面三章可以压缩。 因为这一章的每一个数字都能追到 AWS 的定价页或者我们自己的实测, 它是我们今天能放在 CFO 面前最可信的一件事。

(这个问题几乎一定会被问,而且它是个好问题) 可能有人会想问:「你们是 AWS 的人,为什么反而劝我们别做?」 我的回答是:因为这类项目失败之后,往往被归咎于技术,而实际原因是规模不匹配。 提前把线画出来,其实是在保护技术选择本身。

我们先拆成本,而且要拆到「哪一部分是调度带来的、哪一部分不是」这个粒度。

Ch.4 · 怎么决策 · 图解 · Decision Tree

该不该上,以及该选哪一个:四道闸门 四个出口里有三个是「不做 / 做别的」

批处理跑在 K8s 上最小单位是一组 pod?不是单个 pod1规模够吗?香港 ~40 / 美东 ~55 台2主力是分布式训练?还是 Spark 系3需要跨集群配额?一个 shim = 一个集群4不需要 YuniKorn你在「在线服务」那一列否先别做把 ResourceQuota + PriorityClass 用到极致不到线看 KAI / VolcanoTrainer 的 gang API 填不进 YuniKorn训练为主看 MultiKueue / KarmadaYuniKorn 硬编码单 partition需要是够Spark 为主不需要上 YuniKorn按五阶段灰度四个出口里有三个是「不做 / 做别的」—— 这是刻意的。这类项目失败后往往被归咎于技术,而实际原因是规模不匹配。提前把线画出来,是在保护技术选择本身。闸门 ②③④ 的依据见本章后续页判据:我的负载的最小有意义单位,是一个 pod 还是一组 pod?如果是很多互相独立的单 pod 任务,你在「在线服务」那一列盈亏平衡点:TCO = 一次性 89,362 美元摊 36 月 + 每月 3,333 运维 = 5,816/月;毛节省按 23.7% 算 ⇒ 需要每月 24,538 美元的 EC2+EKS 支出Kubeflow Trainer 的 gang API 是 coscheduling|volcano 的封闭联合,字段根本填不进 YuniKorn;NVIDIA NeMo 文档让你用 KAI Schedulerv1.9.0 硬编码单 partition(K8s shim 只支持 default,YUNIKORN-22)⇒ 跨集群配额做不到五阶段:装但不接管 → 单队列单团队 → 队列树+ACL → Gang → 抢占。抢占放最后且独立成一次变更 —— 它是唯一会主动杀 pod 的能力,而 PDB 保护不了它
怎么用这一页:给还没决定的团队,它是四道闸门;给已经上了的团队,它是四个「值不值得继续投入」的检查点 —— 尤其第 ② 道,规模一直没上来时,继续加人做 gang 和抢占是负收益的,停在「队列 + 配额」是一个合理的终点。
Ch.4 · 图解 — Decision Tree66

⏱ 本页 1.9 分钟 · 主线 397 字 · 深潜层另有 527 字

这一章我先给一张图,因为它决定了后面四页你该用什么心态听。 这是整份材料唯一一张「劝退图」——四个出口里有三个是「不做」或者「做别的」。

四道闸门,从左往右:第一道,你的最小有意义单位是一组 pod 还是一个 pod? 如果是很多互相独立的单 pod 任务,你在「在线服务」那一列,不需要 YuniKorn。 第二道,规模够不够?香港大约 40 台、美东大约 55 台 —— 不到线,先别做。 第三道,主力负载是分布式训练吗?是的话去看 KAI 或 Volcano。 第四道,需要跨集群配额吗?需要的话得看 MultiKueue 或 Karmada。

(这句建议照念,它是这一章的态度) 四个出口里有三个是「不做 / 做别的」—— 这是刻意的。 这类项目失败之后,往往被归咎于技术,而实际原因是规模不匹配。 提前把这条线画出来,是在保护技术选择本身。

只有全过四关,才走到最右边那个「上 YuniKorn」—— 而且要按五阶段灰度。 接下来四页,我把第二道闸门那个数字是怎么算出来的完整拆给你们看。

(每道闸门的依据都在悬停里,也在后面几页) 第二道闸门的算术:TCO 是一次性 89,362 美元摊 36 个月,加每月 3,333 的稳态运维, 等于每月 5,816;毛节省按 23.7% 算,所以需要每月 24,538 美元的 EC2 加 EKS 支出 才够本 —— 换成节点数就是美东约 55 台、香港约 40 台。 香港门槛更低,因为单价更高,同样百分比对应更多绝对金额。

第三道闸门的依据:Kubeflow Trainer 的 gang API 是 coscheduling 与 volcano 的封闭联合,字段根本填不进 YuniKorn; 而 NVIDIA 的 NeMo 平台文档直接让你把 scheduler 设成 KAI Scheduler。 YuniKorn 在「大数据 Spark」生态里是一等公民,在「AI 训练」生态里不是。

第四道闸门的依据:v1.9.0 硬编码单 partition —— Kubernetes shim 只支持 default,对应 issue 是 YUNIKORN-22。 所以「一个调度器管多个集群的配额」这件事它做不到, 而这不是配置问题,是架构决定。

(如果听众问「那我们已经在跑了怎么办」) 这张图是给还没决定的人看的。如果你们已经上了, 那这四道闸门换个用法:它们是四个「值不值得继续投入」的检查点。 尤其第二道 —— 如果规模一直没上来,那继续加人做 gang 和抢占是负收益的, 停在「队列 + 配额」是一个合理的终点。

Ch.4 · 怎么决策 · Cost Model

四个机制,只有两个真值钱 参考单价 m6g.4xlarge us-east-1 = $449.68 / 节点 / 月

#机制占节省份额说明与算例
1池化
用配额替代专用集群
~70% 机制是统计复用,不是调度。三个团队各按自己峰值买 = Σ(mean+z·σ);合池后买 mean_total + z·σ_total,而独立需求下 σ_total = √3·σ_i。
算例:每队 mean 12 / peak 20 ⇒ 3×20 = 60 节点 → 36 + 8√3 ≈ 50 节点。
YuniKorn 在这里的作用只是「提供一个团队信得过的配额,让共享变得可接受」。
2装箱
节点排序 binpacking
~28% 减少碎片 ⇒ Karpenter 更晚才扩容。
🔶 公开材料里唯一的一手量化数字(Halodoc,EMR on EKS,2026-02):节点内存利用率 >90%、CPU ~88%、单节点扩容前可达「96% and above」,"approximately a 10% reduction in EC2 costs"。
保守取 8% 节点数下降:50 → 46 节点。(✅ 我们实测也看到了这个效果:默认 fair 排序用了 46/50 个节点,而 default-scheduler 只用 30/50)
3EKS 控制面合并2% 3 集群 × $0.10/集群·小时 × 730 = $219/月 → $73/月,省 $146/月。这是零头,别拿它当卖点。
4减少失败 / 死锁作业建模为 $0 这是延迟 / SLO 收益,不是成本收益。算例:一个 4 vCPU / 16 GB 的 driver 白等 30 分钟,烧掉的 EMR uplift 是 $0.029。
即使 50 个 driver 同时卡 1 小时也只有 ~$4。放可靠性页,别放 ROI 页。
—Spot 故意不在这个列表里— 它与 YuniKorn 正交(用不用 YuniKorn 都能用 Spot)。把 Spot 的节省算进 YuniKorn 的账是最常见的夸大。
Ch.4 · 怎么决策 — 成本模型67

⏱ 本页 2.1 分钟 · 主线 431 字 · 深潜层另有 887 字

这一页拆成本。先说这一页的核心结论,因为它决定了你该向谁汇报这个项目: YuniKorn 省钱的 70% 来自「池化」,而池化的机制是统计复用、不是调度 —— YuniKorn 在这里的作用只是提供一个团队信得过的配额,让共享在政治上变得可行。

标题里那个单价先交代一下口径:m6g.4xlarge、us-east-1、449 块 68 每节点每月。 后面所有算例都用这个数,你们换成自己的机型和区域重算就行。

(指着第一行,这一行占了全部节省的 70%,值得把算术当场做一遍) 第一行,池化,约占 70%。 三个团队,各自的峰值是 20 个节点。各建专用集群,就是 3 乘 20 等于 60 台。 但是 —— 三个团队的峰值不会同时到来。 如果这三个需求是独立的,合池之后的标准差是根号 3 倍单队标准差,不是 3 倍。 算下来是均值 36 加上 8 乘根号 3,约等于 50 台。

(这句建议照念,它是这一页的灵魂) 省下来的那 10 台,不是调度算法带来的,是概率带来的。 YuniKorn 只是让这三个团队愿意接受共享 —— 因为配额是真的会生效的。 这个区分很重要,因为它意味着:如果你们的三个团队本来就已经在共享一个集群了, 这 70% 你已经拿到了,YuniKorn 在这一项上给你的增量是 0。

第二行,装箱,约占 28%。机制是减少碎片,让 Karpenter 更晚才扩容。 这一行我有两个证据可以并排给你们看。

第一个是第三方的一手数字:Halodoc 在 EMR on EKS 上的实践, 他们报的是节点内存利用率超过 90%、CPU 大约 88%、单节点扩容前能到「96% and above」, 落到账单上是 "approximately a 10% reduction in EC2 costs"。 我特意用了他们的原话,因为这是目前公开材料里唯一一个关于 YuniKorn 装箱的量化数字 —— 其他文章讲装箱都在讲原理,没人给数。我们保守取 8%,50 台降到 46 台。

第二个是我们自己的实测,而它是从反方向印证的,请注意方向: 我们把 1000 个 pod 丢进 50 个节点。YuniKorn 用默认配置,摊到了 46 个节点上; 而 Kubernetes 默认调度器只用了 30 个。 (停一下) 这说明 YuniKorn 的默认值在云上是错的。 它默认 fair,也就是尽量摊平;而你在云上要的是尽量堆满。 这个必须改成 binpacking,官方文档自己也这么建议, 原话是 "better suited for cloud deployments"。

第三行,EKS 控制面合并,2%。

3 个集群,每集群每小时 0.10 美元,乘 730 小时是 219 一个月,合并成一个是 73, 省 146 块钱一个月。 (要主动说)这是零头,别拿它当卖点。我把它列出来只是为了完整。

第四行,减少失败和死锁的作业 —— 我把它建模成 0 美元。

为什么?算给你们听:一个 4 核 16G 的 driver 白等 30 分钟, 烧掉的 EMR uplift 是 2.9 美分。 即使 50 个 driver 同时卡一个小时,也只有大约 4 美元。 (这句要说清)它的价值在 SLO,不在账单 —— 所以请把它放到可靠性那一页去讲,放进 ROI 表里会显得在凑数。

最后一行,Spot。我故意把它放在列表之外。 因为它与 YuniKorn 是正交的 —— 用不用 YuniKorn 你都能用 Spot。

(这句建议照念) 把 Spot 那 60 到 70% 的折扣算进 YuniKorn 的收益里,是我见过最常见的夸大方式, 而且一定会被 FinOps 抓到。

下一页就是那条最容易被夸大的,我建议你们在自己的材料里主动写出来。

Ch.4 · 怎么决策 · The Overclaim

最常见的夸大:EMR on EKS 的 uplift 按申请量计费 装箱省不下它一分钱

AWS 定价页原文(us-east-1,2026-09 读)

"Pricing is based on requested vCPU and memory resources for the Task or Pod"
每 vCPU·小时 $0.01012 · 每 GB·小时 $0.00111125

AWS 自己的算例金额
100 vCPU × $0.01012 × 0.5 h$0.506
300 GB × $0.00111125 × 0.5 h$0.1667
uplift 合计$0.6727
🔴 关键推论: YuniKorn 改变的是 pod 落在哪个节点,从不改变 pod 申请多少。
⇒ EMR uplift 这一行在用 YuniKorn 前后是逐位相同的。
⇒ 装箱省下的 EMR uplift 是 $0。
能降低 uplift 的只有两件事: ① 跑得更快(运行时 / SQL 优化)② 申请更少(rightsizing)。
换调度器不在这两条里。
📌 这一条必须主动在 PPT 上说出来。 一个 FinOps 审阅者一定会发现它。
你先说,是专业;被他发现,是可信度归零。
顺带纠正另一个混淆:那些著名的 「5.37 倍更快、成本降 61%」是 EMR Spark 运行时 vs 开源 Spark 的数字 (TPC-DS 派生、3 TB、104 条查询、6 × c5d.9xlarge),与调度器无关。 AWS 从未发布任何 YuniKorn 的性能数字。
✅ 正确口径:EMR 运行时买的是查询速度;YuniKorn 买的是排队、原子性和公平性——第二样你必须自己测。
Ch.4 · 怎么决策 — 最常见的夸大68

⏱ 本页 1.8 分钟 · 主线 378 字 · 深潜层另有 737 字

这一页是整份材料里最能建立信任的一页。核心一句: EMR on EKS 的 uplift 是按「你申请了多少」计费的, 而 YuniKorn 从不改变 pod 申请多少 —— 所以装箱省下的 EMR uplift 是零。

左边是 AWS 定价页的原文,2026 年 9 月读的,us-east-1。 (念这句英文原文,它是这一页的证据) "Pricing is based on requested vCPU and memory resources for the Task or Pod" —— 注意那个词是 requested,不是 used,也不是节点数。

单价是每 vCPU 每小时 0.01012 美元,每 GB 每小时 0.00111125 美元。

下面这个算例是 AWS 自己文档里的,我直接用它,因为用对方的算例最有说服力: 100 个 vCPU 跑半小时是 0.506 美元;300 GB 跑半小时是 0.1667; uplift 合计 0.6727 美元。 (停一下,然后说这句) 这个数字不会因为你换了调度器而改变一分钱。

(指着右上那个红框) 右边第一个框是关键推论,我把它拆成两步说: 第一步,YuniKorn 改变的是 pod 落在哪个节点上,它从不改变 pod spec 里的 requests。 第二步,既然计费基准是 requests,那这一行账单在用 YuniKorn 前后是逐位相同的。

结论:装箱省下的 EMR uplift 是 0。 你省下来的是 EC2 那一层,也就是少开节点;不是 EMR 那一层。

右边第二个框说清什么才真能降 uplift:只有两件事。 一是跑得更快,也就是运行时优化或者 SQL 优化,因为 uplift 是按时长乘的; 二是申请更少,也就是 rightsizing。 (这句要说)换调度器不在这两条里面。

右边第三个框是我最想让你们带走的方法论。 (这句我建议直接照念) 「这一条必须主动在 PPT 上说出来。一个 FinOps 审阅者一定会发现它。 你先说,是专业;被他发现,是可信度归零。」 具体的风险是:如果你在 PPT 上写「上 YuniKorn 降本 24%」而没有拆开哪一层降了, 他一算 EMR uplift 根本没变,你整页数字的可信度就没了 —— 不只是那一行,是整页。

最后一个框顺带纠正另一个混淆,这个混淆我遇到过好几次。 那些很有名的「5.37 倍更快、成本降 61%」的数字, 是 EMR 的 Spark 运行时对比开源 Spark 的结果 —— 测试条件是 TPC-DS 派生、3 TB 数据、104 条查询、6 台 c5d.9xlarge。 (重一点)它与调度器完全无关。 而且我要说清楚一件事:AWS 从未发布过任何 YuniKorn 的性能数字 —— 他们关于 YuniKorn 的博客里只有一个 4 节点的 demo,没有 benchmark。

(正确口径,建议照念) 所以正确的说法是:EMR 运行时买的是查询速度;YuniKorn 买的是排队、原子性和公平性 —— 而第二样,你必须自己测。

既然把假的省钱都剔掉了,下一页给真实的盈亏平衡点 —— 而它可能会让在座一部分人决定不做这个项目。

Ch.4 · 怎么决策 · Break-even

盈亏平衡点:55 节点(us-east-1)/ 40 节点(香港) 低于这个规模,我的建议是别做

落地成本(按 $4,255 / 工程师·周)

工作项工程师·周金额
试点:1 队列 1 团队非生产,验证 binpacking + 指标3$12,766
生产铺开:3 团队、队列树、放置规则、ACL、配额定量6$25,532
给所有 Spark 作业上 gang(taskGroup、AZ 固定、超时调优)4$17,021
计费链路:日志 → S3 → Athena,关联 CUR split cost5$21,277
runbook、告警、升级自动化、调度器容灾3$12,766
一次性合计21$89,362
稳态运维0.2 FTE$3,333 / 月

TCO = $89,362 / 36 月 + $3,333 = $5,816 / 月
毛节省按 23.7% 计(池化 + 装箱 + 控制面)⇒ 平衡点 = $24,538 / 月的 EC2+EKS 支出 ⇒ us-east-1 约 55 台 m6g.4xlarge;香港 ap-east-1 约 40 台(单价更高,门槛低 27%)。

改造前规模毛节省/月净/月ROI
60 节点($27.2k)$6,446$63111%
120 节点($54.4k)$12,893$7,077122%
300 节点($136k)$32,232$26,416454%
600 节点($272k)$64,464$58,6481008%

必须说出来的一句话

  • 教科书式的「3 个团队各 20 节点」这个例子,过不了盈亏平衡线。一次性投入的简单回收期是 13.9 个月,扣掉稳态运维后,在 $34.6k/月 的账单上只净赚 $631/月。
  • YuniKorn 是一个 >100 节点规模才成立的决定。回收期 3.8 个月(如果你在合并多个专用集群); ~124 个月,也就是永远不回本(如果你本来就把 Karpenter 用得很好)。
Ch.4 · 怎么决策 — 盈亏平衡点69

⏱ 本页 1.9 分钟 · 主线 397 字 · 深潜层另有 878 字

(这是整场我最建议照念的一页) 核心一句:YuniKorn 是一个大于 100 个节点规模才成立的决定。 低于 40 到 55 台,我的建议是别做这个项目。

先说成本是怎么算出来的,否则数字没有可信度。 单位是工程师·周,按 20 万美元的全负载年薪除以 47 个工作周, 折算成每周 4,255 美元。

左边五项,我一项一项说。 试点 3 周:一个队列、一个团队、非生产环境,验证 binpacking 和指标,12,766 美元。 生产铺开 6 周:3 个团队、队列树、放置规则、ACL、配额定量,25,532。 给所有 Spark 作业上 gang,4 周:taskGroup、可用区固定、超时调优,17,021。 计费链路 5 周:日志到 S3 到 Athena,再关联 CUR 的 split cost,21,277。 runbook、告警、升级自动化、调度器容灾,3 周,12,766。 一次性合计 21 个工程师·周,89,362 美元。

(这一条值得单独强调) 这五项里最容易被低估的是「计费链路」那 5 周。 很多团队做完队列就以为完事了,然后发现没法向业务部门解释账单, 又要花一个多月去建分摊链路。这 5 周不是可选项。

再加上稳态运维 0.2 个 FTE,也就是每月 3,333 美元。 所以 TCO 是:89,362 摊到 36 个月,加上每月 3,333,等于每月 5,816 美元。 毛节省按 23.7% 算 —— 也就是刚才那三项:池化加装箱加控制面 —— 平衡点就是每月 24,538 美元的 EC2 加 EKS 支出。

(香港这个数字对在座最直接) 换成节点数:us-east-1 大约 55 台 m6g.4xlarge;香港 ap-east-1 大约 40 台。 香港的门槛比美东低 27%,原因是香港的 EC2 单价更高, 同样的百分比节省对应更多的绝对金额。 所以如果你们主力在香港区,这个门槛会比美国区低一些。

右边这张表把四个规模摆在一起,请重点看第一行。 60 个节点,月账单 2 万 7 千 2:毛节省 6,446,净赚只有 631 美元一个月,ROI 11%。

120 节点:净 7,077,ROI 122%。 300 节点:净 26,416,ROI 454%。 600 节点:净 58,648,ROI 1008%。 (指着这一列)你们看这个跳变 —— 从 60 到 120,ROI 从 11% 跳到 122%。 这不是线性的,因为一次性投入是固定的。

(右下角那两句是这一页的全部价值,建议逐字念) 第一句:「教科书式的『三个团队各 20 节点』这个例子,过不了盈亏平衡线。」 它的简单回收期是 13.9 个月,扣掉稳态运维后, 在每月 3 万 4 千 6 的账单上只净赚 631 美元。 第二句:「YuniKorn 是一个大于 100 节点规模才成立的决定。」 如果你在合并多个专用集群,回收期是 3.8 个月,很划算; 但如果你本来就已经把 Karpenter 用得很好,回收期是 124 个月 —— 也就是永远不回本。

还有两个限定我必须补上,否则这 21 周是不诚实的。 第一,这 21 周假设你们已经在用 Karpenter 和 Prometheus。 如果没有,前面还得加。 第二,如果组织里没有调度器经验,再加大约 4 周 —— 队列树设计、抢占语义、gang 的 taskGroup 正确性,这三件是真正吃时间的地方。

(这一条容易被忘,但它是运维会问的) 另外别忘了 bus factor:这是 pod 准入路径上又一个关键组件,而它默认是单副本。 这件事本身不贵,但它需要有人懂。

如果规模够,接下来的问题就是选哪一个。下一页做选型对比。

Ch.4 · 怎么决策 · Comparison

YuniKorn vs Volcano vs Kueue 不要从 feature 列表开始比——先看架构定位

维度YuniKornVolcanoKueue
架构定位替换 kube-scheduler与 kube-scheduler 并存的独立调度器不调度 pod,只做 Job 级准入门控
用户手上写什么注解 + label不引入新 CRD自己的 CRDQueue / PodGroup / VolcanoJob原生 Job + label + 配套 CRD
层级队列 强项任意深度 + guaranteed/max + ACL有 Queue CRD,层级较弱cohort / borrowing,形态不同
真 gang(原子放置) placeholder 占位 PodGroup + minAvailable招牌能力 不做放置 ⇒ 无真 gang
抢占 七条定律,锚点 guaranteed preempt / reclaim 基于优先级
拓扑感知(NUMA / 网络) 无,路线图上也没有 有相关能力 有 TASGKE 的拓扑调度建在其上
多集群 无,且硬编码单集群 volcano-global(alpha) MultiKueue
AI 训练框架原生支持 Kubeflow Trainer 不支持它 Trainer / LWS / MPI 都支持 JobSet / Trainer / RayJob
Spark 生态 强项有官方专节(最新 GA 钉 1.8.0);但只有文档+测试,无生产代码 Spark 主干内建 feature step
治理归属Apache 基金会 TLPCNCFkubernetes-sigsK8s 官方子项目
云厂商背书仅 AWS + Cloudera华为云 CCE 一等公民GKE / AKS / 火山引擎
选型的真正问题不是「哪个 feature 多」,而是「你要的是配额准入还是原子放置」。 Kueue 放行 Job 之后把放置权交回 kube-scheduler ⇒ 它保证的是「这批 pod 的配额够了」, 不是「这批 pod 一定同时落到节点上」。这是三者之间最实质的技术差异。
Ch.4 · 怎么决策 — 三者对比70

⏱ 本页 1.4 分钟 · 主线 301 字 · 深潜层另有 2926 字

(表格很密,不要逐格念:先说方法,再挑四行讲透,其余成组带过,最后落到 tfoot) 这一页的核心一句建议照念: 不要从 feature 列表开始比。三者的架构定位根本不同,feature 差异全部是架构差异的结果。 真正要回答的问题只有一个:你要的是「配额准入」,还是「原子放置」。

(指第一行) 第一行,架构定位 —— 这一行决定了下面所有行。 YuniKorn 是替换 kube-scheduler 的独立调度器; Volcano 是与 kube-scheduler 并存的独立调度器,它从 kube-scheduler 派生而来。

Kueue 根本不调度 pod,只做 Job 级的准入门控 —— 挂起、排队、放行整个 Job,放行之后把放置权交回 kube-scheduler。

第二行,用户手上写什么。 YuniKorn 是注解加 label,不引入任何新 CRD; Volcano 是自己的 CRD —— Queue、PodGroup、VolcanoJob; Kueue 是原生 Job 加 label,再加一套配套 CRD。 (这一行要讲成双刃剑,别只讲好的一面) 「不引入新 CRD」好处是集成成本极低 —— 对方不用为你写代码,你打个注解就接上了; 坏处是你永远拿不到一等公民待遇,因为一等公民恰恰意味着对方为你写了代码。 证据:Spark 主干里有 Volcano 的 feature step,那是生产代码; YuniKorn 在 Spark 仓库里只有集成测试 YuniKornSuite.scala。 (补一句公道话)但 Spark 官方文档有专门的 YuniKorn 一节,而且钉了 1.9.0。

(第四行是全页最实质的一行,慢讲) 第四行,真 gang,也就是原子放置。 YuniKorn 用 placeholder 占位;Volcano 用 PodGroup 加 minAvailable, 这是它的招牌能力;Kueue 这一格是「不做放置,所以没有真 gang」。 它有 waitForPodsReady,但语义是「等就绪,否则重新排队」,比 all-or-nothing 弱。 (这句是这一页最该带走的判断) Kueue 保证的是「这批 pod 的配额够了」,不是「这批 pod 一定同时落到节点上」。

(第三行和第五行成组过,但每一格都要说成一句话,不要念单词) 第三行,层级队列。这一行是 YuniKorn 的强项:任意深度的队列树, 每一层都能写 guaranteed 和 max,还能在队列上挂 ACL。 Volcano 也有一个 Queue CRD,但它的层级支持比较弱 —— 你很难用它表达一棵深树。 Kueue 走的是另一条路,它的概念叫 cohort 和 borrowing。 (这一格要如实说,不要替它下结论) 我在页面上只写了「形态不同」,因为我们没有对 Kueue 这套概念做过实测 —— 我不想在这里给你们一个我自己没验证过的判断。

第五行,抢占。三家都有,所以这一行的差别不在「有没有」,在「为什么抢」。 YuniKorn 那边是七条定律,目标是让队列拿到自己的 guaranteed, 拿到就停手,不是把 max 抢满。 Volcano 那边是两个动作,一个叫 preempt、一个叫 reclaim。 Kueue 那边是按优先级抢。 (下面这句要标清楚口径) 如果这一行你只记一件事,就记它的锚点是 guaranteed —— 不设 guaranteed,抢占就没有「低于保障量」这个触发条件。 这一条是机制推论,不是我们实测出来的,但它是「抢占配了没反应」最常见的原因。

第六行,拓扑感知,也就是 NUMA 和网络拓扑那一类。这是 YuniKorn 的硬伤:没有, 而且路线图上也没有。 (这个区分要说出来)我特意分清楚:这不是「还没做」,是没打算做。 Volcano 那边有相关能力;Kueue 那边有一套叫 TAS 的东西, 全称是 TopologyAwareScheduling, 而 GKE 的拓扑感知调度就是直接建在它上面的 —— 这是个很强的信号。

第七行,多集群。YuniKorn 没有,而且是硬编码的单集群。 Volcano 有一个 volcano-global,但还停在 alpha。 Kueue 有 MultiKueue,这是上游对「跨集群批处理」给出的答案。 所以如果你们的场景本来就是多集群,这一行会直接影响选择。

(第八行慢一点,它是最容易变成否决项的一行) 第八行,AI 训练框架的原生支持。这一行如果命中你,基本就是否决项。 Kubeflow Trainer 的 gang 调度接口是一个封闭的二元联合 —— 只能填 coscheduling 或者 volcano,没有任何办法填 YuniKorn。 (这句要说清,否则听众会以为只是麻烦) 注意这不是「配起来费劲」,是那个字段根本填不进去。 Volcano 那边 Trainer、LWS、MPI Operator 都支持它; Kueue 那边 JobSet、Trainer、RayJob 也都有。

第九行,Spark 生态。这一行第二行其实已经讲透了: YuniKorn 和 Volcano 都是一等公民, YuniKorn 这一格我写的是「强项」,依据就是 Spark 官方文档有专节并且钉了 1.9.0; Volcano 那格是 Spark 主干里内建的 feature step。 Kueue 这一格我只标了「部分」,它在 Spark 这条线上明显弱一些。

第十行,治理归属。YuniKorn 是 Apache 基金会的顶级项目, Volcano 在 CNCF,Kueue 在 kubernetes-sigs —— 也就是 Kubernetes 官方的子项目。 (这一行看着像行政信息,其实不是;下面这段是全部资料里我认为最有洞察的一段) YuniKorn 的一位 PMC 成员 2022 年就说过这个困境,原话是: 「We have a project that hangs between two things. We have Apache, but we are building on top of the CNCF, the cloud native stuff.」 ASF 的治理,配 CNCF 的技术栈 —— 这是结构性错配,而且是他们自己先看到的。 (这一句必须标清楚,不要让它听成引文的一部分) 但我要说明:「所以 Kueue 因此占优」是我的推论,不是他的原话 —— 他讲的是困境本身,没有讲谁赢。

第十一行,云厂商背书 —— 这一行对在座的实际影响最大。 YuniKorn 只有 AWS,再加上 Cloudera,而 Cloudera 是它的娘家 —— 所以厂商侧其实只有一家半。 Volcano 是华为云 CCE 的一等公民;Kueue 是 GKE、AKS、火山引擎三家。 (这句要说出来,它是这一行的实际含义) 翻译成大白话:在 AWS 上 YuniKorn 是有官方文档背书的一等选项; 在其他云上你是自带方案,出问题没有厂商工单可开。

(指表格最底下那一栏,这是落点,建议逐字念) 「选型的真正问题不是哪个 feature 多,而是你要的是配额准入还是原子放置。 Kueue 放行 Job 之后把放置权交回 kube-scheduler, 所以它保证的是这批 pod 的配额够了,不是这批 pod 一定同时落到节点上。 这是三者之间最实质的技术差异。」

落到实践:痛点是 Spark driver 互等死锁 —— Kueue 解不了; 痛点是「团队之间配额没人管」—— Kueue 是最轻的解。

(这一段 30 秒,它解释了一个很多人当成营销问题的现象) 还有一层:「替换调度器」在托管 Kubernetes 上是天然逆风的。 托管集群的 kube-scheduler 归厂商管,而 YuniKorn 和 Volcano 都要接管调度, Kueue 只做准入,可以和厂商自研的调度器叠加。 (这句建议照念) 这就是 Kueue 在 GKE、AKS、火山引擎文档里成为地基的结构性原因,不是营销力度问题。

(这一条是给要引用别人对比表的人的,一定要说) 诚实提醒一句:网上流传最广的那张三者对比表里有错。 它把 Kueue 的 gang 标成不支持, 而 Ray 官方文档里有一整页题目就叫「Gang scheduling … with Kueue」,直接反驳; 它还把 YuniKorn 的「依赖编排」标成支持,正文里没有任何一处依据 —— YuniKorn 的 gang 是「同时起」,不是「A 完成后起 B」,DAG 是 Argo 和 Airflow 的职责。 (教训要说出来)我抽查了两格,两格都错。引用现成对比表之前,先抽查两三格。

(这一段时间紧可跳,但如果有人问「有没有中立的对比」就用它) KubeCon EU 2025 有一场专门做这三家对比的议题,讲者之一是 Apple 的 Wei Huang, 他做过多年 Kubernetes SIG-Scheduling 的 co-chair, 也是 scheduler-plugins 和 kwok 的创建者。 (限定必须跟上)但那场议题分级是 Beginner、30 分钟,描述里没有任何对比数据 —— 它的价值是「这个话题值得认真对待」,不是一份权威 benchmark。

(这个追问几乎一定会来,而且是个好问题) 可能有人问:「Kueue 上游动能最强,我们是不是该等它?」 我的看法:痛点是原子放置,现在就得用 YuniKorn 或 Volcano,Kueue 短期补不上; 痛点是配额,那等 Kueue 是合理的。

下一页是给从 Hadoop 迁过来的团队的 —— 而这恰恰是 YuniKorn 的护城河。

Ch.4 · 怎么决策 · YARN Migration

YARN → YuniKorn 概念对照 这是它的护城河,也是最容易配错的地方

YARN(Capacity Scheduler)YuniKorn迁移时的注意点
队列(root.a.b)队列(root.a.b)概念与命名几乎 1:1,这是它的护城河
capacity(百分比)resources.guaranteed(绝对量)🔴 YARN 用百分比会随集群自动伸缩,YuniKorn 用绝对量不会。集群扩容后必须回来改配置,否则保障比例被稀释
maximum-capacityresources.max同上,绝对量
acl_submit_applicationssubmitacl语法不同(「用户列表 空格 组列表」),语义相同
acl_administer_queueadminacl⚠️ YuniKorn 的 adminacl 同时授予 submit 权限
ApplicationMasterSpark driverK8s 上没有 AM 这一层
maximum-applicationsmaxapplications子队列必须 ≤ 父队列
队列内 FIFO / Fair · DRFapplication.sort.policy🔴 跑 gang 的队列必须是 fifo;配成 fair 报 unsupported sort type,而这个报错不提原因。且 properties 会从父队列继承
node label / partition🟡 只能靠 nodeSelector + taint 近似🔴 最大的语义缺口:没有「队列绑定节点组」这个一等公民概念(K8s shim 只支持 1 个 partition)
reservation system(预约未来容量)❌ 无对应物YARN 能预约「明天 2 点给我 100 核」,这里不能
opportunistic containers · Federation❌ 无对应物单集群,见第 1 章的边界页
 🔵 反过来 YuniKorn 有 YARN 没有的:gang scheduling(YARN 靠 AM 自己协调)、 以及与 K8s 原生调度约束(affinity / topologySpread / PVC 拓扑)的天然融合。
Ch.4 · 怎么决策 — YARN 概念对照71

⏱ 本页 1.7 分钟 · 主线 356 字 · 深潜层另有 2072 字

(先问一句,这一页的讲法取决于答案) 在座有多少人现在还在跑 YARN,或者刚从 Hadoop 迁过来? ……(举手多 → 这一页慢讲;没人举手 → 三分钟带过,只留那两个缺口)

核心一句:概念几乎一比一,所以熟 YARN 的人几乎不用重新学 —— 但有两个语义缺口会咬人:百分比变成了绝对量,以及 node label 没有对应物。

(先给依据,否则「1:1」听起来像营销话) 这个对照是我整理的,但有一条很硬的依据:YuniKorn 官方的抢占设计文档自己写着 —— 「Prior knowledge of implementing preemption in the Apache YARN scheduler has been used to create this design」。它的设计明确来自 YARN 的经验,所以对得上不是巧合。

(指第一行) 第一行,队列。YARN 里是 root.a.b,YuniKorn 里也是 root.a.b —— 连命名都一样。

这一行就是护城河: 你们用了好几年的队列树可以几乎原样搬过来,团队不需要重新理解「队列是什么」。

(第二行是这一页最重要的一行,而且是延迟发作的,务必慢讲) 第二行,YARN 的 capacity 是百分比,YuniKorn 的 resources.guaranteed 是绝对量。

讲成场景就懂了:YARN 里你写 capacity: 30%,集群从 100 台扩到 200 台, 这个队列自动从 30 台的份额变成 60 台。 YuniKorn 里你写 guaranteed 的 vcore 是 30,集群扩容之后它还是 30 —— 新增的容量全部落进「可借用」那部分,保障比例被悄悄稀释了。 (这句要说重)而且不报错、不告警, 你只会在某天发现「明明扩了容,这个团队还是抢不到资源」。 实践建议:把「集群扩容后回来复核队列配置」写进扩容 runbook。 第三行 maximum-capacity 对应 resources.max,同样绝对量、同样的坑。

第四、第五行是两条 ACL。 acl_submit_applications 对应 submitacl, acl_administer_queue 对应 adminacl。 语义相同、语法不同 —— YuniKorn 写成「用户列表 空格 组列表」,那个空格是分隔符。 (第五行这个注意点很容易漏) YuniKorn 的 adminacl 同时授予 submit 权限 —— 给某人 admin 就等于顺手给了提交权,这跟 YARN 的直觉不一样。

第六行,ApplicationMaster 对应 Spark driver —— 这一行真正在说的是 Kubernetes 上没有 AM 这一层。YARN 里 AM 是框架与调度器共同约定的角色, 在 K8s 上那个角色就是 Spark driver 本身,一个普通 pod。 (隐含含义值得点一句)正因为没有 AM, 「一组 pod 要同生共死」这件事就没人替你协调了 —— 这也解释了为什么这里必须有 gang。 第七行,maximum-applications 对应 maxapplications, 注意子队列必须小于等于父队列。 (顺带纠一个高频误解)YARN 出身的人常以为「设了 FIFO 就是一个一个跑」—— 不是,官方明确写着排序策略不限制并发; 想限制同时跑几个作业,唯一的旋钮是 maxapplications。

(第八行这个坑非常值钱,YARN 出身的人几乎一定会踩) 第八行,队列内的排序。YARN 是 FIFO、Fair、DRF, YuniKorn 对应 application.sort.policy。 但这里有硬约束:跑 gang 的队列必须是 fifo。 配成 fair 我们实测过 —— 直接拒绝,报错就三个单词: unsupported sort type。 (停一下)这条报错不提 sort policy、不提 fifo、也不说是哪个队列的哪个属性, 单看它基本没法定位。机制上的原因是 fair 会给每个应用都预留一点, 于是每个 gang 都凑不齐,全体卡死。 (「传染」这部分更麻烦,一定要说)而且它会从父队列继承 —— 在 root 上设了 fair,所有没显式覆盖的子队列都跑不了 gang。 两条规则:不要在 root 上设这个属性;要跑 gang 的 leaf 队列显式写 fifo。

(第九行是第二个语义缺口,对有异构硬件的团队最关键)

第九行,YARN 的 node label 和 partition。 在 YARN 上它是用来把队列绑到特定硬件的 —— GPU 队列、大内存队列。

YuniKorn 没有这个一等公民概念:队列本身不知道自己该在哪些节点上跑, 只能在 pod 和 task group 上打 nodeSelector,再配节点 taint 来近似; Kubernetes shim 只支持一个 partition。

(这句是真正的后果,建议照念) 这意味着那个约束从「平台强制」降级成了「用户自觉」。

想恢复成强制,得再加一层策略引擎 —— Kyverno 或者 Gatekeeper。

第十行,reservation system,页面上写的是「无对应物」。 YARN 上你能预约未来的容量 —— 「明天下午两点给我 100 核」, 它会替你把那段时间的容量留出来。 YuniKorn 这里不能,没有等价物,你只能在提交侧自己排时间, 比如靠 Airflow 的调度时刻去近似。

第十一行是两个东西,opportunistic containers 和 Federation,同样是「无对应物」。 Federation 那一半好解释:它就是第一章讲过的那条边界 —— YuniKorn 是单集群的, Kubernetes shim 只支持一个 partition,所以跨集群这件事在这里没有落点。 (opportunistic 这一格要如实说成「我们没查」,不要圆过去) 而 opportunistic containers 这一格,我们能确认的只有「没有对应物」这一件事 —— YuniKorn 侧有没有哪个机制勉强能顶上它,我们没有查证,所以我不在这里替它圆。 如果你现在真的在用 YARN 的这个能力,这一格请自己再挖一次。

(这三格要说清是「无」,不要含糊过去,这是这一页的诚实性所在) 这三行放在一起我说一句总结:如果它们命中你现在正在用的能力, 那是实打实的功能退化 —— 不是「换个写法就行」, 得在迁移方案里单独立项、单独找替代方案。

(指最下面那条蓝色的行,这一页必须以正面收尾) 最后一行反过来:YuniKorn 有 YARN 没有的东西。 一是 gang scheduling —— 在 YARN 上这件事靠 AM 自己协调,每个框架各写一遍; 在这里它是调度器提供的能力,所有框架共用。 二是与 Kubernetes 原生调度约束的天然融合 —— affinity、topologySpread、PVC 拓扑,在 YARN 上根本不存在。

(落点这句可以照念) 所以迁移不是「把 YARN 降级成 K8s」,是换了一组能力: 丢掉预约和 node label,换来 gang 和整个 K8s 调度约束体系。

最后一页讲怎么落地 —— 而这里有一个最直觉的方案是行不通的。

Ch.4 · 怎么决策 · Rollout

迁移剧本:五个阶段 而最直觉的那个方案行不通

🔴 先破除一个错误方案: 「给要迁移的负载加 schedulerName: yunikorn,其余保持 default-scheduler」—— 这行不通。mutating webhook 默认作用于全集群所有工作负载类型, 会把显式写着 default-scheduler 的也改写成 yunikorn,而且不报错。 ⇒ 唯一正确的出口是 namespace 级开关。
阶段 0
装但不接管

embedAdmissionController=false,或 processNamespaces 指向空 ns。判据:能读 config、能抓指标

›
阶段 1
单队列单团队

1 ns + 1 leaf 队列 + binpacking;不开 gang、不开抢占。判据:跑一次超配额实验,确认 pod 停在 Pending 且没有任何 PodScheduled 条件(不要去找 SchedulingSkipped,v1.9.0 不会写)

›
阶段 2
队列树 + ACL

3 团队;provided 规则在前;组 ACL。判据:isManaged==false 巡检为空;组 ACL 真的匹配上了

›
阶段 3
Gang

加 taskGroups,显式 Hard,超时按节点冷启动 p99 取值。判据:placeholder 能正常 swap,无长期 Accepted

›
阶段 4
抢占

设 guaranteed;关键队列设 preemption.policy: disabled。判据:能触发,且无永久 Pending 的 Deployment

✅ 正确的灰度开关(两套,可组合)

# A · admission controller 的 namespace 过滤
#   ✅ 实测:支持逗号分隔正则,亚秒热生效
admissionController.filtering.processNamespaces:
  '^data-eng-dev$,^data-eng-staging$'

# B · namespace 注解(覆盖正则,优先判断)
#   🔵 灰度的最佳抓手:不改全局配置
kubectl annotate ns team-a \
  yunikorn.apache.org/namespace.enableYuniKorn=true
为什么抢占放最后、且独立成一次变更: 它是唯一会主动杀掉正在运行的 pod 的能力,而且 PDB 保护不了它。
可逆性(客户最关心的)——PMC 成员原话: "Since it is a drop-in replacement … Stopping YuniKorn will revert the cluster back to its old state."
但要补两条实测限定:① 已带 schedulerName: yunikorn 的 pod 在卸载后永远不会被调度,回退前必须重建; ② 正在跑的 gang 的 placeholder 命运我们未实测,回退演练要专门验证。
诚实表述:新负载的回退是干净的(摘注解,几秒生效); 已在运行的负载需要重建。
Ch.4 · 怎么决策 — 迁移剧本72

⏱ 本页 1.2 分钟 · 主线 243 字 · 深潜层另有 2435 字

(先讲顶上那个红框,讲完再进五个阶段 —— 红框是这一页的价值所在) 核心一句:最直觉的那个灰度方案 —— 给一部分负载写 schedulerName: yunikorn、其余保持默认 —— 是行不通的,而且不报错。唯一正确的出口是 namespace 级的开关。

很多人的第一反应是:「要迁的那批加上 schedulerName: yunikorn, 其他保持 default-scheduler,这不就灰度了?」 这行不通。 YuniKorn 的 mutating webhook 默认作用于全集群所有工作负载类型 —— pod、deployment、replicaset、statefulset、daemonset、job、cronjob 全在内 —— 它会把显式写着 default-scheduler 的也改写成 yunikorn。 (这句要说重)而且不报错。你以为在灰度,其实已经全量切了。

(🔴 这个坑第一章「它的能与不能」那页已经讲过一遍 —— 这里不要从头再讲, 用回指的方式带回来。这一页才是它的正确出口,所以落点留在这一页说) 第一章我提过我们自己踩的那个坑,就是这一条,现在我把它讲完。 当时做性能 A/B,提交了两批 pod,一批写 default-scheduler、 一批写 yunikorn,两组结果漂亮地一致 —— 0.495 秒对 0.470 秒, 落点分布也一致,50 个节点每个恰好 3 个。 然后我们去查集群里真实的 pod spec:1000 个全部是 yunikorn。 (停一下)我们测的是「YuniKorn 对 YuniKorn」,那张对比表整个作废。

(这一层第一章没说,留在这里说 —— 它是这一页真正的价值) 这个坑最恶劣的地方不是它出错,是它给你一个看起来像结论的结果。 「两个调度器性能相同」这句话听起来完全合理,我们差一点就把它当结论发出去了。 (方法论要落成一条可执行的规矩,不要停在感慨) 所以规矩是这样:在装了 YuniKorn 的集群里做任何调度器 A/B, 必须先把对照组那个 namespace 放进 bypassNamespaces, 而且要动手验证它真的生效了 —— 配了不算,要去 kubectl get pod 把 schedulerName 读出来看一眼。

(转到左下那个代码框,两套机制都要念) 正确的做法有两套机制,可以组合。

机制 A 是 admission controller 的 namespace 过滤,key 是 admissionController.filtering.processNamespaces, 写在 ConfigMap 里、和 queues.yaml 平级,不是嵌在 YAML 内部。 (这两点是我们实测确认的,文档没写清) 它支持逗号分隔的正则列表 —— 页面上这个例子里就是两条: ^data-eng-dev$ 和 ^data-eng-staging$,一个开发、一个预发; 而且亚秒级热生效,不需要重启 admission controller。 上线初期用白名单,只放要迁的 namespace 进来;铺开后改成黑名单模式, 也就是 bypassNamespaces,只排除系统和还没准备好的。 (默认值本身是个坑)默认只 bypass 了 kube-system 一个 —— 生产上至少要扩到 kube-public、kube-node-lease 和 yunikorn 自己。

机制 B 是打在 namespace 上的注解,就是页面上那条 kubectl annotate: yunikorn.apache.org/namespace.enableYuniKorn=true, 例子里开的是 team-a 这一个 namespace。 (依据在源码注释里,值得说出来) 源码注释明确写着它覆盖全局正则的行为,而且在正则之前判断。 (这句建议照念) 机制 B 是灰度的最佳抓手:不用改全局配置,一个 namespace 一个 namespace 地开; 哪个出问题,把注解改成 false 就退回去了。 (顺带送一个小技巧)还有个配套注解 namespace.generateAppId, 打上之后自动生成 app-id,省得每个 pod 都去打 label。

(转到中间那条五阶段流程,五个阶段都要交代,重点是判据) 每个阶段都有判据 ——「有判据」是这个剧本能用的关键, 没有判据的阶段划分只是 PPT 上的箭头。

阶段 0,装但不接管:embedAdmissionController=false, 或把 processNamespaces 指向一个空 namespace。 判据是能读到配置、能抓到指标。 (提醒一句)抓指标这一步在 1.9.0 上有个坑,第二章讲过 —— 不要加压缩,否则你会以为指标不存在。

阶段 1,单队列单团队、非生产。 一个 namespace 加一个 leaf 队列,节点排序改成 binpacking; 这个阶段不开 gang、不开抢占。 判据是:跑一次超配额实验,确认 pod 停在 Pending 且没有任何 PodScheduled 条件(🔴 不要去找 SchedulingSkipped,v1.9.0 不会写,你会白找)—— 也就是亲眼确认配额真的在生效,而不是假设它生效了。

阶段 2,队列树加 ACL。铺开到三个团队,provided 规则放最前面,配上组 ACL。 (这个判据要重点念,它挡住的是第二章那个头号陷阱) 判据两条:第一,isManaged==false 的巡检必须为空 —— 查的是「有没有人绕过配额体系、动态造出了没有配额的队列」; 第二,组 ACL 真的匹配上了 —— 如果 Kubernetes 认证链路没把组信息带进来, ACL 会默认拒绝,结果是全部作业被拒。

阶段 3,Gang。给 Spark 和训练作业加 taskGroups,显式写 Hard, 超时按节点冷启动的 p99 取值。 判据:placeholder 能正常 swap,没有长期停在 Accepted 的应用。 (补一句退路,客户会问)这个阶段回退很轻:去掉 gang 注解就行, 应用会退化成普通调度,不会失败。 阶段 4,抢占。设 guaranteed; 关键队列设 preemption.policy: disabled 保护起来。 判据:抢占确实能触发,以及没有出现永久 Pending 的 Deployment —— 后面这条是第二章讲过的那个已知后果。

(指右上那个「为什么抢占放最后」的框) 顺序是刻意的,尤其抢占放最后、而且独立成一次变更。

理由很硬:它是唯一会主动杀掉正在运行的 pod 的能力,而且 PDB 保护不了它。 (这句建议照念) 前四个阶段出问题,最坏是「作业排队」;第五个阶段出问题,是「作业被杀」。 这两件事在组织里的后果完全不同,所以它必须单独变更、单独做一次回退演练。

(指右边那个绿框,这是客户一定会问的问题) 可逆性。

最好的一句回答来自 YuniKorn 的 PMC 成员本人: 「Since it is a drop-in replacement … Stopping YuniKorn will revert the cluster back to its old state.」这句可以直接引用。 (但必须补上我们实测的两条限定,这是这一页的诚实性所在) 限定一:已经带着 schedulerName: yunikorn 的 pod,卸载之后永远不会被调度 —— 没有调度器认领它们 —— 回退前必须让这些负载重建。 限定二:正在跑的 gang,它的 placeholder 在卸载时的确切命运,我们没有实测。 (这一条要如实说成「我们没测」,不要圆过去)所以回退演练必须专门验证这一项。

(最后那个红框,这是对客的标准表述,建议逐字念) 「新负载的回退是干净的 —— 摘掉注解,几秒生效;已在运行的负载需要重建。」

(说清为什么用这个口径)这个表述客户能接受,因为它给了明确的操作边界; 而如果你只说「可以随时回退」,回退当天有人发现一批 pod 永远 Pending,那才是真的信任崩塌。

到这里四章讲完了。最后给一页行动清单,然后我们开放提问。

Ch.4 · 怎么决策 · Call to Action

下周就能做的三件事 按「投入从低到高」排序 · 第一件今天就能做完

今天 · 30 分钟
0 成本

先算规模,再谈技术

  • 拉出当前 EC2 + EKS 月度支出
  • 对照盈亏平衡线:香港 ~40 台 / 美东 ~55 台
  • 不到线就先别做,把这页发给决策者
本周 · 1 天
仅本地

在 kind 上跑一遍

  • 17 秒装完,验证配额真的生效
  • 跑一次装不下的 gang,看 ApplicationRejected
  • 记住 pin kindest/node 版本
下周 · 3 工程师·周
需排期

非生产试点

  • 1 namespace + 1 leaf 队列 + binpacking
  • 先不开 gang、不开抢占
  • 把指标接进 Prometheus(记得关压缩)
动作负责人截止验收标准
算出当前规模与盈亏平衡线的差距平台负责人本周三一个数字:距离平衡点还差多少节点
本地 kind 跑通配额与 gang 两个实验SRE本周五能复述「配额撞上」与「gang 被拒」两种 event 原文
过一遍四个坑,确认自己不会踩SRE + 数据平台下周一输出一份「我们的配置里有没有这四个坑」的检查结果
决定做 / 不做,并写下理由平台负责人下周五不做也是一个合格的结论,但要有理由

如果只带走三句话

  • 它解决的问题是真的(资源死锁、配额不能排队),但它是一个 >100 节点规模才成立的决定。
  • 四个坑都是静默的:资源命名、放置规则、gang 参数名、1.9.0 的 metrics gzip。不报错不等于生效。
  • 在 AWS 上它有官方文档背书,但没有托管版本;与 Karpenter 的协同靠一个未成文的字符串——能用,但要知道它为什么能用。
Ch.4 · 怎么决策 — 行动清单73

⏱ 本页 2.0 分钟 · 主线 427 字 · 深潜层另有 795 字

到行动清单。这一页的关键不是上面那三张卡,是下面那张带负责人和截止日期的表。 (这句建议照念)没有名字和日期的行动清单,等于没有。 如果现场能确认人名,我建议当场填上,然后截图发到群里 —— 这是让这份材料真的产生结果的唯一方法。

上面三张卡按投入从低到高排。第一张,今天、30 分钟、零成本:先算规模,再谈技术。 做三件事:把当前的 EC2 加 EKS 月度支出拉出来;对照盈亏平衡线, 香港大约 40 台、美东大约 55 台;不到线就先别做, 然后把刚才那一页发给决策者。

(这三张卡的顺序是刻意的,值得说出来) 第一件事不是技术,是算规模。 因为如果规模不到线,后面两件事都不该做。这个顺序本身就是这份材料的态度。

第二张卡,本周、1 天、只用本地:在 kind 上跑一遍。 这件事我强烈建议真做,一天就够,而且收益很大 —— 你会亲眼看到配额撞上时的 event 原文,看到 gang 被拒时的 event 原文。

这两段文字以后排障的时候你会用到,而且没有第二个地方能拿到。 具体三步:17 秒装完;验证配额真的生效;跑一次装不下的 gang,看它报 ApplicationRejected。 (这一条一定要说)记住 pin 住 kindest/node 的版本 —— 否则 kind 会给你一个 YuniKorn 不支持的 Kubernetes 版本,而报错信息不会告诉你原因。

第三张卡,下周、3 个工程师·周、需要排期:非生产试点。 一个 namespace、一个 leaf 队列、把节点排序改成 binpacking。

(注意这两个「不开」)先不开 gang、先不开抢占。 这两个是「解决特定痛点」的能力,不是必选项,第一轮不要一起上。 然后把指标接进 Prometheus —— 记得关压缩, 因为 1.9.0 有那个双重 gzip 的问题,不关的话 Prometheus 会直接掉线。

下面这张表我念一遍,因为它是要落到人头上的。 算出当前规模与平衡线的差距,平台负责人,本周三, 验收标准是一个数字:距离平衡点还差多少节点。 本地 kind 跑通配额与 gang 两个实验,SRE,本周五, 验收标准是能复述那两种 event 的原文 —— 不是「跑过了」,是能复述。 过一遍四个坑,SRE 加数据平台,下周一, 输出一份「我们的配置里有没有这四个坑」的检查结果。

(最后一行要念出来,这是这一页的态度) 「决定做或者不做,并写下理由,平台负责人,下周五。 不做也是一个合格的结论 —— 但要有理由。」

下面那三句是如果只带走三句话。我快速念一遍: 第一,它解决的问题是真的 —— 资源死锁、配额不能排队 —— 但它是一个大于 100 节点规模才成立的决定。 第二,四个坑都是静默的:资源命名、放置规则、gang 参数名、1.9.0 的 metrics gzip。 不报错不等于生效。 第三,在 AWS 上它有官方文档背书,但没有托管版本; 与 Karpenter 的协同靠一个未成文的字符串 —— 能用,但你要知道它为什么能用。

(这个追问很常见,而且答案很实用) 可能被问:「我们规模够,但是没有专职的平台团队怎么办?」 我的建议是:先只做第一和第二阶段,也就是队列加配额,把 gang 和抢占往后放。 这两项能拿到成本收益的大部分 —— 池化 70% 加装箱 28% —— 而运维复杂度只有全量的一小部分。

下一页是附录,留给你们带走的。

Appendix · Reference

附录:坑清单速查 每条都有本场对应页码

#坑症状页
1mutating webhook 改写全集群所有工作负载的 schedulerName无法用 schedulerName 灰度;A/B 测出「两边一样」P8 · P72
2放置规则 tag+create:true 在前 ⇒ 造出无配额队列配额完全不生效,pod 全 RunningP19
3队列配置里写 cpu 而非 vcore配额不生效,不报错P18
4schedulingPolicyParameters 键写错 ⇒ 零日志静默忽略超时是 15 分钟而不是你设的值P26 · P45
5v1.9.0 /ws/v1/metrics 双重 gzipPrometheus target 掉线,无指标P31
6抢占走裸 DELETE ⇒ PDB 被绕过PDB 保护不了服务P44
7节点排序默认 fair(摊平)⇒ 云上多开节点实测 46/50 vs 30/50 个节点P67
8gang 队列必须 fifo;fair 报 unsupported sort type报错完全不提原因;properties 会从 root 继承P71
9默认 gangSchedulingStyle=Soft ⇒「半个 gang」应用 Running 但一半 pod Pending,监控看不出P26
10零 placeholder 落地 ⇒ 超时计时器从不启动应用无限期停在 AcceptedP21
11抢占 + Deployment ⇒ 永久 PendingReplicaSet 补的 pod 永远调度不上P29
12抢占方没有 event 记录;K8s event 会丢查不到「我抢了谁」;审计缺记录P30
13Fargate 与 YuniKorn 互斥Fargate pod 永久 Pending—
14placeholder 吃 VPC CNI 的 IP 与 max-pods瞬时需 2× pod 槽位;IP 耗尽表现为 gang 超时—
15kubectl delete cm yunikorn-configs ⇒ 瞬时重置为默认队列树消失,无确认—
完整版见配套《Apache YuniKorn 精通指南》(21 章 + 7 附录,6,400 行):28 条坑清单、25 条 REST 路由全表、Label/Annotation 全表,以及推翻或修正的 7 处流行说法(含 9 处我们自己的更正)。
Appendix — 坑清单速查74

⏱ 本页 1.7 分钟 · 主线 367 字 · 深潜层另有 465 字

这一页是留给各位带走的,所以我讲得很短。只需要说一句: 这 15 条里有 9 条是「不报错」的 —— 所以「跑通了」不等于「配对了」。

(不要逐条念,那会花掉 5 分钟而且没人记得住) 做法是:让大家拍照,然后说一句: 「回去用第 2 条那个巡检命令查一遍你们现在的集群,30 秒就能知道有没有被绕过。」

(如果时间允许,这个互动效果很好) 可以问一句:「这 15 条里,哪一条最让你意外?」 通常会得到很好的讨论 —— 多数人会选第 1 条, 也就是 schedulerName 被全集群改写; 或者第 6 条,抢占走裸 DELETE 所以绕过了 PDB。 (第 6 条对做 SRE 的人杀伤力最大,因为 PDB 是他们的主要防线)

(如果听众想要一个分组的概览,按这四组说,不要按编号) 这 15 条其实可以分成四组,理解了分组你就不用记编号。 第一组是「接管范围」的坑 —— 第 1 条 schedulerName 被全集群改写、 第 13 条 Fargate 与它互斥、第 14 条 placeholder 吃 VPC CNI 的 IP 和 max-pods。 这一组的共性是:你以为你只装了一个调度器,其实你改变了整个集群的准入路径。

第二组是「配置写了不生效」 —— 第 2 条放置规则短路造出无配额队列、 第 3 条把 cpu 写成了应该写 vcore 的地方、 第 4 条 schedulingPolicyParameters 的键写错被零日志忽略、 第 8 条 gang 队列必须 fifo。 (这一组是最该带走的)这四条全都不报错。所以「跑通了」不等于「配对了」。

第三组是「行为与直觉相反」 —— 第 6 条抢占走裸 DELETE 所以绕过 PDB、 第 7 条节点排序默认 fair 会在云上多开节点、 第 9 条默认 Soft 会造出「半个 gang」、 第 11 条抢占加 Deployment 会永久 Pending。 第四组是「观测与运维」 —— 第 5 条 1.9.0 的 metrics 双重 gzip、 第 10 条零 placeholder 落地则超时计时器从不启动、 第 12 条抢占方没有 event 记录、 第 15 条删掉 ConfigMap 会瞬时重置为默认,而且没有任何确认。

最后提一下配套的完整指南:它有 28 条坑清单和全部证据链, 包括我们自己在研究过程中写错并且更正的 9 处。 (这句值得说)那一节的存在本身就是可信度的一部分 —— 一份研究材料如果没有「我改过什么」这一节,你就无从判断它的其他部分有多可靠。

最后一页,开放提问。

Thank you!
Apache YuniKorn 技术深潜 · v1.9.0
Neo SUN
Solutions Architect Amazon Web Services
带走这三样:
· 配额体系完整性巡检命令(P19)
· 四个静默失效的坑(P74)
· 盈亏平衡线:香港 ~40 台(P69)
配套材料:
· 《精通指南》21 章 + 7 附录
· 可复现实验室(kind + KWOK)
· 2,500 行实测记录(含失败过程)

⏱ 本页 1.8 分钟 · 主线 387 字 · 深潜层另有 288 字

(结束页停留的时间会比你想的长,提问环节都在这一页上) 所以中间那个「带走这三样」很有用 —— 它给提问一个锚点, 不然听众会不知道从哪问起。

我先把这三样念一遍:配额体系完整性巡检命令,在第 19 页; 四个静默失效的坑,在第 74 页; 盈亏平衡线,香港大约 40 台,在第 69 页。

(下面是三个最可能被问到的问题及回答方向,提前准备好)

问题一:「我们规模不到 40 台怎么办?」 回答:先把 ResourceQuota 加 PriorityClass 用到极致 —— 多数团队其实还没把这两个用满。等规模上来再说。 如果你们的痛点明确是 gang,那可以只给最痛的那一类作业上,不要铺开 —— 投入会远小于那 21 周。

问题二:「Kueue 会不会取代它?」 回答:在配额层面有可能,在原子放置层面短期不会。 而且我想说清楚:这是一个三年的问题,不是明年的问题。 如果你现在有痛点,不要因为「可能有更好的东西」而不做。

问题三:「plugin 模式真的没了吗?」 回答:真没了。镜像仓库里 scheduler-plugin-* 这个 tag 止于 1.7.0,之后就没有了。原因第三章讲过:吞吐等于 kube-scheduler,比独立模式慢 16 倍。

(如果被问工作量,可以简单说,但别炫耀过程) 如果有人问「你们这份研究做了多少工作」—— 可以说:官方文档全部 91 页、五个仓库的源码、165 个并行 agent 的研究, 以及本地 kind 加 50 个 KWOK 假节点的实测,实测记录 2,500 行,包含两次失败的基准尝试。 但重点不是工作量,是结论可核实。

(收尾这一句我建议照念,它通常会得到很好的反馈,而且它是真的) 「如果这场分享让你决定不做这个项目,那它也是成功的。」

(留 8 到 10 分钟提问。如果没人提问,主动抛这个问题) 「你们现在的 Spark 作业,有没有遇到过 driver 互相等的情况?」 这个问题几乎总能引出讨论,因为遇到过的人会立刻有反应。