How to Use Kubernetes Probes - Liveness, Readiness and Startup

In the dynamic world of containerized applications, ensuring the reliability and availability of your services is crucial. Kubernetes, the popular container orchestration platform, provides a powerful feature known as probes to help monitor and manage the health of your applications. In this article, we will explore three types of probes - Liveness, Readiness and Startup - and understand how to leverage them effectively to enhance the robustness of your Kubernetes deployments.

Understanding Kubernetes Probes:

Probes are mechanisms that allow Kubernetes to periodically check the health and responsiveness of a container. They help Kubernetes make informed decisions about when to restart or redirect traffic to a particular container. Let's delve into the three main types of probes:

1. Liveness Probe:

The Liveness Probe determines whether a container is alive or not. If the probe fails, Kubernetes will restart the container. This is particularly useful for scenarios where a container might become unresponsive due to an application deadlock or other critical issues.

To implement a Liveness Probe, add the following lines to your Pod's YAML definition:

livenessProbe:
  httpGet:
    path: /healthz
    port: 8080
  initialDelaySeconds: 3
  periodSeconds: 3

In this example, the Liveness Probe performs an HTTP GET request on the '/healthz' endpoint every 3 seconds, starting after an initial delay of 3 seconds.

2. Readiness Probe:

The Readiness Probe checks if a container is ready to accept traffic. Unlike the Liveness Probe, a failing Readiness Probe does not trigger a container restart. Instead, it informs the Kubernetes service that the container is not ready to serve traffic.

To implement a Readiness Probe, add the following lines to your Pod's YAML definition:

readinessProbe:
  httpGet:
    path: /readiness
    port: 8080
  initialDelaySeconds: 5
  periodSeconds: 5

In this example, the Readiness Probe checks the '/readiness' endpoint every 5 seconds, starting after an initial delay of 5 seconds.

3. Startup Probe:

The Startup Probe is used to determine when a container is ready to start accepting traffic. It is particularly helpful in scenarios where the application requires some time to initialize.

To implement a Startup Probe, add the following lines to your Pod's YAML definition:

startupProbe:
  httpGet:
    path: /startup
    port: 8080
  initialDelaySeconds: 10
  periodSeconds: 10

In this example, the Startup Probe checks the '/startup' endpoint every 10 seconds, starting after an initial delay of 10 seconds.

Step-by-Step Instructions:

Now, let's walk through a step-by-step guide on how to implement and use these probes in your Kubernetes deployment:

1. Open your Kubernetes Pod YAML definition file.

2. Locate the container section within the Pod definition.

3. Add the appropriate probe sections (livenessProbe, readinessProbe, startupProbe) with the desired configuration for your application.

4. Apply the updated YAML file to your Kubernetes cluster using the kubectl apply -f <filename>.yaml command.

5. Monitor the status of the probes using kubectl describe pod <pod-name>.

More Examples:

Example 1: Using an Exec Probe:

You can use an exec probe to run a custom command within your container. For instance:

livenessProbe:
  exec:
    command:
    - cat
    - /tmp/healthy
  initialDelaySeconds: 2
  periodSeconds: 2

In this example, the Liveness Probe checks if the '/tmp/healthy' file exists every 2 seconds.

Example 2: TCP Socket Probe:

readinessProbe:
  tcpSocket:
    port: 8080
  initialDelaySeconds: 3
  periodSeconds: 3

In this case, the Readiness Probe checks if it can establish a TCP connection to port 8080 every 3 seconds.