Ce sunt Services în Kubernetes și care este diferența dintre ClusterIP, NodePort și LoadBalancer?

Question

IT Interview Practice · Accepted Answer

Un **Service** oferă o identitate de rețea stabilă (un IP virtual și un nume DNS) unui *set de Pod-uri* selectate după label-uri. Deoarece Pod-urile sunt efemere și își schimbă IP-urile, Service-ul este adresa durabilă pe care o folosesc clienții, și el **face load-balancing** între Pod-urile sănătoase din spate.

## De ce există Services

```text
Pod-urile vin și pleacă (IP nou de fiecare dată). Clienții au nevoie de un ENDPOINT STABIL.
Un Service:
  → selectează Pod-uri după label  (selector: app=web)
  → primește un IP virtual fix + nume DNS (web.default.svc.cluster.local)
  → distribuie cererile între Pod-urile care se potrivesc și sunt READY
```

## Cele trei tipuri principale de Service

```text
ClusterIP    (default)  → accesibil DOAR în interiorul clusterului
                          pentru comunicare pod-to-pod / între servicii interne
NodePort               → deschide un port pe FIECARE node (30000-32767)
                          traficul extern lovește nodeIP:nodePort → Service → Pods
LoadBalancer           → provizionează un load balancer extern de cloud
                          oferă un IP public care rutează spre 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 (intern)

```yaml
apiVersion: v1
kind: Service
metadata:
  name: web
spec:
  type: ClusterIP          # default; poate fi omis
  selector:
    app: web               # se potrivește cu Pod-urile etichetate app=web
  ports:
    - port: 80             # portul Service-ului
      targetPort: 8080     # portul containerului
```

Alte Pod-uri îl ating prin DNS: `http://web` (același namespace) sau `http://web.default.svc.cluster.local`.

## NodePort și LoadBalancer

```yaml
# NodePort — fiecare node ascultă pe nodePort și redirecționează spre Service
spec:
  type: NodePort
  selector: { app: web }
  ports:
    - port: 80
      targetPort: 8080
      nodePort: 30080      # opțional; 30000-32767
---
# LoadBalancer — cloud-ul provizionează un LB extern cu un IP public
spec:
  type: LoadBalancer
  selector: { app: web }
  ports:
    - port: 80
      targetPort: 8080
```

```bash
kubectl get svc            # vezi tipurile, cluster IP-urile și external IP-urile
kubectl get endpoints web  # IP-urile reale ale Pod-urilor din spatele Service-ului
```

## De ce contează

Services reprezintă modul în care funcționează networking-ul în Kubernetes, așa că înțelegerea lor și a ierarhiei de tipuri este cunoaștere esențială, de zi cu zi. Deoarece Pod-urile sunt efemere și primesc IP-uri noi la fiecare recreare, nu poți îndrepta clienții direct spre IP-urile Pod-urilor; un **Service** rezolvă asta oferind un **IP virtual și nume DNS stabile** în fața unui set de Pod-uri selectate după label și **făcând load-balancing** al traficului doar spre Pod-urile care sunt Ready. Cele trei tipuri formează o progresie stratificată: **ClusterIP** (default) oferă o adresă doar-internă pentru comunicare pod-to-pod și service-to-service și este blocul de bază; **NodePort** deschide un port fix pe fiecare node astfel încât traficul extern să poată ajunge la Service; iar **LoadBalancer** merge mai departe provizionând un load balancer extern de cloud cu un IP public — fiecare tip construind peste cel de sub el. A ști pe care să-l alegi — ClusterIP pentru trafic de microservicii interne, NodePort pentru acces extern de bază sau setup-uri on-prem, LoadBalancer pentru a expune un endpoint public pe un cloud (și, în practică, Ingress în fața Service-urilor ClusterIP pentru rutare HTTP) — este esențial pentru a proiecta cum comunică componentele între ele și cu lumea exterioară. Deoarece aproape orice workload real are nevoie de conectivitate stabilă și load balancing, înțelegerea Services și a tipurilor lor este cunoaștere fundamentală de networking Kubernetes care apare constant atât în proiectare, cât și în depanare.

De ce există Services

Cele trei tipuri principale de Service

ClusterIP (intern)

NodePort și LoadBalancer

De ce contează

Întrebări conexe