Inleiding tot Kubernetes: De Container Orchestrator

Als je in de wereld van softwareontwikkeling werkt, heb je zeker van Kubernetes gehoord. Maar wat is het precies, en waarom is het de de-facto standaard geworden voor het beheren van gecontaineriseerde applicaties? Deze gids neemt je mee van de basis tot de fundamentele concepten, met praktische voorbeelden en diagrammen om je te helpen begrijpen.

Voor Kubernetes: Een Stukje Geschiedenis

Om te begrijpen waarom Kubernetes zo revolutionair is, laten we een stap terug doen.

1. Traditionele Deployment: Aanvankelijk werden applicaties op fysieke servers gedraaid. Deze aanpak was duur, moeilijk te schalen en gevoelig voor resourceconflicten.
2. Gevirtualiseerde Deployment: Toen kwamen Virtual Machines (VM's). VM's maakten het mogelijk om meerdere geïsoleerde applicaties op dezelfde hardware te draaien, wat het resourcegebruik en de beveiliging verbeterde. Elke VM draait echter een volledig besturingssysteem, wat veel resources verbruikt.
3. Gecontaineriseerde Deployment: Containers (zoals Docker) zijn de volgende evolutie. Ze delen hetzelfde host-besturingssysteem maar draaien geïsoleerde processen. Ze zijn lichtgewicht, snel op te starten en overdraagbaar.

Containers losten het portabiliteitsprobleem op, maar creëerden een ander: hoe beheer je honderden (of duizenden) containers in een productieomgeving? Hoe zorg je ervoor dat ze altijd draaien, met elkaar kunnen communiceren en schalen op basis van belasting?

Dit is waar Kubernetes om de hoek komt kijken.

Wat is Kubernetes?

Kubernetes (vaak afgekort als K8s) is een open-source platform voor containerorkestratie. Simpel gezegd automatiseert het de deployment, schaling en het beheer van gecontaineriseerde applicaties. Gemaakt door Google en nu onderhouden door de Cloud Native Computing Foundation (CNCF), is Kubernetes de go-to tool geworden voor iedereen die met microservices op schaal werkt.

De Architectuur van een Kubernetes Cluster

Een Kubernetes-omgeving wordt een cluster genoemd. Een cluster bestaat uit een set machines, genaamd nodes, die onze applicaties draaien. De architectuur is verdeeld in twee hoofddelen: het Control Plane en de Worker Nodes.

Control Plane

Het Control Plane is het "brein" van het cluster. Het neemt globale beslissingen (zoals scheduling) en detecteert en reageert op cluster-events. De belangrijkste componenten zijn:

• API Server (kube-apiserver): De toegangspoort tot het cluster. Het stelt de Kubernetes API beschikbaar.
• etcd: Een consistente en hoog beschikbare key-value database. Het slaat alle clusterdata op.
• Scheduler (kube-scheduler): Wijst nieuw aangemaakte Pods toe aan een beschikbare Worker Node.
• Controller Manager (kube-controller-manager): Draait controllers die de staat van het cluster bewaken en naar de gewenste staat werken.

Worker Node

Worker Nodes zijn de machines waar de applicaties daadwerkelijk draaien. Elk node bevat:

• Kubelet: Een agent die op elk node draait. Het zorgt ervoor dat de containers in de Pods draaien en gezond zijn.
• Kube-proxy: Een netwerkproxy die netwerkregels op de nodes beheert.
• Container Runtime: De software verantwoordelijk voor het draaien van containers. Docker is de bekendste, maar Kubernetes ondersteunt ook containerd en CRI-O.

Fundamentele Kubernetes Objecten

In Kubernetes wordt alles voorgesteld door objecten. Dit zijn "intentierecords": zodra je een object aanmaakt, werkt Kubernetes er constant aan om ervoor te zorgen dat het bestaat en overeenkomt met de gewenste staat.

Pod

De Pod is de kleinste uitvoeringseenheid in Kubernetes. Het vertegenwoordigt één of meer containers die samen op dezelfde node draaien, met gedeelde resources zoals netwerk en opslag.

Deployment

Een Deployment is het object dat je het vaakst zult gebruiken. Het beschrijft de gewenste staat voor een groep identieke Pods.

# nginx-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.14.2
        ports:
        - containerPort: 80

Service

Pods in Kubernetes zijn vluchtig. Een Service is een abstractie die een logische set Pods definieert en een beleid voor toegang ertoe. Het biedt een stabiel toegangspunt.

# nginx-service.yaml
apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80
  type: ClusterIP # Default - exposes the service only within the cluster

Er zijn verschillende soorten Services:

• ClusterIP: Stelt de service beschikbaar op een cluster-intern IP (standaard).
• NodePort: Stelt de service beschikbaar op een statische poort op elke Worker Node.
• LoadBalancer: Maakt een externe load balancer aan in de cloudprovider.

Ingress

Een Ingress fungeert als een "intelligente router" voor extern verkeer. Het stelt je in staat om routingregels te definiëren op basis van host of pad.

# example-ingress.yaml
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: example-ingress
spec:
  rules:
  - host: mysite.com
    http:
      paths:
      - path: /api
        pathType: Prefix
        backend:
          service:
            name: api-service
            port:
              number: 8080
      - path: /ui
        pathType: Prefix
        backend:
          service:
            name: ui-service
            port:
              number: 3000

Andere Nuttige Objecten

• Namespace: Maakt "virtuele clusters" binnen een fysiek cluster mogelijk.
• ConfigMap en Secret: Voor het beheren van configuratiegegevens en geheimen.
• StatefulSet: Vergelijkbaar met een Deployment, maar specifiek voor stateful applicaties.
• PersistentVolume (PV) en PersistentVolumeClaim (PVC): Voor het beheren van persistente opslag.

Conclusie

Kubernetes is een ongelooflijk krachtige tool, maar de leercurve kan steil zijn. Deze gids heeft alleen het oppervlak bekrast, maar we hopen dat het je een solide begrip van de basisconcepten heeft gegeven.

Wat nu te doen?

• Experimenteer lokaal: Installeer Minikube of Kind om een Kubernetes-cluster op je computer te maken.
• Gebruik kubectl: Maak je vertrouwd met het kubectl-commando.
• Verken de officiële tutorials: De Kubernetes-documentatie is een fantastische bron vol voorbeelden.

Containerorkestratie is een fundamentele vaardigheid in de cloud-native wereld, en het beheersen van Kubernetes opent een wereld van mogelijkheden. Veel plezier!