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-10-13 23:03:24

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. 对结果进行过滤,列出了数据库有问题的内容   第二章 小麦苗健康检查