InitContainer: 初始化容器的概念与使用

在真正的容器启动之前，先启动 InitContainer，在初始化容器中完成真实容器所需的初始化操作，完成后再启动真实的容器。
相对于 postStart 来说，首先 InitController 能够保证一定在 EntryPoint 之前执行，而 postStart 不能，其次 postStart 更适合去执行一些命令操作，而 InitController 实际就是一个容器，可以在其他基础容器环境下执行更复杂的初始化功能。
在 pod 创建的模板中配置 initContainers 参数：

  initContainers:
  - image: nginx
    imagePullPolicy: IfNotPresent
    command: ["sh", "-c", "echo 'inited;' >> ~/.init"]
    name: init-test

[root@k8s-master jobs]# kubectl get deploy
NAME           READY   UP-TO-DATE   AVAILABLE   AGE
nginx          1/1     1            1           13d
nginx-deploy   2/2     2            2           7d22h
[root@k8s-master jobs]#  kubectl edit  deploy  nginx-deploy

   spec:
      initContainers:
        - image: nginx
          imagePullPolicy: IfNotPresent
          command: ['sh', '-c', 'mkdir -p /data && echo "Initialization complete." > /data/initialized']
          name: init-test  

**ini init-test **是一个初始化容器，它使用nginx镜像执行一个简单的命令，将文本写入 /data/initialized 文件。主应用容器可以共享这个初始化过程中创建的 /data 目录。

[root@k8s-master jobs]# kubectl get po
NAME                            READY   STATUS     RESTARTS      AGE
nginx-deploy-55c8848694-dl8k4 0/1     Init:0/1   0             9s
#Pod 的状态为 Init:0/1 表示初始化容器尚未完成

查看 Pod 的详细信息

[root@k8s-master jobs]# kubectl describe pod nginx-deploy-55c8848694-dl8k4
Events:
  Type    Reason     Age   From               Message
  ----    ------     ----  ----               -------
  Normal  Scheduled  98s   default-scheduler  Successfully assigned default/nginx-deploy-6467fd6b6b-bzj6k to k8s-node1
  Normal  Pulled     97s   kubelet            Container image "nginx" already present on machine
  Normal  Created    97s   kubelet            Created container init-test
  Normal  Started    97s   kubelet            Started container init-test
  Normal  Pulled     86s   kubelet            Container image "nginx:1.7.9" already present on machine
  Normal  Created    86s   kubelet            Created container nginx
  Normal  Started    86s   kubelet            Started container nginx

Created： 容器 init-test 被创建（Created container init-test）。
Started： 容器 init-test 已经启动（Started container init-test）。

污点和容忍

污点（Taints）

概念： 污点是一种将限制条件附加到节点的方式，以影响 Pod 是否能够在该节点上调度。如果节点被设置了污点，只有在 Pod 设置了相应容忍规则时，它们才能够被调度到该节点上。

• 通过在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-

接下来，演示下污点的效果：
准备节点node1（为了演示效果更加明显，暂时停止node2节点）

1. 为node1节点设置一个污点: tag=heima:PreferNoSchedule；然后创建pod1( pod1 可以 )
2. 修改为node1节点设置一个污点: tag=heima:NoSchedule；然后创建pod2( pod1 正常 pod2 失败 )
3. 修改为node1节点设置一个污点: tag=heima:NoExecute；然后创建pod3 ( 3个pod都失败 )# 为node1设置污点(PreferNoSchedule)

# 为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  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
pod-configmap   1/1     Running   0          4d      10.244.1.69   k8s-node1   <none>           <none>
pod-secret      1/1     Running   0          3d23h   10.244.1.70   k8s-node1   <none>           <none>
taint1          1/1     Running   0          2m24s   10.244.1.59   node1 
taint2          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
#一旦 Pod 被驱逐，它将处于 Pending 状态，
[root@k8s-master01 ~]# kubectl get pods -n dev -o wide 
NAME          READY   STATUS    RESTARTS   AGE   IP       NODE     NOMINATED 
taint3         0/1     Pending   0          6s    <none>   <none>   <none>     

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

这样的污点标记会防止普通的 Pod 被调度到 master 节点上
这是为了避免在 master 节点上运行用户应用程序，以确保 master 节点专注于集群管理和控制平面的运行。如果需要在 master 节点上运行一些特殊的工作负载，可以手动添加相应的容忍规则，使得 Pod 能够在 master 节点上调度。

容忍（Tolerations）：

容忍是在 Pod 中设置的规则，用于指示该 Pod 是否能够容忍节点上的特定污点。如果 Pod 设置了与节点上的污点匹配的容忍规则，那么该 Pod 就可以被调度到具有该污点的节点上。

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

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

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

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

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

[root@k8s-master k8s]# kubectl apply -f pod-toleration.yaml
pod/pod-toleration created
[root@k8s-master k8s]#  kubectl get pods -n dev -o wide
NAME             READY   STATUS    RESTARTS   AGE     IP            NODE        NOMINATED NODE   READINESS GATES
pod-toleration   1/1     Running   0          2s      10.244.1.93   k8s-node1   <none>           <none>
taint3           0/1     Pending   0          6m50s   <none>        <none>      <none>           <none>

#pod-toleration   添加容忍之后的pod 状态为 Running
#taint3     添加容忍之前的pod  状态为Pending

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

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

亲和性调度

亲和性调度在NodeSelector的基础之上的进行了扩展，可以通过配置的形式，实现优先选择满足条件的Node进行调度，如果没有，也可以调度到不满足条件的节点上，使调度更加灵活。

亲和性调度（Affinity）是 Kubernetes 中用于定义 Pod 与节点或其他 Pod 之间关系的一种机制。通过使用亲和性，你可以控制 Pod 的调度行为，使其倾向于或避免某些节点或其他 Pod。亲和性分为三种主要类型:

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

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

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

节点亲和性（Node Affinity）

节点亲和性是指你可以定义 Pod 与节点关系的规则。这可以通过 nodeAffinity 字段来实现。节点亲和性有两种策略：

• requiredDuringSchedulingIgnoredDuringExecution： 意味着这个规则在调度时必须被满足，但在 Pod 运行时可以被忽略。
• preferredDuringSchedulingIgnoredDuringExecution： 意味着这个规则在调度时是首选，但不是必须的，同样在 Pod 运行时可以被忽略。

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

#关系符的使用说明:
- matchExpressions:
  - key: nodeenv              # 匹配存在标签的key为nodeenv的节点
    operator: Exists
  - key: nodeenv              # 匹配标签的key为nodeenv,且value是"xxx"或"yyy"的节点
    operator: In
    values: ["xxx","yyy"]
  - key: nodeenv              # 匹配标签的key为nodeenv,且value大于"xxx"的节点
    operator: Gt
    values: "xxx"

requiredDuringSchedulingIgnoredDuringExecution节点亲和性示例

创建pod-nodeaffinity-required.yaml

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

要求节点的 nodeenv 标签的值必须是 “xxx” 或 “yyy” 中的一个，Pod 只会被调度到具有 nodeenv 标签且值为 “xxx” 或 “yyy” 的节点上。

# 创建pod 
[root@k8s-master Affinity]# kubectl create -f pod-nodeaffinity-required.yaml
pod/pod-nodeaffinity-required created


# 查看pod状态 （运行失败）
[root@k8s-master Affinity]# 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          6s    <none>   <none>   <none>           <none>


# 查看Pod的详情
# 发现调度失败，提示node选择失败
[root@k8s-master Affinity]#  kubectl describe pod pod-nodeaffinity-required -n dev
Events:
  Type     Reason            Age   From               Message
  ----     ------            ----  ----               -------
  Warning  FailedScheduling  16s   default-scheduler  0/2 nodes are available: 1 node(s) didn't match Pod's node affinity/selector, 1 node(s) had taint {node-role.kubernetes.io/master: }, that the pod didn't tolerate.


#接下来，停止pod
[root@k8s-master Affinity]#  kubectl delete -f pod-nodeaffinity-required.yaml
pod "pod-nodeaffinity-required" delete

#为node打上标签 
[root@k8s-master Affinity]# kubectl label nodes k8s-node1 nodeenv=pro
node/k8s-node1 labeled
#查看node标签现在node上存在了pro的标签
[root@k8s-master Affinity]# kubectl get nodes k8s-node1 --show-labels
NAME        STATUS   ROLES    AGE   VERSION     LABELS
k8s-node1   Ready    <none>   20d   v1.23.17 ...nodeenv=pro

# 修改文件，将values: ["xxx","yyy"]------> ["pro","yyy"]
[root@k8s-master Affinity]#  vim pod-nodeaffinity-required.yaml

# 再次启动
[root@k8s-master Affinity]#  kubectl create -f pod-nodeaffinity-required.yaml
pod/pod-nodeaffinity-required created

# 此时查看，发现调度成功，已经将pod调度到了node1上
[root@k8s-master Affinity]#  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          9s    10.244.1.100   k8s-node1   <none>           <none>

requiredDuringSchedulingIgnoredDuringExecution节点亲和性示例

创建pod-nodeaffinity-preferred.yaml

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

# 创建pod
[root@k8s-master01 ~]# kubectl create -f pod-nodeaffinity-preferred.yaml
pod/pod-nodeaffinity-preferred created

# 查看pod状态 （运行成功）
[root@k8s-master01 ~]# kubectl get pod pod-nodeaffinity-preferred -n dev
NAME                         READY   STATUS    RESTARTS   AGE
pod-nodeaffinity-preferred   1/1     Running   0          40s

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

Pod 亲和性（Pod Affinity）

PodAffinity主要实现以运行的Pod为参照，实现让新创建的Pod跟参照pod在一个区域的功能。
首先来看一下PodAffinity的可配置项：

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

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

requiredDuringSchedulingIgnoredDuringExecution

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

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

# 启动目标pod
[root@k8s-master01 ~]# kubectl create -f pod-podaffinity-target.yaml
pod/pod-podaffinity-target created

# 查看pod状况
[root@k8s-master01 ~]# kubectl get pods  pod-podaffinity-target -n dev
NAME                     READY   STATUS    RESTARTS   AGE
pod-podaffinity-target   1/1     Running   0          4s

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

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

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

# 启动pod
[root@k8s-master01 ~]# kubectl create -f pod-podaffinity-required.yaml
pod/pod-podaffinity-required created

# 查看pod状态，发现未运行
[root@k8s-master01 ~]# kubectl get pods pod-podaffinity-required -n dev
NAME                       READY   STATUS    RESTARTS   AGE
pod-podaffinity-required   0/1     Pending   0          9s

# 查看详细信息
[root@k8s-master01 ~]# kubectl describe pods pod-podaffinity-required  -n dev
......
Events:
  Type     Reason            Age        From               Message
  ----     ------            ----       ----               -------
  Warning  FailedScheduling  <unknown>  default-scheduler  0/3 nodes are available: 2 node(s) didn't match pod affinity rules, 1 node(s) had taints that the pod didn't tolerate.


#

# 接下来修改  values: ["xxx","yyy"]----->values:["pro","yyy"]
# 意思是：新Pod必须要与拥有标签nodeenv=xxx或者nodeenv=yyy的pod在同一Node上
[root@k8s-master01 ~]# vim pod-podaffinity-required.yaml

# 然后重新创建pod，查看效果
[root@k8s-master01 ~]# kubectl delete -f  pod-podaffinity-required.yaml
pod "pod-podaffinity-required" de leted
[root@k8s-master01 ~]# kubectl create -f pod-podaffinity-required.yaml
pod/pod-podaffinity-required created

# 发现此时Pod运行正常
[root@k8s-master01 ~]# kubectl get pods pod-podaffinity-required -n dev
NAME                       READY   STATUS    RESTARTS   AGE   LABELS
pod-podaffinity-required   1/1     Running   0          6s    <none>

PodAntiAffinity (Pod反亲和性)

PodAntiAffinity主要实现以运行的Pod为参照，让新创建的Pod跟参照pod不在一个区域中的功能。
它的配置方式和选项跟PodAffinty是一样的，这里不再做详细解释，直接做一个测试案例。
1）继续使用上个案例中目标pod

[root@k8s-master01 ~]# kubectl get pods -n dev -o wide --show-labels
NAME                     READY   STATUS    RESTARTS   AGE     IP            NODE    LABELS
pod-podaffinity-required 1/1     Running   0          3m29s   10.244.1.38   node1   <none>     
pod-podaffinity-target   1/1     Running   0          9m25s   10.244.1.37   node1   podenv=pro

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

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

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

# 创建pod
[root@k8s-master01 ~]# kubectl create -f pod-podantiaffinity-required.yaml
pod/pod-podantiaffinity-required created

# 查看pod
# 发现调度到了node2上
[root@k8s-master01 ~]# kubectl get pods pod-podantiaffinity-required -n dev -o wide
NAME                           READY   STATUS    RESTARTS   AGE   IP            NODE   .. 
pod-podantiaffinity-required   1/1     Running   0          30s   10.244.1.96   node2  ..