k8s健康检查（9）

时间 2019-11-20

标签 k8s 健康检查繁體版

原文原文链接

1、默认的健康检查

　　强大的自愈能力是 Kubernetes 这类容器编排引擎的一个重要特性。自愈的默认实现方式是自动重启发生故障的容器。除此以外，用户还能够利用 Liveness 和 Readiness 探测机制设置更精细的健康检查，进而实现以下需求：web

　　（1）零停机部署。docker

　　（2）避免部署无效的镜像。数据库

　　（3）更加安全的滚动升级。后端

　　每一个容器启动时都会执行一个进程，此进程由 Dockerfile 的 CMD 或 ENTRYPOINT 指定。若是进程退出时返回码非零，则认为容器发生故障，Kubernetes 就会根据 restartPolicy 重启容器。api

一、模拟一个容器发生故障的场景，Pod 配置文件以下：缓存

[root@ren7 yaml]# cat pod1.yaml 
apiVersion: v1
kind: Pod
metadata:
  name: healthcheck
  labels:
    test: healthcheck
spec:
  containers:
    - name: healthcheck
      image: reg.yunwei.com/learn/busybox:latest
      args: 
      - /bin/sh
      - -c
      - sleep 10; exit 1
  restartPolicy: OnFailure

　　Pod 的 restartPolicy 设置为 OnFailure，默认为 Always。安全

　　sleep 10; exit 1 模拟容器启动 10 秒后发生故障。、服务器

二、执行 kubectl apply 建立 Pod，命名为 healthcheck。app

[root@ren7 yaml]# kubectl apply -f pod1.yaml 
pod/healthcheck created

三、过几分钟查看 Pod 的状态：负载均衡

[root@ren7 yaml]# kubectl get pod -o wide
NAME          READY   STATUS             RESTARTS   AGE    IP              NODE           NOMINATED NODE   READINESS GATES
healthcheck   0/1     CrashLoopBackOff   3          101s   172.20.72.142   192.168.11.5   <none>           <none>

　　可看到容器当前已经重启了 3次。

　　在上面的例子中，容器进程返回值非零，Kubernetes 则认为容器发生故障，须要重启。但有很多状况是发生了故障，但进程并不会退出。好比访问 Web 服务器时显示 500 内部错误，多是系统超载，也多是资源死锁，此时 httpd 进程并无异常退出，在这种状况下重启容器多是最直接最有效的解决方案，那咱们如何利用 Health Check 机制来处理这类场景呢？

2、Liveness探测

　　Liveness 探测让用户能够自定义判断容器是否健康的条件。若是探测失败，Kubernetes 就会重启容器。

一、建立以下 Pod：

[root@ren7 yaml]# cat pod2.yaml 
apiVersion: v1
kind: Pod
metadata:
  name: liveness
  labels:
    test: liveness
spec:
  containers:
    - name: liveness
      image: reg.yunwei.com/learn/busybox:latest
      args: 
      - /bin/sh
      - -c
      - touch /tmp/healthy; sleep 30; rm -rf /tmp/healthy; sleep 600 livenessProbe: exec: command: - cat
          - /tmp/healthy initialDelaySeconds: 10 periodSeconds: 5
  restartPolicy: OnFailure

　　启动进程首先建立文件 /tmp/healthy，30 秒后删除，在咱们的设定中，若是 /tmp/healthy 文件存在，则认为容器处于正常状态，反之则发生故障。

　　livenessProbe 部分定义如何执行 Liveness 探测：

　　探测的方法是：经过 cat 命令检查 /tmp/healthy 文件是否存在。若是命令执行成功，返回值为零，Kubernetes 则认为本次 Liveness 探测成功；若是命令返回值非零，本次 Liveness 探测失败。

　　initialDelaySeconds: 10 指定容器启动 10 以后开始执行 Liveness 探测，咱们通常会根据应用启动的准备时间来设置。好比某个应用正常启动要花 30 秒，那么 initialDelaySeconds 的值就应该大于 30。

　　periodSeconds: 5 指定每 5 秒执行一次 Liveness 探测。Kubernetes 若是连续执行 3 次 Liveness 探测均失败，则会杀掉并重启容器。

二、下面建立 Pod liveness：

[root@ren7 yaml]# kubectl apply -f pod2.yaml 
pod/liveness created

　　从配置文件可知，最开始的 30 秒，/tmp/healthy 存在，cat 命令返回 0，Liveness 探测成功

三、这段时间 kubectl describe pod liveness 的 Events部分会显示正常的日志。

[root@ren7 yaml]# kubectl describe pod liveness
Name:         liveness
Namespace:    default
Node:         192.168.11.5/192.168.11.5
Start Time:   Sat, 26 Oct 2019 10:59:15 +0800
Labels:       test=liveness
Annotations:  kubectl.kubernetes.io/last-applied-configuration:
                {"apiVersion":"v1","kind":"Pod","metadata":{"annotations":{},"labels":{"test":"liveness"},"name":"liveness","namespace":"default"},"spec":...
Status:       Running
IP:           172.20.72.141
Containers:
  liveness:
    Container ID:  docker://abcecd2fe5d291ac028d8eebbb59ef37b22a558d451b0c401da44c1bcd7962e0
    Image:         reg.yunwei.com/learn/busybox:latest
    Image ID:      docker-pullable://reg.yunwei.com/learn/busybox@sha256:dd97a3fe6d721c5cf03abac0f50e2848dc583f7c4e41bf39102ceb42edfd1808
    Port:          <none>
    Host Port:     <none>
    Args:
      /bin/sh
      -c
      touch /tmp/healthy; sleep 30; rm -rf /tmp/healthy; sleep 600
    State:          Running
      Started:      Sat, 26 Oct 2019 10:59:17 +0800
    Ready:          True
    Restart Count:  0
    Liveness:       exec [cat /tmp/healthy] delay=10s timeout=1s period=5s #success=1 #failure=3
    Environment:    <none>
    Mounts:
      /var/run/secrets/kubernetes.io/serviceaccount from default-token-qvqql (ro)
Conditions:
  Type              Status
  Initialized       True 
  Ready             True 
  ContainersReady   True 
  PodScheduled      True 
Volumes:
  default-token-qvqql:
    Type:        Secret (a volume populated by a Secret)
    SecretName:  default-token-qvqql
    Optional:    false
QoS Class:       BestEffort
Node-Selectors:  <none>
Tolerations:     <none>
Events:
  Type    Reason     Age   From                   Message
  ----    ------     ----  ----                   -------
  Normal  Scheduled  18s   default-scheduler      Successfully assigned default/liveness to 192.168.11.5
  Normal  Pulling    17s   kubelet, 192.168.11.5  Pulling image "reg.yunwei.com/learn/busybox:latest"
  Normal  Pulled     16s   kubelet, 192.168.11.5  Successfully pulled image "reg.yunwei.com/learn/busybox:latest"
  Normal  Created    16s   kubelet, 192.168.11.5  Created container liveness
  Normal  Started    16s   kubelet, 192.168.11.5  Started container liveness

四、35秒后再次查看日志

　　35 秒以后，日志会显示 /tmp/healthy 已经不存在，Liveness 探测失败。再过几十秒，几回探测都失败后，容器会被重启。

[root@ren7 yaml]# kubectl describe pod liveness
Name:         liveness
Namespace:    default
Node:         192.168.11.5/192.168.11.5
Start Time:   Sat, 26 Oct 2019 10:59:15 +0800
Labels:       test=liveness
Annotations:  kubectl.kubernetes.io/last-applied-configuration:
                {"apiVersion":"v1","kind":"Pod","metadata":{"annotations":{},"labels":{"test":"liveness"},"name":"liveness","namespace":"default"},"spec":...
Status:       Running
IP:           172.20.72.141
Containers:
  liveness:
    Container ID:  docker://abcecd2fe5d291ac028d8eebbb59ef37b22a558d451b0c401da44c1bcd7962e0
    Image:         reg.yunwei.com/learn/busybox:latest
    Image ID:      docker-pullable://reg.yunwei.com/learn/busybox@sha256:dd97a3fe6d721c5cf03abac0f50e2848dc583f7c4e41bf39102ceb42edfd1808
    Port:          <none>
    Host Port:     <none>
    Args:
      /bin/sh
      -c
      touch /tmp/healthy; sleep 30; rm -rf /tmp/healthy; sleep 600
    State:          Running
      Started:      Sat, 26 Oct 2019 10:59:17 +0800
    Ready:          True
    Restart Count:  0
    Liveness:       exec [cat /tmp/healthy] delay=10s timeout=1s period=5s #success=1 #failure=3
    Environment:    <none>
    Mounts:
      /var/run/secrets/kubernetes.io/serviceaccount from default-token-qvqql (ro)
Conditions:
  Type              Status
  Initialized       True 
  Ready             True 
  ContainersReady   True 
  PodScheduled      True 
Volumes:
  default-token-qvqql:
    Type:        Secret (a volume populated by a Secret)
    SecretName:  default-token-qvqql
    Optional:    false
QoS Class:       BestEffort
Node-Selectors:  <none>
Tolerations:     <none>
Events:
  Type     Reason     Age                From                   Message
  ----     ------     ----               ----                   -------
  Normal   Scheduled  63s                default-scheduler      Successfully assigned default/liveness to 192.168.11.5
  Normal   Pulling    62s                kubelet, 192.168.11.5  Pulling image "reg.yunwei.com/learn/busybox:latest"
  Normal   Pulled     61s                kubelet, 192.168.11.5  Successfully pulled image "reg.yunwei.com/learn/busybox:latest"
  Normal   Created    61s                kubelet, 192.168.11.5  Created container liveness
  Normal   Started    61s                kubelet, 192.168.11.5  Started container liveness
  Warning  Unhealthy  19s (x3 over 29s)  kubelet, 192.168.11.5  Liveness probe failed: cat: can't open '/tmp/healthy': No such file or directory
  Normal   Killing    19s                kubelet, 192.168.11.5  Container liveness failed liveness probe, will be restarted

五、查看pod

　　能够发现容器开始被重启

[root@ren7 yaml]# kubectl get pod -o wide
NAME       READY   STATUS    RESTARTS   AGE   IP              NODE           NOMINATED NODE   READINESS GATES
liveness   1/1     Running   1          76s   172.20.72.141   192.168.11.5   <none>           <none>

3、Readiness 探测

　　除了 Liveness 探测，Kubernetes Health Check 机制还包括 Readiness 探测。

　　用户经过 Liveness 探测能够告诉 Kubernetes 何时经过重启容器实现自愈；Readiness 探测则是告诉 Kubernetes 何时能够将容器加入到 Service 负载均衡池中，对外提供服务。

一、Readiness 探测的配置语法与 Liveness 探测彻底同样

[root@ren7 yaml]# cat pod-read.yaml 
apiVersion: v1
kind: Pod
metadata:
  name: readiness
  labels:
    test: readiness
spec:
  containers:
    - name: readiness
      image: reg.yunwei.com/learn/busybox:latest
      args: 
      - /bin/sh
      - -c
      - touch /tmp/healthy; sleep 30; rm -rf /tmp/healthy; sleep 600 readinessProbe:
        exec:
          command:
          - cat
          - /tmp/healthy
        initialDelaySeconds: 10
        periodSeconds: 5
  restartPolicy: OnFailure

　　这个配置文件只是将前面例子中的 liveness 替换为了 readiness，咱们看看有什么不一样的效果。

二、部署

[root@ren7 yaml]# kubectl get pod readiness
NAME        READY   STATUS    RESTARTS   AGE
readiness   0/1     Running   0          14s
[root@ren7 yaml]# kubectl get pod readiness
NAME        READY   STATUS    RESTARTS   AGE
readiness   1/1     Running   0          26s
[root@ren7 yaml]# kubectl get pod readiness
NAME        READY   STATUS    RESTARTS   AGE
readiness   0/1     Running   0          76s

　　Pod readiness 的 READY 状态经历了以下变化：

　　刚被建立时，READY 状态为不可用。

　　15 秒后（initialDelaySeconds + periodSeconds），第一次进行 Readiness 探测并成功返回，设置 READY 为可用。

　　30 秒后，/tmp/healthy 被删除，连续 3 次 Readiness 探测均失败后，READY 被设置为不可用。

三、经过 kubectl describe pod readiness 也能够看到 Readiness 探测失败的日志。

[root@ren7 yaml]# kubectl describe pod readiness
Name:         readiness
Namespace:    default
Node:         192.168.11.5/192.168.11.5
Start Time:   Sat, 26 Oct 2019 11:10:24 +0800
Labels:       test=readiness
Annotations:  kubectl.kubernetes.io/last-applied-configuration:
                {"apiVersion":"v1","kind":"Pod","metadata":{"annotations":{},"labels":{"test":"readiness"},"name":"readiness","namespace":"default"},"spec...
Status:       Running
IP:           172.20.72.143
Containers:
  readiness:
    Container ID:  docker://7fc2db813b612e71a82b27d7a63fe1860982f4c20fbc1e110a92f3118b08fa82
    Image:         reg.yunwei.com/learn/busybox:latest
    Image ID:      docker-pullable://reg.yunwei.com/learn/busybox@sha256:dd97a3fe6d721c5cf03abac0f50e2848dc583f7c4e41bf39102ceb42edfd1808
    Port:          <none>
    Host Port:     <none>
    Args:
      /bin/sh
      -c
      touch /tmp/healthy; sleep 30; rm -rf /tmp/healthy; sleep 600
    State:          Running
      Started:      Sat, 26 Oct 2019 11:10:26 +0800
    Ready:          False
    Restart Count:  0
    Readiness:      exec [cat /tmp/healthy] delay=10s timeout=1s period=5s #success=1 #failure=3
    Environment:    <none>
    Mounts:
      /var/run/secrets/kubernetes.io/serviceaccount from default-token-qvqql (ro)
Conditions:
  Type              Status
  Initialized       True 
  Ready             False 
  ContainersReady   False 
  PodScheduled      True 
Volumes:
  default-token-qvqql:
    Type:        Secret (a volume populated by a Secret)
    SecretName:  default-token-qvqql
    Optional:    false
QoS Class:       BestEffort
Node-Selectors:  <none>
Tolerations:     <none>
Events:
  Type     Reason     Age                 From                   Message
  ----     ------     ----                ----                   -------
  Normal   Scheduled  2m18s               default-scheduler      Successfully assigned default/readiness to 192.168.11.5
  Normal   Pulling    2m17s               kubelet, 192.168.11.5  Pulling image "reg.yunwei.com/learn/busybox:latest"
  Normal   Pulled     2m16s               kubelet, 192.168.11.5  Successfully pulled image "reg.yunwei.com/learn/busybox:latest"
  Normal   Created    2m16s               kubelet, 192.168.11.5  Created container readiness
  Normal   Started    2m16s               kubelet, 192.168.11.5  Started container readiness
  Warning  Unhealthy  3s (x21 over 103s)  kubelet, 192.168.11.5  Readiness probe failed: cat: can't open '/tmp/healthy': No such file or directory

　　下面对 Liveness 探测和 Readiness 探测作个比较：

　　Liveness 探测和 Readiness 探测是两种 Health Check 机制，若是不特地配置，Kubernetes 将对两种探测采起相同的默认行为，即经过判断容器启动进程的返回值是否为零来判断探测是否成功。

　　两种探测的配置方法彻底同样，支持的配置参数也同样。不一样之处在于探测失败后的行为：Liveness 探测是重启容器；Readiness 探测则是将容器设置为不可用，不接收 Service 转发的请求。

　　Liveness 探测和 Readiness 探测是独立执行的，两者之间没有依赖，因此能够单独使用，也能够同时使用。用 Liveness 探测判断容器是否须要重启以实现自愈；用 Readiness 探测判断容器是否已经准备好对外提供服务。

4、健康检测在scale up中的应用

　　对于多副本应用，当执行 Scale Up 操做时，新副本会做为 backend 被添加到 Service 的负载均衡中，与已有副本一块儿处理客户的请求。考虑到应用启动一般都须要一个准备阶段，好比加载缓存数据，链接数据库等，从容器启动到真正可以提供服务是须要一段时间的。咱们能够经过 Readiness 探测判断容器是否就绪，避免将请求发送到尚未 ready 的 backend。

一、下面是示例应用的配置文件。

[root@ren7 yaml]# cat healthy.yaml 
apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  name: web
spec:
  replicas: 2
  template:
    metadata:
      labels:
        name: web
        run: web
    spec:
      containers:
      - name: web
        image: reg.yunwei.com/learn/httpd:latest
        ports:
        - containerPort: 80 readinessProbe: httpGet: scheme: HTTP path: /healthy port: 8080 initialDelaySeconds: 10 periodSeconds: 5

---
apiVersion: v1
kind: Service
metadata:
  name: web-svc
spec:
  ports: 
    - port: 8080
      targetPort: 80
      protocol: TCP
  selector:
    run: web

　　重点关注 readinessProbe 部分。这里咱们使用了不一样于 exec 的另外一种探测方法 -- httpGet。Kubernetes 对于该方法探测成功的判断条件是 http 请求的返回代码在 200-400 之间。

　　schema 指定协议，支持 HTTP（默认值）和 HTTPS。

　　path 指定访问路径。

　　port 指定端口。

上面配置的做用是：

　　容器启动 10 秒以后开始探测。

　　若是 http://[container_ip]:8080/healthy 返回代码不是 200-400，表示容器没有就绪，不接收 Service web-svc 的请求。

　　每隔 5 秒再探测一次。

　　直到返回代码为 200-400，代表容器已经就绪，而后将其加入到 web-svc 的负载均衡中，开始处理客户请求。

　　探测会继续以 5 秒的间隔执行，若是连续发生 3 次失败，容器又会从负载均衡中移除，直到下次探测成功从新加入。

5、健康检测在滚动更新中的应用

　　现有一个正常运行的多副本应用，接下来对应用进行更新（好比使用更高版本的 image），Kubernetes 会启动新副本，而后发生了以下事件：

　　正常状况下新副本须要 10 秒钟完成准备工做，在此以前没法响应业务请求。

　　但因为人为配置错误，副本始终没法完成准备工做（好比没法链接后端数据库）。

　　思考一个问题：若是没有配置 Health Check，会出现怎样的状况？

　　由于新副本自己没有异常退出，默认的 Health Check 机制会认为容器已经就绪，进而会逐步用新副本替换现有副本，其结果就是：当全部旧副本都被替换后，整个应用将没法处理请求，没法对外提供服务。若是这是发生在重要的生产系统上，后果会很是严重。

　　若是正确配置了 Health Check，新副本只有经过了 Readiness 探测，才会被添加到 Service；若是没有经过探测，现有副本不会被所有替换，业务仍然正常进行。

一、用以下配置文件 app.v1.yml 模拟一个 10 副本的应用：

[root@ren7 yaml]# cat app.v1.yml 
apiVersion: apps/v1beta1
kind: Deployment
metadata:
  name: app
spec:
  replicas: 10
  template:
    metadata:
      labels:
        name: app
        run: app
    spec:
      containers:
      - name: app
        image: reg.yunwei.com/learn/busybox:latest
        args: 
        - /bin/sh
        - -c
        - sleep 10; touch /tmp/healthy; sleep 30000
        readinessProbe:
          exec:
            command:
            - cat
            - /tmp/healthy
          initialDelaySeconds: 10
          periodSeconds: 5

　　10秒后副本可以经过readiness探测

二、执行部署操做

[root@ren7 yaml]# kubectl apply -f app.v1.yml 
deployment.apps/app created
[root@ren7 yaml]# kubectl get deployment app
NAME   READY   UP-TO-DATE   AVAILABLE   AGE
app    10/10   10           10          39s
[root@ren7 yaml]# kubectl get po -o wide
NAME                   READY   STATUS    RESTARTS   AGE   IP              NODE           NOMINATED NODE   READINESS GATES
app-577d86d68d-2qb4c   1/1     Running   0          50s   172.20.72.147   192.168.11.5   <none>           <none>
app-577d86d68d-45fc2   1/1     Running   0          50s   172.20.72.149   192.168.11.5   <none>           <none>
app-577d86d68d-4mbdj   1/1     Running   0          50s   172.20.33.114   192.168.11.6   <none>           <none>
app-577d86d68d-8hvjx   1/1     Running   0          50s   172.20.33.111   192.168.11.6   <none>           <none>
app-577d86d68d-gnwkn   1/1     Running   0          50s   172.20.72.146   192.168.11.5   <none>           <none>
app-577d86d68d-gv64q   1/1     Running   0          50s   172.20.33.113   192.168.11.6   <none>           <none>
app-577d86d68d-mgvv9   1/1     Running   0          50s   172.20.72.145   192.168.11.5   <none>           <none>
app-577d86d68d-mlq22   1/1     Running   0          50s   172.20.33.115   192.168.11.6   <none>           <none>
app-577d86d68d-n9cxh   1/1     Running   0          50s   172.20.33.112   192.168.11.6   <none>           <none>
app-577d86d68d-qjj92   1/1     Running   0          50s   172.20.72.148   192.168.11.5   <none>           <none>

三、接下来滚动更新应用，配置文件 app.v2.yml 以下：

[root@ren7 yaml]# cat app.v2.yml 
apiVersion: apps/v1beta1
kind: Deployment
metadata:
  name: app
spec:
  replicas: 10
  template:
    metadata:
      labels:
        name: app
        run: app
    spec:
      containers:
      - name: app
        image: reg.yunwei.com/learn/busybox:latest
        args: 
        - /bin/sh
        - -c
        - sleep 30000
        readinessProbe:
          exec:
            command:
            - cat
            - /tmp/healthy
          initialDelaySeconds: 10
          periodSeconds: 5

　　很显然，因为新副本中不存在 /tmp/healthy，是没法经过 Readiness 探测的。

四、查看探测结果

[root@ren7 yaml]# kubectl apply -f app.v2.yml --record
deployment.apps/app configured
[root@ren7 yaml]# kubectl get deployment app
NAME   READY   UP-TO-DATE   AVAILABLE   AGE
app    8/10    5            8           3m57s
[root@ren7 yaml]# kubectl get deployment app
NAME   READY   UP-TO-DATE   AVAILABLE   AGE
app    8/10    5            8           4m25s
[root@ren7 yaml]# kubectl get po -o wide
NAME                   READY   STATUS    RESTARTS   AGE     IP              NODE           NOMINATED NODE   READINESS GATES
app-577d86d68d-2qb4c   1/1     Running   0          4m31s   172.20.72.147   192.168.11.5   <none>           <none>
app-577d86d68d-4mbdj   1/1     Running   0          4m31s   172.20.33.114   192.168.11.6   <none>           <none>
app-577d86d68d-8hvjx   1/1     Running   0          4m31s   172.20.33.111   192.168.11.6   <none>           <none>
app-577d86d68d-gnwkn   1/1     Running   0          4m31s   172.20.72.146   192.168.11.5   <none>           <none>
app-577d86d68d-gv64q   1/1     Running   0          4m31s   172.20.33.113   192.168.11.6   <none>           <none>
app-577d86d68d-mgvv9   1/1     Running   0          4m31s   172.20.72.145   192.168.11.5   <none>           <none>
app-577d86d68d-n9cxh   1/1     Running   0          4m31s   172.20.33.112   192.168.11.6   <none>           <none>
app-577d86d68d-qjj92   1/1     Running   0          4m31s   172.20.72.148   192.168.11.5   <none>           <none>
app-58ccc746ff-44kz6   0/1     Running   0          45s     172.20.33.116   192.168.11.6   <none>           <none>
app-58ccc746ff-4ndkq   0/1     Running   0          45s     172.20.72.151   192.168.11.5   <none>           <none>
app-58ccc746ff-5jfvr   0/1     Running   0          46s     172.20.72.150   192.168.11.5   <none>           <none>
app-58ccc746ff-qz7pn   0/1     Running   0          46s     172.20.33.117   192.168.11.6   <none>           <none>
app-58ccc746ff-z4h94   0/1     Running   0          46s     172.20.72.152   192.168.11.5   <none>           <none>
[root@ren7 yaml]#

　　先关注 kubectl get pod 输出：

　　从 Pod 的 AGE 栏可判断，最后 5 个 Pod 是新副本，目前处于 NOT READY 状态。

旧副本从最初 10 个减小到 8 个。

　　再来看 kubectl get deployment app 的输出：

　　DESIRED 10 表示指望的状态是 10 个 READY 的副本。

　　CURRENT 13 表示当前副本的总数：即 8 个旧副本 + 5 个新副本。

　　UP-TO-DATE 5 表示当前已经完成更新的副本数：即 5 个新副本。

　　AVAILABLE 8 表示当前处于 READY 状态的副本数：即 8个旧副本。

　　在咱们的设定中，新副本始终都没法经过 Readiness 探测，因此这个状态会一直保持下去。

　　上面咱们模拟了一个滚动更新失败的场景。不过幸运的是：Health Check 帮咱们屏蔽了有缺陷的副本，同时保留了大部分旧副本，业务没有因更新失败受到影响。

　　接下来咱们要回答：为何新建立的副本数是 5 个，同时只销毁了 2 个旧副本？

　　缘由是：滚动更新经过参数 maxSurge 和 maxUnavailable 来控制副本替换的数量。

maxSurge

　　此参数控制滚动更新过程当中副本总数的超过 DESIRED 的上限。maxSurge 能够是具体的整数（好比 3），也能够是百分百，向上取整。maxSurge 默认值为 25%。

　　在上面的例子中，DESIRED 为 10，那么副本总数的最大值为：

　　roundUp(10 + 10 * 25%) = 13

　　因此咱们看到 CURRENT 就是 13。

maxUnavailable

　　此参数控制滚动更新过程当中，不可用的副本相占 DESIRED 的最大比例。 maxUnavailable 能够是具体的整数（好比 3），也能够是百分百，向下取整。maxUnavailable 默认值为 25%。

　　在上面的例子中，DESIRED 为 10，那么可用的副本数至少要为：

　　10 - roundDown(10 * 25%) = 8

　　因此咱们看到 AVAILABLE 就是 8。

　　maxSurge 值越大，初始建立的新副本数量就越多；maxUnavailable 值越大，初始销毁的旧副本数量就越多。

　　理想状况下，咱们这个案例滚动更新的过程应该是这样的：

　　首先建立 3 个新副本使副本总数达到 13 个。

　　而后销毁 2 个旧副本使可用的副本数降到 8 个。

　　当这 2 个旧副本成功销毁后，可再建立 2 个新副本，使副本总数保持为 13 个。

　　当新副本经过 Readiness 探测后，会使可用副本数增长，超过 8。

　　进而能够继续销毁更多的旧副本，使可用副本数回到 8。

　　旧副本的销毁使副本总数低于 13，这样就容许建立更多的新副本。

　　这个过程会持续进行，最终全部的旧副本都会被新副本替换，滚动更新完成。

6、更新失败回退

[root@ren7 yaml]# kubectl rollout history deployment app
deployment.extensions/app 
REVISION  CHANGE-CAUSE
1         <none>
2         kubectl apply --filename=app.v2.yml --record=true
[root@ren7 yaml]# kubectl get deployment app
NAME   READY   UP-TO-DATE   AVAILABLE   AGE
app    8/10    5            8           7m50s
[root@ren7 yaml]# kubectl rollout undo deployment app --to-revision=1
deployment.extensions/app rolled back
[root@ren7 yaml]# kubectl get deployment app
NAME   READY   UP-TO-DATE   AVAILABLE   AGE
app    10/10   10           10          8m53s

　　若是要定制 maxSurge 和 maxUnavailable，能够以下配置：

[root@ren7 yaml]# cat app.v2.yml 
apiVersion: apps/v1beta1
kind: Deployment
metadata:
  name: app
spec:
  strategy: rollingUpdate: maxSurge: 35% maxUnavailable: 35%
  replicas: 10
  template:
    metadata:
      labels:
        name: app
        run: app
    spec:
      containers:
      - name: app
        image: reg.yunwei.com/learn/busybox:latest
        args: 
        - /bin/sh
        - -c
        - sleep 30000
        readinessProbe:
          exec:
            command:
            - cat
            - /tmp/healthy
          initialDelaySeconds: 10
          periodSeconds: 5