Kubernetesలో Services అంటే ఏమిటి, ClusterIP, NodePort, మరియు LoadBalancer మధ్య తేడా ఏమిటి?

Question

IT Interview Practice · Accepted Answer

**Service** labels ద్వారా ఎంపిక చేసిన *ఒక Pods సమూహానికి* ఒక స్థిరమైన network identity (ఒక virtual IP మరియు ఒక DNS పేరు) ఇస్తుంది. Pods ephemeral కావడంతో మరియు IPs మారుస్తుండటంతో, clients వాడే మన్నికైన చిరునామా Service, మరియు అది దాని వెనుక ఉన్న ఆరోగ్యకరమైన Pods మీద **load-balance** చేస్తుంది.

## Services ఎందుకు ఉన్నాయి

```text
Pods వస్తూ పోతూ ఉంటాయి (ప్రతిసారీ కొత్త IP). Clientsకు ఒక స్థిరమైన ENDPOINT కావాలి.
ఒక Service:
  → label ద్వారా Pods ఎంచుకుంటుంది  (selector: app=web)
  → ఒక స్థిర virtual IP + DNS పేరు పొందుతుంది (web.default.svc.cluster.local)
  → సరిపోయే, READY Pods మీద requests load-balance చేస్తుంది
```

## మూడు ప్రధాన Service రకాలు

```text
ClusterIP    (default)  → cluster లోపల మాత్రమే చేరుకోగలదు
                          pod-to-pod / internal service communication కోసం
NodePort               → ప్రతి nodeపై ఒక port తెరుస్తుంది (30000-32767)
                          బయటి traffic nodeIP:nodePort → Service → Pods
LoadBalancer           → ఒక బయటి cloud load balancer provision చేస్తుంది
                          Serviceకు route చేసే ఒక public IP ఇస్తుంది
```

```text
       Internet
          │
   ┌──────┴───────┐
   │ LoadBalancer │  (cloud LB, public IP)   ← for public services
   └──────┬───────┘
          │
   ┌──────┴───────┐
   │  NodePort    │  (node:30080)            ← exposes on each node
   └──────┬───────┘
          │
   ┌──────┴───────┐
   │  ClusterIP   │  (10.96.x.x, internal)   ← the base building block
   └──────┬───────┘
       Pods (app=web)
LoadBalancer builds on NodePort, which builds on ClusterIP.
```

## ClusterIP (internal)

```yaml
apiVersion: v1
kind: Service
metadata:
  name: web
spec:
  type: ClusterIP          # default; వదిలేయవచ్చు
  selector:
    app: web               # app=web label ఉన్న Pods సరిపోతాయి
  ports:
    - port: 80             # Service port
      targetPort: 8080     # container port
```

ఇతర Pods దీన్ని DNS ద్వారా చేరుకుంటాయి: `http://web` (అదే namespace) లేదా `http://web.default.svc.cluster.local`.

## NodePort మరియు LoadBalancer

```yaml
# NodePort — ప్రతి node nodePort మీద listen చేసి Serviceకు forward చేస్తుంది
spec:
  type: NodePort
  selector: { app: web }
  ports:
    - port: 80
      targetPort: 8080
      nodePort: 30080      # optional; 30000-32767
---
# LoadBalancer — cloud ఒక public IPతో బయటి LB provision చేస్తుంది
spec:
  type: LoadBalancer
  selector: { app: web }
  ports:
    - port: 80
      targetPort: 8080
```

```bash
kubectl get svc            # types, cluster IPs మరియు external IPs చూడు
kubectl get endpoints web  # Service వెనుక అసలు Pod IPs
```

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

Services అనేది Kubernetesలో networking ఎలా పనిచేస్తుందో, కాబట్టి వాటిని మరియు type hierarchyను అర్థం చేసుకోవడం అత్యవసరమైన, రోజువారీ జ్ఞానం. Pods ephemeral కావడంతో మరియు ప్రతి recreationలో కొత్త IPs పొందటంతో, మీరు clientsను Pod IPs వద్ద నేరుగా చూపించలేరు; ఒక **Service** దీన్ని label-selected Pods సమూహం ముందు ఒక **stable virtual IP మరియు DNS name** అందించడం ద్వారా, మరియు Ready అయిన Pods మీద మాత్రమే traffic **load-balancing** చేయడం ద్వారా పరిష్కరిస్తుంది. మూడు types ఒక layered ప్రగతిని ఏర్పరుస్తాయి: **ClusterIP** (default) pod-to-pod మరియు service-to-service communication కోసం internal-only address ఇస్తుంది మరియు base building block; **NodePort** ప్రతి nodeపై ఒక fixed port తెరుస్తుంది, తద్వారా external traffic Serviceను చేరుకోగలదు; మరియు **LoadBalancer** ఒక public IPతో external cloud load balancer provision చేయడం ద్వారా మరింత ముందుకు వెళ్తుంది — ప్రతి type దాని కింది దాని మీద నిర్మించబడుతుంది. దేని వైపు వెళ్లాలో తెలుసుకోవడం — internal microservice traffic కోసం ClusterIP, basic external access లేదా on-prem setups కోసం NodePort, cloudలో ఒక public endpoint బహిర్గతం చేయడానికి LoadBalancer (మరియు ఆచరణలో, HTTP routing కోసం ClusterIP Services ముందు Ingress) — components ఒకదానితో మరొకటి మరియు బయటి ప్రపంచంతో ఎలా మాట్లాడతాయో design చేయడానికి కీలకం. దాదాపు ప్రతి నిజ workloadకు stable connectivity మరియు load balancing అవసరం కాబట్టి, Services మరియు వాటి types అర్థం చేసుకోవడం design మరియు debugging రెండింటిలోనూ నిరంతరం వచ్చే పునాది Kubernetes networking జ్ఞానం.

Services ఎందుకు ఉన్నాయి

మూడు ప్రధాన Service రకాలు

ClusterIP (internal)

NodePort మరియు LoadBalancer

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

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