Kubernetes中的kube-scheduler组件怎么用

概述

Kubernetes是一个开源的容器编排平台，用于自动化部署、扩展和管理容器化应用程序。在Kubernetes集群中，kube-scheduler是一个核心组件，负责将新创建的Pod调度到集群中的合适节点上。本文将详细介绍kube-scheduler的工作原理、配置方法以及如何自定义调度策略。

1. kube-scheduler的作用

kube-scheduler的主要任务是根据Pod的资源需求、节点资源可用性、亲和性、反亲和性等条件，将Pod调度到最合适的节点上。具体来说，kube-scheduler的工作流程如下：

1. 监听Pod创建事件：kube-scheduler通过API Server监听新创建的Pod对象。
2. 过滤节点：根据Pod的资源需求（如CPU、内存等）和节点的资源可用性，过滤掉不满足条件的节点。
3. 评分节点：对剩余的节点进行评分，评分标准包括节点资源利用率、亲和性规则、反亲和性规则等。
4. 选择节点：选择评分最高的节点，并将Pod绑定到该节点上。
5. 更新Pod状态：将Pod的调度结果更新到API Server中。

2. kube-scheduler的配置

kube-scheduler的配置主要通过命令行参数和配置文件进行。以下是一些常用的配置选项：

2.1 命令行参数

• --kubeconfig：指定kubeconfig文件的路径，用于连接API Server。
• --leader-elect：启用领导者选举，确保在多个kube-scheduler实例中只有一个处于活动状态。
• --scheduler-name：指定调度器的名称，默认为default-scheduler。
• --policy-config-file：指定调度策略配置文件的路径。

2.2 配置文件

kube-scheduler的配置文件通常是一个YAML文件，用于定义调度策略和插件。以下是一个简单的配置文件示例：

apiVersion: kubescheduler.config.k8s.io/v1beta1
kind: KubeSchedulerConfiguration
profiles:
  - schedulerName: default-scheduler
    plugins:
      score:
        enabled:
          - name: NodeResourcesBalancedAllocation
          - name: ImageLocality
          - name: InterPodAffinity

在这个配置文件中，我们启用了NodeResourcesBalancedAllocation、ImageLocality和InterPodAffinity三个评分插件。

3. 自定义调度策略

Kubernetes允许用户通过编写自定义调度器或扩展kube-scheduler来实现自定义调度策略。以下是两种常见的方式：

3.1 编写自定义调度器

用户可以编写一个独立的调度器，通过API Server监听Pod创建事件，并根据自定义逻辑进行调度。以下是一个简单的自定义调度器示例：

package main

import (
    "context"
    "fmt"
    "log"
    "time"

    "k8s.io/client-go/kubernetes"
    "k8s.io/client-go/tools/clientcmd"
    "k8s.io/client-go/util/homedir"
    "k8s.io/apimachinery/pkg/fields"
    "k8s.io/apimachinery/pkg/util/wait"
    "k8s.io/client-go/tools/cache"
    "k8s.io/client-go/tools/leaderelection"
    "k8s.io/client-go/tools/leaderelection/resourcelock"
    "k8s.io/client-go/rest"
    "k8s.io/client-go/tools/record"
    "k8s.io/api/core/v1"
    metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)

func main() {
    kubeconfig := filepath.Join(homedir.HomeDir(), ".kube", "config")
    config, err := clientcmd.BuildConfigFromFlags("", kubeconfig)
    if err != nil {
        log.Fatalf("Error building kubeconfig: %s", err.Error())
    }

    clientset, err := kubernetes.NewForConfig(config)
    if err != nil {
        log.Fatalf("Error creating clientset: %s", err.Error())
    }

    // 创建领导者选举锁
    lock := &resourcelock.LeaseLock{
        LeaseMeta: metav1.ObjectMeta{
            Name:      "custom-scheduler",
            Namespace: "kube-system",
        },
        Client: clientset.CoordinationV1(),
        LockConfig: resourcelock.ResourceLockConfig{
            Identity:      "custom-scheduler",
            EventRecorder: &record.FakeRecorder{},
        },
    }

    // 启动领导者选举
    leaderelection.RunOrDie(context.TODO(), leaderelection.LeaderElectionConfig{
        Lock:            lock,
        ReleaseOnCancel: true,
        LeaseDuration:  15 * time.Second,
        RenewDeadline:   10 * time.Second,
        RetryPeriod:     2 * time.Second,
        Callbacks: leaderelection.LeaderCallbacks{
            OnStartedLeading: func(ctx context.Context) {
                // 领导者选举成功后启动调度器
                runScheduler(clientset)
            },
            OnStoppedLeading: func() {
                log.Fatalf("Leader election lost")
            },
        },
    })
}

func runScheduler(clientset *kubernetes.Clientset) {
    // 监听Pod创建事件
    watchlist := cache.NewListWatchFromClient(clientset.CoreV1().RESTClient(), "pods", v1.NamespaceAll, fields.Everything())
    _, controller := cache.NewInformer(
        watchlist,
        &v1.Pod{},
        time.Second*0,
        cache.ResourceEventHandlerFuncs{
            AddFunc: func(obj interface{}) {
                pod := obj.(*v1.Pod)
                if pod.Spec.SchedulerName == "custom-scheduler" {
                    schedulePod(clientset, pod)
                }
            },
        },
    )

    stop := make(chan struct{})
    defer close(stop)
    go controller.Run(stop)
    select {}
}

func schedulePod(clientset *kubernetes.Clientset, pod *v1.Pod) {
    nodes, err := clientset.CoreV1().Nodes().List(context.TODO(), metav1.ListOptions{})
    if err != nil {
        log.Printf("Error listing nodes: %s", err.Error())
        return
    }

    // 简单的调度逻辑：选择第一个节点
    if len(nodes.Items) > 0 {
        pod.Spec.NodeName = nodes.Items[0].Name
        _, err := clientset.CoreV1().Pods(pod.Namespace).Update(context.TODO(), pod, metav1.UpdateOptions{})
        if err != nil {
            log.Printf("Error updating pod: %s", err.Error())
        }
    }
}

3.2 扩展kube-scheduler

Kubernetes提供了调度框架（Scheduling Framework），允许用户通过编写插件来扩展kube-scheduler的功能。以下是一个简单的插件示例：

package main

import (
    "context"
    "k8s.io/kubernetes/pkg/scheduler/framework"
    "k8s.io/kubernetes/pkg/scheduler/framework/plugins/defaultbinder"
    "k8s.io/kubernetes/pkg/scheduler/framework/plugins/noderesources"
    "k8s.io/kubernetes/pkg/scheduler/framework/plugins/queuesort"
    "k8s.io/kubernetes/pkg/scheduler/framework/runtime"
    "k8s.io/kubernetes/pkg/scheduler/profile"
)

type CustomPlugin struct{}

func (p *CustomPlugin) Name() string {
    return "CustomPlugin"
}

func (p *CustomPlugin) Filter(ctx context.Context, state *framework.CycleState, pod *v1.Pod, nodeInfo *framework.NodeInfo) *framework.Status {
    // 自定义过滤逻辑
    return framework.NewStatus(framework.Success, "")
}

func (p *CustomPlugin) Score(ctx context.Context, state *framework.CycleState, pod *v1.Pod, nodeName string) (int64, *framework.Status) {
    // 自定义评分逻辑
    return 0, framework.NewStatus(framework.Success, "")
}

func main() {
    // 创建调度器配置
    cfg := &runtime.Config{
        FrameworkOutOfTreeRegistry: runtime.Registry{
            "CustomPlugin": func(_ runtime.Object, _ framework.Handle) (framework.Plugin, error) {
                return &CustomPlugin{}, nil
            },
        },
    }

    // 创建调度器
    scheduler := runtime.New(
        cfg,
        profile.NewRecorderFactory(),
        queuesort.New,
        noderesources.NewFit,
        defaultbinder.New,
    )

    // 启动调度器
    scheduler.Run(context.TODO())
}

4. 总结

kube-scheduler是Kubernetes集群中负责Pod调度的核心组件。通过合理的配置和自定义调度策略，用户可以优化Pod的调度过程，提高集群的资源利用率和应用程序的性能。本文介绍了kube-scheduler的工作原理、配置方法以及如何通过编写自定义调度器和扩展kube-scheduler来实现自定义调度策略。希望本文能帮助读者更好地理解和使用kube-scheduler。