Kubernetes Readiness Probes: Examples and Use Cases

Kubernetes Probes: Liveness, Readiness, and Startup

Kubernetes, a powerful container orchestration platform, offers a variety of features to ensure the smooth running of applications. One such feature is the use of probes, which are diagnostic tools used by Kubernetes to monitor the health of Pods. Among these, readiness probes play a crucial role in managing traffic flow to the Pods.

What are Readiness Probes?

Readiness probes are used by Kubernetes to determine when a container is ready to start accepting traffic. A Pod is considered ready when all of its containers are ready. If a Pod is not ready, it is removed from Service load balancers. Unlike Startup Probes, Readiness Probes check if the pod is available during the complete lifecycle. In contrast to Liveness Probes, only the traffic to the pod is stopped if the Readiness probe fails, but there will be no restart.

Configuring Readiness Probes

Readiness probes can be configured in the yaml configuration file under spec.containers.readinessprobe. To perform a probe, the kubelet sends an HTTP GET request to the server that is running in the container and listening on port 8080. If the handler for the server’s /healthz path returns a success code, the kubelet considers the container to be alive and healthy.

Use Cases for Readiness Probes

Readiness probes are most useful when an application is temporarily malfunctioning and unable to serve traffic. If the application is running but not fully available, Kubernetes may not be able to scale it up and new deployments could fail. A readiness probe allows Kubernetes to wait until the service is active before sending it traffic.

Here are some specific scenarios where readiness probes can be beneficial:

1. Initial Startup: When setting up a complex application, it might need some time at the start to warm up. The readiness probe ensures Kubernetes doesn’t send traffic its way until it’s fully awake.
2. Handling Temporary Glitches: If your application loses connection to another service (e.g., database), a readiness probe can help manage traffic during these periods.
3. Database Initialization/Migration: Make sure that your Readiness Probe includes database initialization/migration. The simplest way to achieve this is to start the HTTP server listening only after the initialization finished (e.g. Flyway DB migration etc), i.e. instead of changing the health check status, just don’t start the web server until the DB migration is complete.
4. Separate Management Health and Metrics from Normal Traffic: Do use a different “admin” or “management” port if your tech stack (e.g. Java/Spring) allows this to separate management health and metrics from normal traffic.

Remember, when you use a readiness probe, Kubernetes will only send traffic to the pod if the probe succeeds. There is no need to use a readiness probe on deletion of a pod. When a pod is deleted, it automatically puts itself into an unready state, regardless of whether readiness probes are used. It remains in this status until all containers in the pod have stopped.

Conclusion

Readiness probes are a powerful tool for maintaining the health of your Kubernetes applications. However, they must be used carefully to avoid unintended consequences. By understanding and correctly implementing these probes, you can ensure that your applications are robust and reliable.

Examples of Readiness Probes

In the world of Kubernetes, readiness probes act as crucial health checks for your Pods. Here are some examples of how to define readiness probes in Kubernetes:

1. HTTP Get Readiness Probe

Consider this example where the readiness probe is defined in a Deployment. The probe uses an HTTP GET request to the /ready endpoint on port 80. If the endpoint returns a success code, the container is considered ready.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-deployment
spec:
  template:
    metadata:
      labels:
        app: my-test-app
    spec:
      containers:
      - name: my-test-app
        image: nginx:1.14.2
        readinessProbe:
          httpGet:
            path: /ready
            port: 80
          successThreshold: 3
        

2. Exec Readiness Probe

In this example, the readiness probe is a shell script that uses the cat command to read the nginx.conf file. If the cat command returns a zero exit status, the container is considered ready.

readinessProbe:
  initialDelaySeconds: 1
  periodSeconds: 5
  timeoutSeconds: 1
  successThreshold: 1
  failureThreshold: 1
  exec:
    command:
    - cat
    - /etc/nginx/nginx.conf
        

3. TCP Socket Readiness Probe

In this example, the readiness probe checks if the TCP port 80 is open on localhost. If the port is open, the container is considered ready.

readinessProbe:
  initialDelaySeconds: 1
  periodSeconds: 5
  timeoutSeconds: 1
  successThreshold: 1
  failureThreshold: 1
  tcpSocket:
    host: localhost
    port: 80
        

Understanding and correctly implementing these probes can ensure that your applications are robust and reliable. Stay tuned for more insights on Kubernetes!

#Kubernetes #DevOps #CloudComputing