Wat is het verschil tussen Docker en Kubernetes?

Docker is een containerization platform dat applicaties verpakt in containers. Kubernetes is een orchestratie platform dat deze containers beheert, schaalt en coördineert over een cluster van machines. Docker creëert containers, Kubernetes beheert ze.

Hoe moeilijk is het om Kubernetes te leren?

De basis van Kubernetes is te leren in 2-4 weken, maar beheersing vergt 3-6 maanden praktijkervaring. Begin met Minikube voor lokale ontwikkeling, volg de officiële tutorials en oefen met praktische projecten voor de beste leercurve.

Is Kubernetes alleen voor grote organisaties?

Nee, Kubernetes kan ook waardevol zijn voor kleinere organisaties. Managed services zoals AKS, EKS en GKE maken Kubernetes toegankelijk voor MKB. Microservices, CI/CD automatisering en cloud native ontwikkeling zijn voor elke organisatie relevant.

Wat zijn de belangrijkste Kubernetes commando's?

Belangrijke commando's zijn: kubectl get pods, kubectl apply -f, kubectl describe, kubectl logs, kubectl exec, kubectl scale, kubectl rollout en kubectl port-forward. Deze dekken 80% van dagelijkse Kubernetes operaties.

Kubernetes Basics

Laatst bijgewerkt: 9 september 2025

Leestijd: 14 minuten

Kubernetes, container orchestration, k8s, docker, microservices, cloud native

Een complete beginnersgids over Kubernetes: leer de basisprincipes van container orchestration voor het beheren, schalen en automatiseren van moderne applicaties.

Definitie

Kubernetes (ook wel K8s genoemd) is een open-source container orchestratie platform voor het automatiseren van deployment, scaling en beheer van containerized applicaties. Het groepeert containers die een applicatie vormen in logische eenheden voor eenvoudig beheer en discovery.

Waarom Kubernetes?

Kubernetes lost kritieke uitdagingen op in moderne applicatie-ontwikkeling:

Service discovery en load balancing: Automatische verdeling van verkeer over containers
Storage orchestration: Automatisch mounten van storage systemen
Automatische rollouts en rollbacks: Gecontroleerde updates en terugdraaien
Automatisch binpacking: Efficient plaatsen van containers op beschikbare resources
Self-healing: Automatisch herstarten, vervangen en schedulen van containers
Secret en configuration management: Veilig beheren van gevoelige informatie

Belangrijkste Inzicht

Kubernetes is niet alleen een tool voor grote organisaties. Met managed services zoals Google Kubernetes Engine (GKE), Amazon EKS en Azure AKS is Kubernetes toegankelijk geworden voor organisaties van elke omvang. Het stelt ontwikkelaars in staat zich te focussen op code, niet op infrastructuur.

Kubernetes vs. Traditionele Deployment

Aspect	Traditionele Deployment	Kubernetes
Schaling	Handmatig, traag	Automatisch, binnen seconden
Beschikbaarheid	Single point of failure	High availability, self-healing
Resource gebruik	Overprovisioning (40-60% idle)	Efficient binpacking (>90% gebruik)
Deployment	Downtime tijdens updates	Zero-downtime rolling updates
Omgevingsconsistentie	"Works on my machine"	Identiek in dev, test, prod

Kubernetes Architectuur

Master Node

Het controle vlak dat het cluster beheert:

API Server
Front-end voor Kubernetes control plane

etcd
Consistent en hoog beschikbare key-value store

Scheduler
Wijst nieuw gemaakte pods toe aan nodes

Controller Manager
Beheert controller processen

Worker Node

De machines waar containers daadwerkelijk draaien:

Kubelet
Zorgt dat containers draaien in een pod

Kube Proxy
Netwerk proxy die netwerkregels handhaaft

Container Runtime
Software die containers uitvoert (Docker, containerd)

Kernconcepten

Pod - De kleinste deployable eenheid

Web Container
Nginx

App Container
Node.js

Sidecar Container
Log Shipper

Een pod kan één of meerdere containers bevatten die resources delen

Service - Netwerk endpoint voor pods

Een abstractie die een logische set pods definieert en een policy voor toegang:

ClusterIP: Interne service binnen het cluster
NodePort: Maakt service beschikbaar op node's IP
LoadBalancer: Creëert een externe load balancer
ExternalName: Mapt service naar DNS naam

Deployment - Beheert pod replicatie en updates

Biedt declaratieve updates voor pods en ReplicaSets:

Rolling updates en rollbacks
Scaling up/down
Paused deployments
Version history

Praktische Kubernetes YAML Voorbeelden

Eenvoudige Pod Definitie

# simple-pod.yaml
apiVersion: v1
kind: Pod
metadata:
  name: nginx-pod
  labels:
    app: nginx
spec:
  containers:
  - name: nginx-container
    image: nginx:1.21
    ports:
    - containerPort: 80

Deployment met Rolling Updates

# deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: webapp-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: webapp
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 0
  template:
    metadata:
      labels:
        app: webapp
    spec:
      containers:
      - name: webapp
        image: myregistry/webapp:v1.2
        ports:
        - containerPort: 8080
        resources:
          requests:
            memory: "64Mi"
            cpu: "250m"
          limits:
            memory: "128Mi"
            cpu: "500m"

Service voor Load Balancing

# service.yaml
apiVersion: v1
kind: Service
metadata:
  name: webapp-service
spec:
  type: LoadBalancer
  selector:
    app: webapp
  ports:
  - port: 80
    targetPort: 8080
    protocol: TCP

Essentiële kubectl Commando's

Commando	Beschrijving	Voorbeeld
kubectl get	Resources opvragen	kubectl get pods
kubectl apply	Configuratie toepassen	kubectl apply -f deployment.yaml
kubectl describe	Details van resource	kubectl describe pod my-pod
kubectl logs	Container logs bekijken	kubectl logs my-pod
kubectl exec	Commando in container	kubectl exec -it my-pod -- bash
kubectl scale	Replicas aanpassen	kubectl scale deployment webapp --replicas=5
kubectl rollout	Deployment beheren	kubectl rollout status deployment/webapp
kubectl port-forward	Poort doorsturen	kubectl port-forward pod/my-pod 8080:80

Kubernetes Leerpad

Fundamentals (Week 1-2)

Begrijp basisconcepten: pods, services, deployments, namespaces. Installeer Minikube en oefen met kubectl.

Configuration (Week 3-4)

Leer ConfigMaps, Secrets, Persistent Volumes. Implementeer applicatie configuratie en storage.

Networking (Week 5-6)

Master service discovery, ingress controllers, network policies. Configureer interne en externe toegang.

Advanced Topics (Week 7-8)

Verken StatefulSets, DaemonSets, Helm charts, operators. Implementeer stateful applicaties en automatisering.

Kubernetes Tools en Ecosystem

Categorie	Tools	Doel
Local Development	Minikube, Kind, Docker Desktop	Lokale Kubernetes clusters
Package Management	Helm, Kustomize	Kubernetes applicatie pakketten
CI/CD Integration	ArgoCD, Flux, Jenkins X	GitOps en deployment automatisering
Monitoring	Prometheus, Grafana, Datadog	Cluster en applicatie monitoring
Security	Falco, Trivy, Kyverno	Security scanning en policy enforcement
Managed Services	GKE, EKS, AKS, DigitalOcean	Beheerde Kubernetes in de cloud

Real-world Case Study: E-commerce Platform

Uitdaging: Een groeiend e-commerce platform had problemen met schaling tijdens piekmomenten, handmatige deployments en inconsistenties tussen ontwikkelomgevingen.

Oplossing: Kubernetes migratie met:

Microservices architectuur in containers
Autoscaling met HPA (Horizontal Pod Autoscaler)
GitOps workflow met ArgoCD
Service mesh voor communicatie tussen services

Resultaat: 95% reductie in deployment tijd, automatische schaling van 10 naar 100 pods tijdens pieken, en 99.9% beschikbaarheid.

Veelgemaakte Kubernetes Fouten

         Beginners Valkuilen
        Geen resource limits: Containers gebruiken alle beschikbare resources
Hardcoded configuraties: Gebruik ConfigMaps en Secrets
Stateless apps behandelen als stateful: Gebruik StatefulSets voor databases
Geen readiness/liveness probes: Kubernetes weet niet of je app gezond is
Kubernetes als VM's behandelen: Denk in pods en services, niet in servers
Geen monitoring: Je kunt niet beheren wat je niet meet

      

Kubernetes Best Practices

Development Best Practices

Gebruik namespaces voor resource isolatie
Implementeer resource requests en limits
Configureer readiness en liveness probes
Gebruik kleinere container images
Implementeer health checks en graceful shutdown

Operations Best Practices

Implementeer pod anti-affinity voor hoge beschikbaarheid
Gebruik network policies voor security
Monitor cluster metrics en applicatie logs
Implementeer backup strategie voor etcd
Gebruik role-based access control (RBAC)

Kubernetes voor Data Engineering

Data Pipelines op Kubernetes

Kubernetes wordt steeds populairder voor data workloads:

Apache Spark: Spark Operator voor distributed processing
Apache Airflow: Workflow orchestration in Kubernetes
JupyterHub: Multi-user data science omgeving
MLflow: Machine learning experiment tracking
Kafka: Streaming platform met Strimzi operator

Spark Job op Kubernetes

apiVersion: "sparkoperator.k8s.io/v1beta2"
kind: SparkApplication
metadata:
  name: data-processing-job
  namespace: data-team
spec:
  type: Scala
  mode: cluster
  image: "gcr.io/spark-operator/spark:v3.1.1"
  mainClass: org.example.DataProcessor
  mainApplicationFile: "local:///opt/spark/examples/jars/data-processor.jar"
  sparkVersion: "3.1.1"
  restartPolicy:
    type: OnFailure
  driver:
    cores: 1
    memory: "512m"
  executor:
    cores: 1
    instances: 3
    memory: "512m"