Kubernetes-basisbeginselen voor kleine teams

U wilt een applicatie draaien die niet omvalt als een proces stopt, en die meeschaalt zonder dat u om drie uur 's nachts een server bij hoeft te kopen. Kubernetes doet dat, maar het rekent een toegangsprijs in complexiteit die u eerst moet betalen voordat u er iets voor terugziet.

Dit artikel legt uit hoe u die eerste zes stappen zet — cluster maken, app deployen, ontsluiten, schalen, updaten — en wat elke stap u kost. Voor teams van twee tot tien ontwikkelaars die containers draaien en geen dedicated platformteam hebben.

Vereisten

U hebt een machine met minimaal 4 GB RAM en 2 CPU-cores. Alle commando's werken op Linux, macOS of Windows (via WSL2).

• Docker (voor het draaien van de cluster-node-images)
• `kubectl` versie 1.28 of nieuwer
• Minikube versie 1.31 of nieuwer, of Kind versie 0.20 of nieuwer
• Basiskennis van YAML en de commandoregel

Controleer uw versies:

kubectl version --client
minikube version
docker --version

Stap 1: Maak een lokaal cluster

Een Kubernetes-cluster bestaat uit een control plane die de staat beheert en worker nodes die de workloads draaien. In productie zijn dat aparte machines; lokaal draait alles op één machine in een virtuele omgeving.

Minikube is de snelste start:

minikube start --cpus=2 --memory=4096

Dit downloadt een node-image en start een cluster. Het kost vijf tot tien minuten de eerste keer, daarna gaat het sneller.

Kiest u voor Kind, dan draait u Kubernetes in Docker-containers in plaats van een VM:

kind create cluster --name pixzo-test

Kind start sneller dan Minikube en verbruikt minder geheugen, maar u mist enkele features zoals load balancers die in Minikube wel werken. Begin met Minikube als u het eenvoudig wilt houden; kies Kind als u weinig RAM hebt.

Waarom dit kost wat het kost: u leert clusterbeheer op een machine die u kunt weggooien. Maakt u fouten — en die maakt u — dan herstart u het cluster in plaats van een productieserver te repareren.

Stap 2: Deploy een applicatie

Een Deployment is een manifest dat beschrijft welke containerimage moet draaien en hoeveel replica's. Kubernetes leest dit bestand en zorgt dat de werkelijkheid overeenkomt met wat erin staat.

Maak een bestand `deployment.yaml`:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-demo
spec:
  replicas: 2
  selector:
    matchLabels:
      app: nginx-demo
  template:
    metadata:
      labels:
        app: nginx-demo
    spec:
      containers:
      - name: nginx
        image: nginx:1.27
        ports:
        - containerPort: 80

Deploy het met:

kubectl apply -f deployment.yaml

Kubernetes start nu twee Pods op de beschikbare worker nodes. Een Pod is de kleinste eenheid die Kubernetes beheert — een wrapper om één of meer containers die samenwerken en dezelfde netwerk- en opslagresources delen.

Het kernpunt: Kubernetes controleert continu of het aantal draaiende Pods overeenkomt met `replicas`. Crasht een Pod, dan start Kubernetes een nieuwe. U hoeft niet zelf in te grijpen.

Stap 3: Verken de applicatie

`kubectl` is uw enige interface naar het cluster. Vrijwel alles wat u doet, gaat via dit commando.

Bekijk de status van uw Pods:

kubectl get pods

De output toont de naam van elke Pod, de status (`Running`, `Crashing`, `Pending`) en hoe vaak deze opnieuw is gestart. Ziet u `CrashLoopBackOff`, dan is er iets mis met de container zelf — check de logs:

kubectl logs deployment/nginx-demo

Wilt u details over een specifieke Pod, bijvoorbeeld waarom deze op een bepaalde node draait of welke events eraan voorafgingen:

kubectl describe pods

Neem de tijd om deze drie commando's te leren. Ze vormen negentig procent van uw dagelijkse interactie met het cluster.

Stap 4: Ontsluit de applicatie

Pods zijn standaard alleen binnen het cluster bereikbaar. Ze krijgen een intern IP-adres dat verandert zodra de Pod opnieuw start. Voor externe toegang definieert u een Service — een stabiel toegangspunt dat naar de Pods achter een label verwijst.

Maak `service.yaml`:

apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  type: NodePort
  selector:
    app: nginx-demo
  ports:
<ul><li>port: 80</li></ul>
    targetPort: 80
    nodePort: 30080

En activeer hem:

kubectl apply -f service.yaml

NodePort maakt de applicatie bereikbaar via poort 30080 op het IP-adres van uw Minikube-node:

minikube service nginx-service --url

Dit opent uw browser naar het juiste adres.

Er zijn drie Service-types. ClusterIP is alleen intern bereikbaar — handig voor communicatie tussen microservices. NodePort werkt voor testen maar is niet geschikt voor productie. LoadBalancer geeft u een extern IP-adres via uw cloudprovider, maar werkt niet in Minikube zonder extra configuratie.

Begin met NodePort. Het is lelijk maar functioneel, en u leert er het concept mee zonder cloudvendor-specifieke instellingen.

Stap 5: Schaal de applicatie

Met `kubectl scale` past u het aantal replica's aan:

kubectl scale deployment/nginx-demo --replicas=5

Kubernetes start nu drie extra Pods op — of stopt er twee als u terugschaalt naar drie. Dit werkt handmatig, maar u kunt ook horizontale autoscaling instellen op basis van CPU-gebruik:

kubectl autoscale deployment/nginx-demo --min=2 --max=10 --cpu-percent=70

Dit kost een extra component: de metrics-server. Die verzamelt CPU- en geheugengegevens van de nodes. Zonder metrics-server doet het autoscale-commando niets.

Schaal niet te vroeg automatisch. Handmatig schalen leert u hoeveel resources uw applicatie daadwerkelijk nodig heeft. Automatisch schalen op basis van verkeer dat u niet begrijpt, leidt tot kosten die u niet verwacht — zeker als u later naar een cloudprovider verhuist.

Stap 6: Update de applicatie

Wanneer u een nieuwe versie van uw image hebt, werkt u het manifest bij en past u het opnieuw toe:

kubectl set image deployment/nginx-demo nginx=nginx:1.28

Kubernetes voert een rolling update uit: het vervangt oude Pods geleidelijk door nieuwe, zonder dat de service onderbroken wordt. Controleer de voortgang:

kubectl rollout status deployment/nginx-demo

Gaat er iets mis, dan draait u de update terug:

kubectl rollout undo deployment/nginx-demo

Deze drie commando's — set, status, undo — vormen uw deployment-workflow. Het is minder geavanceerd dan GitOps-tools zoals ArgoCD, maar voor een klein team is het vaak genoeg.

Verificatie

Controleer dat alles naar behoren draait:

kubectl get pods,deployments,services

De output moet vijf draaiende Pods tonen (als u naar vijf hebt geschaald), een Deployment met de gewenste status en een Service met een toegewezen poort.

Tenslotte: haal de applicatie op via de Service:

curl $(minikube service nginx-service --url)

U zou de standaard nginx-pagina moeten zien.

Veelgestelde problemen

Pod blijft in `Pending`-status hangen. De node heeft onvoldoende resources. Controleer met `kubectl describe pod` of er een resource-limiet wordt overschreden, en verhoog het geheugen van Minikube: `minikube stop`, dan `minikube start --memory=6144`.

`CrashLoopBackOff` bij nginx. De container start en crasht herhaaldelijk. Check de logs met `kubectl logs deployment/nginx-demo`. Vaak is het een verkeerde image-tag of een configuratiefout in een mounted volume.

`kubectl` kan geen verbinding maken met het cluster. Uw lokale `kubectl` praat tegen een andere context dan uw Minikube-cluster. Stel de context in met:

kubectl config use-context minikube

De officiële Kubernetes-documentatie is opgedeeld in Concepts, Tasks, Tutorials en References. De Concepts-sectie legt uit hoe dingen werken, Tasks geven stapsgewijze instructies, Tutorials combineren beide tot scenario's, en References bevatten de droge API-details. Begin met de Concepts over Pods en Services, niet met de References — die leest u pas als u iets specifieks moet opzoeken.

Kubernetes vermindert geen complexiteit, het verplaatst die. U ruilt handmatige deployment-scripts in voor een systeem dat u moet leren begrijpen voordat het u iets oplevert. De vraag is niet of u het kunt draaien — dat kan iedereen met een tutorial — maar of u het kunt onderhouden als uw applicatie groeit en de eerste onverklaarbare foutmelding opduikt. Dat is het moment waarop de investering zich terugbetaalt, of niet.