Codes on Learning Notes

Scheduler Docs

Mon, 01 Jan 0001 00:00:00 +0000

Kubernetes 调度与驱逐（Scheduling & Eviction）文档总结 #

官方文档： kubernetes.io/docs/concepts/scheduling-eviction/

一、整体结构 #

该文档页面是 Kubernetes 调度、抢占与驱逐 三大主题的导航入口，涵盖以下子主题：

Scheduling（调度） #

序号	主题	说明	Note
1	Kubernetes Scheduler	默认调度器	✅
2	Assigning Pods to Nodes	手动指定节点
3	Pod Overhead	Pod 额外开销
4	Pod Topology Spread Constraints	Pod 拓扑分散约束
5	Taints and Tolerations	污点与容忍
6	Scheduling Framework	调度框架（插件化架构）	✅
7	Dynamic Resource Allocation	动态资源分配
8	Scheduler Performance Tuning	调度器性能调优
9	Resource Bin Packing	扩展资源装箱
10	Pod Scheduling Readiness	Pod 调度就绪
11	PodGroup Scheduling	PodGroup 调度
12	Gang Scheduling	Gang 调度
13	Topology-aware Scheduling	拓扑感知调度
14	Workload-Aware Preemption	工作负载感知抢占
15	Descheduler	反调度器
16	Node Declared Features	节点声明特性

Pod Disruption（Pod 中断） #

序号	主题	说明	Note
1	Pod Priority and Preemption	优先级与抢占	✅
2	Node-pressure Eviction	节点压力驱逐	✅
3	API-initiated Eviction	API 发起的驱逐	✅

二、调度核心：kube-scheduler #

工作原理 #

kube-scheduler 负责为未分配节点的 Pod 选择最佳节点，采用两步法：

Scheduler

Mon, 01 Jan 0001 00:00:00 +0000

Kubernetes Scheduler 代码结构 #

仓库地址： github.com/kubernetes/kubernetes

整体代码布局 #

kubernetes/
├── cmd/kube-scheduler/ # 入口：二进制启动命令
│ ├── scheduler.go # main() 入口
│ └── app/ # cobra 命令、选项解析、初始化
│
└── pkg/scheduler/ # 核心实现
 ├── scheduler.go # Scheduler 主结构体 + Run()
 ├── schedule_one.go # 单 Pod 调度完整流程
 ├── schedule_one_podgroup.go # PodGroup（批量调度）
 ├── eventhandlers.go # Informer 事件处理
 ├── extender.go # 外部扩展调度器
 │
 ├── framework/ # 调度框架（插件系统）
 │ ├── interface.go # 所有扩展点接口定义
 │ ├── types.go # 核心类型（NodeInfo、CycleState 等）
 │ ├── cycle_state.go # 调度周期状态传递
 │ ├── runtime/ # 框架运行时（插件注册/调用）
 │ ├── plugins/ # 内置插件实现
 │ └── preemption/ # 抢占逻辑
 │
 ├── apis/config/ # KubeSchedulerConfiguration API
 ├── profile/ # 多调度 Profile 支持
 ├── metrics/ # Prometheus 指标
 ├── backend/ # 调度队列后端
 ├── util/ # 工具函数
 └── testing/ # 测试工具

核心文件解析 #

1. `scheduler.go` — 主结构体与启动 #

type Scheduler struct {
 Cache internalcache.Cache // 节点/Pod 缓存
 Extenders []fwk.Extender // 外部调度扩展
 NextEntity func() (QueuedEntityInfo, error) // 从队列取 Pod
 SchedulePod func() (ScheduleResult, error) // 核心调度函数
 FailureHandler FailureHandlerFn // 失败处理
 SchedulingQueue internalqueue.SchedulingQueue // 调度队列
 Profiles profile.Map // 多 Profile
 StopEverything <-chan struct{} // 停止信号
}

func (sched *Scheduler) Run(ctx context.Context) {
 sched.SchedulingQueue.Run(logger) // 启动调度队列
 go wait.UntilWithContext(ctx, sched.scheduleOne, 0) // 无限循环调度
}

核心逻辑：Run() 启动后不断调用 scheduleOne() 从队列取 Pod 并调度。

Scheduler-score

Mon, 01 Jan 0001 00:00:00 +0000

Kubernetes Scheduler Score 打分机制深度解析 #

1. Score 在调度流程中的位置 #

Filter（过滤不可用节点）
 ↓
Score（对可用节点打分） ← 我们在这里
 ↓
Select（选择最高分节点）

Score 阶段的输入是经过 Filter 后所有可用的节点列表，输出是每个节点的加权总分。

2. 核心数据结构 #

2.1 分数相关常量 #

const (
 MinNodeScore int64 = 0 // 最低分
 MaxNodeScore int64 = 100 // 最高分（单个插件）
)

2.2 打分结果结构 #

// 单个插件对某个节点的打分
type NodeScore struct {
 Name string // 节点名
 Score int64 // 分数
}

// 单个插件的打分结果
type PluginScore struct {
 Name string // 插件名
 Score int64 // 加权后的分数
}

// 某个节点的所有打分结果
type NodePluginScores struct {
 Name string // 节点名
 Scores []PluginScore // 各插件打分明细
 TotalScore int64 // 加权总分
}

3. ScorePlugin 接口定义 #

// ScorePlugin 是打分插件的接口
type ScorePlugin interface {
 Plugin
 // Score 对单个节点打分
 Score(ctx context.Context, state CycleState, pod *v1.Pod, nodeInfo NodeInfo) (int64, *Status)
 // ScoreExtensions 返回分数归一化扩展（可选）
 ScoreExtensions() ScoreExtensions
}

// ScoreExtensions 是分数归一化扩展接口
type ScoreExtensions interface {
 // NormalizeScore 在所有节点打分完成后进行归一化
 NormalizeScore(ctx context.Context, state CycleState, pod *v1.Pod, scores NodeScoreList) *Status
}

4. Score 执行流程（核心代码） #

4.1 入口函数 `prioritizeNodes()` #

// schedule_one.go
func prioritizeNodes(
 ctx context.Context,
 extenders []fwk.Extender,
 schedFramework framework.Framework,
 state fwk.CycleState,
 pod *v1.Pod,
 nodes []fwk.NodeInfo,
) ([]fwk.NodePluginScores, error) {

 // 1. 没有任何打分插件时，所有节点默认得 1 分
 if len(extenders) == 0 && !schedFramework.HasScorePlugins() {
 result := make([]fwk.NodePluginScores, 0, len(nodes))
 for i := range nodes {
 result = append(result, fwk.NodePluginScores{
 Name: nodes[i].Node().Name,
 TotalScore: 1,
 })
 }
 return result, nil
 }

 // 2. 执行 PreScore 插件（预处理）
 preScoreStatus := schedFramework.RunPreScorePlugins(ctx, state, pod, nodes)

 // 3. 执行 Score 插件（并行打分）
 nodesScores, scoreStatus := schedFramework.RunScorePlugins(ctx, state, pod, nodes)

 // 4. 执行 Extender 打分（外部调度器）
 if len(extenders) != 0 {
 // 并行调用所有 Extender 的 Prioritize 方法
 // ...
 }

 return nodesScores, nil
}

4.2 `RunScorePlugins()` 详细实现 #

// runtime/framework.go
func (f *frameworkImpl) RunScorePlugins(ctx context.Context, state fwk.CycleState, pod *v1.Pod, nodes []fwk.NodeInfo) ([]fwk.NodePluginScores, *fwk.Status) {

 // 初始化结果结构
 allNodePluginScores := make([]fwk.NodePluginScores, len(nodes))
 plugins := make([]fwk.ScorePlugin, 0, numPlugins)
 pluginToNodeScores := make(map[string]fwk.NodeScoreList, numPlugins)

 // ============ 第一阶段：并行 Score ============
 // 对每个节点并行执行所有插件的 Score() 方法
 f.Parallelizer().Until(ctx, len(nodes), func(index int) {
 nodeInfo := nodes[index]
 for _, pl := range plugins {
 // 调用插件的 Score 方法
 s, status := f.runScorePlugin(ctx, pl, state, pod, nodeInfo)

 // 记录该插件对该节点的打分
 pluginToNodeScores[pl.Name()][index] = fwk.NodeScore{
 Name: nodeInfo.Node().Name,
 Score: s, // 原始分数
 }
 }
 }, metrics.Score)

 // ============ 第二阶段：并行 NormalizeScore ============
 // 对每个插件并行执行 NormalizeScore()（如果实现了 ScoreExtensions）
 f.Parallelizer().Until(ctx, len(plugins), func(index int) {
 pl := plugins[index]
 if pl.ScoreExtensions() == nil {
 return // 该插件没有实现归一化
 }
 nodeScoreList := pluginToNodeScores[pl.Name()]
 // 调用归一化方法，将分数调整到 [0, MaxNodeScore] 范围
 status := pl.ScoreExtensions().NormalizeScore(ctx, state, pod, nodeScoreList)
 }, metrics.Score)

 // ============ 第三阶段：并行加权计算 ============
 // 对每个节点并行计算加权总分
 f.Parallelizer().Until(ctx, len(nodes), func(index int) {
 nodePluginScores := fwk.NodePluginScores{
 Name: nodes[index].Node().Name,
 Scores: make([]fwk.PluginScore, len(plugins)),
 }

 for i, pl := range plugins {
 weight := f.scorePluginWeight[pl.Name()] // 从配置读取权重
 score := pluginToNodeScores[pl.Name()][index].Score

 // 验证分数范围
 if score > fwk.MaxNodeScore || score < fwk.MinNodeScore {
 // 错误：分数超出范围
 }

 // 加权分数 = 原始分数 × 权重
 weightedScore := score * int64(weight)

 nodePluginScores.Scores[i] = fwk.PluginScore{
 Name: pl.Name(),
 Score: weightedScore,
 }
 nodePluginScores.TotalScore += weightedScore // 累加总分
 }

 allNodePluginScores[index] = nodePluginScores
 }, metrics.Score)

 return allNodePluginScores, nil
}

5. 内置打分插件示例 #

5.1 插件列表 #

插件	策略	说明
`NodeResourcesFit`	LeastAllocated / MostAllocated / BalancedAllocation	资源打分
`InterPodAffinity`	-	Pod 间亲和性打分
`PodTopologySpread`	-	拓扑分散约束打分
`NodeAffinity`	-	节点亲和性打分
`TaintToleration`	-	污点容忍打分

5.2 `LeastAllocated` 打分实现 #

// pkg/scheduler/framework/plugins/noderesources/least_allocated.go

// 核心打分函数：偏好资源使用率低的节点
func leastResourceScorer(resources []config.ResourceSpec) func([]int64, []int64, []int64) int64 {
 return func(requested, _, allocable []int64) int64 {
 var nodeScore, weightSum int64
 for i := range requested {
 if allocable[i] == 0 {
 continue
 }
 weight := resources[i].Weight
 resourceScore := leastRequestedScore(requested[i], allocable[i])
 nodeScore += resourceScore * weight
 weightSum += weight
 }
 return nodeScore / weightSum
 }
}

// 单个资源打分公式
func leastRequestedScore(requested, capacity int64) int64 {
 if capacity == 0 {
 return 0
 }
 if requested > capacity {
 return 0
 }
 // 公式：(capacity - requested) * MaxNodeScore / capacity
 // 空闲资源越多，分数越高
 return ((capacity - requested) * fwk.MaxNodeScore) / capacity
}

打分示例：

Descheduler

Mon, 01 Jan 0001 00:00:00 +0000

Descheduler for Kubernetes — README 总结 #

仓库地址： github.com/kubernetes-sigs/descheduler

一、什么是 Descheduler？ #

Descheduler 是 Kubernetes 的反调度器，用于解决 kube-scheduler 无法处理的问题：当集群状态随时间变化后，已经运行的 Pod 可能不再处于最优节点上。Descheduler 根据策略找到并驱逐这些 Pod，让它们被重新调度到更合适的节点。

为什么需要 Descheduler？ #

场景	说明
节点负载不均	部分节点过载或空闲
调度条件变化	节点的 taint/label 变化，亲和性不再满足
节点故障恢复	故障节点的 Pod 迁移到其他节点后造成聚集
新增节点	新节点加入集群后需要重新平衡

注意：Descheduler 只负责驱逐 Pod，不负责调度。被驱逐的 Pod 由 kube-scheduler 重新调度。

二、部署方式 #

Descheduler 可以以 Job / CronJob / Deployment 三种方式运行在集群中（kube-system 命名空间，作为 Critical Pod 避免被驱逐）：

方式	说明
Job	执行一次后退出
CronJob	定时周期性执行
Deployment	常驻运行，支持 HA（Leader Election）

安装方式支持：kubectl apply / Helm Chart（v0.18+）/ Kustomize

Codes on Learning Notes

Scheduler Docs

Kubernetes 调度与驱逐（Scheduling & Eviction）文档总结 #

一、整体结构 #

Scheduling（调度） #

Pod Disruption（Pod 中断） #

二、调度核心：kube-scheduler #

工作原理 #

Scheduler

Kubernetes Scheduler 代码结构 #

整体代码布局 #

核心文件解析 #

1. scheduler.go — 主结构体与启动 #

Scheduler-score

Kubernetes Scheduler Score 打分机制深度解析 #

1. Score 在调度流程中的位置 #

2. 核心数据结构 #

2.1 分数相关常量 #

2.2 打分结果结构 #

3. ScorePlugin 接口定义 #

4. Score 执行流程（核心代码） #

4.1 入口函数 prioritizeNodes() #

4.2 RunScorePlugins() 详细实现 #

5. 内置打分插件示例 #

5.1 插件列表 #

5.2 LeastAllocated 打分实现 #

Descheduler

Descheduler for Kubernetes — README 总结 #

一、什么是 Descheduler？ #

为什么需要 Descheduler？ #

二、部署方式 #

1. `scheduler.go` — 主结构体与启动 #

4.1 入口函数 `prioritizeNodes()` #

4.2 `RunScorePlugins()` 详细实现 #

5.2 `LeastAllocated` 打分实现 #