健康监测1

主要内容

1. LivenessProbes
2. ReadinessProbe

---

预备知识
健康检查是一种用于监测和确保应用程序或容器的正常运行的机制。在Kubernetes中，健康检查是通过对容器的状态和可用性进行定期检查来实现的。Kubernetes提供了两种类型的健康检查：存活探针（Liveness Probe）和就绪探针（Readiness Probe）。

• 存活探针（Liveness Probe）：用于确定容器是否仍然运行。如果存活探针失败，Kubernetes将重启容器。存活探针通常用于检查应用程序是否处于活动状态，例如，检查应用程序是否能够响应HTTP请求。

• 就绪探针（Readiness Probe）：用于确定容器是否已准备好接收流量。如果就绪探针失败，Kubernetes将停止将流量发送到该容器。就绪探针通常用于确保应用程序已完成初始化过程，并已准备好接收流量。

健康检查可以通过以下方式进行配置：

• HTTP探测：发送HTTP请求并检查响应的状态码。
• TCP探测：尝试建立TCP连接并检查连接是否成功。
• Exec探测：在容器内运行自定义命令，并检查命令的返回值。

在Kubernetes中，可以通过在Pod或容器的配置文件中定义存活探针和就绪探针来配置健康检查。这些探针将定期执行，并根据配置的条件判断容器的健康状态。如果探针失败，则Kubernetes将采取相应的操作，如重启容器或停止发送流量。通过配置适当的健康检查，可以提高应用程序的可靠性和稳定性。

一.Liveness Probes

Liveness Probes（存活探测器）用来检测什么时候要重启容器。例如，存活探测器可以捕捉到死
锁（应用程序在运行，但是无法继续执行后面的步骤）。在这种情况下重启容器有助于让应用程序在
有问题的情况下变得可用。
Readiness Probes（就绪探测器）可以知道容器什么时候准备好了并可以开始接受请求流量，只
有当一个 Pod 内的所有容器都准备好了，才能把这个 Pod 看作就绪。
Startup Probes（启动探测器）可以知道应用程序容器什么时候启动了。可以控制容器在启动成
功后再进行存活性和就绪检查，确保这些存活、就绪探测器不会影响应用程序的启动。这可以用于对
慢启动容器进行存活性检测，避免它们在启动运行之前就被杀掉。

Liveness Probe（存活探针）是Kubernetes中用于检测容器是否仍然运行的一种机制。它定期发送请求到容器，并根据请求的响应来判断容器的健康状态。如果存活探针失败，Kubernetes将重启容器。

存活探针可以使用以下三种方式之一进行配置：

1. HTTP探测：发送HTTP请求到容器的指定端点，并检查响应的状态码。如果状态码指示成功（例如200-399），则存活探针被认为是成功的。例如，可以配置存活探针发送GET请求到/health端点，并检查返回的状态码是否为200。

2. TCP探测：尝试建立TCP连接到容器的指定端口。如果连接成功建立，则存活探针被认为是成功的。这种方式适用于无需HTTP服务器的容器，例如数据库容器。

3. Exec探测：在容器内部执行自定义命令，并检查命令的返回值。如果命令的返回值为0，则存活探针被认为是成功的。这种方式适用于需要执行一些自定义逻辑来确定容器是否健康的情况。

存活探针的配置可以在Pod的配置文件中进行。以下是一个示例配置：

apiVersion: v1
kind: Pod
metadata:
  name: my-pod
spec:
  containers:
    - name: my-container
      image: my-image
      livenessProbe:
        httpGet:
          path: /health
          port: 8080
        initialDelaySeconds: 10
        periodSeconds: 5

在上述示例中，我们配置了一个HTTP探测，它将每隔5秒发送一个GET请求到容器的/health路径，并检查返回的状态码。如果连续三次探测失败，则Kubernetes将重启容器。

存活探针还可以配置一些其他参数，例如：

• initialDelaySeconds：容器启动后等待多少秒开始执行第一次探测。
• timeoutSeconds：每次探测的超时时间。
• periodSeconds：连续执行探测的间隔时间。
• failureThreshold：连续失败多少次后认为探测失败。

通过合理配置存活探针，可以确保容器在发生故障时能够自动重启，提高应用程序的可靠性和稳定性。

1. 文件存活检测
2. HTTP存活检测

1.文件存活检测，创建一个名为liveness的容器，并在其中执行文件的创建，之后休眠，接着再执行删除文件的操作，最后用livenessProbe来检测。

代码如下（示例）:

cat > liveness.yml <<EOF
apiVersion: v1
kind: Pod
metadata:
  labels:
    test: liveness
  name: liveness-exec
spec:
  containers:
  - name: liveness
    image: busybox
    imagePullPolicy: IfNotPresent
    args:
    - /bin/sh
    - -c
    - touch /tmp/healthy; sleep 30; rm -rf /tmp/healthy; sleep 600
    livenessProbe:
      exec:
        command:
        - cat
        - /tmp/healthy
      initialDelaySeconds: 5
      periodSeconds: 5
EOF

1. periodSeconds 字段指定了 kubelet 应该每 5 秒执行一次存活探测。
2. initialDelaySeconds 字段告诉 kubelet 在执行第一次探测前应该等待 5 秒。
3. kubelet 在容器内执行命令 cat /tmp/healthy 来进行探测。
4. 如果命令执行成功并且返回值为 0，kubelet 就会认为这个容器是健康存活的。
5. 如果这个命令返回非 0 值，kubelet 会杀死这个容器并重新启动它。

这个容器生命周期的前 30 秒， /tmp/healthy 文件是存在的。所以在这最开始的 30 秒内，执
行命令 cat /tmp/healthy 会返回成功代码。 30 秒之后，执行命令 cat /tmp/healthy 就
会返回失败代码。

kubectl create -f liveness.yml 
kubectl describe pod liveness-exec

kubectl get pods 
kubectl delete -f liveness.yml 

可以看到，每 30 秒在 pod 事件中就会显示存活探测器失败了，上面信息显示这个容器被杀死并
且被重建了 4 次。

2.解释

这是一个使用Kubernetes创建一个带有存活探针的Pod的示例配置文件。让我们逐句解释每个命令的作用：

1. cat > liveness.yml <<EOF：创建一个名为liveness.yml的文件，并将后续的输入重定向到该文件。

2. apiVersion: v1：指定使用的Kubernetes API版本。

3. kind: Pod：定义资源类型为Pod。

4. metadata:：定义Pod的元数据。

5. labels:：为Pod添加标签。

6. name: liveness-exec：指定Pod的名称。

7. spec:：定义Pod的规格。

8. containers:：定义Pod中的容器列表。

9. - name: liveness：定义容器的名称。

10. image: busybox：指定容器使用的镜像。

11. imagePullPolicy: IfNotPresent：定义镜像拉取策略为仅在本地不存在时才拉取。

12. args:：定义容器的启动参数。

13. - /bin/sh：指定容器使用的shell。

14. - -c：表示后续的参数将作为shell命令执行。

15. - touch /tmp/healthy; sleep 30; rm -rf /tmp/healthy; sleep 600：在容器启动时执行的命令。它创建一个名为/tmp/healthy的文件，然后等待30秒，然后删除该文件，并继续睡眠600秒。

16. livenessProbe:：定义存活探针。

17. exec:：指定使用执行命令的方式进行探测。

18. command:：指定执行的命令。

19. - cat：执行的命令为cat。

20. - /tmp/healthy：cat命令的参数为/tmp/healthy。

21. initialDelaySeconds: 5：在容器启动后等待5秒开始执行第一次探测。

22. periodSeconds: 5：每隔5秒执行一次探测。

23. EOF：表示输入结束，结束文件的输入。

24. kubectl create -f liveness.yml：使用kubectl命令创建Pod，将liveness.yml文件作为配置文件。

25. kubectl describe pod liveness-exec：使用kubectl命令获取liveness-exec Pod的详细信息。

26. kubectl get pods：使用kubectl命令列出所有的Pod。

27. kubectl delete -f liveness.yml：使用kubectl命令删除liveness.yml文件中定义的Pod。

通过这些命令，我们创建了一个名为liveness-exec的Pod，其中包含一个名为liveness的容器。该容器在启动时创建一个/tmp/healthy文件，并在30秒后删除该文件。存活探针会每5秒执行一次命令cat /tmp/healthy，如果该文件存在，则认为容器存活。最后，我们使用kubectl命令获取Pod的详细信息，并删除该Pod。

3.HTTP存活检测，以 httpget 的形式访问容器中的 /httppage 页面，根据返回代码来判断是否正常

代码如下（示例）:

cat > httpget.yml <<EOF
apiVersion: v1
kind: Pod
metadata:
  name: http
spec:
  containers:
  - name: httpd
    image: httpd
    imagePullPolicy: IfNotPresent
    livenessProbe:
      httpGet:
        path: /httppage
        port: 80
        httpHeaders:
        - name: Custom-Header
          value: Awesome
      initialDelaySeconds: 3
      periodSeconds: 3
  restartPolicy: OnFailure
EOF

1. kubelet 会向容器内运行的服务发送一个 HTTP GET 请求来执行探测。如果服务器上
   /httppage 路径下的处理程序返回成功代码，则 kubelet 认为容器是健康存活的。
2. 如果处理程序返回失败代码，则 kubelet 会杀死这个容器并且重新启动它。
3. 任何大于或等于 200 并且小于 400 的返回代码标示成功，其它返回代码都标示失败。

kubectl create -f httpget.yml 
kubectl get pods
kubectl describe pod http
kubectl delete -f httpget.yml 

4.解释

这是一个使用Kubernetes创建一个带有HTTP存活探针的Pod的示例配置文件。让我们逐句解释每个命令的作用：

1. cat > httpget.yml <<EOF：创建一个名为httpget.yml的文件，并将后续的输入重定向到该文件。

2. apiVersion: v1：指定使用的Kubernetes API版本。

3. kind: Pod：定义资源类型为Pod。

4. metadata:：定义Pod的元数据。

5. name: http：指定Pod的名称。

6. spec:：定义Pod的规格。

7. containers:：定义Pod中的容器列表。

8. - name: httpd：定义容器的名称。

9. image: httpd：指定容器使用的镜像。

10. imagePullPolicy: IfNotPresent：定义镜像拉取策略为仅在本地不存在时才拉取。

11. livenessProbe:：定义存活探针。

12. httpGet:：指定使用HTTP请求的方式进行探测。

13. path: /httppage：指定探测请求的路径为/httppage。

14. port: 80：指定探测请求的端口为80。

15. httpHeaders:：定义HTTP请求头。

16. - name: Custom-Header：指定自定义请求头的名称为Custom-Header。

17. value: Awesome：指定自定义请求头的值为Awesome。

18. initialDelaySeconds: 3：在容器启动后等待3秒开始执行第一次探测。

19. periodSeconds: 3：每隔3秒执行一次探测。

20. restartPolicy: OnFailure：定义Pod的重启策略为仅在容器失败时重启。

21. EOF：表示输入结束，结束文件的输入。

22. kubectl create -f httpget.yml：使用kubectl命令创建Pod，将httpget.yml文件作为配置文件。

23. kubectl get pods：使用kubectl命令列出所有的Pod。

24. kubectl describe pod http：使用kubectl命令获取http Pod的详细信息。

25. kubectl delete -f httpget.yml：使用kubectl命令删除httpget.yml文件中定义的Pod。

通过这些命令，我们创建了一个名为http的Pod，其中包含一个名为httpd的容器。存活探针会每3秒发送一个HTTP请求到路径/httppage，并携带一个自定义请求头Custom-Header: Awesome。如果请求成功，则认为容器存活。最后，我们使用kubectl命令列出Pod，获取Pod的详细信息，并删除该Pod。

---

二.ReadinessProbe

Readiness Probe（就绪探针）是Kubernetes中用于确定容器是否已准备好接收流量的一种机制。它定期发送请求到容器，并根据请求的响应来判断容器的健康状态。如果就绪探针失败，Kubernetes将停止将流量发送到该容器。

就绪探针可以使用以下三种方式之一进行配置：

1. HTTP探测：发送HTTP请求到容器的指定端点，并检查响应的状态码。如果状态码指示成功（例如200-399），则就绪探针被认为是成功的。例如，可以配置就绪探针发送GET请求到/health端点，并检查返回的状态码是否为200。

2. TCP探测：尝试建立TCP连接到容器的指定端口。如果连接成功建立，则就绪探针被认为是成功的。这种方式适用于无需HTTP服务器的容器，例如数据库容器。

3. Exec探测：在容器内部执行自定义命令，并检查命令的返回值。如果命令的返回值为0，则就绪探针被认为是成功的。这种方式适用于需要执行一些自定义逻辑来确定容器是否健康的情况。

就绪探针的配置可以在Pod的配置文件中进行。以下是一个示例配置：

apiVersion: v1
kind: Pod
metadata:
  name: my-pod
spec:
  containers:
    - name: my-container
      image: my-image
      readinessProbe:
        httpGet:
          path: /health
          port: 8080
        initialDelaySeconds: 10
        periodSeconds: 5

在上述示例中，我们配置了一个HTTP探测，它将每隔5秒发送一个GET请求到容器的/health路径，并检查返回的状态码。如果连续三次探测成功，则Kubernetes将认为容器已准备好接收流量。

就绪探针还可以配置一些其他参数，例如：

• initialDelaySeconds：容器启动后等待多少秒开始执行第一次探测。
• timeoutSeconds：每次探测的超时时间。
• periodSeconds：连续执行探测的间隔时间。
• failureThreshold：连续失败多少次后认为探测失败。

通过合理配置就绪探针，可以确保只有在容器已准备好接收流量时才将流量发送到该容器，提高应用程序的可靠性和稳定性。

1.TCP存活检测

kubelet 会在容器启动 5 秒后发送第一个就绪探测，这会尝试连接容器的 80 端口。如果探测成
功，这个 Pod 会被标记为就绪状态，kubelet 将继续每隔 10 秒运行一次检测。
除了就绪探测，这个配置包括了一个存活探测。kubelet 会在容器启动 15 秒后进行第一次存活
探测。与就绪探测类似，会尝试连接器的 80 端口。如果存活探测失败，这个容器会被重新启动。

代码如下（示例）:

cat > readiness.yml <<EOF
apiVersion: v1
kind: Pod
metadata:
  name: tcpcheck
spec:
  containers:
  - name: httpd
    image: httpd
    imagePullPolicy: IfNotPresent
    ports:
      - name: webport
        protocol: TCP
        containerPort: 80
    readinessProbe:
      tcpSocket:
        port: 800
      initialDelaySeconds: 5
      periodSeconds: 10
    livenessProbe:
      tcpSocket:
        port: 800
      initialDelaySeconds: 15
      periodSeconds: 20
  restartPolicy: OnFailure
EOF

kubectl create -f readiness.yml 
kubectl get pods
kubectl describe pod tcpcheck
kubectl delete -f readiness.yml

可以看到，pod 对外提供了 80 端口，但是我们一直在检测 800 端口，所以这个 pod 检测是失败
的。

2.解释

这是一个使用Kubernetes创建一个具有TCP检查的Pod的示例配置文件。让我们逐句解释每个命令的作用：

1. cat > readiness.yml <<EOF：创建一个名为readiness.yml的文件，并将后续的输入重定向到该文件。

2. apiVersion: v1：指定使用的Kubernetes API版本。

3. kind: Pod：定义资源类型为Pod。

4. metadata:：定义Pod的元数据。

5. name: tcpcheck：指定Pod的名称。

6. spec:：定义Pod的规格。

7. containers:：定义Pod中的容器列表。

8. - name: httpd：定义容器的名称。

9. image: httpd：指定容器使用的镜像。

10. imagePullPolicy: IfNotPresent：定义镜像拉取策略为仅在本地不存在时才拉取。

11. ports:：定义容器的端口列表。

12. - name: webport：指定端口的名称为webport。

13. protocol: TCP：指定端口的协议为TCP。

14. containerPort: 80：指定容器监听的端口为80。

15. readinessProbe:：定义就绪探针。

16. tcpSocket:：指定使用TCP套接字进行检查。

17. port: 800：指定检查的端口为800。

18. initialDelaySeconds: 5：在容器启动后等待5秒开始执行第一次检查。

19. periodSeconds: 10：每隔10秒执行一次检查。

20. livenessProbe:：定义存活探针。

21. tcpSocket:：指定使用TCP套接字进行检查。

22. port: 800：指定检查的端口为800。

23. initialDelaySeconds: 15：在容器启动后等待15秒开始执行第一次检查。

24. periodSeconds: 20：每隔20秒执行一次检查。

25. restartPolicy: OnFailure：定义Pod的重启策略为仅在容器失败时重启。

26. EOF：表示输入结束，结束文件的输入。

27. kubectl create -f readiness.yml：使用kubectl命令创建Pod，将readiness.yml文件作为配置文件。

28. kubectl get pods：使用kubectl命令列出所有的Pod。

29. kubectl describe pod tcpcheck：使用kubectl命令获取tcpcheck Pod的详细信息。

30. kubectl delete -f readiness.yml：使用kubectl命令删除readiness.yml文件中定义的Pod。

通过这些命令，我们创建了一个名为tcpcheck的Pod，其中包含一个名为httpd的容器。就绪探针会每10秒执行一次TCP套接字检查，检查容器的端口800是否可用。存活探针也会每20秒执行一次TCP套接字检查。最后，我们使用kubectl命令列出Pod，获取Pod的详细信息，并删除该Pod。

---

总结

以上是今天是今天要讲的内容，学到了LivenessProbes，ReadinessProbe。