Hvad er Services i Kubernetes, og hvad er forskellen mellem ClusterIP, NodePort og LoadBalancer?

Question

IT Interview Practice · Accepted Answer

En **Service** giver en stabil netværksidentitet (en virtuel IP og et DNS-navn) til et *sæt Pods*, valgt via labels. Da Pods er ephemeral og skifter IP, er Service'en den holdbare adresse, klienter bruger, og den **load-balancer** over de sunde Pods bagved.

## Hvorfor Services findes

```text
Pods kommer og går (ny IP hver gang). Klienter har brug for et STABILT endpoint.
En Service:
  → vælger Pods via label  (selector: app=web)
  → får en fast virtuel IP + DNS-navn (web.default.svc.cluster.local)
  → load-balancer requests over de matchende Pods, der er READY
```

## De tre vigtigste Service-typer

```text
ClusterIP    (default)  → kun tilgængelig INDE i klyngen
                          til pod-til-pod / intern service-kommunikation
NodePort               → åbner en port på HVER node (30000-32767)
                          ekstern trafik rammer nodeIP:nodePort → Service → Pods
LoadBalancer           → provisionerer en ekstern cloud-load-balancer
                          giver en offentlig IP, der router til Service'en
```

```text
       Internet
          │
   ┌──────┴───────┐
   │ LoadBalancer │  (cloud-LB, offentlig IP)  ← til offentlige services
   └──────┬───────┘
          │
   ┌──────┴───────┐
   │  NodePort    │  (node:30080)              ← eksponerer på hver node
   └──────┬───────┘
          │
   ┌──────┴───────┐
   │  ClusterIP   │  (10.96.x.x, intern)       ← den grundlæggende byggeklods
   └──────┬───────┘
       Pods (app=web)
LoadBalancer bygger på NodePort, som bygger på ClusterIP.
```

## ClusterIP (intern)

```yaml
apiVersion: v1
kind: Service
metadata:
  name: web
spec:
  type: ClusterIP          # default; kan udelades
  selector:
    app: web               # matcher Pods med label app=web
  ports:
    - port: 80             # Service-port
      targetPort: 8080     # container-port
```

Andre Pods når den via DNS: `http://web` (samme namespace) eller `http://web.default.svc.cluster.local`.

## NodePort og LoadBalancer

```yaml
# NodePort — hver node lytter på nodePort og videresender til Service'en
spec:
  type: NodePort
  selector: { app: web }
  ports:
    - port: 80
      targetPort: 8080
      nodePort: 30080      # valgfri; 30000-32767
---
# LoadBalancer — cloud provisionerer en ekstern LB med en offentlig IP
spec:
  type: LoadBalancer
  selector: { app: web }
  ports:
    - port: 80
      targetPort: 8080
```

```bash
kubectl get svc            # se typer, cluster-IP'er og eksterne IP'er
kubectl get endpoints web  # de faktiske Pod-IP'er bag Service'en
```

## Hvorfor det betyder noget

Services er måden, netværk fungerer på i Kubernetes, så det er essentiel hverdagsviden at forstå dem og typehierarkiet. Fordi Pods er ephemeral og får nye IP'er ved hver genoprettelse, kan du ikke pege klienter direkte på Pod-IP'er; en **Service** løser dette ved at levere en **stabil virtuel IP og DNS-navn** foran et label-valgt sæt Pods og ved at **load-balance** trafik over kun de Pods, der er Ready. De tre typer danner en lagdelt progression: **ClusterIP** (default) giver en intern-kun adresse til pod-til-pod- og service-til-service-kommunikation og er den grundlæggende byggeklods; **NodePort** åbner en fast port på hver node, så ekstern trafik kan nå Service'en; og **LoadBalancer** går videre ved at provisionere en ekstern cloud-load-balancer med en offentlig IP — hver type bygger på den under den. At vide, hvilken man skal gribe til — ClusterIP til intern microservice-trafik, NodePort til grundlæggende ekstern adgang eller on-prem-opsætninger, LoadBalancer til at eksponere et offentligt endpoint på en cloud (og i praksis Ingress foran ClusterIP-Services til HTTP-routing) — er kernen i at designe, hvordan komponenter taler med hinanden og med omverdenen. Da næsten enhver reel workload har brug for stabil forbindelse og load balancing, er det at forstå Services og deres typer grundlæggende Kubernetes-netværksviden, der dukker op konstant både i design og fejlfinding.

Hvorfor Services findes

De tre vigtigste Service-typer

ClusterIP (intern)

NodePort og LoadBalancer

Hvorfor det betyder noget

Relaterede spørgsmål