Che cosa sono i Service in Kubernetes, e qual è la differenza tra ClusterIP, NodePort e LoadBalancer?

Question

IT Interview Practice · Accepted Answer

Un **Service** dà un'identità di rete stabile (un IP virtuale e un nome DNS) a un *insieme di Pod* selezionati tramite label. Poiché i Pod sono effimeri e cambiano IP, il Service è l'indirizzo durevole che i client usano, e fa **load-balancing** tra i Pod sani che gli stanno dietro.

## Perché esistono i 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
```

## I tre tipi principali di 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 (interno)

```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
```

Gli altri Pod lo raggiungono tramite DNS: `http://web` (stesso namespace) oppure `http://web.default.svc.cluster.local`.

## NodePort e 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
```

## Perché è importante

I Service sono il modo in cui funziona il networking in Kubernetes, quindi capirli e capire la gerarchia dei tipi è una conoscenza essenziale, di uso quotidiano. Poiché i Pod sono effimeri e ottengono nuovi IP a ogni ricreazione, non puoi puntare i client direttamente agli IP dei Pod; un **Service** risolve il problema fornendo un **IP virtuale e un nome DNS stabili** davanti a un insieme di Pod selezionati tramite label, e facendo **load-balancing** del traffico solo verso i Pod che sono Ready. I tre tipi formano una progressione stratificata: **ClusterIP** (il default) fornisce un indirizzo solo interno per la comunicazione pod-to-pod e service-to-service ed è il mattone di base; **NodePort** apre una porta fissa su ogni node così che il traffico esterno possa raggiungere il Service; e **LoadBalancer** va oltre, effettuando il provisioning di un load balancer cloud esterno con un IP pubblico — ogni tipo costruisce su quello sottostante. Sapere a quale ricorrere — ClusterIP per il traffico microservice interno, NodePort per l'accesso esterno di base o per setup on-prem, LoadBalancer per esporre un endpoint pubblico su un cloud (e, nella pratica, Ingress davanti ai Service ClusterIP per il routing HTTP) — è fondamentale per progettare come i componenti dialogano tra loro e con il mondo esterno. Poiché quasi ogni workload reale ha bisogno di connettività stabile e load balancing, capire i Service e i loro tipi è una conoscenza fondamentale del networking di Kubernetes, che ricorre di continuo sia in fase di progettazione sia di debugging.

Perché esistono i Service

I tre tipi principali di Service

ClusterIP (interno)

NodePort e LoadBalancer

Perché è importante

Domande correlate