Day 18 of Kubernetes : Health Probes Explained

Kubernetes has become the go-to platform for orchestrating containerized applications, providing powerful tools to manage, scale, and maintain applications. Among these tools, health probes are essential for ensuring that applications run smoothly. In this blog, we'll delve into what health probes are, their types, and how to configure them in Kubernetes.

What is a Probe?

In Kubernetes, a probe is a diagnostic tool used to assess the state of a container. It helps determine whether an application is healthy and operating as expected. Probes are configured within the pod specification and are used by the kubelet to make decisions about the container's lifecycle.

Health Probes in Kubernetes

Health probes in Kubernetes are critical for maintaining application reliability and availability. They enable Kubernetes to perform health checks on containers, ensuring that they are functioning correctly. If a container fails a health check, Kubernetes can take appropriate actions, such as restarting the container or marking it as unavailable for serving traffic.

Types of Health Probes

Kubernetes supports three main types of health probes:

1. Liveness Probe: Checks if the container is still running. If the liveness probe fails, Kubernetes kills the container and attempts to restart it.

2. Readiness Probe: Determines if the container is ready to accept traffic. If the readiness probe fails, the container is removed from the service endpoints, meaning it won't receive any traffic until it passes the check.

3. Startup Probe: Used to check if an application has started successfully. This is particularly useful for applications that have a long startup time. If the startup probe fails, Kubernetes kills the container and restarts it.

Health Check Methods

Kubernetes supports three methods to perform health checks:

1. HTTP/HTTPS: Sends an HTTP/HTTPS GET request to the container and checks for a successful response code.

2. TCP: Establishes a TCP connection to the specified port. The container is considered healthy if the connection can be established.

3. Command: Executes a command inside the container. The container is considered healthy if the command returns a zero exit status.

Configure Liveness, Readiness, and Startup Probes Examples

Let's look at examples of how to configure these probes in a Kubernetes pod specification.

Liveness Probe Example

apiVersion: v1
kind: Pod
metadata:
  name: liveness-example
spec:
  containers:
  - name: myapp
    image: myapp:latest
    livenessProbe:
      httpGet:
        path: /healthz
        port: 8080
      initialDelaySeconds: 3
      periodSeconds: 3

In this example, Kubernetes sends an HTTP GET request to /healthz on port 8080 every 3 seconds, starting 3 seconds after the container starts. If the probe fails, the container is restarted.

Readiness Probe Example

apiVersion: v1
kind: Pod
metadata:
  name: readiness-example
spec:
  containers:
  - name: myapp
    image: myapp:latest
    readinessProbe:
      httpGet:
        path: /ready
        port: 8080
      initialDelaySeconds: 5
      periodSeconds: 5

Here, Kubernetes checks the /ready endpoint on port 8080 every 5 seconds, starting 5 seconds after the container starts. If the probe fails, the container is marked as unavailable for serving traffic.

Startup Probe Example

apiVersion: v1
kind: Pod
metadata:
  name: startup-example
spec:
  containers:
  - name: myapp
    image: myapp:latest
    startupProbe:
      httpGet:
        path: /startup
        port: 8080
      initialDelaySeconds: 10
      periodSeconds: 5
      failureThreshold: 30

In this configuration, Kubernetes checks the /startup endpoint on port 8080 every 5 seconds, starting 10 seconds after the container starts. If the probe fails 30 times consecutively, the container is restarted.

Conclusion

Health probes are a fundamental feature in Kubernetes, enabling automatic monitoring and management of containerized applications. By configuring liveness, readiness, and startup probes, you can ensure that your applications remain healthy, responsive, and available. With hands-on practice, you can become proficient in using health probes to maintain the reliability and robustness of your Kubernetes deployments.

Reference

Video