Wat is Kubernetes en welke problemen lost het op?

Question

IT Interview Practice · Accepted Answer

**Kubernetes** (vaak afgekort als **K8s**) is een open-source **container orchestration**-platform. Het automatiseert het deployen, schalen, netwerken en healen van gecontaineriseerde applicaties over een cluster van machines, zodat jij de *desired state* beschrijft en Kubernetes er continu aan werkt om de werkelijkheid daarmee overeen te laten komen.

## Het probleem: containers draaien op schaal is lastig

```text
Je hebt containers (van Docker), maar in productie moet je ook antwoorden:
  → Op WELKE machine draait elke container? (scheduling)
  → Wat als een container crasht? (self-healing / restarts)
  → Wat als een hele node uitvalt? (elders opnieuw inplannen)
  → Hoe vinden 50 replicas elkaar en praten ze met elkaar? (service discovery)
  → Hoe rol ik een nieuwe versie uit met zero downtime? (rolling updates)
  → Hoe schaal ik van 3 naar 30 replicas bij een verkeerspiek? (autoscaling)
Dit alles handmatig over veel servers doen, schaalt niet.
```

## De oplossing: declaratieve orchestration

Je dient een **manifest** in dat beschrijft wat je wilt, en de **control loops** van het cluster sturen het systeem daarnaartoe:

```yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: web
spec:
  replicas: 3            # "Ik wil altijd 3 draaiende kopieën"
  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     # desired state declareren
kubectl get pods              # Kubernetes heeft 3 Pods aangemaakt & ingepland
```

Als een Pod sterft, merkt Kubernetes het gat op (2 draaiend vs 3 gewenst) en maakt automatisch een vervanger aan.

## Wat Kubernetes je geeft

```text
✓ SCHEDULING       — plaatst Pods op nodes o.b.v. resources & constraints
✓ SELF-HEALING     — herstart gecrashte containers, vervangt dode Pods/nodes
✓ SERVICE DISCOVERY— stabiele virtuele IP's & DNS-namen voor groepen Pods
✓ LOAD BALANCING   — verdeelt verkeer over gezonde replicas
✓ ROLLING UPDATES  — nieuwe versies zonder downtime, rollback bij falen
✓ SCALING          — handmatig of automatisch (Horizontal Pod Autoscaler)
✓ CONFIG & SECRETS — injecteer configuratie zonder images te herbouwen
✓ STORAGE ORCHESTRATION — koppel persistent volumes aan workloads
```

## Declaratief vs imperatief

```text
IMPERATIEF  → "voer dit commando uit, dan dat commando" (jij beheert elke stap)
DECLARATIEF → "dit is de eindtoestand die ik wil" (Kubernetes reconcileert ernaartoe)
Het declaratieve, reconciliation-loop-model is de kernidee van Kubernetes.
```

## Waarom het belangrijk is

Kubernetes is de facto standaard geworden voor het draaien van gecontaineriseerde workloads in productie, dus begrijpen wat het is en welke problemen het oplost, is fundamentele, breed toepasbare kennis. Containers (van tools als Docker) lossen packaging op, maar ze beantwoorden niet de operationele vragen die op schaal ontstaan: op welke machine elke container draait, wat er gebeurt als een container of een hele node faalt, hoe tientallen replicas elkaar ontdekken en met elkaar praten, hoe je een nieuwe versie uitrolt zonder downtime, en hoe je op- en afschaalt met de vraag. Kubernetes pakt dit alles aan via een **declaratief, op reconciliation gebaseerd** model: je beschrijft de desired state in een manifest, en de control loops van het cluster sturen de werkelijke toestand continu naar die gewenste toe — door Pods aan te maken, in te plannen, te herstarten en te vervangen waar nodig. Dit geeft je **self-healing** (gecrashte containers en dode nodes worden automatisch hersteld), **service discovery en load balancing** (stabiele virtuele IP's en DNS voor groepen Pods), **rolling updates en rollbacks** (zero-downtime deploys), **scaling** (handmatig of automatisch), en **config-, secret- en storage-orchestration**. Omdat Kubernetes ten grondslag ligt aan hoe een groot deel van de industrie software deployt en beheert — over elke grote cloud en on-premises — is het begrijpen van het doel en het declaratieve model dat er de kern van vormt, essentiële context voor modern infrastructuurwerk, en de mentale fundering waarop elk ander Kubernetes-concept voortbouwt.

Het probleem: containers draaien op schaal is lastig

De oplossing: declaratieve orchestration

Wat Kubernetes je geeft

Declaratief vs imperatief

Waarom het belangrijk is

Gerelateerde vragen