Pod详解

Pod介绍

术语中英文对照：

英文全称	英文缩写	中文翻译
Pod	Pod	容器组
Container	Container	容器
Controller	Controller	控制器

什么是 Pod 容器组

Pod 是可以在 Kubernetes 中创建和管理的、最小的可部署的计算单元。

一个 Pod（容器组）包含了一个应用程序容器（某些情况下是多个容器）、存储资源、一个唯一的网络 IP 地址、以及一些确定容器该如何运行的选项。Pod 容器组代表了 Kubernetes 中一个独立的应用程序运行实例，该实例可能由单个容器或者几个紧耦合在一起的容器组成。

说明： Docker 是 Kubernetes Pod 中使用最广泛的容器运行时； 除了 Docker 之外，Kubernetes 支持很多其他容器运行时

Kubernetes 集群中的 Pod 存在如下两种使用途径：

• 一个 Pod 中只运行一个容器。“one-container-per-pod” 是 Kubernetes 中最常见的使用方式。此时，您可以认为 Pod 容器组是该容器的 wrapper，Kubernetes 通过 Pod 管理容器，而不是直接管理容器。
• 一个 Pod 中运行多个需要互相协作的容器。您可以将多个紧密耦合、共享资源且始终在一起运行的容器编排在同一个 Pod 中

Pod结构

Pod 的共享上下文包括一组 Linux 名字空间、控制组（cgroup）和可能一些其他的隔离方面， 即用来隔离容器的技术。 在 Pod 的上下文中，每个独立的应用可能会进一步实施隔离。

Pod 类似于共享名字空间并共享文件系统卷的一组容器。

每个Pod中都可以包含一个或者多个容器，这些容器可以分为两类：

• 用户程序所在的容器，数量可多可少

• Pause容器，这是每个Pod都会有的一个根容器，它的作用有两个：

  • 可以以它为依据，评估整个Pod的健康状态

  • 可以在根容器上设置Ip地址，其它容器都此Ip（Pod IP），以实现Pod内部的网路通信

    这里是Pod内部的通讯，Pod的之间的通讯采用虚拟二层网络技术来实现，我们当前环境用的是Flannel
    

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，默认TCPenv:   #容器运行前需设置的环境变量列表- 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、portpath: stringport: numberhost: stringscheme: stringHttpHeaders:- name: stringvalue: stringtcpSocket:     #对Pod内个容器健康检查方式设置为tcpSocket方式port: numberinitialDelaySeconds: 0       #容器启动完成后首次探测的时间，单位为秒timeoutSeconds: 0    　　    #对容器健康检查探测等待响应的超时时间，单位秒，默认1秒periodSeconds: 0     　　    #对容器监控检查的定期探测时间设置，单位秒，默认10秒一次successThreshold: 0failureThreshold: 0securityContext:privileged: falserestartPolicy: [Always | Never | OnFailure]  #Pod的重启策略nodeName: <string> #设置NodeName表示将该Pod调度到指定到名称的node节点上nodeSelector: obeject #设置NodeSelector表示将该Pod调度到包含这个label的node上imagePullSecrets: #Pull镜像时使用的secret名称，以key：secretkey格式指定- name: stringhostNetwork: 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: stringpath: stringconfigMap:         #类型为configMap的存储卷，挂载预定义的configMap对象到容器内部name: stringitems:- key: stringpath: string

在这里，可通过一个命令来查看每种资源的可配置项 kubectl explain 资源类型 ，查看某种资源可以配置的一级属性 kubectl explain 资源类型.属性 查看属性的子属性
执行：kubectl explain pod

KIND:     Pod
VERSION:  v1
FIELDS:apiVersion   <string>kind <string>metadata     <Object>spec <Object>status       <Object>

执行：kubectl explain pod.metadata

KIND:     Pod
VERSION:  v1
RESOURCE: metadata <Object>
FIELDS:annotations  <map[string]string>clusterName  <string>creationTimestamp    <string>deletionGracePeriodSeconds   <integer>deletionTimestamp    <string>finalizers   <[]string>generateName <string>generation   <integer>labels       <map[string]string>managedFields        <[]Object>name <string>namespace    <string>ownerReferences      <[]Object>resourceVersion      <string>selfLink     <string>uid  <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[]> 根据NodeSelector中定义的信息选择将该Pod调度到包含这些label的Node 上
• hostNetwork 是否使用主机网络模式，默认为false，如果设置为true，表示使用宿主机网络
• volumes <[]Object> 存储卷，用于定义Pod上面挂在的存储信息
• restartPolicy 重启策略，表示Pod在遇到故障的时候的处理策略

Pod配置

本小节主要来研究pod.spec.containers属性，这也是pod配置中最为关键的一项配置。

执行：kubectl explain 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>      # 资源限制和资源请求的设置

基本配置

创建pod-base.yaml文件，内容如下：

apiVersion: v1
kind: Pod
metadata:name: pod-basenamespace: devlabels:user: heima
spec:containers:- name: nginximage: nginx:1.17.1- name: busyboximage: busybox:1.30

root@master:/# kubectl get pods
NAME                             READY   STATUS             RESTARTS           AGE
sc-deployment-78f5b66dd6-sqxkg   0/1     ImagePullBackOff   0                  35d
sc-deployment-78f5b66dd6-wtj8d   0/1     Error              9688 (5m22s ago)   35d

上面定义了一个比较简单Pod的配置，里面有两个容器：

• nginx：用1.17.1版本的nginx镜像创建，（nginx是一个轻量级web容器）
• busybox：用1.30版本的busybox镜像创建，（busybox是一个小巧的linux命令集合）

# 创建Pod
root@master:/# kubectl apply -f pod-base.yaml
pod/pod-base created# 查看Pod状况
# READY 1/2 : 表示当前Pod中有2个容器，其中1个准备就绪，1个未就绪
# RESTARTS  : 重启次数，因为有1个容器故障了，Pod一直在重启试图恢复它
root@master:~# kubectl get pod -n dev
NAME       READY   STATUS             RESTARTS      AGE
pod-base   1/2     CrashLoopBackOff   6 (51s ago)   8m5s# 可以通过describe查看内部的详情
# 此时已经运行起来了一个基本的Pod，虽然它暂时有问题
root@master:~# kubectl describe pod pod-base -n dev

镜像拉取

创建pod-imagepullpolicy.yaml文件，内容如下：

apiVersion: v1
kind: Pod
metadata:name: pod-imagepullpolicynamespace: dev
spec:containers:- name: nginximage: nginx:1.17.1imagePullPolicy: Never # 用于设置镜像拉取策略- name: busyboximage: busybox:1.30

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

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

默认值说明：

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

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

# 创建Pod
root@master:/# k apply -f pod-imagepullpolicy.yaml
pod/pod-imagepullpolicy created# 查看Pod详情
# 此时明显可以看到nginx镜像有一步Pulling image "nginx:1.17.1"的过程
root@master:~# kubectl describe pod pod-imagepullpolicy -n dev
......
Events:Type     Reason     Age                From               Message----     ------     ----               ----               -------Normal   Scheduled  24s                default-scheduler  Successfully assigned dev/pod-imagepullpolicy to masterNormal   Pulled     21s                kubelet            Container image "nginx:1.17.1" already present on machineNormal   Created    20s                kubelet            Created container nginxNormal   Started    20s                kubelet            Started container nginxNormal   Created    17s (x2 over 19s)  kubelet            Created container busyboxNormal   Started    16s (x2 over 18s)  kubelet            Started container busyboxWarning  BackOff    15s (x2 over 16s)  kubelet            Back-off restarting failed containerNormal   Pulled     1s (x3 over 20s)   kubelet            Container image "busybox:1.30" already present on machine

启动命令

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

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

创建pod-command.yaml文件，内容如下：

apiVersion: v1
kind: Pod
metadata:name: pod-commandnamespace: dev
spec:containers:- name: nginximage: nginx:1.17.1- name: busyboximage: busybox:1.30command: ["/bin/sh","-c","touch /tmp/hello.txt;while true;do /bin/echo $(date +%T) >> /tmp/hello.txt; sleep 3; done;"]

root@master:~# kubectl get pods -n dev
NAME                  READY   STATUS             RESTARTS      AGE
pod-base              1/2     CrashLoopBackOff   7 (34s ago)   13m
pod-command           2/2     Running            0             84s
pod-imagepullpolicy   1/2     CrashLoopBackOff   5 (18s ago)   3m32s

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秒向文件中写入当前时间

# 创建Pod
root@master:~# k apply -f pod-command.yaml
pod/pod-command created# 查看Pod状态
# 此时发现两个pod都正常运行了
root@master:~# kubectl get pods pod-command -n dev
NAME          READY   STATUS    RESTARTS   AGE
pod-command   2/2     Running   0          39s# 进入pod中的busybox容器，查看文件内容
# 补充一个命令: kubectl exec  pod名称 -n 命名空间 -it -c 容器名称 /bin/sh  在容器内部执行命令
# 使用这个命令就可以进入某个容器的内部，然后进行相关操作了
# 比如，可以查看txt文件的内容
root@master:~# kubectl exec pod-command -n dev -it -c busybox /bin/sh
kubectl exec [POD] [COMMAND] is DEPRECATED and will be removed in a future version. Use kubectl exec [POD] -- [COMMAND] instead.
/ # tail -f /tmp/hello.txt
09:53:10
09:53:13
09:53:16
特别说明：通过上面发现command已经可以完成启动命令和传递参数的功能，为什么这里还要提供一个args选项，用于传递参数呢?这其实跟docker有点关系，kubernetes中的command、args两项其实是实现覆盖Dockerfile中ENTRYPOINT的功能。1 如果command和args均没有写，那么用Dockerfile的配置。2 如果command写了，但args没有写，那么Dockerfile默认的配置会被忽略，执行输入的command3 如果command没写，但args写了，那么Dockerfile中配置的ENTRYPOINT的命令会被执行，使用当前args的参数4 如果command和args都写了，那么Dockerfile的配置被忽略，执行command并追加上args参数

环境变量

创建pod-env.yaml文件，内容如下：

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

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

# 创建Pod
root@master:~# kubectl apply -f pod-env.yaml
pod/pod-env created# 进入容器，输出环境变量
root@master:~# kubectl exec pod-env -n dev -c busybox -it /bin/sh
kubectl exec [POD] [COMMAND] is DEPRECATED and will be removed in a future version. Use kubectl exec [POD] -- [COMMAND] instead.
/ # echo $username
admin
/ # echo $password
123456

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

端口设置

本小节来介绍容器的端口设置，也就是containers的ports选项。

首先看下ports支持的子选项：

[root@k8s-master01 ~]# kubectl explain pod.spec.containers.ports
KIND:     Pod
VERSION:  v1
RESOURCE: ports <[]Object>
FIELDS:name         <string>  # 端口名称，如果指定，必须保证name在pod中是唯一的     containerPort<integer> # 容器要监听的端口(0<x<65536)hostPort     <integer> # 容器要在主机上公开的端口，如果设置，主机上只能运行容器的一个副本(一般省略) hostIP       <string>  # 要将外部端口绑定到的主机IP(一般省略)protocol     <string>  # 端口协议。必须是UDP、TCP或SCTP。默认为“TCP”。

接下来，编写一个测试案例，创建pod-ports.yaml

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

# 创建Pod
root@master:~# kubectl create -f pod-ports.yaml
pod/pod-ports created# 查看pod
# 在下面可以明显看到配置信息
root@master:~# kubectl get pod pod-ports -n dev -o yaml
......
spec:containers:- image: nginx:1.17.1imagePullPolicy: IfNotPresentname: nginxports:- containerPort: 80name: nginx-portprotocol: TCP
......# 查看详情
root@master:~# kubectl get pods pod-ports -n dev -o wide
NAME        READY   STATUS    RESTARTS   AGE   IP             NODE     NOMINATED NODE   READINESS GATES
pod-ports   1/1     Running   0          85s   10.244.0.222   master   <none>           <none># 访问容器中的程序
root@master:~# curl 10.244.0.222:80
<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
<style>body {width: 35em;margin: 0 auto;font-family: Tahoma, Verdana, Arial, sans-serif;}
</style>
</head>
<body>
<h1>Welcome to nginx!</h1>
<p>If you see this page, the nginx web server is successfully installed and
working. Further configuration is required.</p><p>For online documentation and support please refer to
<a href="http://nginx.org/">nginx.org</a>.<br/>
Commercial support is available at
<a href="http://nginx.com/">nginx.com</a>.</p><p><em>Thank you for using nginx.</em></p>
</body>
</html>

资源配额

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

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

可以通过上面两个选项设置资源的上下限。

接下来，编写一个测试案例，创建pod-resources.yaml

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

在这对cpu和memory的单位做一个说明：

• cpu：core数，可以为整数或小数
• memory： 内存大小，可以使用Gi、Mi、G、M等形式

# 运行Pod
root@master:~# kubectl create  -f pod-resources.yaml
pod/pod-resources created# 查看发现pod运行正常
root@master:~# kubectl get pod pod-resources -n dev
NAME            READY   STATUS    RESTARTS   AGE
pod-resources   1/1     Running   0          39s   # 接下来，停止Pod
root@master:~# kubectl delete  -f pod-resources.yaml
pod "pod-resources" deleted# 编辑pod，修改resources.requests.memory的值为11Gi
root@master:~# vim pod-resources.yaml# 再次启动pod,启动失败内存超出限制
root@master:~# kubectl apply -f pod-resources.yaml
The Pod "pod-resources" is invalid:
* spec.containers[0].resources.requests: Invalid value: "11Gi": must be less than or equal to memory limit

Pod生命周期

Pod 在其生命周期中只会被调度一次。 一旦 Pod 被调度（分派）到某个节点，Pod 会一直在该节点运行，直到 Pod 停止或者被终止。

Pod 遵循预定义的生命周期，起始于 Pending 阶段， 如果至少其中有一个主要容器正常启动，则进入 Running，之后取决于 Pod 中是否有容器以失败状态结束而进入 Succeeded 或者 Failed 阶段。它主要包含下面的过程：

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

在整个生命周期中，Pod会出现5种阶段（Phase），分别如下：

取值	描述
Pending（挂起）	Pod 已被 Kubernetes 系统接受，但有一个或者多个容器尚未创建亦未运行。此阶段包括等待 Pod 被调度的时间和通过网络下载镜像的时间。
Running（运行中）	Pod 已经绑定到了某个节点，Pod 中所有的容器都已被创建。至少有一个容器仍在运行，或者正处于启动或重启状态。
Succeeded（成功）	Pod 中的所有容器都已成功终止，并且不会再重启。
Failed（失败）	Pod 中的所有容器都已终止，并且至少有一个容器是因为失败终止。也就是说，容器以非 0 状态退出或者被系统终止。
Unknown（未知）	因为某些原因无法取得 Pod 的状态。这种情况通常是因为与 Pod 所在主机通信失败。

说明： 当一个 Pod 被删除时，执行一些 kubectl 命令会展示这个 Pod 的状态为 Terminating（终止）。 这个 Terminating 状态并不是 Pod 阶段之一。 Pod 被赋予一个可以体面终止的期限，默认为 30 秒。 你可以使用 –force 参数来强制终止 Pod。

创建和终止

pod的创建过程

1. 用户通过kubectl或其他api客户端提交需要创建的pod信息给apiServer

2. apiServer开始生成pod对象的信息，并将信息存入etcd，然后返回确认信息至客户端

3. apiServer开始反映etcd中的pod对象的变化，其它组件使用watch机制来跟踪检查apiServer上的变动

4. scheduler发现有新的pod对象要创建，开始为Pod分配主机并将结果信息更新至apiServer

5. node节点上的kubelet发现有pod调度过来，尝试调用容器运行时启动容器，并将结果回送至apiServer

6. apiServer将接收到的pod状态信息存入etcd中

pod的终止过程

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

初始化容器

初始化容器与工作容器完全相同，除了如下几点：

• 初始化容器总是运行并自动结束
• kubelet 按顺序执行 Pod 中的初始化容器，前一个初始化容器成功结束后，下一个初始化容器才开始运行。所有的初始化容器成功执行后，才开始启动工作容器
• 如果 Pod 的任意一个初始化容器执行失败，kubernetes 将反复重启该 Pod，直到初始化容器全部成功（除非 Pod 的 restartPolicy 被设定为 Never）
• 初始化容器的 Resource request / limits 处理不同
• 初始化容器不支持 就绪检查 readiness probe，因为初始化容器必须在 Pod ready 之前运行并结束

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

• 初始化容器可以包含工作容器中没有的工具代码或者自定义代码。例如：您无需仅仅为了少量的 setup 工作（使用 sed, awk, python 或 dig 进行环境设定）而重新从一个基础镜像制作另外一个镜像
• 初始化容器可以更安全地执行某些使工作容器变得不安全的代码
• 应用程序的镜像构建者和部署者可以各自独立地工作，而无需一起构建一个镜像
• 初始化容器相较于工作容器，可以以另外一个视角处理文件系统。例如，他们可以拥有访问 Secrets 的权限，而工作容器却不一定被授予该权限
• 初始化容器在任何工作容器启动之前结束运行，这个特性使得我们可以阻止或者延迟工作容器的启动，直到某些前提条件得到满足。一旦前提条件满足，所有的工作容器将同时并行启动

接下来做一个案例，模拟下面这个需求：

假设要以主容器来运行nginx，但是要求在运行nginx之前先要能够连接上mysql和redis所在服务器

为了简化测试，事先规定好mysql(192.168.90.14)和redis(192.168.90.15)服务器的地址

创建pod-initcontainer.yaml，内容如下：

apiVersion: v1
kind: Pod
metadata:name: pod-initcontainernamespace: dev
spec:containers:- name: nginximage: nginxports:- containerPort: 80volumeMounts:- name: workdirmountPath: /usr/share/nginx/html# These containers are run during pod initializationinitContainers:- name: installimage: busyboxcommand:- wget- "-O"- "/work-dir/index.html"- https://kuboard.cnvolumeMounts:- name: workdirmountPath: "/work-dir"dnsPolicy: Defaultvolumes:- name: workdiremptyDir: {}

从配置文件可以看出，Pod 中初始化容器和应用程序共享了同一个数据卷。初始化容器将该共享数据卷挂载到 /work-dir 路径，应用程序容器将共享数据卷挂载到 /usr/share/nginx/html 路径。初始化容器执行如下命令后，就退出执行：

wget -O /work-dir/index.html https://kuboard.cn

执行该命令时，初始化容器将结果写入了应用程序容器 nginx 服务器对应的 html 根路径下的 index.html。

• 执行命令以创建 Pod

root@master:~# kubectl apply -f  pod-initcontainer.yaml
pod/pod-initcontainer created

• 验证nginx容器已经运行

root@master:~# kubectl get pods pod-initcontainer -n dev -o wide
NAME                READY   STATUS    RESTARTS   AGE     IP             NODE     NOMINATED NODE   READINESS GATES
pod-initcontainer   1/1     Running   0          2m13s   10.244.0.230   master   <none>           <none>root@master:~# curl 10.244.0.230
<!doctype html>
<html lang="en"><head><meta charset="utf-8"><title>Kuboard_Kubernetes教程_K8S安装_管理界面</title>......

钩子函数

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

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

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

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

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

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

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

  ……      lifecycle:postStart:tcpSocket: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-execnamespace: dev
spec:containers:- name: main-containerimage: nginx:1.17.1ports:- name: nginx-portcontainerPort: 80lifecycle:postStart: exec: # 在容器启动的时候执行一个命令，修改掉nginx的默认首页内容command: ["/bin/sh", "-c", "echo postStart... > /usr/share/nginx/html/index.html"]preStop:exec: # 在容器停止之前停止nginx服务command: ["/usr/sbin/nginx","-s","quit"]

# 创建pod
root@master:~# kubectl apply -f pod-hook-exec.yaml
pod/pod-hook-exec created# 查看pod
root@master:~#  kubectl get pods  pod-hook-exec -n dev -o wide
NAME            READY   STATUS    RESTARTS   AGE   IP             NODE     NOMINATED NODE   READINESS GATES
pod-hook-exec   1/1     Running   0          10s   10.244.0.227   master   <none>           <none># 访问pod
root@master:~# curl 10.244.0.227
postStart...

容器探测

推荐阅读：
从零开始入门 K8s | 可观测性：你的应用健康吗？

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

探测结果

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

• Success（成功）

  容器通过了诊断。

• Failure（失败）

  容器未通过诊断。

• Unknown（未知）

  诊断失败，因此不会采取任何行动

探测类型

针对运行中的容器，kubelet 可以选择是否执行以下三种探针，以及如何针对探测结果作出反应：

• livenessProbe存活性探针

  指示容器是否处于正常运行状态。如果存活态探测失败，则 kubelet 会杀死容器， 并且容器将根据其重启策略决定未来。如果容器不提供存活探针， 则默认状态为 Success。

• readinessProbe就绪性探针

  指示容器是否准备好为请求提供服务。如果就绪态探测失败， 端点控制器将从与 Pod 匹配的所有服务的端点列表中删除该 Pod 的 IP 地址。 初始延迟之前的就绪态的状态值默认为 Failure。 如果容器不提供就绪态探针，则默认状态为 Success。

• startupProbe启动探针

  指示容器中的应用是否已经启动。如果提供了启动探针，则所有其他探针都会被 禁用，直到此探针成功为止。如果启动探测失败，kubelet 将杀死容器， 而容器依其重启策略进行重启。 如果容器没有提供启动探测，则默认状态为 Success。

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

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

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

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

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

  ……      livenessProbe:tcpSocket:port: 8080
  ……
  

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

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

下面以liveness probes为例，做几个演示：

方式一：Exec

创建pod-liveness-exec.yaml

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

创建pod，观察效果

# 创建Pod
[root@k8s-master01 ~]# kubectl create -f pod-liveness-exec.yaml
pod/pod-liveness-exec created# 查看Pod详情
[root@k8s-master01 ~]# kubectl describe pods pod-liveness-exec -n dev
......Normal   Created    20s (x2 over 50s)  kubelet, node1     Created container nginxNormal   Started    20s (x2 over 50s)  kubelet, node1     Started container nginxNormal   Killing    20s                kubelet, node1     Container nginx failed liveness probe, will be restartedWarning  Unhealthy  0s (x5 over 40s)   kubelet, node1     Liveness probe failed: cat: can't open '/tmp/hello11.txt': No such file or directory# 观察上面的信息就会发现nginx容器启动之后就进行了健康检查
# 检查失败之后，容器被kill掉，然后尝试进行重启（这是重启策略的作用，后面讲解）
# 稍等一会之后，再观察pod信息，就可以看到RESTARTS不再是0，而是一直增长
[root@k8s-master01 ~]# kubectl get pods pod-liveness-exec -n dev
NAME                READY   STATUS             RESTARTS   AGE
pod-liveness-exec   0/1     CrashLoopBackOff   2          3m19s# 当然接下来，可以修改成一个存在的文件，比如/tmp/hello.txt，再试，结果就正常了......

方式二：TCPSocket

创建pod-liveness-tcpsocket.yaml

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

创建pod，观察效果

# 创建Pod
[root@k8s-master01 ~]# kubectl create -f pod-liveness-tcpsocket.yaml
pod/pod-liveness-tcpsocket created# 查看Pod详情
[root@k8s-master01 ~]# kubectl describe pods pod-liveness-tcpsocket -n dev
......Normal   Scheduled  31s                            default-scheduler  Successfully assigned dev/pod-liveness-tcpsocket to node2Normal   Pulled     <invalid>                      kubelet, node2     Container image "nginx:1.17.1" already present on machineNormal   Created    <invalid>                      kubelet, node2     Created container nginxNormal   Started    <invalid>                      kubelet, node2     Started container nginxWarning  Unhealthy  <invalid> (x2 over <invalid>)  kubelet, node2     Liveness probe failed: dial tcp 10.244.2.44:8080: connect: connection refused# 观察上面的信息，发现尝试访问8080端口,但是失败了
# 稍等一会之后，再观察pod信息，就可以看到RESTARTS不再是0，而是一直增长
[root@k8s-master01 ~]# kubectl get pods pod-liveness-tcpsocket  -n dev
NAME                     READY   STATUS             RESTARTS   AGE
pod-liveness-tcpsocket   0/1     CrashLoopBackOff   2          3m19s# 当然接下来，可以修改成一个可以访问的端口，比如80，再试，结果就正常了......

方式三：HTTPGet

创建pod-liveness-httpget.yaml

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

创建pod，观察效果

# 创建Pod
[root@k8s-master01 ~]# kubectl create -f pod-liveness-httpget.yaml
pod/pod-liveness-httpget created# 查看Pod详情
[root@k8s-master01 ~]# kubectl describe pod pod-liveness-httpget -n dev
.......Normal   Pulled     6s (x3 over 64s)  kubelet, node1     Container image "nginx:1.17.1" already present on machineNormal   Created    6s (x3 over 64s)  kubelet, node1     Created container nginxNormal   Started    6s (x3 over 63s)  kubelet, node1     Started container nginxWarning  Unhealthy  6s (x6 over 56s)  kubelet, node1     Liveness probe failed: HTTP probe failed with statuscode: 404Normal   Killing    6s (x2 over 36s)  kubelet, node1     Container nginx failed liveness probe, will be restarted# 观察上面信息，尝试访问路径，但是未找到,出现404错误
# 稍等一会之后，再观察pod信息，就可以看到RESTARTS不再是0，而是一直增长
[root@k8s-master01 ~]# kubectl get pod pod-liveness-httpget -n dev
NAME                   READY   STATUS    RESTARTS   AGE
pod-liveness-httpget   1/1     Running   5          3m17s# 当然接下来，可以修改成一个可以访问的路径path，比如/，再试，结果就正常了......

至此，已经使用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。最小值是1successThreshold     <integer>  # 连续探测成功多少次才被认定为成功。默认是1

下面稍微配置两个，演示下效果即可：

[root@k8s-master01 ~]# more pod-liveness-httpget.yaml
apiVersion: v1
kind: Pod
metadata:name: pod-liveness-httpgetnamespace: dev
spec:containers:- name: nginximage: nginx:1.17.1ports:- name: nginx-portcontainerPort: 80livenessProbe:httpGet:scheme: HTTPport: 80 path: /initialDelaySeconds: 30 # 容器启动后30s开始探测timeoutSeconds: 5 # 探测超时时间为5s

重启策略

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

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

重启策略适用于pod对象中的所有容器，首次需要重启的容器，将在其需要时立即进行重启，随后再次需要重启的操作将由kubelet延迟一段时间后进行，且反复的重启操作的延迟时长以此为10s、20s、40s、80s、160s和300s，300s是最大延迟时长。

创建pod-restartpolicy.yaml：

apiVersion: v1
kind: Pod
metadata:name: pod-restartpolicynamespace: dev
spec:containers:- name: nginximage: nginx:1.17.1ports:- name: nginx-portcontainerPort: 80livenessProbe:httpGet:scheme: HTTPport: 80path: /hellorestartPolicy: Never # 设置重启策略为Never

运行Pod测试

# 创建Pod
root@master:~# kubectl apply -f pod-restartpolicy.yaml
pod/pod-restartpolicy created# 查看Pod详情，发现nginx容器失败
root@master:~# kubectl describe pods pod-restartpolicy -n dev
Events:Type     Reason     Age                From               Message----     ------     ----               ----               -------Normal   Scheduled  73s                default-scheduler  Successfully assigned dev/pod-restartpolicy to masterNormal   Pulled     70s                kubelet            Container image "nginx:1.17.1" already present on machineNormal   Created    69s                kubelet            Created container nginxNormal   Started    69s                kubelet            Started container nginxWarning  Unhealthy  42s (x3 over 62s)  kubelet            Liveness probe failed: HTTP probe failed with statuscode: 404Normal   Killing    42s                kubelet            Stopping container nginx# 多等一会，再观察pod的重启次数，发现一直是0，并未重启
root@master:~#  kubectl  get pods pod-restartpolicy -n dev
NAME                READY   STATUS      RESTARTS   AGE
pod-restartpolicy   0/1     Completed   0          90s

将容器组调度到指定的节点

在 Kubernetes，您可以限定 Pod 只能在特定的节点上运行，或者优先选择在特定的节点上运行。通常您并不需要这样做，而应该交由 Scheduler组件根据资源使用情况采用相应的算法自动地为 Pod 分配节点。

场景

• 确保某些 Pod 被分配到具有固态硬盘的节点
• 将相互通信频繁的两个 Pod 分配到同一个高可用区的节点

控制某些Pod到达某些节点上，四大类调度方式：

• 指定节点 nodeName
• 节点选择器 nodeSelector
• Node isolation/restriction
• Affinity and anti-affinity

定向调度

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

NodeName

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

通过 nodeName 限定 Pod 所运行的节点有如下局限性：

• 如果 nodeName 对应的节点不存在，Pod 将不能运行
• 如果 nodeName 对应的节点没有足够的资源，Pod 将运行失败，可能的原因有：OutOfmemory /OutOfcpu
• 集群中的 nodeName 通常是变化的（新的集群中可能没有该 nodeName 的节点，指定的 nodeName 的节点可能从集群中移除）

接下来，实验一下：创建一个pod-nodename.yaml文件

apiVersion: v1
kind: Pod
metadata:name: pod-nodenamenamespace: dev
spec:containers:- name: nginximage: nginx:1.17.1nodeName: node1 # 指定调度到node1节点上

#创建Pod
root@master:~# kubectl apply -f pod-nodename.yaml
pod/pod-nodename created#查看Pod调度到NODE属性，确实是调度到了node1节点上
root@master:~# kubectl get pods pod-nodename -n dev -o wide
NAME           READY   STATUS    RESTARTS   AGE   IP             NODE    NOMINATED NODE   READINESS GATES
pod-nodename   1/1     Running   0          89s   10.244.1.181   node1   <none>           <none># 接下来，删除pod，修改nodeName的值为node3（并没有node3节点）
root@master:~# kubectl delete -f pod-nodename.yaml
pod "pod-nodename" deleted
root@master:~# vim pod-nodename.yaml
root@master:~#  kubectl apply -f pod-nodename.yaml
pod/pod-nodename created#再次查看，发现已经向Node3节点调度，但是由于不存在node3节点，所以pod无法正常运行
root@master:~# kubectl get pods pod-nodename -n dev -o wide
NAME           READY   STATUS    RESTARTS   AGE   IP       NODE    NOMINATED NODE   READINESS GATES
pod-nodename   0/1     Pending   0          9s    <none>   node3   <none>           <none>

NodeSelector

NodeSelector用于将pod调度到添加了指定标签的node节点上。它是通过kubernetes的label-selector机制实现的，也就是说，在pod创建之前，会由scheduler使用MatchNodeSelector调度策略进行label匹配，找出目标node，然后将pod调度到目标节点，该匹配规则是强制约束。

接下来，实验一下：

1 首先分别为node节点添加标签

root@master:~# kubectl label nodes node1 nodeenv=pro
node/node1 labeled

2 创建一个pod-nodeselector.yaml文件，并使用它创建Pod

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

#创建Pod
root@master:~# kubectl apply -f pod-nodeselector.yaml
pod/pod-nodeselector created#查看Pod调度到NODE属性，确实是调度到了node1节点上
root@master:~# kubectl get pods pod-nodeselector -n dev -o wide
NAME               READY   STATUS    RESTARTS   AGE   IP             NODE    NOMINATED NODE   READINESS GATES
pod-nodeselector   1/1     Running   0          8s    10.244.1.182   node1   <none>           <none># 接下来，删除pod，修改nodeSelector的值为nodeenv: xxxx（不存在打有此标签的节点）
pod "pod-nodeselector" deleted
root@master:~# vim pod-nodeselector.yaml
root@master:~# kubectl apply -f pod-nodeselector.yaml
pod/pod-nodeselector created#再次查看，发现pod无法正常运行,Node的值为none
root@master:~# kubectl get pods -n dev -o wide
NAME                  READY   STATUS             RESTARTS          AGE   IP             NODE     NOMINATED NODE   READINESS GATES
pod-nodeselector      0/1     Pending            0                 9s    <none>         <none>   <none>           <none># 查看详情,发现node selector匹配失败的提示
root@master:~# kubectl describe pods pod-nodeselector -n dev
.......
Events:Type     Reason            Age   From               Message----     ------            ----  ----               -------Warning  FailedScheduling  54s   default-scheduler  0/2 nodes are available: 2 node(s) didn't match Pod's node affinity/selector. preemption: 0/2 nodes are available: 2 Preemption is not helpful for scheduling.

Node isolation/restriction

向节点对象添加标签后，可以将 Pod 指定到特定（一个或一组）的节点，以便确保某些 Pod 只在具备某些隔离性、安全性或符合管理规定的节点上运行。如果将标签用于这个目的，推荐选择那些不会被 kubelet 修改的标签。这样做可以避免节点非法使用其 kubelet credential 来设置节点自己的标签，进一步影响到调度器将工作负载调度到该节点上。

NodeRestriction 管理插件可以阻止 kubelet 设置或者修改节点上以 node-restriction.kubernetes.io/ 开头的标签。如需要使用该标签前缀作为节点隔离的目的，需要：

1. 确保 kubenetes 已经启用了 Node authorizer (opens new window)和 NodeRestriction admission plugin(opens new window)
2. 添加带 node-restriction.kubernetes.io/ 前缀的标签到节点对象，并将这些标签作为 Pod 中的节点选择器。例如： example.com.node-restriction.kubernetes.io/fips=true 或 example.com.node-restriction.kubernetes.io/pci-dss=true。

亲和性调度

nodeSelector 提供了一个非常简单的方式，将 Pod 限定到包含特定标签的节点上。但是也有一定的问题，那就是如果没有满足条件的Node，那么Pod将不会被运行，即使在集群中还有可用Node列表也不行，这就限制了它的使用场景。

亲和性与反亲和性（affinity / anti-affinity）特性则极大地扩展了限定的表达方式。主要的增强点在于：

1. 表达方式更加有效（不仅仅是多个精确匹配表达式的“和”关系）
2. 可以标识该规则为“soft” / “preference” （软性的、偏好的）而不是 hard requirement（必须的），此时，如果调度器发现该规则不能被满足，Pod 仍然可以被调度
3. 可以对比节点上（或其他拓扑域 topological domain）已运行的其他 Pod 的标签，而不仅仅是节点自己的标签，此时，可以定义类似这样的规则：某两类 Pod 不能在同一个节点（或拓扑域）上共存

Affinity主要分为三类：

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

关于亲和性(反亲和性)使用场景的说明：

亲和性：如果两个应用频繁交互，那就有必要利用亲和性让两个应用的尽可能的靠近，这样可以减少因网络通信而带来的性能损耗。

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

NodeAffinity

首先来看一下NodeAffinity的可配置项：

pod.spec.affinity.nodeAffinityrequiredDuringSchedulingIgnoredDuringExecution  Node节点必须满足指定的所有规则才可以，相当于硬限制nodeSelectorTerms  节点选择列表matchFields   按节点字段列出的节点选择器要求列表matchExpressions   按节点标签列出的节点选择器要求列表(推荐)key    键values 值operat or 关系符 支持Exists, DoesNotExist, In, NotIn, Gt, LtpreferredDuringSchedulingIgnoredDuringExecution 优先调度到满足指定的规则的Node，相当于软限制 (倾向)preference   一个节点选择器项，与相应的权重相关联matchFields   按节点字段列出的节点选择器要求列表matchExpressions   按节点标签列出的节点选择器要求列表(推荐)key    键values 值operator 关系符 支持In, NotIn, Exists, DoesNotExist, Gt, Ltweight 倾向权重，在范围1-100。
关系符的使用说明:- matchExpressions:- key: nodeenv              # 匹配存在标签的key为nodeenv的节点operator: Exists- key: nodeenv              # 匹配标签的key为nodeenv,且value是"xxx"或"yyy"的节点operator: Invalues: ["xxx","yyy"]- key: nodeenv              # 匹配标签的key为nodeenv,且value大于"xxx"的节点operator: Gtvalues: "xxx"

接下来首先演示一下requiredDuringSchedulingIgnoredDuringExecution （hard，目标节点必须满足此条件）,

创建pod-nodeaffinity-required.yaml

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

# 创建pod
root@master:~# kubectl apply -f pod-nodeaffinity-required.yaml
pod/pod-nodeaffinity-required created# 查看pod状态 （运行失败）,node 为 none
root@master:~# kubectl get pods pod-nodeaffinity-required -n dev -o wide
NAME                        READY   STATUS    RESTARTS   AGE   IP       NODE     NOMINATED NODE   READINESS GATES
pod-nodeaffinity-required   0/1     Pending   0          8s    <none>   <none>   <none>           <none># 查看Pod的详情
# 发现调度失败，提示node选择失败
root@master:~# kubectl describe pod pod-nodeaffinity-required -n dev
Events:Type     Reason            Age   From               Message----     ------            ----  ----               -------Warning  FailedScheduling  29s   default-scheduler  0/2 nodes are available: 2 node(s) didn't match Pod's node affinity/selector. preemption: 0/2 nodes are available: 2 Preemption is not helpful for scheduling.selector.#接下来，停止pod
root@master:~# kubectl delete -f pod-nodeaffinity-required.yaml
pod "pod-nodeaffinity-required" deleted# 修改文件，将values: ["xxx","yyy"]------> ["pro","yyy"]
root@master:~# vim pod-nodeaffinity-required.yaml# 再次启动
root@master:~# kubectl apply -f pod-nodeaffinity-required.yaml
pod/pod-nodeaffinity-required created# 此时查看，发现调度成功，已经将pod调度到了node1上
root@master:~# kubectl get pods pod-nodeaffinity-required -n dev -o wide
NAME                        READY   STATUS    RESTARTS   AGE   IP             NODE    NOMINATED NODE   READINESS GATES
pod-nodeaffinity-required   1/1     Running   0          27s   10.244.1.183   node1   <none>           <none>

接下来再演示一下requiredDuringSchedulingIgnoredDuringExecution （soft，目标节点最好能满足此条件）,

创建pod-nodeaffinity-preferred.yaml

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

# 创建pod
root@master:~#  kubectl apply -f pod-nodeaffinity-preferred.yaml
pod/pod-nodeaffinity-preferred created# 查看pod状态 （运行成功）
root@master:~# kubectl get pod pod-nodeaffinity-preferred -n dev
NAME                         READY   STATUS    RESTARTS   AGE
pod-nodeaffinity-preferred   1/1     Running   0          8s

NodeAffinity规则设置的注意事项：

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

PodAffinity

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

首先来看一下PodAffinity的可配置项：

pod.spec.affinity.podAffinityrequiredDuringSchedulingIgnoredDuringExecution  硬限制namespaces       指定参照pod的namespacetopologyKey      指定调度作用域labelSelector    标签选择器matchExpressions  按节点标签列出的节点选择器要求列表(推荐)key    键values 值operator 关系符 支持In, NotIn, Exists, DoesNotExist.matchLabels    指多个matchExpressions映射的内容preferredDuringSchedulingIgnoredDuringExecution 软限制podAffinityTerm  选项namespaces      topologyKeylabelSelectormatchExpressions  key    键values 值operatormatchLabels weight 倾向权重，在范围1-100
topologyKey用于指定调度时作用域,例如:如果指定为kubernetes.io/hostname，那就是以Node节点为区分范围如果指定为beta.kubernetes.io/os,则以Node节点的操作系统类型来区分

接下来，演示下requiredDuringSchedulingIgnoredDuringExecution （hard，目标节点必须满足此条件）,

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

apiVersion: v1
kind: Pod
metadata:name: pod-podaffinity-targetnamespace: devlabels:podenv: pro #设置标签
spec:containers:- name: nginximage: nginx:1.17.1nodeName: node1 # 将目标pod名确指定到node1上

# 启动目标pod
root@master:~#  kubectl apply -f pod-podaffinity-target.yaml
pod/pod-podaffinity-target created# 查看pod状况
root@master:~# kubectl get pods  pod-podaffinity-target -n dev
NAME                     READY   STATUS    RESTARTS   AGE
pod-podaffinity-target   1/1     Running   0          11s

2）创建pod-podaffinity-required.yaml，内容如下：

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

上面配置表达的意思是：新Pod必须要与拥有标签nodeenv=xxx或者nodeenv=yyy的pod在同一Node上，显然现在没有这样pod，接下来，运行测试一下。

# 启动pod
root@master:~#  kubectl apply -f pod-podaffinity-required.yaml
pod/pod-podaffinity-required created# 查看pod状态，发现未运行
root@master:~# kubectl get pods pod-podaffinity-required -n dev
NAME                       READY   STATUS    RESTARTS   AGE
pod-podaffinity-required   0/1     Pending   0          18s# 查看详细信息
root@master:~# kubectl describe pods pod-podaffinity-required  -n dev
......
Events:Type     Reason            Age   From               Message----     ------            ----  ----               -------Warning  FailedScheduling  25s   default-scheduler  0/2 nodes are available: 2 node(s) didn't match pod affinity rules. preemption: 0/2 nodes are available: 2 Preemption is not helpful for scheduling.# 接下来修改  values: ["xxx","yyy"]----->values:["pro","yyy"]
# 意思是：新Pod必须要与拥有标签nodeenv=xxx或者nodeenv=yyy的pod在同一Node上
root@master:~# vim pod-podaffinity-required.yaml# 然后重新创建pod，查看效果
root@master:~# kubectl delete -f  pod-podaffinity-required.yaml
pod "pod-podaffinity-required" deleted
root@master:~# kubectl apply -f pod-podaffinity-required.yaml
pod/pod-podaffinity-required created# 发现此时Pod运行正常
root@master:~# kubectl get pods pod-podaffinity-required -n dev
NAME                       READY   STATUS    RESTARTS   AGE
pod-podaffinity-required   1/1     Running   0          12s

关于PodAffinity的 preferredDuringSchedulingIgnoredDuringExecution，这里不再演示。

PodAntiAffinity

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

它的配置方式和选项跟PodAffinty是一样的，这里不再做详细解释，直接做一个测试案例。

1）继续使用上个案例中目标pod

root@master:~# kubectl get pods -n dev -o wide --show-labels
NAME                         READY   STATUS             RESTARTS          AGE     IP             NODE     NOMINATED NODE   READINESS GATES   LABELS
pod-podaffinity-required     1/1     Running            0                 117s    10.244.1.185   node1    <none>           <none>            <none>
pod-podaffinity-target       1/1     Running            0                 4m2s    10.244.1.184   node1    <none>           <none>            podenv=pro

2）创建pod-podantiaffinity-required.yaml，内容如下：

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

上面配置表达的意思是：新Pod必须要与拥有标签nodeenv=pro的pod不在同一Node上，运行测试一下。

# 创建pod
root@master:~# kubectl apply -f pod-podantiaffinity-required.yaml
pod/pod-podantiaffinity-required created# 查看pod
# 发现调度到了node2上
root@master:~# kubectl get pods pod-podantiaffinity-required -n dev -o wide
NAME                           READY   STATUS    RESTARTS   AGE   IP             NODE     NOMINATED NODE   READINESS GATES
pod-podantiaffinity-required   1/1     Running   0          8s    10.244.0.232   master   <none>           <none>

污点和容忍

污点和容忍（taints and tolerations）成对工作，以确保 Pod 不会被调度到不合适的节点上。

• 可以为节点增加污点（taints，一个节点可以有 0-N 个污点）
• 可以为 Pod 增加容忍（toleration，一个 Pod 可以有 0-N 个容忍）
• 如果节点上存在污点，则该节点不会接受任何不能容忍（tolerate）该污点的 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驱离

使用kubectl设置和去除污点的命令示例如下：

# 设置污点
kubectl taint nodes node1 key=value:effect# 去除污点
kubectl taint nodes node1 key:effect-# 去除所有污点
kubectl taint nodes node1 key-

接下来，演示下污点的效果：

1. 准备节点node1（为了演示效果更加明显，暂时停止node2节点）
2. 为node1节点设置一个污点: tag=heima:PreferNoSchedule；然后创建pod1( pod1 可以 )
3. 修改为node1节点设置一个污点: tag=heima:NoSchedule；然后创建pod2( pod1 正常 pod2 失败 )
4. 修改为node1节点设置一个污点: tag=heima:NoExecute；然后创建pod3 ( 3个pod都失败 )

# 为node1设置污点(PreferNoSchedule)
[root@k8s-master01 ~]# kubectl taint nodes node1 tag=heima:PreferNoSchedule# 创建pod1
[root@k8s-master01 ~]# kubectl run taint1 --image=nginx:1.17.1 -n dev
[root@k8s-master01 ~]# kubectl get pods -n dev -o wide
NAME                      READY   STATUS    RESTARTS   AGE     IP           NODE
taint1-7665f7fd85-574h4   1/1     Running   0          2m24s   10.244.1.59   node1    # 为node1设置污点(取消PreferNoSchedule，设置NoSchedule)
[root@k8s-master01 ~]# kubectl taint nodes node1 tag:PreferNoSchedule-
[root@k8s-master01 ~]# kubectl taint nodes node1 tag=heima:NoSchedule# 创建pod2
[root@k8s-master01 ~]# kubectl run taint2 --image=nginx:1.17.1 -n dev
[root@k8s-master01 ~]# kubectl get pods taint2 -n dev -o wide
NAME                      READY   STATUS    RESTARTS   AGE     IP            NODE
taint1-7665f7fd85-574h4   1/1     Running   0          2m24s   10.244.1.59   node1
taint2-544694789-6zmlf    0/1     Pending   0          21s     <none>        <none>   # 为node1设置污点(取消NoSchedule，设置NoExecute)
[root@k8s-master01 ~]# kubectl taint nodes node1 tag:NoSchedule-
[root@k8s-master01 ~]# kubectl taint nodes node1 tag=heima:NoExecute# 创建pod3
[root@k8s-master01 ~]# kubectl run taint3 --image=nginx:1.17.1 -n dev
[root@k8s-master01 ~]# kubectl get pods -n dev -o wide
NAME                      READY   STATUS    RESTARTS   AGE   IP       NODE     NOMINATED
taint1-7665f7fd85-htkmp   0/1     Pending   0          35s   <none>   <none>   <none>
taint2-544694789-bn7wb    0/1     Pending   0          35s   <none>   <none>   <none>
taint3-6d78dbd749-tktkq   0/1     Pending   0          6s    <none>   <none>   <none>

小提示：
使用kubeadm搭建的集群，默认就会给master节点添加一个污点标记（NoSchedule）,所以pod就不会调度到master节点上.

容忍（Toleration）

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

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

下面先通过一个案例看下效果：

1. 上一小节，已经在node1节点上打上了NoExecute的污点，此时pod是调度不上去的
2. 本小节，可以通过给pod添加容忍，然后将其调度上去

创建pod-toleration.yaml,内容如下

apiVersion: v1
kind: Pod
metadata:name: pod-tolerationnamespace: dev
spec:containers:- name: nginximage: nginx:1.17.1tolerations:      # 添加容忍- key: "tag"        # 要容忍的污点的keyoperator: "Equal" # 操作符value: "heima"    # 容忍的污点的valueeffect: "NoExecute"   # 添加容忍的规则，这里必须和标记的污点规则相同

# 添加容忍之前的pod
[root@k8s-master01 ~]# kubectl get pods -n dev -o wide
NAME             READY   STATUS    RESTARTS   AGE   IP       NODE     NOMINATED
pod-toleration   0/1     Pending   0          3s    <none>   <none>   <none>           # 添加容忍之后的pod
[root@k8s-master01 ~]# kubectl get pods -n dev -o wide
NAME             READY   STATUS    RESTARTS   AGE   IP            NODE    NOMINATED
pod-toleration   1/1     Running   0          3s    10.244.1.62   node1   <none>

下面看一下容忍的详细配置:

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

参考：
kuboard Kubernetes 进阶
Kubernetes详细教程-调整版

5. Kubernetes 进阶之容器组（Pod）相关推荐

1. k8s pod内部容器_第三章 pod：运行于kubernetes中的容器

   本章内容涵盖 创建. 启动和停止 pod 使用标签组织 pod 和其他资源 使用特定标签对所有 pod 执行操作 使用命名空间将多个 pod 分到不重叠的组中 调度 pod 到指定类型的工作节点 上一 ...

2. Kubernetes 进阶训练营 Pod基础

   Pod基础 K8s架构图 组件 kube-apiserver kube-controller-manager kube-controller-manageer kube-scheduler kubel ...

3. 容器编排技术 -- kubernetes 通过环境变量向容器暴露 Pod 信息

   容器编排技术 -- kubernetes 通过环境变量向容器暴露 Pod 信息 1 Before you begin 2 Downward API 3 使用 Pod 字段作为环境变量的值 4 使用容器 ...

4. 容器编排技术 -- Kubernetes 给容器和Pod分配CPU资源

   容器编排技术 -- Kubernetes 给容器和Pod分配CPU资源 1 Before you begin 2 创建一个命名空间 3 声明一个CPU申请和限制 4 CPU 单位 5 请求的CPU超出 ...

5. 容器编排技术 -- Kubernetes 给容器和Pod分配内存资源

   容器编排技术 -- Kubernetes 给容器和Pod分配内存资源 1 Before you begin 2 创建一个命名空间 3 配置内存申请和限制 4 超出容器的内存限制 5 配置超出节点能力范 ...

6. Kubernetes基础：包含多个容器的Pod

   在前面的文章中介绍了Pod的使用方法,示例中的Pod包含一个容器,这篇文章介绍一下包含多个容器的Pod的使用方法. YAML文件示例 [root@host131 Pod]# cat multi-pod ...

7. kubernetes 通过环境变量向容器暴露 Pod 信息

   kubernetes 通过环境变量向容器暴露 Pod 信息 在学习docker的时候,大家可能经常看到不少示例在docker run的时候指定环境变量(比如wordpress的docker示例就是通过 ...

8. 容器与Pod到底有什么区别和联系？

   点击上方"朱小厮的博客",选择"设为星标" 后台回复"书",获取 后台回复"k8s",可领取k8s资料 容器本可以成为轻 ...

9. 基于Kubernetes构建企业容器云

   前言 团队成员有DBA.运维.Python开发,由于需要跨部门向公司私有云团队申请虚拟机, 此时我在思考能否在现有已申请的虚拟机之上,再进行更加细粒度的资源隔离和划分,让本团队的成员使用, 也就是在私 ...

最新文章

1. 参与开源项目，结识技术大牛！CSDN “开源加速器计划”招募志愿者啦！
2. 在Android开发中，有哪些好的内存优化方式？如何避免 Out Of Memory(OOM) ？
3. 用信号量实现任务间单向同步
4. 《计算机网络》学习笔记_(2、物理层)
5. JPA教程：实体映射-第2部分
6. 运用Arc Hydro提取河网
7. 还驾驭不了4核？ 别人已模拟出百万核心上的并行
8. [JavaScript] 函数同名问题
9. 有没有发现4G网速越来越慢了？
10. ofo（小黄车）项目分析
11. 算法题04：分治法：求第K小元素（线性时间选择算法）
12. php ip纯真数据库Dat,php查询IP地理位置（dat数据库）-纯真IP数据库
13. 魅族android11,魅族17系列即将吃上安卓11，信息保护更稳了？
14. Python中类的多继承
15. 入门全栈Java程序员——CSS
16. 错过校招_我们在用户测试中容易错过的事情
17. 英特尔cpu发布时间表_英特尔延长CPU发布周期：摩尔定律终结
18. shell编程——select语句
19. Photoshop生成320*320像素图片
20. 微信公众号批量打标签的自动化实现方法

热门文章

1. hpm725打印机拆解_惠普笔记本拆解详细教程
2. 微信开发者工具地址自动跳转https问题处理
3. 流技术安全系统-流量流向监控技术
4. python推箱子游戏代码_用python入门知识做推箱子游戏，若能打过第三关，则可以学会编程...
5. 真正从0开始用Unity3D制作类战地2玩法的类龙之谷、王者荣耀的手游（暨全平台游戏）
6. 关于xml文件出现valid xml document must have a root tag错误的解决方法
7. Supervisor：优秀的进程管理工具
8. PHP四舍五入，不足补零
9. Alios-Thins教程连载 ③ 图文并茂教你使用乐鑫esp8266轻松连接阿里飞燕平台，个人设备实现轻松对接天猫精灵 。(上篇)（附带demo）
10. linux桌面显示主文件夹,Ubuntu在桌面上显示主文件夹内容