Pod શું છે અને તે Kubernetes માં સૌથી નાનું deployable એકમ કેમ છે?

Question

IT Interview Practice · Accepted Answer

**Pod** એ Kubernetes માં સૌથી નાનું deployable એકમ છે: **એક કે વધુ containers** ની આસપાસનું એક wrapper જે એક જ network namespace (એક IP) વહેંચે છે અને storage volumes વહેંચી શકે છે. તમે 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` પર એકબીજા સુધી પહોંચી શકે છે.

## એક minimal 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
The Pod is an abstraction that lets a "logical application" be more than one
container that MUST run together and share resources:
  → a main app container + a helper "sidecar" (log shipper, proxy, etc.)
  → they share the same IP and can use shared volumes for exchanging files
Most Pods hold a SINGLE container. Multi-container Pods are for tight coupling only.
```

## Pods ephemeral છે — તેમને સીધા manage ન કરો

```text
A Pod is DISPOSABLE:
  → it gets a new IP each time it is (re)created
  → if the node dies, the Pod is GONE (not rescheduled by itself)
→ You almost never create bare Pods in production.
→ Instead a controller (Deployment / StatefulSet / Job) creates and REPLACES
  Pods for you, keeping the desired count alive.
```

```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 કરે છે — એક કે વધુ containers ની આસપાસનું પાતળું wrapper જે એક network namespace (એક જ IP, જેમાં તેઓ `localhost` પર એકબીજા સુધી પહોંચી શકે) વહેંચે છે અને storage volumes વહેંચી શકે છે. એ સમજવું કે Pod માંના containers એક જ node પર હંમેશા **co-located અને co-scheduled** હોય છે એ Pod *શેના માટે* છે તે સમજાવે છે: એવા containers ને એકસાથે જૂથબદ્ધ કરવા જે સાથે ચાલવા અને resources વહેંચવા જરૂરી હોય, જેમ કે એક મુખ્ય application સાથે એક ચુસ્તપણે-જોડાયેલ **sidecar** (log shipper, proxy, કે adapter) — સાથે એ પણ ઓળખવું કે વ્યવહારમાં મોટાભાગના Pods માત્ર એક જ container ધરાવે છે. એટલું જ મહત્વનું છે એ સમજવું કે Pods **ephemeral અને disposable** છે: તેઓ દરેક recreation પર નવો IP મેળવે છે અને node મરી જાય તો પોતાની જાતે પુનર્જીવિત થતા નથી, અને એ જ કારણ છે કે તમે ભાગ્યે જ bare Pods બનાવો છો અને તેના બદલે ઊંચા-સ્તરના controllers (**Deployments**, **StatefulSets**, **Jobs**) પર આધાર રાખો છો જે desired state જાળવવા Pods બનાવે અને replace કરે છે. આ ભેદ — Pod એ atomic એકમ છે, જે હાથે નહીં પણ controllers દ્વારા manage થાય છે — એ single containers થી લઈને વાસ્તવિક Kubernetes workloads સુધીનો ખ્યાલાત્મક પુલ છે, અને cluster પર એપ્લિકેશનો deploy કરનાર, debug કરનાર (`kubectl logs`, `describe`, `exec` દ્વારા), કે તેમના વિશે વિચારનાર કોઈપણ માટે રોજિંદું જ્ઞાન છે.

Pod ની અંદર શું છે

એક minimal Pod

Pod કેમ, માત્ર એક container કેમ નહીં?

Pods ephemeral છે — તેમને સીધા manage ન કરો

આ શા માટે મહત્વનું છે

સંબંધિત પ્રશ્નો