Kubernetes என்றால் என்ன, அது என்ன பிரச்சினைகளைத் தீர்க்கிறது?

Question

IT Interview Practice · Accepted Answer

**Kubernetes** (பெரும்பாலும் **K8s** எனச் சுருக்கப்படுகிறது) என்பது ஒரு open-source **container orchestration** platform. இது ஒரு machine cluster முழுவதும் container-ஆக்கப்பட்ட application களை deploy செய்தல், scale செய்தல், networking, மற்றும் self-healing ஐ தானியக்கமாக்குகிறது, எனவே நீங்கள் *desired state* ஐ விவரிக்கிறீர்கள், Kubernetes அதற்கு நிஜத்தைப் பொருத்த தொடர்ந்து வேலை செய்கிறது.

## பிரச்சினை: container களை scale-இல் இயக்குவது கடினம்

```text
You have containers (from Docker), but in production you must also answer:
  → On WHICH machine does each container run? (scheduling)
  → What if a container crashes? (self-healing / restarts)
  → What if a whole node dies? (reschedule elsewhere)
  → How do 50 replicas find and talk to each other? (service discovery)
  → How do I roll out a new version with zero downtime? (rolling updates)
  → How do I scale from 3 to 30 replicas on a traffic spike? (autoscaling)
Doing all this by hand across many servers does not scale.
```

## தீர்வு: declarative orchestration

நீங்கள் விரும்புவதை விவரிக்கும் ஒரு **manifest** ஐ சமர்ப்பிக்கிறீர்கள், cluster-இன் **control loop கள்** system ஐ அதை நோக்கி இயக்குகின்றன:

```yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: web
spec:
  replicas: 3            # "I want 3 copies running, always"
  selector:
    matchLabels: { app: web }
  template:
    metadata:
      labels: { app: web }
    spec:
      containers:
        - name: web
          image: nginx:1.27
          ports:
            - containerPort: 80
```

```bash
kubectl apply -f web.yaml     # declare desired state
kubectl get pods              # Kubernetes has created & scheduled 3 Pods
```

ஒரு Pod இறந்தால், Kubernetes இடைவெளியைக் கவனிக்கிறது (3 விரும்பியதற்கு எதிராக 2 இயங்குகிறது) மற்றும் தானாகவே ஒரு மாற்றை உருவாக்குகிறது.

## Kubernetes உங்களுக்கு என்ன தருகிறது

```text
✓ SCHEDULING       — places Pods on nodes based on resources & constraints
✓ SELF-HEALING     — restarts failed containers, replaces dead Pods/nodes
✓ SERVICE DISCOVERY— stable virtual IPs & DNS names for groups of Pods
✓ LOAD BALANCING   — spreads traffic across healthy replicas
✓ ROLLING UPDATES  — ship new versions with no downtime, roll back on failure
✓ SCALING          — manual or automatic (Horizontal Pod Autoscaler)
✓ CONFIG & SECRETS — inject configuration without rebuilding images
✓ STORAGE ORCHESTRATION — attach persistent volumes to workloads
```

## Declarative vs imperative

```text
IMPERATIVE  → "run this command, then that command" (you manage each step)
DECLARATIVE → "here is the end state I want" (Kubernetes reconciles to it)
The declarative, reconciliation-loop model is Kubernetes' core idea.
```

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

Kubernetes production-இல் container-ஆக்கப்பட்ட workload களை இயக்குவதற்கான de facto தரமாக மாறிவிட்டது, எனவே அது என்ன, என்ன பிரச்சினைகளைத் தீர்க்கிறது என்பதைப் புரிந்துகொள்வது அடிப்படையான, பரவலாகப் பொருந்தும் அறிவு. Container கள் (Docker போன்ற கருவிகளிலிருந்து) packaging ஐத் தீர்க்கின்றன, ஆனால் அவை scale-இல் எழும் operational கேள்விகளுக்குப் பதிலளிக்கவில்லை: ஒவ்வொரு container எந்த machine-இல் இயங்குகிறது, ஒரு container அல்லது முழு node தோல்வியடையும்போது என்ன நடக்கிறது, டஜன் கணக்கான replica கள் எவ்வாறு ஒன்றையொன்று கண்டறிந்து பேசுகின்றன, downtime இல்லாமல் ஒரு புதிய version ஐ எவ்வாறு roll out செய்வது, மற்றும் தேவைக்கேற்ப எவ்வாறு scale up மற்றும் down செய்வது. Kubernetes இவை அனைத்தையும் ஒரு **declarative, reconciliation-based** model மூலம் கையாளுகிறது: நீங்கள் desired state ஐ ஒரு manifest-இல் விவரிக்கிறீர்கள், cluster-இன் control loop கள் தொடர்ந்து உண்மையான state ஐ அதை நோக்கி இயக்குகின்றன — தேவைக்கேற்ப Pod களை உருவாக்கி, schedule செய்து, restart செய்து, மாற்றுகின்றன. இது உங்களுக்கு **self-healing** ஐ (crash ஆன container களும் இறந்த node களும் தானாக மீட்கப்படுகின்றன), **service discovery மற்றும் load balancing** ஐ (Pod குழுக்களுக்கு முன் நிலையான virtual IP மற்றும் DNS), **rolling updates மற்றும் rollback களை** (zero-downtime deploy கள்), **scaling** ஐ (manual அல்லது automatic), மற்றும் **config, secret, மற்றும் storage orchestration** ஐ தருகிறது. Kubernetes தொழில்துறையின் ஒரு பெரும் பங்கு software ஐ எவ்வாறு deploy செய்து இயக்குகிறது என்பதற்கு அடித்தளமாக இருப்பதால் — ஒவ்வொரு பெரிய cloud மற்றும் on-premises முழுவதும் — அதன் நோக்கத்தையும் அதன் மையத்தில் உள்ள declarative model ஐயும் புரிந்துகொள்வது நவீன infrastructure பணிக்கு அத்தியாவசியமான சூழல், மற்றும் ஒவ்வொரு பிற Kubernetes கருத்தும் கட்டமைக்கப்படும் மனநிலை அடித்தளம்.

பிரச்சினை: container களை scale-இல் இயக்குவது கடினம்

தீர்வு: declarative orchestration

Kubernetes உங்களுக்கு என்ன தருகிறது

Declarative vs imperative

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

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