k8s的集群调度

scheduler：负责调度资源。把pod调度到node节点。通过算法调度。分为预算策略和优先策略

List-watch

在k8s集群当中通过List-watch的机制进行每个组件的协作。保持数据同步。可以实现每个组件之间的解耦。

通过kubectl来配置文件统一向集群内部的apiserver来发送命令。通过apiserver把命令发送到各个组件。

1、 kubectl run nginx --image=nginx:1.22  >
2、 由apiserver调度到各个组件  >
3、 controller-manger负责创建pod控制器  >
4、 scheduler调度资源  >
5、 kubelet来管理节点  >
创建成功后，通过kubectl get pod/kubectl describe pod nginx
这些信息都保存在etcd数据库当中。

List-watch会在每一步把监听的消息(监听APIserver:6443)

controller-manger、scheduler、kubelet、etcd都会监听apiserver:6443端口

List-watch工作流程图：

工作流程：

1. kubectl创建pod和副本数传递给apiserver

2. 创建replicas指定pod的策略保存在etcd数据库中存储配置信息。

3. etcd会将创建replicas的事件发送给apiserver

4. apiserver发送创建指令开始调用controller-manger

5. controller-manger收到指令开始创建pod再将信息发送给apiserver

6. apiserver收到创建pod的信息并将信息保存在etcd中

7. etcd把发送创建pod的信息再发送给apiserver

8. apiserver把创建pod的指令发送给scheduler

9. scheduler开始选择往哪个node节点上创建pod并更新pod的node节点信息。发送给apiserver

10. apiserver把pod的更新信息保存到etcd中

11. etcd告诉apiserver 已经确定节点信息。需要调用节点上的kubelet

12. apiserver传递消息开始调用kubelet创建pod和容器

13. kubelet将确定完毕的信息和节点信息，发送给apiserver。

14. apiserver将最终保存容器、副本、节点信息保存到etcd数据库中。

list-watch就是各个组件都会监听apiserver的6443端口

调度的过程和策略

scheduler是k8s集群的调度器。他的意义就是把pod分配到集群的节点。

他有以下几个问题

1、 公平：每个节点都能够分配资源。公平的分配资源。

2、 资源高效利用：集群当中的资源可以被最大化使用。

3、 效率：调度的性能要好。能够尽快的完成大批量pod的调度工作

4、 灵活：允许用户根据自身需求。控制调整调度的逻辑。例如：扩缩容

scheduler是一个单独运行的容器。只要启动之后就会一直监听apiserver。他会获取报文的字段：spec模块中的nodeName字段。

在创建pod时候，他会为每个pod创建一个binding

binding：表示该往哪个节点上部署。

scheduler拥有两个策略。预算策略和优选策略。

在创建pod到节点时，有两个策略。会执行预算策略。在执行优先策略。这两步的操作都必须成功。否则立刻返回报错。

也就是说部署的node必须要同时满足这两个策略

预算策略

预算策略/predicate：使用自带一些算法来选择node节点。是scheduler自带的算法策略。不需要人工干预。

1、 podfitsresources：pod适应资源。检查节点上的剩余资源是否满足pod请求的资源。主要是cpu和内存。

2、 podfitshost：pod适应主机。如果pod指定了node的名称。那么这个算法可以用于检测主机名是否存在。

如果存在要和pod指定的名称匹配。这样才能调度过去。

3、 podselectormatches：pod选择器匹配。创建pod的时候可以根据node节点的标签进行匹配。用于查找指定的node节点上标签是否存在。存在的标签是否匹配。

4、 nodiskconflict：无磁盘冲突。确保已挂载的卷于pod的卷不发生冲突。除非目录是只读才会覆盖。

只有这四个条件满足了才会进入优先策略。如果预算策略都不满足。pod将书中处于pending状态。pod将不断重试调度。直到右节点满足条件为止。

经过预算策略。上述三个节点条件都满足

优先策略

1、 leastrequestedpriority：最低请求优先级，通过算法计算节点上的cpu和内存使用率。确定节点的权重。

使用率越低的节点相应的权重就越高。调到时会更倾向于使用率低的节点。实现资源合理的利用。

2、 balanceresourceallocation：平衡资源分配。考虑cpu和内存的使用率。给节点赋予权重。这里权重计算的是cpu和内存使用率越接近。权重越高。例如：

node1：cpu和内存的使用率 20:60

node2：cpu和内存的使用率 50:50

node2在被调度时会被优先

通常和leastrequestedpriority最低请求优先级一起使用。

3、 imagelocalitypriority：节点上是否已经有了要部署的镜像。镜像的总数成正比。满足的镜像数越高，权重越好。例如：

nginx:1.22

node1：无

node2：有

那么node2在调度时会被优先

以上这些策略都是scheduler自带的算法。

通过预算选择出可以部署的节点。再通过优先选择出来最好的节点。以上都是自带的算法。k8s集群自己来选择。

指定节点以及指定标签

指定节点

在spec参数设置当中加入nodeName字段

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx2
  labels:
    app: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - image: nginx:1.22
        name: nginx
      nodeName: node2

如果指定了节点。在参数中设置了nodeName指定节点名称。他将跳过scheduler的调度策略。

这个规则是强制匹配

指定标签

在spec参数设置当中加入nodeSelector字段

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx2
  labels:
    app: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      nodeSelector:
        test1: a
#声明指定标签选择node节点
      containers:
      - image: nginx:1.22
        name: nginx

指定节点标签部署pod，要经过scheduler的算法。如果节点不满足条件pod会进入pending状态。直到节点满足条件位置

标签创建和删除

kubectl get nodes --show-labels
#查看node的标签
kubectl label nodes 节点名 标签名
#给node节点创建标签。
kubectl label nodes 节点名 标签名-
#删除标签
kubectl label nodes 节点名 标签名 --overwrite
#覆盖标签

亲和性

节点亲和性、pod亲和性以及他们的硬策略和软策略

node节点的亲和性

preferredDuringSchedulingIgnoredDuringExecution：软策略

选择node节点时，声明了我最好能部署在node01。软策略会尽量满足这个条件。不一定会完全部署在node01节点上。

requiredDuringSchedulingIgnoredDuringExecution：硬策略

选择ndoe时。声明了部署在node01。是硬策略，必须满足硬策略的条件。必须部署在node01。强制性要求。

pod的亲和性

preferredDuringSchedulingIgnoredDuringExecution：软策略

要求调度器将pod调度到其他pod的亲和性匹配的节点上。可以是，也可也不是。软策略会尽量满足这个条件。

requiredDuringSchedulingIgnoredDuringExecution：硬策略

要求调度器将pod调度到其他pod的亲和性匹配的节点上。必须是。软策略必须满足这个条件。

键值的运算关系

都是根据标签来选择亲和性。

node节点的亲和性

In

In：在。选择的标签值。在node节点上存在

硬策略举例：

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx2
  labels:
    app: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - image: nginx:1.22
        name: nginx
      affinity:
#开始选择亲和性部署方式
        nodeAffinity:
#选择node节点的亲和性
          requiredDuringSchedulingIgnoredDuringExecution:
            nodeSelectorTerms:
#选择亲和性的策略。nodeSelectorTerms表示需要选择哪个node作为硬策略
#表示需要匹配节点的标签。
            - matchExpressions:
#定义一个符合我要选择的node节点的信息
              - key: test3
                operator: In
#指定键值对的算法
##如果使用In那么后面一定要加values
                values:
                - c
#指定标签名是test3。对应的值是C

软策略举例：

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx2
  labels:
    app: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - image: nginx:1.22
        name: nginx
      affinity:
#开始选择亲和性部署方式
        nodeAffinity:
#选择node节点的亲和性
          preferredDuringSchedulingIgnoredDuringExecution:
          - weight: 1
            preference:
              matchExpressions:
              - key: test2
                operator: In
#指定键值对的算法
##如果使用In那么后面一定要加values
                values:
                - b
#指定标签名是test2。对应的值是b

Notin

Notin：不在。选择label的值不再node节点上

硬策略举例：

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx2
  labels:
    app: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - image: nginx:1.22
        name: nginx
      affinity:
#开始选择亲和性部署方式
        nodeAffinity:
#选择node节点的亲和性
          requiredDuringSchedulingIgnoredDuringExecution:
            nodeSelectorTerms:
#选择亲和性的策略。nodeSelectorTerms表示需要选择哪个node作为硬策略
##表示需要匹配节点的标签。
            - matchExpressions:
#定义一个符合我要选择的node节点的信息
              - key: test3
                operator: NotIn
#指定键值对的算法
                values:
                - c
#指定标签名是test3。表示不能部署在test3和标签为C的节点上

软策略举例：

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx2
  labels:
    app: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - image: nginx:1.22
        name: nginx
      affinity:
#开始选择亲和性部署方式
        nodeAffinity:
#选择node节点的亲和性
          preferredDuringSchedulingIgnoredDuringExecution:
          - weight: 1
            preference:
              matchExpressions:
              - key: test3
                operator: NotIn
#指定键值对的算法
##如果使用In那么后面一定要加values
                values:
                - c
#指定标签名是test2。对应的值是b

?

Gt

Gt：大于。大于选择的标签值。只能比较整数值。亲和数值由标签值的大小判断

硬策略举例：

apiVersion: apps/v1
kind: Deployment
metadata:
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx2
  labels:
    app: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - image: nginx:1.22
        name: nginx
      affinity:
        nodeAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
            nodeSelectorTerms:
            - matchExpressions:
              - key: memory
                operator: Gt
                values:
                - "500"

软策略举例：

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx2
  labels:
    app: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - image: nginx:1.22
        name: nginx
      affinity:
        nodeAffinity:
          preferredDuringSchedulingIgnoredDuringExecution:
          - weight: 1
            preference:
              matchExpressions:
              - key: memory
                operator: Gt
                values:
                - "500"

Lt

Lt：小于。小于选择的标签值。只能比较整数值。亲和数值由标签值的大小判断

硬策略举例：

apiVersion: apps/v1
kind: Deployment
metadata:
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx2
  labels:
    app: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - image: nginx:1.22
        name: nginx
      affinity:
        nodeAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
            nodeSelectorTerms:
            - matchExpressions:
              - key: memory
                operator: Lt
                values:
                - "500"

软策略举例：

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx2
  labels:
    app: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - image: nginx:1.22
        name: nginx
      affinity:
        nodeAffinity:
          preferredDuringSchedulingIgnoredDuringExecution:
          - weight: 1
            preference:
              matchExpressions:
              - key: memory
                operator: Lt
                values:
                - "500"

Exists

Exists：存在。选择标签对象。值不考虑

硬策略举例：

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx2
  labels:
    app: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - image: nginx:1.22
        name: nginx
      affinity:
#开始选择亲和性部署方式
        nodeAffinity:
#选择node节点的亲和性
          requiredDuringSchedulingIgnoredDuringExecution:
            nodeSelectorTerms:
#选择亲和性的策略。nodeSelectorTerms表示需要选择哪个node作为硬策略
##表示需要匹配节点的标签。
            - matchExpressions:
              - key: memory
                operator: Exists
#指定键值对的算法
##使用Exists或者DoesNotExist时候不能使用values字段。否则会报错

?软策略举例：

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx2
  labels:
    app: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - image: nginx:1.22
        name: nginx
      affinity:
        nodeAffinity:
          preferredDuringSchedulingIgnoredDuringExecution:
          - weight: 1
            preference:
              matchExpressions:
              - key: memory
                operator: Exists

DoesNotExist

DoesNotExist：选择不具有指定标签的对象。值不考虑

硬策略举例：

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx2
  labels:
    app: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - image: nginx:1.22
        name: nginx
      affinity:
        nodeAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
            nodeSelectorTerms:
            - matchExpressions:
              - key: memory
                operator: DoesNotExist

软策略举例：

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx2
  labels:
    app: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - image: nginx:1.22
        name: nginx
      affinity:
        nodeAffinity:
          preferredDuringSchedulingIgnoredDuringExecution:
          - weight: 1
            preference:
              matchExpressions:
              - key: memory
                operator: DoesNotExist

多个策略同在一个yaml文件中

两个软策略举例：

kind: Deployment
metadata:
  name: nginx2
  labels:
    app: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - image: nginx:1.22
        name: nginx
      affinity:
        nodeAffinity:
          preferredDuringSchedulingIgnoredDuringExecution:
          - weight: 1
            preference:
              matchExpressions:
              - key: memory
                operator: In
                values:
                - "1000"
          preferredDuringSchedulingIgnoredDuringExecution:
          - weight: 2
            preference:
              matchExpressions:
              - key: memory
                operator: In
                values:
                - "500"

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx2
  labels:
    app: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - image: nginx:1.22
        name: nginx
      affinity:
        nodeAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
            nodeSelectorTerms:
            - matchExpressions:
              - key: memory
                operator: Gt
                values:
                - "500"
          preferredDuringSchedulingIgnoredDuringExecution:
          - weight: 1
            preference:
              matchExpressions:
              - key: memory
                operator: In
                values:
                - "600"

如果有硬策略需要先满足硬策略条件，再满足软策略。

如果硬策略无法满足则不会执行软策略。

一般在一个文件中指定1个策略。有需求指定硬策略即可。