k8s的集群调度

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

List-watch

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

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

bash 复制代码
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字段

bash 复制代码
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字段

bash 复制代码
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状态。直到节点满足条件位置

标签创建和删除

bash 复制代码
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节点上存在

硬策略举例:

bash 复制代码
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

软策略举例:

bash 复制代码
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节点上

硬策略举例:

bash 复制代码
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的节点上

软策略举例:

bash 复制代码
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:大于。大于选择的标签值。只能比较整数值。亲和数值由标签值的大小判断

硬策略举例:

bash 复制代码
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"

软策略举例:

bash 复制代码
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:小于。小于选择的标签值。只能比较整数值。亲和数值由标签值的大小判断

硬策略举例:

bash 复制代码
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"

软策略举例:

bash 复制代码
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:存在。选择标签对象。值不考虑

硬策略举例:

bash 复制代码
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字段。否则会报错

软策略举例:

bash 复制代码
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:选择不具有指定标签的对象。值不考虑

硬策略举例:

bash 复制代码
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

软策略举例:

bash 复制代码
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文件中

两个软策略举例:

bash 复制代码
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"
bash 复制代码
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个策略。有需求指定硬策略即可。

相关推荐
烟雨书信4 分钟前
Docker文件操作、数据卷、挂载
运维·docker·容器
IT成长日记8 分钟前
【Docker基础】Docker数据卷管理:docker volume prune及其参数详解
运维·docker·容器·volume·prune
这儿有一堆花13 分钟前
Docker编译环境搭建与开发实战指南
运维·docker·容器
LuckyLay14 分钟前
Compose 高级用法详解——AI教你学Docker
运维·docker·容器
Uluoyu22 分钟前
redisSearch docker安装
运维·redis·docker·容器
IT成长日记5 小时前
【Docker基础】Docker数据持久化与卷(Volume)介绍
运维·docker·容器·数据持久化·volume·
物联网老王7 小时前
Ubuntu Linux Cursor 安装与使用一
linux·运维·ubuntu
一位摩羯座DBA9 小时前
Redhat&Centos挂载镜像
linux·运维·centos
学习3人组9 小时前
CentOS配置网络
linux·网络·centos
疯子的模样9 小时前
Docker 安装 Neo4j 保姆级教程
docker·容器·neo4j