Hva er Services i Kubernetes, og hva er forskjellen mellom ClusterIP, NodePort og LoadBalancer?

Question

IT Interview Practice · Accepted Answer

En **Service** gir en stabil nettverksidentitet (en virtuell IP og et DNS-navn) til et *sett av Pods* valgt med labels. Siden Pods er flyktige og bytter IP, er Servicen den varige adressen klienter bruker, og den **load-balancer** over de friske Pods bak seg.

## Hvorfor Services finnes

```text
Pods kommer og går (ny IP hver gang). Klienter trenger et STABILT endpoint.
En Service:
  → velger Pods etter label  (selector: app=web)
  → får en fast virtuell IP + DNS-navn (web.default.svc.cluster.local)
  → load-balancer forespørsler over de matchende, READY Pods
```

## De tre viktigste Service-typene

```text
ClusterIP    (default)  → nåbar KUN inne i klyngen
                          for pod-to-pod / intern service-kommunikasjon
NodePort               → åpner en port på HVER node (30000-32767)
                          ekstern trafikk treffer nodeIP:nodePort → Service → Pods
LoadBalancer           → provisjonerer en ekstern cloud load balancer
                          gir en offentlig IP som ruter til Servicen
```

```text
       Internet
          │
   ┌──────┴───────┐
   │ LoadBalancer │  (cloud LB, offentlig IP)  ← for offentlige tjenester
   └──────┬───────┘
          │
   ┌──────┴───────┐
   │  NodePort    │  (node:30080)              ← eksponerer på hver node
   └──────┬───────┘
          │
   ┌──────┴───────┐
   │  ClusterIP   │  (10.96.x.x, intern)       ← den grunnleggende byggeklossen
   └──────┬───────┘
       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 utelates
  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 Servicen
spec:
  type: NodePort
  selector: { app: web }
  ports:
    - port: 80
      targetPort: 8080
      nodePort: 30080      # valgfritt; 30000-32767
---
# LoadBalancer — cloud provisjonerer 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-ene bak Servicen
```

## Hvorfor det er viktig

Services er hvordan networking fungerer i Kubernetes, så å forstå dem og typehierarkiet er essensiell, daglig kunnskap. Fordi Pods er flyktige og får nye IP-er ved hver gjenopprettelse, kan du ikke peke klienter rett mot Pod-IP-er; en **Service** løser dette ved å tilby en **stabil virtuell IP og et DNS-navn** foran et label-valgt sett av Pods, og ved å **load-balance** trafikk kun over de Pods som er Ready. De tre typene danner en lagdelt progresjon: **ClusterIP** (default) gir en intern-only adresse for pod-to-pod- og service-to-service-kommunikasjon og er den grunnleggende byggeklossen; **NodePort** åpner en fast port på hver node slik at ekstern trafikk kan nå Servicen; og **LoadBalancer** går videre ved å provisjonere en ekstern cloud load balancer med en offentlig IP — hver type bygger på den under. Å vite hvilken man skal gripe til — ClusterIP for intern microservice-trafikk, NodePort for grunnleggende ekstern tilgang eller on-prem-oppsett, LoadBalancer for å eksponere et offentlig endpoint i en cloud (og, i praksis, Ingress foran ClusterIP-Services for HTTP-ruting) — er kjernen i å designe hvordan komponenter snakker med hverandre og med omverdenen. Siden nesten hver reell workload trenger stabil tilkobling og load balancing, er det å forstå Services og typene deres grunnleggende Kubernetes-networking-kunnskap som dukker opp hele tiden både i design og feilsøking.

Hvorfor Services finnes

De tre viktigste Service-typene

ClusterIP (intern)

NodePort og LoadBalancer

Hvorfor det er viktig

Relaterte spørsmål