Startup probe concept in Kubernetes - Commands & Configuration

Introduction

Sometimes an application takes a long time to start. Kubernetes needs a way to know when the app is ready to start checking if it is healthy. The startup probe helps Kubernetes wait until the app is fully started before running other health checks.

When your app takes a long time to initialize before it can serve requests.

When you want to avoid Kubernetes killing your app too early because it thinks the app is not ready.

When you have complex startup tasks like loading large data or connecting to external services.

When you want to separate startup health checks from regular readiness or liveness checks.

When you want to improve stability by letting Kubernetes know exactly when your app is ready.

Config File - startup-probe.yaml

startup-probe.yaml

apiVersion: v1
kind: Pod
metadata:
  name: startup-probe-example
spec:
  containers:
  - name: my-app
    image: nginx:1.23
    startupProbe:
      httpGet:
        path: /healthz
        port: 80
      failureThreshold: 30
      periodSeconds: 10
    readinessProbe:
      httpGet:
        path: /healthz
        port: 80
      periodSeconds: 5
    livenessProbe:
      httpGet:
        path: /healthz
        port: 80
      initialDelaySeconds: 15
      periodSeconds: 20

This YAML defines a Pod with one container running nginx.

The startupProbe checks the /healthz path on port 80 every 10 seconds and allows up to 30 failures before marking the container as failed. This lets Kubernetes wait longer during startup.

The readinessProbe checks if the app is ready to receive traffic every 5 seconds.

The livenessProbe checks if the app is alive every 20 seconds, starting 15 seconds after the container starts.

Commands

This command creates the Pod with the startup probe configuration so Kubernetes can manage the container's startup health.

Terminal

kubectl apply -f startup-probe.yaml

Expected Output

pod/startup-probe-example created

This command checks the status of the Pod to see if it is running and ready after applying the startup probe.

Terminal

kubectl get pods startup-probe-example

Expected Output

NAME                   READY   STATUS    RESTARTS   AGE

startup-probe-example   1/1     Running   0          10s

This command shows detailed information about the Pod, including the results of the startup probe and other health checks.

Terminal

kubectl describe pod startup-probe-example

Expected Output

Name:         startup-probe-example

Namespace:    default

Status:       Running

Containers:

  my-app:

    Container ID:   docker://abcdef123456

    Image:          nginx:1.23

    State:          Running

    Ready:          True

    Restart Count:  0

    Startup Probe:

      http-get http://:80/healthz delay=0s timeout=1s period=10s #success=1 #failure=30

    Readiness Probe:

      http-get http://:80/healthz delay=0s timeout=1s period=5s

    Liveness Probe:

      http-get http://:80/healthz delay=15s timeout=1s period=20s

Events:

  Type    Reason     Age   From               Message

  ----    ------     ----  ----               -------

  Normal  Scheduled  1m    default-scheduler  Successfully assigned default/startup-probe-example to node-1

Key Concept

If you remember nothing else from this pattern, remember: the startup probe tells Kubernetes when your app has fully started before running readiness or liveness checks.

Common Mistakes

Not setting a startup probe for apps that take a long time to start.

Kubernetes may kill the app early thinking it failed to start, causing restarts and downtime.

Add a startup probe with appropriate failureThreshold and periodSeconds to allow enough startup time.

Using the same probe settings for startup, readiness, and liveness probes.

Startup probe needs different timing because it only runs during startup, while readiness and liveness run continuously.

Configure startup probe separately with longer timeouts and failure thresholds.

Summary

Create a Pod with a startup probe to let Kubernetes know when the app is fully started.

Use kubectl apply to create the Pod and kubectl get pods to check its status.

Use kubectl describe pod to see detailed probe results and events.

Practice

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

easy

A. To monitor CPU and memory usage of the pod

B. To restart the pod immediately when it crashes

C. To check if the application has started before other health checks run

D. To manage network traffic routing to the pod

Solution

1. Step 1: Understand the role of startupProbe

   The startupProbe is designed to check if an application has started successfully before Kubernetes runs readiness or liveness probes.

2. Step 2: Differentiate from other probes

   Unlike liveness or readiness probes, startupProbe prevents Kubernetes from killing pods that take longer to start.

3. Final Answer:

   To check if the application has started before other health checks run -> Option C

4. Quick Check:

   startupProbe checks app start status = A [OK]

Hint: Startup probe delays other checks until app starts [OK]

Common Mistakes:

• Confusing startupProbe with livenessProbe
• Thinking startupProbe manages resource usage
• Assuming startupProbe handles traffic routing

2. Which of the following is the correct syntax to define a startupProbe using an HTTP GET request in a pod spec?

easy

A. startupProbe:
exec:
command: ["curl", "-f", "http://localhost:8080/healthz"]
timeoutSeconds: 5

B. startupProbe:
httpGet:
path: /healthz
port: 8080
failureThreshold: 30
periodSeconds: 10

C. startupProbe:
tcpSocket:
port: 8080
initialDelaySeconds: 5

D. startupProbe:
httpGet:
path: /status
port: 80
successThreshold: 3

Solution

1. Step 1: Identify correct HTTP GET syntax for startupProbe

   The startupProbe uses httpGet with path and port fields, plus timing settings like failureThreshold and periodSeconds.

2. Step 2: Compare options for correctness

   startupProbe: httpGet: path: /healthz port: 8080 failureThreshold: 30 periodSeconds: 10 correctly uses httpGet with path /healthz, port 8080, and timing fields. Other options use exec or tcpSocket or wrong ports/fields.

3. Final Answer:

   startupProbe: httpGet: path: /healthz port: 8080 failureThreshold: 30 periodSeconds: 10 -> Option B

4. Quick Check:

   startupProbe HTTP GET with path and port = A [OK]

Hint: HTTP GET startupProbe needs path, port, failureThreshold [OK]

Common Mistakes:

• Using exec probe syntax instead of httpGet
• Missing failureThreshold or periodSeconds
• Incorrect port or path values

3. Given this pod spec snippet, what will happen if the startupProbe fails repeatedly during startup?

startupProbe:
  httpGet:
    path: /start
    port: 8080
  failureThreshold: 5
  periodSeconds: 2
livenessProbe:
  httpGet:
    path: /live
    port: 8080
  initialDelaySeconds: 10
  periodSeconds: 5

medium

A. Kubernetes will never restart the pod because startupProbe is ignored

B. Kubernetes will restart the pod after 10 seconds of livenessProbe failures

C. Kubernetes will restart the pod after 10 seconds of readinessProbe failures

D. Kubernetes will restart the pod after 10 seconds of startupProbe failures

Solution

1. Step 1: Calculate startupProbe failure timeout

   failureThreshold 5 and periodSeconds 2 means Kubernetes waits 5*2=10 seconds of failed startupProbe checks before restarting.

2. Step 2: Understand probe precedence during startup

   During startup, startupProbe controls pod health. LivenessProbe starts after startupProbe succeeds, so restart depends on startupProbe failures first.

3. Final Answer:

   Kubernetes will restart the pod after 10 seconds of startupProbe failures -> Option D

4. Quick Check:

   startupProbe failureThreshold * periodSeconds = restart delay [OK]

Hint: Restart delay = failureThreshold x periodSeconds of startupProbe [OK]

Common Mistakes:

• Confusing startupProbe failure timing with livenessProbe
• Assuming readinessProbe triggers restart
• Ignoring startupProbe during pod startup

4. You configured a startupProbe but your pod keeps restarting immediately. Which fix is most likely correct?

medium

A. Increase failureThreshold and periodSeconds to allow more startup time

B. Remove the startupProbe to rely only on livenessProbe

C. Change the startupProbe to a readinessProbe

D. Set initialDelaySeconds to 0 in the livenessProbe

Solution

1. Step 1: Identify cause of immediate restarts

   If the startupProbe fails too quickly, Kubernetes restarts the pod before it finishes starting.

2. Step 2: Adjust startupProbe timing

   Increasing failureThreshold and periodSeconds gives the app more time to start before Kubernetes kills it.

3. Final Answer:

   Increase failureThreshold and periodSeconds to allow more startup time -> Option A

4. Quick Check:

   Longer startupProbe timeout prevents premature restarts [OK]

Hint: Longer failureThreshold and periodSeconds prevent early restarts [OK]

Common Mistakes:

• Removing startupProbe loses slow start protection
• Confusing startupProbe with readinessProbe
• Setting initialDelaySeconds on livenessProbe doesn't fix startup timing

5. You have a slow-starting app that takes about 3 minutes to initialize. How should you configure the startupProbe to avoid premature pod restarts?

hard

A. Set failureThreshold to 18 and periodSeconds to 10

B. Set failureThreshold to 3 and periodSeconds to 30

C. Set failureThreshold to 1 and periodSeconds to 100

D. Disable startupProbe and rely on livenessProbe with initialDelaySeconds 180

Solution

1. Step 1: Calculate total startupProbe timeout needed

   App needs 3 minutes (180 seconds) to start. Total timeout = failureThreshold x periodSeconds.

2. Step 2: Choose values matching 180 seconds

   Set failureThreshold to 18 and periodSeconds to 10: 18 x 10 = 180 seconds, allowing full startup time before restart.

3. Step 3: Evaluate other options

   Set failureThreshold to 1 and periodSeconds to 100: failureThreshold to 1 and periodSeconds to 100 = 100 seconds (too short). Set failureThreshold to 3 and periodSeconds to 30: 3 x 30 = 90 seconds (too short). Disable startupProbe and rely on livenessProbe with initialDelaySeconds 180 disables startupProbe, risking premature restarts from livenessProbe.

4. Final Answer:

   Set failureThreshold to 18 and periodSeconds to 10 -> Option A

5. Quick Check:

   failureThreshold x periodSeconds = startup timeout [OK]

Hint: Multiply failureThreshold by periodSeconds to match startup time [OK]

Common Mistakes:

• Configuring insufficient total timeout (failureThreshold x periodSeconds < 180s)
• Disabling startupProbe causing premature restarts
• Setting only initialDelaySeconds without startupProbe