liveness, readiness, మరియు startup probes అంటే ఏమిటి, ప్రతిదాన్ని ఎప్పుడు వాడతారు?

Question

IT Interview Practice · Accepted Answer

Probes kubelet ఒక container ఆరోగ్యాన్ని తనిఖీ చేసి ఫలితంపై చర్య తీసుకోనిస్తాయి. మూడు ఉన్నాయి: **liveness** (బతికి ఉందా, లేక restart చేయాలా?), **readiness** (traffic స్వీకరించడానికి సిద్ధమా?), మరియు **startup** (boot అవ్వడం పూర్తయిందా?). ప్రతిదీ వేరే ప్రశ్నకు సమాధానం ఇస్తుంది.

## మూడు probes ఒక్క చూపులో

```text
LIVENESS   → "app stuck/deadlock అయిందా?"      FAIL → kubelet container‌ను RESTART చేస్తుంది
READINESS  → "ఇప్పుడు traffic serve చేయగలదా?"  FAIL → Pod Service endpoints నుండి తొలగించబడుతుంది
                                                       (RESTART కాదు)
STARTUP    → "నెమ్మది boot పూర్తయిందా?"          మొదట నడుస్తుంది; అది నడిచేటప్పుడు liveness &
                                                readiness వాయిదా వేయబడతాయి
```

## Readiness vs liveness — ప్రధాన తేడా

```text
Readiness TRAFFIC‌ను నియంత్రిస్తుంది:
  → readiness fail అయిన Pod Service load-balancer నుండి బయటకు తీయబడుతుంది,
    కానీ నడుస్తూనే ఉంటుంది (ఉదా. cache warm చేస్తోంది లేదా ఒక dependency down)
Liveness LIFE‌ను నియంత్రిస్తుంది:
  → liveness fail అయిన Pod KILL చేయబడి restart అవుతుంది (కోలుకోలేనంత విరిగిపోయింది)
readiness ఉద్దేశించి liveness వాడటం అనవసర restart loopsకు దారితీస్తుంది.
```

## Probe నిర్వచనాలు

```yaml
spec:
  containers:
    - name: app
      image: myapp:1.0
      ports: [{ containerPort: 8080 }]

startupProbe:            # ఇతరవి మొదలయ్యే ముందు నెమ్మది starterకు సమయం
        httpGet: { path: /healthz, port: 8080 }
        failureThreshold: 30   # 30 * 10s = start కావడానికి 5 నిమిషాల వరకు
        periodSeconds: 10

readinessProbe:          # traffic gate చేయి
        httpGet: { path: /ready, port: 8080 }
        initialDelaySeconds: 5
        periodSeconds: 10

livenessProbe:           # unhealthy అయితే restart
        httpGet: { path: /healthz, port: 8080 }
        periodSeconds: 10
        failureThreshold: 3
```

## Probe విధానాలు (mechanisms)

```text
httpGet    → ఒక path GET; 2xx/3xx = pass          (web appsకు అత్యంత సాధారణం)
tcpSocket  → TCP connection తెరవగలమా?              (HTTP కాని servicesకు)
exec       → ఒక command నడుపు; exit 0 = pass       (custom checks)
grpc       → native gRPC health check
ముఖ్య knobs: initialDelaySeconds, periodSeconds, timeoutSeconds,
           failureThreshold, successThreshold.
```

## startup probes ఎందుకు ఉన్నాయి

```text
నెమ్మదిగా start అయ్యే apps (JVM warmup, పెద్ద migrations) గతంలో liveness మీద భారీ
initialDelaySeconds పెట్టేలా బలవంతం చేసేవి — దీంతో నిజమైన crashes ఆలస్యంగా గుర్తించబడేవి.
startupProbe దీన్ని పరిష్కరిస్తుంది: ఇది నెమ్మది bootను రక్షిస్తుంది, మరియు అది pass అయిన
తర్వాతే liveness/readiness వాటి సాధారణ (గట్టి) timingsతో మొదలవుతాయి.
```

```bash
kubectl describe pod app     # events‌లో probe failures & restart reasons చూడు
kubectl get pod app          # READY column readinessను ప్రతిబింబిస్తుంది; RESTARTS livenessను
```

## ఇది ఎందుకు ముఖ్యం

Health probes అనేవి Kubernetes self-healing మరియు safe traffic routing ఎలా అందిస్తుందో, కాబట్టి మూడు రకాలను మరియు ప్రతిదాన్ని ఎప్పుడు వాడాలో అర్థం చేసుకోవడం అత్యవసరమైన reliability జ్ఞానం. కీలక తేడా — చాలా engineersను తడబడేలా చేసేది — **readiness** మరియు **liveness** మధ్య: readiness **traffic**ను నియంత్రిస్తుంది (fail అయ్యే Pod Service load-balancer నుండి బయటకు తీయబడుతుంది కానీ నడుస్తూనే ఉంటుంది, అది warm up అవుతున్నప్పుడు లేదా ఒక dependency తాత్కాలికంగా down అయినప్పుడు ఆదర్శం), while liveness **life**ను నియంత్రిస్తుంది (fail అయ్యే Pod kill చేయబడి restart అవుతుంది, అది కోలుకోలేనంత deadlock అయినప్పుడు). ఈ రెండింటిని గందరగోళపరచడం — readiness ఉద్దేశించిన చోట liveness probe వాడటం — అనవసర restart loops మరియు outagesకు దారితీస్తుంది, కాబట్టి ప్రతి probe ఏ ప్రశ్నకు సమాధానం ఇస్తుందో తెలుసుకోవడం నేరుగా ఆచరణాత్మకం. **startup** probe ఒక నిజ చారిత్రక బాధను పరిష్కరిస్తుంది: నెమ్మదిగా boot అయ్యే apps ఒకప్పుడు liveness మీద భారీ `initialDelaySeconds` బలవంతం చేసేవి (ఇది నిజ crashes గుర్తింపును ఆలస్యం చేసేది), while ఒక startup probe boot windowను రక్షించి, startup విజయవంతమైన తర్వాతే liveness/readinessను గట్టి, సాధారణ timingsతో నడపనిస్తుంది. probe mechanisms (`httpGet`, `tcpSocket`, `exec`, `grpc`) మరియు tuning knobs (`initialDelaySeconds`, `periodSeconds`, `failureThreshold`, మొదలైనవి) అర్థం చేసుకోవడం health checkingను ఊహలతో కాకుండా సరిగ్గా configure చేయనిస్తుంది. probes users ఆరోగ్యకరమైన Podsను తాకుతారో మరియు విరిగిన Pods స్వయంచాలకంగా కోలుకుంటాయో నేరుగా నిర్ణయిస్తాయి కాబట్టి, వాటిని సరిగ్గా చేయడం Kubernetesలో reliable, production-grade workloads నడపడానికి పునాది.

మూడు probes ఒక్క చూపులో

Readiness vs liveness — ప్రధాన తేడా

Probe నిర్వచనాలు

Probe విధానాలు (mechanisms)

startup probes ఎందుకు ఉన్నాయి

ఇది ఎందుకు ముఖ్యం

సంబంధిత ప్రశ్నలు