k8s之健康检查(Health Check)

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

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

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

默认的健康检查

首先学习 Kubernetes 默认的健康检查机制：

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

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

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。

# kubectl apply -f healthcheck.yml
pod/healthcheck created

过几分钟查看 Pod 的状态：

# kubectl get pod healthcheck
NAME          READY   STATUS             RESTARTS   AGE
healthcheck   0/1     CrashLoopBackOff   4          3m39s

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

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

答案就是 Liveness 探测。

Liveness 探测

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

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

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

# kubectl apply -f liveness.yaml
pod/liveness created

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

# kubectl describe pod liveness 
Events:
  Type    Reason     Age   From                Message
  ----    ------     ----  ----                -------
  Normal  Scheduled  31s   default-scheduler   Successfully assigned default/liveness to k8s-node2
  Normal  Pulling    30s   kubelet, k8s-node2  Pulling image "busybox"
  Normal  Pulled     30s   kubelet, k8s-node2  Successfully pulled image "busybox"
  Normal  Created    30s   kubelet, k8s-node2  Created container liveness
  Normal  Started    29s   kubelet, k8s-node2  Started container liveness

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

Events:
  Type     Reason     Age               From                Message
  ----     ------     ----              ----                -------
  Normal   Scheduled  47s               default-scheduler   Successfully assigned default/liveness to k8s-node2
  Normal   Pulling    46s               kubelet, k8s-node2  Pulling image "busybox"
  Normal   Pulled     46s               kubelet, k8s-node2  Successfully pulled image "busybox"
  Normal   Created    46s               kubelet, k8s-node2  Created container liveness
  Normal   Started    45s               kubelet, k8s-node2  Started container liveness
  Warning  Unhealthy  3s (x3 over 13s)  kubelet, k8s-node2  Liveness probe failed: cat: can‘t open ‘/tmp/healthy‘: No such file or directory
  Normal   Killing    3s                kubelet, k8s-node2  Container liveness failed liveness probe, will be restarted
# kubectl get pod liveness
NAME       READY   STATUS    RESTARTS   AGE
liveness   1/1     Running   1          76s

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

Readiness 探测

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

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

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，我们看看有什么不同的效果。

[[email protected] ~]# kubectl get pod readiness
NAME        READY   STATUS    RESTARTS   AGE
readiness   0/1     Running   0          10s
[[email protected] ~]# kubectl get pod readiness
NAME        READY   STATUS    RESTARTS   AGE
readiness   1/1     Running   0          20s
[[email protected] ~]# kubectl get pod readiness
NAME        READY   STATUS    RESTARTS   AGE
readiness   1/1     Running   0          35s
[[email protected] ~]# kubectl get pod readiness
NAME        READY   STATUS    RESTARTS   AGE
readiness   0/1     Running   0          61s
[[email protected] ~]# kubectl describe pod readiness

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

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

通过 kubectl describe pod readiness 也可以看到 Readiness 探测失败的日志。

Events:
  Type     Reason     Age                From                Message
  ----     ------     ----               ----                -------
  Normal   Scheduled  95s                default-scheduler   Successfully assigned default/readiness to k8s-node2
  Normal   Pulling    94s                kubelet, k8s-node2  Pulling image "busybox"
  Normal   Pulled     94s                kubelet, k8s-node2  Successfully pulled image "busybox"
  Normal   Created    93s                kubelet, k8s-node2  Created container readiness
  Normal   Started    93s                kubelet, k8s-node2  Started container readiness
  Warning  Unhealthy  4s (x12 over 59s)  kubelet, k8s-node2  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 探测判断容器是否已经准备好对外提供服务。

在业务场景中使用 Health Check。

在 Rolling Update 中使用 Health Check

上一节讨论了 Health Check 在 Scale Up 中的应用，Health Check 另一个重要的应用场景是 Rolling Update。试想一下下面的情况：

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

  1. 正常情况下新副本需要 10 秒钟完成准备工作，在此之前无法响应业务请求。
  2. 但由于人为配置错误，副本始终无法完成准备工作（比如无法连接后端数据库）。

思考问题：如果没有配置 Health Check，会出现怎样的情况？

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

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

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

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

apiVersion: apps/v1beta1
kind: Deployment
metadata:
  name: app
spec:
  replicas: 10
  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

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

# kubectl get deployments. app
NAME   READY   UP-TO-DATE   AVAILABLE   AGE
app    0/10    10           0           8s

# kubectl get pod
NAME                   READY   STATUS    RESTARTS   AGE
app-6dd7f876c4-575v5   1/1     Running   0          25s
app-6dd7f876c4-9kwk9   1/1     Running   0          25s
app-6dd7f876c4-bx4pf   1/1     Running   0          25s
app-6dd7f876c4-f6qf2   1/1     Running   0          25s
app-6dd7f876c4-fxp2m   1/1     Running   0          25s
app-6dd7f876c4-k76mr   1/1     Running   0          25s
app-6dd7f876c4-mfqsq   1/1     Running   0          25s
app-6dd7f876c4-whkc7   1/1     Running   0          25s
app-6dd7f876c4-x9q87   1/1     Running   0          25s
app-6dd7f876c4-xf8dv   1/1     Running   0          25s

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

apiVersion: apps/v1beta1
kind: Deployment
metadata:
  name: app
spec:
  replicas: 10
  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 探测的。验证如下：

# kubectl apply -f app.yml --record
deployment.apps/app configured
[[email protected] ~]# kubectl get deployments. app
NAME   READY   UP-TO-DATE   AVAILABLE   AGE
app    8/10    5            8           80s

# kubectl get pod
NAME                   READY   STATUS    RESTARTS   AGE
app-6dd7f876c4-575v5   1/1     Running   0          2m3s
app-6dd7f876c4-9kwk9   1/1     Running   0          2m3s
app-6dd7f876c4-f6qf2   1/1     Running   0          2m3s
app-6dd7f876c4-fxp2m   1/1     Running   0          2m3s
app-6dd7f876c4-k76mr   1/1     Running   0          2m3s
app-6dd7f876c4-whkc7   1/1     Running   0          2m3s
app-6dd7f876c4-x9q87   1/1     Running   0          2m3s
app-6dd7f876c4-xf8dv   1/1     Running   0          2m3s
app-7d7559dd99-6w2kn   0/1     Running   0          49s
app-7d7559dd99-jnbxg   0/1     Running   0          49s
app-7d7559dd99-mxbwg   0/1     Running   0          49s
app-7d7559dd99-n59vq   0/1     Running   0          49s
app-7d7559dd99-t49cp   0/1     Running   0          49s

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

先关注 kubectl get pod 输出：

  1. 从 Pod 的 AGE 栏可判断，最后 5 个 Pod 是新副本，目前处于 NOT READY 状态。
  2. 旧副本从最初 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 的日志部分查看。
Events:
  Type    Reason             Age   From                   Message
  ----    ------             ----  ----                   -------
  Normal  ScalingReplicaSet  11m   deployment-controller  Scaled up replica set app-6dd7f876c4 to 10
  Normal  ScalingReplicaSet  10m   deployment-controller  Scaled up replica set app-7d7559dd99 to 3
  Normal  ScalingReplicaSet  10m   deployment-controller  Scaled down replica set app-6dd7f876c4 to 8
  Normal  ScalingReplicaSet  10m   deployment-controller  Scaled up replica set app-7d7559dd99 to 5

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

# kubectl rollout history deployment app
deployment.extensions/app
REVISION  CHANGE-CAUSE
1         kubectl apply --filename=app.yml --record=true
2         kubectl apply --filename=app.yml --record=true

# kubectl get deployments. app
NAME   READY   UP-TO-DATE   AVAILABLE   AGE
app    8/10    5            8           14m
 kubectl get pod
NAME                   READY   STATUS    RESTARTS   AGE
app-6dd7f876c4-575v5   1/1     Running   0          14m
app-6dd7f876c4-9kwk9   1/1     Running   0          14m
app-6dd7f876c4-f6qf2   1/1     Running   0          14m
app-6dd7f876c4-fxp2m   1/1     Running   0          14m
app-6dd7f876c4-k76mr   1/1     Running   0          14m
app-6dd7f876c4-whkc7   1/1     Running   0          14m
app-6dd7f876c4-x9q87   1/1     Running   0          14m
app-6dd7f876c4-xf8dv   1/1     Running   0          14m
app-7d7559dd99-6w2kn   0/1     Running   0          13m
app-7d7559dd99-jnbxg   0/1     Running   0          13m
app-7d7559dd99-mxbwg   0/1     Running   0          13m
app-7d7559dd99-n59vq   0/1     Running   0          13m
app-7d7559dd99-t49cp   0/1     Running   0          13m

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

apiVersion: apps/v1beta1
kind: Deployment
metadata:
  name: app
spec:
  strategy:
    rollingUpdate:
      maxSurge: 35%
      maxUnavailable: 35%
  replicas: 10
  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

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

原文地址：https://blog.51cto.com/5157495/2441349

时间： 2024-08-14 05:24:27

k8s之健康检查(Health Check)的相关文章

ASP.NET Core之跨平台的实时性能监控(2.健康检查)

前言 上篇我们讲了如何使用App Metrics 做一个简单的APM监控,最后提到过健康检查这个东西. 这篇主要就是讲解健康检查的内容. 没看过上篇的,请移步:ASP.NET Core之跨平台的实时性能监控 首先我们来了解一下什么是健康检查(health checks)? 1.什么是健康检查? 健康检查,其实这个名称已经很明确了,它是检查你的应用程序是否健康运行的一种方式.随着当前各类项目越来越多的应用程序正在转向微服务式架构,健康检查就变得尤为关键.虽然微服务体系结构具有许多好处,但其中一个缺

k8s的Health Check（健康检查）

强大的自愈能力是 Kubernetes 这类容器编排引擎的一个重要特性.自愈的默认实现方式是自动重启发生故障的容器.除此之外,用户还可以利用 Liveness 和 Readiness 探测机制设置更精细的健康检查,进而实现如下需求: 零停机部署. 避免部署无效的镜像. 更加安全的滚动升级. 下面通过实践学习 Kubernetes 的 Health Check 功能. 1.默认的健康检查 我们首先学习 Kubernetes 默认的健康检查机制: 每个容器启动时都会执行一个进程,此进程由 Docke

Biztalk 健康检查（Health check）powershell脚本

<#.SYNOPSISPowerShell script to perform a quick BizTalk Health Check.DESCRIPTIONThis script gathers and displays a lot of information about a BizTalk server. Sections include Windows, Computer, BizTalk artifacts, Event Logs and more.IMPORTANT! The sc

k8s健康检查（9）

一.默认的健康检查 强大的自愈能力是 Kubernetes 这类容器编排引擎的一个重要特性.自愈的默认实现方式是自动重启发生故障的容器.除此之外,用户还可以利用 Liveness 和 Readiness 探测机制设置更精细的健康检查,进而实现如下需求: (1)零停机部署. (2)避免部署无效的镜像. (3)更加安全的滚动升级. 每个容器启动时都会执行一个进程,此进程由 Dockerfile 的 CMD 或 ENTRYPOINT 指定.如果进程退出时返回码非零,则认为容器发生故障,Kubernet

.net core i上 K8S(四).netcore程序的pod管理，重启策略与健康检查

上一章我们已经通过yaml文件将.netcore程序跑起来了,但还有一下细节问题可以分享给大家. 1.pod管理 1.1创建pod kubectl create -f netcore-pod.yaml 我们创建一个netcore-pod.yaml文件,内容如下: apiVersion: v1 kind: Pod #指明类型 metadata: name: netcore-pod labels: app: netcorepod spec: containers: - name: netcorepo

idou老师教你学Istio 14：如何用K8S对Istio Service进行流量健康检查

Istio利用k8s的探针对service进行流量健康检查,有两种探针可供选择,分别是liveness和readiness: liveness探针用来侦测什么时候需要重启容器.比如说当liveness探针捕获到程序运行时出现的一个死锁,这种情况下重启容器可以让程序更容易可用. readiness探针用来使容器准备好接收流量.当所有容器都ready时被视为pod此时ready.比如说用这种信号来控制一个后端服务,当pod没有到ready状态时,服务会从负载均衡被移除. 使用场景: liveness

k8s探测机制之pod健康检查

一:需求来源: 首先来看一下,整个需求的来源:当把应用迁移到 Kubernetes 之后,要如何去保障应用的健康与稳定呢?其实很简单,可以从两个方面来进行增强: 1,首先是提高应用的可观测性:2,第二是提高应用的可恢复能力. 从可观测性上来讲,可以在三个方面来去做增强: 1,首先是应用的健康状态上面,可以实时地进行观测:2,第二个是可以获取应用的资源使用情况:3,第三个是可以拿到应用的实时日志,进行问题的诊断与分析. 当出现了问题之后,首先要做的事情是要降低影响的范围,进行问题的调试与诊断.最后

健康监控器(Health Monitor)

健康监控器(Health Monitor)ORACLE 11G 中引入了免费的数据库健康监控器,通过DBMS_HM程序包来完成. 检查项目:1.DB结构完整性检查 2.数据块及完整性检查 3.中做日志完整性检查 4.Undo段完整性检查 5.事物完整性检查 6.数据字典完整性检查 SQL> select name,description from v$hm_check;NAME                           DESCRIPTION----------------------

小麦苗健康检查脚本说明

小麦苗健康检查脚本说明 第一章 小麦苗健康检查脚本特点 小麦苗健康检查脚本有如下的特点: 1. 绿色版.免安装.纯SQL文本 2. 跨平台,只要有SQL*Plus环境即可运行 3. 兼容Oracle 10g.11g及12c版本 4. 一次购买,终身免费升级 5. 检查内容非常全面 6. 脚本可视化,可以看到脚本内容,因此可供学习使用 7. 只有1个SQL脚本,不存在嵌套调用等其它问题 8. 生成html文件的健康检查结果 9. 对结果进行过滤,列出了数据库有问题的内容   第二章 小麦苗健康检查