k8s集群调度

目录

1.调度约束

2.Pod启动创建过程

3.调度过程

4.指定节点调度Pod

4.1 通过nodeName调度Pod

4.2 通过节点标签选择器调度Pod

4.3 通过亲和性调度Pod

1. 节点亲和性

2. Pod 亲和性

5.污点(Taint) 和 容忍(Tolerations)

5.1 污点(Taint) 

5.2 容忍(Tolerations)

6.cordon和drain

7.总结

---

1.调度约束

Kubernetes 是通过 List-Watch 的机制进行每个组件的协作，保持数据同步的，每个组件之间的设计实现了解耦。

用户是通过 kubectl 根据配置文件，向 APIServer 发送命令，在 Node 节点上面建立 Pod 和 Container。
APIServer 经过 API 调用，权限控制，调用资源和存储资源的过程，实际上还没有真正开始部署应用。这里    需要 Controller Manager、Scheduler 和 kubelet 的协助才能完成整个部署过程。

在 Kubernetes 中，所有部署的信息都会写到 etcd 中保存。实际上 etcd 在存储部署信息的时候，会发送 Create 事件给 APIServer，而 APIServer 会通过监听（Watch）etcd 发过来的事件。其他组件也会监听（Watch）APIServer 发出来的事件。

2.Pod启动创建过程

Pod 是 Kubernetes 的基础单元，Pod 启动典型创建过程如下

• （1）这里有三个 List-Watch，分别是 Controller Manager（运行在 Master），Scheduler（运行在 Master），kubelet（运行在 Node）。 他们在进程已启动就会监听（Watch）APIServer 发出来的事件。
• （2）用户通过 kubectl 或其他 API 客户端提交请求给 APIServer 来建立一个 Pod 对象副本。
• （3）APIServer 尝试着将 Pod 对象的相关元信息存入 etcd 中，待写入操作执行完成，APIServer 即会返回确认信息至客户端。
• （4）当 etcd 接受创建 Pod 信息以后，会发送一个 Create 事件给 APIServer。
• （5）由于 Controller Manager 一直在监听（Watch，通过https的6443端口）APIServer 中的事件。此时 APIServer 接受到了 Create 事件，又会发送给 Controller Manager。
• （6）Controller Manager 在接到 Create 事件以后，调用其中的 Replication Controller 来保证 Node 上面需要创建的副本数量。一旦副本数量少于 RC 中定义的数量，RC 会自动创建副本。总之它是保证副本数量的 Controller（PS：扩容缩容的担当）。
• （7）在 Controller Manager 创建 Pod 副本以后，APIServer 会在 etcd 中记录这个 Pod 的详细信息。例如 Pod 的副本数，Container 的内容是什么。
• （8）同样的 etcd 会将创建 Pod 的信息通过事件发送给 APIServer。
• （9）由于 Scheduler 在监听（Watch）APIServer，并且它在系统中起到了“承上启下”的作用，“承上”是指它负责接收创建的 Pod 事件，为其安排 Node；“启下”是指安置工作完成后，Node 上的 kubelet 进程会接管后继工作，负责 Pod 生命周期中的“下半生”。 换句话说，Scheduler 的作用是将待调度的 Pod 按照调度算法和策略绑定到集群中 Node 上。
• （10）Scheduler 调度完毕以后会更新 Pod 的信息，此时的信息更加丰富了。除了知道 Pod 的副本数量，副本内容。还知道部署到哪个 Node 上面了。并将上面的 Pod 信息更新至 API Server，由 APIServer 更新至 etcd 中，保存起来。
• （11）etcd 将更新成功的事件发送给 APIServer，APIServer 也开始反映此 Pod 对象的调度结果。
• （12）kubelet 是在 Node 上面运行的进程，它也通过 List-Watch 的方式监听（Watch，通过https的6443端口）APIServer 发送的 Pod 更新的事件。kubelet 会尝试在当前节点上调用 Docker 启动容器，并将 Pod 以及容器的结果状态回送至 APIServer。
• （13）APIServer 将 Pod 状态信息存入 etcd 中。在 etcd 确认写入操作成功完成后，APIServer将确认信息发送至相关的 kubelet，事件将通过它被接受。

注意：在创建 Pod 的工作就已经完成了后，为什么 kubelet 还要一直监听呢？原因很简单，假设这个时候 kubectl 发命令，要扩充 Pod 副本数量，那么上面的流程又会触发一遍，kubelet 会根据最新的 Pod 的部署情况调整 Node 的资源。又或者 Pod 副本数量没有发生变化，但是其中的镜像文件升级了，kubelet 也会自动获取最新的镜像文件并且加载。

3.调度过程

Scheduler 是 kubernetes 的调度器，主要的任务是把定义的 pod 分配到集群的节点上。其主要考虑的问题如下：

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

Sheduler 是作为单独的程序运行的，启动之后会一直监听 APIServer，获取 spec.nodeName 为空的 pod，对每个 pod 都会创建一个 binding，表明该 pod 应该放到哪个节点上。

调度分为几个部分：首先是过滤掉不满足条件的节点，这个过程称为预算策略（predicate）；然后对通过的节点按照优先级排序，这个是优选策略（priorities）；最后从中选择优先级最高的节点。如果中间任何一步骤有错误，就直接返回错误。

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 使用率越接近，权重越高。这个一般和上面的一起使用，不单独使用。比如 node01 的 CPU 和 Memory 使用率 20:60，node02 的 CPU 和 Memory 使用率 50:50，虽然 node01 的总使用率比 node02 低，但 node02 的 CPU 和 Memory 使用率更接近，从而调度时会优选 node02
• ImageLocalityPriority：倾向于已经有要使用镜像的节点，镜像总大小值越大，权重越高。

4.指定节点调度Pod

4.1 通过nodeName调度Pod

pod.spec.nodeName 将 Pod 直接调度到指定的 Node 节点上，会跳过 Scheduler 的调度策略，该匹配规则是强制匹配；此种方法创建的pod不会经过scheduler调度

vim demo1-deploy.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  creationTimestamp: null
  labels:
    app: deploy-demo
  name: deploy-demo
spec:
  replicas: 3
  selector:
    matchLabels:
      app: deploy-demo
  strategy: {}
  template:
    metadata:
      creationTimestamp: null
      labels:
        app: deploy-demo
    spec:
      nodeName: node01               #通过nodeName指定node节点
      containers:
      - image: soscscs/myapp:v1
        name: myapp
        ports:
        - containerPort: 80
        resources: {}
status: {}
 
kubectl apply -f demo1-deploy.yaml
kubectl get pod -o wide

4.2 通过节点标签选择器调度Pod

键值运算关系

• In：label 的值在某个列表中
• NotIn：label 的值不在某个列表中
• Gt：label 的值大于某个值
• Lt：label 的值小于某个值
• Exists：某个 label 存在

标签的增删改查

kubectl label nodes node01 myname=scj    #添加标签
kubectl label nodes node02 myname=tan

kubectl get nodes --show-labels    #查看标签

kubectl label nodes node01 myname=chen --overwrite   #修改标签

kubectl label nodes node01 myname-   #删除标签

kubectl get nodes -l myname=tan #-l指定值或键值对进一步查看
kubectl get nodes -l myname

通过节点标签选择器调度Pod示例：

vim demo1-deploy.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  creationTimestamp: null
  labels:
    app: deploy-demo1
  name: deploy-demo1
spec:
  replicas: 3
  selector:
    matchLabels:
      app: deploy-demo
  strategy: {}
  template:
    metadata:
      creationTimestamp: null
      labels:
        app: deploy-demo
    spec:
      nodeSelector:               # myname: chen 为node01节点的标签
        myname: chen
      containers:
      - image: soscscs/myapp:v1
        name: myapp
        ports:
        - containerPort: 80
        resources: {}
status: {}
 
kubectl apply -f demo1-deploy.yaml
kubectl get pod -o wide

4.3 通过亲和性调度Pod

1. 节点亲和性

硬策略：

vim demo2-pod.yaml
apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    run: nginx-demo2
  name: nginx-demo2
spec:
  containers:
  - image: soscscs/myapp:v1
    name: myapp
    ports:
    - containerPort: 80
    resources: {}
  dnsPolicy: ClusterFirst
  restartPolicy: Always
  affinity:                      #亲和
    nodeAffinity:                #节点亲和
      requiredDuringSchedulingIgnoredDuringExecution:    #硬策略
        nodeSelectorTerms:       
        - matchExpressions:      #标签选择
          - key: myname
            operator: In
            values:
            - chen               #此标签为node01所属
status: {}
 
kubectl apply -f demo2-pod.yaml

vim demo2-pod.yaml
apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    run: nginx-demo3
  name: nginx-demo3
spec:
  containers:
  - image: soscscs/myapp:v1
    name: myapp
    ports:
    - containerPort: 80
    resources: {}
  dnsPolicy: ClusterFirst
  restartPolicy: Always
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
        - matchExpressions:
          - key: myname
            operator: NotIn   #标签不为myname=chen
            values:
            - chen
status: {}

vim demo2-pod.yaml
apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    run: nginx-demo4
  name: nginx-demo4
spec:
  containers:
  - image: soscscs/myapp:v1
    name: myapp
    ports:
    - containerPort: 80
    resources: {}
  dnsPolicy: ClusterFirst
  restartPolicy: Always
  affinity:
    nodeAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
        - matchExpressions:
          - key: myname
            operator: NotIn     #同时标签不能为chen、tan
            values:
            - chen  
            - tan
status: {}
 
kubectl apply -f demo2-pod.yaml

软策略：

vim demo3-pod.yaml
apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    run: myapp-test3
  name: myapp-test3
spec:
  containers:
  - image: soscscs/myapp:v1
    name: myapp
    ports:
    - containerPort: 80
    resources: {}
  dnsPolicy: ClusterFirst
  restartPolicy: Always
  affinity:
    nodeAffinity:
      preferredDuringSchedulingIgnoredDuringExecution:   #软策略
      - weight: 100
        preference:
          matchExpressions:     #标签选择 
          - key: myname
            operator: In
            values:
            - chen
status: {}
 
kubectl apply -f demo3-pod.yaml

vim demo3-pod.yaml 
apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    run: myapp-test4
  name: myapp-test4
spec:
  containers:
  - image: soscscs/myapp:v1
    name: myapp
    ports:
    - containerPort: 80
    resources: {}
  dnsPolicy: ClusterFirst
  restartPolicy: Always
  affinity:
    nodeAffinity:
      preferredDuringSchedulingIgnoredDuringExecution:
      - weight: 100
        preference:
          matchExpressions:
          - key: myname
            operator: In
            values:
            - tc                   #若软策略中指定标签不存在
status: {}
kubectl apply -f demo3-pod.yaml

当软、硬策略同时存在

vim demo3-pod.yaml
apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    run: myapp-test5
  name: myapp-test5
spec:
  containers:
  - image: soscscs/myapp:v1
    name: myapp
    ports:
    - containerPort: 80
    resources: {}
  dnsPolicy: ClusterFirst
  restartPolicy: Always
  affinity:
    nodeAffinity:
      preferredDuringSchedulingIgnoredDuringExecution:
      - weight: 100
        preference:
          matchExpressions:
          - key: myname
            operator: In                  #软策略有满足的标签
            values:
            - tan
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
        - matchExpressions:
          - key: myname
            operator: NotIn                #硬策略没有满足的标签
            values:
            - chen
            - tan
 
status: {}

kubectl label nodes node01 myclass=xy101
kubectl label nodes node02 myclass=xy101
kubectl get node --show-labels

vim demo3-pod.yaml
apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    run: myapp-test5
  name: myapp-test5
spec:
  containers:
  - image: soscscs/myapp:v1
    name: myapp
    ports:
    - containerPort: 80
    resources: {}
  dnsPolicy: ClusterFirst
  restartPolicy: Always
  affinity:
    nodeAffinity:
      preferredDuringSchedulingIgnoredDuringExecution:
      - weight: 100
        preference:
          matchExpressions:
          - key: myname
            operator: In
            values:
            - tan
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
        - matchExpressions:
          - key: myclass
            operator: NotIn             #硬策略满足条件
            values:
            - xy102
            - xy103
 
status: {}


kubectl label nodes node02 myclass=xy102 --overwrite

vim demo3-pod.yaml
apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    run: myapp-test6
  name: myapp-test6
spec:
  containers:
  - image: soscscs/myapp:v1
    name: myapp
    ports:
    - containerPort: 80
    resources: {}
  dnsPolicy: ClusterFirst
  restartPolicy: Always
  affinity:
    nodeAffinity:
      preferredDuringSchedulingIgnoredDuringExecution:
      - weight: 100
        preference:
          matchExpressions:
          - key: myname
            operator: In
            values:
            - tan
      requiredDuringSchedulingIgnoredDuringExecution:
        nodeSelectorTerms:
        - matchExpressions:
          - key: myclass
            operator: NotIn         #此时硬策略只有node01满足，软策略只有node02满足
            values:
            - xy102
            - xy103
 
status: {}
 
kubectl apply -f demo3-pod.yaml

2. Pod 亲和性

Pod亲和性(podAffinity)

vim pod.yaml
apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    app: myapp-demo
  name: myapp-demo
spec:
  containers:
  - image: soscscs/myapp:v1
    name: myapp
    ports:
    - containerPort: 80
    resources: {}
  dnsPolicy: ClusterFirst
  restartPolicy: Always
status: {}
 
kubectl apply -f pod.yaml   #创建一个pod

vim demo4-pod.yaml
apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    run: myapp-demo4
  name: myapp-demo7
spec:
  containers:
  - image: soscscs/myapp:v1
    name: myapp
    ports:
    - containerPort: 80
    resources: {}
  dnsPolicy: ClusterFirst
  restartPolicy: Always
  affinity:
    podAffinity:               #pod亲和
      requiredDuringSchedulingIgnoredDuringExecution:   #硬策略     
      - topologyKey: myname
        namespaces:
        - default
        labelSelector:
          matchExpressions:     #指定标签
          - key: app
            operator: In
            values:
            - myapp-demo
status: {}

创建四个pod资源，修改其中的名字

当一个拓扑域中有多个符合条件时

vim demo4-pod.yaml
apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    run: myapp-demo4
  name: myapp-demo7
spec:
  containers:
  - image: soscscs/myapp:v1
    name: myapp
    ports:
    - containerPort: 80
    resources: {}
  dnsPolicy: ClusterFirst
  restartPolicy: Always
  affinity:
    podAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
      - topologyKey: myclass          #有相同的拓扑域
        namespaces:
        - default
        labelSelector:
          matchExpressions:
          - key: app
            operator: In
            values:
            - myapp-demo
status: {}

Pod反亲和性(podAntiAffinity)：

vim demo4-pod.yaml
apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    run: myapp-demo4
  name: myapp-demo8
spec:
  containers:
  - image: soscscs/myapp:v1
    name: myapp
    ports:
    - containerPort: 80
    resources: {}
  dnsPolicy: ClusterFirst
  restartPolicy: Always
  affinity:
    podAntiAffinity:       #设置反亲和
      requiredDuringSchedulingIgnoredDuringExecution:
      - topologyKey: myclass   #拓扑域设置的myclass
        namespaces:
        - default
        labelSelector:
          matchExpressions:         #标签匹配在node02节点，由于拓扑域设置的是反亲和，因此没有节点能创建pod
          - key: app
            operator: In
            values:
            - myapp-demo
status: {}

vim demo4-pod.yaml 
apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    run: myapp-demo4
  name: myapp-demo8
spec:
  containers:
  - image: soscscs/myapp:v1
    name: myapp
    ports:
    - containerPort: 80
    resources: {}
  dnsPolicy: ClusterFirst
  restartPolicy: Always
  affinity:
    podAntiAffinity:
      requiredDuringSchedulingIgnoredDuringExecution:
      - topologyKey: myname
        namespaces:
        - default
        labelSelector:
          matchExpressions:
          - key: app
            operator: In
            values:
            - myapp-demo
status: {}

标签匹配的为node02节点，且拓扑域为标签myname，node02节点的myname标签是唯一的，由于设置的是反亲和，因此要创建在node01节点

5.污点(Taint) 和 容忍(Tolerations)

5.1 污点(Taint) 

节点亲和性，是Pod的一种属性（偏好或硬性要求），它使Pod被吸引到一类特定的节点。Taint 则相反，它使节点能够排斥一类特定的 Pod。
Taint 和 Toleration 相互配合，可以用来避免 Pod 被分配到不合适的节点上。每个节点上都可以应用一个或多个 taint ，这表示对于那些不能容忍这些 taint 的 Pod，是不会被该节点接受的。如果将 toleration 应用于 Pod 上，则表示这些 Pod 可以（但不一定）被调度到具有匹配 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 驱逐出去

污点的增删查

kubectl taint node node01 key1=value1:NoSchedule   #添加污点
kubectl taint node node02 key1=value1:NoSchedule
kubectl describe nodes node01
kubectl describe nodes node02

创建污点时，值可以神略

删除污点

kubectl describe nodes | grep -A 3 Taint   #查看所有节点污点
kubectl taint node node02 key1:NoSchedule-  #删除污点

PreferNoSchedule:

kubectl taint node node02  key1=value1:PreferNoSchedule  #设置node02节点的污点为PreferNoSchedule

5.2 容忍(Tolerations)

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

现所有节点都有污点，需求在master节点上上调度pod

vim demo7-pod.yaml
apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    app: myapp-demo7
  name: myapp-demo6
  namespace: default
spec:
  containers:
  - image: soscscs/myapp:v1
    name: myapp
    ports:
    - containerPort: 80
    resources: {}
  dnsPolicy: ClusterFirst
  restartPolicy: Always
  tolerations:                               #配置容忍
  - key: node-role.kubernetes.io/master      #设置污点的键
    operator: Exists                         #设置污点的值，没有值就填Exists
    effect: NoSchedule                       #设置污点的选项
status: {}  
 
kubectl apply -f demo7-pod.yaml

现所有节点都有污点，需求在node02节点上上调度pod

vim demo7-pod.yaml
apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    app: myapp-demo7
  name: myapp-demo8
  namespace: default
spec:
  containers:
  - image: soscscs/myapp:v1
    name: myapp
    ports:
    - containerPort: 80
    resources: {}
  dnsPolicy: ClusterFirst
  restartPolicy: Always
  tolerations:                   #定义容忍
  - key: key1                    #定义键
    operator: Equal              #键有值的话operator:填Equal
    value: volue1                #值
    effect: NoExecute            #污点类型
    tolerationSeconds: 30        #容忍时间
status: {}

kubectl apply -f demo7-pod.yaml

其它注意事项

（1）当不指定 key 值时，表示容忍所有的污点 key

  tolerations:
  - operator: "Exists"

（2）当不指定 effect 值时，表示容忍所有的污点作用

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

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

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

如果某个 Node 更新升级系统组件，为了防止业务长时间中断，可以先在该 Node 设置 NoExecute 污点，把该 Node 上的 Pod 都驱逐出去
kubectl taint node node01 check=mycheck:NoExecute

//此时如果别的 Node 资源不够用，可临时给 Master 设置 PreferNoSchedule 污点，让 Pod 可在 Master 上临时创建

kubectl taint node master node-role.kubernetes.io/master=:PreferNoSchedule --overwrite

//待所有 Node 的更新操作都完成后，再去除污点

kubectl taint node node01 check=mycheck:NoExecute-

6.cordon和drain

将 Node 标记为不可调度的状态，这样就不会让新创建的 Pod 在此 Node 上运行

kubectl cordon <NODE_NAME>          #该node将会变为SchedulingDisabled状态
 
kubectl cordon <节点名称>
kubectl uncordon <节点名称>
 
kubectl cordon node01
kubectl uncordon node01

设置节点不可调度并驱逐Pod

kubectl drain 可以让 Node 节点开始释放所有 pod，并且不接收新的 pod 进程。drain 本意排水，意思是将出问题的 Node 下的 Pod 转移到其它 Node 下运行
kubectl drain <NODE_NAME> --ignore-daemonsets --delete-emptydir-data --force

• --ignore-daemonsets：无视 DaemonSet 管理下的 Pod。
• --delete-emptydir-data：如果有 mount local volume 的 pod，会强制杀掉该 pod。
• --force：强制释放不是控制器管理的 Pod。

vim pod.yaml
apiVersion: v1
kind: Pod
metadata:
  creationTimestamp: null
  labels:
    app: myapp-demo1
  name: myapp-demo3
spec:
  nodeName: node02
  containers:
  - image: soscscs/myapp:v1
    name: myapp
    ports:
    - containerPort: 80
    resources: {}
  dnsPolicy: ClusterFirst
  restartPolicy: Always
status: {}

 通过创建三个自主式pod 

vim demo1-deploy.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  creationTimestamp: null
  labels:
    app: deploy-demo1
  name: deploy-demo1
spec:
  replicas: 3
  selector:
    matchLabels:
      app: deploy-demo
  strategy: {}
  template:
    metadata:
      creationTimestamp: null
      labels:
        app: deploy-demo
    spec:
      nodeSelector:
        myname: chen
      containers:
      - image: soscscs/myapp:v1
        name: myapp
        ports:
        - containerPort: 80
        resources: {}
status: {}

#创建一个控制器管理的pod

kubectl drain node02 --ignore-daemonsets --delete-emptydir-data --force
kubectl get node  #查看node节点
kubectl get pod -o wide   #查看pod
 
kubectl label nodes node01 myname=chen --overwrite  #因为创建控制器pod时关联的标签只有node02有，node02此时被设置为不可调度，可以将node01的标签设置为chen，即可将调度pod

7.总结

k8s是通过list-watch机制实现每个组件的协同工作
controller-manager、scheduler、kubelet通过list-watch机制监听apiserver发出的事件，apiserver也会监听etcd发出的事件

scheduler的调度策略：

预选策略（predicate）：通过调度算法过滤掉不满足条件的node节点，如果没有满足条件的node节点，Pod会处于Pending状态，直到有符合条件的node节点出现；PodFitsResources（根据pod的request资源量）

• PodFitsHost（根据pod的nodename）
• PodFitsHostPorts（根据pod使用的端口）
• PodSelectorMatches（根据pod的节点标签选择器）
• NoDiskConflict（根据pod使用存储卷0

优选策略：（priorities）：根据优先级选项为满足预选策略条件的node节点进行优先级排序，最终选择优先级最高的node节点调度pod

• LeastRequestedPriority（倾向资源使用率更低的节点）
• BalancedResourceAllocation（倾向cpu和内存使用率更接近的节点）
• ImageLocalityPriority（倾向本地已有要使用镜像的节点）

如何指定node节点调度Pod？
1）使用 nodeName 指定node节点名称
2）使用 nodeSelector 指定node节点的标签
3）使用 节点亲和性、Pod亲和性、Pod反亲和性
4）使用 给node节点设置污点，Pod设置容忍