Kubernetes voor Beginners: Deploy je Eerste App in 2026

SAMENVATTING

Kubernetes voor Beginners: Je Eerste Applicatie Deployen in 2026

Een stap-voor-stap gids om je eerste containerized applicatie te deployen op Kubernetes (K8s) in 2026.

Keywords: Kubernetes, K8s, containerisatie

ACHTERGROND

De Noodzaak van Kubernetes in 2026

In de dynamische wereld van softwareontwikkeling en IT-infrastructuur is de complexiteit van applicaties exponentieel toegenomen. Waar we voorheen monolithische architecturen hadden, zien we in 2026 een sterke verschuiving naar microservices, serverless computing en gedistribueerde systemen. Deze moderne architecturen bieden ongekende schaalbaarheid en flexibiliteit, maar brengen ook nieuwe uitdagingen met zich mee op het gebied van beheer, deployment en operatie. Hier komt Kubernetes (vaak afgekort als K8s) om de hoek kijken – een open-source platform dat is ontworpen om de automatisering van de deployment, schaalbaarheid en het beheer van containerized applicaties te vereenvoudigen.

Kubernetes is inmiddels de de facto standaard geworden voor container-orkestratie, ondersteund door alle grote cloudproviders zoals Google Cloud, Amazon Web Services (AWS) en Microsoft Azure. Het stelt ontwikkelaars en operations-teams in staat om applicaties te bouwen die veerkrachtiger, schaalbaarder en gemakkelijker te beheren zijn. Denk aan applicaties die miljoenen gebruikers bedienen, zoals e-commerceplatforms, streamingdiensten of complexe AI/ML-workloads. Zonder een robuust orkestratieplatform zoals Kubernetes zou het handmatig beheren van honderden of duizenden containers een onmogelijke taak zijn.

De adoptie van Kubernetes is in 2026 verder gestegen, met naar schatting meer dan 85% van de Fortune 500-bedrijven die het platform gebruiken voor kritieke workloads. Dit komt door de bewezen voordelen: verhoogde uptime, efficiënter gebruik van resources, snellere deployment-cycli en een betere scheiding van zorgen tussen ontwikkeling en operations. Voor beginners kan de leercurve intimiderend lijken, maar de investering loont zich ruimschoots. Deze gids is speciaal ontworpen om je door de eerste stappen te leiden, zodat je in 2026 met vertrouwen je eerste applicatie kunt deployen op Kubernetes.

De overgang naar cloud-native ontwikkeling heeft de vraag naar efficiënte tooling voor infrastructuurbeheer aangewakkerd. Kubernetes vult deze leemte perfect door een abstractielaag te bieden bovenop de onderliggende infrastructuur. Dit betekent dat ontwikkelaars zich kunnen concentreren op het schrijven van code, terwijl Kubernetes de details van het draaien van die code in de gaten houdt, zoals het toewijzen van compute-resources, netwerkconfiguratie en opslag. Het stroomlijnt de processen van Continuous Integration/Continuous Deployment (CI/CD), waardoor teams in staat zijn om sneller te innoveren en updates met minder risico uit te rollen. De kracht van Kubernetes ligt in zijn vermogen om een declaratief model te hanteren: je beschrijft de gewenste staat van je applicatie, en Kubernetes zorgt ervoor dat deze staat wordt bereikt en gehandhaafd.

KERNINHOUD

Kubernetes Basisconcepten en Architectuur

Voordat we een applicatie deployen, is het essentieel om de fundamentele concepten en de architectuur van Kubernetes te begrijpen. Een Kubernetes-cluster bestaat uit een set worker machines, genaamd Nodes, en een Control Plane die deze Nodes beheert. Samen vormen ze een robuuste omgeving voor het draaien van containerized applicaties.

Kubernetes Cluster Architectuur

Een typisch Kubernetes-cluster bestaat uit twee hoofdcomponenten:

• 1. Control Plane (voorheen Master Node): Dit is de “hersenen” van het cluster. Het beheert de worker nodes en de Pods in het cluster. De Control Plane bestaat uit verschillende componenten:
• kube-apiserver: De front-end voor de Kubernetes Control Plane. Alle communicatie (intern en extern) verloopt via de API-server.
• etcd: Een consistente en zeer beschikbare sleutel-waarde-store die alle clusterdata opslaat. Dit is de “enige bron van waarheid” voor de clusterstaat.
• kube-scheduler: Bewaakt nieuwe Pods zonder toegewezen node en selecteert een node waarop ze moeten draaien.
• kube-controller-manager: Draait controller-processen. Bijvoorbeeld, de Deployment controller beheert Deployments en de ReplicaSet controller zorgt ervoor dat het gewenste aantal Pods draait.
• 2. Worker Nodes: Dit zijn de machines (virtueel of fysiek) waar de daadwerkelijke applicatiecontainers draaien. Elke worker node heeft de volgende componenten:
• kubelet: Een agent die op elke node draait. Het zorgt ervoor dat containers in een Pod draaien en gezond zijn.
• kube-proxy: Een netwerkproxy die draait op elke node en netwerkregels handhaaft. Het zorgt voor netwerkcommunicatie naar je Pods, zowel van binnen als van buiten het cluster.
• Container Runtime: De software die verantwoordelijk is voor het draaien van containers, zoals Docker, containerd of CRI-O.

Essentiële Kubernetes Objecten

Kubernetes werkt met verschillende objecten die de gewenste staat van je applicatie beschrijven. De belangrijkste zijn:

• Pods: De kleinste, meest elementaire deployeerbare unit in Kubernetes. Een Pod vertegenwoordigt een enkele instantie van een draaiende applicatie en kan één of meer containers bevatten die een gedeelde opslag en netwerkbronnen delen. Pods zijn efemeer; als een Pod sterft, wordt deze niet automatisch opnieuw gestart.
• Deployments: Een controller die verantwoordelijk is voor het declaratief beheer van Pods. Een Deployment specificeert hoeveel replica’s van een Pod moeten draaien en hoe updates moeten worden uitgerold (bijv. rolling updates). Als een Pod crasht, zorgt de Deployment ervoor dat een nieuwe Pod wordt gestart.
• Services: Een abstractie die een logische set Pods definieert en een beleid specificeert om toegang te krijgen tot deze Pods. Services zorgen voor netwerkconnectiviteit en load balancing voor je applicaties, zelfs als de onderliggende Pods worden gecreëerd, vernietigd of verplaatst. Typen services zijn onder andere ClusterIP, NodePort en LoadBalancer.
• Namespaces: Een manier om resources binnen een Kubernetes-cluster te partitioneren. Namespaces helpen bij het organiseren van projecten en teams in grotere clusters en bieden een scope voor namen.

Het begrijpen van deze concepten is cruciaal voor een succesvolle deployment. Kubernetes hanteert een declaratief model, wat betekent dat je de “gewenste staat” van je systeem beschrijft in YAML-bestanden, en Kubernetes werkt continu om die staat te bereiken en te handhaven. Dit is een fundamentele verschuiving van imperatief beheer (waarbij je stap voor stap commando’s geeft) en een van de belangrijkste redenen voor zijn populariteit.

KERNINHOUD

Je Eerste Applicatie Voorbereiden: Containerisatie met Docker

Voordat we een applicatie op Kubernetes kunnen deployen, moet deze gecontaineriseerd zijn. Docker is de meest populaire tool voor het bouwen en distribueren van containers. Een container bundelt een applicatie en al zijn afhankelijkheden (bibliotheken, runtime, configuratiebestanden) in één geïsoleerd pakket, waardoor het consistent draait, ongeacht de onderliggende infrastructuur.

De Applicatie: Een Eenvoudige Node.js Webserver

Laten we een zeer eenvoudige Node.js-applicatie gebruiken die “Hallo van Kubernetes!” teruggeeft op poort 3000. Maak een map genaamd my-kubernetes-app en daarin twee bestanden: app.js en package.json.

app.js:

const express = require('express');
const app = express();
const PORT = 3000;

app.get('/', (req, res) => {
  res.send('Hallo van Kubernetes!');
});

app.listen(PORT, () => {
  console.log(`Applicatie luistert op poort ${PORT}`);
});

package.json:

{
  "name": "my-kubernetes-app",
  "version": "1.0.0",
  "description": "Mijn eerste Kubernetes applicatie",
  "main": "app.js",
  "scripts": {
    "start": "node app.js"
  },
  "dependencies": {
    "express": "^4.19.2"
  }
}

Het Dockerfile maken

Nu maken we een Dockerfile in dezelfde map my-kubernetes-app. Dit bestand bevat instructies voor Docker om een containerimage te bouwen.

# Gebruik een officiële Node.js runtime als de basis image
FROM node:18-alpine

# Stel de werkdirectory in de container in
WORKDIR /app

# Kopieer package.json en package-lock.json naar de werkdirectory
COPY package*.json ./

# Installeer projectafhankelijkheden
RUN npm install

# Kopieer de rest van de applicatiecode naar de werkdirectory
COPY . .

# Exposeer poort 3000 zodat de applicatie toegankelijk is
EXPOSE 3000

# Definieer het commando om de applicatie te starten
CMD [ "npm", "start" ]

De Docker Image bouwen en pushen

Navigeer naar de map my-kubernetes-app in je terminal. Om de Docker image te bouwen, voer je het volgende commando uit:

docker build -t kwonnis/my-kubernetes-app:1.0.0 .

Vervang kwonnis door je eigen Docker Hub-gebruikersnaam. Na het bouwen moet je de image naar een containerregister pushen zodat Kubernetes deze kan ophalen. Docker Hub is een populaire keuze:

docker login
docker push kwonnis/my-kubernetes-app:1.0.0

Zorg ervoor dat je account een openbare repository toestaat, of configureer je Kubernetes-cluster om toegang te krijgen tot een privéregister als je dat gebruikt.

KERNINHOUD

Deployen op Kubernetes: Stap voor Stap

Nu onze applicatie is gecontaineriseerd en beschikbaar is in een register, kunnen we deze deployen op Kubernetes. Voor beginners is een lokale Kubernetes-omgeving zoals Minikube of Kind ideaal om te oefenen. In deze gids gebruiken we Minikube.

Stap 1: Minikube installeren en starten

Minikube draait een single-node Kubernetes-cluster op je lokale machine. Volg de instructies op de officiële Minikube-website voor jouw besturingssysteem. Zorg ervoor dat je ook kubectl hebt geïnstalleerd, de command-line tool voor het communiceren met Kubernetes-clusters.

minikube start --driver=docker

Controleer of Minikube correct draait:

minikube status

Stap 2: Deployment YAML maken

Een Deployment beschrijft hoe je applicatie draait (welke image, hoeveel replica’s). Maak een bestand genaamd deployment.yaml.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-kubernetes-app-deployment
  labels:
    app: my-kubernetes-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-kubernetes-app
  template:
    metadata:
      labels:
        app: my-kubernetes-app
    spec:
      containers:
      - name: my-kubernetes-app-container
        image: kwonnis/my-kubernetes-app:1.0.0
        ports:
        - containerPort: 3000
        imagePullPolicy: IfNotPresent # Gebruik deze voor lokale Minikube images

Stap 3: Service YAML maken

Een Service zorgt ervoor dat je applicatie toegankelijk is. We gebruiken een NodePort Service, die de applicatie exposeert op een statische poort op elke node van het cluster.

apiVersion: v1
kind: Service
metadata:
  name: my-kubernetes-app-service
spec:
  selector:
    app: my-kubernetes-app
  ports:
    - protocol: TCP
      port: 80
      targetPort: 3000
  type: NodePort

Stap 4: Configuratie toepassen

Pas de gemaakte YAML-bestanden toe op je Kubernetes-cluster met kubectl.

kubectl apply -f deployment.yaml
kubectl apply -f service.yaml

Stap 5: Deployment verifiëren

Controleer of de Pods en Services correct draaien:

kubectl get pods
kubectl get deployments
kubectl get services

De output zou er ongeveer zo uit moeten zien:

$ kubectl get pods
NAME                                        READY   STATUS    RESTARTS   AGE
my-kubernetes-app-deployment-78f94f79b-2c67t   1/1     Running   0          2m
my-kubernetes-app-deployment-78f94f79b-k9l2s   1/1     Running   0          2m
my-kubernetes-app-deployment-78f94f79b-p5x8z   1/1     Running   0          2m

$ kubectl get deployments
NAME                           READY   UP-TO-DATE   AVAILABLE   AGE
my-kubernetes-app-deployment   3/3     3            3           2m

$ kubectl get services
NAME                        TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)        AGE
kubernetes                  ClusterIP   10.96.0.1        <none>        443/TCP        2d
my-kubernetes-app-service   NodePort    10.101.123.234   <none>        80:30000/TCP   2m

Stap 6: Applicatie openen

Gebruik Minikube om de URL van je Service te krijgen:

minikube service my-kubernetes-app-service

Je zou nu “Hallo van Kubernetes!” in je browser moeten zien. Gefeliciteerd, je hebt zojuist je eerste applicatie op Kubernetes gedeployd in 2026!

PROBLEEMOPLOSSING

Veelvoorkomende Uitdagingen en Oplossingen

Als beginner in Kubernetes kom je waarschijnlijk een aantal veelvoorkomende problemen tegen. Hier zijn enkele van de meest voorkomende uitdagingen en hoe je ze kunt oplossen.

# Controleer de Pod-status en gebeurtenissen
kubectl get pods
kubectl describe pod <pod-naam>

# Verifieer de image-naam en tag in je deployment.yaml
# Zorg ervoor dat de image bestaat op Docker Hub of je privéregister
# Voor privéregisters: zorg voor correct geconfigureerde ImagePullSecrets
# Voor Minikube: zorg ervoor dat de image lokaal beschikbaar is of gebruik 'imagePullPolicy: Never' of 'IfNotPresent'
# Bij gebruik van Minikube Docker daemon:
# eval $(minikube docker-env)
# docker build -t my-kubernetes-app:1.0.0 . (zonder registry prefix)

# Haal de naam van de crashende Pod op
kubectl get pods

# Bekijk de logs van de Pod om de oorzaak van de crash te achterhalen
kubectl logs <pod-naam>

# Voor eerdere logs (als de Pod al meerdere keren is gecrasht)
kubectl logs <pod-naam> --previous

# Zorg ervoor dat je applicatie luistert op de verwachte poort binnen de container
# Controleer of alle omgevingsvariabelen correct zijn ingesteld
# Bouw de Docker image opnieuw als je code hebt gewijzigd en push deze

# Controleer de Service-details
kubectl describe service my-kubernetes-app-service

# Controleer de Deployment-details (specifiek de selectors)
kubectl describe deployment my-kubernetes-app-deployment

# Zorg ervoor dat de 'selector' in je service.yaml overeenkomt met de 'labels' in de template van je deployment.yaml
# Zorg ervoor dat 'targetPort' in je service.yaml overeenkomt met 'containerPort' in je deployment.yaml
# Controleer de 'type' van de service (NodePort, LoadBalancer, ClusterIP) en de bijbehorende toegangsmechanismen
# Voor Minikube, gebruik 'minikube service <service-naam>' om de URL te krijgen

PRAKTISCHE TOEPASSING

Monitoring en Schaalbaarheid

Een van de krachtigste aspecten van Kubernetes is het vermogen om applicaties automatisch te schalen en te monitoren. Dit zijn cruciale functies voor het handhaven van prestaties en beschikbaarheid in productieomgevingen.

Basis Monitoring met kubectl top

Voor rudimentaire monitoring van resourcegebruik (CPU en geheugen) kun je kubectl top gebruiken. Hiervoor moet wel de Metrics Server in je cluster draaien. In Minikube kun je deze eenvoudig inschakelen:

minikube addons enable metrics-server

Na het inschakelen kun je het resourcegebruik van je Pods bekijken:

kubectl top pods

Automatisch Schalen met Horizontal Pod Autoscaler (HPA)

De Horizontal Pod Autoscaler (HPA) schaalt automatisch het aantal Pods in een Deployment of ReplicaSet op basis van geobserveerd CPU-gebruik, geheugengebruik of aangepaste metrics. Dit zorgt ervoor dat je applicatie altijd voldoende capaciteit heeft om de belasting aan te kunnen, zonder dat je handmatig hoeft in te grijpen.

Voordat je HPA kunt gebruiken, moeten je Pods resource requests en limits hebben gedefinieerd in de Deployment. Laten we onze deployment.yaml aanpassen:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-kubernetes-app-deployment
  labels:
    app: my-kubernetes-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-kubernetes-app
  template:
    metadata:
      labels:
        app: my-kubernetes-app
    spec:
      containers:
      - name: my-kubernetes-app-container
        image: kwonnis/my-kubernetes-app:1.0.0
        ports:
        - containerPort: 3000
        resources:
          requests:
            cpu: "100m"
            memory: "128Mi"
          limits:
            cpu: "200m"
            memory: "256Mi"
        imagePullPolicy: IfNotPresent

Pas deze wijziging toe: kubectl apply -f deployment.yaml.

Nu kunnen we een HPA definiëren. Maak een bestand genaamd hpa.yaml:

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: my-kubernetes-app-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: my-kubernetes-app-deployment
  minReplicas: 1
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 50

Pas de HPA toe:

kubectl apply -f hpa.yaml

Nu zal Kubernetes automatisch het aantal Pods schalen op basis van de CPU-belasting. Dit is een krachtige functie die de veerkracht en kosteneffectiviteit van je applicaties aanzienlijk verbetert.

Bedankt voor het lezen!

We hopen dat deze gids je heeft geholpen om je eerste stappen te zetten in de wereld van Kubernetes. De reis is nog maar net begonnen, maar met deze basis ben je goed op weg om complexe, schaalbare applicaties te beheren in 2026 en daarna.

Vragen? Laat een reactie achter!

Gerelateerde berichten

• [DevOps & Cloud] Cloud Kosten Optimaliseren: Bespaar op AWS, Azure en GCP in 2026
• [DevOps & Cloud] Realtime Monitoring met Prometheus en Grafana: Een Praktische Gids 2026
• [DevOps & Cloud] AWS Lambda voor Serverless Applicaties: De Complete Gids 2026