详细介绍Pod资源的各种配置(YAML)和原理。

1 Pod的介绍

1.1 Pod的结构

Pod的结构.png

  • 每个Pod中都包含一个或者多个容器,这些容器可以分为两类:
  • ① 用户程序所在的容器,数量可多可少。
  • ② Pause容器,这是每个Pod都会有的一个根容器,它的作用有两个:
    • 可以以它为依据,评估整个Pod的健康状况。
    • 可以在根容器上设置IP地址,其它容器都共享此IP(Pod的IP),以实现Pod内部的网络通信(这里是Pod内部的通讯,Pod之间的通讯采用虚拟二层网络技术来实现,我们当前环境使用的是Flannel)。

1.2 Pod定义

  • 下面是Pod的资源清单:
  1. apiVersion: v1 #必选,版本号,例如v1
  2. kind: Pod   #必选,资源类型,例如 Pod
  3. metadata:   #必选,元数据
  4. name: string #必选,Pod名称
  5. namespace: string #Pod所属的命名空间,默认为"default"
  6. labels:    #自定义标签列表
  7. - name: string  
  8. spec: #必选,Pod中容器的详细定义
  9. containers: #必选,Pod中容器列表
  10. - name: string #必选,容器名称
  11. image: string #必选,容器的镜像名称
  12. imagePullPolicy: [ Always|Never|IfNotPresent ] #获取镜像的策略
  13. command: [string] #容器的启动命令列表,如不指定,使用打包时使用的启动命令
  14. args: [string] #容器的启动命令参数列表
  15. workingDir: string #容器的工作目录
  16. volumeMounts: #挂载到容器内部的存储卷配置
  17. - name: string #引用pod定义的共享存储卷的名称,需用volumes[]部分定义的的卷名
  18. mountPath: string #存储卷在容器内mount的绝对路径,应少于512字符
  19. readOnly: boolean #是否为只读模式
  20. ports: #需要暴露的端口库号列表
  21. - name: string #端口的名称
  22. containerPort: int #容器需要监听的端口号
  23. hostPort: int #容器所在主机需要监听的端口号,默认与Container相同
  24. protocol: string #端口协议,支持TCP和UDP,默认TCP
  25. env: #容器运行前需设置的环境变量列表
  26. - name: string #环境变量名称
  27. value: string #环境变量的值
  28. resources: #资源限制和请求的设置
  29. limits: #资源限制的设置
  30. cpu: string #Cpu的限制,单位为core数,将用于docker run --cpu-shares参数
  31. memory: string #内存限制,单位可以为Mib/Gib,将用于docker run --memory参数
  32. requests: #资源请求的设置
  33. cpu: string #Cpu请求,容器启动的初始可用数量
  34. memory: string #内存请求,容器启动的初始可用数量
  35. lifecycle: #生命周期钩子
  36. postStart: #容器启动后立即执行此钩子,如果执行失败,会根据重启策略进行重启
  37. preStop: #容器终止前执行此钩子,无论结果如何,容器都会终止
  38. livenessProbe: #对Pod内各容器健康检查的设置,当探测无响应几次后将自动重启该容器
  39. exec:   #对Pod容器内检查方式设置为exec方式
  40. command: [string] #exec方式需要制定的命令或脚本
  41. httpGet: #对Pod内个容器健康检查方法设置为HttpGet,需要制定Path、port
  42. path: string
  43. port: number
  44. host: string
  45. scheme: string
  46. HttpHeaders:
  47. - name: string
  48. value: string
  49. tcpSocket: #对Pod内个容器健康检查方式设置为tcpSocket方式
  50. port: number
  51. initialDelaySeconds: 0 #容器启动完成后首次探测的时间,单位为秒
  52. timeoutSeconds: 0    #对容器健康检查探测等待响应的超时时间,单位秒,默认1秒
  53. periodSeconds: 0    #对容器监控检查的定期探测时间设置,单位秒,默认10秒一次
  54. successThreshold: 0
  55. failureThreshold: 0
  56. securityContext:
  57. privileged: false
  58. restartPolicy: [Always | Never | OnFailure] #Pod的重启策略
  59. nodeName: <string> #设置NodeName表示将该Pod调度到指定到名称的node节点上
  60. nodeSelector: obeject #设置NodeSelector表示将该Pod调度到包含这个label的node上
  61. imagePullSecrets: #Pull镜像时使用的secret名称,以key:secretkey格式指定
  62. - name: string
  63. hostNetwork: false #是否使用主机网络模式,默认为false,如果设置为true,表示使用宿主机网络
  64. volumes: #在该pod上定义共享存储卷列表
  65. - name: string #共享存储卷名称 (volumes类型有很多种)
  66. emptyDir: {} #类型为emtyDir的存储卷,与Pod同生命周期的一个临时目录。为空值
  67. hostPath: string #类型为hostPath的存储卷,表示挂载Pod所在宿主机的目录
  68. path: string    #Pod所在宿主机的目录,将被用于同期中mount的目录
  69. secret:    #类型为secret的存储卷,挂载集群与定义的secret对象到容器内部
  70. scretname: string
  71. items:
  72. - key: string
  73. path: string
  74. configMap: #类型为configMap的存储卷,挂载预定义的configMap对象到容器内部
  75. name: string
  76. items:
  77. - key: string
  78. path: string
  • 语法:查看每种资源的可配置项
  1. # 查看某种资源可以配置的一级配置
  2. kubectl explain 资源类型
  3. # 查看属性的子属性
  4. kubectl explain 资源类型.属性
  • 示例:查看资源类型为pod的可配置项
  1. kubectl explain pod

查看资源类型为pod的可配置项.png

  • 示例:查看资源类型为Pod的metadata的属性的可配置项
  1. kubectl explain pod.metadata

查看资源类型为Pod的metadata的属性的可配置项.png

在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 :根据NodeSelector中定义的信息选择该Pod调度到包含这些Label的Node上。
    • hostNetwork :是否使用主机网络模式,默认为false,如果设置为true,表示使用宿主机网络。
    • volumes <[]Object> :存储卷,用于定义Pod上面挂载的存储信息。
    • restartPolicy :重启策略,表示Pod在遇到故障的时候的处理策略。

    2 Pod的配置

    2.1 概述

    • 本小节主要来研究pod.spec.containers属性,这也是Pod配置中最为关键的一项配置。
    • 示例:查看pod.spec.containers的可选配置项
    1. kubectl explain pod.spec.containers
    1. # 返回的重要属性
    2. KIND: Pod
    3. VERSION: v1
    4. RESOURCE: containers <[]Object> # 数组,代表可以有多个容器FIELDS:
    5. name <string> # 容器名称
    6. image <string> # 容器需要的镜像地址
    7. imagePullPolicy <string> # 镜像拉取策略
    8. command <[]string> # 容器的启动命令列表,如不指定,使用打包时使用的启动命令
    9. args <[]string> # 容器的启动命令需要的参数列表
    10. env <[]Object> # 容器环境变量的配置
    11. ports <[]Object> # 容器需要暴露的端口号列表
    12. resources <Object> # 资源限制和资源请求的设置

    2.2 基本配置

    • 创建pod-base.yaml文件,内容如下:
    1. apiVersion: v1
    2. kind: Pod
    3. metadata:
    4. name: pod-base
    5. namespace: dev
    6. labels:
    7. user: xudaxian
    8. spec:
    9. containers:
    10. - name: nginx # 容器名称
    11. image: nginx:1.17.1 # 容器需要的镜像地址
    12. - name: busybox # 容器名称
    13. image: busybox:1.30 # 容器需要的镜像地址
    • 上面定义了一个比较简单的Pod的配置,里面有两个容器:
      • nginx:用的是1.17.1版本的nginx镜像创建(nginx是一个轻量级的web容器)。
      • busybox:用的是1.30版本的busybox镜像创建(busybox是一个小巧的linux命令集合)。
    • 创建Pod:
    1. kubectl apply -f pod-base.yaml
    • 查看Pod状况:
    1. kubectl get pod -n dev

    Pod基本配置之查看Pod状况.png

    • 通过describe查看内部的详情:
    1. # 此时已经运行起来了一个基本的Pod,虽然它暂时有问题
    2. kubectl describe pod pod-base -n dev

    Pod基本配置之通过describe查看内部的详情.png

    2.3 镜像拉取策略

    • 创建pod-imagepullpolicy.yaml文件,内容如下:
    1. apiVersion: v1
    2. kind: Pod
    3. metadata:
    4. name: pod-imagepullpolicy
    5. namespace: dev
    6. labels:
    7. user: xudaxian
    8. spec:
    9. containers:
    10. - name: nginx # 容器名称
    11. image: nginx:1.17.1 # 容器需要的镜像地址
    12. imagePullPolicy: Always # 用于设置镜像的拉取策略
    13. - name: busybox # 容器名称
    14. image: busybox:1.30 # 容器需要的镜像地址
    • imagePullPolicy:用于设置镜像拉取的策略,kubernetes支持配置三种拉取策略:
      • Always:总是从远程仓库拉取镜像(一直远程下载)。
      • IfNotPresent:本地有则使用本地镜像,本地没有则从远程仓库拉取镜像(本地有就用本地,本地没有就使用远程下载)。
      • Never:只使用本地镜像,从不去远程仓库拉取,本地没有就报错(一直使用本地,没有就报错)。

    默认值说明:

    • 如果镜像tag为具体的版本号,默认策略是IfNotPresent。
    • 如果镜像tag为latest(最终版本),默认策略是Always。
    • 创建Pod:
    1. kubectl apply -f pod-imagepullpolicy.yaml
    • 查看Pod详情:
    1. kubectl describe pod pod-imagepullpolicy -n dev

    Pod镜像拉取之查看Pod详情.png

    2.4 启动命令

    • 在前面的案例中,一直有一个问题没有解决,就是busybox容器一直没有成功运行,那么到底是什么原因导致这个容器的故障的呢?
    • 原来busybox并不是一个程序,而是类似于一个工具类的集合,kubernetes集群启动管理后,它会自动关闭。解决方法就是让其一直在运行,这就用到了command的配置。
    • 创建pod-command.yaml文件,内容如下:
    1. apiVersion: v1
    2. kind: Pod
    3. metadata:
    4. name: pod-command
    5. namespace: dev
    6. labels:
    7. user: xudaxian
    8. spec:
    9. containers:
    10. - name: nginx # 容器名称
    11. image: nginx:1.17.1 # 容器需要的镜像地址
    12. imagePullPolicy: IfNotPresent # 设置镜像拉取策略
    13. - name: busybox # 容器名称
    14. image: busybox:1.30 # 容器需要的镜像地址
    15. command: ["/bin/sh","-c","touch /tmp/hello.txt;while true;do /bin/echo $(date +%T) >> /tmp/hello.txt;sleep 3;done;"]

    command:用于在Pod中的容器初始化完毕之后执行一个命令。 这里稍微解释下command中的命令的意思:

    • “/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秒,向文件写入当前时间
    • 创建Pod:
    1. kubectl apply -f pod-command.yaml
    • 查看Pod状态:
    1. kubectl get pod pod-command -n dev

    启动命令之查看Pod状态.png

    • 进入Pod中的busybox容器,查看文件内容:
    1. # 在容器中执行命令
    2. # kubectl exec -it pod的名称 -n 命名空间 -c 容器名称 /bin/sh
    3. kubectl exec -it pod-command -n dev -c busybox /bin/sh

    启动命令之进入Pod中的busybox容器,查看文件内容.png

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

    • 如果command和args均没有写,那么用Dockerfile的配置。
    • 如果command写了,但是args没有写,那么Dockerfile默认的配置会被忽略,执行注入的command。
    • 如果command没有写,但是args写了,那么Dockerfile中配置的ENTRYPOINT命令会被执行,使用当前args的参数。
    • 如果command和args都写了,那么Dockerfile中的配置会被忽略,执行command并追加上args参数。

    2.5 环境变量(不推荐)

    • 创建pod-evn.yaml文件,内容如下:
    1. apiVersion: v1
    2. kind: Pod
    3. metadata:
    4. name: pod-env
    5. namespace: dev
    6. labels:
    7. user: xudaxian
    8. spec:
    9. containers:
    10. - name: nginx # 容器名称
    11. image: nginx:1.17.1 # 容器需要的镜像地址
    12. imagePullPolicy: IfNotPresent # 设置镜像拉取策略
    13. - name: busybox # 容器名称
    14. image: busybox:1.30 # 容器需要的镜像地址
    15. command: ["/bin/sh","-c","touch /tmp/hello.txt;while true;do /bin/echo $(date +%T) >> /tmp/hello.txt;sleep 3;done;"]
    16. env:
    17. - name: "username"
    18. value: "admin"
    19. - name: "password"
    20. value: "123456"

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

    • 创建Pod:
    1. kubectl create -f pod-env.yaml

    环境变量之创建Pod.png

    • 进入容器,输出环境变量:
    1. kubectl exec -it pod-env -n dev -c busybox -it /bin/sh

    环境变量之进入容器输出环境变量.png

    此种方式不推荐,推荐将这些配置单独存储在配置文件中,后面介绍。

    2.6 端口设置

    • 查看ports支持的子选项:
    1. kubectl explain pod.spec.containers.ports

    查看ports支持的子选项.png

    1. KIND: Pod
    2. VERSION: v1
    3. RESOURCE: ports <[]Object>
    4. FIELDS:
    5. name <string> # 端口名称,如果指定,必须保证name在pod中是唯一的
    6. containerPort <integer> # 容器要监听的端口(0<x<65536)
    7. hostPort <integer> # 容器要在主机上公开的端口,如果设置,主机上只能运行容器的一个副本(一般省略)
    8. hostIP <string> # 要将外部端口绑定到的主机IP(一般省略)
    9. protocol <string> # 端口协议。必须是UDP、TCP或SCTP。默认为“TCP”
    • 创建pod-ports.yaml文件,内容如下:
    1. apiVersion: v1
    2. kind: Pod
    3. metadata:
    4. name: pod-ports
    5. namespace: dev
    6. labels:
    7. user: xudaxian
    8. spec:
    9. containers:
    10. - name: nginx # 容器名称
    11. image: nginx:1.17.1 # 容器需要的镜像地址
    12. imagePullPolicy: IfNotPresent # 设置镜像拉取策略
    13. ports:
    14. - name: nginx-port # 端口名称,如果执行,必须保证name在Pod中是唯一的
    15. containerPort: 80 # 容器要监听的端口 (0~65536)
    16. protocol: TCP # 端口协议
    • 创建Pod:
    1. kubectl create -f pod-ports.yaml

    端口设置之创建Pod.png

    访问Pod中的容器中的程序使用的是PodIp:containerPort。

    2.7 资源配额

    • 容器中的程序要运行,肯定会占用一定的资源,比如CPU和内存等,如果不对某个容器的资源做限制,那么它就可能吃掉大量的资源,导致其他的容器无法运行。针对这种情况,kubernetes提供了对内存和CPU的资源进行配额的机制,这种机制主要通过resources选项实现,它有两个子选项:
      • limits:用于限制运行的容器的最大占用资源,当容器占用资源超过limits时会被终止,并进行重启。
      • requests:用于设置容器需要的最小资源,如果环境资源不够,容器将无法启动。
    • 可以通过上面的两个选项设置资源的上下限。
    • 创建pod-resoures.yaml文件,内容如下:
    1. apiVersion: v1
    2. kind: Pod
    3. metadata:
    4. name: pod-resoures
    5. namespace: dev
    6. labels:
    7. user: xudaxian
    8. spec:
    9. containers:
    10. - name: nginx # 容器名称
    11. image: nginx:1.17.1 # 容器需要的镜像地址
    12. imagePullPolicy: IfNotPresent # 设置镜像拉取策略
    13. ports: # 端口设置
    14. - name: nginx-port # 端口名称,如果执行,必须保证name在Pod中是唯一的
    15. containerPort: 80 # 容器要监听的端口 (0~65536)
    16. protocol: TCP # 端口协议
    17. resources: # 资源配额
    18. limits: # 限制资源的上限
    19. cpu: "2" # CPU限制,单位是core数
    20. memory: "10Gi" # 内存限制
    21. requests: # 限制资源的下限
    22. cpu: "1" # CPU限制,单位是core数
    23. memory: "10Mi" # 内存限制

    cpu:core数,可以为整数或小数。 memory:内存大小,可以使用Gi、Mi、G、M等形式。

    • 创建Pod:
    1. kubectl create -f pod-resource.yaml

    资源配额之创建Pod.png

    • 查看发现Pod运行正常:
    1. kubectl get pod pod-resoures -n dev

    资源配额之查看发现Pod运行正常.png

    • 接下来,停止Pod:
    1. kubectl delete -f pod-resource.yaml
    • 编辑Pod,修改resources.requests.memory的值为10Gi:
    1. apiVersion: v1
    2. kind: Pod
    3. metadata:
    4. name: pod-resoures
    5. namespace: dev
    6. labels:
    7. user: xudaxian
    8. spec:
    9. containers:
    10. - name: nginx # 容器名称
    11. image: nginx:1.17.1 # 容器需要的镜像地址
    12. imagePullPolicy: IfNotPresent # 设置镜像拉取策略
    13. ports: # 端口设置
    14. - name: nginx-port # 端口名称,如果执行,必须保证name在Pod中是唯一的
    15. containerPort: 80 # 容器要监听的端口 (0~65536)
    16. protocol: TCP # 端口协议
    17. resources: # 资源配额
    18. limits: # 限制资源的上限
    19. cpu: "2" # CPU限制,单位是core数
    20. memory: "10Gi" # 内存限制
    21. requests: # 限制资源的下限
    22. cpu: "1" # CPU限制,单位是core数
    23. memory: "10Gi" # 内存限制
    • 再次启动Pod:
    1. kubectl create -f pod-resource.yaml
    • 查看Pod状态,发现Pod启动失败:
    1. kubectl get pod pod-resoures -n dev -o wide

    资源配额之查看Pod状态,发现Pod启动失败.png

    • 查看Pod详情会发现,如下提示:
    1. kubectl describe pod pod-resoures -n dev

    资源配额之查看Pod详情发现内存不足.png

    3 Pod的生命周期

    3.1 概述

    • 我们一般将Pod对象从创建到终止的这段时间范围称为Pod的生命周期,它主要包含下面的过程:
      • Pod创建过程。
      • 运行初始化容器(init container)过程。
      • 运行主容器(main container):
        • 容器启动后钩子(post start)、容器终止前钩子(pre stop)。
        • 容器的存活性探测(liveness probe)、就绪性探测(readiness probe)。
      • Pod终止过程。

    Pod的生命周期.png

    • 在整个生命周期中,Pod会出现5种状态(相位),分别如下:
      • 挂起(Pending):API Server已经创建了Pod资源对象,但它尚未被调度完成或者仍处于下载镜像的过程中。
      • 运行中(Running):Pod已经被调度到某节点,并且所有容器都已经被kubelet创建完成。
      • 成功(Succeeded):Pod中的所有容器都已经成功终止并且不会被重启。
      • 失败(Failed):所有容器都已经终止,但至少有一个容器终止失败,即容器返回了非0值的退出状态。
      • 未知(Unknown):API Server无法正常获取到Pod对象的状态信息,通常由于网络通信失败所导致。

    3.2 创建和终止

    3.2.1 Pod的创建过程

    Pod的创建过程.jpg

    • ① 用户通过kubectl或其他的api客户端提交需要创建的Pod信息给API Server。
    • ② API Server开始生成Pod对象的信息,并将信息存入etcd,然后返回确认信息至客户端。
    • ③ API Server开始反映etcd中的Pod对象的变化,其它组件使用watch机制来跟踪检查API Server上的变动。
    • ④ Scheduler发现有新的Pod对象要创建,开始为Pod分配主机并将结果信息更新至API Server。
    • ⑤ Node节点上的kubelet发现有Pod调度过来,尝试调度Docker启动容器,并将结果回送至API Server。
    • ⑥ API Server将接收到的Pod状态信息存入到etcd中。

    3.2.2 Pod的终止过程

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

    3.3 初始化容器

    • 初始化容器是在Pod的主容器启动之前要运行的容器,主要是做一些主容器的前置工作,它具有两大特征:
      • ① 初始化容器必须运行完成直至结束,如果某个初始化容器运行失败,那么kubernetes需要重启它直至成功完成。
      • ② 初始化容器必须按照定义的顺序执行,当且仅当前一个成功之后,后面的一个才能运行。
    • 初始化容器有很多的应用场景,下面列出的是最常见的几个:
      • 提供主容器镜像中不具备的工具程序或自定义代码。
      • 初始化容器要先于应用容器串行启动并运行完成,因此可用于延后应用容器的启动直至其依赖的条件得到满足。
    • 接下来做一个案例,模拟下面这个需求:
      • 假设要以主容器来运行Nginx,但是要求在运行Nginx之前要能够连接上MySQL和Redis所在的服务器。
      • 为了简化测试,事先规定好MySQL和Redis所在的IP地址分别为192.168.18.103和192.168.18.104(注意,这两个IP都不能ping通,因为环境中没有这两个IP)。
    • 创建pod-initcontainer.yaml文件,内容如下:
    1. apiVersion: v1
    2. kind: Pod
    3. metadata:
    4. name: pod-initcontainer
    5. namespace: dev
    6. labels:
    7. user: xudaxian
    8. spec:
    9. containers: # 容器配置
    10. - name: nginx
    11. image: nginx:1.17.1
    12. imagePullPolicy: IfNotPresent
    13. ports:
    14. - name: nginx-port
    15. containerPort: 80
    16. protocol: TCP
    17. resources:
    18. limits:
    19. cpu: "2"
    20. memory: "10Gi"
    21. requests:
    22. cpu: "1"
    23. memory: "10Mi"
    24. initContainers: # 初始化容器配置
    25. - name: test-mysql
    26. image: busybox:1.30
    27. command: ["sh","-c","until ping 192.168.18.103 -c 1;do echo waiting for mysql ...;sleep 2;done;"]
    28. securityContext:
    29. privileged: true # 使用特权模式运行容器
    30. - name: test-redis
    31. image: busybox:1.30
    32. command: ["sh","-c","until ping 192.168.18.104 -c 1;do echo waiting for redis ...;sleep 2;done;"]
    • 创建Pod:
    1. kubectl create -f pod-initcontainer.yaml

    初始化容器之创建Pod.png

    • 查看Pod状态:
    1. kubectl describe pod pod-initcontainer -n dev

    初始化容器之查看Pod状态.png

    • 动态查看Pod:
    1. kubectl get pod pod-initcontainer -n dev -w

    初始化容器之动态查看Pod.png

    • 接下来,新开一个shell,为当前服务器(192.168.18.100)新增两个IP,观察Pod的变化:
    1. ifconfig ens33:1 192.168.18.103 netmask 255.255.255.0 up
    1. ifconfig ens33:2 192.168.18.104 netmask 255.255.255.0 up

    初始化容器之动态查看Pod2.png

    3.4 钩子函数

    • 钩子函数能够感知自身生命周期中的事件,并在相应的时刻到来时运行用户指定的程序代码。
    • kubernetes在主容器启动之后和停止之前提供了两个钩子函数:
      • post start:容器创建之后执行,如果失败会重启容器。
      • pre stop:容器终止之前执行,执行完成之后容器将成功终止,在其完成之前会阻塞删除容器的操作。
    • 钩子处理器支持使用下面的三种方式定义动作:

      • ① exec命令:在容器内执行一次命令。

        1. ……
        2. lifecycle:
        3. postStart:
        4. exec:
        5. command:
        6. - cat
        7. - /tmp/healthy
        8. ……
      • ② tcpSocket:在当前容器尝试访问指定的socket。

        1. ……
        2. lifecycle:
        3. postStart:
        4. tcpSocket:
        5. port: 8080
        6. ……
      • ③ httpGet:在当前容器中向某url发起HTTP请求。

        1. ……
        2. lifecycle:
        3. postStart:
        4. httpGet:
        5. path: / #URI地址
        6. port: 80 #端口号
        7. host: 192.168.109.100 #主机地址
        8. scheme: HTTP #支持的协议,http或者https
        9. ……
    • 接下来,以exec方式为例,演示下钩子函数的使用,创建pod-hook-exec.yaml文件,内容如下:

    1. apiVersion: v1
    2. kind: Pod
    3. metadata:
    4. name: pod-hook-exec
    5. namespace: dev
    6. labels:
    7. user: xudaxian
    8. spec:
    9. containers: # 容器配置
    10. - name: nginx
    11. image: nginx:1.17.1
    12. imagePullPolicy: IfNotPresent
    13. ports:
    14. - name: nginx-port
    15. containerPort: 80
    16. protocol: TCP
    17. resources:
    18. limits:
    19. cpu: "2"
    20. memory: "10Gi"
    21. requests:
    22. cpu: "1"
    23. memory: "10Mi"
    24. lifecycle: # 生命周期配置
    25. postStart: # 容器创建之后执行,如果失败会重启容器
    26. exec: # 在容器启动的时候,执行一条命令,修改掉Nginx的首页内容
    27. command: ["/bin/sh","-c","echo postStart ... > /usr/share/nginx/html/index.html"]
    28. preStop: # 容器终止之前执行,执行完成之后容器将成功终止,在其完成之前会阻塞删除容器的操作
    29. exec: # 在容器停止之前停止Nginx的服务
    30. command: ["/usr/sbin/nginx","-s","quit"]
    • 创建Pod:
    1. kubectl create -f pod-hook-exec.yaml

    钩子函数之创建Pod.png

    • 查看Pod:
    1. kubectl get pod pod-hook-exec -n dev -o wide

    钩子函数之查看Pod.png

    • 访问Pod:
    1. curl 10.244.1.11

    钩子函数之访问Pod.png

    3.5 容器探测

    3.5.1 概述

    • 容器探测用于检测容器中的应用实例是否正常工作,是保障业务可用性的一种传统机制。如果经过探测,实例的状态不符合预期,那么kubernetes就会把该问题实例“摘除”,不承担业务流量。kubernetes提供了两种探针来实现容器探测,分别是:
      • liveness probes:存活性探测,用于检测应用实例当前是否处于正常运行状态,如果不是,k8s会重启容器。
      • readiness probes:就绪性探测,用于检测应用实例是否可以接受请求,如果不能,k8s不会转发流量。

    livenessProbe:存活性探测,决定是否重启容器。 readinessProbe:就绪性探测,决定是否将请求转发给容器。

    k8s在1.16版本之后新增了startupProbe探针,用于判断容器内应用程序是否已经启动。如果配置了startupProbe探针,就会先禁止其他的探针,直到startupProbe探针成功为止,一旦成功将不再进行探测。

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

      • ① exec命令:在容器内执行一次命令,如果命令执行的退出码为0,则认为程序正常,否则不正常。

        1. ……
        2. livenessProbe:
        3. exec:
        4. command:
        5. - cat
        6. - /tmp/healthy
        7. ……
      • ② tcpSocket:将会尝试访问一个用户容器的端口,如果能够建立这条连接,则认为程序正常,否则不正常。

        1. ……
        2. livenessProbe:
        3. tcpSocket:
        4. port: 8080
        5. ……
      • ③ httpGet:调用容器内web应用的URL,如果返回的状态码在200和399之前,则认为程序正常,否则不正常。

        1. ……
        2. livenessProbe:
        3. httpGet:
        4. path: / #URI地址
        5. port: 80 #端口号
        6. host: 127.0.0.1 #主机地址
        7. scheme: HTTP #支持的协议,http或者https
        8. ……

    3.5.2 exec方式

    • 创建pod-liveness-exec.yaml文件,内容如下:
    1. apiVersion: v1
    2. kind: Pod
    3. metadata:
    4. name: pod-liveness-exec
    5. namespace: dev
    6. labels:
    7. user: xudaxian
    8. spec:
    9. containers: # 容器配置
    10. - name: nginx
    11. image: nginx:1.17.1
    12. imagePullPolicy: IfNotPresent
    13. ports:
    14. - name: nginx-port
    15. containerPort: 80
    16. protocol: TCP
    17. livenessProbe: # 存活性探针
    18. exec:
    19. command: ["/bin/cat","/tmp/hello.txt"] # 执行一个查看文件的命令,必须失败,因为根本没有这个文件
    • 创建Pod:
    1. kubectl create -f pod-liveness-exec.yaml

    容器探测之exec方式创建Pod.png

    • 查看Pod详情:
    1. kubectl describe pod pod-liveness-exec -n dev

    容器探测之exec方式查看Pod详情.png

    • 观察上面的信息就会发现nginx容器启动之后就进行了健康检查。
    • 检查失败之后,容器被kill掉,然后尝试进行重启,这是重启策略的作用。
    • 稍等一会之后,再观察Pod的信息,就会看到RESTARTS不再是0,而是一直增长。
    • 查看Pod信息:
    1. kubectl get pod pod-liveness-exec -n dev

    容器探测之exec方式查看Pod信息.png

    3.5.3 tcpSocket方式

    • 创建pod-liveness-tcpsocket.yaml文件,内容如下:
    1. apiVersion: v1
    2. kind: Pod
    3. metadata:
    4. name: pod-liveness-tcpsocket
    5. namespace: dev
    6. labels:
    7. user: xudaxian
    8. spec:
    9. containers: # 容器配置
    10. - name: nginx
    11. image: nginx:1.17.1
    12. imagePullPolicy: IfNotPresent
    13. ports:
    14. - name: nginx-port
    15. containerPort: 80
    16. protocol: TCP
    17. livenessProbe: # 存活性探针
    18. tcpSocket:
    19. port: 8080 # 尝试访问8080端口,必须失败,因为Pod内部只有一个Nginx容器,而且只是监听了80端口
    • 创建Pod:
    1. kubectl create -f pod-liveness-tcpsocket.yaml

    容器探测之tcpSocket方式创建Pod.png

    • 查看Pod详情:
    1. kubectl describe pod pod-liveness-tcpsocket -n dev

    容器探测之tcpSocket方式查看Pod详情.png

    观察上面的信息,发现尝试访问8080端口,但是失败了 稍等一会之后,再观察Pod的信息,就会看到RESTARTS不再是0,而是一直增长。

    • 查看Pod信息:
    1. kubectl get pod pod-liveness-tcpsocket -n dev

    容器探测之tcpSocket方式查看Pod信息.png

    3.5.4 httpGet方式

    • 创建pod-liveness-httpget.yaml文件,内容如下:
    1. apiVersion: v1
    2. kind: Pod
    3. metadata:
    4. name: pod-liveness-httpget
    5. namespace: dev
    6. labels:
    7. user: xudaxian
    8. spec:
    9. containers: # 容器配置
    10. - name: nginx
    11. image: nginx:1.17.1
    12. imagePullPolicy: IfNotPresent
    13. ports:
    14. - name: nginx-port
    15. containerPort: 80
    16. protocol: TCP
    17. livenessProbe: # 存活性探针
    18. httpGet: # 其实就是访问http://127.0.0.1:80/hello
    19. port: 80 # 端口号
    20. scheme: HTTP # 支持的协议,HTTP或HTTPS
    21. path: /hello # URI地址
    22. host: 127.0.0.1 # 主机地址
    • 创建Pod:
    1. kubectl create -f pod-liveness-httpget.yaml

    容器探测之httpGet方式创建Pod.png

    • 查看Pod详情:
    1. kubectl describe pod pod-liveness-httpget -n dev

    容器探测之httpGet方式查看Pod详情.png

    • 查看Pod信息:
    1. kubectl get pod pod-liveness-httpget -n dev

    容器探测之httpGet方式查看Pod信息.png

    3.5.5 容器探测的补充

    • 上面已经使用了livenessProbe演示了三种探测方式,但是查看livenessProbe的子属性,会发现除了这三种方式,还有一些其他的配置。
    1. kubectl explain pod.spec.containers.livenessProbe

    容器探测补充.png

    FIELDS: exec tcpSocket
    httpGet
    initialDelaySeconds # 容器启动后等待多少秒执行第一次探测 timeoutSeconds # 探测超时时间。默认1秒,最小1秒 periodSeconds # 执行探测的频率。默认是10秒,最小1秒 failureThreshold # 连续探测失败多少次才被认定为失败。默认是3。最小值是1 successThreshold # 连续探测成功多少次才被认定为成功。默认是1

    3.6 重启策略

    • 在容器探测中,一旦容器探测出现了问题,kubernetes就会对容器所在的Pod进行重启,其实这是由Pod的重启策略决定的,Pod的重启策略有3种,分别如下:
      • Always:容器失效时,自动重启该容器,默认值。
      • OnFailure:容器终止运行且退出码不为0时重启。
      • Never:不论状态如何,都不重启该容器。
    • 重启策略适用于Pod对象中的所有容器,首次需要重启的容器,将在其需要的时候立即进行重启,随后再次重启的操作将由kubelet延迟一段时间后进行,且反复的重启操作的延迟时长以此为10s、20s、40s、80s、160s和300s,300s是最大的延迟时长。
    • 创建pod-restart-policy.yaml文件,内容如下:
    1. apiVersion: v1
    2. kind: Pod
    3. metadata:
    4. name: pod-restart-policy
    5. namespace: dev
    6. labels:
    7. user: xudaxian
    8. spec:
    9. containers: # 容器配置
    10. - name: nginx
    11. image: nginx:1.17.1
    12. imagePullPolicy: IfNotPresent
    13. ports:
    14. - name: nginx-port
    15. containerPort: 80
    16. protocol: TCP
    17. livenessProbe: # 存活性探测
    18. httpGet:
    19. port: 80
    20. path: /hello
    21. host: 127.0.0.1
    22. scheme: HTTP
    23. restartPolicy: Never # 重启策略
    • 创建Pod:
    1. kubectl create -f pod-restart-policy.yaml

    重启策略之创建Pod.png

    • 查看Pod详情,发现nginx容器启动失败:
    1. kubectl describe pod pod-restart-policy -n dev

    重启策略之查看Pod详情.png

    多等一会,观察Pod的重试次数,发现一直是0,并未重启。

    • 查看Pod:
    1. kubectl get pod pod-restart-policy -n dev

    重启策略之查看Pod.png

    4 Pod的调度

    4.1 概述

    • 在默认情况下,一个Pod在哪个Node节点上运行,是由Scheduler组件采用相应的算法计算出来的,这个过程是不受人工控制的。但是在实际使用中,这并不满足需求,因为很多情况下,我们想控制某些Pod到达某些节点上,那么应该怎么做?这就要求了解kubernetes对Pod的调度规则,kubernetes提供了四大类调度方式。
      • 自动调度:运行在哪个Node节点上完全由Scheduler经过一系列的算法计算得出。
      • 定向调度:NodeName、NodeSelector。
      • 亲和性调度:NodeAffinity、PodAffinity、PodAntiAffinity。
      • 污点(容忍)调度:Taints、Toleration。

    4.2 定向调度

    4.2.1 概述

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

    4.2.2 nodeName

    • nodeName用于强制约束将Pod调度到指定的name的Node节点上。这种方式,其实是直接跳过Scheduler的调度逻辑,直接将Pod调度到指定名称的节点。
    • 创建一个pod-nodename.yaml文件,内容如下:
    1. apiVersion: v1
    2. kind: Pod
    3. metadata:
    4. name: pod-nodename
    5. namespace: dev
    6. labels:
    7. user: xudaxian
    8. spec:
    9. containers: # 容器配置
    10. - name: nginx
    11. image: nginx:1.17.1
    12. imagePullPolicy: IfNotPresent
    13. ports:
    14. - name: nginx-port
    15. containerPort: 80
    16. protocol: TCP
    17. nodeName: k8s-node1 # 指定调度到k8s-node1节点上
    • 创建Pod:
    1. kubectl create -f pod-nodename.yaml

    定向调度之nodeName创建Pod.png

    • 查看Pod:
    1. kubectl get pod pod-nodename -n dev -o wide

    定向调度之nodeName查看Pod.png

    4.2.3 nodeSelector

    • nodeSelector用于将Pod调度到添加了指定标签的Node节点上,它是通过kubernetes的label-selector机制实现的,换言之,在Pod创建之前,会由Scheduler使用MatchNodeSelector调度策略进行label匹配,找出目标node,然后将Pod调度到目标节点,该匹配规则是强制约束。
    • 首先给node节点添加标签:
    1. kubectl label node k8s-node1 nodeenv=pro
    1. kubectl label node k8s-node2 nodeenv=test

    定向调度之nodeSelector添加Label.png

    • 创建pod-nodeselector.yaml文件,内容如下:
    1. apiVersion: v1
    2. kind: Pod
    3. metadata:
    4. name: pod-nodeselector
    5. namespace: dev
    6. spec:
    7. containers: # 容器配置
    8. - name: nginx
    9. image: nginx:1.17.1
    10. imagePullPolicy: IfNotPresent
    11. ports:
    12. - name: nginx-port
    13. containerPort: 80
    14. protocol: TCP
    15. nodeSelector:
    16. nodeenv: pro # 指定调度到具有nodeenv=pro的Node节点上
    • 创建Pod:
    1. kubectl create -f pod-nodeselector.yaml

    定向调度之nodeSelector创建Pod.png

    • 查看Pod:
    1. kubectl get pod pod-nodeselector -n dev -o wide

    定向调度之nodeSelector查看Pod.png

    4.3 亲和性调度

    4.3.1 概述

    • 虽然定向调度的两种方式,使用起来非常方便,但是也有一定的问题,那就是如果没有满足条件的Node,那么Pod将不会被运行,即使在集群中还有可用的Node列表也不行,这就限制了它的使用场景。
    • 基于上面的问题,kubernetes还提供了一种亲和性调度(Affinity)。它在nodeSelector的基础之上进行了扩展,可以通过配置的形式,实现优先选择满足条件的Node进行调度,如果没有,也可以调度到不满足条件的节点上,使得调度更加灵活。
    • Affinity主要分为三类:
      • nodeAffinity(node亲和性):以Node为目标,解决Pod可以调度到那些Node的问题。
      • podAffinity(pod亲和性):以Pod为目标,解决Pod可以和那些已存在的Pod部署在同一个拓扑域中的问题。
      • podAntiAffinity(pod反亲和性):以Pod为目标,解决Pod不能和那些已经存在的Pod部署在同一拓扑域中的问题。

    关于亲和性和反亲和性的使用场景的说明:

    • 亲和性:如果两个应用频繁交互,那么就有必要利用亲和性让两个应用尽可能的靠近,这样可以较少因网络通信而带来的性能损耗。
    • 反亲和性:当应用采用多副本部署的时候,那么就有必要利用反亲和性让各个应用实例打散分布在各个Node上,这样可以提高服务的高可用性。

    4.3.2 nodeAffinity

    • 查看nodeAffinity的可选配置项:
    1. pod.spec.affinity.nodeAffinity
    2. requiredDuringSchedulingIgnoredDuringExecution Node节点必须满足指定的所有规则才可以,相当于硬限制
    3. nodeSelectorTerms 节点选择列表
    4. matchFields 按节点字段列出的节点选择器要求列表
    5. matchExpressions 按节点标签列出的节点选择器要求列表(推荐)
    6. key 键
    7. values 值
    8. operator 关系符 支持Exists, DoesNotExist, In, NotIn, Gt, Lt
    9. preferredDuringSchedulingIgnoredDuringExecution 优先调度到满足指定的规则的Node,相当于软限制 (倾向)
    10. preference 一个节点选择器项,与相应的权重相关联
    11. matchFields 按节点字段列出的节点选择器要求列表
    12. matchExpressions 按节点标签列出的节点选择器要求列表(推荐)
    13. key 键
    14. values 值
    15. operator 关系符 支持In, NotIn, Exists, DoesNotExist, Gt, Lt
    16. weight 倾向权重,在范围1-100。

    关系符的使用说明:

    1. - matchExpressions:
    2. - key: nodeenv # 匹配存在标签的key为nodeenv的节点
    3. operator: Exists
    4. - key: nodeenv # 匹配标签的key为nodeenv,且value是"xxx"或"yyy"的节点
    5. operator: In
    6. values: ["xxx","yyy"]
    7. - key: nodeenv # 匹配标签的key为nodeenv,且value大于"xxx"的节点
    8. operator: Gt
    9. values: "xxx"
    • 下面演示requiredDuringSchedulingIgnoredDuringExecution:

      • 创建pod-nodeaffinity-required.yaml文件,内容如下:

        1. apiVersion: v1
        2. kind: Pod
        3. metadata:
        4. name: pod-nodeaffinity-required
        5. namespace: dev
        6. spec:
        7. containers: # 容器配置
        8. - name: nginx
        9. image: nginx:1.17.1
        10. imagePullPolicy: IfNotPresent
        11. ports:
        12. - name: nginx-port
        13. containerPort: 80
        14. protocol: TCP
        15. affinity: # 亲和性配置
        16. nodeAffinity: # node亲和性配置
        17. requiredDuringSchedulingIgnoredDuringExecution: # Node节点必须满足指定的所有规则才可以,相当于硬规则,类似于定向调度
        18. nodeSelectorTerms: # 节点选择列表
        19. - matchExpressions:
        20. - key: nodeenv # 匹配存在标签的key为nodeenv的节点,并且value是"xxx"或"yyy"的节点
        21. operator: In
        22. values:
        23. - "xxx"
        24. - "yyy"
      • 创建Pod:

        1. kubectl create -f pod-nodeaffinity-required.yaml

        亲和性调度之node亲和性硬限制创建Pod.png

      • 查看Pod状态(运行失败):

        1. kubectl get pod pod-nodeaffinity-required -n dev -o wide

        亲和性调度之node亲和性硬限制查看Pod状态.png

      • 查看Pod详情(发现调度失败,提示node选择失败):

        1. kubectl describe pod pod-nodeaffinity-required -n dev

        亲和性调度之node亲和性硬限制查看Pod详情.png

      • 删除Pod:

        1. kubectl delete -f pod-nodeaffinity-required.yaml

        亲和性调度之node亲和性硬限制删除Pod.png

      • 修改pod-nodeaffinity-required.yaml文件,内容如下:

        1. apiVersion: v1
        2. kind: Pod
        3. metadata:
        4. name: pod-nodeaffinity-required
        5. namespace: dev
        6. spec:
        7. containers: # 容器配置
        8. - name: nginx
        9. image: nginx:1.17.1
        10. imagePullPolicy: IfNotPresent
        11. ports:
        12. - name: nginx-port
        13. containerPort: 80
        14. protocol: TCP
        15. affinity: # 亲和性配置
        16. nodeAffinity: # node亲和性配置
        17. requiredDuringSchedulingIgnoredDuringExecution: # Node节点必须满足指定的所有规则才可以,相当于硬规则,类似于定向调度
        18. nodeSelectorTerms: # 节点选择列表
        19. - matchExpressions:
        20. - key: nodeenv # 匹配存在标签的key为nodeenv的节点,并且value是"xxx"或"yyy"的节点
        21. operator: In
        22. values:
        23. - "pro"
        24. - "yyy"
      • 再次创建Pod:

        1. kubectl create -f pod-nodeaffinity-required.yaml

        亲和性调度之node亲和性硬限制再次创建Pod.png

      • 再次查看Pod:

        1. kubectl get pod pod-nodeaffinity-required -n dev -o wide

        亲和性调度之node亲和性硬限制再次查看Pod状态.png

    • 下面演示preferredDuringSchedulingIgnoredDuringExecution:

      • 创建pod-nodeaffinity-preferred.yaml文件,内容如下:

        1. apiVersion: v1
        2. kind: Pod
        3. metadata:
        4. name: pod-nodeaffinity-preferred
        5. namespace: dev
        6. spec:
        7. containers: # 容器配置
        8. - name: nginx
        9. image: nginx:1.17.1
        10. imagePullPolicy: IfNotPresent
        11. ports:
        12. - name: nginx-port
        13. containerPort: 80
        14. protocol: TCP
        15. affinity: # 亲和性配置
        16. nodeAffinity: # node亲和性配置
        17. preferredDuringSchedulingIgnoredDuringExecution: # 优先调度到满足指定的规则的Node,相当于软限制 (倾向)
        18. - preference: # 一个节点选择器项,与相应的权重相关联
        19. matchExpressions:
        20. - key: nodeenv
        21. operator: In
        22. values:
        23. - "xxx"
        24. - "yyy"
        25. weight: 1
      • 创建Pod:

        1. kubectl create -f pod-nodeaffinity-preferred.yaml

        亲和性调度之node亲和性软限制创建Pod.png

      • 查看Pod:

        1. kubectl get pod pod-nodeaffinity-preferred -n dev -o wide

        亲和性调度之node亲和性软限制查看Pod.png

    nodeAffinity的注意事项:

    • 如果同时定义了nodeSelector和nodeAffinity,那么必须两个条件都满足,Pod才能运行在指定的Node上。
    • 如果nodeAffinity指定了多个nodeSelectorTerms,那么只需要其中一个能够匹配成功即可。
    • 如果一个nodeSelectorTerms中有多个matchExpressions,则一个节点必须满足所有的才能匹配成功。
    • 如果一个Pod所在的Node在Pod运行期间其标签发生了改变,不再符合该Pod的nodeAffinity的要求,则系统将忽略此变化。

    4.3.3 podAffinity

    • podAffinity主要实现以运行的Pod为参照,实现让新创建的Pod和参照的Pod在一个区域的功能。
    • PodAffinity的可选配置项:
    1. pod.spec.affinity.podAffinity
    2. requiredDuringSchedulingIgnoredDuringExecution 硬限制
    3. namespaces 指定参照pod的namespace
    4. topologyKey 指定调度作用域
    5. labelSelector 标签选择器
    6. matchExpressions 按节点标签列出的节点选择器要求列表(推荐)
    7. key 键
    8. values 值
    9. operator 关系符 支持In, NotIn, Exists, DoesNotExist.
    10. matchLabels 指多个matchExpressions映射的内容
    11. preferredDuringSchedulingIgnoredDuringExecution 软限制
    12. podAffinityTerm 选项
    13. namespaces
    14. topologyKey
    15. labelSelector
    16. matchExpressions
    17. key 键
    18. values 值
    19. operator
    20. matchLabels
    21. weight 倾向权重,在范围1-1

    topologyKey用于指定调度的作用域,例如:

    • 如果指定为kubernetes.io/hostname,那就是以Node节点为区分范围。
    • 如果指定为beta.kubernetes.io/os,则以Node节点的操作系统类型来区分。
    • 演示requiredDuringSchedulingIgnoredDuringExecution。
    • 创建参照Pod过程:

      • 创建pod-podaffinity-target.yaml文件,内容如下:

        1. apiVersion: v1
        2. kind: Pod
        3. metadata:
        4. name: pod-podaffinity-target
        5. namespace: dev
        6. labels:
        7. podenv: pro # 设置标签
        8. spec:
        9. containers: # 容器配置
        10. - name: nginx
        11. image: nginx:1.17.1
        12. imagePullPolicy: IfNotPresent
        13. ports:
        14. - name: nginx-port
        15. containerPort: 80
        16. protocol: TCP
        17. nodeName: k8s-node1 # 将目标pod定向调度到k8s-node1
      • 创建参照Pod:

        1. kubectl create -f pod-podaffinity-target.yaml

        亲和性调度之pod亲和性创建参照Pod.png

      • 查看参照Pod:

        1. kubectl get pod pod-podaffinity-target -n dev -o wide

        亲和性调度之pod亲和性查看参照Pod.png

    • 创建Pod过程:

      • 创建pod-podaffinity-requred.yaml文件,内容如下:

        1. apiVersion: v1
        2. kind: Pod
        3. metadata:
        4. name: pod-podaffinity-requred
        5. namespace: dev
        6. spec:
        7. containers: # 容器配置
        8. - name: nginx
        9. image: nginx:1.17.1
        10. imagePullPolicy: IfNotPresent
        11. ports:
        12. - name: nginx-port
        13. containerPort: 80
        14. protocol: TCP
        15. affinity: # 亲和性配置
        16. podAffinity: # Pod亲和性
        17. requiredDuringSchedulingIgnoredDuringExecution: # 硬限制
        18. - labelSelector:
        19. matchExpressions: # 该Pod必须和拥有标签podenv=xxx或者podenv=yyy的Pod在同一个Node上,显然没有这样的Pod
        20. - key: podenv
        21. operator: In
        22. values:
        23. - "xxx"
        24. - "yyy"
        25. topologyKey: kubernetes.io/hostname
      • 创建Pod:

        1. kubectl create -f pod-podaffinity-requred.yaml

        亲和性调度之pod亲和性创建Pod.png

      • 查看Pod状态,发现没有运行:

        1. kubectl get pod pod-podaffinity-requred -n dev

        亲和性调度之pod亲和性查看Pod.png

      • 查看Pod详情:

        1. kubectl get pod pod-podaffinity-requred -n dev

        亲和性调度之pod亲和性查看Pod详情.png

      • 删除Pod:

        1. kubectl delete -f pod-podaffinity-requred.yaml

        亲和性调度之pod亲和性删除Pod.png

      • 修改pod-podaffinity-requred.yaml文件,内容如下:

        1. apiVersion: v1
        2. kind: Pod
        3. metadata:
        4. name: pod-podaffinity-requred
        5. namespace: dev
        6. spec:
        7. containers: # 容器配置
        8. - name: nginx
        9. image: nginx:1.17.1
        10. imagePullPolicy: IfNotPresent
        11. ports:
        12. - name: nginx-port
        13. containerPort: 80
        14. protocol: TCP
        15. affinity: # 亲和性配置
        16. podAffinity: # Pod亲和性
        17. requiredDuringSchedulingIgnoredDuringExecution: # 硬限制
        18. - labelSelector:
        19. matchExpressions: # 该Pod必须和拥有标签podenv=xxx或者podenv=yyy的Pod在同一个Node上,显然没有这样的Pod
        20. - key: podenv
        21. operator: In
        22. values:
        23. - "pro"
        24. - "yyy"
        25. topologyKey: kubernetes.io/hostname
      • 再次创建Pod:

        1. kubectl create -f pod-podaffinity-requred.yaml

        亲和性调度之pod亲和性再次创建Pod.png

      • 再次查看Pod:

        1. kubectl get pod pod-podaffinity-requred -n dev -o wide

        亲和性调度之pod亲和性再次查看Pod.png

    4.3.4 podAntiAffinity

    • podAntiAffinity主要实现以运行的Pod为参照,让新创建的Pod和参照的Pod不在一个区域的功能。
    • 其配置方式和podAffinity一样,此处不做详细解释。
    • 使用上个案例中的目标Pod:
    1. kubectl get pod -n dev -o wide

    亲和性调度之pod反亲和性使用上个案例中的目标Pod.png

    • 创建pod-podantiaffinity-requred.yaml文件,内容如下:
    1. apiVersion: v1
    2. kind: Pod
    3. metadata:
    4. name: pod-podantiaffinity-requred
    5. namespace: dev
    6. spec:
    7. containers: # 容器配置
    8. - name: nginx
    9. image: nginx:1.17.1
    10. imagePullPolicy: IfNotPresent
    11. ports:
    12. - name: nginx-port
    13. containerPort: 80
    14. protocol: TCP
    15. affinity: # 亲和性配置
    16. podAntiAffinity: # Pod反亲和性
    17. requiredDuringSchedulingIgnoredDuringExecution: # 硬限制
    18. - labelSelector:
    19. matchExpressions:
    20. - key: podenv
    21. operator: In
    22. values:
    23. - "pro"
    24. topologyKey: kubernetes.io/hostname
    • 创建Pod:
    1. kubectl create -f pod-podantiaffinity-requred.yaml

    亲和性调度之pod反亲和性创建Pod.png

    • 查看Pod:
    1. kubectl get pod -n dev -o wide

    亲和性调度之pod反亲和性查看Pod.png

    4.4 污点和容忍

    4.4.1 污点(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驱逐。

    污点的三种格式.png

    • 语法:

      • 设置污点:

        1. kubectl taint node xxx key=value:effect
      • 去除污点:

        1. kubectl taint node xxx key:effect-
      • 去除所有污点:

        1. kubectl taint node xxx key-
      • 查询所有节点的污点:

        1. wget -O jq https://github.com/stedolan/jq/releases/download/jq-1.6/jq-linux64
        1. chmod +x ./jq
        1. cp jq /usr/bin
      • 列出所有节点的污点方式一:

        1. kubectl get nodes -o json | jq '.items[].spec'
      • 列出所有节点的污点方式二:

        1. kubectl get nodes -o json | jq '.items[].spec.taints'
      • 查看指定节点上的污点:

        1. kubectl describe node 节点名称
    • 接下来,演示污点效果:

      • ① 准备节点k8s-node1(为了演示效果更加明显,暂时停止k8s-node2节点)。
      • ② 为k8s-node1节点设置一个污点:tag=xudaxian:PreferNoSchedule,然后创建Pod1(Pod1可以)。
      • ③ 修改k8s-node1节点的污点为:tag=xudaxian:NoSchedule,然后创建Pod2(Pod1可以正常运行,Pod2失败)。
      • ④ 修改k8s-node1节点的污点为:tag=xudaxian:NoExecute,然后创建Pod3(Pod1、Pod2、Pod3失败)。
    • 为k8s-node1设置污点(PreferNoSchedule):
    1. kubectl taint node k8s-node1 tag=xudaxian:PreferNoSchedule

    为k8s-node1设置污点(PreferNoSchedule).png

    • 创建Pod1:
    1. kubectl run pod1 --image=nginx:1.17.1 -n dev

    污点之创建Pod1.png

    • 查看Pod:
    1. kubectl get pod pod1 -n dev -o wide

    污点之查看Pod状态1.png

    • 为k8s-node1取消污点(PreferNoSchedule),并设置污点(NoSchedule):
    1. kubectl taint node k8s-node1 tag:PreferNoSchedule-
    1. kubectl taint node k8s-node1 tag=xudaxian:NoSchedule

    为k8s-node1取消污点(PreferNoSchedule),并设置污点(NoSchedule).png

    • 创建Pod2:
    1. kubectl run pod2 --image=nginx:1.17.1 -n dev

    污点之创建Pod2.png

    • 查看Pod:
    1. kubectl get pod pod1 -n dev -o wide
    1. kubectl get pod pod2 -n dev -o wide

    污点之查看Pod状态2.png

    • 为k8s-node1取消污点(NoSchedule),并设置污点(NoExecute):
    1. kubectl taint node k8s-node1 tag:NoSchedule-
    1. kubectl taint node k8s-node1 tag=xudaxian:NoExecute

    为k8s-node1取消污点(NoSchedule),并设置污点(NoExecute).png

    • 创建Pod3:
    1. kubectl run pod3 --image=nginx:1.17.1 -n dev

    污点之创建Pod3.png

    • 查看Pod:
    1. kubectl get pod pod1 -n dev -o wide
    1. kubectl get pod pod2 -n dev -o wide
    1. kubectl get pod pod3 -n dev -o wide

    污点之查看Pod状态3.png

    使用kubeadm搭建的集群,默认就会给Master节点添加一个污点标记,所以Pod就不会调度到Master节点上。

    4.4.2 容忍(Toleration)

    • 上面介绍了污点的作用,我们可以在Node上添加污点用来拒绝Pod调度上来,但是如果就是想让一个Pod调度到一个有污点的Node上去,这时候应该怎么做?这就需要使用到容忍。

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

    • 容忍的详细配置:
    1. kubectl explain pod.spec.tolerations
    2. ......
    3. FIELDS:
    4. key # 对应着要容忍的污点的键,空意味着匹配所有的键
    5. value # 对应着要容忍的污点的值
    6. operator # key-value的运算符,支持Equal和Exists(默认)
    7. effect # 对应污点的effect,空意味着匹配所有影响
    8. tolerationSeconds # 容忍时间, 当effect为NoExecute时生效,表示pod在Node上的停留时间

    当operator为Equal的时候,如果Node节点有多个Taint,那么Pod每个Taint都需要容忍才能部署上去。 当operator为Exists的时候,有如下的三种写法:

    • 容忍指定的污点,污点带有指定的effect:
    • 容忍指定的污点,不考虑具体的effect:
    • 容忍一切污点(慎用):
    1. tolerations: # 容忍
    2. - key: "tag" # 要容忍的污点的key
    3. operator: Exists # 操作符
    4. effect: NoExecute # 添加容忍的规则,这里必须和标记的污点规则相同
    1. tolerations: # 容忍
    2. - key: "tag" # 要容忍的污点的key
    3. operator: Exists # 操作符
    1. tolerations: # 容忍
    2. - operator: Exists # 操作符
    • 在上面的污点中,已经给k8s-node1打上了NoExecute的污点,此时Pod是调度不上去的,此时可以通过在Pod中添加容忍,将Pod调度上去。
    • 创建pod-toleration.yaml文件,内容如下:
    1. apiVersion: v1
    2. kind: Pod
    3. metadata:
    4. name: pod-toleration
    5. namespace: dev
    6. spec:
    7. containers: # 容器配置
    8. - name: nginx
    9. image: nginx:1.17.1
    10. imagePullPolicy: IfNotPresent
    11. ports:
    12. - name: nginx-port
    13. containerPort: 80
    14. protocol: TCP
    15. tolerations: # 容忍
    16. - key: "tag" # 要容忍的污点的key
    17. operator: Equal # 操作符
    18. value: "xudaxian" # 要容忍的污点的value
    19. effect: NoExecute # 添加容忍的规则,这里必须和标记的污点规则相同
    • 创建Pod:
    1. kubectl create -f pod-toleration.yaml

    容忍之创建Pod.png

    • 查看Pod:
    1. kubectl get pod pod-toleration -n dev -o wide

    容忍之查看Pod.png

    5 临时容器

    5.1 概述

    • 临时容器是一种特殊的容器,该容器可以在现有的Pod中临时运行,以便完成我们发起的操作,比如故障排查。我们应该使用临时容器来检查服务,而不是用临时容器来构建应用程序。
    • Pod是kubernetes集群进行管理的最小单元,由于Pod是一次性且可以替换的,因此Pod一旦被创建,就无法将容器加入到Pod中。而且,我们通常使用Deployment来删除并替换Pod。但是,有的时候我们需要检查现有Pod的状态,比如对难以复现的故障进行排查。在这些场景中,可以在现有Pod中运行临时容器来检查其状态并运行任意命令。

    5.2 什么是临时容器?

    • 临时容器和其他容器的不同之处在于,它们缺少对资源或执行的保证,并且永远不会自动重启,因此不适合用来构建应用程序。临时容器使用和常规容器相同的ContainerSpec来描述,但是许多字段是不兼容或者不允许的。
      • 临时容器没有端口配置,因此像ports、livenessProbe、readinessProbe这样的字段是没有的。
      • Pod的资源分配是不可变的,因此resources这样的配置临时容器也是没有的。
      • ……
    • 临时容器是使用ephemeralcontainers来进行创建的,而不是直接添加到pod.spec中,所以是无法使用kubectl edit来添加一个临时容器。
    • 和常规容器一样,将临时容器添加到Pod后,不能更改或删除临时容器。

    5.3 临时容器的用途

    • 当由于容器奔溃或容器镜像不包含调试工具而导致kubectl exec无用的时候,临时容器对于交互式故障排查非常有用。
    • 比如,像distroless 镜像允许用户部署最小的容器镜像,从而减少攻击面并减少故障和漏洞的暴露。由于distroless 镜像不包含Shell或任何的调试工具,因此很难单独使用kubectl exec命令进行故障排查。
    • 使用临时容器的时候,启用进程名字空间共享 很有帮助,可以查看其他容器中的进程。

    5.4 临时容器的配置

    • 目前来说,临时容器默认是关闭的。
    • 查看临时容器是否开启:
    1. kubelet -h | grep EphemeralContainers

    查看临时容器是否开启.png

    • 在每个节点(不管Master节点还是Node节点)修改kubectl的参数:

    注意:kubectl的启动文件的路径是/usr/lib/systemd/system/kubelet.service.d/10-kubeadm.conf

    1. vim /etc/sysconfig/kubelet
    1. # 修改增加--feature-gates EphemeralContainers=true
    2. KUBELET_EXTRA_ARGS="--cgroup-driver=systemd --feature-gates EphemeralContainers=true"
    3. KUBE_PROXY_MODE="ipvs"
    1. vim /var/lib/kubelet/config.yaml
    1. apiVersion: kubelet.config.k8s.io/v1beta1
    2. authentication:
    3. anonymous:
    4. enabled: falsevim
    5. webhook:
    6. cacheTTL: 0s
    7. enabled: true
    8. x509:
    9. clientCAFile: /etc/kubernetes/pki/ca.crt
    10. authorization:
    11. mode: Webhook
    12. webhook:
    13. cacheAuthorizedTTL: 0s
    14. cacheUnauthorizedTTL: 0s
    15. clusterDNS:
    16. - 10.96.0.10
    17. clusterDomain: cluster.local
    18. cpuManagerReconcilePeriod: 0s
    19. evictionPressureTransitionPeriod: 0s
    20. fileCheckFrequency: 0s
    21. healthzBindAddress: 127.0.0.1
    22. healthzPort: 10248
    23. httpCheckFrequency: 0s
    24. imageMinimumGCAge: 0s
    25. kind: KubeletConfiguration
    26. nodeStatusReportFrequency: 0s
    27. nodeStatusUpdateFrequency: 0s
    28. rotateCertificates: true
    29. runtimeRequestTimeout: 0s
    30. staticPodPath: /etc/kubernetes/manifests
    31. streamingConnectionIdleTimeout: 0s
    32. syncFrequency: 0s
    33. volumeStatsAggPeriod: 0s
    34. # 修改部分
    35. featureGates:
    36. EphemeralContainers: true
    • 加载配置文件重启kubelet:
    1. systemctl daemon-reload
    1. systemctl stop kubelet
    1. systemctl start kubelet
    • 在Master节点修改kube-apiserver.yaml和kube-scheduler.yaml:
    1. vim /etc/kubernetes/manifests/kube-apiserver.yaml
    1. apiVersion: v1
    2. kind: Pod
    3. metadata:
    4. annotations:
    5. kubeadm.kubernetes.io/kube-apiserver.advertise-address.endpoint: 192.168.49.100:6443
    6. creationTimestamp: null
    7. labels:
    8. component: kube-apiserver
    9. tier: control-plane
    10. name: kube-apiserver
    11. namespace: kube-system
    12. spec:
    13. containers:
    14. - command:
    15. - kube-apiserver
    16. - --advertise-address=192.168.49.100
    17. - --allow-privileged=true
    18. - --authorization-mode=Node,RBAC
    19. - --client-ca-file=/etc/kubernetes/pki/ca.crt
    20. - --enable-admission-plugins=NodeRestriction
    21. - --enable-bootstrap-token-auth=true
    22. - --etcd-cafile=/etc/kubernetes/pki/etcd/ca.crt
    23. - --etcd-certfile=/etc/kubernetes/pki/apiserver-etcd-client.crt
    24. - --etcd-keyfile=/etc/kubernetes/pki/apiserver-etcd-client.key
    25. - --etcd-servers=https://127.0.0.1:2379
    26. - --insecure-port=0
    27. - --kubelet-client-certificate=/etc/kubernetes/pki/apiserver-kubelet-client.crt
    28. - --kubelet-client-key=/etc/kubernetes/pki/apiserver-kubelet-client.key
    29. - --kubelet-preferred-address-types=InternalIP,ExternalIP,Hostname
    30. - --proxy-client-cert-file=/etc/kubernetes/pki/front-proxy-client.crt
    31. - --proxy-client-key-file=/etc/kubernetes/pki/front-proxy-client.key
    32. - --requestheader-allowed-names=front-proxy-client
    33. - --requestheader-client-ca-file=/etc/kubernetes/pki/front-proxy-ca.crt
    34. - --requestheader-extra-headers-prefix=X-Remote-Extra-
    35. - --requestheader-group-headers=X-Remote-Group
    36. - --requestheader-username-headers=X-Remote-User
    37. - --secure-port=6443
    38. - --service-account-issuer=https://kubernetes.default.svc.cluster.local
    39. - --service-account-key-file=/etc/kubernetes/pki/sa.pub
    40. - --service-account-signing-key-file=/etc/kubernetes/pki/sa.key
    41. - --service-cluster-ip-range=10.96.0.0/12
    42. - --tls-cert-file=/etc/kubernetes/pki/apiserver.crt
    43. - --tls-private-key-file=/etc/kubernetes/pki/apiserver.key
    44. # 修改部分
    45. - --feature-gates=EphemeralContainers=true
    1. vim /etc/kubernetes/manifests/kube-scheduler.yaml
    1. apiVersion: v1
    2. kind: Pod
    3. metadata:
    4. creationTimestamp: null
    5. labels:
    6. component: kube-scheduler
    7. tier: control-plane
    8. name: kube-scheduler
    9. namespace: kube-system
    10. spec:
    11. containers:
    12. - command:
    13. - kube-scheduler
    14. - --authentication-kubeconfig=/etc/kubernetes/scheduler.conf
    15. - --authorization-kubeconfig=/etc/kubernetes/scheduler.conf
    16. - --bind-address=127.0.0.1
    17. - --kubeconfig=/etc/kubernetes/scheduler.conf
    18. - --leader-elect=true
    19. # 修改部分
    20. - --feature-gates=EphemeralContainers=true

    5.5 使用临时容器在线debug

    • 创建一个nginx.yaml文件,内容如下:
    1. apiVersion: v1
    2. kind: Pod
    3. metadata:
    4. name: nginx
    5. spec:
    6. shareProcessNamespace: true # 这个配置非常重要,一定要配置
    7. containers:
    8. - name: nginx
    9. image: nginx:1.17.1
    • 创建Pod:
    1. kubectl apply -f nginx.yaml
    • 创建ec.json文件,内容如下(注意:name是Pod的名称):
    1. {
    2. "apiVersion": "v1",
    3. "kind": "EphemeralContainers",
    4. "metadata": {
    5. "name": "nginx"
    6. },
    7. "ephemeralContainers": [{
    8. "command": [
    9. "sh"
    10. ],
    11. "image": "busybox",
    12. "imagePullPolicy": "IfNotPresent",
    13. "name": "debugger",
    14. "stdin": true,
    15. "tty": true,
    16. "terminationMessagePolicy": "File"
    17. }]
    18. }
    • 使用下面的命令更新已经运行的容器:
    1. kubectl replace --raw /api/v1/namespaces/default/pods/nginx/ephemeralcontainers -f ec.json

    使用下面的命令更新已经运行的容器.png

    • 使用如下的命令查看新创建的临时容器的状态:
    1. kubectl describe pod nginx

    使用如下的命令查看新创建的临时容器的状态.png

    • 可以使用如下的命令连接临时容器:
    1. kubectl exec -it nginx -c debugger -- sh
    1. kubectl attach -it nginx -c debugger

    可以使用如下的命令连接临时容器.png

    6 服务质量Qos

    6.1 概述

    • kubernetes创建Pod的时候就会指定QoS。
    • QoS分为如下的三类:
      • ① Guaranteed。
      • ② Burstable。
      • ③ BestEffort。

    6.2 Qos之Guaranteed

    6.2.1 概述

    • 对于 QoS 类为 Guaranteed 的 Pod:
      • Pod 中的每个容器,包含初始化容器,必须指定内存请求和内存限制,并且两者要相等。
      • Pod 中的每个容器,包含初始化容器,必须指定 CPU 请求和 CPU 限制,并且两者要相等。

    6.2.2 应用示例

    • 创建命名空间:

      1. kubectl create namespace qos-example
    • 创建qos-demo.yaml文件,内容如下:

      1. vim qos-demo.yaml
      1. apiVersion: v1
      2. kind: Pod
      3. metadata:
      4. name: qos-demo
      5. namespace: qos-example
      6. spec:
      7. containers:
      8. - name: qos-demo-ctr
      9. image: nginx
      10. resources:
      11. limits:
      12. memory: "200Mi"
      13. cpu: "700m"
      14. requests:
      15. memory: "200Mi"
      16. cpu: "700m"
    • 创建Pod:

      1. kubectl create -f qos-demo.yaml
    • 查看Pod详情:

      1. kubectl get pod qos-demo -n qos-example -o yaml

      Qos之Guaranteed之查看Pod详情.png

    • 删除Pod:

      1. kubectl delete -f qos-demo.yaml

    6.3 Qos之Burstable

    6.3.1 概述

    • 如果满足下面条件,将会指定 Pod 的 QoS 类为 Burstable:
      • Pod 不符合 Guaranteed QoS 类的标准。
      • Pod 中至少一个容器具有内存或 CPU 请求,但是值不相等。

    6.3.2 应用示例

    • 创建qos-demo-2.yaml文件,内容如下:

      1. vim qos-demo-2.yaml
      1. apiVersion: v1
      2. kind: Pod
      3. metadata:
      4. name: qos-demo-2
      5. namespace: qos-example
      6. spec:
      7. containers:
      8. - name: qos-demo-2-ctr
      9. image: nginx
      10. resources:
      11. limits:
      12. memory: "200Mi"
      13. requests:
      14. memory: "100Mi"
    • 创建Pod:

      1. kubectl create -f qos-demo-2.yaml
    • 查看Pod详情:

      1. kubectl get pod qos-demo-2 -n qos-example -o yaml

      Qos之Burstable之查看Pod详情.png

    • 删除Pod:

      1. kubectl delete -f qos-demo2.yaml

    6.4 Qos之BestEffort

    6.4.1 概述

    • 对于 QoS 类为 BestEffort 的 Pod,Pod 中的容器必须没有设置内存和 CPU 限制或请求。

    6.4.2 应用示例

    • 创建qos-demo-3.yaml文件,内容如下:

      1. vim qos-demo-3.yaml
      1. apiVersion: v1
      2. kind: Pod
      3. metadata:
      4. name: qos-demo-3
      5. namespace: qos-example
      6. spec:
      7. containers:
      8. - name: qos-demo-3-ctr
      9. image: nginx
    • 创建Pod:

      1. kubectl create -f qos-demo-3.yaml
    • 查看Pod详情:

      1. kubectl get pod qos-demo-3 -n qos-example -o yaml

      Qos之BestEffort之查看Pod详情.png

    • 删除Pod:

      1. kubectl delete -f qos-demo3.yaml

    6.5 Qos的应用

    • 一旦出现OOM,kubernetes为了保证服务的可用,会先删除QoS为BestEffort的Pod,然后删除QoS为Burstable的Pod,最后删除QoS为Guaranteed 的Pod。