Vad är Kubernetes och vilka problem löser det?

Question

IT Interview Practice · Accepted Answer

**Kubernetes** (ofta förkortat **K8s**) är en **container-orkestreringsplattform** med öppen källkod. Den automatiserar driftsättning, skalning, nätverk och självläkning av containeriserade applikationer över ett kluster av maskiner, så att du beskriver det *önskade tillståndet (desired state)* och Kubernetes arbetar kontinuerligt för att få verkligheten att matcha det.

## Problemet: att köra containrar i stor skala är svårt

```text
You have containers (from Docker), but in production you must also answer:
  → On WHICH machine does each container run? (scheduling)
  → What if a container crashes? (self-healing / restarts)
  → What if a whole node dies? (reschedule elsewhere)
  → How do 50 replicas find and talk to each other? (service discovery)
  → How do I roll out a new version with zero downtime? (rolling updates)
  → How do I scale from 3 to 30 replicas on a traffic spike? (autoscaling)
Doing all this by hand across many servers does not scale.
```

## Lösningen: deklarativ orkestrering

Du skickar in ett **manifest** som beskriver vad du vill ha, och klustrets **control loops** driver systemet mot det:

```yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: web
spec:
  replicas: 3            # "Jag vill alltid ha 3 kopior igång"
  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     # deklarera önskat tillstånd
kubectl get pods              # Kubernetes har skapat & schemalagt 3 Pods
```

Om en Pod dör märker Kubernetes glappet (2 igång mot 3 önskade) och skapar automatiskt en ersättare.

## Vad Kubernetes ger dig

```text
✓ SCHEDULING       — places Pods on nodes based on resources & constraints
✓ SELF-HEALING     — restarts failed containers, replaces dead Pods/nodes
✓ SERVICE DISCOVERY— stable virtual IPs & DNS names for groups of Pods
✓ LOAD BALANCING   — spreads traffic across healthy replicas
✓ ROLLING UPDATES  — ship new versions with no downtime, roll back on failure
✓ SCALING          — manual or automatic (Horizontal Pod Autoscaler)
✓ CONFIG & SECRETS — inject configuration without rebuilding images
✓ STORAGE ORCHESTRATION — attach persistent volumes to workloads
```

## Deklarativt kontra imperativt

```text
IMPERATIVE  → "run this command, then that command" (you manage each step)
DECLARATIVE → "here is the end state I want" (Kubernetes reconciles to it)
The declarative, reconciliation-loop model is Kubernetes' core idea.
```

## Varför det är viktigt

Kubernetes har blivit de facto-standarden för att köra containeriserade workloads i produktion, så att förstå vad det är och vilka problem det löser är grundläggande, brett tillämpbar kunskap. Containrar (från verktyg som Docker) löser paketering, men de besvarar inte de driftsfrågor som uppstår i stor skala: vilken maskin varje container körs på, vad som händer när en container eller en hel nod fallerar, hur dussintals replicas upptäcker och pratar med varandra, hur man rullar ut en ny version utan driftstopp, och hur man skalar upp och ner efter efterfrågan. Kubernetes hanterar allt detta genom en **deklarativ, reconciliation-baserad** modell: du beskriver det önskade tillståndet i ett manifest, och klustrets control loops driver kontinuerligt det faktiska tillståndet mot det — genom att skapa, schemalägga, starta om och ersätta Pods efter behov. Detta ger dig **self-healing** (kraschade containrar och döda noder återställs automatiskt), **service discovery och load balancing** (stabila virtuella IP-adresser och DNS framför grupper av Pods), **rolling updates och rollbacks** (driftsättningar utan driftstopp), **skalning** (manuell eller automatisk), samt **orkestrering av config, secrets och storage**. Eftersom Kubernetes ligger till grund för hur en stor del av branschen driftsätter och driver mjukvara — över alla större moln och on-premises — är det att förstå dess syfte och den deklarativa modellen i dess kärna en väsentlig kontext för modernt infrastrukturarbete, och den mentala grund som varje annat Kubernetes-koncept bygger på.

Problemet: att köra containrar i stor skala är svårt

Lösningen: deklarativ orkestrering

Vad Kubernetes ger dig

Deklarativt kontra imperativt

Varför det är viktigt

Relaterade frågor