Kubernetes vs Docker: Alles wat je moet weten

Containers zijn snel en licht omdat ze direct op de kernel van de hostmachine draaien, zonder de overhead van een hypervisor zoals bij virtuele machines. Deze containers bevatten alles wat je app nodig heeft: code, runtime, libraries en dependencies.

Het biedt een consistente runtime, zodat je app hetzelfde draait in ontwikkeling, test en productie - ongeacht het systeem of de omgeving.

Hoe werkt Docker? 

Docker is de basis voor het bouwen en runnen van gecontaineriseerde applicaties. Het verpakt je app en alles eromheen in een container. Binnen de architectuur van Docker (zie hieronder) vertelt de Docker-client de daemon wat hij moet doen door commando's uit te voeren (build, pull, run).

De Docker daemon haalt images op uit een register (rechterzijde van het diagram). Registers zoals Docker Hub slaan herbruikbare images op (zoals Ubuntu). Zodra de daemon de image heeft, maakt hij er een container van.

In het kort:  
Client commando's → Docker daemon → pulls image → creëert containers → voert je app uit.

Daar komt Kubernetes om de hoek kijken – daar gaan we zo op in… 

Wat is Kubernetes? 

Dus, wat is Kubernetes precies? Laten we het niet moeilijker maken dan nodig is: Kubernetes (K8S) is een open-source platform voor het automatiseren, beheren en schalen van containerized applications.

Door de flexibiliteit en het vermogen om grote workloads aan te kunnen, is het dé standaard geworden voor container orchestration. Het regelt scaling, load balancing en zelfs self-healing.

Hoe werkt Kubernetes?

Als je containers hebt, beheert Kubernetes ze over meerdere machines. De Kubernetes cluster groepeert containers die een microservice of app ondersteunen in pods, die draaien op nodes.

• Pods: Pods zijn de kleinste eenheid in Kubernetes en delen hetzelfde netwerk en storage. Perfect dus voor apps die strak samenwerken en veel met elkaar praten. 
• Nodes: Nodes zijn worker machines (zoals virtual machines) die de pods draaien. 

Apps die draaien in Kubernetes gedragen zich als één geheel, ook al bestaan ze uit losse containers.

In Kubernetes regelt een deployment de gewenste state van je app. Het bepaalt hoeveel pod replicas er moeten draaien en houdt dit aantal in stand.

YAML

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: myapp
  template:
    metadata:
      labels:
        app: myapp
    spec:
      containers:
        - name: myapp-container
          image: myapp:1.0

Kubernetes Deployment YAML

Deployments zijn geschikt voor stateless workloads en ondersteunen declarative updates. Daardoor kun je makkelijk nieuwe versies uitrollen of opschalen. Onder water gebruikt een deployment een replica set om het juiste aantal pods actief te houden.

Crasht er één of wordt er eentje verwijderd? Dan zorgt de replica set dat er automatisch een nieuwe komt. 

Als developer beschrijf je de gewenste state in de deployment. De deployment controller zorgt ervoor dat die gewenste state wordt nageleefd. 

Dat gebeurt via een control loop. De controller checkt constant de actuele state van het cluster via de API server. Klopt er iets niet? Dan grijpt hij in om alles weer gelijk te trekken met de gewenste state.

Kubernetes balanceert ook automatisch netwerkverkeer over pods, zodat niet één container overbelast raakt.

Het schaalt pods automatisch op basis van load: Check hoe je cloud native schaalt met Kubernetes.

De rol van Docker binnen Kubernetes

Vroeger was Docker de standaard container runtime voor Kubernetes, maar ondertussen ondersteunt Kubernetes via de Container Runtime Interface (CRI) ook andere runtimes zoals containerd en CRI-O.

Die verandering begon met het uitfaseren van Dockershim in Kubernetes v1.20, en de volledige verwijdering ervan in v1.24. Hierdoor kon Kubernetes de architectuur versimpelen en de performance verbeteren.

Docker wordt nog steeds veel gebruikt om containers te bouwen en te beheren, maar Kubernetes is er niet langer afhankelijk van om containers te runnen.

Use Cases voor Docker en Kubernetes

Nu je weet hoe Docker en Kubernetes ongeveer werken, kijken we naar waar je ze precies voor gebruikt:

Waar gebruik je Docker voor

• Requests doorsturen naar en van containers
• Lifecycle van containers beheren
• Containeractiviteit monitoren en loggen
• Gedeelde directories mounten
• Resource limits instellen op containers
• Images bouwen via Dockerfile
• Images pushen en pullen van registries

Waar gebruik je Kubernetes voor

Dus waar is Kubernetes voor bedoeld? Hier een overzicht:

• Auto-scaling: Past zich automatisch aan op basis van load
• Rollouts: Ondersteunt automatische rollouts en rollbacks
• Pods: Groepen containers die geheugen, CPU, storage en netwerk delen
• Self-healing: Start containers opnieuw op als ze crashen
• Load balancing: Verdeelt requests over beschikbare pods
• Storage orchestration: Mount netwerk storage als lokale file system
• Config management en secrets: Beveiligt gevoelige data met “Secrets”

Wat is het verschil tussen Kubernetes en Docker?

Laten we kijken hoe ze zich tot elkaar verhouden – dat is waarschijnlijk waar je voor kwam.

Er is een beetje overlap: ze kunnen allebei containers draaien.

Een belangrijk verschil is:

• Docker gebruik je om je app te verpakken en te shippen
• Kubernetes gebruik je om die app te deployen en te schalen

Maar het grootste verschil zit in het schalen. Wil je 4 containers lokaal draaien zonder veel gedoe, dan is docker run prima.

Maar als je 20.000 containers wilt draaien op 500 servers verspreid over 3 datacenters, dan heb je een orchestrator nodig.

Sommigen zeggen: je kunt prima Docker draaien zonder Kubernetes. Klopt – maar voor grotere distributed systems is Kubernetes onmisbaar.

Om het helemaal helder te maken, zie je hieronder een vergelijkingstabel met de belangrijkste verschillen:

Kubernetes vs Docker Vergelijkingstabel

Kubernetes of Docker: Welke past het best bij jou?

Wanneer kies je voor Docker

Docker is een goede keuze voor single-container apps of lokale development omgevingen, bijvoorbeeld met tools zoals Docker Compose. Het mist de orchestration-kracht van Kubernetes, maar is perfect voor het lokaal opzetten van multi-container omgevingen tijdens development.

Docker wordt vooral gebruikt tijdens development en testing van een app. Voorbeelden zijn:

• Consistente development omgevingen opzetten
• Bij het bouwen van een microservice lokaal kun je de service en bijvoorbeeld de database of cache in eigen containers draaien
• Ook ideaal in CI/CD pipelines waar je consistente builds en tests wil, ongeacht de omgeving

Maar het schiet tekort als je schaalbare, complexe, distributed apps wilt bouwen. Docker kan namelijk niet zelf containers verdelen over meerdere servers.

Voorbeeld: wil je 20.000 containers draaien over 500 servers? Dan heb je een orchestration platform nodig, zoals Kubernetes.

Wanneer kies je voor Kubernetes

Kubernetes gebruik je als je een app uitrolt naar productie of andere omgevingen.

Kubernetes is super handig als je:

• Meerdere microservices met hoge beschikbaarheid wilt deployen
• Data stores wilt beheren met stevige durability garanties
• Big data workloads zoals Apache Spark wilt draaien
• Of zelfs kleinere dingen zoals cron jobs wilt runnen
• En natuurlijk: Docker en Kubernetes samen wilt gebruiken

De echte vraag is uiteindelijk: “Waarom zou je Docker en Kubernetes samen gebruiken?”

Het antwoord = zodra je veel containers moet beheren en schalen, is Docker alleen niet genoeg. De twee zijn juist gemaakt om samen te werken:

• Docker runt de containers
• Kubernetes regelt de orchestration en zorgt dat alles stabiel draait op schaal

Samen zijn ze ideaal voor productie-omgevingen waar automatische scaling, failover en beheer over meerdere machines nodig zijn.

Zo ziet een simpele workflow eruit met Docker en Kubernetes:

1. Developers gebruiken Docker om de app in een container te verpakken, inclusief dependencies
2. De Docker image wordt gepusht naar een container registry
3. Kubernetes haalt de image op uit de registry en zet die om in een pod
4. Kubernetes monitort het verkeer en schaalt pods horizontaal als dat nodig is
5. Het zorgt ook dat verkeer netjes naar gezonde containers wordt gestuurd
6. Als een container crasht, start Kubernetes die automatisch opnieuw op zodat het gewenste aantal replicas blijft draaien

Conclusie

We hebben Kubernetes en Docker besproken en waarom het vaak geen kwestie is van kiezen, maar van combineren. Ze hebben elk hun eigen rol.

Door Kubernetes en Docker te combineren, krijg je een goed geïntegreerd platform voor het deployen, beheren en schalen van containers. Samen vormen ze de backbone van moderne cloud native apps.