滚动更新是一次只更新一小部分副本，成功后再更新更多的副本，最终完成所有副本的更新。滚动更新的最大好处是零停机，整个更新过程始终有副本在运行，从而保证了业务的连续性。

Rolling Update

实践

我们先部署3个副本，初始镜像为httpd:2.2.31，然后将其更新到httpd:2.2.32。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

# API 版本号
apiVersion: apps/v1
# 类型，如：Pod/ReplicationController/Deployment/Service/Ingress
kind: Deployment
metadata:
  # Kind 的名称
  name: httpd
spec:
  selector:
    matchLabels:
      # 容器标签的名字，发布 Service 时，selector 需要和这里对应
      app: httpd
  # 部署的实例数量
  replicas: 3
  template:
    metadata:
      labels:
        app: httpd
    spec:
      # 配置容器，数组类型，说明可以配置多个容器
      containers:
      # 容器名称
      - name: httpd
        # 容器镜像
        image: httpd:2.2.31
        # 只有镜像不存在时，才会进行镜像拉取
        imagePullPolicy: IfNotPresent
        ports:
        # Pod 端口
        - containerPort: 80

通过kubectl apply进行部署，

image-20230306232504473

部署过程如下：

（1）创建Deployment httpd。

（2）创建ReplicaSet httpd-58659b58f。

（3）创建三个Pod。

（4）当前镜像为httpd:2.2.31。

将配置文件中的httpd:2.2.31替换为httpd:2.2.32，再次执行kubectl apply，

image-20230306233011892

我们发现了如下的变化：

（1）Deployment httpd的镜像更新为httpd:2.2.32。

（2）新创建了ReplicaSet httpd-6bd866cb56，镜像为httpd:2.2.32，并且管理了三个新的Pod。

（3）之前的ReplicaSet httpd-58659b58f里面已经没有任何Pod。

结论是：ReplicaSet httpd-58659b58f的三个httpd:2.2.31 Pod已经被ReplicaSet httpd-6bd866cb56的三个httpd:2.2.32 Pod替换了。

具体过程可以通过kubectl describe deployment httpd查看，

image-20230306233501863

每次只更新替换一个Pod：

（1）ReplicaSet httpd-6bd866cb56增加一个Pod，总数为1。

（2）ReplicaSet httpd-58659b58f减少一个Pod，总数为2。

（3）ReplicaSet httpd-6bd866cb56增加一个Pod，总数为2。

（4）ReplicaSet httpd-58659b58f减少一个Pod，总数为1。

（5）ReplicaSet httpd-6bd866cb56增加一个Pod，总数为3。

（6）ReplicaSet httpd-58659b58f减少一个Pod，总数为0。

每次替换的Pod数量是可以定制的。Kubernetes提供了两个参数maxSurge和maxUnavailable来精细控制Pod的替换数量，我们将在后面结合Health Check特性一起讨论。

回滚

kubectl apply每次更新应用时，Kubernetes都会记录下当前的配置，保存为一个revision（版次），这样就可以回滚到某个特定revision。

默认配置下，Kubernetes只会保留最近的几个revision，可以在Deployment配置文件中通过revisionHistoryLimit属性增加revision数量。

下面实践回滚功能。应用有三个配置文件，即httpd.v1.yml、httpd.v2.yml和httpd.v3.yml，分别对应不同的httpd镜像2.4.16、2.4.17和2.4.18，

image-20230306234745623

–record的作用是将当前命令记录到revision记录中，这样我们就可以知道每个revison对应的是哪个配置文件了。通过kubectl rollout history deployment httpd查看revison历史记录，

image-20230306234908534

CHANGE-CAUSE就是–record的结果。如果要回滚到某个版本，比如revision 1，可以执行命令kubectl rollout undo deployment httpd --to-revision=1，

image-20230306235157320

此时，revison历史记录也会发生相应变化，

image-20230306235246980

revison 1变成了revison 4。不过我们可以通过CHANGE-CAUSE知道每个revison的具体含义，所以一定要在执行kubectl apply时加上–record参数。

滚动更新采用渐进的方式逐步替换旧版本Pod。如果更新不如预期，可以通过回滚操作恢复到更新前的状态。

Health Check

强大的自愈能力是Kubernetes这类容器编排引擎的一个重要特性。自愈的默认实现方式是自动重启发生故障的容器。

除此之外，用户还可以利用Liveness和Readiness探测机制设置更精细的健康检查，进而实现如下需求：

  • 零停机部署。
  • 避免部署无效的镜像。
  • 更加安全的滚动升级。

下面通过实践学习Kubernetes的Health Check功能。

我们首先学习Kubernetes默认的健康检查机制：每个容器启动时都会执行一个进程，此进程由Dockerfile的CMD或ENTRYPOINT指定。如果进程退出时返回码非零，则认为容器发生故障，Kubernetes就会根据restartPolicy重启容器。

下面来模拟一个容器发生故障的场景：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

apiVersion: v1
kind: Pod
metadata:
  name: healthcheck
  labels:
    test: healthcheck
spec:
  restartPolicy: OnFailure
  containers:
  - name: healthcheck
    image: busybox
    args:
    - /bin/sh
    - -c
    - sleep 10; exit 1
  • Pod的restartPolicy设置为OnFailure，默认为Always。
  • sleep 10; exit 1模拟容器启动10秒后发生故障。
  • 执行kubectl apply创建Pod，命名为healthcheck，

image-20230310232946063

可看到容器当前已经重启了4次。在上面的例子中，容器进程返回值非零，Kubernetes则认为容器发生故障，需要重启。

有不少情况是发生了故障，但进程并不会退出。比如访问Web服务器时显示500内部错误，可能是系统超载，也可能是资源死锁，此时httpd进程并没有异常退出，在这种情况下重启容器可能是最直接、最有效的解决方案，

那我们如何利用Health Check机制来处理这类场景呢？答案就是Liveness探测。

Liveness探测

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

apiVersion: v1
kind: Pod
metadata:
  name: liveness
  labels:
    test: liveness
spec:
  restartPolicy: OnFailure
  containers:
  - name: liveness
    image: busybox
    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

image-20230310234623051

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

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

  1. 探测的方法是：通过cat命令检查/tmp/healthy文件是否存在。如果命令执行成功，返回值为零，Kubernetes则认为本次Liveness探测成功；如果命令返回值非零，本次Liveness探测失败。
  2. initialDelaySeconds：10指定容器启动10之后开始执行Liveness探测，我们一般会根据应用启动的准备时间来设置。比如某个应用正常启动要花30秒，那么initialDelaySeconds的值就应该大于30。
  3. periodSeconds：5指定每5秒执行一次Liveness探测。Kubernetes如果连续执行3次Liveness探测均失败，则会杀掉并重启容器。

下面创建Pod liveness:

image-20230310235217954

从配置文件可知，最开始的30秒，/tmp/healthy存在，cat命令返回0，Liveness探测成功，这段时间kubectl describe pod liveness的Events部分会显示正常的日志，

image-20230310235435089

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

image-20230310235613635

image-20230310235759204

Readiness探测

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

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

Readiness探测的配置语法与Liveness探测完全一样，

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

apiVersion: v1
kind: Pod
metadata:
  name: readiness
  labels:
    test: readiness
spec:
  restartPolicy: OnFailure
  containers:
  - name: readiness
    image: busybox
    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

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

image-20230311000701675

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

  • 刚被创建时，READY状态为不可用。
  • 15秒后（initialDelaySeconds + periodSeconds），第一次进行Readiness探测并成功返回，设置READY为可用。
  • 30秒后，/tmp/healthy被删除，连续3次Readiness探测均失败后，READY被设置为不可用。

image-20230311000928503

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

  • Liveness探测和Readiness探测是两种Health Check机制，如果不特意配置，Kubernetes将对两种探测采取相同的默认行为，即通过判断容器启动进程的返回值是否为零来判断探测是否成功。
  • 两种探测的配置方法完全一样，支持的配置参数也一样。不同之处在于探测失败后的行为：Liveness探测是重启容器；Readiness探测则是将容器设置为不可用，不接收Service转发的请求。
  • Liveness探测和Readiness探测是独立执行的，二者之间没有依赖，所以可以单独使用，也可以同时使用。用Liveness探测判断容器是否需要重启以实现自愈；用Readiness探测判断容器是否已经准备好对外提供服务。

Health Check在Scale Up中的应用

对于多副本应用，当执行Scale Up操作时，新副本会作为backend被添加到Service的负载均衡中，与已有副本一起处理客户的请求。考虑到应用启动通常都需要一个准备阶段，比如加载缓存数据、连接数据库等，从容器启动到真正能够提供服务是需要一段时间的。

我们可以通过Readiness探测判断容器是否就绪，避免将请求发送到还没有准备好的backend。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

apiVersion: apps/v1
kind: Deployment
metadata:
 name: web
spec:
 replicas: 3
 selector:
  matchLabels:
   run: web
 template:
  metadata:
   labels:
    run: web
  spec:
   containers:
   - name: web
     image: httpd
     ports:
     - containerPort: 8080
     readinessProbe:
       httpGet:
         scheme: HTTP
         path: /healthy
         port: 8080
     initiaDelaySeconds: 10
     periodSeconds: 5

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

image-20230311002157438

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

  • schema指定协议，支持HTTP（默认值）和HTTPS。
  • path指定访问路径。
  • port指定端口。

上面配置的作用是：

（1）容器启动10秒之后开始探测。

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

（3）每隔5秒探测一次。

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

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

对于http://[container_ip]:8080/healthy，应用则可以实现自己的判断逻辑，比如检查所依赖的数据库是否就绪，

image-20230311002707663

①定义/healthy的处理函数。

②连接数据库并执行测试SQL。

③测试成功，正常返回，代码200。

④测试失败，返回错误代码503。

⑤在8080端口监听。

对于生产环境中重要的应用，都建议配置Health Check，保证处理客户请求的容器都是准备就绪的Service backend。

Health Check在滚动更新中的应用

Health Check另一个重要的应用场景是Rolling Update。试想一下，现有一个正常运行的多副本应用，接下来对应用进行更新（比如使用更高版本的image），Kubernetes会启动新副本，然后发生了如下事件：

（1）正常情况下新副本需要10秒钟完成准备工作，在此之前无法响应业务请求。

（2）由于人为配置错误，副本始终无法完成准备工作（比如无法连接后端数据库）。

试想一下，如果我们没有配置Health Check，会发生什么样的情况？

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

2）如果正确配置了Health Check，新副本只有通过了Readiness探测才会被添加到Service；如果没有通过探测，现有副本不会被全部替换，业务仍然正常进行。

下面通过例子来实践Health Check在Rolling Update中的应用。

使用如下配置文件app.v1.yml模拟一个10副本的应用，

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

apiVersion: apps/v1
kind: Deployment
metadata:
 name: app
spec:
 replicas: 10
 selector:
  matchLabels:
   run: app
 template:
  metadata:
   labels:
    run: app
  spec:
   containers:
   - name: app
     image: busybox
     args:
     - /bin/sh
     - -c
     - sleep 10; touch /tmp/healthy; sleep 30000
     readinessProbe:
       exec:
         command:
         - cat
         - /tmp/healthy
       initialDelaySeconds: 10
       periodSeconds: 5

10秒后副本能够通过Readiness探测，

image-20230311004456002

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

apiVersion: apps/v1
kind: Deployment
metadata:
 name: app
spec:
 replicas: 10
 selector:
  matchLabels:
   run: app
 template:
  metadata:
   labels:
    run: app
  spec:
   containers:
   - name: app
     image: busybox
     args:
     - /bin/sh
     - -c
     - sleep 3000
     readinessProbe:
       exec:
         command:
         - cat
         - /tmp/healthy
       initialDelaySeconds: 10
       periodSeconds: 5

很显然，由于新副本中不存在/tmp/healthy，因此是无法通过Readiness探测的，验证如下：

image-20230311005007034

image-20230311005445930

上面两个截图包含了大量的信息，值得我们详细分析。

先关注kubectl get pods输出：

  • 从Pod的AGE栏可判断，前面5个Pod是新副本，目前处于NOT READY状态。
  • 旧副本从最初10个减少到8个。

再来看kubectl get deployment app的输出：

（1）DESIRED 10表示期望的状态是10个READY的副本。

（2）CURRENT 13表示当前副本的总数，即8个旧副本+5个新副本。

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

（4）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值越大，初始销毁的旧副本数量就越多。

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

（1）创建3个新副本使副本总数达到13个。

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

（3）当2个旧副本成功销毁后，再创建2个新副本，使副本总数保持为13个。

（4）当新副本通过Readiness探测后，会使可用副本数增加，超过8。

（5）进而可以继续销毁更多的旧副本，使可用副本数回到8。

（6）旧副本的销毁使副本总数低于13，这样就允许创建更多的新副本。

（7）这个过程会持续进行，最终所有的旧副本都会被新副本替换，滚动更新完成。

而我们的实际情况是在第4步就卡住了，新副本无法通过Readiness探测。这个过程可以在kubectl describe deployment app的日志部分查看，

image-20230311010432162

如果滚动更新失败，可以通过kubectl rollout undo回滚到上一个版本，

image-20230311010921993

如果要定制maxSurge和maxUnavailable，可以按如下配置：

image-20230311011129425

如上讨论了Kubernetes健康检查的两种机制：Liveness探测和Readiness探测，并实践了健康检查在Scale Up和Rolling Update场景中的应用。