[源码分析-kubernetes]3. 调度器框架

互联网 2021/10/5 20:40:58

调度器框架 写在前面 今天我们从pkg/scheduler/scheduler.go出发,分析Scheduler的整体框架。前面讲Scheduler设计的时候有提到过源码的3层结构,pkg/scheduler/scheduler.go也就是中间这一层,负责Scheduler除了具体node过滤算法外的工作逻辑~ 调度器启动运行 从goland的…

调度器框架

写在前面

今天我们从pkg/scheduler/scheduler.go出发,分析Scheduler的整体框架。前面讲Scheduler设计的时候有提到过源码的3层结构,pkg/scheduler/scheduler.go也就是中间这一层,负责Scheduler除了具体node过滤算法外的工作逻辑~

调度器启动运行

从goland的Structure中可以看到这个源文件(pkg/scheduler/scheduler.go)主要有这些对象:

1551161117264

大概浏览一下可以很快找到我们的第一个关注点应该是Scheduler这个struct和Scheduler的Run()方法:

!FILENAME pkg/scheduler/scheduler.go:58

// Scheduler watches for new unscheduled pods. It attempts to find
// nodes that they fit on and writes bindings back to the api server.
type Scheduler struct {
	config *factory.Config
}

这个struct在上一讲有跟到过,代码注释说的是:

Scheduler watch新创建的未被调度的pods,然后尝试寻找合适的node,回写一个绑定关系到api server.

!FILENAME pkg/scheduler/scheduler.go:276

// Run begins watching and scheduling. It waits for cache to be synced, then starts a goroutine and returns immediately.
func (sched *Scheduler) Run() {
	if !sched.config.WaitForCacheSync() {
		return
	}
	go wait.Until(sched.scheduleOne, 0, sched.config.StopEverything)
}

注释说这个函数开始watching and scheduling,也就是调度器主要逻辑了!注释后半段说到Run()方法起了一个goroutine后马上返回了,这个怎么理解呢?我们先看一下调用Run的地方:

!FILENAME cmd/kube-scheduler/app/server.go:240

	// Prepare a reusable runCommand function.
	run := func(ctx context.Context) {
		sched.Run()
		<-ctx.Done()
	}

可以发现调用了sched.Run()之后就在等待ctx.Done()了,所以Run中启动的goroutine自己不退出就ok.

wait.Until这个函数做的事情是:每隔n时间调用f一次,除非channel c被关闭。这里的n就是0,也就是一直调用,前一次调用返回下一次调用就开始了。这里的f当然就是sched.scheduleOne,c就是sched.config.StopEverything.

一个pod的调度流程

于是我们的关注点就转到了sched.scheduleOne这个方法上,看一下:

scheduleOne does the entire scheduling workflow for a single pod. It is serialized on the scheduling algorithm's host fitting.

注释里说scheduleOne实现1个pod的完整调度工作流,这个过程是顺序执行的,也就是非并发的。结合前面的wait.Until逻辑,也就是说前一个pod的scheduleOne一完成,一个return,下一个pod的scheduleOne立马接着执行!

这里的串行逻辑也好理解,如果是同时调度N个pod,计算的时候觉得一个node很空闲,实际调度过去启动的时候发现别人的一群pod先起来了,端口啊,内存啊,全给你抢走了!所以这里的调度算法执行过程用串行逻辑很好理解。注意哦,调度过程跑完不是说要等pod起来,最后一步是写一个binding到apiserver,所以不会太慢。下面我们看一下scheduleOne的主要逻辑:

!FILENAME pkg/scheduler/scheduler.go:513

func (sched *Scheduler) scheduleOne() {
	pod := sched.config.NextPod()
	suggestedHost, err := sched.schedule(pod)
    if err != nil {
		if fitError, ok := err.(*core.FitError); ok {
			preemptionStartTime := time.Now()
			sched.preempt(pod, fitError)
		}
		return
	}
	assumedPod := pod.DeepCopy()
	allBound, err := sched.assumeVolumes(assumedPod, suggestedHost)
	err = sched.assume(assumedPod, suggestedHost)
	go func() {
		err := sched.bind(assumedPod, &v1.Binding{
			ObjectMeta: metav1.ObjectMeta{Namespace: assumedPod.Namespace, Name: assumedPod.Name, UID: assumedPod.UID},
			Target: v1.ObjectReference{
				Kind: "Node",
				Name: suggestedHost,
			},
		})
	}()
}

上面几行代码只保留了主干,对于我们理解scheduleOne的过程足够了,这里来个流程图吧:

1551419004854

不考虑scheduleOne的所有细节和各种异常情况,基本是上图的流程了,主流程的核心步骤当然是suggestedHost, err := sched.schedule(pod)这一行,这里完成了不需要抢占的场景下node的计算,我们耳熟能详的预选过程,优选过程等就是在这里面。

潜入第三层前的一点逻辑

ok,这时候重点就转移到了suggestedHost, err := sched.schedule(pod)这个过程,强调一下这个过程是“同步”执行的。

!FILENAME pkg/scheduler/scheduler.go:290

// schedule implements the scheduling algorithm and returns the suggested host.
func (sched *Scheduler) schedule(pod *v1.Pod) (string, error) {
	host, err := sched.config.Algorithm.Schedule(pod, sched.config.NodeLister)
	if err != nil {
		pod = pod.DeepCopy()
		sched.config.Error(pod, err)
		sched.config.Recorder.Eventf(pod, v1.EventTypeWarning, "FailedScheduling", "%v", err)
		sched.config.PodConditionUpdater.Update(pod, &v1.PodCondition{
			Type:          v1.PodScheduled,
			Status:        v1.ConditionFalse,
			LastProbeTime: metav1.Now(),
			Reason:        v1.PodReasonUnschedulable,
			Message:       err.Error(),
		})
		return "", err
	}
	return host, err
}

schedule方法很简短,我们关注一下第一行,调用sched.config.Algorithm.Schedule()方法,入参是pod和nodes,返回一个host,继续看一下这个Schedule方法:

!FILENAME pkg/scheduler/algorithm/scheduler_interface.go:78

type ScheduleAlgorithm interface {
	Schedule(*v1.Pod, NodeLister) (selectedMachine string, err error)
	Preempt(*v1.Pod, NodeLister, error) (selectedNode *v1.Node, preemptedPods []*v1.Pod, cleanupNominatedPods []*v1.Pod, err error)
	Predicates() map[string]FitPredicate
	Prioritizers() []PriorityConfig
}

发现是个接口,这个接口有4个方法,实现ScheduleAlgorithm接口的对象意味着知道如何调度pods到nodes上。默认的实现是pkg/scheduler/core/generic_scheduler.go:98 genericScheduler这个struct.我们先继续看一下ScheduleAlgorithm接口定义的4个方法:

  • Schedule() //给定pod和nodes,计算出一个适合跑pod的node并返回;
  • Preempt() //抢占
  • Predicates() //预选
  • Prioritizers() //优选

前面流程里讲到的sched.config.Algorithm.Schedule()也就是genericScheduler.Schedule()方法了,这个方法位于:pkg/scheduler/core/generic_scheduler.go:139一句话概括这个方法就是:尝试将指定的pod调度到给定的node列表中的一个,如果成功就返回这个node的名字。最后看一眼签名:

func (g *genericScheduler) Schedule(pod *v1.Pod, nodeLister algorithm.NodeLister) (string, error)

从如参和返回值其实可以猜到很多东西,行,今天就到这里,具体的逻辑下回我们再分析~

随时随地学软件编程-关注百度小程序和微信小程序
关于找一找教程网

本站文章仅代表作者观点,不代表本站立场,所有文章非营利性免费分享。
本站提供了软件编程、网站开发技术、服务器运维、人工智能等等IT技术文章,希望广大程序员努力学习,让我们用科技改变世界。
[[源码分析-kubernetes]3. 调度器框架]http://www.zyiz.net/tech/detail-238144.html

上一篇:[源码分析-kubernetes]1.调度器设计

下一篇:Kubernetes-官网最小系统-Minikube

赞(0)
关注微信小程序
程序员编程王-随时随地学编程

扫描二维码或查找【程序员编程王】

可以随时随地学编程啦!

技术文章导航 更多>
扫一扫关注最新编程教程