10、Health Check、及机制Liveness 探测、机制Readiness 探测、在Scale Up(伸缩)中使用Health Check、

最新推荐文章于 2024-05-22 20:05:44 发布

junior1206

最新推荐文章于 2024-05-22 20:05:44 发布

阅读量2.4k

点赞数

分类专栏： Kubernetes

本文链接：https://blog.csdn.net/cojn52/article/details/111554477

版权

Kubernetes 专栏收录该内容

28 篇文章 3 订阅

订阅专栏

Health Check

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

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

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

默认的健康检查

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

下面我们模拟一个容器发生故障的场景，Pod 配置文件如下：

[root@master pod]# vim healthcheck.yml 
apiVersion: v1
kind: Pod
metadata:
  labels:
    test: healthcheck
  name: 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。

[root@master pod]# kubectl apply -f healthcheck.yml 
pod/healthcheck created

过几分钟查看 Pod 的状态：

[root@master pod]# kubectl get pod healthcheck
NAME          READY   STATUS    RESTARTS   AGE
healthcheck   1/1     Running   3          50s

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

在上面的例子中，容器进程返回值非零，Kubernetes 则认为容器发生故障，需要重启。但有不少情况是发生了故障，但进程并不会退出。

比如访问 Web 服务器时显示 500 内部错误，可能是系统超载，也可能是资源死锁，此时 httpd 进程并没有异常退出，在这种情况下重启容器可能是最直接最有效的解决方案，利用 Health Check 机制Liveness 探测来处理这类场景

Liveness 探测

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

还是举例说明，创建如下 Pod：

[root@master pod]# vim liveness.yml 

apiVersion: v1
kind: Pod
metadata:
  labels:
    test: liveness
  name: 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

启动进程首先创建文件 /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：

[root@master pod]# kubectl apply -f liveness.yml 
pod/liveness created

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

[root@master pod]# kubectl describe pod liveness
Name:         liveness
Namespace:    default
Priority:     0
Node:         node2/10.70.36.252
Start Time:   Wed, 23 Dec 2020 10:25:37 +0800
Labels:       test=liveness
Annotations:  <none>
Status:       Running
IP:           10.244.2.235
IPs:
  IP:  10.244.2.235
Containers:
  liveness:
    Container ID:  docker://8aa3028afef003178d854bd2a3aa4cec931ee32ff08def25e7565d99db9054fc
    Image:         busybox
    Image ID:      docker-pullable://busybox@sha256:bde48e1751173b709090c2539fdf12d6ba64e88ec7a4301591227ce925f3c678
    Port:          <none>
    Host Port:     <none>
    Args:
      /bin/sh
      -c
      touch /tmp/healthy; sleep 30; rm -rf /tmp/healthy; sleep 600
    State:          Running
      Started:      Wed, 23 Dec 2020 10:25:41 +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-6x5lr (ro)
Conditions:
  Type              Status
  Initialized       True 
  Ready             True 
  ContainersReady   True 
  PodScheduled      True 
Volumes:
  default-token-6x5lr:
    Type:        Secret (a volume populated by a Secret)
    SecretName:  default-token-6x5lr
    Optional:    false
QoS Class:       BestEffort
Node-Selectors:  <none>
Tolerations:     node.kubernetes.io/not-ready:NoExecute op=Exists for 300s
                 node.kubernetes.io/unreachable:NoExecute op=Exists for 300s
Events:
  Type     Reason     Age                From               Message
  ----     ------     ----               ----               -------
  Normal   Scheduled  64s                default-scheduler  Successfully assigned default/liveness to node2
  Normal   Pulling    64s                kubelet            Pulling image "busybox"
  Normal   Pulled     60s                kubelet            Successfully pulled image "busybox" in 3.216361371s
  Normal   Created    60s                kubelet            Created container liveness
  Normal   Started    60s                kubelet            Started container liveness
  Warning  Unhealthy  20s (x3 over 30s)  kubelet            Liveness probe failed: cat: can't open '/tmp/healthy': No such file or directory
  Normal   Killing    20s                kubelet            Container liveness failed liveness probe, will be restarted

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

[root@master pod]# kubectl get pod liveness
NAME       READY   STATUS    RESTARTS   AGE
liveness   1/1     Running   2          3m43s

Readiness 探测

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

Readiness 探测的配置语法与 Liveness 探测完全一样，下面是个例子：

[root@master pod]# vim readiness.yml 
apiVersion: v1
kind: Pod
metadata:
  labels:
    test: readiness
  name: 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，我们看看有什么不同的效果。

[root@master pod]# kubectl apply -f readiness.yml 
pod/readiness created
[root@master pod]# kubectl get pod readiness
NAME        READY   STATUS    RESTARTS   AGE
readiness   1/1     Running   0          32s
[root@master pod]# kubectl get pod readiness
NAME        READY   STATUS    RESTARTS   AGE
readiness   1/1     Running   0          40s
[root@master pod]# kubectl get pod readiness
NAME        READY   STATUS    RESTARTS   AGE
readiness   0/1     Running   0          46s

Pod readiness 的 READY 状态经历了如下变化：
1、刚被创建时，READY 状态为不可用。
2、15 秒后（initialDelaySeconds + periodSeconds），第一次进行 Readiness 探测并成功返回，设置 READY 为可用。
3、30 秒后，/tmp/healthy 被删除，连续 3 次 Readiness 探测均失败后，READY 被设置为不可用。

[root@master pod]# kubectl describe pod readiness
Name:         readiness
Namespace:    default
Priority:     0
Node:         node1/10.70.36.251
Start Time:   Wed, 23 Dec 2020 11:13:06 +0800
Labels:       test=readiness
Annotations:  <none>
Status:       Running
IP:           10.244.1.217
IPs:
  IP:  10.244.1.217
Containers:
  readiness:
    Container ID:  docker://5964a97e12aa315eff7bff2ad388a9a82f11fc1d481013dec8f7cf3b1bb66722
    Image:         busybox
    Image ID:      docker-pullable://busybox@sha256:bde48e1751173b709090c2539fdf12d6ba64e88ec7a4301591227ce925f3c678
    Port:          <none>
    Host Port:     <none>
    Args:
      /bin/sh
      -c
      touch /tmp/healthy; sleep 30; rm -rf /tmp/healthy; sleep 600
    State:          Running
      Started:      Wed, 23 Dec 2020 11:13:11 +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-6x5lr (ro)
Conditions:
  Type              Status
  Initialized       True 
  Ready             False 
  ContainersReady   False 
  PodScheduled      True 
Volumes:
  default-token-6x5lr:
    Type:        Secret (a volume populated by a Secret)
    SecretName:  default-token-6x5lr
    Optional:    false
QoS Class:       BestEffort
Node-Selectors:  <none>
Tolerations:     node.kubernetes.io/not-ready:NoExecute op=Exists for 300s
                 node.kubernetes.io/unreachable:NoExecute op=Exists for 300s
Events:
  Type     Reason     Age               From               Message
  ----     ------     ----              ----               -------
  Normal   Scheduled  71s               default-scheduler  Successfully assigned default/readiness to node1
  Normal   Pulling    70s               kubelet            Pulling image "busybox"
  Normal   Pulled     66s               kubelet            Successfully pulled image "busybox" in 4.04135028s
  Normal   Created    66s               kubelet            Created container readiness
  Normal   Started    66s               kubelet            Started container readiness
  Warning  Unhealthy  0s (x8 over 35s)  kubelet            Readiness probe failed: cat: can't open '/tmp/healthy': No such file or directory

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

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

在Scale Up(伸缩)中使用Health Check

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

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

apiVersion: apps/v1
kind: Deployment
metadata:
  name: web
spec:
  selector:
     matchLabels:
        run: web

  replicas: 3
  template:
    metadata:
      labels:
        run: web
    spec:
      containers:
      - name: web
        image: httpd
        ports:
        - containerPort: 8080
        readinessProbe:
          httpGet:
            scheme: HTTP
            path: /health-check
            port: 8080
          initialDelaySeconds: 10
          periodSeconds: 5
---
apiVersion: v1
kind: Service
metadata:
  name: web-svc
spec:
  selector:
    run: web
  ports:
  - protocol: TCP
    port: 8080
    targetPort: 80

重点关注 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，应用则可以实现自己的判断逻辑，比如检查所依赖的数据库是否就绪，示例代码如下：

å¾ç

① 定义 /healthy 的处理函数。
② 连接数据库并执行测试 SQL。
③ 测试成功，正常返回，代码 200。
④ 测试失败，返回错误代码 503。
⑤ 在 8080 端口监听。
对于生产环境中重要的应用都建议配置 Health Check，保证处理客户请求的容器都是准备就绪的 Service backend

通过以上yaml，创建了一个名为web-svc的服务和名为web的Deployment。

[root@k8s-m health-check]# kubectl apply -f HealthCheck-web-deployment.yaml
deployment.apps/web unchanged
service/web-svc created
[root@k8s-m health-check]# kubectl get service web-svc
NAME      TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)    AGE
web-svc   ClusterIP   10.101.1.6   <none>        8080/TCP   2m20s
[root@k8s-m health-check]# kubectl get deployment web
NAME   DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
web    3         3         3            0           3m26s
[root@k8s-m health-check]# kubectl get pod
NAME                   READY   STATUS    RESTARTS   AGE
web-7d96585f7f-q5p4d   0/1     Running   0          3m35s
web-7d96585f7f-w6tqx   0/1     Running   0          3m35s
web-7d96585f7f-xrqwm   0/1     Running   0          3m35s

重点关注一下指出本案例中使用的Health Check机制为Readiness，探测方法为httpGet。Kubernetes对于该方法探测成功的判断条件时http请求返回值在200-400之间。schema指定了协议，可以为http（默认）和https。path指定访问路径，port指定端口。

容器启动10s后开始探测，如果 http://container_ip:8080/health-check 的返回值不是200-400,表示容器没有准备就绪，不接收Service web-svc的请求。/health-check则是我们实现探测的代码。探测结果示例如下：

[root@k8s-m health-check]# kubectl describe pod web
Warning  Unhealthy  57s (x219 over 19m)  kubelet, k8s-n2    Readiness probe failed: Get http://10.244.2.61:8080/healthy: dial tcp 10.244.2.61:8080: connect: connection refused

Health Check在滚动更新（Rolling Update）中的应用。

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

1、正常情况下新副本需要 10 秒钟完成准备工作，在此之前无法响应业务请求。
2、但由于人为配置错误，副本始终无法完成准备工作（比如无法连接后端数据库）。
先别继续往下看，现在请花一分钟思考这个问题：如果没有配置 Health Check，会出现怎样

默认情况下，在Rolling Update过程中，Kubernetes会认为容器已经准备就绪，进而会逐步替换旧副本。如果新版本的容器出现故障，那么在版本更新完成之后可能导致整个应用无法处理请求，无法对外提供服务。此类事件若发生在生产环境中，后果会非常严重。正确配置了Health Check，只有通过了Readiness探测的新副本才能添加到Service，如果没有通过探测，现有副本就不会被替换，业务依然正常运行。

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

接下来，我们分别创建yaml文件app.v1.yaml和app.v2.yaml:

[root@master update]# vim app.v1.yml 

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

[root@master update]# vim app.v2.yml 
apiVersion: apps/v1
kind: Deployment
metadata:
  name: app
spec:
  selector:
     matchLabels:
        run: app
  replicas: 10
  template:
    metadata:
      labels:
        run: app
    spec:
      containers:
      - name: app
        image: busybox
        args:
        - /bin/sh
        - -c
        - sleep 3000
        readinessProbe:
          exec:
            command:
            - cat
            - /tmp/health-check
          initialDelaySeconds: 10
          periodSeconds: 5

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

[root@master update]# kubectl apply -f app.v1.yml --record
deployment.apps/app created
[root@master update]# kubectl get deployment app
NAME   READY   UP-TO-DATE   AVAILABLE   AGE
app    10/10   10           10          41s
[root@master update]# kubectl get pod
NAME                   READY   STATUS    RESTARTS   AGE
app-5c8756f6b5-74sqc   1/1     Running   0          53s
app-5c8756f6b5-fjnw4   1/1     Running   0          53s
app-5c8756f6b5-g9kgk   1/1     Running   0          53s
app-5c8756f6b5-ghlkg   1/1     Running   0          53s
app-5c8756f6b5-h8mvj   1/1     Running   0          53s
app-5c8756f6b5-jw2fv   1/1     Running   0          53s
app-5c8756f6b5-kksmz   1/1     Running   0          53s
app-5c8756f6b5-nbxv2   1/1     Running   0          53s
app-5c8756f6b5-v5hth   1/1     Running   0          53s
app-5c8756f6b5-zdrtk   1/1     Running   0          53s

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

[root@master update]# kubectl apply -f app.v2.yml --record
deployment.apps/app configured
[root@master update]# kubectl get pod
NAME                   READY   STATUS    RESTARTS   AGE
app-55cbf7d698-cjrlk   0/1     Running   0          69s
app-55cbf7d698-dpwt5   0/1     Running   0          69s
app-55cbf7d698-npzl5   0/1     Running   0          69s
app-55cbf7d698-r9vzh   0/1     Running   0          69s
app-55cbf7d698-zjg89   0/1     Running   0          69s
app-5c8756f6b5-74sqc   1/1     Running   0          3m12s
app-5c8756f6b5-fjnw4   1/1     Running   0          3m12s
app-5c8756f6b5-g9kgk   1/1     Running   0          3m12s
app-5c8756f6b5-ghlkg   1/1     Running   0          3m12s
app-5c8756f6b5-h8mvj   1/1     Running   0          3m12s
app-5c8756f6b5-kksmz   1/1     Running   0          3m12s
app-5c8756f6b5-nbxv2   1/1     Running   0          3m12s
app-5c8756f6b5-v5hth   1/1     Running   0          3m12s

此刻状态全部为running，但是依然有5个Pod的READY为0/1，再看一下：

[root@master update]# kubectl get deployment app
NAME   READY   UP-TO-DATE   AVAILABLE   AGE
app    8/10    5            8           4m14s

先关注 kubectl get pod 输出：

1、从 Pod 的 AGE 栏可判断，最后 5 个 Pod 是新副本，目前处于 NOT READY 状态。
2、旧副本从最初 10 个减少到 8 个。
再来看 kubectl get deployment app 的输出：
1、READY 8/10 表示期望的状态是 10 个 READY 的副本,实际状态8个READY 的副本
2、UP-TO-DATE 5 表示当前已经完成更新的副本数：即 5 个新副本。就是app.v2.yml
3、AVAILABLE 8 表示当前处于 READY 状态的副本数：即 8个旧副本。
在我们的设定中，新副本始终都无法通过 Readiness 探测，所以这个状态会一直保持下去。
上面我们模拟了一个滚动更新失败的场景。不过幸运的是：Health Check 帮我们屏蔽了有缺陷的副本，同时保留了大部分旧副本，业务没有因更新失败受到影响。

为什么新创建的副本数是 5 个，同时只销毁了 2 个旧副本？
原因是：滚动更新通过参数 maxSurge 和 maxUnavailable 来控制副本替换的数量。
maxSurge
此参数控制滚动更新过程中副本总数的超过 DESIRED 的上限。maxSurge 可以是具体的整数（比如 3），也可以是百分百，向上取整。maxSurge 默认值为 25%。
在上面的例子中，DESIRED 为 10，那么副本总数的最大值为：
roundUp(10 + 10 * 25%) = 13
所以我们看到 UP-TO-DATE + AVAILABLE就是 13。
maxUnavailable
此参数控制滚动更新过程中，不可用的副本相占 DESIRED 的最大比例。 maxUnavailable 可以是具体的整数（比如 3），也可以是百分百，向下取整。maxUnavailable 默认值为 25%。
在上面的例子中，DESIRED 为 10，那么可用的副本数至少要为：
10 - roundDown(10 * 25%) = 8
所以我们看到 AVAILABLE 就是 8。
maxSurge 值越大，初始创建的新副本数量就越多；maxUnavailable 值越大，初始销毁的旧副本数量就越多。

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

[root@master update]# kubectl rollout history deployment app
deployment.apps/app 
REVISION  CHANGE-CAUSE
1         kubectl apply --filename=app.v1.yml --record=true
2         kubectl apply --filename=app.v2.yml --record=true

[root@master update]# kubectl rollout undo deployment app --to-revision=1
deployment.apps/app rolled back
[root@master update]# kubectl get pod
NAME                   READY   STATUS    RESTARTS   AGE
app-5c8756f6b5-5p6kc   1/1     Running   0          55s
app-5c8756f6b5-74sqc   1/1     Running   0          43m
app-5c8756f6b5-fjnw4   1/1     Running   0          43m
app-5c8756f6b5-g9kgk   1/1     Running   0          43m
app-5c8756f6b5-ghlkg   1/1     Running   0          43m
app-5c8756f6b5-h8mvj   1/1     Running   0          43m
app-5c8756f6b5-kksmz   1/1     Running   0          43m
app-5c8756f6b5-mkw8z   1/1     Running   0          55s
app-5c8756f6b5-nbxv2   1/1     Running   0          43m
app-5c8756f6b5-v5hth   1/1     Running   0          43m

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

å¾ç

Liveness和Readiness是Kubernetes中两种不同的Health Check方式，他们非常类似，但又有区别。可以两者同时使用，也可以单独使用。具体差异在上文已经提及。

Rolling Update提到滚动更新过程中的替换规则。在本文中我们依然使用了默认方式进行更新。maxSurge和maxUnavailable两个参数决定了更新过程中各个状态下的副本个数，这两个参数的默认值都是25%。更新后，总副本数=8+8*0.25=10；可用副本数：8-8*0.25=6。此过程中，销毁了2个副本，创建了4个新副本。

在一般生产环境上线时，尽量使用Health Check来确保业务不受影响。这个过程的实现手段多样化，需要根据实际情况进行总结和选用。