【k8s】pod详解

一、pod介绍

1、pod的基础概念

Pod是kubernetes中最小的资源管理组件，Pod也是最小化运行容器化应用的资源对象，一个pod代表着集群中运行的一个进程。kubernetes中其它大多数组件都是围绕着pod来进行支持和扩展pod功能的。

例如，用于管理pod运行的statefulset和deployment 等控制器对象，用于暴露应用的service和ingress对象，为pod提供存储的persistentVolumes存储资源对象。

在kubernetes集群中Pod有如下两种使用方式

• 一个Pod中运行一个容器， “ 每个Pod中一个容器” 的模式是最常见的用法，在这种使用方式中，你可以把Pod想像成单个容器的封装，kubernetes管理的是Pod而不是直接管理容器。
• 在一个Pod中同时运行多个容器 ，一个Pod中也可以同时封装几个需要紧密耦合互相协作的容器，他们之间共享资源，这些在同一个Pod中的容器可以互相协作称为一个service单位，比如一个容器共享文件，另一个sidecar 容器来更新这些文件。pod将这些容器的存储资源作为一个实体来管理。

一个Pod下的容器必须运行在同一个节点上，现代容器技术建议一个容器只运行一个进程，该进程在容器中PID命名空间中的进程号为1，可直接接受并处理信号，进程终止时容器生命周期也就结束了。

若想在容器内运行多个进程，需要有一个类似linux操作系统init进程的管控类进程，以树状结构完成多进程的生命周期管理，运行于各自容器内的 进程无法直接完成网络通信，这是由于容器间的隔离机制导致，k8s中的Pod资源抽象正式解决此类问题，Pod对象是一组容器的集合，这些容器共享network、UTS及IPC命名空间，因此具有相同的域名，主句名和网络接口，并可通过IPC直接通信。

namespace	功能
mnt（mount）	提供磁盘挂载点和文件系统的隔离能力
ipc（inter-Process Communication）	提供进程间通信的隔离能力
net（network）	提供网络隔离能力
uts（Unix Time Sharing）	提供主机名隔离能力
pid	提供进程号隔离能力
user	提供用户隔离能力

 

Pod中的pause容器

Pod资源中针对各容器提供网络命名空间等共享机制的是底层基础容器pause，pause就是为了管理Pod容器间的共享操作，这个副容器需要能够准确的知道如何去创建共享运行环境的容器，还能管理这些容器的生命周期，为了实现这个副容器的构想，kubernetes中用pause容器来作为一个Pod中所有容器的副容器， 这个pause容器有两个核心的功能，一个是它提供整个Pod的Linux命名空间的基础，二是启动PID命名空间，它在每个Pod中都作为PID为1的进程（init进程），并回收僵尸进程。

pause容器使得Pod中的所有容器可以共享两种资源：网络和存储

网络

• 每个Pod都会被分配一个唯一的IP地址，Pod中的所有容器共享网络空间，包括IP地址和端口，Pod内部的容器可以使用localhost互相通信，Pod中的容器与外界通信时，必须分配共享网络资源（例如使用宿主机的端口映射

存储

• Pod可以指定多个共享的Volume，Pod中的所有容器都可以访问共享Volume。Volume也可以用来持久化Pod中的存储资源，以防止容器后文件丢失。

#总的来说
//每个Pod都有一个特殊的被称为“基础容器”的pause容器，pause容器对应的镜像属于kubernetes平台的一部分，除了pause容器，每个Pod号包含一个或多个紧密相关的用户应用容器。

#kubernetes中pause容器主要为每个容器提供一下功能
//在pod中担任linux命名空间(如网络命名空间)共享的基础
//启用PID命名空间，开启init进程

#kubernetes涉及这样的Pod概念和特殊组成结构有什么用意？
//原因一
在一组容器作为一个单元的情况下，难以对整体的容器简单的进行判断及有效进行行动。比如一个容器死亡了，此时是算整体挂了吗？那么引入与业务无关的pause容器作为Pod的基础容器，以它的状态代表牌整个容器组的状态，这样就可以解决该问题。

//原因二
Pod里的多个应用容器共享pause容器的IP。共享pause容器挂载的Volume，这样简化了应用容器之间的通信问题，也解决了容器之间的文件共享问题。

//就是产生pause容器的两个原因是，1、通过pause容器判断整个pod中容器是否正常，2、通过pause容器共享网络和挂载。

 

Pod的分类

自主式Pod

• 这种Pod本身是不能自我修复的，当Pod被创建后（不论是由你直接创建还是被其它controller），都会被kubernetes调度到集群的Node上，直到Pod的进程终止，被删掉，因为缺少资源而被驱逐，或者Node故障之前这个Pod都会一直保持在那个Node上。
• Pod不会自愈。如果Pod运行的Node故障，或者是调度器本身故障，这个Pod就会被删除，同样的，如果所在Node缺少资源或者pod处理维护状态，Pod也会被驱逐。

控制器管理的Pod

• kubernetes使用更高级的称为controller的抽象层，来管理Pod实例。controller可以创建和管理多个Pod，提供副本管理，滚动升级和集群级别的自愈能力。
• 例如，如果一个Node故障，controller就能自动将该节点上Pod调度到其它健康的Node上，虽然可以直接使用Pod，但是kubernetes中通常是使用controller来管理Pod的。

Pod的容器分类

基础容器（infrastructure container）

• 维护整个Pod网络和存储空间
• node节点中操作
• 启动一个容器时，k8s会自动启动一个基础容器

初始化容器（init container）

Init 容器必须在应用程序容器启动之前运行完成，而应用程序容器是并行运行的，所以 Init 容器能够提供了一种简单的阻塞或延迟应用容器的启动的方法。Init 容器与普通的容器非常像，除了以下两点

• Init 容器总是运行到成功完成为止
• 每个 Init 容器都必须在下一个 Init 容器启动之前成功完成启动和退出

如果 Pod 的 Init 容器失败，k8s 会不断地重启该 Pod，直到 Init 容器成功为止。然而，如果 Pod 对应的重启策略（restartPolicy）为 Never，它不会重新启动。

#init容器的作用
因为 init 容器具有与应用容器分离的单独镜像，其启动相关代码具有如下优势

1、Init 容器可以包含一些安装过程中应用容器中不存在的实用工具或个性化代码。例如，没有必要仅为了在安装过程中使用类似 sed、 awk、python 或 dig 这样的工具而去 FROM 一个镜像来生成一个新的镜像。

2、Init 容器可以安全地运行这些工具，避免这些工具导致应用镜像的安全性降低。

3、应用镜像的创建者和部署者可以各自独立工作，而没有必要联合构建一个单独的应用镜像。

4、Init 容器能以不同于 Pod 内应用容器的文件系统视图运行。因此，Init 容器可具有访问 Secrets的权限，而应用容器不能够访问。

5、由于 Init 容器必须在应用容器启动之前运行完成，因此 Init容器提供了一种机制来阻塞或延迟应用容器的启动，直到满足了一组先决条件。一旦前置条件满足，Pod 内的所有的应用容器会并行启动。

应用容器（ main container）

• 在init容器完成并退出后并行启动

2、pod定义（资源清单）

apiVersion: v1     #必选，版本号，例如v1
kind: Pod       　 #必选，资源类型，例如 Pod
metadata:       　 #必选，元数据
  name: string     #必选，Pod名称
  namespace: string  #Pod所属的命名空间,默认为"default"
  labels:       　　  #自定义标签列表
    - name: string      　          
spec:  #必选，Pod中容器的详细定义
  containers:  #必选，Pod中容器列表
  - name: string   #必选，容器名称
    image: string  #必选，容器的镜像名称
    imagePullPolicy: [ Always|Never|IfNotPresent ]  #获取镜像的策略 
    command: [string]   #容器的启动命令列表，如不指定，使用打包时使用的启动命令
    args: [string]      #容器的启动命令参数列表
    workingDir: string  #容器的工作目录
    volumeMounts:       #挂载到容器内部的存储卷配置
    - name: string      #引用pod定义的共享存储卷的名称，需用volumes[]部分定义的的卷名
      mountPath: string #存储卷在容器内mount的绝对路径，应少于512字符
      readOnly: boolean #是否为只读模式
    ports: #需要暴露的端口库号列表
    - name: string        #端口的名称
      containerPort: int  #容器需要监听的端口号
      hostPort: int       #容器所在主机需要监听的端口号，默认与Container相同
      protocol: string    #端口协议，支持TCP和UDP，默认TCP
    env:   #容器运行前需设置的环境变量列表
    - name: string  #环境变量名称
      value: string #环境变量的值
    resources: #资源限制和请求的设置
      limits:  #资源限制的设置
        cpu: string     #Cpu的限制，单位为core数，将用于docker run --cpu-shares参数
        memory: string  #内存限制，单位可以为Mib/Gib，将用于docker run --memory参数
      requests: #资源请求的设置
        cpu: string    #Cpu请求，容器启动的初始可用数量
        memory: string #内存请求,容器启动的初始可用数量
    lifecycle: #生命周期钩子
        postStart: #容器启动后立即执行此钩子,如果执行失败,会根据重启策略进行重启
        preStop: #容器终止前执行此钩子,无论结果如何,容器都会终止
    livenessProbe:  #对Pod内各容器健康检查的设置，当探测无响应几次后将自动重启该容器
      exec:       　 #对Pod容器内检查方式设置为exec方式
        command: [string]  #exec方式需要制定的命令或脚本
      httpGet:       #对Pod内个容器健康检查方法设置为HttpGet，需要制定Path、port
        path: string
        port: number
        host: string
        scheme: string
        HttpHeaders:
        - name: string
          value: string
      tcpSocket:     #对Pod内个容器健康检查方式设置为tcpSocket方式
         port: number
       initialDelaySeconds: 0       #容器启动完成后首次探测的时间，单位为秒
       timeoutSeconds: 0    　　    #对容器健康检查探测等待响应的超时时间，单位秒，默认1秒
       periodSeconds: 0     　　    #对容器监控检查的定期探测时间设置，单位秒，默认10秒一次
       successThreshold: 0
       failureThreshold: 0
       securityContext:
         privileged: false
  restartPolicy: [Always | Never | OnFailure]  #Pod的重启策略
  nodeName: <string> #设置NodeName表示将该Pod调度到指定到名称的node节点上
  nodeSelector: obeject #设置NodeSelector表示将该Pod调度到包含这个label的node上
  imagePullSecrets: #Pull镜像时使用的secret名称，以key：secretkey格式指定
  - name: string
  hostNetwork: false   #是否使用主机网络模式，默认为false，如果设置为true，表示使用宿主机网络
  volumes:   #在该pod上定义共享存储卷列表
  - name: string    #共享存储卷名称 （volumes类型有很多种）
    emptyDir: {}       #类型为emtyDir的存储卷，与Pod同生命周期的一个临时目录。为空值
    hostPath: string   #类型为hostPath的存储卷，表示挂载Pod所在宿主机的目录
      path: string      　　        #Pod所在宿主机的目录，将被用于同期中mount的目录
    secret:       　　　#类型为secret的存储卷，挂载集群与定义的secret对象到容器内部
      scretname: string  
      items:     
      - key: string
        path: string
    configMap:         #类型为configMap的存储卷，挂载预定义的configMap对象到容器内部
      name: string
      items:
      - key: string
        path: string

在kubernetes中所有资源的一级属性都是一样的，主要包含5部分 

• apiVersion 版本： 由kubernetes内部定义，版本号必须可以用kubectl api-versions 查询到
• kind 类型： 由kubernetes 内部定义，版本号必须可以用kubectl api-resources 查询到
• metadata 元数据： 主要是资源标识和说明，常用的有name、namespace、labels等
• spec 描述： 这是配置中最重要的一部分，里面是对各种资源配置的详细描述。
• status 状态信息： 里面的内容不需要定义，由kubernetes自动生成。

在上面的属性中，spec 是接下来研究的重点，继续看它的常见子属性

• containers <[]Object> 容器列表： 用于定于容器的详细信息
• nodeName ： 根据nodeName的值将pod调度到指定的Node节点上
• nodeSelector <map[]> ： 根据NodeSelrctor中定义的信息选择将该pod调度到包含这些label的Node上
• hostNetwork 是否使用主机网络模式，默认为false，如果设置为true，表示使用宿主机网络
• volumes <[]Object> 存储卷： 用于定义Pod上面挂在的存储信息
• restartPolicy 重启策略： 表示Pod在遇到故障的时候的处理策略

二、Pod中的容器配置

kubectl explain pod.spec.containers
#查看pod资源下的spec属性下的containers容器的配置信息
//下面列出常用的几项配置

KIND: Pod
VERSION: V1
RESOURCE: containers <[] object>  #数组，代表可以有多个容器
FIELDS:
    name <string>          #容器名称
    image <string>         #容器需要的镜像地址
    imagePullPolicy <string>   #镜像拉取策略
    command  <[]string>        #容器的启动命令列表
    args     <[]string>        #容器的启动命令需要的参数列表
    env      <[]object>        #容器环境变量的配置
    ports    <[]object>        #容器需要暴露的端口号列表
    resources  <object>        #资源限制和资源请求的设置
    
//上面每个字段的后面都有特定的标识
<string>  : //表示此字段后面，只需要跟一个字符串即可
<[]string> : //表示此字段后面，需要跟数组类型的字符串
<[]object> : //表示此字段后面，还有很多类型的字段，且需要使用数组的形式表示，可以使用explain继续往里面查看字段类型

1、基本配置

vim pod-text.yaml

apiVersion: v1
kind: Pod
metadata:
  name: pod-base
  namespace: dev
  labels:
    user:ydq
spec:
  containers:
  - name: nginx
    image: nginx:1.17.1
  - name: busybox
    image: busybox:1.30

kubectl apply -f pod-base.yaml
#生成pod

kubectl get pods -n dev
#查看pod是否生成

kubectl describe pod pod-base -n dev
#查看该pod的详细信息

//READY 1/2 : 表示当前pod中有两个容器，其中一个准备就绪，1个未就绪
//RESTARTS : 重启次数，因为有一个1个容器故障了，Pod这一直在重启试图恢复它

2、镜像拉取（imagePullPolicy）

imagePullPolicy ： 用于设置镜像拉取策略，kubernets支持配置三种拉取策略

• Always： 总是从远程仓库拉取镜像（一直远程下载）
• ifNotPresent： 本地有则使用本地镜像，本地没有则从远程仓库拉取镜像
• Never： 只使用本地镜像，从不去远程仓库拉取，本地没有就报错。（一直使用本地）

默认值说明：

• 如果镜像tag为具体版本号， 默认策略是：IfNotPresent

• 如果镜像tag为：latest（最终版本） ，默认策略是always

apiVersion: v1
kind: Pod
metadata:
  name: pod-imagepullpolicy
  namespace: dev
spec:
  containers:
  - name: nginx
    image: nginx:1.17.2
    imagePullPolicy: Never    #用于设置镜像拉取策略
  - name: busybox
    image: busybox:1.30

 

kubectl apply -f pod-imagepullpolicy.yaml
#制作pod

kubectl get pod -n dev
#查看pod

kubectl describe pod pod-imagepullpolicy -n dev
#查看详细信息

 

 

3、启动命令（command）

在前面的案例中，一直有一个问题没有解决，就是busybox容器一直没有成功运行，那么到底是什么原因导致整个容器的故障呢？

• 因为busybox并不是一个程序，而是类似于一个工具类的集合，kubernetes集群启动管理后，它会自动关闭，解决办法就是让其一直在运行，这就用到了conmand配置。

apiVersion: v1
kind: Pod 
metadata:
  name: pod-command
  namespace: dev
spec:
  containers:
  - name: nginx
    image: nginx:1.17.1
  - name: busybox
    image: busybox:1.30
    command: ["/bin/sh","-c","touch /tmp/hello.txt;while true;do /bin/echo $(date +%T) >> /tmp/hello.txt; sleep 3; done;"]
    
//command: 用于在pod中的容器初始化完毕之后运行一个命令。

"/bin/sh","-c",  #使用sh执行命令
touch /tmp/hello.txt;  #创建一个/tmp/hello.txt 文件
while true;do /bin/echo $(date +%T) >> /tmp/hello.txt; sleep 3; done; # 每隔3秒向文件中写入当前时间

 

#格式: 
kubectl exec 【pod名称】 -n 【命名空间】 -it -c 【容器名称】 /bin/bash

kubectl exec pod-command -n dev -it -c busybox /bin/sh
#进入指定pod中的指定容器中

#特别说明：
    通过上面发现command已经可以完成启动命令和传递参数的功能，为什么这里还要提供一个args选项，用于传递参数呢?这其实跟docker有点关系，kubernetes中的command、args两项其实是实现覆盖Dockerfile中ENTRYPOINT的功能。

1、如果command和args均没有写，那么用Dockerfile的配置。
2、如果command写了，但args没有写，那么Dockerfile默认的配置会被忽略，执行输入的command
3、如果command没写，但args写了，那么Dockerfile中配置的ENTRYPOINT的命令会被执行，使用当前args的参数
4、如果command和args都写了，那么Dockerfile的配置被忽略，执行command并追加上args参数

4、环境变量（env）

env : 环境变量，用于在pod中的容器设置环境变量。

apiVersion: v1
kind: Pod
metadata:
  name: pod-env
  namespace: dev
spec:
  containers:
  - name: busybox
    image: busybox:1.30
    command: ["/bin/sh","-c","while true;do /bin/echo $(date +%T);sleep 60; done;"]
    env: # 设置环境变量列表
    - name: "username"
      value: "admin"
    - name: "password"
      value: "123456"

kubectl apply -f pod-env.yaml

kubectl exec -it pod-env -n dev /bin/sh
#登录到容器中，（这里不需要使用-c指定容器名称，因为将诶这个pod里面就一个容器）

5、端口设置（ports）

apiVersion: v1
kind: Pod
metadata:
  name: pod-ports
  namespace: dev
spec:
  containers:
  - name: nginx
    image: nginx:1.17.1
    ports: # 设置容器暴露的端口列表
    - name: nginx-port
      containerPort: 80
      protocol: TCP

kubect apply -f pod-port.yaml

kubectl get pods -n dev

kubectl get pod pod-ports -n dev -o yaml

 

6、资源配额（resources）

容器中的程序要运行，肯定是要占用一定资源的，比如cpu和内存等，如果不对某个容器的资源做限制，那么它就可能吃掉大量资源，导致其它容器无法运行。 针对这种情况，kubernetes提供了对内存和cpu的资源进行配额的机制，这种机制主要通过resources选项实现，他有两个子选项：

• limits： 用于限制运行时容器的最大占用资源，当容器占用资源超过limits时会被终止，并进行重启
• requests ： 用于设置容器需要的最小资源，如果环境资源不够，容器将无法启动

内存资源单位

• 内存的request 和limit 以字节为单位，可以整数表示，或者以10为底数的指数的单位（E、P、T、G、M、K）来表示，或者以2 为底数的指数来表示（Ei、Pi、Ti、Gi、Mi、Ki）来表示。
• cpu的单位如果为0.5，表示该容器能获取的一个Cpu的一半，（类似于Cgroup对cpu的资源的时间分片），表达式0.1等价于表达式100m（毫核），表示每1000毫秒内容器可以使用cpu时间总量为100号秒。

案例1：

创建pod-resources.yaml 文件

apiVersion: v1
kind: Pod
metadata:
  name: pod-resources
  namespace: dev
spec:
  containers:
  - name: nginx
    image: nginx:1.17.1
    resources:              # 资源配额
      limits:               # 限制资源（上限）
        cpu: "2"            # CPU限制，单位是core数 
        memory: "10Gi"      # 内存限制
      requests:             # 请求资源（下限）
        cpu: "1"            # CPU限制，单位是core数
        memory: "10Mi"      # 内存限制   

#以上是可以正常创建pod的，然后再将requests的最小内存限制改为10Gi，再创建pod，查看是否创建成功

#发现是无法创建成功的，因为requests最小请求量不仅需要满足容器内部的应用启动大小， 也需要在当前node节点上能划分出该设定的资源的。不然资源无法请求成功到，容器也无法运行。

kubectl apply -f pod-resources.yaml

kubectl get pods -n dev

kubectl describe pod pod-resources -n dev
#查看详细信息

kubectl logs pod-resources -c nginx
#查看对象的容器日志信息

 

案例2：

创建pod-resources2.yaml

apiVersion: v1
kind: Pod
metadata:
  name: frontend
spec:
  containers:
  - name: web
    image: nginx
    env:
    - name: WEB_ROOT_PASSWORD
      value: "password"
    resources:
      requests:
        memory: "64Mi"
        cpu: "250m"
      limits:
        memory: "128Mi"
        cpu: "500m"
  - name: db
    image: mysql
    env:
    - name: MYSQL_ROOT_PASSWORD
      value: "abc123"
    resources:
      requests:
        memory: "512Mi"
        cpu: "0.5"
      limits:
        memory: "1Gi"
        cpu: "1"

kubectl create -f pod-resource2.yaml

kubectl get pods -owide

kubectl describe pods frontend

kubectl describe nodes node02

 

 

三、pod生命周期

我们一般将pod对象从创建至终的这段时间范围称为pod的生命周期，它主要包含下面的过程

• pod创建过程
• 运行初始化容器（init container）过程
• 运行主容器（main container）
  • 容器启动后钩子（post start），容器终止前钩子（pre stop）
  • 容器的存活性探测（liveness probe），就绪性探测（readiness probe）
• pod终止过程

 在整个生命周期中，pod会出现5中状态（也称为相位）。

• 挂起（Pending）：apiserver已经创建了pod资源对象，但它尚未被调度完成或者仍处于下载镜像的过程中
• 运行中（Running）：pod已经被调度至某节点，并且所有容器都已经被kubelet创建完成
• 成功（Succeeded）：pod中的所有容器都已经成功终止并且不会被重启。
• 失败（Failed）：所有容器都已经终止，但至少有一个容器终止失败，即容器返回了非0值的退出状态
• 未知（Unknown）：apiserver无法正常获取到pod对象的状态信息，通常由网络通信失败所导致。

1、创建和终止

pod的创建过程

• 用户通过kubectl或其它api客户端提交需要创建的pod信息给apiserver。
• apiserver开始生成pod对象的信息，并将信息存入etcd，然后返回确认信息至客户端。
• apiserver开始反映etcd中的pod对象的变化，其它组件使用watch机制来跟踪检查apiserver上的变动。
• scheduler发现有新的pod对象要创建，开始为pod分配主机并将结果信息更新至apiserver。
• node节点上的kubelet发现有pod调度过来，尝试调用docker启动容器，并将结构返回至apiserver
• apiserver将接收到的pod状态信息存入etcd中。

pod的终止过程

• 用户向apiServer发送删除pod对象的命令
• apiServcer中的pod对象信息会随着时间的推移而更新，在宽限期内（默认30s），pod被视为dead
• 将pod标记为terminating状态
• kubelet在监控到pod对象转为terminating状态的同时启动pod关闭过程
• 端点控制器监控到pod对象的关闭行为时将其从所有匹配到此端点的service资源的端点列表中移除
• 如果当前pod对象定义了preStop钩子处理器，则在其标记为terminating后即会以同步的方式启动执行
• pod对象中的容器进程收到停止信号
• 宽限期结束后，若pod中还存在仍在运行的进程，那么pod对象会收到立即终止的信号
• kubelet请求apiServer将此pod资源的宽限期设置为0从而完成删除操作，此时pod对于用户已不可见

 

2、初始化容器（initContainers）

初始化容器是在pod的主容器启动之前要运行的容器，主要是做一些主容器的前置工作，它具有两大特征：

• 初始化容器必须运行完成直至结束，若某初始化容器运行失败，那么kubernetes需要重启它直到成功完成
• 初始化容器必须按照定义的顺序执行，当且仅当前一个成功之后，后面的一个才能运行

初始化容器有很多的应用场景，下面列出的是最常见的几个：

• 提供主容器镜像中不具备的工具程序或自定义代码
• 初始化容器要先于应用容器串行启动并运行完成，因此可用于延后应用容器的启动直至其依赖的条件得到满足

测试案例

假设要以主容器来运行nginx，但是要求在运行nginx之前先要能够连接上mysql和redis所在服务器为了简化测试，事先规定好mysql (20.0.0.100 ) 和 redis (20.0.0.110) 服务器的地址

apiVersion: v1
kind: Pod
metadata:
  name: pod-initcontainer
  namespace: dev
spec:
  containers:
  - name: main-container
    image: nginx:1.17.1
    ports: 
    - name: nginx-port
      containerPort: 80
  initContainers:
  - name: test-mysql
    image: busybox:1.30
    command: ['sh', '-c', 'until ping 20.0.0.100 -c 1 ; do echo waiting for mysql...; sleep 2; done;']
  - name: test-redis
    image: busybox:1.30
    command: ['sh', '-c', 'until ping 20.0.0.110 -c 1 ; do echo waiting for reids...; sleep 2; done;']

kubectl create -f pod-initcontainer.yaml
#创建pod

kubectl describe pod pod-initcontainer -n dev
#查看pod状态(发现pod卡在启动第一个初始化容器过程中，后面的容器不会运行)

kubectl get pods pod-initcontainer -n dev -w
#动态查看pod状态

//接下来新开一个shell，为当前服务器新增两个ip，观察pod的变化
ifconfig ens33:1 20.0.0.100 netmask 255.255.255.0 up
ifconfig ens33:2 20.0.0.110 netmask 255.255.255.0 up
//发现可以正常启动，因为初始化容器运行完成了

3、钩子函数（lifecycle）

钩子函数能够感知自身生命周期中的事件，并在相应的时刻到来时运行用户指定的程序代码。

kubernetes在主容器的启动之后和停止之前提供了两个钩子函数

• post start ： 容器创建之后执行，如果失败会重启容器
• pre stop ： 容器终止之前执行，执行完成之后容器将成功终止，在其完成之前会阻塞删除容器的操作。

钩子处理器支持使用下面三种方式定义动作

• Exec命令：在容器内执行一次命令

....
   lifecycle:
      postStart:
        exec:
          command:
          - cat
          - /tmp/healthy
....

• TCPSocket：在当前容器尝试访问指定的socker，

....
   lifecycle:
     postStart:
       tcpSocker:
         port: 8080
....

• HTTPGet：在当前容器中向某url发起http请求

....
  lifecycle:
    postStart:
      httpGet:
        path: /           #URI地址
        port: 80          #端口号
        host: 192.168.5.3 #主机地址
        scheme: HTTP      #支持的协议，http或者https
....

 接下来，以exec方式为例，演示下钩子函数的使用，创建pod-hook-exec.yaml文件，内容如下：

apiVersion: v1
kind: Pod
metadata:
  name: pod-hook-exec
  namespace: dev
spec:
  containers:
  - name: main-container
    image: nginx:1.17.1
    ports:
    - name: nginx-port
      containerPort: 80
    lifecycle:
      postStart: 
        exec: # 在容器启动的时候执行一个命令，修改掉nginx的默认首页内容
          command: ["/bin/sh", "-c", "echo postStart... > /usr/share/nginx/html/index.html"]
      preStop:
        exec: # 在容器停止之前停止nginx服务
          command: ["/usr/sbin/nginx","-s","quit"]

kubectl create -f pod-hook-exec.yaml

kubectl get pods pod-hook-exec -n dev -o wide

curl 【pod的ip地址】

4、容器探测（probe） 

容器探测用于检测容器中的应用实例是否正常共工作，是保障业务可用性的一种传统机制，如果经过探测，实例的状态不符合预期，那么kubernetes就会把问题实例 “ 摘除 ”，不承担业务流量，kubernetes提供了两种探针来实现容器探测。

• liveness probe： 存活性探针，用于检测应用实例当前是否处于正常状态，如果不是，k8s会重启容器（根据重启策略选择是否重启），如果容器不提供存活探针，则默认状态为success。
• readiness probe： 就绪性探针，用于检测应用实例当前是否可以接收请求，如果不能，k8s不会转发流量。端点控制器将从与Pod匹配的所有service endpoints中剔除删除该pod的IP地址。初始延迟之前的就绪状态默认为Failure。如果容器不提供就绪探针，则默认状态为Success。
• startupProbe： 启动性探针，判断容器内的应用程序是否已启动，主要针对不能确定具体启动时间的应用，如果配置了 startup Probe 探测，在startup Probe 状态为Success之前，其它探针都处于无效状态，直到它成功后，其它探针才起作用，如果startupProbe失败，kubelet将杀死容器，容器将根据restartPolicy来重启。如果容器没有配置startupProbe，则默认状态为Success。

#以上规则可言同时定义，在readinessProbe检测成功之前，Pod的running状态是不会变成ready状态的。

livenessProbe 决定是否重启容器，readinessProbe 决定是否将请求转发给容器。

上面两种探针目前均支持三种探测方式

• Exec命令： 在容器内执行一次命令，如果命令执行的退出吗为0 ，则认为程序正常，否侧不正常

....
  livenessProbe:
    exec:
      command:
      - cat
      - /tmp/healthy
....

• TCPSocket：将会尝试访问一个用户容器的端口，如果能够建立这条连接，则认为程序正常，否侧不正常

....
  livenessProbe:
    tcpSocket:
      port: 8080
....

• HTTPGet：调用容器内Web应用的URL。如果返回的状态码在200和399之间，则认为程序正常，否则不正常

....
  livenessProbe:
    httpGet:
      path: /         #URL地址
      port: 80        #端口号
      host: 127.0.0.1 #主机地址
      scheme: HTTP    #支持的协议，http或https
....

每次探测都将获得以下三种结果之一：

• 成功：容器通过了诊断
• 失败：容器未通过诊断
• 未知：诊断失败，因此不会采取任何行动

4.1 exec（命令检测）

案例1：

创建pod-liveness-exec.yaml

apiVersion: v1
kind: Pod
metadata:
  name: pod-liveness-exec
  namespace: dev
spec:
  containers:
  - name: nginx
    image: nginx:1.17.1
    ports: 
    - name: nginx-port
      containerPort: 80
    livenessProbe:
      exec:
        command: ["/bin/cat","/tmp/hello.txt"] # 执行一个查看文件的命令

kubectl create -f pod-liveness-exec.yaml
#创建pod

kubectl describe pods pod-liveness-exec -n dev
#查看pod详情

kubectl get pods pod-liveness-exec -n dev
#查看pod的状态

//以上进行探测的时候，会探测失败，所以就导致pod不停的重启，后面将command命令中的执行命令换成可执行的正常命令即可。

 

案例2：

创建pod-liveness2.yaml 文件

apiVersion: v1
kind: Pod
metadata: 
  labels:
    test: liveness
  name: liveness-exec
  namespace: dev
spec:
  containers:
  - name: liveness
    image: busybox
    imagePullPolicy: IfNotPresent
    args:
    - /bin/sh
    - -c
    - touch /tmp/healthy;sleep 30;rm -rf /tmp/healthy;sleep 60
    livenessProbe:
      exec:
        command:
        - cat
        - /tmp/healthy
      failureThreshold: 1
      initialDelaySeconds: 5
      periodSeconds: 5
------------------------------------------------------------
failureThreshold: # 当探测失败是，k8s将在放弃之前重试次数。存活探测情况下的放弃就意味着重新启动。就绪性探测情况下放弃Pod 会被打伤未就绪的标签，默认值是3，最小值是1。
(简单理解:就是探测的失败次数,允许连续探测几次)

initialDelaySeconds: #指定kubelet在执行第一次探测前应该等待的时间，也就就是第一次探测的时间初始化结束后的第1秒，初始化时间默认0秒，最小值0秒。
(简单理解:就是每次的第一次探测前需要等待的时间，如果探测多次，不用等待)

periodSeconds: #指定了kubelet 应该多久时间执行一次探测，默认10秒，最小值是1秒。

timeoutSeconds: #探测的超时后等待多少秒，默认值是1秒，最小值是1秒。(在kubernetes 1.20版本之前，exec探针会忽略此事件，探针会无限期的持续运行，升值可能超过所配置的限期，知道返回结果为止)

 下面进行创建pod，观察探测结果

kubectl create -f pod-liveness2.yaml
#创建pod

kubectl get pods -n dev -w 
#提前时实监控一个pod

4.2 TCPSocket（端口检测）

案例1：

创建pod-liveness-tcpsocket.yaml

apiVersion: v1
kind: Pod
metadata:
  name: pod-liveness-tcpsocket
  namespace: dev
spec:
  containers:
  - name: nginx
    image: nginx:1.17.1
    ports: 
    - name: nginx-port
      containerPort: 80
    livenessProbe:
      tcpSocket:
        port: 8080    # 尝试访问8080端口

kubectl create -f pod-liveness-tcpsocket.yaml
#创建pod

kubectl get pods pod-liveness-tcpsocket -n dev
#查看容器状态

kubectl describe pods pod-liveness-tcpsocket -n dev
#查看容器的详细状态

//观察上面的信息，发现尝试访问8080端口，但是失败了
//稍微一会之后，再观察pod信息，就可看到RESTART不再是0 ，而是一直增长。表示pod在重启
#当然接下来，可以修改一个可以访问的端口，比如80，正常访问后，活性检测就正常。

 

案例2：

创建pod-liveness-tcpsocket2.yaml 文件

apiVersion: v1
kind: Pod
metadata:
  name: nginx
  labels:
    app: nginx
spec:
  containers:
  - name: nginx
    image: nginx
    ports:
    - containerPort: 80
    readinessProbe:
      tcpSocket:
        port: 80
      initialDelaySeconds: 5
      periodSeconds: 10
    livenessProbe: 
      tcpSocket:
        port: 80
      initialDelaySeconds: 15
      periodSeconds: 20

下面开始运行，正常情况

这个例子同时使用 readinessProbe 和 livenessProbe 探测。

kubelet 会在容器启动 5 秒后发送第一个 readinessProbe 探测。这会尝试连接 nginx容器的 80 端口。如果探测成功，kubelet 将继续每隔 10 秒运行一次检测。如果探测失败，容器将会是处于noready状态。

kubelet 会在容器启动 15 秒后进行第一次 livenessProbe 探测。就像 readinessProbe 探测一样，会尝试连接 nginx 容器的 80 端口。如果 livenessProbe 探测失败，这个容器会被重新启动。

 

4.3 HTTPGet（URL检测）

案例1：

创建pod-liveness-httpget.yaml

apiVersion: v1
kind: Pod
metadata:
  name: pod-liveness-httpget
  namespace: dev
spec:
  containers:
  - name: nginx
    image: nginx:1.17.1
    ports:
    - name: nginx-port
      containerPort: 80
    livenessProbe:
      httpGet:             # 其实就是访问http://127.0.0.1:80/hello  
        scheme: HTTP       #支持的协议，http或者https
        port: 80           #端口号
        path: /hello       #URI地址

kubectl create -f pod-liveness-httpget.yaml
#创建pod

kubectl get pod pod-liveness-httpget -n dev
#查看pod的状态

kubectl describe pod pod-liveness-httpget -n dev
#查看pod的详细信息

//观察上面信息，尝试访问路径，但是未找到，出现404报错
#可以将访问路径修改一个存在的路径，比如/，重新创建pod，即可探测成功

 

案例2：

创建 pod-httpget.yaml 文件

apiVersion: v1
kind: Pod
metadata:
  name: myapp1
  labels:
     app: myapp
spec:
  containers:
  - name: myapp
    image: soscscs/myapp:v1
    ports:
    - name: http
      containerPort: 80
    readinessProbe:
      httpGet:
        port: 80
        path: /index.html
      initialDelaySeconds: 5
      periodSeconds: 5
      timeoutSeconds: 10 
---
apiVersion: v1
kind: Pod
metadata:
  name: myapp2
  labels:
     app: myapp
spec:
  containers:
  - name: myapp
    image: soscscs/myapp:v1
    ports:
    - name: http
      containerPort: 80
    readinessProbe:
      httpGet:
        port: 80
        path: /index.html
      initialDelaySeconds: 5
      periodSeconds: 5
      timeoutSeconds: 10 
---
apiVersion: v1
kind: Pod
metadata:
  name: myapp3
  labels:
     app: myapp
spec:
  containers:
  - name: myapp
    image: soscscs/myapp:v1
    ports:
    - name: http
      containerPort: 80
    readinessProbe:
      httpGet:
        port: 80
        path: /index.html
      initialDelaySeconds: 5
      periodSeconds: 5
      timeoutSeconds: 10 
---
apiVersion: v1
kind: Service
metadata:
  name: myapp
spec:
  selector:
    app: myapp
  type: ClusterIP
  ports:
  - name: http
    port: 80
    targetPort: 80

下面开始创建并模拟故障测试

kubectl get pods,svc,endpoint -o wide
#查看各种资源的状态

kubectl exec -it pod/myapp1 sh
#进入容器中
rm-rf /usr/share/nginx/html/index.html
#删除html文件(为了让该容器的就绪性探测失败)

#readiness探测失败，Pod 无法进入READY状态，且端点控制器将从 endpoints 中剔除删除该 Pod 的 IP 地址
//就绪性探测失败，容器并不会重启，我们可以进入到容器中，创建对应的文件，让容器恢复。

4.4 其它配置

已经使用liveness Probe演示了三种探测方式，但是查看livenessProbe的子属性，会发现除了这三种方式，还有一些其他的配置

[root@k8s-master01 ~]# kubectl explain pod.spec.containers.livenessProbe
FIELDS:
   exec <Object>  
   tcpSocket    <Object>
   httpGet      <Object>
   initialDelaySeconds  <integer>  # 容器启动后等待多少秒执行第一次探测
   timeoutSeconds       <integer>  # 探测超时时间。默认1秒，最小1秒
   periodSeconds        <integer>  # 执行探测的频率。默认是10秒，最小1秒
   failureThreshold     <integer>  # 连续探测失败多少次才被认定为失败。默认是3。最小值是1
   successThreshold     <integer>  # 连续探测成功多少次才被认定为成功。默认是1

5、 重启策略（restartpolicy）

一旦容器探测出现了问题，kubernetes就会对容器所在的Pod进行重启，其实这是由pod的重启策略决定的，pod的重启策略有 3 种

• Always ： 容器失效时，自动重启该容器，这也是默认值。
• OnFailure ： 容器终止运行且退出码不为0时重启（0不重启，非0就重启）
• Never ： 不论状态为何，都不重启该容器

##注意！！！k8s中不支持重启Pod资源，只有删除重建
创建pod-restartpolicy.yaml

apiVersion: v1
kind: Pod
metadata:
  name: pod-restartpolicy
  namespace: dev
spec:
  containers:
  - name: nginx
    image: nginx:1.17.1
    ports:
    - name: nginx-port
      containerPort: 80
    livenessProbe:
      httpGet:
        scheme: HTTP
        port: 80
        path: /hello
  restartPolicy: Never # 设置重启策略为Never

kubectl apply -f pod-restartpolicy.yaml
#创建pod

kubectl get pod pod-restartpolicy -n dev
#查看pod的状态

kubectl describe pod pod-restartpolicy -n dev
#查看pod的详细信息

 

四、Pod调度

在默认情况下，一个Pod在哪个Node节点上运行，是由Scheduler组件采用相应的算法计算出来的，这个过程是不受人工控制的。但是在实际使用中，这并不满足的需求，因为很多情况下，我们想控制某些Pod到达某些节点上，那么应该怎么做呢？这就要求了解kubernetes对Pod的调度规则，kubernetes提供了四大类调度方式：

• 自动调度： 运行在哪个节点上完全由Scheduler经过一系列的算法计算得出
• 定向调度： NodeName（节点名称）、NodeSelector（标签选择器）
• 亲和性调度： NodeAffinity（节点亲和）、PodAffinity（pod亲和）、PodAntiAffinity（Pod非亲和）
• 污点（容忍）调度： Taints、Toleration

1、自动调度

1.1 list-watch监听机制

各组件协作介绍

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

• 用户时通过kubelet 根据配置文件，向APIServer发行命名，在Node节点上建立Pod和container。

• APIServer经过API 调用，权限控制，调用资源和存储资源的过程，实际上还没有真正开始部署应用，这里需要controller Manager、Scheduler 和 kubelet 的协助才能完成整个部署过程。

• 在kubernetes中，所有部署的信息都会写到etcd中保存，实际上etcd在存储部署信息的时候，会发送Create 事件给APIServer，而APIServer会通过监听（watch）etcd。

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 也会自动获取最新的镜像文件并且加载。

1.2 调度过程

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

• 公平： 如何保证每个节点都被分配资源
• 资源高效利用： 集群所有资源最大化被使用
• 效率： 调度的心梗要好，能够尽快的对大批量的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 过程：按照优先级大小对节点排序。
 

priorities一系列键值对组成，键是该优先级项的名称，值是它的权重（该项的重要性）。有一系列的常见的优先级选项包括：

• LeastRequestedPriority：通过计算CPU和Memory的使用率来决定权重，使用率越低权重越高。也就是说，这个优先级指标倾向于资源使用比例更低的节点。
• BalancedResourceAllocation：节点上 CPU 和 Memory 使用率越接近，权重越高。这个一般和上面的一起使用，不单独使用。比如 node01 的 CPU 和 Memory 使用率 20:60，node02 的 CPU 和 Memory 使用率 50:50，虽然 node01 的总使用率比 node02 低，但 node02 的 CPU 和 Memory 使用率更接近，从而调度时会优选 node02
• ImageLocalityPriority：倾向于已经有要使用镜像的节点，镜像总大小值越大，权重越高。

2、定向调度

定向调度、指的是利用在Pod上声明nodeName或nodeSelector，以此将Pod调度到期望的node节点上。注意，这里的调度是强制的，这就意味着即使调度的目标node不存在，也会向上面进行调度，只不过pod运行失败而已。

2.1 NodeName（节点名称）

NodeName用于强制约束将Pod调度到指定的Name的Node节点上，这种方式，起始就是直接跳过Scheduler的调度逻辑，直接将Pod调度到指定名称的节点。

创建一个pod-nodename.yaml文件

apiVersion: v1
kind: Pod
metadata:
  name: pod-nodename
  namespace: dev
spec:
  containers:
  - name: nginx
    image: nginx:1.17.1
  nodeName: node01        # 指定调度到node01节点上

kubectl apply -f pod-nodename.yaml

kubectl get pods pod-nodename -n dev -o wide
#查看pod的状态信息

//此时查看信息，发现整个pod被定向调度到指定pod01上面。
//下面做个实验，将yaml文件内容修改一下， 将pod定向调度到node1上面，发现报错，pod无法正常起来，因为在我们集群中，没有node1整个主机。虽然调度成功，但是启动失败。

修改yaml文件后的调度结果 

 

2.2 NodeSeletor（node标签）

NodeSelector 用于将pod调度到添加了指定标签的node节点上，它是通过kubernetes的label-selector机制实现

的，也就是说，在pod创建之前，会由scheduler使用MatchNodeSelector调度策略进行label匹配，找出目标node，然后pod调度到目标节点，该匹配规则是强制约束。

为两个node节点添加标签

创建pod-nodeselector.yaml文件 

apiVersion: v1
kind: Pod
metadata:
  name: pod-nodeselector
  namespace: dev
spec:
  containers:
  - name: nginx
    image: nginx:1.17.1
    
  nodeSelector: 
    nodeenv: pro     # 指定调度到具有nodeenv=pro标签的节点上

kubectl apply -f pod-nodeselector.yaml

kubectl get pods pod-nodeselector -n dev -o wide

//此时调度到指定标签的节点上，如果在yaml文件中，将标签修改，它将会调度到标签所在的node，即使node不存在。

修改yaml的文件的结果

3、亲和性调度

定向调度使用起来非常方便，但是也存在一定的问题，那就是没有满足条件的node，那么Pod将不会被运行，即使在集群中还有可用的Node列表也不行，这就限制了它的使用场景

基于上面的问题，kubernetes还提供了一种亲和性调度（Affinity），它在NodeSelector的基础之上进行了扩展，可用通过配置的形式，实现优先选择满足条件的Node进行调度，如果没有，也可以调度到不满足的节点上，使调度更加灵活。
 

Affinity主要分为三类

• nodeAffinity（node亲和性）： 以node为目标，解决pod可以调度哪些node问题。
• podAffinity（pod亲和性）： 以pod为目标，解决pod可以和哪些已存在的pod部署在同一个拓扑域中的问题
• podAntiAffinity（pod反亲和性）： 以pod为目标，解决pod不能和哪些已存在pod部署在同一个拓扑域中的问题。

#关于亲和性(反亲和性)使用场景的说明
//亲和性:
如果两个应用频繁交互，那就有必要利用亲和性让两个应用的竟可能靠近，这样可以减少因网络通信而带来的性能损耗。

//反亲和性:
 当应用的采用多副本部署时，有必要采用反亲和性让各个应用实例打散分布在各个node上，这样可以提高服务的高可用性。

3.1 NodeAffinity（节点亲和性）

kubectl explain pod.spec.affinity.nodeAffinity  #查看解释资源

  requiredDuringSchedulingIgnoredDuringExecution  #Node节点必须满足指定的所有规则才可以，相当于硬限制
    nodeSelectorTerms  #节点选择列表
      matchFields   #按节点字段列出的节点选择器要求列表
      matchExpressions   #按节点标签列出的节点选择器要求列表(推荐)
        key      #键
        values   #值
        operator  #关系符:支持Exists, DoesNotExist, In, NotIn, Gt, Lt
        
  preferredDuringSchedulingIgnoredDuringExecution //优先调度到满足指定的规则的Node，相当于软限制 (倾向)
    preference   //一个节点选择器项，与相应的权重相关联
      matchFields   //按节点字段列出的节点选择器要求列表
      matchExpressions   //按节点标签列出的节点选择器要求列表(推荐)
        key    //键
        values //值
        operator //关系符:支持In, NotIn, Exists, DoesNotExist, Gt, Lt
	weight     //倾向权重，在范围1-100。

关系符的使用说明:

- matchExpressions:
  - key: nodeenv              # 匹配存在标签的key为nodeenv的节点
    operator: Exists
    
  - key: nodeenv              # 匹配标签的key为nodeenv,且value是"xxx"或"yyy"的节点
    operator: In
    values: ["xxx","yyy"]
   
  - key: nodeenv              # 匹配标签的key为nodeenv,且value大于"xxx"的节点(大于小于的是资源的大小。)
    operator: Gt
    values: "xxx"

硬限制案例

• 这种和定向调度类似，都是必须满足，不然调度失败

创建pod-nodeaffinity-required.yaml

apiVersion: v1
kind: Pod
metadata:
  name: pod-nodeaffinity-required
  namespace: dev
spec:
  containers:
  - name: nginx
    image: nginx:1.17.1
  affinity:        #亲和性设置
    nodeAffinity:  #设置node亲和性
      requiredDuringSchedulingIgnoredDuringExecution: # 硬限制
        nodeSelectorTerms:
        - matchExpressions: # 匹配env的值在["xxx","yyy"]中的标签
          - key: nodeenv
            operator: In
            values: ["xxx","yyy"]

将yaml文件中的values的值修改一下，添加存在的标签。修改最后一段的标签选择部分

- matchExpressions: # 匹配env的值在["xxx","yyy"]中的标签
          - key: nodeenv
            operator: In
            values: ["pro","yyy"]

软限制案例

• 软限制，会进行按照设置的条件进行匹配，匹配不到，它会自己调度一个node节点

创建pod-nodeaffinity-preferred.yaml

apiVersion: v1
kind: Pod
metadata:
  name: pod-nodeaffinity-preferred
  namespace: dev
spec:
  containers:
  - name: nginx
    image: nginx:1.17.1
  affinity:  #亲和性设置
    nodeAffinity: #设置node亲和性
      preferredDuringSchedulingIgnoredDuringExecution: # 软限制
      - weight: 1
        preference:
          matchExpressions: # 匹配env的值在["xxx","yyy"]中的标签(当前环境没有)
          - key: nodeenv
            operator: In
            values: ["xxx","yyy"]

 

nodeAffinity规则设置的注意事项

1、如果同时定义了nodeSelector和nodeAffinity，那么必须两个条件都得到满足，Pod才能运行在指定的Node上。

2、如果nodeAffinity指定了多个nodeSelectorTerms，那么只需要其中一个能够匹配成功即可

3、如果一个nodeSelectorTerms中有多个matchExpressions ，则一个节点必须满足所有的才能匹配成功

4、如果一个pod所在的Node在Pod运行期间其标签发生了改变，不再符合该Pod的节点亲和性需求，则系统将忽略此变化

3.2 PodAffinity（Pod亲和性） 

kubectl explain pod.spec.affinity.podAffinity  #查看pod亲和度的解释

  requiredDuringSchedulingIgnoredDuringExecution  #硬限制
    namespaces       #指定参照pod的namespace
    topologyKey      #指定调度作用域
    labelSelector    #标签选择器
      matchExpressions  #按节点标签列出的节点选择器要求列表(推荐)
        key    #键
        values #值
        operator 关系符 #支持In, NotIn, Exists, DoesNotExist.
      matchLabels    #指多个matchExpressions映射的内容
      
  preferredDuringSchedulingIgnoredDuringExecution #软限制
    podAffinityTerm  #选项
      namespaces      
      topologyKey
      labelSelector
        matchExpressions  
          key    键
          values 值
          operator
        matchLabels 
    weight 倾向权重，在范围1-100

#topologyKey用于指定调度时作用域,例如:
 
如果指定为kubernetes.io/hostname，那就是以Node节点为区分范围
如果指定为beta.kubernetes.io/os,则以Node节点的操作系统类型来区分

 

硬限制案例

首先创建一个参照Pod，pod-podaffinity-target.yaml：

apiVersion: v1
kind: Pod
metadata:
  name: pod-podaffinity-target
  namespace: dev
  labels:
    podenv: pro #设置标签
spec:
  containers:
  - name: nginx
    image: nginx:1.17.1
  nodeName: node01 # 将目标pod名确指定到node1上

创建pod-podaffinity-required.yaml

apiVersion: v1
kind: Pod
metadata:
  name: pod-podaffinity-required
  namespace: dev
spec:
  containers:
  - name: nginx
    image: nginx:1.17.1
  affinity:  #亲和性设置
    podAffinity: #设置pod亲和性
      requiredDuringSchedulingIgnoredDuringExecution: # 硬限制
      - labelSelector:
          matchExpressions: # 匹配env的值在["xxx","yyy"]中的标签
          - key: podenv
            operator: In
            values: ["xxx","yyy"]
        topologyKey: kubernetes.io/hostname

----------------------------------------------------------------
# 上面配置表达的意思是: 新Pod必须要和拥有标签nodeenv=xxx或者nodeenv=yyy的pod在同一node上，显然现在没有这样的pod。

这时可以修改yaml文件，添加指定的标签
  affinity:  #亲和性设置
    podAffinity: #设置pod亲和性
      requiredDuringSchedulingIgnoredDuringExecution: # 硬限制
      - labelSelector:
          matchExpressions: # 匹配env的值在["xxx","yyy"]中的标签
          - key: podenv
            operator: In
            values: ["pro","yyy"]
        topologyKey: kubernetes.io/hostname

软限制案例

• 软限制案例跟硬限制类似

3.3 PodAntiAffinity（Pod反亲和性）

PodAntiAffinity主要实现以运行的Pod为参照，让新创建的Pod跟参照pod不在一个区域中的功能。

这边测试继续使用pod亲和度的pod

创建pod-podantiaffinity-required.yaml

apiVersion: v1
kind: Pod
metadata:
  name: pod-podantiaffinity-required
  namespace: dev
spec:
  containers:
  - name: nginx
    image: nginx:1.17.1
  affinity:  #亲和性设置
    podAntiAffinity: #设置pod亲和性
      requiredDuringSchedulingIgnoredDuringExecution: # 硬限制
      - labelSelector:
          matchExpressions: # 匹配podenv的值在["pro"]中的标签
          - key: podenv
            operator: In
            values: ["pro"]
        topologyKey: kubernetes.io/hostname

4、Pod污点（Taints）

前面的调度方式都是站在Pod的角度上，通过在Pod上添加属性，来确定Pod是否要调度到指定的Node上，其实我们也可以站在Node的角度上，通过在Node上添加 污点 属性，来决定是否允许Pod调度过来。

Node被设置上污点之后就和Pod之间存在了一种相斥的关系，进而拒绝Pod调度进来，甚至可以将已经存在的Pod驱逐出去。

污点的格式为：key=value:effect ,key和 value是污点的标签，effect描述污点的作用，支持下面三个选项

• PreferNoSchedule： kubernetes将尽量避免把Pod调度到具有该污点Node上，除非没有其它节点可调度。
• NoSchedule ： kubernetes将不会把Pod调度到具有该污点的Node上，但不会影响当前Node上已经存在的Pod
• NoExecute： kubernetes将不会把Pod调度到具有该污点的Node上，同时也会将Node上已存在的Pod驱离。

#注意！！！
//在我们kubernetes集群中，目前有三个节点，两个node一个master，那为什么schedule不把pod调度到master节点上呢？

//因为master节点就设置了最高级的污点，也就是NoEcxecute。pod无法运行。

 使用kubectl设置和去除污点的命令

kubectl taint nodes node01 key=value:NoExecute
#设置污点

kubectl taint nodes node01 key:NoExecute-
#去除污点

kubectl taint nodes node01 NoExecute-
#去除所有污点

案例演示 

• 准备节点node01（为了演示效果更佳明显，暂停node02节点）
• 为node01节点设置一个污点：tag=ydq:PreferNoSchedule，然后创建Pod1
• 修改node01节点污点：tag=ydq:NoSchedule，然后创建Pod2
• 修改node01节点污点：tag=ydq:NoExecute；然后创建Pod3

kubectl taint nodes node01 key=ydq:PreferNoSchedule
#为node01节点设置一个污点

kubectl run taint1 --image=nginx:1.17.1 -n dev
#创建一个Pod

kubectl get pods -n dev -o wide
#查看pod运行情况

//设置了污点PreferNoschedule，当没有node调度时，它会选择这个污点的node
--------------------------------------------------
kubectl taint nodes node01 key:PreferNoSchedule-
#删除node01节点上的污点

kubectl taint nodes node01 key=ydq:NoSchedule
#重新设置一个新的污点

kubectl run taint2 --image=nginx:1.17.1 -n dev
#再创建一个pod

kubectl get pods -n dev
#查看pod的运行情况

//设置了污点NoSchedule，旧的pod可正常运行，新的Pod无法加入到此node
-------------------------------------------------------
kubectl taint nodes node01 key:NoSchedule-
#删除node01上的污点

kubectl taint nodes node01 key=ydq:NoExecute
#重新设置一个新污点

kubectl run taint3 --image=nginx:1.17.1 -n dev
#再创建一个Pod

kubectl get pods -n dev
#查看pod的运行情况

//设置了污点NoExecute，新的老的Pod都不能在此node上运行。

 

5、Pod容忍（Toleration）

上面介绍了污点的作用，我们可以在node上添加污点用于拒绝pod调度上来，但是如果就是想将一个pod调度到一个有污点的node上去，这时候应该怎么做呢？这就要使用到容忍。

 

#污点就是拒绝，容忍就是忽略，Node通过污点拒绝Pod调度上去，Pod通过容忍忽略拒绝

#查看容忍的详细配置
kubectl explain pod.spec.tolerations
....
FIELDS:
   key       //对应着要容忍的污点的键，空意味着匹配所有的键
   value     //对应着要容忍的污点的值
   operator  //key-value的运算符，支持Equal和Exists（默认）
   effect    //对应污点的effect，空意味着匹配所有影响
   tolerationSeconds   //容忍时间, 当effect为NoExecute时生效，表示pod在Node上的停留时间

 

下面创建一个两个pod，一个没有加容忍的pod，一个加了容忍的pod，进行测试

创建pod-toleration.yaml

apiVersion: v1
kind: Pod
metadata:
  name: pod-toleration
  namespace: dev
spec:
  containers:
  - name: nginx
    image: nginx:1.17.1
  tolerations:            # 添加容忍
  - key: "key"            # 要容忍的污点的key
    operator: "Equal"     # 操作符
    value: "ydq"        # 容忍的污点的value
    effect: "NoExecute"   # 添加容忍的规则，这里必须和标记的污点规则相同

 

#注意事项

1、当不指定key 值时，表示容器所有的污点 key
 tolerations:
 - operator: "Exists"
 
2、当不指定effect 值时，表示容忍所有的污点作用
 tolerations:
 - key: "key"
   operator: "Exists"

五、总结