Wat zijn Services in Kubernetes, en wat is het verschil tussen ClusterIP, NodePort en LoadBalancer?

Question

IT Interview Practice · Accepted Answer

Een **Service** geeft een stabiele netwerkidentiteit (een virtueel IP en een DNS-naam) aan een *set Pods* die op basis van labels wordt geselecteerd. Omdat Pods ephemeral zijn en van IP veranderen, is de Service het duurzame adres dat clients gebruiken, en het **load-balanced** over de gezonde Pods erachter.

## Waarom Services bestaan

```text
Pods komen en gaan (elke keer een nieuw IP). Clients hebben een STABIEL endpoint nodig.
Een Service:
  → selecteert Pods per label  (selector: app=web)
  → krijgt een vast virtueel IP + DNS-naam (web.default.svc.cluster.local)
  → load-balanced requests over de matchende, READY Pods
```

## De drie belangrijkste Service-types

```text
ClusterIP    (default)  → ALLEEN bereikbaar binnen het cluster
                          voor pod-to-pod / interne service-communicatie
NodePort               → opent een poort op ELKE node (30000-32767)
                          extern verkeer komt op nodeIP:nodePort → Service → Pods
LoadBalancer           → provisiont een externe cloud load balancer
                          geeft een publiek IP dat naar de Service routeert
```

```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; mag worden weggelaten
  selector:
    app: web               # matcht Pods met label app=web
  ports:
    - port: 80             # poort van de Service
      targetPort: 8080     # poort van de container
```

Andere Pods bereiken het via DNS: `http://web` (zelfde namespace) of `http://web.default.svc.cluster.local`.

## NodePort en LoadBalancer

```yaml
# NodePort — elke node luistert op nodePort en stuurt door naar de Service
spec:
  type: NodePort
  selector: { app: web }
  ports:
    - port: 80
      targetPort: 8080
      nodePort: 30080      # optioneel; 30000-32767
---
# LoadBalancer — cloud provisiont een externe LB met een publiek IP
spec:
  type: LoadBalancer
  selector: { app: web }
  ports:
    - port: 80
      targetPort: 8080
```

```bash
kubectl get svc            # bekijk types, cluster-IP's en externe IP's
kubectl get endpoints web  # de daadwerkelijke Pod-IP's achter de Service
```

## Waarom het belangrijk is

Services zijn hoe netwerken werkt in Kubernetes, dus ze begrijpen en de type-hiërarchie is essentiële, alledaagse kennis. Omdat Pods ephemeral zijn en bij elke hercreatie nieuwe IP's krijgen, kun je clients niet rechtstreeks op Pod-IP's laten wijzen; een **Service** lost dit op door een **stabiel virtueel IP en DNS-naam** te bieden vóór een op labels geselecteerde set Pods, en door verkeer te **load-balancen** over alleen de Pods die Ready zijn. De drie types vormen een gelaagde progressie: **ClusterIP** (de default) geeft een intern-alleen adres voor pod-to-pod- en service-to-service-communicatie en is het basisbouwblok; **NodePort** opent een vaste poort op elke node zodat extern verkeer de Service kan bereiken; en **LoadBalancer** gaat verder door een externe cloud load balancer met een publiek IP te provisioneren — elk type bouwt voort op het type eronder. Weten waar je naar moet grijpen — ClusterIP voor intern microservice-verkeer, NodePort voor basale externe toegang of on-prem-opstellingen, LoadBalancer om een publiek endpoint op een cloud bloot te stellen (en, in de praktijk, Ingress vóór ClusterIP-Services voor HTTP-routing) — is kern voor het ontwerpen van hoe componenten met elkaar en met de buitenwereld praten. Omdat vrijwel elke echte workload stabiele connectiviteit en load balancing nodig heeft, is het begrijpen van Services en hun types fundamentele Kubernetes-netwerkkennis die zowel bij ontwerp als bij debuggen voortdurend opduikt.

Waarom Services bestaan

De drie belangrijkste Service-types

ClusterIP (intern)

NodePort en LoadBalancer

Waarom het belangrijk is

Gerelateerde vragen