Kubernetes Probes Explained with Examples

Kubernetes, the open-source container orchestration platform, has become a cornerstone in the world of modern application deployment. To ensure the reliability and health of applications running within Kubernetes clusters, various mechanisms are employed. One crucial aspect of this is the use of probes, which allow Kubernetes to assess the health of an application and take appropriate actions based on its findings. In this article, we will delve into the world of Kubernetes probes, offering a comprehensive understanding along with practical examples.

Understanding Probes:
In Kubernetes, probes are mechanisms that determine the liveliness and readiness of a container. Liveness probes ascertain if the container is running, while readiness probes determine if the container can receive incoming requests. By utilizing these probes, Kubernetes can make intelligent decisions, such as restarting containers that are deemed unhealthy or redirecting traffic away from pods that are not ready to serve.

Types of Probes:
There are three types of probes in Kubernetes: liveness, readiness, and startup probes. Each serves a specific purpose in ensuring the proper functioning of applications within a cluster.

1. Liveness Probes:
   Liveness probes are designed to detect if the application inside the container is still running as expected. If the probe fails, Kubernetes can take corrective actions, such as restarting the container.

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

   In this example, a liveness probe is configured to send an HTTP GET request to the /healthz endpoint on port 8080 every 3 seconds.

2. Readiness Probes:
   Readiness probes determine if the container is ready to accept incoming requests. If a container is not ready, Kubernetes will stop directing traffic to it until it passes the readiness probe.

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

   This readiness probe checks the /ready endpoint on port 8080, with an initial delay of 5 seconds and subsequent checks every 5 seconds.

3. Startup Probes:
   Startup probes are used to delay the execution of the liveness and readiness probes until the startup probe succeeds. This is beneficial for applications that require some time to initialize.

   startupProbe:
     httpGet:
       path: /init
       port: 8080
     initialDelaySeconds: 10
     periodSeconds: 5
   

   In this example, the startup probe checks the /init endpoint on port 8080, with an initial delay of 10 seconds and subsequent checks every 5 seconds.

Step-by-Step Guide: Implementing Probes in Kubernetes:
Now, let's walk through the process of implementing probes in a Kubernetes deployment.

1. Create a Deployment:
   Start by creating a simple deployment YAML file. Include a container with your application and define the liveness and readiness probes.

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: my-app
   spec:
     replicas: 3
     selector:
       matchLabels:
         app: my-app
     template:
       metadata:
         labels:
           app: my-app
       spec:
         containers:
         - name: my-app-container
           image: my-app-image:latest
           ports:
           - containerPort: 8080
           livenessProbe:
             httpGet:
               path: /healthz
               port: 8080
             initialDelaySeconds: 3
             periodSeconds: 3
           readinessProbe:
             httpGet:
               path: /ready
               port: 8080
             initialDelaySeconds: 5
             periodSeconds: 5
   

2. Apply the Deployment:
   Use the following command to apply the deployment to your Kubernetes cluster.

   kubectl apply -f your-deployment-file.yaml
   

3. Monitor Probes:
   Monitor the probes using the following commands:

   • View liveness probe status:

     kubectl get pods
     kubectl describe pod <pod-name>
     

   • Check readiness probe status:

     kubectl get pods
     kubectl describe pod <pod-name>
     

Additional Examples:
Let's explore a few more examples to deepen our understanding of probes in Kubernetes.

1. TCP Liveness Probe:

   livenessProbe:
     tcpSocket:
       port: 8080
     initialDelaySeconds: 5
     periodSeconds: 10
   

   In this example, a liveness probe is configured to check the TCP socket on port 8080 every 10 seconds.

2. Command Readiness Probe:

   readinessProbe:
     exec:
       command:
         - cat
         - /app/ready
     initialDelaySeconds: 2
     periodSeconds: 5
   

   This readiness probe executes the command cat /app/ready and checks for success every 5 seconds.

So, Kubernetes probes play a pivotal role in maintaining the reliability and stability of applications within a cluster. By understanding the nuances of liveness, readiness, and startup probes, you can fine-tune the behavior of your applications and enhance the overall robustness of your Kubernetes deployments.