Kubernetes అంటే ఏమిటి, అది ఏ సమస్యలను పరిష్కరిస్తుంది?

Question

IT Interview Practice · Accepted Answer

**Kubernetes** (తరచుగా **K8s** అని సంక్షిప్తీకరిస్తారు) అనేది ఒక open-source **container orchestration** ప్లాట్‌ఫారమ్. ఇది machinesతో కూడిన ఒక cluster అంతటా containerized అప్లికేషన్‌లను deploy, scale, networking, మరియు healing చేయడాన్ని automate చేస్తుంది; కాబట్టి మీరు *desired state*ను వర్ణిస్తారు, వాస్తవాన్ని దానికి సరిపోయేలా చేయడానికి Kubernetes నిరంతరం పనిచేస్తుంది.

## సమస్య: పెద్ద స్థాయిలో containers నడపడం కష్టం

```text
మీ దగ్గర containers ఉన్నాయి (Docker నుండి), కానీ productionలో మీరు వీటికి కూడా సమాధానం ఇవ్వాలి:
  → ప్రతి container ఏ మెషీన్‌పై నడుస్తుంది? (scheduling)
  → ఒక container crash అయితే ఏమవుతుంది? (self-healing / restarts)
  → ఒక మొత్తం node చనిపోతే ఏమవుతుంది? (వేరే చోట reschedule)
  → 50 replicas ఒకదానికొకటి ఎలా కనుగొని మాట్లాడుకుంటాయి? (service discovery)
  → zero downtimeతో కొత్త versionను ఎలా roll out చేయాలి? (rolling updates)
  → traffic ఒక్కసారిగా పెరిగినప్పుడు 3 నుండి 30 replicasకు ఎలా scale చేయాలి? (autoscaling)
అనేక serversలో వీటన్నింటినీ చేతితో చేయడం 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ను declare చేయి
kubectl get pods              # Kubernetes 3 Podsను సృష్టించి schedule చేసింది
```

ఒక Pod చనిపోతే, Kubernetes ఆ తేడాను (3 కావాలి vs 2 నడుస్తున్నాయి) గమనించి, స్వయంచాలకంగా ఒక ప్రత్యామ్నాయాన్ని సృష్టిస్తుంది.

## Kubernetes మీకు ఏమి ఇస్తుంది

```text
✓ SCHEDULING       — resources & constraints ఆధారంగా Podsను nodesపై ఉంచుతుంది
✓ SELF-HEALING     — విఫలమైన containersను restart చేస్తుంది, చనిపోయిన Pods/nodesను భర్తీ చేస్తుంది
✓ SERVICE DISCOVERY— Pods సమూహాలకు స్థిరమైన virtual IPs & DNS పేర్లు
✓ LOAD BALANCING   — ఆరోగ్యకరమైన replicas మీద traffic పంచుతుంది
✓ ROLLING UPDATES  — downtime లేకుండా కొత్త versions, విఫలమైతే roll back
✓ SCALING          — manual లేదా automatic (Horizontal Pod Autoscaler)
✓ CONFIG & SECRETS — images rebuild చేయకుండా configuration inject చేస్తుంది
✓ STORAGE ORCHESTRATION — workloadsకు persistent volumes జతచేస్తుంది
```

## Declarative vs imperative

```text
IMPERATIVE  → "ఈ command నడుపు, తర్వాత ఆ command" (ప్రతి అడుగును మీరు manage చేస్తారు)
DECLARATIVE → "నాకు కావలసిన తుది స్థితి ఇదీ" (Kubernetes దానికి reconcile చేస్తుంది)
declarative, reconciliation-loop model అనేది Kubernetes యొక్క ప్రధాన ఆలోచన.
```

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

Kubernetes productionలో containerized workloads నడపడానికి de facto standardగా మారింది, కాబట్టి అది ఏమిటి మరియు ఏ సమస్యలను పరిష్కరిస్తుందో అర్థం చేసుకోవడం పునాది స్థాయి, విస్తృతంగా వర్తించే జ్ఞానం. Containers (Docker వంటి tools నుండి) packaging సమస్యను పరిష్కరిస్తాయి, కానీ పెద్ద స్థాయిలో తలెత్తే operational ప్రశ్నలకు అవి సమాధానం ఇవ్వవు: ప్రతి container ఏ మెషీన్‌పై నడుస్తుంది, ఒక container లేదా మొత్తం node విఫలమైనప్పుడు ఏమవుతుంది, డజన్ల కొద్దీ replicas ఒకదానికొకటి ఎలా కనుగొని మాట్లాడుకుంటాయి, downtime లేకుండా కొత్త versionను ఎలా roll out చేయాలి, మరియు demandకు అనుగుణంగా ఎలా పెంచి తగ్గించాలి. Kubernetes వీటన్నింటినీ ఒక **declarative, reconciliation-based** model ద్వారా పరిష్కరిస్తుంది: మీరు desired stateను ఒక manifestలో వర్ణిస్తారు, మరియు cluster యొక్క control loops అవసరమైనట్లు Podsను సృష్టిస్తూ, schedule చేస్తూ, restart చేస్తూ, భర్తీ చేస్తూ వాస్తవ స్థితిని దాని వైపు నిరంతరం నడిపిస్తాయి. ఇది మీకు **self-healing** (crash అయిన containers మరియు చనిపోయిన nodes స్వయంచాలకంగా కోలుకుంటాయి), **service discovery మరియు load balancing** (Pods సమూహాల ముందు స్థిరమైన virtual IPs మరియు DNS), **rolling updates మరియు rollbacks** (zero-downtime deploys), **scaling** (manual లేదా automatic), మరియు **config, secret, మరియు storage orchestration** అందిస్తుంది. పరిశ్రమలో పెద్ద భాగం softwareను deploy చేసి నడిపే విధానానికి Kubernetes పునాది కావడంతో — ప్రతి major cloud మరియు on-premises అంతటా — దాని ఉద్దేశాన్ని మరియు దాని కేంద్రంలోని declarative modelను గ్రహించడం ఆధునిక infrastructure పనికి అత్యవసరమైన సందర్భం, మరియు ప్రతి ఇతర Kubernetes concept దాని మీద నిర్మించబడే మానసిక పునాది.

సమస్య: పెద్ద స్థాయిలో containers నడపడం కష్టం

పరిష్కారం: declarative orchestration

Kubernetes మీకు ఏమి ఇస్తుంది

Declarative vs imperative

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

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