Pod అంటే ఏమిటి, Kubernetesలో అది ఎందుకు అతిచిన్న deployable unit?

Question

IT Interview Practice · Accepted Answer

**Pod** అనేది Kubernetesలో అతిచిన్న deployable unit: ఒకే network namespace (ఒక IP)ను పంచుకునే మరియు storage volumes పంచుకోగల **ఒకటి లేదా అంతకంటే ఎక్కువ containers** చుట్టూ ఒక wrapper. మీరు containersను నేరుగా deploy చేయరు — మీరు Podsను deploy చేస్తారు.

## Pod లోపల ఏముంది

```text
┌───────────────── Pod (has ONE shared IP) ─────────────────┐
│                                                            │
│   ┌──────────────┐   ┌──────────────┐   shared:           │
│   │  container A  │   │  container B  │    • network (IP)   │
│   │  (app)        │   │  (sidecar)    │    • localhost      │
│   └──────────────┘   └──────────────┘    • volumes         │
│         │ talk to each other via localhost:port            │
└────────────────────────────────────────────────────────────┘
```

ఒకే Podలోని containers ఎల్లప్పుడూ ఒకే nodeపై **co-located** గా ఉంటాయి, కలిసి schedule అవుతాయి, మరియు `localhost` ద్వారా ఒకదానికొకటి చేరుకోగలవు.

## కనీస Pod

```yaml
apiVersion: v1
kind: Pod
metadata:
  name: web
  labels: { app: web }
spec:
  containers:
    - name: web
      image: nginx:1.27
      ports:
        - containerPort: 80
```

## Pod ఎందుకు, కేవలం ఒక container కాదా?

```text
Pod అనేది ఒక "logical application" ఒకటి కంటే ఎక్కువ containersను కలిగి ఉండేలా చేసే
ఒక abstraction; ఆ containers తప్పనిసరిగా కలిసి నడవాలి మరియు resources పంచుకోవాలి:
  → ఒక ప్రధాన app container + ఒక సహాయక "sidecar" (log shipper, proxy, మొదలైనవి)
  → అవి ఒకే IP పంచుకుంటాయి మరియు files మార్చుకోవడానికి shared volumes వాడగలవు
చాలా Pods ఒకే container కలిగి ఉంటాయి. Multi-container Pods గట్టి coupling కోసం మాత్రమే.
```

## Pods ephemeral — వాటిని నేరుగా manage చేయకండి

```text
Pod అనేది DISPOSABLE:
  → అది (re)create అయిన ప్రతిసారీ కొత్త IP పొందుతుంది
  → node చనిపోతే, Pod పోతుంది (అదే స్వయంగా reschedule కాదు)
→ మీరు productionలో దాదాపు ఎప్పుడూ bare Pods సృష్టించరు.
→ బదులుగా ఒక controller (Deployment / StatefulSet / Job) మీ కోసం Podsను సృష్టించి
  భర్తీ చేస్తుంది, కావలసిన count బతికి ఉండేలా చూస్తుంది.
```

```bash
kubectl get pods -o wide          # Pods, వాటి node మరియు IP చూడు
kubectl describe pod web          # events, status, restarts
kubectl logs web -c web           # ఒక నిర్దిష్ట container యొక్క logs
kubectl exec -it web -- sh        # container లోకి shell
```

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

Pod అనేది Kubernetes యొక్క ప్రాథమిక building block, కాబట్టి అది ఏమిటి మరియు ఎందుకు ఉంది అని అర్థం చేసుకోవడం అత్యవసరమైన, తప్పక తెలియాల్సిన జ్ఞానం. Kubernetes bare containersను schedule చేయదు; ఇది **Pods**ను schedule చేస్తుంది — ఒక network namespace పంచుకునే (ఒకే IP, `localhost` ద్వారా తమలో తాము చేరుకోగలవు) మరియు storage volumes పంచుకోగల ఒకటి లేదా అంతకంటే ఎక్కువ containers చుట్టూ ఒక సన్నని wrapper. ఒక Podలోని containers ఒకే nodeపై **ఎల్లప్పుడూ co-located మరియు co-scheduled** అని అర్థం చేసుకోవడం ఒక Pod దేని *కోసం* అనేది వివరిస్తుంది: కలిసి నడవాల్సిన మరియు resources పంచుకోవాల్సిన containersను సమూహపరచడం, ఉదాహరణకు ఒక ప్రధాన application పాటు గట్టిగా-coupled అయిన ఒక **sidecar** (ఒక log shipper, proxy, లేదా adapter) — ఆచరణలో చాలా Pods కేవలం ఒకే container కలిగి ఉంటాయని గుర్తిస్తూ. అంతే ముఖ్యం Pods **ephemeral మరియు disposable** అని గ్రహించడం: అవి ప్రతి recreationలో కొత్త IP పొందుతాయి మరియు node చనిపోతే స్వయంగా పునరుజ్జీవించబడవు, అందుకే మీరు అరుదుగా bare Pods సృష్టిస్తారు మరియు బదులుగా desired state నిర్వహించడానికి Podsను సృష్టించి భర్తీ చేసే ఉన్నత-స్థాయి controllers (**Deployments**, **StatefulSets**, **Jobs**) మీద ఆధారపడతారు. ఈ తేడా — Pod ఒక atomic unitగా, చేతితో కాకుండా controllers చే manage చేయబడటం — single containers నుండి నిజ Kubernetes workloadsకు భావనాత్మక వారధి, మరియు ఒక clusterలో applications deploy, debug (`kubectl logs`, `describe`, `exec` ద్వారా), లేదా reason చేసే ఎవరికైనా రోజువారీ జ్ఞానం.

Pod లోపల ఏముంది

కనీస Pod

Pod ఎందుకు, కేవలం ఒక container కాదా?

Pods ephemeral — వాటిని నేరుగా manage చేయకండి

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

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