Kubernetes શું છે અને તે કઈ સમસ્યાઓ ઉકેલે છે?

Question

IT Interview Practice · Accepted Answer

**Kubernetes** (ઘણી વાર **K8s** તરીકે ટૂંકાવાય છે) એ એક ઓપન-સોર્સ **container orchestration** પ્લેટફોર્મ છે. તે મશીનોના એક cluster પર containerized એપ્લિકેશનોને deploy કરવું, scale કરવું, networking અને healing આપોઆપ કરી આપે છે, જેથી તમે માત્ર *desired state* વર્ણવો અને Kubernetes સતત વાસ્તવિકતાને તેની સાથે મેળ ખવડાવવા માટે કામ કરતું રહે છે.

## સમસ્યા: મોટા પાયે containers ચલાવવું અઘરું છે

```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 loops** સિસ્ટમને તેની તરફ દોરી જાય છે:

```yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: web
spec:
  replicas: 3            # "મારે હંમેશા 3 copies ચાલતી જોઈએ છે"
  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     # desired state જાહેર કરો
kubectl get pods              # Kubernetes એ 3 Pods બનાવી અને schedule કરી દીધા છે
```

જો કોઈ Pod મરી જાય, તો Kubernetes અંતર જોઈ લે છે (3 desired સામે 2 ચાલુ) અને આપોઆપ એક replacement બનાવે છે.

## 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 માં containerized workloads ચલાવવા માટેનું de facto ધોરણ બની ગયું છે, તેથી તે શું છે અને કઈ સમસ્યાઓ ઉકેલે છે તે સમજવું એ પાયાનું, વ્યાપકપણે લાગુ પડતું જ્ઞાન છે. Containers (Docker જેવા સાધનોમાંથી) packaging ઉકેલે છે, પણ મોટા પાયે ઊભા થતા operational પ્રશ્નોના જવાબ તે આપતા નથી: દરેક container કયા મશીન પર ચાલે છે, જ્યારે કોઈ container કે આખો node નિષ્ફળ જાય ત્યારે શું થાય, ડઝનબંધ replicas એકબીજાને કેવી રીતે શોધે અને વાત કરે, downtime વગર નવું version કેવી રીતે roll out કરવું, અને માંગ પ્રમાણે કેવી રીતે ઉપર-નીચે scale કરવું. Kubernetes આ બધું એક **declarative, reconciliation-based** મોડલ દ્વારા ઉકેલે છે: તમે manifest માં desired state વર્ણવો છો, અને cluster ના control loops સતત actual state ને તેની તરફ દોરી જાય છે — જરૂર પ્રમાણે Pods બનાવે, schedule કરે, restart કરે અને replace કરે. આ તમને **self-healing** (crash થયેલા containers અને મરેલા nodes આપોઆપ recover થાય છે), **service discovery અને load balancing** (Pods ના જૂથો સામે સ્થિર virtual IPs અને DNS), **rolling updates અને rollbacks** (zero-downtime deploys), **scaling** (manual કે automatic), અને **config, secret, અને storage orchestration** આપે છે. Kubernetes ઉદ્યોગનો મોટો હિસ્સો software કેવી રીતે deploy અને operate કરે છે તેનો આધાર છે — દરેક મોટા cloud પર અને on-premises — તેથી તેનો હેતુ અને તેના કેન્દ્રમાં રહેલા declarative મોડલને સમજવું એ આધુનિક infrastructure કામ માટે આવશ્યક સંદર્ભ છે, અને એ માનસિક પાયો છે જેના પર બીજા દરેક Kubernetes ખ્યાલ બંધાય છે.

સમસ્યા: મોટા પાયે containers ચલાવવું અઘરું છે

ઉકેલ: declarative orchestration

Kubernetes તમને શું આપે છે

Declarative vs imperative

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

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