Container Orchestratie met Kubernetes: Setup Gids 2026

SAMENVATTING

Docker Container Orchestratie met Kubernetes: Complete Setup Gids 2026

Beheers Docker containers op schaal met Kubernetes orchestratie, van basis setup tot productie-ready deployments.

Keywords: Kubernetes orchestratie, Docker containers, Cloud deployment

ACHTERGROND

Waarom Container Orchestratie Essentieel is in 2026

In 2026 draait 89% van alle nieuwe enterprise applicaties in containers, waarbij Kubernetes de facto standaard is geworden voor orchestratie. Bedrijven zoals Netflix beheren meer dan 100.000 containers dagelijks via Kubernetes, wat de schaal en complexiteit van moderne applicaties illustreert.

Docker containers hebben de manier waarop we software ontwikkelen en deployen revolutionair veranderd. Echter, het beheren van tientallen, honderden of duizenden containers handmatig is praktisch onmogelijk. Hier komt Kubernetes (K8s) om de hoek kijken als orchestratie-platform dat:

Automatische scaling — Containers worden automatisch opgeschaald bij verhoogde load. Spotify schaalt bijvoorbeeld automatisch van 50 naar 500 pod replicas tijdens piekmomenten in muziekstreaming.

Self-healing capabilities — Gefaalde containers worden automatisch vervangen. Google rapporteert dat hun Kubernetes clusters 99.95% uptime behalen door automatische recovery.

Rolling updates — Nieuwe versies worden geleidelijk uitgerold zonder downtime. Airbnb deployed dagelijks 500+ keer naar productie met zero-downtime via Kubernetes rolling updates.

De statistieken spreken voor zich: volgens de CNCF Survey 2025 gebruikt 96% van de organisaties containers in productie, waarvan 87% Kubernetes als orchestratie-platform heeft gekozen. De gemiddelde enterprise beheert 847 containers in productie, wat handmatig beheer praktisch onmogelijk maakt.

FUNDAMENTALS

Kubernetes Fundamentals: Van Docker naar Orchestratie

Kubernetes bouwt voort op Docker containers maar introduceert een geheel nieuwe abstractielaag. Waar Docker individuele containers beheert, orchestreert Kubernetes complete applicatie-ecosystemen bestaande uit meerdere interconnected services.

Kubernetes Architectuur Overzicht

Kubernetes Resources: Pods, Services en Deployments

Kubernetes introduceert verschillende resource types die samen een applicatie vormen. Deze resources worden gedefinieerd in YAML manifests en beheerd via de Kubernetes API.

apiVersion: v1
kind: Pod
metadata:
  name: nginx-pod
  labels:
    app: nginx
spec:
  containers:
  - name: nginx
    image: nginx:1.21
    ports:
    - containerPort: 80
    resources:
      limits:
        memory: "128Mi"
        cpu: "500m"
      requests:
        memory: "64Mi"
        cpu: "250m"
    livenessProbe:
      httpGet:
        path: /
        port: 80
      initialDelaySeconds: 30
      periodSeconds: 10

In productie worden Pods zelden direct aangemaakt. In plaats daarvan gebruikt men Deployments die Pods beheren en features bieden zoals rolling updates, rollbacks en replica management.

SETUP

Kubernetes Cluster Setup: Lokaal en Cloud

Voor ontwikkeling en testing zijn er verschillende opties om een Kubernetes cluster op te zetten. We behandelen zowel lokale development clusters als productie-ready cloud setups.

Lokale Development met Kind (Kubernetes in Docker)

# Kind installeren op macOS
brew install kind

# Linux installatie
curl -Lo ./kind https://kind.sigs.k8s.io/dl/v0.20.0/kind-linux-amd64
chmod +x ./kind
sudo mv ./kind /usr/local/bin/kind

# Cluster configuratie bestand maken
cat <<EOF > kind-config.yaml
kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
nodes:
- role: control-plane
- role: worker
- role: worker
EOF

# Multi-node cluster aanmaken
kind create cluster --config kind-config.yaml --name development

# Cluster status controleren
kubectl cluster-info

# Nodes bekijken
kubectl get nodes

# Context instellen (automatisch door Kind)
kubectl config current-context

# Namespace aanmaken voor development
kubectl create namespace development

# Default namespace instellen
kubectl config set-context --current --namespace=development

Cloud Kubernetes Services: AKS, EKS, GKE

Voor productie workloads bieden cloud providers managed Kubernetes services die de complexiteit van cluster management wegnemen. De drie grootste providers hebben elk hun eigen implementatie:

DEPLOYMENT

Docker Images Deployen naar Kubernetes

Het deployen van Docker containers naar Kubernetes vereist een andere mindset dan directe Docker runs. In plaats van containers direct te starten, definiëren we desired state via YAML manifests.

Van Docker Run naar Kubernetes Deployment

Laten we een praktisch voorbeeld bekijken: het deployen van een Node.js applicatie die lokaal draait via Docker.

# Traditionele Docker run
docker run -d \
  --name nodejs-app \
  -p 3000:3000 \
  -e NODE_ENV=production \
  --restart unless-stopped \
  myregistry/nodejs-app:v1.2.0

Deze Docker run configuratie wordt in Kubernetes getransformeerd naar een Deployment manifest dat dezelfde functionaliteit biedt plus additional orchestratie features:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nodejs-app
  labels:
    app: nodejs-app
spec:
  replicas: 3
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxUnavailable: 1
      maxSurge: 1
  selector:
    matchLabels:
      app: nodejs-app
  template:
    metadata:
      labels:
        app: nodejs-app
    spec:
      containers:
      - name: nodejs-app
        image: myregistry/nodejs-app:v1.2.0
        ports:
        - containerPort: 3000
        env:
        - name: NODE_ENV
          value: "production"
        resources:
          requests:
            memory: "256Mi"
            cpu: "250m"
          limits:
            memory: "512Mi"
            cpu: "500m"
        livenessProbe:
          httpGet:
            path: /health
            port: 3000
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /ready
            port: 3000
          initialDelaySeconds: 5
          periodSeconds: 5

Container Registry Integration

Kubernetes haalt images uit container registries. Voor private registries moet je authentication configureren via Secrets. Dit is essentieel voor productie deployments waar proprietary code wordt gebruikt.

# Docker registry secret aanmaken
kubectl create secret docker-registry regcred \
  --docker-server=myregistry.com \
  --docker-username=myuser \
  --docker-password=mypassword \
  [email protected]

# Secret gebruiken in Deployment
spec:
  template:
    spec:
      imagePullSecrets:
      - name: regcred
      containers:
      - name: nodejs-app
        image: myregistry.com/nodejs-app:v1.2.0

NETWORKING

Service Discovery en Load Balancing

Kubernetes Services vormen de backbone van inter-container communicatie. Ze bieden stable networking endpoints voor dynamische Pod sets en fungeren als internal load balancers.

Service Types en Use Cases

Praktische Service Implementatie

# Frontend LoadBalancer Service (external access)
apiVersion: v1
kind: Service
metadata:
  name: frontend-service
spec:
  type: LoadBalancer
  ports:
  - port: 80
    targetPort: 3000
    protocol: TCP
  selector:
    app: frontend
---
# API ClusterIP Service (internal)
apiVersion: v1
kind: Service
metadata:
  name: api-service
spec:
  type: ClusterIP
  ports:
  - port: 8080
    targetPort: 8080
    protocol: TCP
  selector:
    app: api
---
# Database Service (internal)
apiVersion: v1
kind: Service
metadata:
  name: postgres-service
spec:
  type: ClusterIP
  ports:
  - port: 5432
    targetPort: 5432
    protocol: TCP
  selector:
    app: postgres

Service Discovery in Kubernetes werkt via DNS. Elke Service krijgt automatisch een DNS entry in het formaat service-name.namespace.svc.cluster.local. Dit maakt inter-service communicatie eenvoudig:

# Frontend container configuratie
env:
- name: API_URL
  value: "http://api-service:8080"
- name: POSTGRES_HOST
  value: "postgres-service"
- name: POSTGRES_PORT
  value: "5432"

# Database connection string
- name: DATABASE_URL
  value: "postgresql://user:pass@postgres-service:5432/mydb"

STORAGE

Persistent Storage en ConfigMaps

Containers zijn by design stateless en ephemeral. Voor applicaties die data persistence vereisen, biedt Kubernetes Persistent Volumes (PV) en Persistent Volume Claims (PVC). ConfigMaps en Secrets beheren configuratie data gescheiden van container images.

Persistent Volume Claims voor Database Storage

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: postgres-pvc
spec:
  accessModes:
    - ReadWriteOnce
  storageClassName: gp2  # AWS EBS
  resources:
    requests:
      storage: 20Gi
---
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: postgres
spec:
  serviceName: postgres-service
  replicas: 1
  selector:
    matchLabels:
      app: postgres
  template:
    metadata:
      labels:
        app: postgres
    spec:
      containers:
      - name: postgres
        image: postgres:13
        env:
        - name: POSTGRES_DB
          value: "myapp"
        - name: POSTGRES_USER
          value: "appuser"
        - name: POSTGRES_PASSWORD
          valueFrom:
            secretKeyRef:
              name: postgres-secret
              key: password
        volumeMounts:
        - name: postgres-storage
          mountPath: /var/lib/postgresql/data
        resources:
          requests:
            memory: "512Mi"
            cpu: "250m"
          limits:
            memory: "1Gi"
            cpu: "500m"
      volumes:
      - name: postgres-storage
        persistentVolumeClaim:
          claimName: postgres-pvc

ConfigMaps voor Application Configuration

ConfigMaps scheiden configuratie van application code. Dit volgt de twelve-factor app methodology en maakt environment-specific deployments mogelijk zonder image rebuilds.

# ConfigMap met key-value pairs
apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config
data:
  database_url: "postgresql://appuser@postgres-service:5432/myapp"
  redis_url: "redis://redis-service:6379"
  log_level: "info"
  max_connections: "100"
  # Complete configuratie bestand
  nginx.conf: |
    server {
      listen 80;
      server_name _;
      location / {
        proxy_pass http://api-service:8080;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
      }
    }
---
# Pod die ConfigMap gebruikt
apiVersion: v1
kind: Pod
metadata:
  name: app-pod
spec:
  containers:
  - name: app
    image: myapp:v1.0
    # Environment variabelen van ConfigMap
    envFrom:
    - configMapRef:
        name: app-config
    # Specifieke key als environment variabele
    env:
    - name: DATABASE_URL
      valueFrom:
        configMapKeyRef:
          name: app-config
          key: database_url
    # ConfigMap als volume mount
    volumeMounts:
    - name: config-volume
      mountPath: /etc/nginx
  volumes:
  - name: config-volume
    configMap:
      name: app-config
      items:
      - key: nginx.conf
        path: nginx.conf

Storage Classes en Dynamic Provisioning

Cloud providers bieden verschillende storage types via Storage Classes. Dynamic provisioning creëert automatisch storage volumes based on PVC requests, wat operationele overhead drastisch reduceert.

# High-performance SSD storage class
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: fast-ssd
provisioner: ebs.csi.aws.com
parameters:
  type: gp3
  iops: "3000"
  throughput: "125"
allowVolumeExpansion: true
---
# Cost-optimized HDD storage class
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: slow-hdd
provisioner: ebs.csi.aws.com
parameters:
  type: sc1  # Cold HDD
allowVolumeExpansion: true

MONITORING

Monitoring en Troubleshooting

Effectieve monitoring is cruciaal voor productie Kubernetes clusters. Zonder proper observability ben je blind voor performance issues, resource bottlenecks en security incidents. We behandelen zowel built-in Kubernetes tools als enterprise monitoring solutions.

kubectl Diagnostics Commands

kubectl biedt uitgebreide diagnostic capabilities voor eerste-lijn troubleshooting. Deze commands zijn essentieel voor elke Kubernetes operator.

# Cluster overview
kubectl get nodes -o wide
kubectl top nodes  # Requires metrics-server

# Pod troubleshooting
kubectl get pods --all-namespaces
kubectl describe pod <pod-name>
kubectl logs <pod-name> -f
kubectl logs <pod-name> -c <container-name> --previous

# Resource monitoring
kubectl top pods --all-namespaces
kubectl get events --sort-by=.metadata.creationTimestamp

# Service debugging
kubectl get svc --all-namespaces
kubectl describe svc <service-name>
kubectl get endpoints

# Storage troubleshooting
kubectl get pv,pvc
kubectl describe pvc <pvc-name>

Prometheus en Grafana Stack

Voor enterprise monitoring is de Prometheus-Grafana stack de industry standard. Prometheus verzamelt metrics, Grafana visualiseert data, en Alertmanager handelt notifications af. De CNCF rapporteert dat 87% van de organisaties deze stack gebruikt.

# Prometheus Community Helm repository toevoegen
helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
helm repo update

# Monitoring namespace aanmaken
kubectl create namespace monitoring

# Prometheus stack installeren
helm install prometheus prometheus-community/kube-prometheus-stack \
  --namespace monitoring \
  --set prometheus.prometheusSpec.retention=15d \
  --set prometheus.prometheusSpec.storageSpec.volumeClaimTemplate.spec.resources.requests.storage=50Gi \
  --set grafana.adminPassword=admin123 \
  --set alertmanager.alertmanagerSpec.retention=120h

# Services port-forwarden voor local access
kubectl port-forward -n monitoring svc/prometheus-kube-prometheus-prometheus 9090:9090
kubectl port-forward -n monitoring svc/prometheus-grafana 3000:80

Custom Application Metrics

Naast infrastructure metrics zijn application-specific metrics cruciaal. ServiceMonitors configureren automatische scraping van custom metrics endpoints in je applicaties.

# ServiceMonitor voor custom app metrics
apiVersion: monitoring.coreos.com/v1
kind: ServiceMonitor
metadata:
  name: nodejs-app-metrics
  namespace: monitoring
spec:
  selector:
    matchLabels:
      app: nodejs-app
  endpoints:
  - port: metrics
    path: /metrics
    interval: 30s
---
# Service met metrics endpoint
apiVersion: v1
kind: Service
metadata:
  name: nodejs-app-metrics
  labels:
    app: nodejs-app
spec:
  ports:
  - name: metrics
    port: 9090
    targetPort: 9090
  - name: http
    port: 3000
    targetPort: 3000
  selector:
    app: nodejs-app

PRODUCTIE

Productie Best Practices en Security

Productie Kubernetes clusters vereisen een fundamenteel andere mindset dan development environments. Security, compliance, disaster recovery en cost optimization worden kritische succesfactoren die je applicatie kunnen maken of breken.

Security Hardening Checklist

Een praktisch voorbeeld van Network Policy implementatie voor een web applicatie met database backend:

# Network Policy voor database isolation
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: database-access-policy
spec:
  podSelector:
    matchLabels:
      app: postgres
  policyTypes:
  - Ingress
  - Egress
  ingress:
  - from:
    - podSelector:
        matchLabels:
          app: api-server
    ports:
    - protocol: TCP
      port: 5432
  egress:
  - to: []  # Allow all egress for updates, DNS, etc.
---
# Pod Security Context (restricted)
apiVersion: v1
kind: Pod
metadata:
  name: secure-app
spec:
  securityContext:
    runAsNonRoot: true
    runAsUser: 10001
    fsGroup: 10001
    seccompProfile:
      type: RuntimeDefault
  containers:
  - name: app
    image: myapp:v1.0
    securityContext:
      allowPrivilegeEscalation: false
      readOnlyRootFilesystem: true
      runAsNonRoot: true
      capabilities:
        drop:
        - ALL

Resource Management en Cost Optimization

Kubernetes clusters kunnen kostbaar worden zonder proper resource management. Volgens FinOps studies verspillen organisaties gemiddeld 35% van hun cloud budget door overprovisioning en idle resources.

# Resource Quota per namespace
apiVersion: v1
kind: ResourceQuota
metadata:
  name: development-quota
  namespace: development
spec:
  hard:
    requests.cpu: "4"
    requests.memory: 8Gi
    limits.cpu: "8"
    limits.memory: 16Gi
    pods: "10"
    persistentvolumeclaims: "4"
---
# LimitRange voor default resource limits
apiVersion: v1
kind: LimitRange
metadata:
  name: default-limits
  namespace: development
spec:
  limits:
  - default:
      cpu: 500m
      memory: 512Mi
    defaultRequest:
      cpu: 200m
      memory: 256Mi
    type: Container

High Availability en Disaster Recovery

Productie clusters vereisen 99.9%+ uptime. Dit wordt bereikt door multi-zone deployments, automated backups en tested disaster recovery procedures. Netflix behaalt 99.97% uptime met hun chaos engineering approach.

# Multi-zone Deployment met Anti-Affinity
apiVersion: apps/v1
kind: Deployment
metadata:
  name: web-app
spec:
  replicas: 6
  selector:
    matchLabels:
      app: web-app
  template:
    spec:
      affinity:
        podAntiAffinity:
          preferredDuringSchedulingIgnoredDuringExecution:
          - weight: 100
            podAffinityTerm:
              labelSelector:
                matchExpressions:
                - key: app
                  operator: In
                  values:
                  - web-app
              topologyKey: failure-domain.beta.kubernetes.io/zone
      containers:
      - name: web-app
        image: webapp:v2.1.0
---
# Pod Disruption Budget
apiVersion: policy/v1
kind: PodDisruptionBudget
metadata:
  name: web-app-pdb
spec:
  minAvailable: 3
  selector:
    matchLabels:
      app: web-app

REFERENTIES

Kubernetes Official Documentation
Helm Package Manager
Prometheus Monitoring
Kind Local Kubernetes
CNCF Container Surveys

Klaar om je containers naar de volgende level te tillen!

Met deze complete Kubernetes gids heb je alle tools om Docker containers professioneel te orchestreren. Van lokale development tot enterprise productie — Kubernetes transformeert hoe we moderne applicaties deployen en beheren.

Welke Kubernetes feature ga jij als eerste implementeren? Deel je ervaringen in de comments!