Hvad er Kubernetes, og hvilke problemer løser det?

Question

IT Interview Practice · Accepted Answer

**Kubernetes** (ofte forkortet **K8s**) er en open source-platform til **container-orkestrering**. Den automatiserer deployment, skalering, netværk og selvhelbredelse af containeriserede applikationer på tværs af en klynge af maskiner, så du beskriver den *ønskede tilstand (desired state)*, og Kubernetes arbejder løbende på at få virkeligheden til at matche den.

## Problemet: at køre containere i stor skala er svært

```text
Du har containere (fra Docker), men i production skal du også svare på:
  → På HVILKEN maskine kører hver container? (scheduling)
  → Hvad hvis en container crasher? (self-healing / genstarter)
  → Hvad hvis en hel node dør? (omplacér et andet sted)
  → Hvordan finder 50 replicas hinanden og taler sammen? (service discovery)
  → Hvordan udruller jeg en ny version uden downtime? (rolling updates)
  → Hvordan skalerer jeg fra 3 til 30 replicas ved en trafikspids? (autoscaling)
At gøre alt dette manuelt på tværs af mange servere skalerer ikke.
```

## Løsningen: deklarativ orkestrering

Du indsender et **manifest**, der beskriver, hvad du vil have, og klyngens **control loops** driver systemet hen mod det:

```yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: web
spec:
  replicas: 3            # "Jeg vil altid have 3 kørende kopier"
  selector:
    matchLabels: { app: web }
  template:
    metadata:
      labels: { app: web }
    spec:
      containers:
        - name: web
          image: nginx:1.27
          ports:
            - containerPort: 80
```

```bash
kubectl apply -f web.yaml     # erklær ønsket tilstand
kubectl get pods              # Kubernetes har oprettet & schedulet 3 Pods
```

Hvis en Pod dør, opdager Kubernetes forskellen (2 kørende mod 3 ønskede) og opretter automatisk en erstatning.

## Hvad Kubernetes giver dig

```text
✓ SCHEDULING       — placerer Pods på nodes ud fra ressourcer & begrænsninger
✓ SELF-HEALING     — genstarter fejlede containere, erstatter døde Pods/nodes
✓ SERVICE DISCOVERY— stabile virtuelle IP'er & DNS-navne for grupper af Pods
✓ LOAD BALANCING   — fordeler trafik over sunde replicas
✓ ROLLING UPDATES  — udrul nye versioner uden downtime, rul tilbage ved fejl
✓ SCALING          — manuelt eller automatisk (Horizontal Pod Autoscaler)
✓ CONFIG & SECRETS — indsprøjt konfiguration uden at genbygge images
✓ STORAGE ORCHESTRATION — tilknyt persistente volumes til workloads
```

## Deklarativ vs imperativ

```text
IMPERATIVT  → "kør denne kommando, så den næste" (du styrer hvert trin)
DEKLARATIVT → "her er sluttilstanden jeg vil have" (Kubernetes reconciler hen til den)
Den deklarative reconciliation-loop-model er Kubernetes' kerneidé.
```

## Hvorfor det betyder noget

Kubernetes er blevet de facto-standarden for at køre containeriserede workloads i production, så det er grundlæggende, bredt anvendelig viden at forstå, hvad det er, og hvilke problemer det løser. Containere (fra værktøjer som Docker) løser pakketering, men de besvarer ikke de driftsspørgsmål, der opstår i stor skala: hvilken maskine hver container kører på, hvad der sker, når en container eller en hel node fejler, hvordan snesevis af replicas opdager og taler med hinanden, hvordan man udruller en ny version uden downtime, og hvordan man skalerer op og ned med efterspørgslen. Kubernetes håndterer alt dette gennem en **deklarativ, reconciliation-baseret** model: du beskriver den ønskede tilstand i et manifest, og klyngens control loops driver løbende den faktiske tilstand hen mod den — opretter, scheduler, genstarter og erstatter Pods efter behov. Det giver dig **self-healing** (crashede containere og døde nodes genoprettes automatisk), **service discovery og load balancing** (stabile virtuelle IP'er og DNS foran grupper af Pods), **rolling updates og rollbacks** (deployments uden downtime), **scaling** (manuel eller automatisk) og **orkestrering af config, secrets og storage**. Fordi Kubernetes ligger til grund for, hvordan en stor del af branchen deployer og driver software — på tværs af alle større cloud-udbydere og on-premises — er det at forstå dets formål og den deklarative model i kernen essentiel kontekst for moderne infrastrukturarbejde og det mentale fundament, som alle andre Kubernetes-koncepter bygger på.

Problemet: at køre containere i stor skala er svært

Løsningen: deklarativ orkestrering

Hvad Kubernetes giver dig

Deklarativ vs imperativ

Hvorfor det betyder noget

Relaterede spørgsmål