HTTP probe configuration in Kubernetes - Commands & Configuration

Introduction

Sometimes your app might stop responding or crash. Kubernetes can check your app's health by sending simple web requests called HTTP probes. This helps Kubernetes restart or stop your app if it is not working properly.

When you want Kubernetes to check if your web app is running and responding.

When you want to restart your app automatically if it stops responding.

When you want to make sure traffic only goes to healthy app instances.

When you want to detect if your app is ready to accept traffic after starting.

When you want to avoid sending users to broken or crashed app copies.

Config File - pod.yaml

pod.yaml

apiVersion: v1
kind: Pod
metadata:
  name: example-pod
spec:
  containers:
  - name: example-container
    image: nginx:1.23
    ports:
    - containerPort: 80
    readinessProbe:
      httpGet:
        path: /healthz
        port: 80
      initialDelaySeconds: 5
      periodSeconds: 10
    livenessProbe:
      httpGet:
        path: /healthz
        port: 80
      initialDelaySeconds: 15
      periodSeconds: 20

This file creates a pod running an Nginx web server.

readinessProbe checks if the app is ready to receive traffic by sending an HTTP GET request to /healthz on port 80, starting 5 seconds after the container starts, and repeats every 10 seconds.

livenessProbe checks if the app is alive by sending the same HTTP GET request, starting 15 seconds after the container starts, repeating every 20 seconds. If this fails, Kubernetes restarts the container.

Commands

This command creates the pod with the HTTP probes configured. Kubernetes starts the pod and begins checking its health.

Terminal

kubectl apply -f pod.yaml

Expected Output

pod/example-pod created

This command lists all pods and shows their status to verify if the pod is running and ready.

Terminal

kubectl get pods

Expected Output

NAME          READY   STATUS    RESTARTS   AGE

example-pod   1/1     Running   0          10s

This command shows detailed information about the pod, including the status of readiness and liveness probes.

Terminal

kubectl describe pod example-pod

Expected Output

Name:         example-pod

Namespace:    default

Containers:

  example-container:

    Container ID:   docker://abcdef123456

    Image:          nginx:1.23

    State:          Running

    Ready:          True

    Restart Count:  0

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

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

Conditions:

  Type              Status

  Initialized       True 

  Ready             True 

  ContainersReady   True 

  PodScheduled      True 

Key Concept

If you remember nothing else from this pattern, remember: HTTP probes let Kubernetes check your app’s health by sending simple web requests and act if the app is not responding.

Common Mistakes

Not setting initialDelaySeconds causing probes to run before the app is ready.

Probes may fail immediately, causing Kubernetes to restart the app unnecessarily.

Set initialDelaySeconds to a few seconds to give the app time to start before probing.

Using wrong path or port in the httpGet probe.

Kubernetes will get errors because it cannot reach the correct endpoint, marking the app unhealthy.

Use the exact path and port your app exposes for health checks.

Not distinguishing readinessProbe and livenessProbe roles.

Readiness controls traffic routing; liveness controls restarts. Mixing them can cause traffic to go to unhealthy pods or unnecessary restarts.

Use readinessProbe to check if app is ready for traffic, livenessProbe to check if app is alive.

Summary

Create a pod manifest with readinessProbe and livenessProbe using httpGet to check app health.

Apply the pod manifest with kubectl apply -f pod.yaml to start the pod and probes.

Use kubectl get pods and kubectl describe pod to verify pod status and probe results.

Practice

1. What is the main purpose of an HTTP probe in Kubernetes?

easy

A. To deploy new versions of the application automatically

B. To store application logs for debugging

C. To check if the application is running and responding to HTTP requests

D. To manage network traffic between pods

Solution

1. Step 1: Understand the role of HTTP probes

   HTTP probes send HTTP requests to the app to check if it is alive and ready.

2. Step 2: Identify the correct purpose

   Only To check if the application is running and responding to HTTP requests describes checking app health via HTTP requests.

3. Final Answer:

   To check if the application is running and responding to HTTP requests -> Option C

4. Quick Check:

   HTTP probe purpose = health check [OK]

Hint: HTTP probes test app health by sending HTTP requests [OK]

Common Mistakes:

• Confusing probes with deployment or logging
• Thinking probes manage network traffic
• Assuming probes store logs

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

easy

A. livenessProbe:
exec:
command: ["curl", "/healthz"]
initialDelaySeconds: 5
periodSeconds: 10

B. livenessProbe:
httpGet:
path: /healthz
port: 8080
initialDelaySeconds: 5
periodSeconds: 10

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

D. livenessProbe:
httpGet:
url: http://localhost:8080/healthz
initialDelaySeconds: 5
periodSeconds: 10

Solution

1. Step 1: Review HTTP probe syntax

   The correct HTTP probe uses httpGet with path and port keys.

2. Step 2: Identify the correct YAML structure

   livenessProbe: httpGet: path: /healthz port: 8080 initialDelaySeconds: 5 periodSeconds: 10 correctly uses httpGet with path and port. livenessProbe: httpGet: url: http://localhost:8080/healthz initialDelaySeconds: 5 periodSeconds: 10 is invalid because url is not a valid key.

3. Final Answer:

   Correct HTTP liveness probe syntax with httpGet, path, and port -> Option B

4. Quick Check:

   httpGet uses path and port keys [OK]

Hint: Use httpGet with path and port, not url [OK]

Common Mistakes:

• Using 'url' instead of 'path' in httpGet
• Confusing exec or tcpSocket probes with httpGet
• Wrong indentation or missing keys

3. Given this probe configuration snippet in a pod spec:

livenessProbe:
  httpGet:
    path: /status
    port: 8080
  initialDelaySeconds: 10
  periodSeconds: 5

What will Kubernetes do after the pod starts?

medium

A. Send an HTTP GET to /status only once after 10 seconds

B. Send an HTTP GET to /status immediately, then every 10 seconds

C. Wait 5 seconds, then send an HTTP GET to /status every 10 seconds

D. Wait 10 seconds, then send an HTTP GET to /status every 5 seconds

Solution

1. Step 1: Understand initialDelaySeconds

   This value tells Kubernetes to wait 10 seconds after pod start before first probe.

2. Step 2: Understand periodSeconds

   This value sets the interval between probes, here every 5 seconds.

3. Final Answer:

   Wait 10 seconds, then send an HTTP GET to /status every 5 seconds -> Option D

4. Quick Check:

   initialDelaySeconds = wait, periodSeconds = repeat interval [OK]

Hint: initialDelaySeconds = wait before first probe, periodSeconds = probe interval [OK]

Common Mistakes:

• Confusing initialDelaySeconds with periodSeconds
• Assuming immediate probe on pod start
• Mixing up timing values

4. You configured this HTTP readiness probe:

readinessProbe:
  httpGet:
    path: /ready
    port: 80
  initialDelaySeconds: 5
  periodSeconds: 10
  timeoutSeconds: 2

But Kubernetes marks the pod as not ready even though the app is healthy. What is the likely problem?

medium

A. The probe path /ready is incorrect or not handled by the app

B. initialDelaySeconds is too high, delaying readiness

C. timeoutSeconds is too long, causing probe to fail

D. periodSeconds is too short, causing probe overload

Solution

1. Step 1: Check probe path correctness

   If the app does not respond correctly to /ready, probe fails and pod is not ready.

2. Step 2: Evaluate timing parameters

   initialDelaySeconds of 5 is reasonable; timeoutSeconds of 2 is short but typical; periodSeconds of 10 is normal.

3. Final Answer:

   The probe path /ready is incorrect or not handled by the app -> Option A

4. Quick Check:

   Probe path must match app endpoint [OK]

Hint: Check if probe path matches app endpoint exactly [OK]

Common Mistakes:

• Ignoring probe path correctness
• Changing timing values unnecessarily
• Assuming timeoutSeconds causes readiness failure

5. You want to configure a Kubernetes HTTP readiness probe that waits 15 seconds after container start, then checks the path /health every 3 seconds, but fails the pod if no response within 1 second. Which is the correct probe configuration snippet?

hard

A. readinessProbe:
httpGet:
path: /health
port: 8080
initialDelaySeconds: 15
periodSeconds: 3
timeoutSeconds: 1

B. readinessProbe:
httpGet:
path: /health
port: 8080
initialDelaySeconds: 3
periodSeconds: 15
timeoutSeconds: 1

C. readinessProbe:
httpGet:
path: /health
port: 8080
initialDelaySeconds: 15
periodSeconds: 1
timeoutSeconds: 3

D. readinessProbe:
httpGet:
path: /health
port: 8080
initialDelaySeconds: 1
periodSeconds: 15
timeoutSeconds: 3

Solution

1. Step 1: Match initialDelaySeconds to 15 seconds

   The probe must wait 15 seconds before first check, so initialDelaySeconds: 15.

2. Step 2: Set periodSeconds to 3 seconds and timeoutSeconds to 1 second

   Checks happen every 3 seconds, and timeout is 1 second as required.

3. Final Answer:

   Correct probe with initialDelaySeconds 15, periodSeconds 3, timeoutSeconds 1 -> Option A

4. Quick Check:

   initialDelay=15, period=3, timeout=1 matches requirements [OK]

Hint: Match timing values exactly to requirements [OK]

Common Mistakes:

• Swapping initialDelaySeconds and periodSeconds
• Setting timeoutSeconds longer than periodSeconds
• Using wrong path or port