Zoeken naar Docker vs Kubernetes suggereert dat je er één moet kiezen, maar die framing zorgt voor veel verwarring. Het lijkt een beetje op het vergelijken van een zeecontainer met de haven die er duizenden organiseert. Ze opereren op verschillende niveaus en worden vaak naast elkaar gebruikt.

Deze gids legt uit wat iedereen doet, toont in beide dezelfde kleine app en eindigt met een praktische manier om te beslissen. De opdrachten en bestanden hier zijn standaardvoorbeelden die we voor dit artikel niet hebben uitgevoerd, dus vergelijk ze met de versies die u installeert.

Het korte antwoord

Docker is een platform waarmee u een applicatie en de bijbehorende afhankelijkheden in een image kunt verpakken en die image vervolgens als container kunt uitvoeren. Het beantwoordt de vraag “hoe zorg ik ervoor dat deze app overal op dezelfde manier werkt?”

Kubernetes, vaak geschreven als K8s, is een containerorkestrator. Het bepaalt waar containers op veel machines draaien, start ze opnieuw op als ze uitvallen en schaalt ze op als er vraag naar is. Het geeft antwoord op de vraag: “Hoe zorg ik ervoor dat honderden containers betrouwbaar blijven draaien?”

Docker versus Kubernetes zij aan zij

Wat Docker doet

Vóór containers was “het werkt op mijn machine” een dagelijks probleem, omdat elke server overal verschillende versies van had. Docker bundelt uw code, runtime en bibliotheken in één image. Een actieve kopie van die image is een container en deelt de kernel van de host, zodat deze sneller opstart en minder geheugen gebruikt dan een volledige virtuele machine.

De workflow bestaat uit drie stappen:

1. Build: a Dockerfile beschrijft hoe je de afbeelding maakt.
2. Verzenden: duw de afbeelding naar een register, zoals Docker Hub.
3. Uitvoeren: start containers vanaf die afbeelding op elke compatibele machine.

Om aan de slag te gaan, begint u met onze Docker-tutorial voor beginners en leest u vervolgens onze Dockerfile best practices.

Wat Kubernetes doet

Docker op één server werkt goed totdat die server uitvalt, het verkeer er overheen groeit of je tientallen services moet coördineren. Kubernetes verzorgt deze operationele klussen:

• Planning: het plaatsen van containers op machines met voldoende vrije capaciteit.
• Zelfherstel: defecte containers vervangen en werk verplaatsen van defecte knooppunten.
• Schaal: kopieën toevoegen of verwijderen, handmatig of op basis van statistieken.
• Servicedetectie: een veranderende groep containers één stabiele naam geven.
• Doorlopende updates: Nieuwe versies worden geleidelijk uitgebracht, met een simpele rollback.
• Configuratie: instellingen en geheimen afzonderlijk van afbeeldingen beheren.

Het kernidee is de gewenste toestand. U verklaart dat er drie exemplaren zouden moeten bestaan, en de controleurs blijven dat vergelijken met de werkelijkheid en eventuele verschillen corrigeren. Onze Kubernetes-tutorial voor beginners loopt hier doorheen op een lokaal cluster.

Hoe Docker en Kubernetes samenwerken

Een typisch pad van de laptop van een ontwikkelaar naar productie ziet er als volgt uit:

1. Een ontwikkelaar schrijft een Dockerfile en test de container lokaal.
2. Een CI/CD-pijplijn bouwt de image en voert de tests uit.
3. De pijplijn pusht een versie-image naar een register.
4. Een Kubernetes-manifest wordt bijgewerkt om die installatiekopieversie te gebruiken.
5. Kubernetes haalt de afbeelding op en rolt deze uit over het cluster.

De taak van Docker is dus grotendeels klaar voordat Kubernetes begint. De afbeelding is het overdrachtspunt tussen hen.

Eén app, beide kanten op

Hier is een kleine webservice. De afbeelding wordt op dezelfde manier opgebouwd, ongeacht welke tool deze uitvoert:

# Dockerfile
FROM python:3.13-slim
WORKDIR /app
COPY . .
RUN pip install -r requirements.txt
CMD ["python", "app.py"]

Voer het uit met Docker

docker build -t shop-api:1.0 .
docker run -d --name shop -p 8080:8000 --restart unless-stopped shop-api:1.0

Twee commando’s en het draait. Dit is eenvoudig en geschikt voor veel kleine projecten. Maar er staat één exemplaar op één machine, en als de machine het begeeft, gaat de service mee.

Het wordt uitgevoerd met Kubernetes

# shop.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: shop
spec:
  replicas: 3
  selector:
    matchLabels:
      app: shop
  template:
    metadata:
      labels:
        app: shop
    spec:
      containers:
        - name: api
          image: registry.example.com/shop-api:1.0
          ports:
            - containerPort: 8000
---
apiVersion: v1
kind: Service
metadata:
  name: shop
spec:
  selector:
    app: shop
  ports:
    - port: 80
      targetPort: 8000

kubectl apply -f shop.yaml
kubectl get pods -l app=shop

Er valt nog veel meer te schrijven, en je hebt een cluster nodig om het uit te voeren. In ruil daarvoor krijgt u drie exemplaren, een stabiel intern adres en automatische vervanging. Die afweging is de hele beslissing in miniatuur: meer complexiteit in ruil voor meer veerkracht.

Wat gebeurt er als een container faalt?

De dockershim-verwarring

Je hebt misschien gelezen dat “Kubernetes Docker heeft laten vallen”. Dit is in engere zin waar, en het heeft veel mensen onnodig bang gemaakt. Kubernetes voert containers uit via een standaard die de Container Runtime Interface wordt genoemd. Docker Engine implementeerde het niet rechtstreeks, dus voegde Kubernetes een adapter toe genaamd dockershim. Die adapter is verwijderd in versie 1.24.

Clusters gebruiken nu doorgaans runtimes zoals containerd of CRI-O. Afbeeldingen die je met Docker maakt, werken nog steeds, omdat ze de Open Container Initiative (OCI)-imagestandaard volgen. U kunt dus blijven bouwen met Docker en uw cluster voert het resultaat uit met een andere runtime.

Docker Compose versus Swarm versus Kubernetes

De betekenisvollere vergelijking is tussen tools die containers coördineren:

Docker Compose start verschillende gerelateerde containers vanuit één bestand, en het is uitstekend geschikt voor een webapp plus een database op een laptop. Swarm is ingebouwd in Docker en is veel gemakkelijker te leren dan Kubernetes, maar het heeft een veel kleiner ecosysteem. Kubernetes heeft de grootste community en tooling, wat een groot deel is van de reden waarom het de standaard werd voor grote implementaties.

Welke heb je nodig?

Docker alleen is meestal voldoende als:

• U ontwikkelt lokaal of draait een kleine app op één server.
• Je hebt een klein team en geen toegewijd operationeel personeel.
• Incidentele korte onderbrekingen zijn acceptabel.

Kubernetes begint zinvol te worden wanneer:

• Je voert veel services uit die verschillende teams zelfstandig inzetten.
• U hebt een hoge beschikbaarheid nodig voor meerdere machines of zones.
• Het verkeer varieert zo erg dat automatisch schalen echt geld bespaart.
• U beschikt over de vaardigheden of het budget om het te bedienen.

Er is ook een middenweg. Beheerde containerplatforms, zoals AWS Fargate, Google Cloud Run of een PaaS, draaien uw Docker-image zonder dat u een cluster hoeft te onderhouden. Voor veel groeiende bedrijven is dat de juiste volgende stap, in plaats van direct naar Kubernetes te springen.

Als je beide om carrièreredenen wilt leren, is de volgorde duidelijk: eerst Docker, dan Kubernetes. U kunt een Pod niet op een comfortabele manier debuggen zonder eerst afbeeldingen, poorten en containerlogboeken te begrijpen.

Veel voorkomende fouten

• Kubernetes te vroeg adopteren. Het kopiëren van de architectuur van een gigantisch bedrijf kan een klein team in operationeel werk begraven.
• De tag latest wordt gebruikt in productie. Je kunt niet op betrouwbare wijze zien wat er wordt uitgevoerd of terugdraaien. Gebruik specifieke versietags.
• Gegevens opslaan in containers. Containers zijn wegwerpbaar, dus gebruik volumes of een beheerde database.
• Statuschecks overslaan. Zonder tests op gereedheid en liveness kan Kubernetes geen goede beslissingen nemen over uw app.
• Resourcelimieten vergeten. Eén hebzuchtige container kan al het andere op een node uithongeren.

Tot slot

Docker verpakt uw software en Kubernetes voert deze op schaal uit. In plaats van te vragen wat beter is, kun je beter vragen welk probleem je vandaag hebt. Als het “mijn app is moeilijk te installeren” is, gebruik dan Docker. Als het is “mijn 40 services moeten serverstoringen overleven”, kijk dan naar Kubernetes. Begin met het eenvoudigste hulpmiddel dat uw werkelijke probleem oplost, en ga verder als u de noodzaak ervan inziet.

Veelgestelde vragen

Blijf leren