Kubernetes(七)：集群调度

╰半橙微兮° 2022-11-27 06:28 206阅读 0赞

### 文章目录 ###

*  一、集群调度
 *   *  1.1 调度器简介
     *  1.2 调度过程
     *  1.3 自定义调度器
 *  二、调度选择
 *   *  2.1 Node 亲和性
     *  2.2 Pod 亲和性
     *  2.3 Taint 和 Toleration
     *   *  2.3.1 Taint
         *  2.3.2 Tolerations
     *  2.4 指定调度节点

# 一、集群调度 #

## 1.1 调度器简介 ##

`Scheduler`是`Kubernetes`的调度器，主要的任务是把定义的`pod`分配到集群的节点上，需要考虑以下问题：

*  公平：如何保证每个节点都能被分配资源
 *  资源高效利用：集群所有资源最大化被使用
 *  效率：调度的性能要好，能够尽快地对大批量的`pod`完成调度工作
 *  灵活：允许用户根据自己的需求控制调度的逻辑

`Scheduler`是作为单独的程序运行的，启动之后会一直连接`apiserver`获取`PodSpec.NodeName`为空的`pod`，对每个`pod`都会创建一个`binding`，表明该`pod`应该放到哪个节点上。

## 1.2 调度过程 ##

调度分为几个部分：

1.  先是过滤掉不满足条件的节点，这个过程称为`predicate`（预选）
2.  然后对通过的节点按照优先级排序，这个是`priority`（优选）
3.  最后从中选择优先级最高的节点

`Predicate`有一系列的算法可以使用：

*  `PodFitsResources`：节点上剩余的资源是否大于`pod`请求的资源
 *  `PodFitsHost`：如果`pod`指定了`NodeName`，检查节点名称是否和`NodeName`匹配
 *  `PodFitsHostPorts`：节点上已经使用的`port`是否和`pod`申请的`port`冲突
 *  `PodSelectorMatches`：过滤掉和`pod`指定的`label`不匹配的节点
 *  `NoDiskConflict`：已经`mount`的`volume`和`pod`指定的`volume`不冲突，除非它们都是只读

如果在`predicate`过程中没有合适的节点，`pod`会一直在`pending`状态（等待），不断重试调度，直到有节点满足条件。

经过这个步骤，如果有多个节点满足条件，就继续`priorities`过程：按照优先级大小对节点排序。优先级由一系列键值对组成，键是该优先级项的名称，值是它的权重，这些优先级选项包括：

*  `LeastRequestedPriority`：通过计算`CPU`和`Memory`的使用率来决定权重，使用率越低权重越高。换句话说，这个优先级指标倾向于资源使用比例更低的节点
 *  `BalancedResourceAllocation`：节点上`CPU`和`Memory`使用率越接近，权重越高。这个应该和上面的一起使用，不应该单独使用
 *  `ImageLocalityPriority`：倾向于已经有要使用镜像的节点，镜像总大小值越大，权重越高

通过算法对所有的优先级项目和权重进行计算，得出最终的结果。

## 1.3 自定义调度器 ##

除了`K8S`自带的调度器，可以自定义调度器。通过`spec:schedulername`参数指定调度器的名字，可以为`pod`选择某个调度器进行调度。比如下面的`pod`选择`my-scheduler`进行调度，而不是默认的`default-scheduler`：

apiVersion: v1
    kind: Pod
    metadata:
      name: annotation-second-scheduler
      labels:
        name: multischeduler-example
    spec:
      schedulername: my-scheduler
      containers:
     - name: pod-with-second-annotation-container
        image: gcr.io/google_containers/pause:2.0

# 二、调度选择 #

## 2.1 Node 亲和性 ##

`spec.affinity.nodeAffinity`：

*  `preferredDuringSchedulingIgnoredDuringExecution`（优先执行计划）：软策略
 *  `requiredDuringSchedulingIgnoredDuringExecution`（要求执行计划）：硬策略

**键值运算关系：**

<table> 
 <thead> 
  <tr> 
   <th>键</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>In</td> 
   <td>label 的值在某个列表中</td> 
  </tr> 
  <tr> 
   <td>NotIn</td> 
   <td>label 的值不在某个列表中</td> 
  </tr> 
  <tr> 
   <td>Gt</td> 
   <td>label 的值大于某个值</td> 
  </tr> 
  <tr> 
   <td>Lt</td> 
   <td>label 的值小于某个值</td> 
  </tr> 
  <tr> 
   <td>Exists</td> 
   <td>某个 label 存在</td> 
  </tr> 
  <tr> 
   <td>DoesNotExist</td> 
   <td>某个 label 不存在</td> 
  </tr> 
 </tbody> 
</table>

**软策略:**

[root@master schedule]# cat node-preferred-pod.yaml 
    apiVersion: v1
    kind: Pod
    metadata:
      name: affinity
      labels:
        app: node-affinity-pod
    spec:
      containers:
      - name: with-node-affinity
        image: hub.hc.com/library/myapp:v1
      affinity:
        nodeAffinity:
          preferredDuringSchedulingIgnoredDuringExecution:
          - weight: 1
            preference: 
              matchExpressions:
              - key: kubernetes.io/hostname
                operator: In
                values:
                - worker3
    [root@master schedule]# kubectl get pod -o wide
    NAME                      READY   STATUS    RESTARTS   AGE   IP            NODE      NOMINATED NODE   READINESS GATES
    affinity                 1/1     Running   0          39s   10.244.2.92   worker2   <none>           <none>

**硬策略:**

[root@master schedule]# cat node-required-pod.yaml 
    apiVersion: v1
    kind: Pod
    metadata:
      name: affinity2
      labels:
        app: node-affinity-pod
    spec:
      containers:
      - name: with-node-affinity
        image: hub.hc.com/library/myapp:v1
      affinity:            #亲和性
        nodeAffinity:        #node亲和性
          requiredDuringSchedulingIgnoredDuringExecution:
            nodeSelectorTerms:
            - matchExpressions:
              - key: kubernetes.io/hostname
                operator: In      
                values:
                - worker3
        
    [root@master schedule]# kubectl get pod -o wide
    NAME                      READY   STATUS    RESTARTS   AGE   IP            NODE      NOMINATED NODE   READINESS GATES
    affinity2                  0/1     Pending   0          23s   <none>        <none>    <none>           <none>
    
    [root@master schedule]# kubectl decribe pod affinity2
    Events:
      Type     Reason            Age   From               Message
      ----     ------            ----  ----               -------
      Warning  FailedScheduling  49s   default-scheduler  0/3 nodes are available: 3 node(s) didn't match node selector.

## 2.2 Pod 亲和性 ##

`spec.affinity.podAffinity/podAntiAffinity`：

*  `preferredDuringSchedulingIgnoredDuringExecution`（优先执行计划）：软策略
 *  `requiredDuringSchedulingIgnoredDuringExecution`（要求执行计划）：硬策略

[root@master schedule]# cat pod-affinity.yaml 
    apiVersion: v1
    kind: Pod
    metadata:
      name: pod-2
      labels:
        app: pod-2
    spec:
      containers:
      - name: pod-2
        image: hub.hc.com/library/myapp:v1
      affinity:
        podAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
          - labelSelector: 
              matchExpressions:
              - key: app
                operator: In
                values: 
                - pod-1
            topologyKey: kubernetes.io/hostname
        podAntiAffinity:
          preferredDuringSchedulingIgnoredDuringExecution:
          - weight: 1
            podAffinityTerm:
              labelSelector:
                matchExpressions:
                - key: app
                  operator: In
                  values:
                  - pod-2
              topologyKey: kubernetes.io/hostname
    
    [root@master schedule]# kubectl get pod -o wide
    pod-2                     0/1     Pending   0          4s      <none>        <none>    <none>           <none>
    
    #修改标签为pod-1，创建pod
    [root@master schedule]# kubectl get pod -o wide
    NAME                      READY   STATUS    RESTARTS   AGE     IP            NODE      NOMINATED NODE   READINESS GATES
    pod-1                     1/1     Running   0          5s      10.244.2.94   worker2   <none>           <none>

**亲和性/反亲和性调度策略比较如下：**

<table> 
 <thead> 
  <tr> 
   <th>调度策略</th> 
   <th>匹配标签</th> 
   <th>操作符</th> 
   <th>拓扑域支持</th> 
   <th>调度目标</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>nodeAffinity</td> 
   <td>主机</td> 
   <td>In, NotIn, Exists,DoesNotExist, Gt, Lt</td> 
   <td>否</td> 
   <td>指定主机</td> 
  </tr> 
  <tr> 
   <td>podAffinity</td> 
   <td>POD</td> 
   <td>In, NotIn, Exists,DoesNotExist</td> 
   <td>是</td> 
   <td>POD与指定POD同一拓扑域</td> 
  </tr> 
  <tr> 
   <td>podAnitAffinity</td> 
   <td>POD</td> 
   <td>In, NotIn, Exists,DoesNotExist</td> 
   <td>是</td> 
   <td>POD与指定POD不在同一拓扑域</td> 
  </tr> 
 </tbody> 
</table>

## 2.3 Taint 和 Toleration ##

节点亲和性，是`pod`的一种属性（偏好或硬性要求），它使`pod`被吸引到一类特定的节点。`Taint`则相反，它使节点能够排斥一类特定的`pod`

`Taint`和`toleration`相互配合，可以用来避免`pod`被分配到不合适的节点上。每个节点上都可以应用一个或多个`taint`，这表示对于那些不能容忍这些`taint`的`pod`，是不会被该节点接受的。如果将`toleration`应用于`pod`上，则表示这些`pod`可以（但不要求）被调度到具有匹配`taint`的节点上。

### 2.3.1 Taint ###

**①污点 ( `Taint`) 的组成**

使用`kubectl taint`命令可以给某个`Node`节点设置污点，`Node`被设置上污点之后就和 `Pod`之间存在了一种相斥的关系，可以让`Node`拒绝`Pod`的调度执行，甚至将`Node`已经存在的`Pod`驱逐出去每个污点的组成如下：`key=value:effect`

每个污点有一个`key`和`value`作为污点的标签，其中`value`可以为空，`effect`描述污点的作用。当前`taint effect`支持如下三个选项：

*  **NoSchedule**：`K8S`将不会将`Pod`调度到具有该污点的`Node`上
 *  **PreferNoSchedule**：`K8S`将尽量避免将`Pod`调度到具有该污点的`Node`上
 *  **NoExecute**：`K8S`将不会将`Pod`调度到具有该污点的`Node`上，同时会将`Node`上已经存在的`Pod`驱逐出去

**② 污点的设置、查看和去除**

#查看节点污点，查找 Taints 字段
    kubectl describe node node-name
    
    # 设置污点
    kubectl taint nodes node1 key1=value1:effect
    
    # 去除污点
    kubectl taint nodes node1 key1=value1:effect

### 2.3.2 Tolerations ###

设置了污点的`Node`将根据`taint`的`effect`和`Pod`之间产生互斥的关系，`Pod`将在一定程度上不会被调度到`Node`上。但我们可以在`Pod`上设置容忍 (`Toleration`) ，设置了容忍的`Pod`将可以容忍污点的存在，可以被调度到存在污点的`Node`上。

**`toleration`的配置：**

spec:
      tolerations:
        - key: "key1"
          operator: "Equal"
          value: "value1"
          effect: "NoSchedule"
          tolerationSeconds: 3600
        - key: "key1"
          operator: "Equal"
          value: "value1"
          effect: "NoExecute"
        - key: "key2"
          operator: "Exists"
          effect: "NoSchedule"

**说明：**

*  其中`key`、 `vaule`、 `effect`要与`Node`上设置的`taint`保持一致
 *  `operator`的值为`Exists`将会忽略`value`值
 *  `tolerationSeconds`：当`Pod`需要被驱逐时可以在`Pod`上继续保留运行的时间

① 当不指定`key`值时，表示容忍所有的污点`key`

tolerations:
     - operator: "Exists"

② 当不指定`effect`值时，表示容忍所有的污点作用

tolerations:
     - key: "key"
    operator: "Exists"

③ 有多个`Master`存在时，防止资源浪费，可以如下设置

kubectl taint nodes Node-Name node-role.kubernetes.io/master=:PreferNoSchedule

## 2.4 指定调度节点 ##

apiVersion: extensions/v1beta1
    kind: Deployment
    metadata:
      name: myweb
    spec:
      replicas: 7
      template:
        metadata:
          labels:
            app: myweb
        spec:
          nodeName: worker1
          nodeSelector:
    	    type: theSelected
          containers:
          - name: myweb
            image: hub.hc.com/library/myapp:v1
            ports:
            - containerPort: 80

**说明：**

*  `spec.nodeName`：将`Pod`直接调度到指定的`Node`节点上，会跳过`Scheduler`的调度策略，该匹配规则是强制匹配
 *  `spec.nodeSelector`：通过`K8S`的`label-selector`机制选择节点，由调度器调度策略匹配`label`，而后调度`Pod`到目标节点，该匹配规则属于强制约束
 *  给`Node`打标签：`kubect; label node worker1 type=theSelected`