Deployments మరియు ReplicaSets అంటే ఏమిటి, rolling updates మరియు rollbacks ఎలా పనిచేస్తాయి?

Question

IT Interview Practice · Accepted Answer

**Deployment** అనేది stateless apps నడపడానికి ప్రామాణిక controller. ఇది **ReplicaSets**ను manage చేస్తుంది, మరియు ఒక ReplicaSet నిర్దిష్ట సంఖ్యలో ఒకేలాంటి Pods నడుస్తూ ఉండేలా చూస్తుంది. మీరు Deploymentను edit చేస్తారు; అది మీ కోసం **rolling updates** మరియు **rollbacks** orchestrate చేస్తుంది.

## క్రమానుగత నిర్మాణం (hierarchy)

```text
Deployment  → desired state + update strategyను declare చేస్తుంది (మీరు manage చేసేది)
   └── ReplicaSet  → N ఒకేలాంటి Pods ఉండేలా చూస్తుంది (app versionకి ఒకటి)
          └── Pod  → Pod → Pod ...  (అసలు నడుస్తున్న copies)

ప్రతి కొత్త versionలో, Deployment ఒక కొత్త ReplicaSet సృష్టించి Podsను అటుగా మారుస్తుంది.
```

## Deployment manifest

```yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: web
spec:
  replicas: 4
  selector:
    matchLabels: { app: web }
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxUnavailable: 1      # update సమయంలో గరిష్ఠంగా 1 Pod down
      maxSurge: 1            # desired count కంటే గరిష్ఠంగా 1 అదనపు Pod
  template:
    metadata:
      labels: { app: web }
    spec:
      containers:
        - name: web
          image: myapp:1.0
          ports:
            - containerPort: 8080
```

## Rolling update: zero-downtime version మార్పు

```bash
kubectl set image deployment/web web=myapp:2.0   # rolling update trigger చేయి
kubectl rollout status deployment/web            # progress గమనించు
```

```text
maxSurge=1, maxUnavailable=1, replicas=4:
  v1: ████        (start: 4 old Pods)
      █████       spin up 1 new (v2), now 5 total (surge)
      ███ █       old down to 3, new is Ready
      ...gradually shift...
  v2: ████        (end: 4 new Pods, old ReplicaSet scaled to 0)
Traffic only goes to Pods that pass their readiness probe → no downtime.
```

## విడుదల చెడ్డదైనప్పుడు rollback

```bash
kubectl rollout history deployment/web       # revisions జాబితా
kubectl rollout undo deployment/web          # మునుపటి revisionకు roll back
kubectl rollout undo deployment/web --to-revision=3
```

పాత ReplicaSet ఉంచబడుతుంది (0కు scale) కాబట్టి, rollback వేగంగా జరుగుతుంది: Kubernetes కేవలం మునుపటి ReplicaSetను తిరిగి పైకి, కొత్తదాన్ని కిందికి scale చేస్తుంది.

## Scaling

```bash
kubectl scale deployment/web --replicas=10   # desired count మార్చు
```

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

Deployments Kubernetesలో stateless applications నడపడానికి workhorse, కాబట్టి వాటిని మరియు ReplicaSetsతో వాటి సంబంధాన్ని అర్థం చేసుకోవడం అత్యవసరమైన, రోజువారీ జ్ఞానం. layering ప్రధాన అంతర్దృష్టి: మీరు ఒక **Deployment** manage చేస్తారు, అది **ReplicaSets** (versionకి ఒకటి) సొంతం చేసుకుంటుంది, మరియు ప్రతి ReplicaSet నిర్దిష్ట సంఖ్యలో ఒకేలాంటి Pods నడుస్తున్నాయని guarantee చేస్తుంది — self-healing మరియు ఒక stable replica countను కలిసి అందించే reconciliation loops గొలుసు. నిజమైన శక్తి Deployment మార్పును ఎలా handle చేస్తుందో అందులో ఉంది: ఒక **rolling update** ఒక కొత్త ReplicaSet సృష్టించి, `maxSurge` మరియు `maxUnavailable` చే నియంత్రించబడి Podsను పాత నుండి కొత్తకు క్రమంగా మారుస్తుంది, కాబట్టి capacity భద్రపరచబడుతుంది మరియు — ఏ Pods traffic పొందుతాయో gate చేసే readiness probesతో కలిపి — విడుదల **zero downtime**తో జరుగుతుంది. మునుపటి ReplicaSet ఉంచబడటం వల్ల (delete కాకుండా సున్నాకు scale), ఒక **rollback** వేగం మరియు సురక్షితం: `kubectl rollout undo` కేవలం పాత versionను తిరిగి పైకి, చెడ్డదాన్ని కిందికి scale చేస్తుంది, ఒక విడుదల తప్పుగా ప్రవర్తించినప్పుడు మీరు దీని వైపే వెళ్తారు. ఈ mechanics అర్థం చేసుకోవడం — పాటు ఎలా scale (`kubectl scale`) మరియు progress పరిశీలించడం (`kubectl rollout status/history`) — Kubernetesలో software సురక్షితంగా ship చేయడానికి పునాది, మరియు productionలో platform ఎలా పనిచేస్తుందో నిర్వచించే declarative, controller-driven modelను ప్రతిబింబిస్తుంది.

క్రమానుగత నిర్మాణం (hierarchy)

Deployment manifest

Rolling update: zero-downtime version మార్పు

విడుదల చెడ్డదైనప్పుడు rollback

Scaling

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

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