【K8s源码品读】008:Phase 1 - kube-scheduler - 初探调度的启动流程与算法

简介: 理解kube-scheduler启动的流程

聚焦目标

理解kube-scheduler启动的流程

目录

  1. kube-scheduler的启动
  2. Scheduler的注册
  3. 了解一个最简单的算法NodeName

run

// kube-scheduler 类似于kube-apiserver,是个常驻进程,查看其对应的Run函数
func runCommand(cmd *cobra.Command, opts *options.Options, registryOptions ...Option) error {
   
    // 根据入参,返回配置cc与调度sched
   cc, sched, err := Setup(ctx, opts, registryOptions...)
    // 运行
   return Run(ctx, cc, sched)
}

// 运行调度策略
func Run(ctx context.Context, cc *schedulerserverconfig.CompletedConfig, sched *scheduler.Scheduler) error {
   
    // 将配置注册到configz中,会保存在一个全局map里
    if cz, err := configz.New("componentconfig"); err == nil {
   
        cz.Set(cc.ComponentConfig)
    } else {
   
        return fmt.Errorf("unable to register configz: %s", err)
    }

    // 事件广播管理器,涉及到k8s里的一个核心资源 - Event事件,暂时不细讲
    cc.EventBroadcaster.StartRecordingToSink(ctx.Done())

    // 健康监测的服务
    var checks []healthz.HealthChecker

    // 异步各个Informer。Informer是kube-scheduler的一个重点
    go cc.PodInformer.Informer().Run(ctx.Done())
    cc.InformerFactory.Start(ctx.Done())
    cc.InformerFactory.WaitForCacheSync(ctx.Done())

    // 选举Leader的工作,因为Master节点可以存在多个,选举一个作为Leader
    if cc.LeaderElection != nil {
   
        cc.LeaderElection.Callbacks = leaderelection.LeaderCallbacks{
   
      // 两个钩子函数,开启Leading时运行调度,结束时打印报错
            OnStartedLeading: sched.Run,
            OnStoppedLeading: func() {
   
                klog.Fatalf("leaderelection lost")
            },
        }
        leaderElector, err := leaderelection.NewLeaderElector(*cc.LeaderElection)
        if err != nil {
   
            return fmt.Errorf("couldn't create leader elector: %v", err)
        }
    // 参与选举的会持续通信
        leaderElector.Run(ctx)
        return fmt.Errorf("lost lease")
    }

    // 不参与选举的,也就是单节点的情况时,在这里运行
    sched.Run(ctx)
    return fmt.Errorf("finished without leader elect")
}

/*
到这里,我们已经接触了kube-scheduler的2个核心概念:
1. scheduler:正如程序名kube-scheduler,这个进程的核心作用是进行调度,会涉及到多种调度策略
2. Informer:k8s中有各种类型的资源,包括自定义的。而Informer的实现就将调度和资源结合了起来
*/

Scheduler

// 在创建scheduler的函数
func Setup() {
   
    // 创建scheduler,包括多个选项
    sched, err := scheduler.New(cc.Client,
        cc.InformerFactory,
        cc.PodInformer,
        recorderFactory,
        ctx.Done(),
        scheduler.WithProfiles(cc.ComponentConfig.Profiles...),
        scheduler.WithAlgorithmSource(cc.ComponentConfig.AlgorithmSource),
        scheduler.WithPercentageOfNodesToScore(cc.ComponentConfig.PercentageOfNodesToScore),
        scheduler.WithFrameworkOutOfTreeRegistry(outOfTreeRegistry),
        scheduler.WithPodMaxBackoffSeconds(cc.ComponentConfig.PodMaxBackoffSeconds),
        scheduler.WithPodInitialBackoffSeconds(cc.ComponentConfig.PodInitialBackoffSeconds),
        scheduler.WithExtenders(cc.ComponentConfig.Extenders...),
    )
    return &cc, sched, nil
}

// 我们再看一下New这个函数
func New() (*Scheduler, error) {
   
  // 先注册了所有的算法,保存到一个 map[string]PluginFactory 中
  registry := frameworkplugins.NewInTreeRegistry()

  // 重点看一下Scheduler的创建过程
  var sched *Scheduler
    source := options.schedulerAlgorithmSource
    switch {
   
   // 根据Provider创建,重点看这里
    case source.Provider != nil:
        sc, err := configurator.createFromProvider(*source.Provider)
        if err != nil {
   
            return nil, fmt.Errorf("couldn't create scheduler using provider %q: %v", *source.Provider, err)
        }
        sched = sc
  // 根据用户设置创建,来自文件或者ConfigMap
    case source.Policy != nil:
        policy := &schedulerapi.Policy{
   }
        switch {
   
        case source.Policy.File != nil:
            if err := initPolicyFromFile(source.Policy.File.Path, policy); err != nil {
   
                return nil, err
            }
        case source.Policy.ConfigMap != nil:
            if err := initPolicyFromConfigMap(client, source.Policy.ConfigMap, policy); err != nil {
   
                return nil, err
            }
        }
        configurator.extenders = policy.Extenders
        sc, err := configurator.createFromConfig(*policy)
        if err != nil {
   
            return nil, fmt.Errorf("couldn't create scheduler from policy: %v", err)
        }
        sched = sc
    default:
        return nil, fmt.Errorf("unsupported algorithm source: %v", source)
    }
}

// 创建
func (c *Configurator) createFromProvider(providerName string) (*Scheduler, error) {
   
    klog.V(2).Infof("Creating scheduler from algorithm provider '%v'", providerName)
  // 实例化算法的Registry
    r := algorithmprovider.NewRegistry()
    defaultPlugins, exist := r[providerName]
    if !exist {
   
        return nil, fmt.Errorf("algorithm provider %q is not registered", providerName)
    }

  // 将各种算法作为plugin进行设置
    for i := range c.profiles {
   
        prof := &c.profiles[i]
        plugins := &schedulerapi.Plugins{
   }
        plugins.Append(defaultPlugins)
        plugins.Apply(prof.Plugins)
        prof.Plugins = plugins
    }
    return c.create()
}

// 从这个初始化中可以看到,主要分为2类:默认与ClusterAutoscaler两种算法
func NewRegistry() Registry {
   
  // 默认算法包括过滤、打分、绑定等,有兴趣的去源码中逐个阅读
    defaultConfig := getDefaultConfig()
    applyFeatureGates(defaultConfig)
    // ClusterAutoscaler 是集群自动扩展的算法,被单独拎出来,
    caConfig := getClusterAutoscalerConfig()
    applyFeatureGates(caConfig)

    return Registry{
   
        schedulerapi.SchedulerDefaultProviderName: defaultConfig,
        ClusterAutoscalerProvider:                 caConfig,
    }
}
/*
在这里,熟悉k8s的朋友会有个疑问:以前听说kubernets的调度有个Predicate和Priority两个算法,这里怎么没有分类?
这个疑问,我们在后面具体场景时再进行分析。
*/

NodeName

// 为了加深大家对Plugin的印象,我选择一个最简单的示例:根据Pod的spec字段中的NodeName,分配到指定名称的节点
package nodename

import (
    "context"

    v1 "k8s.io/api/core/v1"
    "k8s.io/apimachinery/pkg/runtime"
    framework "k8s.io/kubernetes/pkg/scheduler/framework/v1alpha1"
)

type NodeName struct{
   }

var _ framework.FilterPlugin = &NodeName{
   }

// 这个调度算法的名称和错误信息
const (
    Name = "NodeName"
    ErrReason = "node(s) didn't match the requested hostname"
)

// 调度算法的明明
func (pl *NodeName) Name() string {
   
    return Name
}

// 过滤功能,这个就是NodeName算法的实现
func (pl *NodeName) Filter(ctx context.Context, _ *framework.CycleState, pod *v1.Pod, nodeInfo *framework.NodeInfo) *framework.Status {
   
  // 找不到Node
    if nodeInfo.Node() == nil {
   
        return framework.NewStatus(framework.Error, "node not found")
    }
  // 匹配不到,返回错误
    if !Fits(pod, nodeInfo) {
   
        return framework.NewStatus(framework.UnschedulableAndUnresolvable, ErrReason)
    }
    return nil
}

/*
  匹配的算法,两种条件满足一个就认为成功
  1. spec没有填NodeName 
  2.spec的NodeName和节点匹配
*/
func Fits(pod *v1.Pod, nodeInfo *framework.NodeInfo) bool {
   
    return len(pod.Spec.NodeName) == 0 || pod.Spec.NodeName == nodeInfo.Node().Name
}

// 初始化
func New(_ runtime.Object, _ framework.FrameworkHandle) (framework.Plugin, error) {
   
    return &NodeName{
   }, nil
}
相关实践学习
通过Ingress进行灰度发布
本场景您将运行一个简单的应用,部署一个新的应用用于新的发布,并通过Ingress能力实现灰度发布。
容器应用与集群管理
欢迎来到《容器应用与集群管理》课程,本课程是“云原生容器Clouder认证“系列中的第二阶段。课程将向您介绍与容器集群相关的概念和技术,这些概念和技术可以帮助您了解阿里云容器服务ACK/ACK Serverless的使用。同时,本课程也会向您介绍可以采取的工具、方法和可操作步骤,以帮助您了解如何基于容器服务ACK Serverless构建和管理企业级应用。 学习完本课程后,您将能够: 掌握容器集群、容器编排的基本概念 掌握Kubernetes的基础概念及核心思想 掌握阿里云容器服务ACK/ACK Serverless概念及使用方法 基于容器服务ACK Serverless搭建和管理企业级网站应用
目录
相关文章
|
4月前
|
存储 Kubernetes 监控
在K8S中,发布应用流程是什么?
在K8S中,发布应用流程是什么?
|
21天前
|
搜索推荐 算法 C语言
【排序算法】八大排序(上)(c语言实现)(附源码)
本文介绍了四种常见的排序算法:冒泡排序、选择排序、插入排序和希尔排序。通过具体的代码实现和测试数据,详细解释了每种算法的工作原理和性能特点。冒泡排序通过不断交换相邻元素来排序,选择排序通过选择最小元素进行交换,插入排序通过逐步插入元素到已排序部分,而希尔排序则是插入排序的改进版,通过预排序使数据更接近有序,从而提高效率。文章最后总结了这四种算法的空间和时间复杂度,以及它们的稳定性。
65 8
|
21天前
|
搜索推荐 算法 C语言
【排序算法】八大排序(下)(c语言实现)(附源码)
本文继续学习并实现了八大排序算法中的后四种:堆排序、快速排序、归并排序和计数排序。详细介绍了每种排序算法的原理、步骤和代码实现,并通过测试数据展示了它们的性能表现。堆排序利用堆的特性进行排序,快速排序通过递归和多种划分方法实现高效排序,归并排序通过分治法将问题分解后再合并,计数排序则通过统计每个元素的出现次数实现非比较排序。最后,文章还对比了这些排序算法在处理一百万个整形数据时的运行时间,帮助读者了解不同算法的优劣。
59 7
|
6月前
|
搜索推荐 算法 小程序
基于Java协同过滤算法的电影推荐系统设计和实现(源码+LW+调试文档+讲解等)
基于Java协同过滤算法的电影推荐系统设计和实现(源码+LW+调试文档+讲解等)
|
3月前
|
Kubernetes 算法 调度
Kubernetes的灵魂核心:kube-scheduler
本文介绍了Kubernetes中关键组件kube-scheduler的工作原理,详细解释了其通过预选和优选过程为Pod选择合适节点的机制,并提供了一个简化的Python示例来模拟这一过程,帮助读者更好地理解和管理Kubernetes集群。
|
2月前
|
存储 算法 安全
ArrayList简介及使用全方位手把手教学(带源码),用ArrayList实现洗牌算法,3个人轮流拿牌(带全部源码)
文章全面介绍了Java中ArrayList的使用方法,包括其构造方法、常见操作、遍历方式、扩容机制,并展示了如何使用ArrayList实现洗牌算法的实例。
19 0
|
4月前
|
JSON 算法 API
京东以图搜图功能API接口调用算法源码python
京东图搜接口是一款强大工具,通过上传图片即可搜索京东平台上的商品。适合电商平台、比价应用及需商品识别服务的场景。使用前需了解接口功能并注册开发者账号获取Key和Secret;准备好图片的Base64编码和AppKey;生成安全签名后,利用HTTP客户端发送POST请求至接口URL;最后解析JSON响应数据以获取商品信息。
|
4月前
|
数据采集 机器学习/深度学习 算法
【python】python客户信息审计风险决策树算法分类预测(源码+数据集+论文)【独一无二】
【python】python客户信息审计风险决策树算法分类预测(源码+数据集+论文)【独一无二】
|
4月前
|
Kubernetes Java 开发工具
Kubernetes部署项目流程(新手上线新版本服务整个流程)
【8月更文挑战第1天】Kubernetes(k8s)新手上线新版本服务整个流程
|
4月前
|
存储 Kubernetes API
在K8S中,陈述⼀下创建Pod的流程?
在K8S中,陈述⼀下创建Pod的流程?