Kubernetes 集群中调度器的使用及自定义调度规则-JavaScript中文网-JavaScript教程资源分享门户

什么是 Kubernetes 调度器

Kubernetes 调度器是集群中负责将容器调度到节点上的组件。它会根据节点的可用资源和容器的资源需求来计算最优的调度方案。在 Kubernetes 中，调度器也是一个控制器，它会监控集群中未调度的 Pod，并负责将它们调度到合适的节点上。

Kubernetes 调度器的默认规则

Kubernetes 调度器的默认规则主要包括以下几个方面：

Pod 与节点的匹配：根据 Pod 的资源需求和节点的可用资源进行匹配，选择最优的节点；
Pod 与容器的调度：根据 Pod 中每个容器的资源需求和节点的资源情况，将容器调度到合适的节点上；
高可用性：确保每个 Pod 在至少一个节点上持续运行。

使用 Kubernetes 调度器

在 Kubernetes 集群中，默认情况下已经有一个调度器在运行。

通过 kubectl 命令可以查看调度器的状态：

$ kubectl get componentstatuses

如果想要在创建 Pod 时禁用调度器的默认规则，可以通过在 Pod 定义中增加 nodeName 字段来实现：

// javascriptcn.com 代码示例
apiVersion: v1
kind: Pod
metadata:
  name: my-pod
spec:
  nodeName: my-node
  containers:
  - name: my-container
    image: my-image
    resources:
      limits:
        cpu: "1"
        memory: "512Mi"

这个 Pod 只会调度到名为 my-node 的节点上。

自定义 Kubernetes 调度规则

除了默认的调度规则之外，我们还可以通过增加调度器扩展程序来实现自定义的调度规则。

Kubernetes 调度器的扩展程序是一个独立的二进制文件，它可以将自定义的调度规则注入到 Kubernetes 调度器中。这些规则可以基于节点上的标签、Pod 的标签和其他一些自定义的策略。

以下是一个简单的示例，演示如何自定义调度规则。

首先，我们需要编写一个调度器扩展程序。在这个示例中，我们创建了一个以节点为单位的调度器扩展程序，它将根据节点的 CPU 利用率来决定是否将 Pod 调度到该节点上。

// javascriptcn.com 代码示例
package main

import (
    "context"
    "fmt"
    "os"
    "time"

    v1 "k8s.io/api/core/v1"
    "k8s.io/apimachinery/pkg/api/resource"
    "k8s.io/apimachinery/pkg/labels"
    "k8s.io/apimachinery/pkg/runtime"
    "k8s.io/apimachinery/pkg/types"
    "k8s.io/client-go/kubernetes"
    "k8s.io/client-go/rest"
    "k8s.io/client-go/tools/cache"
    "k8s.io/client-go/util/retry"
    framework "k8s.io/kubernetes/pkg/scheduler/framework/v1alpha1"
)

type MyScheduler struct {
    framework.FrameworkHandle
}

func (s *MyScheduler) Filter(ctx context.Context, state *framework.CycleState, pod *v1.Pod, nodeInfo *framework.NodeInfo) *framework.Status {
    nodeMetrics := nodeInfo.Node().Status.Capacity.Memory()
    podMetrics := pod.Spec.Containers[0].Resources.Limits.Memory()

    fmt.Printf("nodeMetrics: %v, podMetrics: %v\n", nodeMetrics, podMetrics)

    // 如果节点的剩余资源小于 Pod 所需资源，则拒绝这个节点。
    if nodeMetrics.Cmp(podMetrics) == -1 {
        return framework.NewStatus(framework.Unschedulable, "insufficient memory resources")
    }

    return framework.NewStatus(framework.Success, "")
}

func main() {
    // 创建一个 kubernetes 客户端来操作集群。
    config, err := rest.InClusterConfig()
    if err != nil {
        panic(err.Error())
    }
    clientset, err := kubernetes.NewForConfig(config)
    if err != nil {
        panic(err.Error())
    }

    // 创建一个 MyScheduler 实例，并编写调度器扩展程序。
    myScheduler := MyScheduler{}

    // 创建一个调度器缓存。
    cache := cache.NewCache(func(obj interface{}) (key string, err error) {
        pod := obj.(*v1.Pod)
        return pod.ObjectMeta.Name, nil
    })
    myScheduler.Cache = cache

    // 将 MyScheduler 实例添加到调度器扩展程序中。
    framework.Register("my-scheduler", func(handle framework.FrameworkHandle) (framework.Plugin, error) {
        myScheduler.FrameworkHandle = handle
        return &myScheduler, nil
    })

    // 运行调度器扩展程序。
    stopCh := make(chan struct{})
    defer close(stopCh)
    go framework.RunFramework(stopCh, clientset)

    // 创建一个 Pod。
    pod := v1.Pod{
        ObjectMeta: v1.ObjectMeta{
            Name:      "my-pod",
            Namespace: "default",
            Labels:    map[string]string{"app": "my-app"},
        },
        Spec: v1.PodSpec{
            Containers: []v1.Container{
                {
                    Name: "my-container",
                    Image: "my-image",
                    Resources: v1.ResourceRequirements{
                        Limits: v1.ResourceList{
                            v1.ResourceName(v1.ResourceMemory): resource.MustParse("300Mi"),
                            v1.ResourceName(v1.ResourceCPU):    resource.MustParse("1"),
                        },
                        Requests: v1.ResourceList{
                            v1.ResourceName(v1.ResourceMemory): resource.MustParse("200Mi"),
                            v1.ResourceName(v1.ResourceCPU):    resource.MustParse("0.5"),
                        },
                    },
                },
            },
        },
    }

    // 将 Pod 丢给 Kubernetes，让其调度。
    _, err = clientset.CoreV1().Pods("default").Create(&pod)
    if err != nil {
        panic(err.Error())
    }

    // 等待调度结果。
    err = retry.RetryOnConflict(retry.DefaultRetry, func() error {
        p, err := clientset.CoreV1().Pods("default").Get("my-pod", v1.GetOptions{})
        if err != nil {
            return err
        }

        if p.Spec.NodeName != "" {
            fmt.Printf("pod %s scheduled to node %s\n", p.ObjectMeta.Name, p.Spec.NodeName)
            return nil
        }

        fmt.Println("waiting for pod to be scheduled...")
        time.Sleep(1 * time.Second)

        return fmt.Errorf("pod not scheduled yet")
    })

    if err != nil {
        panic(err.Error())
    }

    os.Exit(0)
}

编译并运行这个程序：

$ go build -o my-scheduler
$ ./my-scheduler

现在，我们已经创建了一个自定义调度器规则。

总结

Kubernetes 调度器是集群中非常重要的一个组件，我们可以通过内置的调度规则为 Pod 分配最优的节点。同时，我们也可以通过自定义调度器扩展程序，进一步定制化集群的调度规则，并将 Pod 调度到特定的节点上。

来源：JavaScript中文网，转载请注明来源本文地址：https://www.javascriptcn.com/post/6527c54a7d4982a6eba5c300