Kubernetes-இல் Service கள் என்ன, மற்றும் ClusterIP, NodePort, மற்றும் LoadBalancer இடையேயான வேறுபாடு என்ன?

Question

IT Interview Practice · Accepted Answer

ஒரு **Service** label களால் தேர்ந்தெடுக்கப்பட்ட *Pod களின் ஒரு தொகுப்பிற்கு* ஒரு நிலையான network அடையாளத்தை (ஒரு virtual IP மற்றும் ஒரு DNS name) தருகிறது. Pod கள் ephemeral ஆகவும் IP களை மாற்றுவதாலும், Service என்பது client கள் பயன்படுத்தும் நீடித்த முகவரி, மேலும் அது தனக்குப் பின்னால் உள்ள ஆரோக்கியமான Pod களுக்கு **load-balance** செய்கிறது.

## Service கள் ஏன் இருக்கின்றன

```text
Pods come and go (new IP each time). Clients need a STABLE endpoint.
A Service:
  → selects Pods by label  (selector: app=web)
  → gets a fixed virtual IP + DNS name (web.default.svc.cluster.local)
  → load-balances requests across the matching, READY Pods
```

## மூன்று முக்கிய Service வகைகள்

```text
ClusterIP    (default)  → reachable ONLY inside the cluster
                          for pod-to-pod / internal service communication
NodePort               → opens a port on EVERY node (30000-32767)
                          external traffic hits nodeIP:nodePort → Service → Pods
LoadBalancer           → provisions an external cloud load balancer
                          gives a public IP that routes to the Service
```

```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; can be omitted
  selector:
    app: web               # matches Pods labelled app=web
  ports:
    - port: 80             # Service port
      targetPort: 8080     # container port
```

பிற Pod கள் அதை DNS மூலம் அடைகின்றன: `http://web` (அதே namespace) அல்லது `http://web.default.svc.cluster.local`.

## NodePort மற்றும் LoadBalancer

```yaml
# NodePort — every node listens on nodePort and forwards to the Service
spec:
  type: NodePort
  selector: { app: web }
  ports:
    - port: 80
      targetPort: 8080
      nodePort: 30080      # optional; 30000-32767
---
# LoadBalancer — cloud provisions an external LB with a public IP
spec:
  type: LoadBalancer
  selector: { app: web }
  ports:
    - port: 80
      targetPort: 8080
```

```bash
kubectl get svc            # see types, cluster IPs and external IPs
kubectl get endpoints web  # the actual Pod IPs behind the Service
```

## இது ஏன் முக்கியம்

Service கள் தான் Kubernetes-இல் networking செயல்படும் விதம், எனவே அவற்றையும் வகை படிநிலையையும் புரிந்துகொள்வது அத்தியாவசியமான, தினசரி அறிவு. Pod கள் ephemeral ஆகவும் ஒவ்வொரு recreation-இலும் புதிய IP களைப் பெறுவதாலும், நீங்கள் client களை நேரடியாக Pod IP களை நோக்கி சுட்ட முடியாது; ஒரு **Service** இதை ஒரு label-தேர்ந்தெடுக்கப்பட்ட Pod தொகுப்பின் முன் ஒரு **நிலையான virtual IP மற்றும் DNS name** ஐ வழங்குவதன் மூலமும், Ready ஆக உள்ள Pod களுக்கு மட்டுமே traffic ஐ **load-balance** செய்வதன் மூலமும் தீர்க்கிறது. மூன்று வகைகளும் ஒரு அடுக்கமைந்த முன்னேற்றத்தை உருவாக்குகின்றன: **ClusterIP** (default) pod-to-pod மற்றும் service-to-service தொடர்பிற்கு ஒரு internal-only முகவரியைத் தருகிறது, இது அடிப்படை கட்டுமான தொகுதி; **NodePort** ஒவ்வொரு node-இலும் ஒரு நிலையான port ஐத் திறக்கிறது, இதனால் external traffic Service ஐ அடையலாம்; மற்றும் **LoadBalancer** ஒரு public IP கொண்ட external cloud load balancer ஐ provision செய்வதன் மூலம் மேலும் செல்கிறது — ஒவ்வொரு வகையும் அதற்குக் கீழே உள்ளதன் மேல் கட்டமைக்கிறது. எதை எட்ட வேண்டும் என்பதை அறிவது — internal microservice traffic-க்கு ClusterIP, அடிப்படை external access அல்லது on-prem setup-க்கு NodePort, ஒரு cloud-இல் ஒரு public endpoint ஐ வெளிப்படுத்த LoadBalancer (மற்றும், நடைமுறையில், HTTP routing-க்கு ClusterIP Service களின் முன் Ingress) — components ஒன்றுடன் ஒன்றும் வெளி உலகுடனும் எப்படி பேசுகின்றன என்பதை design செய்வதற்கு மையமானது. கிட்டத்தட்ட ஒவ்வொரு நிஜமான workload உம் நிலையான connectivity மற்றும் load balancing தேவைப்படுவதால், Service களையும் அவற்றின் வகைகளையும் புரிந்துகொள்வது என்பது design மற்றும் debugging இரண்டிலும் தொடர்ந்து வரும் அடிப்படையான Kubernetes networking அறிவு.

Service கள் ஏன் இருக்கின்றன

மூன்று முக்கிய Service வகைகள்

ClusterIP (internal)

NodePort மற்றும் LoadBalancer

இது ஏன் முக்கியம்

தொடர்புடைய கேள்விகள்