Liveness, readiness, ਅਤੇ startup probes ਕੀ ਹਨ, ਅਤੇ ਤੁਸੀਂ ਹਰ ਇੱਕ ਕਦੋਂ ਵਰਤਦੇ ਹੋ?

Question

IT Interview Practice · Accepted Answer

Probes kubelet ਨੂੰ ਇੱਕ container ਦੀ ਸਿਹਤ ਦੀ ਜਾਂਚ ਕਰਨ ਅਤੇ ਨਤੀਜੇ 'ਤੇ ਕਾਰਵਾਈ ਕਰਨ ਦਿੰਦੇ ਹਨ। ਤਿੰਨ ਹਨ: **liveness** (ਕੀ ਇਹ ਜ਼ਿੰਦਾ ਹੈ, ਜਾਂ ਇਸਨੂੰ restart ਕਰਨਾ ਚਾਹੀਦਾ?), **readiness** (ਕੀ ਇਹ traffic ਲੈਣ ਲਈ ਤਿਆਰ ਹੈ?), ਅਤੇ **startup** (ਕੀ ਇਸਨੇ boot ਹੋਣਾ ਪੂਰਾ ਕਰ ਲਿਆ?)। ਹਰ ਇੱਕ ਇੱਕ ਵੱਖਰੇ ਸਵਾਲ ਦਾ ਜਵਾਬ ਦਿੰਦਾ ਹੈ।

## ਤਿੰਨ probes ਇੱਕ ਨਜ਼ਰ ਵਿੱਚ

```text
LIVENESS   → "Is the app stuck/deadlocked?"   FAIL → kubelet RESTARTS the container
READINESS  → "Can it serve traffic right now?" FAIL → Pod removed from Service endpoints
                                                       (NOT restarted)
STARTUP    → "Has the slow boot finished?"     runs FIRST; while it runs, liveness &
                                                readiness are held off
```

## Readiness ਬਨਾਮ liveness — ਮੁੱਖ ਫ਼ਰਕ

```text
Readiness controls TRAFFIC:
  → a Pod that fails readiness is pulled OUT of the Service load-balancer,
    but keeps running (e.g. it's warming a cache or a dependency is down)
Liveness controls LIFE:
  → a Pod that fails liveness is KILLED and restarted (it's broken beyond recovery)
Using liveness where you meant readiness causes needless 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:           # ਗ਼ੈਰ-ਸਿਹਤਮੰਦ ਹੋਣ 'ਤੇ restart ਕਰੋ
        httpGet: { path: /healthz, port: 8080 }
        periodSeconds: 10
        failureThreshold: 3
```

## Probe ਵਿਧੀਆਂ

```text
httpGet    → GET a path; 2xx/3xx = pass         (web apps ਲਈ ਸਭ ਤੋਂ ਆਮ)
tcpSocket  → can we open a TCP connection?       (ਗ਼ੈਰ-HTTP services ਲਈ)
exec       → run a command; exit 0 = pass        (custom checks)
grpc       → native gRPC health check
ਮੁੱਖ ਨੌਬ: initialDelaySeconds, periodSeconds, timeoutSeconds,
           failureThreshold, successThreshold.
```

## Startup probes ਕਿਉਂ ਮੌਜੂਦ ਹਨ

```text
ਹੌਲੀ-start ਹੋਣ ਵਾਲੀਆਂ ਐਪਸ (JVM warmup, ਵੱਡੇ migrations) ਪਹਿਲਾਂ ਤੁਹਾਨੂੰ liveness 'ਤੇ ਇੱਕ ਵੱਡਾ
initialDelaySeconds ਸੈੱਟ ਕਰਨ ਲਈ ਮਜਬੂਰ ਕਰਦੀਆਂ ਸਨ — ਜੋ ਫਿਰ ਅਸਲੀ crash ਨੂੰ ਪਤਾ ਲੱਗਣ ਵਿੱਚ ਹੌਲੀ ਕਰ ਦਿੰਦਾ ਸੀ।
startupProbe ਇਸਨੂੰ ਠੀਕ ਕਰਦਾ ਹੈ: ਇਹ ਹੌਲੀ boot ਦੀ ਰਾਖੀ ਕਰਦਾ ਹੈ, ਅਤੇ ਸਿਰਫ਼ ਇਸ ਦੇ pass ਹੋਣ ਤੋਂ ਬਾਅਦ ਹੀ
liveness/readiness ਆਪਣੀ ਆਮ (ਤੰਗ) timing ਨਾਲ ਸ਼ੁਰੂ ਹੁੰਦੇ ਹਨ।
```

```bash
kubectl describe pod app     # events ਵਿੱਚ probe failures ਤੇ restart ਕਾਰਨ ਵੇਖੋ
kubectl get pod app          # READY column readiness ਦਰਸਾਉਂਦਾ; RESTARTS liveness ਦਰਸਾਉਂਦਾ ਹੈ
```

## ਇਹ ਮਹੱਤਵਪੂਰਨ ਕਿਉਂ ਹੈ

Health probes ਹੀ ਉਹ ਤਰੀਕਾ ਹਨ ਜਿਸ ਨਾਲ Kubernetes self-healing ਅਤੇ ਸੁਰੱਖਿਅਤ traffic routing ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ, ਇਸ ਲਈ ਤਿੰਨ ਕਿਸਮਾਂ ਅਤੇ ਹਰ ਇੱਕ ਕਦੋਂ ਵਰਤਣੀ ਹੈ ਇਹ ਸਮਝਣਾ ਜ਼ਰੂਰੀ reliability ਗਿਆਨ ਹੈ। ਅਹਿਮ ਫ਼ਰਕ — ਜੋ ਕਈ engineers ਨੂੰ ਠੋਕਰ ਖੁਆਉਂਦਾ ਹੈ — **readiness** ਅਤੇ **liveness** ਵਿਚਕਾਰ ਹੈ: readiness **traffic** ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਦਾ ਹੈ (ਇੱਕ ਫੇਲ੍ਹ Pod ਨੂੰ Service load-balancer ਵਿੱਚੋਂ ਬਾਹਰ ਕੱਢਿਆ ਜਾਂਦਾ ਹੈ ਪਰ ਇਹ ਚੱਲਦਾ ਰਹਿੰਦਾ ਹੈ, ਆਦਰਸ਼ ਜਦੋਂ ਇਹ warming up ਹੋਵੇ ਜਾਂ ਕੋਈ dependency ਅਸਥਾਈ ਤੌਰ 'ਤੇ down ਹੋਵੇ), ਜਦੋਂ ਕਿ liveness **ਜ਼ਿੰਦਗੀ** ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਦਾ ਹੈ (ਇੱਕ ਫੇਲ੍ਹ Pod ਨੂੰ ਮਾਰ ਕੇ restart ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਉਦੋਂ ਲਈ ਜਦੋਂ ਇਹ ਮੁੜ ਬਹਾਲੀ ਤੋਂ ਪਰੇ deadlock ਹੋਵੇ)। ਦੋਵਾਂ ਨੂੰ ਰਲਗੱਡ ਕਰਨਾ — readiness ਦੀ ਥਾਂ liveness probe ਵਰਤਣਾ — ਬੇਲੋੜੇ restart loops ਅਤੇ outages ਪੈਦਾ ਕਰਦਾ ਹੈ, ਇਸ ਲਈ ਇਹ ਜਾਣਨਾ ਕਿ ਹਰ probe ਕਿਹੜੇ ਸਵਾਲ ਦਾ ਜਵਾਬ ਦਿੰਦਾ ਹੈ ਸਿੱਧਾ ਵਿਹਾਰਕ ਹੈ। **Startup** probe ਇੱਕ ਅਸਲ ਇਤਿਹਾਸਕ ਦਰਦ ਹੱਲ ਕਰਦਾ ਹੈ: ਹੌਲੀ-boot ਵਾਲੀਆਂ ਐਪਸ ਕਦੇ liveness 'ਤੇ ਵੱਡਾ `initialDelaySeconds` ਮਜਬੂਰ ਕਰਦੀਆਂ ਸਨ (ਜੋ ਅਸਲੀ crash ਦੀ ਪਛਾਣ ਵਿੱਚ ਦੇਰੀ ਕਰਦਾ ਸੀ), ਜਦੋਂ ਕਿ ਇੱਕ startup probe boot window ਦੀ ਰਾਖੀ ਕਰਦਾ ਹੈ ਅਤੇ liveness/readiness ਨੂੰ ਤੰਗ, ਆਮ timing ਨਾਲ ਸਿਰਫ਼ startup ਸਫ਼ਲ ਹੋਣ 'ਤੇ ਚੱਲਣ ਦਿੰਦਾ ਹੈ। Probe ਵਿਧੀਆਂ (`httpGet`, `tcpSocket`, `exec`, `grpc`) ਅਤੇ tuning ਨੌਬ (`initialDelaySeconds`, `periodSeconds`, `failureThreshold`, ਆਦਿ) ਨੂੰ ਸਮਝਣਾ ਤੁਹਾਨੂੰ health checking ਨੂੰ ਅੰਦਾਜ਼ੇ ਦੀ ਬਜਾਏ ਸਹੀ ਢੰਗ ਨਾਲ configure ਕਰਨ ਦਿੰਦਾ ਹੈ। ਕਿਉਂਕਿ probes ਸਿੱਧਾ ਇਹ ਤੈਅ ਕਰਦੇ ਹਨ ਕਿ ਵਰਤੋਂਕਾਰ ਸਿਹਤਮੰਦ Pod 'ਤੇ ਪਹੁੰਚਦੇ ਹਨ ਜਾਂ ਨਹੀਂ ਅਤੇ ਟੁੱਟੇ Pod ਆਪਣੇ-ਆਪ ਮੁੜ ਬਹਾਲ ਹੁੰਦੇ ਹਨ ਜਾਂ ਨਹੀਂ, ਉਹਨਾਂ ਨੂੰ ਸਹੀ ਕਰਨਾ Kubernetes 'ਤੇ ਭਰੋਸੇਯੋਗ, production-grade workload ਚਲਾਉਣ ਦੀ ਨੀਂਹ ਹੈ।

ਤਿੰਨ probes ਇੱਕ ਨਜ਼ਰ ਵਿੱਚ

Readiness ਬਨਾਮ liveness — ਮੁੱਖ ਫ਼ਰਕ

Probe ਪਰਿਭਾਸ਼ਾਵਾਂ

Probe ਵਿਧੀਆਂ

Startup probes ਕਿਉਂ ਮੌਜੂਦ ਹਨ

ਇਹ ਮਹੱਤਵਪੂਰਨ ਕਿਉਂ ਹੈ

ਸੰਬੰਧਿਤ ਸਵਾਲ