怎么使用Pod的Liveness和Readiness与StartupProbe

本文转载自微信公众号「运维开发故事」，作者没有文案的夏老师。转载本文请联系运维开发故事公众号。

怎么配置Pod的liveness和readiness与startup探针

当你使用kubernetes的时候，有没有遇到过Pod在启动后一会就挂掉然后又重新启动这样的恶性循环?你有没有想过kubernetes是如何检测pod是否还存活?虽然容器已经启动，但是kubernetes如何知道容器的进程是否准备好对外提供服务了呢?让我们通过kubernetes官网的这篇文章Configure Liveness and Readiness Probes，来一探究竟。

本文将展示如何配置容器的存活和可读性探针。

Kubelet使用liveness probe(存活探针)来确定何时重启容器。例如，当应用程序处于运行状态但无法做进一步操作，liveness探针将捕获到deadlock，重启处于该状态下的容器，使应用程序在存在bug的情况下依然能够继续运行下去(谁的程序还没几个bug呢)。

Kubelet使用readiness probe(就绪探针)来确定容器是否已经就绪可以接受流量。只有当Pod中的容器都处于就绪状态时kubelet才会认定该Pod处于就绪状态。该信号的作用是控制哪些Pod应该作为service的后端。如果Pod处于非就绪状态，那么它们将会被从service的load balancer中移除。

Kubelet使用startup probe(启动探针)来确定容器是否已经启动。有时候，会有一些现有的应用程序在启动时需要较多的初始化时间。要不影响对引起探测死锁的快速响应，在这种情况下，设置存活探测参数是要技巧的。技巧就是使用一个命令来设置启动探测，针对HTTP 或者 TCP 检测，可以通过设置 failureThreshold * periodSeconds 参数来保证有足够长的时间应对糟糕情况下的启动时间。

定义 liveness命令

许多长时间运行的应用程序最终会转换到broken状态，除非重新启动，否则无法恢复。Kubernetes提供了liveness probe来检测和补救这种情况。在本次练习将基于 gcr.io/google_containers/busybox镜像创建运行一个容器的Pod。以下是Pod的配置文件exec-liveness.yaml：

 
 
 
 
    
  
  
  
  
  1. apiVersion: v1 
    2. 
  
  
  
  
  2. kind: Pod 
    3. 
  
  
  
  
  3. metadata: 
    4. 
  
  
  
  
  4.   labels: 
    5. 
  
  
  
  
  5.     test: liveness 
    6. 
  
  
  
  
  6.   name: liveness-exec 
    7. 
  
  
  
  
  7. spec: 
    8. 
  
  
  
  
  8.   containers: 
    9. 
  
  
  
  
  9.   - name: liveness 
    10. 
  
  
  
  
  10.     args: 
    11. 
  
  
  
  
  11.     - /bin/sh 
    12. 
  
  
  
  
  12.     - -c 
    13. 
  
  
  
  
  13.     - touch /tmp/healthy; sleep 30; rm -rf /tmp/healthy; sleep 600 
    14. 
  
  
  
  
  14.     image: gcr.io/google_containers/busybox 
    15. 
  
  
  
  
  15.     livenessProbe: 
    16. 
  
  
  
  
  16.       exec: 
    17. 
  
  
  
  
  17.         command: 
    18. 
  
  
  
  
  18.         - cat 
    19. 
  
  
  
  
  19.         - /tmp/healthy 
    20. 
  
  
  
  
  20.       initialDelaySeconds: 5 
    21. 
  
  
  
  
  21.       periodSeconds: 5 
    22.

该配置文件给Pod配置了一个容器。periodSeconds 规定kubelet要每隔5秒执行一次liveness probe。initialDelaySeconds 告诉kubelet在第一次执行probe之前要的等待5秒钟。探针检测命令是在容器中执行 cat /tmp/healthy 命令。如果命令执行成功，将返回0，kubelet就会认为该容器是活着的并且很健康。如果返回非0值，kubelet就会杀掉这个容器并重启它。容器启动时，执行该命令：

 
 
 
 
    
  
  
  
  
  1. /bin/sh -c "touch /tmp/healthy; sleep 30; rm -rf /tmp/healthy; sleep 600" 
    2.

在容器生命的最初30秒内有一个 /tmp/healthy 文件，在这30秒内 cat /tmp/healthy命令会返回一个成功的返回码。30秒后， cat /tmp/healthy 将返回失败的返回码。创建Pod：

 
 
 
 
    
  
  
  
  
  1. kubectl create -f https://k8s.io/docs/tasks/configure-pod-container/exec-liveness.yaml 
    2.

在30秒内，查看Pod的event：

 
 
 
 
    
  
  
  
  
  1. kubectl describe pod liveness-exec 
    2.

结果显示没有失败的liveness probe：

 
 
 
 
    
  
  
  
  
  1. FirstSeen    LastSeen    Count   From            SubobjectPath           Type        Reason      Message 
    2. 
  
  
  
  
  2. --------- --------    -----   ----            -------------           --------    ------      ------- 
    3. 
  
  
  
  
  3. 24s       24s     1   {default-scheduler }                    Normal      Scheduled   Successfully assigned liveness-exec to worker0 
    4. 
  
  
  
  
  4. 23s       23s     1   {kubelet worker0}   spec.containers{liveness}   Normal      Pulling     pulling image "gcr.io/google_containers/busybox" 
    5. 
  
  
  
  
  5. 23s       23s     1   {kubelet worker0}   spec.containers{liveness}   Normal      Pulled      Successfully pulled image "gcr.io/google_containers/busybox" 
    6. 
  
  
  
  
  6. 23s       23s     1   {kubelet worker0}   spec.containers{liveness}   Normal      Created     Created container with docker id 86849c15382e; Security:[seccomp=unconfined] 
    7. 
  
  
  
  
  7. 23s       23s     1   {kubelet worker0}   spec.containers{liveness}   Normal      Started     Started container with docker id 86849c15382e 
    8.

启动35秒后，再次查看pod的event：

 
 
 
 
    
  
  
  
  
  1. kubectl describe pod liveness-exec 
    2.

在最下面有一条信息显示liveness probe失败，容器被删掉并重新创建。

 
 
 
 
    
  
  
  
  
  1. FirstSeen LastSeen    Count   From            SubobjectPath           Type        Reason      Message 
    2. 
  
  
  
  
  2. --------- --------    -----   ----            -------------           --------    ------      ------- 
    3. 
  
  
  
  
  3. 37s       37s     1   {default-scheduler }                    Normal      Scheduled   Successfully assigned liveness-exec to worker0 
    4. 
  
  
  
  
  4. 36s       36s     1   {kubelet worker0}   spec.containers{liveness}   Normal      Pulling     pulling image "gcr.io/google_containers/busybox" 
    5. 
  
  
  
  
  5. 36s       36s     1   {kubelet worker0}   spec.containers{liveness}   Normal      Pulled      Successfully pulled image "gcr.io/google_containers/busybox" 
    6. 
  
  
  
  
  6. 36s       36s     1   {kubelet worker0}   spec.containers{liveness}   Normal      Created     Created container with docker id 86849c15382e; Security:[seccomp=unconfined] 
    7. 
  
  
  
  
  7. 36s       36s     1   {kubelet worker0}   spec.containers{liveness}   Normal      Started     Started container with docker id 86849c15382e 
    8. 
  
  
  
  
  8. 2s        2s      1   {kubelet worker0}   spec.containers{liveness}   Warning     Unhealthy   Liveness probe failed: cat: can't open '/tmp/healthy': No such file or directory 
    9.

再等30秒，确认容器已经重启：

 
 
 
 
    
  
  
  
  
  1. kubectl get pod liveness-exec 
    2.

从输出结果来RESTARTS值加1了

 
 
 
 
    
  
  
  
  
  1. NAME            READY     STATUS    RESTARTS   AGE 
    2. 
  
  
  
  
  2. liveness-exec   1/1       Running   1          1m 
    3.

定义一个liveness HTTP请求

我们还可以使用HTTP GET请求作为liveness probe。下面是一个基于gcr.io/google_containers/liveness镜像运行了一个容器的Pod的例子http-liveness.yaml：该配置文件只定义了一个容器，livenessProbe 指定kubelet需要每隔3秒执行一次liveness probe。initialDelaySeconds 指定kubelet在该执行第一次探测之前需要等待3秒钟。该探针将向容器中的server的8080端口发送一个HTTP GET请求。如果server的/healthz路径的handler返回一个成功的返回码，kubelet就会认定该容器是活着的并且很健康。如果返回失败的返回码，kubelet将杀掉该容器并重启它。任何大于200小于400的返回码都会认定是成功的返回码。其他返回码都会被认为是失败的返回码。最开始的10秒该容器是活着的， /healthz handler返回200的状态码。这之后将返回500的返回码。

 
 
 
 
    
  
  
  
  
  1. http.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) { 
    2. 
  
  
  
  
  2.     duration := time.Now().Sub(started) 
    3. 
  
  
  
  
  3.     if duration.Seconds() > 10 { 
    4. 
  
  
  
  
  4.         w.WriteHeader(500) 
    5. 
  
  
  
  
  5.         w.Write([]byte(fmt.Sprintf("error: %v", duration.Seconds()))) 
    6. 
  
  
  
  
  6.     } else { 
    7. 
  
  
  
  
  7.         w.WriteHeader(200) 
    8. 
  
  
  
  
  8.         w.Write([]byte("ok")) 
    9. 
  
  
  
  
  9.     } 
    10. 
  
  
  
  
  10. }) 
    11.

容器启动3秒后，kubelet开始执行健康检查。第一次健康监测会成功，但是10秒后，健康检查将失败，kubelet将杀掉和重启容器。创建一个Pod来测试一下HTTP liveness检测：

 
 
 
 
    
  
  
  
  
  1. kubectl create -f https://k8s.io/docs/tasks/configure-pod-container/http-liveness.yaml 
    2.

After 10 seconds, view Pod events to verify that liveness probes have failed and the Container has been restarted: 10秒后，查看Pod的event，确认liveness probe失败并重启了容器。

 
 
 
 
    
  
  
  
  
  1. kubectl describe pod liveness-http 
    2.

定义TCP liveness探针

第三种liveness probe使用TCP Socket。使用此配置，kubelet将尝试在指定端口上打开容器的套接字。如果可以建立连接，容器被认为是健康的，如果不能就认为是失败的。

 
 
 
 
    
  
  
  
  
  1. apiVersion: v1 
    2. 
  
  
  
  
  2. kind: Pod 
    3. 
  
  
  
  
  3. metadata: 
    4. 
  
  
  
  
  4.   name: goproxy 
    5. 
  
  
  
  
  5.   labels: 
    6. 
  
  
  
  
  6.     app: goproxy 
    7. 
  
  
  
  
  7. spec: 
    8. 
  
  
  
  
  8.   containers: 
    9. 
  
  
  
  
  9.   - name: goproxy 
    10. 
  
  
  
  
  10.     image: gcr.io/google_containers/goproxy:0.1 
    11. 
  
  
  
  
  11.     ports: 
    12. 
  
  
  
  
  12.     - containerPort: 8080 
    13. 
  
  
  
  
  13.     readinessProbe: 
    14. 
  
  
  
  
  14.       tcpSocket: 
    15. 
  
  
  
  
  15.         port: 8080 
    16. 
  
  
  
  
  16.       initialDelaySeconds: 5 
    17. 
  
  
  
  
  17.       periodSeconds: 10 
    18. 
  
  
  
  
  18.     livenessProbe: 
    19. 
  
  
  
  
  19.       tcpSocket: 
    20. 
  
  
  
  
  20.         port: 8080 
    21. 
  
  
  
  
  21.       initialDelaySeconds: 15 
    22. 
  
  
  
  
  22.       periodSeconds: 20 
    23.

TCP检查的配置与HTTP检查非常相似。此示例同时使用了readiness和liveness probe。容器启动后5秒钟，kubelet将发送第一个readiness probe。这将尝试连接到端口8080上的goproxy容器。如果探测成功，则该pod将被标记为就绪。Kubelet将每隔10秒钟执行一次该检查。除了readiness probe之外，该配置还包括liveness probe。容器启动15秒后，kubelet将运行第一个liveness probe。就像readiness probe一样，这将尝试连接到goproxy容器上的8080端口。如果liveness probe失败，容器将重新启动。使用命名的端口，可以使用命名的ContainerPort作为HTTP或TCP liveness检查：

 
 
 
 
    
  
  
  
  
  1. ports: 
    2. 
  
  
  
  
  2. - name: liveness-port 
    3. 
  
  
  
  
  3.   containerPort: 8080 
    4. 
  
  
  
  
  4.   hostPort: 8080 
    5. 
  
  
  
  
  5.  
    6. 
  
  
  
  
  6. livenessProbe: 
    7. 
  
  
  
  
  7.   httpGet: 
    8. 
  
  
  
  
  8.   path: /healthz 
    9. 
  
  
  
  
  9.   port: 8080 
    10.

定义readiness探针

有时，应用程序暂时无法对外部流量提供服务。例如，应用程序可能需要在启动期间加载大量数据或配置文件。在这种情况下，你不想杀死应用程序，但你也不想发送请求。Kubernetes提供了readiness probe来检测和减轻这些情况。Pod中的容器可以报告自己还没有准备，不能处理Kubernetes服务发送过来的流量。

Readiness probe的配置跟liveness probe很像。唯一的不同是使用 readinessProbe而不是livenessProbe。

 
 
 
 
    
  
  
  
  
  1. readinessProbe: 
    2. 
  
  
  
  
  2.   exec: 
    3. 
  
  
  
  
  3.     command: 
    4. 
  
  
  
  
  4.     - cat 
    5. 
  
  
  
  
  5.     - /tmp/healthy 
    6. 
  
  
  
  
  6.   initialDelaySeconds: 5 
    7. 
  
  
  
  
  7.   periodSeconds: 5 
    8.

Readinessprobe的HTTP和TCP的探测器配置跟liveness probe一样。Readiness和livenssprobe可以并行用于同一容器。使用两者可以确保流量无法到达未准备好的容器，并且容器在失败时重新启动。

定义startup探针

这是kubernetes1.16带来的新功能。Probes 允许 Kubernetes 监控应用程序的状态。可以使用livenessProbe定期检查应用程序是否还活着。一个示例容器定义了这个探测器：

 
 
 
 
    
  
  
  
  
  1. livenessProbe : httpGet:  
    2. 
  
  
  
  
  2.   path: /healthz  
    3. 
  
  
  
  
  3.   port: 8080 
    4. 
  
  
  
  
  4. failureThreshold: 3 
    5. 
  
  
  
  
  5. periodSeconds: 10 
    6.

如果在 30 秒内失败 3 次，容器将重新启动。但是由于这个容器很慢，需要30多秒才能启动，所以探针会失败，容器会再次重启。这个新特性让你可以定义一个startupProbe在 pod 完成启动之前阻止所有其他探测的方法：

 
 
 
 
    
  
  
  
  
  1. startupProbe:  
    2. 
  
  
  
  
  2.   httpGet:  
    3. 
  
  
  
  
  3.     path: /healthz  
    4. 
  
  
  
  
  4.     port: 8080 
    5. 
  
  
  
  
  5.   failureThreshold: 30 
    6. 
  
  
  
  
  6.   periodSeconds: 10 
    7.

现在我们的慢速容器最多有 5 分钟(30 个检查 * 10 秒 = 300 秒)来完成它的启动。

配置Probe

Probe 中有很多精确和详细的配置，通过它们你能准确的控制liveness和readiness检查：

  • initialDelaySeconds：容器启动后第一次执行探测是需要等待多少秒。
  • periodSeconds：执行探测的频率。默认是10秒，最小1秒。
  • timeoutSeconds：探测超时时间。默认1秒，最小1秒。
  • successThreshold：探测失败后，最少连续探测成功多少次才被认定为成功。默认是1。对于liveness必须是1。最小值是1。
  • failureThreshold：探测成功后，最少连续探测失败多少次才被认定为失败。默认是3。最小值是1。

HTTP probe 可以给 httpGet设置其他配置项：

  • host：连接的主机名，默认连接到pod的IP。你可能想在http header中设置"Host"而不是使用IP。
  • scheme：连接使用的schema，默认HTTP。
  • path: 访问的HTTP server的path。
  • httpHeaders：自定义请求的header。HTTP运行重复的header。
  • port：访问的容器的端口名字或者端口号。端口号必须介于1和65535之间。

对于HTTP探测器，kubelet向指定的路径和端口发送HTTP请求以执行检查。Kubelet将probe发送到容器的IP地址，除非地址被httpGet中的可选host字段覆盖。在大多数情况下，你不想设置主机字段。有一种情况下你可以设置它。假设容器在127.0.0.1上侦听，并且Pod的hostNetwork字段为true。然后，在httpGet下的host应该设置为127.0.0.1。如果你的pod依赖于虚拟主机，这可能是更常见的情况，你不应该用host，而是应该在httpHeaders中设置Host头。

我们应该怎么做?

  • 对于提供 HTTP 协议(REST 服务等)的微服务， 始终定义一个ReadinessProbe，用于检查的应用程序(Pod)是否已准备好接收流量。
  • 对于慢启动的应用，我们应该使用StartupProbe，来防止容器没有启动，就被LivenessProbe杀死了。
  • 如果服务是多端口的，请确保ReadinessProbe覆盖了所以的端口。例如：为readinessProbe使用“admin”或“management”端口(例如 9090)时，请确保端点仅在主要 HTTP 端口(例如 8080)准备好接受流量时才返回 success.
  • 使用httpGet对服务端口与路径(例如 /health)进行就绪探测。

我们不应该怎么做?

  • 不要依赖外部依赖项(如数据存储)进行就绪/探活检查，因为这可能会导致级联故障

1. 假如10 个pod的服务，数据库使用Postgres，缓存使用redis：当你的探针的路径依赖于工作的redis连接时，如果出现redis/网络故障，则所有 10 个 Pod 都将“重启”——这通常会产生影响比它应该的更糟。因为服务还能到Postgres拿去数据。

2. 服务最好不要与数据库做强依赖。

3. 只探测自己内部的端口，不要去探测外部pod的端口。探测器不应依赖于同一集群中其他 Pod 的状态，以防止级联故障。

  • 需要明确知道使用 Liveness Probe 的原因，否则不要为 Pod 使用 Liveness Probe。

Liveness Probe 可以帮助恢复“卡住”的容器，但是当我们能控制我们的应用程序，出现意料之外的“卡住”进程和死锁之类的故障，更好的选择是从应用内部故意崩溃以恢复到已知良好状态。

失败的 Liveness Probe 将导致容器重启，从而可能使与负载相关的错误的影响变得更糟：容器重启将导致停机(至少的应用程序的启动时间，例如 30s+)，从而导致更多错误并为其他容器提供更多流量负载，导致更多失败的容器，等等

Liveness Probes 与外部依赖相结合是导致级联故障的最坏情况：单个环境的小问题将重新启动所有容器。

  • 如果使用 LivenessProbe，请不要为LivenessProbe和ReadinessProbe设置相同的规范

可以使用具有相同运行状况检查但具有更高failureThreshold的 Liveness Probe (例如，在 3 次尝试后标记为未就绪，在 10 次尝试后将 Liveness Probe 标记为失败)

不要使用“exec”探测器，它们存在导致僵尸进程的。因为我们写的应用进程很大一部分不会解决依附在主进程上的进程的

总结

  • 为 Web 应用程序使用ReadinessProbe来决定 Pod 何时应接收流量
  • 不正确使用Readiness/LivenessProbes可能导致可用性降低和级联故障
  • 对于慢启动的应用，我们应该使用StartupProbe

参考：

https://jimmysong.io/kubernetes-handbook/guide/configure-liveness-readiness-probes.html

https://srcco.de/posts/kubernetes-liveness-probes-are-dangerous.html#id6

本文名称：怎么使用Pod的Liveness和Readiness与StartupProbe
浏览路径：http://www.shufengxianlan.com/qtweb/news20/471520.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

网站策划知识

分类信息网

泸州网站建设　　 　移动手机网站制作　　 　广汉做网站　　 　网站建设方案　　 　成都气球装饰　　 　app开发　　 　丹棱网站建设　　 　香港虚拟主机空间　　 　网络推广公司　　 　东电技改　　 　移动APP　　 　成都定制网站建设　　 　四川成都托管服务器　　 　服务器托管　　 　仿古建筑设计　　 　成都网站推广　　 　成都机房机柜租用　　 　成都网站改版　　 　广安搬家公司　　 　手提袋印刷制作