Kubernetes Liveness Probe Failing Randomly — Fix

# Check probe failure details
kubectl describe pod <pod-name> -n <namespace>
 
# Look for:
# Warning  Unhealthy  Liveness probe failed: HTTP probe failed with statuscode: 500
# Warning  Unhealthy  Liveness probe failed: context deadline exceeded
# Warning  Killing    Container killed due to liveness probe failure
 
# Check restart history
kubectl get pod <pod-name> -o jsonpath='{.status.containerStatuses[0].restartCount}'
 
# Watch probe events in real time
kubectl get events -n <namespace> --field-selector reason=Unhealthy -w

# Default (too tight):
livenessProbe:
  httpGet:
    path: /health
    port: 8080
  initialDelaySeconds: 0   # fires immediately!
  periodSeconds: 10        # every 10 seconds
  timeoutSeconds: 1        # 1 second to respond!
  failureThreshold: 3      # 3 failures = restart

livenessProbe:
  httpGet:
    path: /health
    port: 8080
  initialDelaySeconds: 30   # wait for app to start
  periodSeconds: 15         # check every 15s
  timeoutSeconds: 5         # 5 seconds to respond
  failureThreshold: 3       # 3 consecutive failures = restart
  successThreshold: 1       # 1 success to become healthy

// Checks everything — too fragile
func healthHandler(w http.ResponseWriter, r *http.Request) {
    if err := db.Ping(); err != nil {  // DB might be slow!
        http.Error(w, "DB unhealthy", 503)
        return
    }
    if err := redis.Ping(); err != nil {  // Redis might be slow!
        http.Error(w, "Cache unhealthy", 503)
        return
    }
    w.WriteHeader(200)
}

// Liveness: is the process alive? (bare minimum)
func livenessHandler(w http.ResponseWriter, r *http.Request) {
    w.WriteHeader(200)  // If this endpoint responds, the app is alive
    w.Write([]byte(`{"status":"alive"}`))
}
 
// Readiness: can this pod accept traffic? (check dependencies)
func readinessHandler(w http.ResponseWriter, r *http.Request) {
    if err := db.Ping(); err != nil {
        http.Error(w, "DB not ready", 503)
        return
    }
    w.WriteHeader(200)
    w.Write([]byte(`{"status":"ready"}`))
}

livenessProbe:
  httpGet:
    path: /health/live    # Simple alive check
    port: 8080
 
readinessProbe:
  httpGet:
    path: /health/ready   # Full dependency check
    port: 8080

livenessProbe:
  httpGet:
    path: /actuator/health/liveness
    port: 8080
  initialDelaySeconds: 60    # JVM takes time to start
  periodSeconds: 20
  timeoutSeconds: 10         # Allow for GC pauses
  failureThreshold: 5        # Be lenient
 
startupProbe:               # Handle slow startup separately
  httpGet:
    path: /actuator/health/liveness
    port: 8080
  failureThreshold: 30      # 30 * 10s = 5 minutes max startup time
  periodSeconds: 10

# Problematic — spawns a new process every 10 seconds
livenessProbe:
  exec:
    command:
      - sh
      - -c
      - "curl -f http://localhost:8080/health || exit 1"

livenessProbe:
  httpGet:
    path: /health
    port: 8080
  # Much lighter than spawning curl

# Check if CPU is being throttled
kubectl top pod <pod-name>
 
# Check events for OOMKilled (memory pressure)
kubectl describe pod <pod-name> | grep -A5 "Last State"

resources:
  requests:
    cpu: "100m"
    memory: "256Mi"
  limits:
    cpu: "500m"    # Increase if app is CPU throttled
    memory: "512Mi"

# Node.js / Go (fast startup)
livenessProbe:
  httpGet:
    path: /health
    port: 3000
  initialDelaySeconds: 10
  periodSeconds: 15
  timeoutSeconds: 5
  failureThreshold: 3
 
# Java / Spring Boot (slow startup)
startupProbe:
  httpGet:
    path: /actuator/health
    port: 8080
  failureThreshold: 30
  periodSeconds: 10
livenessProbe:
  httpGet:
    path: /actuator/health/liveness
    port: 8080
  periodSeconds: 20
  timeoutSeconds: 10
  failureThreshold: 5
 
# Python / Django
livenessProbe:
  httpGet:
    path: /health/
    port: 8000
  initialDelaySeconds: 20
  periodSeconds: 15
  timeoutSeconds: 8
  failureThreshold: 3