Pod控制器

# 简介

在kubernetes中，Pod是最小的控制单元，但是kubernetes很少直接控制Pod，一般都是通过Pod控制器来完成的
Pod控制器用于Pod的管理，确保Pod资源符合预期的状态，当Pod的资源出现故障的时候，会尝试进行重启或重建Pod

**在kubernetes中，按照Pod的创建方式可以将其分为两类：**
- 自主式Pod：kubernetes直接创建出来的Pod，这种Pod删除后就没有了，也不会重建
- 控制器创建Pod：通过Pod控制器创建的Pod，这种Pod删除之后还会自动重建

**在kubernetes中，有很多类型的Pod控制器，每种都有自己的适合的场景，常见的有下面这些：**
- ReplicationController：比较原始的Pod控制器，已经被废弃，由ReplicaSet替代
- ReplicaSet：保证指定数量的Pod运行，并支持Pod数量变更，镜像版本变更
- Deployment：通过控制ReplicaSet来控制Pod，并支持滚动升级、版本回退
- Horizontal Pod Autoscaler：可以根据集群负载自动调整Pod的数量，实现削峰填谷
- DaemonSet：在集群中的指定Node上都运行一个副本，一般用于守护进程类的任务
- Job：它创建出来的Pod只要完成任务就立即退出，用于执行一次性任务
- CronJob：它创建的Pod会周期性的执行，用于执行周期性的任务
- StatefulSet：管理有状态的应用

# ReplicaSet（RS）

主要作用是保证一定数量的Pod能够正常运行，持续监听这些Pod的运行状态，一旦Pod发生故障，就会重启或重建。
同时它还支持对Pod数量的扩缩容和版本镜像升级。

![](/media/202406/2024-06-26_132440_8574230.9124124530378258.png)

## 资源清单

```asp
apiVersion: apps/v1       #版本号
kind: ReplicaSet          #类型
metadata:                 #元数据
  name:                   #rs名称
  namespace:              #所属命名空间
  labels:                 #标签
    controller: rs
spec:                     #详情描述
  replicas: 3             #副本数量
  selector:               #选择器，通过它指定该控制器管理哪些po
    matchLabels:          #Labels匹配规则
      app: nginx-pod
    matchExpressions:     #Expressions匹配规则
      - {key: app, operator: In, values: [nginx-pod]}
template:                 #模板，当副本数量不足时，会根据下面的模板创建pod副本
  metadata:
    labels:
      app: nginx-pod
  spec:
    containers:
      - name: nginx
        image: nginx:1.17.1
        ports:
        - containerPort: 80
```
## 基本操作
**启动**
创建pc-replicaset.yaml
```asp
cat <<EOF> pc-replicaset.yaml
apiVersion: apps/v1
kind: ReplicaSet             #控制器类型
metadata:
  name: pc-replicaset
  namespace: dev
spec:
  replicas: 3                #副本数量
  selector:
    matchLabels:
      app: nginx-pod
  template:
    metadata:
      labels:
        app: nginx-pod
    spec:
      containers:
        - name: nginx
          image: nginx:1.17.1 #镜像版本
EOF
```
运行
```asp
kubectl create -f pc-replicaset.yaml
```
**查看**
DESIRED:期望数量、CURRENT：当前数量、READY：就绪数量
```asp
kubectl get rs -n dev -o wide
```
```asp
NAME            DESIRED   CURRENT   READY   AGE     CONTAINERS   IMAGES         SELECTOR
pc-replicaset   3         3         3       3m31s   nginx        nginx:1.17.1   app=nginx-pod
```
## 扩/缩容
edit修改（replicas:3修改为6、image:nginx:1.17.1修改为1.17.2，wq保存退出）
```asp
kubectl edit rs pc-replicaset -n dev
```
再次查看rs（pod数量变为6个，nginx版本变为1.17.2）
```asp
kubectl get rs -n dev -o wide
```
```asp
NAME            DESIRED   CURRENT   READY   AGE     CONTAINERS   IMAGES         SELECTOR
pc-replicaset   6         6         6       8m40s   nginx        nginx:1.17.2   app=nginx-pod
```
scale修改（修改pod启动数量）
```asp
kubectl scale rs pc-replicaset --replicas=2 -n dev
```
再次查看（pod数量变为2个）
```asp
kubectl get rs -n dev -o wide
```
```asp
NAME            DESIRED   CURRENT   READY   AGE   CONTAINERS   IMAGES         SELECTOR
pc-replicaset   2         2         2       17m   nginx        nginx:1.17.2   app=nginx-pod
```
set修改（修改nginx版本）
```asp
kubectl set image rs pc-replicaset nginx=nginx:1.17.3 -n dev
```
再次查看rs（nginx版本变为1.17.3）
```asp
kubectl get rs -n dev -o wide
```
```asp
NAME            DESIRED   CURRENT   READY   AGE   CONTAINERS   IMAGES         SELECTOR
pc-replicaset   2         2         2       24m   nginx        nginx:1.17.3   app=nginx-pod
```
**删除**
删除控制器及所控制的pod
```asp
kubectl delete -f pc-replicaset.yaml
```
仅删除控制器保留pod（不推荐）
```asp
kubectl delete rs pc-replicaset -n dev --cascade=false
```

# Deployment（Deploy）

在v1.2版本开始，引入了Deployment控制器，Deployment控制器并不直接管理Pod而是通过管理ReplicaSet来间接管理Pod
Deployment支持ReplicaSet的所有功能、支持发布的停止/继续、支持版本滚动更新和版本回退

![](/media/202406/2024-06-26_141747_9124260.23277898786204543.png)

## 资源清单

```asp
apiVersion: apps/v1             #版本号
kind: Deployment                #类型
metadata:                       #元数据
  name:                         #rs名称
  namespace:                    #所属命名空间
  labels:                       #标签
    controller: deploy
spec:                           #详情描述
  replicas: 3                   #副本数量
  revisionHistoryLimit: 3       #保留历史版本，默认为10
  paused: false                 #暂停部署，默认是false
  progressDeadlineSeconds: 600  #部署超时时间（s），默认是600
  strategy:                     #策略
    type: RollingUpdate         #滚动更新策略
    rollingUpdate:              #滚动更新
      maxSurge: 30%             #最大额外可以存在的副本数，可以为百分比，也可以为整数
      maxUnavailable: 30%       #最大不可用状态的 Pod 的最大值，可以为百分比，也可以为整数
  selector:                     #选择器，通过它指定该控制器管理哪些pod
    matchLabels:                #Labels匹配规则
      app: nginx-pod
    matchExpressions:           #Expressions匹配规则
      - {key: app, operator: In, values: [nginx-pod]}
  template:                     #模板，当副本数量不足时，会根据下面的模板创建pod副本
    metadata:
      labels:
        app: nginx-pod
    spec:
      containers:
      - name: nginx
        image: nginx:1.17.1
        ports:
        - containerPort: 80
```

## 基本操作

**启动**
创建pc-deployment.yaml
```asp
cat <<EOF> pc-deployment.yaml
apiVersion: apps/v1
kind: Deployment             #控制器类型
metadata:
  name: pc-deployment
  namespace: dev
spec:
  replicas: 3                 #副本数量
  selector:
    matchLabels:
      app: nginx-pod
  template:
    metadata:
      labels:
        app: nginx-pod
    spec:
      containers:
        - name: nginx
          image: nginx:1.17.1  #镜像版本
EOF
```
运行
```asp
kubectl create -f pc-deployment.yaml
```

**查看**
UP-TO-DATE：最新版本pod的数量、AVAILABLE：当前可用的pod数量
```asp
kubectl get -f pc-deployment.yaml -o wide
```
```asp
NAME            READY   UP-TO-DATE   AVAILABLE   AGE   CONTAINERS   IMAGES         SELECTOR
pc-deployment   3/3     3            3           21s   nginx        nginx:1.17.1   app=nginx-pod
```

## 扩/缩容
edit修改（replicas:3修改为6、image:nginx:1.17.1修改为1.17.2，wq保存退出）
```asp
kubectl edit -f pc-deployment.yaml -n dev
```
再次查看（pod数量变为6个，nginx版本变为1.17.2）
```asp
kubectl get -f pc-deployment.yaml -o wide
```
```asp
NAME            READY   UP-TO-DATE   AVAILABLE   AGE   CONTAINERS   IMAGES         SELECTOR
pc-deployment   2/2     2            2           71s   nginx        nginx:1.17.2   app=nginx-pod
```
scale修改（修改pod启动数量）
```asp
kubectl scale deploy pc-deployment --replicas=2 -n dev
```
再次查看（pod数量变为2个）
```asp
kubectl get -f pc-deployment.yaml -o wide
```
```asp
NAME            READY   UP-TO-DATE   AVAILABLE   AGE     CONTAINERS   IMAGES         SELECTOR
pc-deployment   2/2     2            2           2m52s   nginx        nginx:1.17.2   app=nginx-pod
```
set修改（修改nginx版本）
```asp
kubectl set image deploy pc-deployment nginx=nginx:1.17.3 -n dev
```
再次查看（nginx版本变为1.17.3）
```asp
kubectl get -f pc-deployment.yaml -o wide
```
```asp
NAME            READY   UP-TO-DATE   AVAILABLE   AGE     CONTAINERS   IMAGES         SELECTOR
pc-deployment   2/2     2            2           4m21s   nginx        nginx:1.17.3   app=nginx-pod
```

**删除**
删除名为nginx的pod控制器，该控制器下所有pod都会被删除
```asp
kubectl delete -f pc-deployment.yaml
```

## 版本升级

Deployment支持两种镜像更新的策略：重建更新和滚动更新（默认），通过strategy选项进行配置。

### Recreate（重建更新）

重建更新，期间先杀掉所有已经存在的旧版本Pod在创建新版本的Pod

创建pc-deployment-recreate.yaml
```asp
cat <<EOF> pc-deployment-recreate.yaml
apiVersion: apps/v1
kind: Deployment      #控制器类型
metadata:
  name: pc-deployment-recreate
  namespace: dev
spec:
  strategy:           #镜像更新策略
    type: Recreate    #创建新pod同时杀死所有旧pod
  replicas: 3
  selector:
    matchLabels:
      app: nginx-pod
  template:
    metadata:
      labels:
        app: nginx-pod
    spec:
      containers:
        - name: nginx
          image: nginx:1.17.1
EOF
```
启动
```asp
kubectl create -f pc-deployment-recreate.yaml
```
更新版本
```asp
kubectl set image deploy pc-deployment-recreate nginx=nginx:1.17.2 -n dev
```
查看（开启另外一个终端观察过程可以看出来同时更新就是同时杀死所有pod然后创建新的pod）
```asp
kubectl get pod -n dev -w
```
```asp
NAME                                      READY   STATUS           RESTARTS      AGE
pc-deployment-recreate-858db84f89-l7946   1/1     Running             0          2m20s
pc-deployment-recreate-858db84f89-lg7st   1/1     Running             0          2m20s
pc-deployment-recreate-858db84f89-rfzb7   1/1     Running             0          2m20s
pc-deployment-recreate-858db84f89-l7946   1/1     Terminating         0          3m11s
pc-deployment-recreate-858db84f89-lg7st   1/1     Terminating         0          3m11s
pc-deployment-recreate-858db84f89-rfzb7   1/1     Terminating         0          3m11s
pc-deployment-recreate-6c78d7875b-s667g   0/1     Pending             0          0s
pc-deployment-recreate-6c78d7875b-2r7bs   0/1     Pending             0          0s
pc-deployment-recreate-6c78d7875b-s667g   0/1     Pending             0          0s
pc-deployment-recreate-6c78d7875b-2r7bs   0/1     ContainerCreating   0          2s
pc-deployment-recreate-6c78d7875b-s667g   0/1     ContainerCreating   0          2s
pc-deployment-recreate-6c78d7875b-sgmd9   0/1     ContainerCreating   0          2s
pc-deployment-recreate-6c78d7875b-s667g   1/1     Running             0          30s
pc-deployment-recreate-6c78d7875b-2r7bs   1/1     Running             0          31s
pc-deployment-recreate-6c78d7875b-sgmd9   1/1     Running             0          47s
```
删除
```asp
kubectl delete -f pc-deployment-recreate.yaml
```

### RollingUpdate（滚动更新）

滚动更新，先杀死一部分启动一部分，在更新过程中，存在两个版本的Pod

![](/media/202406/2024-06-26_152332_3623410.8707747347426591.png)

创建pc-deployment-rollingupdate.yaml
```asp
cat <<EOF> pc-deployment-rollingupdate.yaml
apiVersion: apps/v1
kind: Deployment             #控制器类型
metadata:
  name: pc-deployment-rollingupdate
  namespace: dev
spec:
  strategy:                  #镜像更新策略
    type: RollingUpdate      #在更新过程中，存在两个版本的Pod
    rollingUpdate:
      maxUnavailable: 25%    #升级过程中不可用的Pod的最大数量
      maxSurge: 25%          #升级过程中可以超过期望的Pod的最大数量
  replicas: 3
  selector:
    matchLabels:
      app: nginx-pod
  template:
    metadata:
      labels:
        app: nginx-pod
    spec:
      containers:
        - name: nginx
          image: nginx:1.17.1
EOF
```
启动（--record：记录更新日志）
```asp
kubectl create -f pc-deployment-rollingupdate.yaml --record
```
更新版本
```asp
kubectl set image deploy pc-deployment-rollingupdate nginx=nginx:1.17.2 -n dev
```
查看（开启另外一个终端观察过程可以看出来滚动更新就是每创建1个新的pod就杀死1个旧的pod）
```asp
kubectl get pod -n dev -w
```
```asp
kubectl get pod -n dev -w
NAME                                           READY   STATUS              RESTARTS   AGE
pc-deployment-rollingupdate-858db84f89-h9kgt   1/1     Running             0          8s
pc-deployment-rollingupdate-858db84f89-khl5b   1/1     Running             0          8s
pc-deployment-rollingupdate-858db84f89-w84nq   1/1     Running             0          8s
pc-deployment-rollingupdate-6c78d7875b-j9ng6   1/1     Running             0          2s
pc-deployment-rollingupdate-858db84f89-w84nq   1/1     Terminating         0          31s
pc-deployment-rollingupdate-6c78d7875b-stfph   1/1     Running             0          3s
pc-deployment-rollingupdate-858db84f89-khl5b   1/1     Terminating         0          34s
pc-deployment-rollingupdate-6c78d7875b-mlwtc   1/1     Running             0          2s
pc-deployment-rollingupdate-858db84f89-h9kgt   1/1     Terminating         0          36s
```
删除
```asp
kubectl delete -f pc-deployment-rollingupdate.yaml
```

## 版本回退

版本升级过程中实际是产生了一个新的RS，原来的RS保留为版本回退预留操作空间

创建pc-deployment-rollout.yaml
```asp
cat <<EOF> pc-deployment-rollout.yaml
apiVersion: apps/v1
kind: Deployment      #控制器类型
metadata:
  name: pc-deployment-rollout
  namespace: dev
spec:
  strategy:           #镜像更新策略
    type: Recreate    #创建新pod同时杀死所有旧pod
  replicas: 3
  selector:
    matchLabels:
      app: nginx-pod
  template:
    metadata:
      labels:
        app: nginx-pod
    spec:
      containers:
        - name: nginx
          image: nginx:1.17.1
EOF
```
启动
```asp
kubectl create -f pc-deployment-rollout.yaml
```
查看当前版本和RS（版本号都是更新后的1.17.1、所有pod都在第一次创建生成的RS中）
```asp
kubectl get rs -n dev -o wide
```
```asp
NAME                               DESIRED   CURRENT   READY   AGE   CONTAINERS   IMAGES         SELECTOR
pc-deployment-rollout-858db84f89   3         3         3       40s   nginx        nginx:1.17.1   app=nginx-pod,pod-template-hash=858db84f89
```
更新版本
```asp
kubectl set image deploy pc-deployment-rollout nginx=nginx:1.17.2 -n dev
```

### status（状态）

显示当前升级的状态（升级过程日志直至完成）
```asp
kubectl rollout status deploy pc-deployment-rollout -n dev
```
```asp
Waiting for deployment "pc-deployment-rollout" rollout to finish: 0 out of 3 new replicas have been updated...
Waiting for deployment "pc-deployment-rollout" rollout to finish: 0 of 3 updated replicas are available...
Waiting for deployment "pc-deployment-rollout" rollout to finish: 1 of 3 updated replicas are available...
Waiting for deployment "pc-deployment-rollout" rollout to finish: 2 of 3 updated replicas are available...
deployment "pc-deployment-rollout" successfully rolled out
```
查看当前版本和RS（版本号都是更新后的1.17.2、所有pod都在第2次更新生成的RS中）
```asp
kubectl get rs -n dev -o wide
```
```asp
NAME                               DESIRED   CURRENT   READY   AGE     CONTAINERS   IMAGES         SELECTOR
pc-deployment-rollout-6c78d7875b   3         3         3       52s     nginx        nginx:1.17.2   app=nginx-pod,pod-template-hash=6c78d7875b
pc-deployment-rollout-858db84f89   0         0         0       2m41s   nginx        nginx:1.17.1   app=nginx-pod,pod-template-hash=858db84f89
```

### history（历史）

显示升级历史记录，创建控制器时候需要加--record参数（REVISION=1是1.17.1版本、REVISION=2是1.17.2版本）
```asp
kubectl rollout history deploy pc-deployment-rollout -n dev
```
```asp
deployment.apps/pc-deployment-rollout
REVISION  CHANGE-CAUSE
1         <none>
2         <none>
```

### undo（回退）

回滚到历史版本（--to-revision=1就是1.17.1版本）
```asp
kubectl rollout undo deployment pc-deployment-rollout --to-revision=1 -n dev
```
查看RS（版本变为1.17.1，pod都运行到初始的第一个RS中）
```asp
kubectl get rs -n dev -o wide
```
```asp
NAME                               DESIRED   CURRENT   READY   AGE     CONTAINERS   IMAGES         SELECTOR
pc-deployment-rollout-6c78d7875b   0         0         0       4m33s   nginx        nginx:1.17.2   app=nginx-pod,pod-template-hash=6c78d7875b
pc-deployment-rollout-858db84f89   3         3         3       6m22s   nginx        nginx:1.17.1   app=nginx-pod,pod-template-hash=858db84f89
```
再次查看历史版本（1版本没有了，3版本实际就是1版本）
```asp
kubectl rollout history deploy pc-deployment-rollout -n dev
```
```asp
deployment.apps/pc-deployment-rollout
REVISION  CHANGE-CAUSE
2         <none>
3         <none>
```
删除
```asp
kubectl delete -f pc-deployment-rollout.yaml
```

## 金丝雀发布

Deployment支持更新过程中的控制，暂停更新（pause）或继续更新操作（resume），金丝雀发布需要使用滚动更新

> 例如有一批新的Pod资源创建完成后立即暂停更新过程，此时，仅存在一部分新版本的应用，主体部分还是旧的版本。然后，再筛选一小部分的用户请求到新版本的Pod应用，继续观察能够稳定的按照期望的方式运行，如果没有问题之后再继续完成余下的Pod资源的滚动更新，否则立即回滚操作。

创建pc-deployment-pause-resume.yaml
```asp
cat <<EOF> pc-deployment-pause-resume.yaml
apiVersion: apps/v1
kind: Deployment            #控制器类型
metadata:
  name: pc-deployment-pause-resume
  namespace: dev
spec:
  strategy:                  #镜像更新策略
    type: RollingUpdate      #在更新过程中，存在两个版本的Pod
    rollingUpdate:
      maxUnavailable: 25%    #升级过程中不可用的Pod的最大数量
      maxSurge: 25%          #升级过程中可以超过期望的Pod的最大数量
  replicas: 3
  selector:
    matchLabels:
      app: nginx-pod
  template:
    metadata:
      labels:
        app: nginx-pod
    spec:
      containers:
        - name: nginx
          image: nginx:1.17.1
EOF
```
启动
```asp
kubectl create -f pc-deployment-pause-resume.yaml
```
查看当前版本和RS（版本号都是更新后的1.17.1、所有pod都在第一次创建生成的RS中）
```asp
kubectl get rs -n dev -o wide
```
```asp
NAME                                    DESIRED   CURRENT   READY   AGE    CONTAINERS   IMAGES         SELECTOR
pc-deployment-pause-resume-858db84f89   3         3         3       107s   nginx        nginx:1.17.1   app=nginx-pod,pod-template-hash=858db84f89
```

### Pause（暂停）

更新版本到1.17.2，并配置立即暂停：
```asp
kubectl set image deployment pc-deployment-pause-resume nginx=nginx:1.17.2 -n dev && kubectl rollout pause deployment pc-deployment-pause-resume -n dev
```
查看更新状态（正在等待更新，已经有1个更新完成，3个待处理）
```asp
kubectl rollout status deploy pc-deployment-pause-resume -n dev
```
```asp
Waiting for deployment "pc-deployment-pause-resume" rollout to finish: 1 out of 3 new replicas have been updated...
```
查看RS状态（3个pod是1.17.1版本，1个新运行的pod是1.17.2版本）
```asp
kubectl get rs -n dev -o wide
```
```asp
NAME                                    DESIRED   CURRENT   READY   AGE   CONTAINERS   IMAGES         SELECTOR
pc-deployment-pause-resume-6c78d7875b   1         1         1       3s    nginx        nginx:1.17.2   app=nginx-pod,pod-template-hash=6c78d7875b
pc-deployment-pause-resume-858db84f89   3         3         3       13s   nginx        nginx:1.17.1   app=nginx-pod,pod-template-hash=858db84f89
```
### Resume（继续）

测试后确保更新的Pod没问题之后，可以继续更新
```asp
kubectl rollout resume deployment pc-deployment-pause-resume -n dev
```
查看更新状态
```asp
kubectl rollout status deploy pc-deployment-pause-resume -n dev
```
```asp
deployment "pc-deployment-pause-resume" successfully rolled out
```
查看现在RS状态（3个pod都升级到1.17.2版本）
```asp
kubectl get rs -n dev -o wide
```
```asp
NAME                                    DESIRED   CURRENT   READY   AGE    CONTAINERS   IMAGES         SELECTOR
pc-deployment-pause-resume-6c78d7875b   3         3         3       101s   nginx        nginx:1.17.2   app=nginx-pod,pod-template-hash=6c78d7875b
pc-deployment-pause-resume-858db84f89   0         0         0       111s   nginx        nginx:1.17.1   app=nginx-pod,pod-template-hash=858db84f89
```
删除
```asp
kubectl delete -f pc-deployment-pause-resume.yaml
```

# Horizontal Pod Autoscaler（HPA）

通过手动执行kubectl scale命令实现Pod的扩缩容，不符合kubernetes的定位目标–自动化和智能化
kubernetes期望可以通过监测Pod的使用情况，实现Pod数量的自动调整，于是就产生了HPA这种控制器
HPA可以获取每个Pod的利用率，然后和HPA中定义的指标进行对比，同时计算出需要伸缩的具体值，最后实现Pod的数量的调整
HPA和Deployment一样，也属于一种kubernetes资源对象，它通过追踪分析目标Pod的负载变化情况，来确定是否需要针对性的调整目标Pod的副本数

## 准备工作

查看node资源使用（需要提前安装metrics-server详情见"集群部署"）
```asp
kubectl top node
```
```asp
NAME     CPU(cores)   CPU%   MEMORY(bytes)   MEMORY%
master   314m         7%     954Mi           25%
node1    200m         5%     482Mi           13%
node2    241m         6%     492Mi           13%
```

创建一个pod
```asp
kubectl run nginx --image=nginx:1.17.1 --requests=cpu=100m -n dev
```
暴漏端口
```asp
kubectl expose deployment nginx --type=NodePort --port=80 -n dev
```
查看
```asp
kubectl get deploy,pod,svc -n dev
```
```asp
NAME                    READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/nginx   1/1     1            1           34s

NAME                         READY   STATUS    RESTARTS   AGE
pod/nginx-84fb495966-vg7hx   1/1     Running   0          34s

NAME            TYPE       CLUSTER-IP       EXTERNAL-IP   PORT(S)        AGE
service/nginx   NodePort   10.108.198.143   <none>        80:30779/TCP   29s

```
## HPA部署

```asp
cat <<EOF> pc-hpa.yaml
apiVersion: autoscaling/v1
kind: HorizontalPodAutoscaler        #控制器类型
metadata:
  name: pc-hpa
  namespace: dev
spec:
  minReplicas: 1                     #最小Pod数量
  maxReplicas: 10                    #最大Pod数量
  targetCPUUtilizationPercentage: 3  #CPU使用率指标
  scaleTargetRef:                    #指定要控制的Nginx的信息
    apiVersion: apps/v1
    kind: Deployment
    name: nginx
EOF
```
启动
```asp
kubectl create -f pc-hpa.yaml
```
查看（TARGETS指标）
```asp
kubectl get -f pc-hpa.yaml
```
```asp
NAME     REFERENCE          TARGETS   MINPODS   MAXPODS   REPLICAS   AGE
pc-hpa   Deployment/nginx   0%/3%     1         10        1          38s
```
## HPA压测
安装压测工具
```asp
yum -y install httpd-tools
```
设置测压上限
```asp
ulimit -n 20000
```
开始对nginx进行压测模拟1万次访问
```asp
ab -c 10000 -n 10000 http://192.168.1.100:30779/
```
持续查看TARGETS指标（随着指标率增加pod数量也随之增加上限是10个pod，随着压力减小pod也会随之减少）
```asp
kubectl get -f pc-hpa.yaml -w
```
```asp
NAME     REFERENCE          TARGETS   MINPODS   MAXPODS   REPLICAS   AGE
pc-hpa   Deployment/nginx   1%/3%     1         10        1          17m
pc-hpa   Deployment/nginx   3%/3%     1         10        3          19m
pc-hpa   Deployment/nginx   10%/3%    1         10        5          20m
pc-hpa   Deployment/nginx   20%/3%    1         10        8          21m
pc-hpa   Deployment/nginx   37%/3%    1         10        10         21m
pc-hpa   Deployment/nginx   20%/3%    1         10        8          22m
pc-hpa   Deployment/nginx   0%/3%     1         10        5          28m
pc-hpa   Deployment/nginx   0%/3%     1         10        1          32m
```
持续查看pod数量（随着指标率增加pod数量也随之增加上线是10个，随着压力减小pod也会随之减少）
```asp
kubectl get deploy -n dev -w
```
```asp
NAME    READY   UP-TO-DATE   AVAILABLE   AGE
nginx   1/1     1            1           14m
nginx   1/4     1            1           32m
nginx   2/4     4            2           32m
nginx   3/4     4            3           32m
nginx   4/4     4            4           32m
nginx   5/8     8            5           33m
nginx   6/8     8            6           33m
nginx   7/8     8            7           33m
nginx   8/10    10           8           33m
nginx   9/10    10           9           33m
nginx   10/10   10           10          33m
nginx   10/5    10           10          38m
nginx   5/5     5            5           38m
nginx   5/1     5            5           39m
nginx   1/1     1            1           39m
```
删除HPA
```asp
kubectl delete -f pc-hpa.yaml
```
删除SVC
```asp
kubectl delete svc nginx -n dev
```
删除Pod
```asp
kubectl delete deploy nginx -n dev
```

# DaemonSet（DS）

DaemonSet类型的控制器可以保证集群中的每一台（或指定）节点上都运行一个副本，一般适用于日志收集、节点监控等场景。
如果一个Pod提供的功能是节点级别的（每个节点都需要且只需要一个），那么这类Pod就适合使用DaemonSet类型的控制器创建。

![](/media/202406/2024-06-27_153202_1502680.6818919048017865.png)

**DaemonSet控制器的特点：**
- 每向集群中添加一个节点的时候，指定的Pod副本也将添加到该节点上。
- 当节点从集群中移除的时候，Pod也会被垃圾回收。

## 资源清单
```asp
apiVersion: apps/v1        #版本号
kind: DaemonSet            #类型
metadata:                  #元数据
  name:                    #RS名称
  namespace:               #命名空间
  labels:                  #标签
    controller: daemonset
spec:                      #详情描述
  revisionHistoryLimit: 3  #保留历史版本
  updateStrategy:          #更新策略
    type: RollingUpdate    #滚动更新策略
    rollingUpdate:         #滚动更新
      maxUnavailable: 1    #最大不可用状态的Pod的最大值，可用为百分比，也可以为整数
  selector:                #选择器，通过它指定该控制器管理那些Pod
    matchLabels:           #Labels匹配规则
      app: nginx-pod
    matchExpressions:      #Expressions匹配规则
      - key: app
        operator: In
        values:
          - nginx-pod
  template:                #模板，当副本数量不足时，会根据下面的模板创建Pod模板
     metadata:
       labels:
         app: nginx-pod
     spec:
       containers:
         - name: nginx
           image: nginx:1.17.1
           ports:
             - containerPort: 80
```
## 基本操作
创建pc-daemonset.yaml
```asp
cat <<EOF> pc-daemonset.yaml
apiVersion: apps/v1
kind: DaemonSet       #控制器类型
metadata:
  name: pc-damonset
  namespace: dev
spec:                 # 详情描述
  selector:           # 选择器，通过它指定该控制器管理那些Pod
    matchLabels:      # Labels匹配规则
      app: nginx-pod
  template:           # 模板，当副本数量不足时，会根据下面的模板创建Pod模板
     metadata:
       labels:
         app: nginx-pod
     spec:
       containers:
         - name: nginx
           image: nginx:1.17.1
EOF
```
启动
```asp
kubectl create -f pc-daemonset.yaml
```
查看pod（当前集群只有node1和node2所以有2个pod分别运行在上面）
```asp
kubectl get pod -n dev -o wide
```
```asp
NAME                READY   STATUS    RESTARTS   AGE   IP               NODE    NOMINATED NODE   READINESS GATES
pc-damonset-wtzhz   1/1     Running   0          53s   10.244.166.148   node1   <none>           <none>
pc-damonset-zfzbb   1/1     Running   0          53s   10.244.104.59    node2   <none>           <none>
```
查看集群加入信息（加入新的node节点，新的node会随之增加新的pod在上面）
```asp
kubeadm token create --print-join-command --ttl 0
```
删除
```asp
kubectl delete -f pc-daemonset.yaml
```

# Job

用于负责批量处理短暂的一次性任务，Job的特点：
- 当Job创建的Pod执行成功结束时，Job将记录成功结束的Pod数量
- 当成功结束的Pod达到指定的数量时，Job将完成执行

![](/media/202406/2024-06-27_163636_5564290.6159450390717214.png)

## 资源清单
```asp
apiVersion: batch/v1          #版本号
kind: Job                     #类型
metadata:                     #元数据
  name:                       #名称
  namespace:                  #命名空间
  labels:                     #标签
    controller: job
spec:                         #详情描述
  completions: 1              #指定Job需要成功运行Pod的总次数，默认为1
  parallelism: 1              #指定Job在任一时刻应该并发运行Pod的数量，默认为1
  activeDeadlineSeconds: 30   #指定Job可以运行的时间期限，超过时间还没结束，系统将会尝试进行终止
  backoffLimit: 6             #指定Job失败后进行重试的次数，默认为6
  manualSelector: true        #是否可以使用selector选择器选择Pod，默认为false
  selector:                   #选择器，通过它指定该控制器管理那些Pod
    matchLabels:              #Labels匹配规则
      app: counter-pod
    matchExpressions:         #Expressions匹配规则
      - key: app
        operator: In
        values:
          - counter-pod
  template:                   #模板，当副本数量不足时，会根据下面的模板创建Pod模板
     metadata:
       labels:
         app: counter-pod
     spec:
       restartPolicy: Never   #重启策略只能设置为Never或OnFailure
       containers:
         - name: counter
           image: busybox:1.30
           command: ["/bin/sh","-c","for i in 9 8 7 6 5 4 3 2 1;do echo $i;sleep 20;done"]
```
> 关于模板中的重启策略的说明：
● 如果设置为OnFailure，则Job会在Pod出现故障的时候重启容器，而不是创建Pod，failed次数不变。
● 如果设置为Never，则Job会在Pod出现故障的时候创建新的Pod，并且故障Pod不会消失，也不会重启，failed次数+1。
● 如果指定为Always的话，就意味着一直重启，意味着Pod任务会重复执行，这和Job的定义冲突，所以不能设置为Always。

## 基本配置

创建pc-job.yaml
```asp
cat <<EOF> pc-job.yaml
apiVersion: batch/v1
kind: Job                   #控制器类型
metadata:
  name: pc-job
  namespace: dev
spec:
  manualSelector: true
  completions: 1             #指定Job需要成功运行Pod的总次数，默认为1
  parallelism: 1             #指定Job在任一时刻应该并发运行Pod的数量，默认为1
  selector:
    matchLabels:
      app: counter-pod
  template:
    metadata:
      labels:
        app: counter-pod
    spec:
      restartPolicy: Never   #重启策略只能设置为Never或OnFailure
      containers:
        - name: counter
          image: busybox:1.30
          command: [ "/bin/sh","-c","for i in 9 8 7 6 5 4 3 2 1;do echo $i;sleep 3;done" ]
EOF
```
启动
```asp
kubectl create -f pc-job.yaml
```
查看job（一个job在46s时候被成功执行）
```asp
kubectl get job -n dev -w
```
```asp
NAME     COMPLETIONS   DURATION   AGE
pc-job   1/1           46s        46s
```
查看pod（持续查看可以看出计划任务执行前创建了pod在46s执行完成后关闭了pod）
```asp
kubectl get pod -n dev -w
```
```asp
NAME           READY   STATUS               RESTARTS   AGE
pc-job-mwx8b   0/1     Pending              0          0s
pc-job-mwx8b   0/1     ContainerCreating    0          1s
pc-job-mwx8b   1/1     Running              0          19s
pc-job-mwx8b   0/1     Completed            0          46s
```
删除
```asp
kubectl delete -f pc-job.yaml
```

# CronJob（CJ）
CronJob控制器以Job控制器为其管控对象，并借助它管理Pod资源对象，Job控制器定义的作业任务在其控制器资源创建之后便会立即执行，CronJob可以以类似Linux操作系统的周期性任务作业计划的方式控制器运行时间点及重复运行的方式，换言之，CronJob可以在特定的时间点反复去执行Job任务。

![](/media/202406/2024-06-27_172031_9458560.7771623421117283.png)

## 资源清单
```asp
apiVersion: batch/v1beta1        #版本号
kind: CronJob                    #类型
metadata:                        #元数据
  name:                          #名称
  namespace:                     #命名空间
  labels:
    controller: cronjob
spec:                            #详情描述
  schedule:                      #cron格式的作业调度运行时间点，用于控制任务任务时间执行
  concurrencyPolicy:             #并发执行策略
  failedJobsHistoryLimit:        #为失败的任务执行保留的历史记录数，默认为1
  successfulJobsHistoryLimit:    #为成功的任务执行保留的历史记录数，默认为3
  jobTemplate:                   #job控制器模板，用于为cronjob控制器生成job对象，下面其实就是job的定义
    metadata: {}
    spec:
      completions: 1             #指定Job需要成功运行Pod的总次数，默认为1
      parallelism: 1             #指定Job在任一时刻应该并发运行Pod的数量，默认为1
      activeDeadlineSeconds: 30  #指定Job可以运行的时间期限，超过时间还没结束，系统将会尝试进行终止
      backoffLimit: 6            #指定Job失败后进行重试的次数，默认为6
      template:                  #模板，当副本数量不足时，会根据下面的模板创建Pod模板
        spec:
          restartPolicy: Never   #重启策略只能设置为Never或OnFailure
          containers:
            - name: counter
              image: busybox:1.30
              command: [ "/bin/sh","-c","for i in 9 8 7 6 5 4 3 2 1;do echo $i;sleep 20;done" ]
```
> schedule：cron表达式，用于指定任务的执行时间。
● */1  *  *  *  *：表示分钟  小时  日  月份  星期。
● 分钟的值从0到59。
● 小时的值从0到23。
● 日的值从1到31。
● 月的值从1到12。
● 星期的值从0到6，0表示星期日。
● 多个时间可以用逗号隔开，范围可以用连字符给出：* 可以作为通配符，/表示每...

> concurrencyPolicy：并发执行策略
● Allow：运行Job并发运行（默认）。
● Forbid：禁止并发运行，如果上一次运行尚未完成，则跳过下一次运行。
● Replace：替换，取消当前正在运行的作业并使用新作业替换它。

## 基本操作

创建pc-cronjob.yaml
```asp
cat <<EOF> pc-cronjob.yaml
apiVersion: batch/v1beta1
kind: CronJob                   #控制器类型
metadata:
  name: pc-cronjob
  namespace: dev
spec:
  schedule: "*/1 * * * * "      #每分钟执行一次
  jobTemplate:                  #job控制器模板，用于为cronjob控制器生成job对象，下面其实就是job的定义
    metadata: {}
    spec:
      template:
        spec:
          restartPolicy: Never  #重启策略只能设置为Never或OnFailure
          containers:
            - name: counter
              image: busybox:1.30
              command: [ "/bin/sh","-c","for i in 9 8 7 6 5 4 3 2 1;do echo $i;sleep 2;done" ]
EOF
```
启动
```asp
kubectl create -f pc-cronjob.yaml
```
查看cj（每分钟运行一次）
```asp
kubectl get cj -n dev -w
```
```asp
NAME         SCHEDULE       SUSPEND   ACTIVE   LAST SCHEDULE   AGE
pc-cronjob   */1 * * * *    False     1        1s              1m55s
pc-cronjob   */1 * * * *    False     1        1s              2m55s
pc-cronjob   */1 * * * *    False     1        1s              3m55s
```
查看job（成功执行的记录）
```asp
kubectl get job -n dev -w
```
```asp
NAME                    COMPLETIONS   DURATION   AGE
pc-cronjob-1719481920   1/1           20s        3m9s
pc-cronjob-1719481980   1/1           19s        2m8s
pc-cronjob-1719482040   1/1           19s        68s
```
查看pod（没执行成功一次就完成一个pod）
```asp
kubectl get pod -n dev -w
```
```asp
NAME                          READY   STATUS      RESTARTS   AGE
pc-cronjob-1719481860-ljvs7   0/1     Completed   0          1m55s
pc-cronjob-1719481920-974hf   0/1     Completed   0          2m55s
pc-cronjob-1719481980-rbppl   0/1     Completed   0          3m55s

```
删除
```asp
kubectl delete -f pc-cronjob.yaml
```