Horizontal Pod Autoscaler ఎలా పనిచేస్తుంది, అది Cluster Autoscalerకు ఎలా సంబంధించి ఉంటుంది?

Question

IT Interview Practice · Accepted Answer

**Horizontal Pod Autoscaler (HPA)** గమనించిన metrics (CPU, memory, లేదా custom) ఆధారంగా **Pod replicas** జోడిస్తుంది లేదా తొలగిస్తుంది. **Cluster Autoscaler (CA)** Pods schedule కానప్పుడు లేదా nodes తక్కువగా వాడబడినప్పుడు **nodes** జోడిస్తుంది లేదా తొలగిస్తుంది. అవి వేర్వేరు layersలో పనిచేసి కలిసి పనిచేస్తాయి.

## రెండు autoscalers, రెండు layers

```text
HPA  → PODS scale చేస్తుంది (Deployment యొక్క ఎక్కువ/తక్కువ replicas)  — LOADకు స్పందిస్తుంది
CA   → NODES scale చేస్తుంది (cluster machines పెంచుతుంది/తగ్గిస్తుంది)  — PENDING Podsకు స్పందిస్తుంది
VPA  → (bonus) ఒక Pod యొక్క requests/limits సర్దుబాటు చేస్తుంది         — right-sizingకు స్పందిస్తుంది

సాధారణ ప్రవాహం: load పెరుగుతుంది → HPA Pods జోడిస్తుంది → Pods సరిపోవు → CA ఒక node జోడిస్తుంది →
              Pods schedule అవుతాయి. load తగ్గుతుంది → HPA Pods తొలగిస్తుంది → node idle → CA దాన్ని తొలగిస్తుంది.
```

## HPA control loop ఎలా పనిచేస్తుంది

```text
ప్రతి ~15s HPA controller:
  1. metrics-server / custom API నుండి ప్రస్తుత metric (ఉదా. Pods అంతటా avg CPU) చదువుతుంది
  2. లెక్కిస్తుంది:  desiredReplicas = ceil(currentReplicas * currentMetric / targetMetric)
  3. Deploymentను దాని వైపు scale చేస్తుంది (minReplicas/maxReplicasతో పరిమితం)
ఉదాహరణ: 4 Pods 80% CPU వద్ద, target 50% → 4 * 80/50 = 6.4 → 7 replicas.
Stabilization windows flapping‌ను తగ్గిస్తాయి (ముఖ్యంగా scale-downలో).
```

## ఒక HPA manifest

```yaml
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: web-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: web
  minReplicas: 3
  maxReplicas: 20
  metrics:
    - type: Resource
      resource:
        name: cpu
        target:
          type: Utilization
          averageUtilization: 60      # avg CPUను REQUEST లో ~60% వద్ద ఉంచు
  behavior:                           # optional: scale up/down వేగం tune చేయి
    scaleDown:
      stabilizationWindowSeconds: 300
```

```bash
kubectl get hpa                       # current/target metric, replica count
kubectl top pods                      # metrics-server అవసరం
```

## ముఖ్యమైన dependencies & హెచ్చరికలు

```text
• CPU/memory మీద HPAకు metrics-server install కావాలి; utilization REQUESTS కు సాపేక్షం
  → requests unset/తప్పు అయితే, HPA లెక్క అర్థరహితం. requests సరిగ్గా పెట్టు.
• Custom/external metrics (RPS, queue depth) కి ఒక adapter కావాలి (Prometheus Adapter, KEDA).
• HPA మరియు manual `replicas` విభేదిస్తాయి — replica countను HPA సొంతం చేసుకోనివ్వు.
• Cluster Autoscalerకు కూడా సరైన requests కావాలి: node scaling నిర్ణయించడానికి Pending Pods
  యొక్క REQUESTS చూస్తుంది. Node scale-up నిమిషాలు పడుతుంది (provisioning), కాబట్టి headroom ఉంచు.
```

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

Autoscaling అనేది Kubernetes capacityను demandకు స్వయంచాలకంగా సరిపోల్చడాన్ని అనుమతించేది, మరియు రెండు layers అర్థం చేసుకోవడం cost-efficient, resilient clustersను over- లేదా under-provisioned వాటి నుండి వేరు చేసే senior-level జ్ఞానం. కీలక మానసిక model ఏమిటంటే **HPA Pods scale చేస్తుంది** loadకు స్పందిస్తూ (గమనించిన CPU, memory, లేదా custom metrics నుండి replica count సర్దుబాటు) while **Cluster Autoscaler nodes scale చేస్తుంది** scheduling ఒత్తిడికి స్పందిస్తూ (Pods Pending అయినప్పుడు machines జోడించి, nodes idle అయినప్పుడు తొలగించడం) — అవి వేర్వేరు layersలో పనిచేసి సహకరిస్తాయి: HPA చోటు ఉంటేనే Pods జోడించగలదు, మరియు CA ఆ చోటు అందిస్తుంది. HPA control loop అర్థం చేసుకోవడం — `desiredReplicas = ceil(currentReplicas * currentMetric / targetMetric)` సూత్రం, ఆవర్తన reconciliation, మరియు flapping ను నివారించే stabilization windows — దాన్ని ఒక మాయలా చూడకుండా configure మరియు debug చేయనిస్తుంది. Caveats అనేవి senior judgment కనిపించే చోటు: CPU/memory మీద HPAకు **metrics-server అవసరం** మరియు utilizationను **requestsకు సాపేక్షంగా** లెక్కిస్తుంది, కాబట్టి తప్పు లేదా లేని requests దాని లెక్కను అర్థరహితం చేస్తాయి; custom metrics (requests-per-second, queue depth)కి Prometheus Adapter లేదా KEDA వంటి ఒక adapter అవసరం; మరియు node scale-up నిమిషాలు పడుతుంది, కాబట్టి headroom ముఖ్యం. capacity right-sizing traffic spikes కింద reliabilityను మరియు నిశ్శబ్ద కాలాలలో cloud spendను నేరుగా ప్రభావితం చేస్తుంది కాబట్టి, మరియు రెండు autoscalers సరిగ్గా set చేసిన resource requests మీద ఆధారపడతాయి కాబట్టి, HPA మరియు Cluster Autoscaler ప్రావీణ్యం production Kubernetesను సమర్థవంతంగా మరియు నమ్మకంగా operate చేయడానికి పునాది.

రెండు autoscalers, రెండు layers

HPA control loop ఎలా పనిచేస్తుంది

ఒక HPA manifest

ముఖ్యమైన dependencies & హెచ్చరికలు

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

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