ஒரு Pod என்றால் என்ன, அது Kubernetes-இல் ஏன் மிகச்சிறிய deployable அலகு?

Question

IT Interview Practice · Accepted Answer

ஒரு **Pod** என்பது Kubernetes-இல் மிகச்சிறிய deployable அலகு: ஒரே network namespace ஐப் (ஒரு IP) பகிர்ந்து storage volume களைப் பகிரக்கூடிய **ஒன்று அல்லது அதற்கு மேற்பட்ட container களைச்** சுற்றியுள்ள ஒரு wrapper. நீங்கள் container களை நேரடியாக deploy செய்வதில்லை — நீங்கள் Pod களை 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-இல் உள்ள container கள் **எப்போதும் ஒரே 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.
```

## Pod கள் ephemeral — அவற்றை நேரடியாக நிர்வகிக்க வேண்டாம்

```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          # see Pods, their node and IP
kubectl describe pod web          # events, status, restarts
kubectl logs web -c web           # logs of a specific container
kubectl exec -it web -- sh        # shell into the container
```

## இது ஏன் முக்கியம்

Pod என்பது Kubernetes-இன் அடிப்படை கட்டுமான தொகுதி, எனவே அது என்ன, அது ஏன் இருக்கிறது என்பதைப் புரிந்துகொள்வது அத்தியாவசியமான, அவசியம் அறிய வேண்டிய அறிவு. Kubernetes வெறும் container களை schedule செய்யாது; அது **Pod களை** schedule செய்கிறது — ஒரு network namespace ஐப் (ஒரு ஒற்றை IP, தமக்கிடையே `localhost` வழியாக அடையக்கூடியது) பகிர்ந்து storage volume களைப் பகிரக்கூடிய ஒன்று அல்லது அதற்கு மேற்பட்ட container களைச் சுற்றியுள்ள ஒரு மெல்லிய wrapper. ஒரு Pod-இல் உள்ள container கள் **எப்போதும் ஒரே node-இல் co-located மற்றும் co-scheduled** என்பதைப் புரிந்துகொள்வது ஒரு Pod எதற்காக இருக்கிறது என்பதை விளக்குகிறது: ஒன்றாக இயங்கி resource களைப் பகிர வேண்டிய container களை குழுவாக்குவது, எடுத்துக்காட்டாக ஒரு முதன்மை application உடன் ஒரு இறுக்கமாக-இணைந்த **sidecar** (log shipper, proxy, அல்லது adapter) — அதே சமயம் நடைமுறையில் பெரும்பாலான Pod கள் ஒரே ஒரு container ஐ மட்டுமே வைத்திருக்கின்றன என்பதை அங்கீகரிப்பது. சமமாக முக்கியமானது Pod கள் **ephemeral மற்றும் disposable** என்பதைப் புரிந்துகொள்வது: அவை ஒவ்வொரு recreation-இலும் ஒரு புதிய IP ஐப் பெறுகின்றன, ஒரு node இறந்தால் தாமாக உயிர்பெறாது, இதனால்தான் நீங்கள் அரிதாகவே bare Pod களை உருவாக்கி, Pod களை உருவாக்கி மாற்றி desired state ஐப் பராமரிக்கும் உயர்-நிலை controller களை (**Deployment கள்**, **StatefulSet கள்**, **Job கள்**) நம்புகிறீர்கள். இந்த வேறுபாடு — Pod ஒரு atomic அலகு, கையால் அல்லாமல் controller களால் நிர்வகிக்கப்படுகிறது — ஒற்றை container களிலிருந்து நிஜமான Kubernetes workload களுக்கான கருத்தியல் பாலம், மற்றும் ஒரு cluster-இல் application களை deploy செய்யும், debug செய்யும் (`kubectl logs`, `describe`, `exec` வழியாக), அல்லது அவற்றைப் பற்றிப் பகுத்தறியும் எவருக்கும் தினசரி அறிவு.

ஒரு Pod-க்குள் என்ன இருக்கிறது

ஒரு minimal Pod

ஏன் ஒரு Pod, வெறும் container அல்ல?

Pod கள் ephemeral — அவற்றை நேரடியாக நிர்வகிக்க வேண்டாம்

இது ஏன் முக்கியம்

தொடர்புடைய கேள்விகள்