Why probes keep applications healthy in Kubernetes - Why It Works

Introduction

Applications can stop working properly without showing obvious errors. Probes help Kubernetes check if an app is running and ready to serve users. They keep apps healthy by restarting or stopping traffic to broken parts automatically.

When you want Kubernetes to restart an app that is stuck or crashed without manual help

When you want to stop sending user requests to an app that is not ready yet

When you want to detect if an app is alive and fix it quickly if it is not

When you want to improve your app's reliability by automatic health checks

When you want to avoid downtime caused by apps that appear running but are not working

Config File - pod.yaml

pod.yaml

apiVersion: v1
kind: Pod
metadata:
  name: my-app
spec:
  containers:
  - name: my-app-container
    image: nginx:1.23
    livenessProbe:
      httpGet:
        path: /healthz
        port: 80
      initialDelaySeconds: 5
      periodSeconds: 10
    readinessProbe:
      httpGet:
        path: /ready
        port: 80
      initialDelaySeconds: 3
      periodSeconds: 5

This pod runs an nginx container with two probes:

• livenessProbe: Checks if the app is alive by requesting /healthz on port 80. If it fails, Kubernetes restarts the container.
• readinessProbe: Checks if the app is ready to serve traffic by requesting /ready on port 80. If it fails, Kubernetes stops sending traffic to this pod.
• initialDelaySeconds: Wait time before starting probes to allow app startup.
• periodSeconds: How often to run the probe checks.

Commands

This command creates the pod with the configured liveness and readiness probes so Kubernetes can start monitoring the app's health.

Terminal

kubectl apply -f pod.yaml

Expected Output

pod/my-app created

This command shows the status of the pod to verify it is running and ready after applying the probes.

Terminal

kubectl get pods

Expected Output

NAME      READY   STATUS    RESTARTS   AGE

my-app    1/1     Running   0          10s

This command shows detailed information about the pod including probe results and any restarts triggered by failed liveness probes.

Terminal

kubectl describe pod my-app

Expected Output

Name:         my-app

Namespace:    default

Containers:

  my-app-container:

    Container ID:   docker://abcdef123456

    Image:          nginx:1.23

    State:          Running

    Ready:          True

    Restart Count:  0

    Liveness:       http-get http://:80/healthz delay=5s timeout=1s period=10s #success=1 #failure=3

    Readiness:      http-get http://:80/ready delay=3s timeout=1s period=5s #success=1 #failure=3

Key Concept

If you remember nothing else from this pattern, remember: probes let Kubernetes check app health and fix problems automatically by restarting or stopping traffic.

Common Mistakes

Not setting initialDelaySeconds causing probes to run before app is ready

Probes may fail immediately and cause unnecessary restarts or mark the app as not ready

Set initialDelaySeconds to allow the app enough time to start before probes begin

Using the same probe for both liveness and readiness

Liveness and readiness have different purposes; using one probe for both can cause wrong behavior like restarting healthy apps or sending traffic to unready apps

Configure separate liveness and readiness probes tailored to their specific checks

Not defining readiness probe causing traffic to be sent to unready pods

Without readiness probe, Kubernetes assumes the pod is always ready and may send requests to an app that is still starting or unhealthy

Always define a readiness probe to control when the pod receives traffic

Summary

Define liveness and readiness probes in your pod spec to let Kubernetes monitor app health.

Use liveness probes to restart stuck or crashed containers automatically.

Use readiness probes to control when your app receives user traffic.

Apply the pod manifest and verify pod status and probe results with kubectl commands.

Practice

1. What is the main purpose of a liveness probe in Kubernetes?

easy

A. To check if the application is running and restart it if it is not healthy

B. To control when the application receives user traffic

C. To update the application configuration automatically

D. To monitor the CPU usage of the application

Solution

1. Step 1: Understand liveness probe role

   Liveness probes check if the app is alive and working properly.

2. Step 2: Identify action on failure

   If the liveness probe fails, Kubernetes restarts the app to fix it.

3. Final Answer:

   To check if the application is running and restart it if it is not healthy -> Option A

4. Quick Check:

   Liveness probe = restarts unhealthy app [OK]

Hint: Liveness probe restarts app if unhealthy [OK]

Common Mistakes:

• Confusing liveness with readiness probe
• Thinking liveness controls traffic
• Assuming liveness updates configs

2. Which of the following is the correct syntax to define a readiness probe in a Kubernetes pod spec?

easy

A. readinessProbe:
httpGet:
path: /ready
port: 8080
initialDelaySeconds: 5
periodSeconds: 10

B. livenessProbe:
exec:
command: ["curl", "/health"]
timeoutSeconds: 3

C. readinessProbe:
tcpSocket:
port: 80
failureThreshold: 5

D. startupProbe:
httpGet:
path: /start
port: 9090
periodSeconds: 15

Solution

1. Step 1: Identify readiness probe syntax

   Readiness probes often use httpGet with path and port defined.

2. Step 2: Match correct YAML structure

   readinessProbe: httpGet: path: /ready port: 8080 initialDelaySeconds: 5 periodSeconds: 10 shows readinessProbe with httpGet, initialDelaySeconds, and periodSeconds correctly.

3. Final Answer:

   readinessProbe: httpGet: path: /ready port: 8080 initialDelaySeconds: 5 periodSeconds: 10 -> Option A

4. Quick Check:

   Readiness probe syntax = readinessProbe: httpGet: path: /ready port: 8080 initialDelaySeconds: 5 periodSeconds: 10 [OK]

Hint: Readiness probe uses httpGet with path and port [OK]

Common Mistakes:

• Mixing liveness and readiness probe syntax
• Using startupProbe instead of readinessProbe
• Incorrect indentation or missing fields

3. Given this pod spec snippet, what happens if the readiness probe fails?

readinessProbe:
  httpGet:
    path: /healthz
    port: 8080
  initialDelaySeconds: 5
  periodSeconds: 10

medium

A. The pod is restarted immediately

B. The pod stops receiving new traffic but keeps running

C. The pod is deleted from the cluster

D. Nothing happens; the pod continues as normal

Solution

1. Step 1: Understand readiness probe effect

   Readiness probe controls if pod is ready to get user traffic.

2. Step 2: Identify behavior on failure

   If readiness probe fails, pod stays running but is removed from service endpoints, so no new traffic.

3. Final Answer:

   The pod stops receiving new traffic but keeps running -> Option B

4. Quick Check:

   Readiness failure = no traffic, pod runs [OK]

Hint: Readiness failure stops traffic, no restart [OK]

Common Mistakes:

• Thinking readiness failure restarts pod
• Confusing readiness with liveness probe
• Assuming pod deletion on readiness failure

4. You notice your application pod keeps restarting frequently. The liveness probe is defined as:

livenessProbe:
  httpGet:
    path: /health
    port: 8080
  initialDelaySeconds: 5
  periodSeconds: 10
  failureThreshold: 3

What is the most likely cause?

medium

A. The readiness probe is missing

B. The liveness probe is incorrectly configured with wrong port

C. The pod has insufficient CPU resources

D. The application is not responding to the /health endpoint in time

Solution

1. Step 1: Analyze liveness probe behavior

   Liveness probe checks /health on port 8080 every 10 seconds after 5 seconds delay.

2. Step 2: Understand restart cause

   If app does not respond correctly 3 times (failureThreshold), Kubernetes restarts pod.

3. Final Answer:

   The application is not responding to the /health endpoint in time -> Option D

4. Quick Check:

   Liveness failure = app not responding, causes restart [OK]

Hint: Liveness failure causes restart due to no response [OK]

Common Mistakes:

• Assuming readiness probe causes restart
• Ignoring failureThreshold effect
• Blaming resource limits without evidence

5. You want to ensure your app only receives traffic after it finishes loading data and is ready. Which probe setup achieves this best?

hard

A. Use a startup probe that immediately sends traffic to the app

B. Use a liveness probe that restarts the app if /health fails

C. Use a readiness probe that checks a /ready endpoint returning success after data load

D. Use both liveness and readiness probes checking the same /health endpoint

Solution

1. Step 1: Identify probe controlling traffic

   Readiness probe controls when app receives user traffic.

2. Step 2: Choose probe matching app readiness

   Readiness probe checking /ready after data load ensures traffic only after app is ready.

3. Step 3: Exclude other options

   Liveness restarts app but does not control traffic; startup probe delays startup but not traffic control.

4. Final Answer:

   Use a readiness probe that checks a /ready endpoint returning success after data load -> Option C

5. Quick Check:

   Readiness probe controls traffic flow [OK]

Hint: Readiness probe controls traffic after app is ready [OK]

Common Mistakes:

• Using liveness probe to control traffic
• Confusing startup probe with readiness probe
• Checking same endpoint for both probes