Wat is Kubernetes? Een introductie met voorbeelden

Als je op de hoogte bent van de opkomst van cloud computing, heb je vast wel eens van Kubernetes gehoord. In moderne applicatieontwikkeling is het een onmisbare tool om verschillende infrastructuuromgevingen te beheren.

In dit introductieartikel geven we een overzicht van Kubernetes en de onderdelen ervan, plus een uitgebreide tutorial om het lokaal te implementeren. Wil je een praktische leerervaring naast deze tutorial, bekijk dan onze Introduction to Kubernetes-cursus. 

Wat is Kubernetes?

Kubernetes is een open-source platform voor orkestratie van containers dat de uitrol, schaalvergroting en het beheer van gecontaineriseerde applicaties automatiseert. Oorspronkelijk ontwikkeld door Google, is het uitgegroeid tot de de-facto standaard voor het grootschalig draaien van containers.

Het abstraheert de complexiteit van het beheren van individuele containers, zodat ontwikkelaars zich kunnen richten op het bouwen en uitrollen van hun applicaties.

Waarom Kubernetes gebruiken?

Dit zijn enkele belangrijke voordelen van Kubernetes:

• Containerorkestratie: Automatiseert de distributie en planning van containers over een cluster.
• Schaalbaarheid en zelfherstel: Vereenvoudigt horizontaal schalen (containers repliceren) en verticaal schalen (resourceallocatie aanpassen), allebei met zelfherstellende mogelijkheden.
• Hoge beschikbaarheid: Zorgt ervoor dat containers (en dus je services) operationeel blijven, zelfs als sommige nodes uitvallen.
• Portabiliteit: Abstraheert de onderliggende infrastructuur, waardoor het eenvoudig is om zowel on-premises als bij verschillende cloudproviders te draaien.
• Efficiënt gebruik van resources: Past containers aan op basis van resourcegebruik, optimaliseert toewijzing en verlaagt kosten.

Kubernetes is nuttig in uiteenlopende toepassingen zoals:

• DevOps: Automatiseert de uitrol, schaalvergroting en het beheer van gecontaineriseerde applicaties.
• Microservices: Splitst grote monolithische applicaties op in kleinere, beheersbare services voor meer wendbaarheid en schaalbaarheid.
• Big data: Vereenvoudigt de uitrol en het beheer van complexe bigdatasystemen met behulp van containers.
• Edge computing: Maakt het mogelijk om Kubernetes op edge-apparaten te draaien om data dichter bij de bron te verwerken en analyseren, wat latency vermindert en prestaties verbetert.
• Continuous delivery: Integreert met tools zoals Jenkins en GitLab voor geautomatiseerde continuous-deliverypijplijnen.
• Machine learning: Biedt een schaalbaar platform voor het trainen en uitrollen van machinelearningmodellen, inclusief grote datasets en complexe berekeningen.

Belangrijke concepten in Kubernetes

Om te begrijpen hoe Kubernetes werkt, heb je een goed beeld nodig van de belangrijkste concepten. 

Die omvatten 4 hoofdconcepten:

1. Clusters
2. Pods
3. Namespaces
4. Operators

Hieronder gaan we hier dieper op in.

Clusters

Kubernetes-clusters zijn groepen nodes, individuele machines waarop de Kubernetes-software draait. Het cluster fungeert als het controlevlak voor het beheren van applicaties en services.

In een typische setup heeft een cluster één master node en meerdere worker nodes. De master node coördineert alle activiteiten binnen het cluster, terwijl de worker nodes het draaien en beheren van containers voor hun rekening nemen.

Pods

Pods zijn de kleinste uitrolbare eenheid in Kubernetes. Ze kunnen één of meerdere containers bevatten, samen met gedeelde opslagresources en netwerkinstellingen.

Elke pod heeft een eigen uniek IP-adres en kan via dit adres communiceren met andere pods in hetzelfde cluster. Dit maakt efficiënte communicatie tussen verschillende componenten van een applicatie mogelijk.

Pods kunnen bestaan uit één of meerdere containers, elk met een eigen gebruikssituatie.

• Pods met één container: Het meest voorkomende type pod, met één container die binnenin draait. Handig voor eenvoudige applicaties of microservices die slechts één container nodig hebben.
• Pods met meerdere containers: Meerdere containers zijn samengebracht en draaien samen. Dit is nuttig voor complexe applicaties waarbij verschillende containers met elkaar moeten communiceren en resources delen.

Namespaces

Namespaces bieden een manier om resources logisch te verdelen binnen één cluster. Dit zorgt voor betere organisatie en beheer van resources, en voor strengere beveiligingscontroles.

Namespaces kunnen ook worden gebruikt om verschillende omgevingen te beheren, zoals development, staging en productie. Zo blijven resources geïsoleerd en worden ze niet beïnvloed door wijzigingen in andere omgevingen.

Om de namespaces in je cluster te bekijken, kun je dit commando gebruiken:

kubectl get namespaces

Om tussen namespaces te wisselen, gebruik je het volgende

kubectl config set-context --current --namespace <namespace name>

Operators

Operators zijn software-extensies die helpen bij het automatiseren van het beheer van Kubernetes-resources. Ze gebruiken aangepaste controllers en API-extensies om complexe taken efficiënter en automatisch te beheren.

Enkele populaire operators zijn:

• Prometheus voor monitoring
• etcd-operator voor het beheren van etcd-clusters

Met operators wordt het beheer van applicaties en resources binnen je cluster een stuk eenvoudiger. Door hun vermogen om taken te automatiseren en geavanceerde functies te bieden, winnen ze snel aan populariteit onder Kubernetes-gebruikers.

Kerncomponenten van Kubernetes

In de meeste Kubernetes-omgevingen is er een set kerncomponenten.

Bron: Kubernetes

Hier is een lijst met componenten en wat ze doen:

1. API-server: Dit onderdeel fungeert als het centrale beheerpunt voor alle Kubernetes-resources. Het ontvangt verzoeken van gebruikers en andere componenten en handhaaft vervolgens policies om het cluster te beheren.
2. Controller manager: Verantwoordelijk voor het handhaven van de gewenste toestand van het cluster door continu wijzigingen aan objecten in het cluster te monitoren en te reconciliëren.
3. etcd: Een gedistribueerde key-value store die dient als de primaire datastore voor Kubernetes. Slaat alle clusterdata op en waarborgt consistentie en beschikbaarheid.
4. kubelet: Deze agent draait op elke node in het cluster en beheert containers, zodat ze draaien volgens hun opgegeven configuraties.
5. Kube Proxy: Dit onderdeel draait op elke node en is verantwoordelijk voor het routeren van netwerkverkeer naar de juiste container.

Hoe Kubernetes werkt

Zoals we hebben gezien, automatiseert Kubernetes de uitrol, schaalvergroting en het beheer van gecontaineriseerde applicaties over clusters heen. Het zorgt voor hoge beschikbaarheid, efficiënt resourcengebruik en zelfherstel zonder handmatige tussenkomst.

In plaats van individuele containers te beheren, groepeert Kubernetes ze in Pods en verdeelt ze over worker nodes, die met het controlevlak communiceren om de gewenste toestand van het systeem te behouden.

Zo werkt Kubernetes, in het kort:

1. Definieer de applicatie-uitrol: Je specificeert de gewenste toestand in een YAML-bestand, inclusief replica’s, resourcelimieten en netwerkregels.
2. Plan workloads: De Scheduler wijst Pods toe aan worker nodes op basis van beschikbare resources.
3. Beheer de clusterstaat: De Controller Manager zorgt dat het systeem het juiste aantal Pods behoudt en vervangt mislukte exemplaren.
4. Afhandelen van netwerken: Kubernetes beheert communicatie tussen services en externe toegang via Services en Ingress-controllers.
5. Schaal en herstel zelf: Kubernetes past het aantal draaiende Pods aan op basis van vraag en herstart mislukte containers automatisch.

Door de infrastructuurcomplexiteit weg te nemen, kunnen teams zich richten op het bouwen van applicaties in plaats van op het beheer van uitrolprocessen. Zo is het essentieel voor schaalbare, veerkrachtige workloads in uiteenlopende sectoren.

Veelgebruikte terminologie en concepten

Laten we enkele belangrijke termen doornemen die je moet kennen, plus hun definities:

• YAML-manifests: Configuratiebestanden die de gewenste toestand van je applicatie of infrastructuur definiëren. Ze kunnen worden gebruikt om resources in Kubernetes te maken, bij te werken en te verwijderen.
• StatefulSets vs. Deployments: Twee typen controllers in Kubernetes die de levenscyclus van pods beheren. Deployments worden meestal gebruikt voor stateloze applicaties, terwijl StatefulSets voor stateful applicaties zijn.
• Services: Bieden een stabiel IP-adres en DNS-naam om binnen het cluster toegang te krijgen tot je applicatie. Ze faciliteren ook communicatie tussen verschillende pods.
• ConfigMaps: Worden gebruikt om configuratiegegevens op te slaan in key-valueparen die door je applicatie kunnen worden geraadpleegd.
• Secrets: Lijken op ConfigMaps, maar worden gebruikt om gevoelige informatie op te slaan, zoals wachtwoorden of API-sleutels.

Aan de slag met Kubernetes

Werken met Kubernetes kan ontmoedigend lijken, zeker bij alle terminologie en concepten. Maar zodra je deze essentiële termen goed begrijpt, navigeer je veel makkelijker door het platform.

Laten we beginnen met enkele tools die je met Kubernetes gebruikt.

Tools voor beginners

Als beginner kan het uitrollen van applicaties in de cloud best veel zijn. Daarom kun je terugvallen op een aantal gangbare tools om lokaal te deployen. 

Hier zijn de 2 meest gebruikte tools:

1. Minikube

Minikube is een lichtgewicht Kubernetes-implementatie die op één hostmachine kan draaien. Meestal draait het een single-nodecluster in een virtuele machine (VM) op je laptop of workstation.

Waarom gebruiken:

• Eenvoudig op te zetten en weer te verwijderen.
• Geweldig voor lokale ontwikkeling en proofs-of-concept.
• Minimaal resourcegebruik vergeleken met een volwaardig cluster.

Minikube installeren (voorbeeld op Windows):

# Install via Windows Package Manager
winget install Kubernetes.minikube

Je zou het volgende installatiescherm moeten zien. Ga akkoord met de voorwaarden als daarom wordt gevraagd met “Y”.

Gebruik vervolgens het start-commando om een eenvoudig cluster op minikube te starten:

# Start a single-node cluster
minikube start

Om te controleren of de clusternode succesvol is gestart, voer je het get-commando uit:

# Verify the cluster is running
kubectl get nodes

Let op: Je moet de kubectl-API-server op je lokale machine hebben geïnstalleerd (wordt in veel gevallen automatisch met Minikube geïnstalleerd).

2. Kind (Kubernetes in Docker)

Kind staat voor Kubernetes in Docker. Het gebruikt Docker-containers als "nodes" in een Kubernetes-cluster en biedt zo een eenvoudige, containergebaseerde lokale clusteromgeving.

Waarom gebruiken:

• Snellere opstart in veel scenario’s vergeleken met Minikube.
• Eenvoudig meerdere testclusters tegelijk op te zetten, ideaal voor CI/CD-pijplijnen.
• Vaak gebruikt in geautomatiseerde testomgevingen vanwege de lagere overhead.

Kind installeren (voorbeeld op Windows):

# Install Kind with Windows Package Manager
winget install Kubernetes.kind

Na installatie kun je met het commando create cluster een eenvoudig cluster maken en het een naam geven.

# Create a basic cluster
kind create cluster --name example-cluster

Om te controleren of je Kubernetes-kindcluster is gestart, gebruik je het volgende get-commando.

# Check running clusters
kind get clusters

Je kunt ook via de kubectl-interface met het cluster werken:

# Interact with your Kind cluster using kubectl
kubectl get nodes

Let op: Zorg dat Docker is geïnstalleerd en draait.

Cloudproviders (EKS, GKE, AKS)

Als je Kubernetes in de cloud draait, zijn dit enkele providers om uit te kiezen:

1. Amazon EKS (Elastic Kubernetes Service)

Amazon EKS is een beheerde service die het eenvoudig maakt om Kubernetes op AWS te draaien zonder dat je je eigen control plane of workernodes hoeft te beheren. Het integreert met andere AWS-services voor extra functionaliteit zoals load balancing, opslag, autoscaling en monitoring.

Enkele extra functies zijn onder meer:

• Biedt integraties met andere AWS-services (bijv. IAM, CloudWatch, ECR).
• Schaalbaarheid en hoge beschikbaarheid zijn ingebouwd in het platform.

2. Google GKE (Google Kubernetes Engine)

Google GKE is een volledig beheerde service voor het draaien van Kubernetes op Google Cloud Platform. Het biedt automatische schaalvergroting, zelfherstellende mogelijkheden en integratie met andere Google Cloud-services.

Enkele extra functies zijn onder meer:

• Diepe integratie met GCP-services zoals Cloud Logging, Cloud Monitoring en Container Registry.
• Biedt autopilot-modus, die de clusterinfrastructuur automatisch beheert.

3. Azure AKS (Azure Kubernetes Service)

Azure AKS biedt serverloze Kubernetes-clusters die volledig geïntegreerd zijn met andere Azure-services zoals Storage, Networking en Load Balancing. Het heeft ook ingebouwde ondersteuning voor DevOps-tools zoals Helm en Prometheus.

Enkele extra functies zijn onder meer:

• Integreert met Azure Active Directory, Azure Monitor, Container Registry, enzovoort.
• Biedt serverloze Kubernetes (Virtual Nodes) met Azure Container Instances.

Leermiddelen voor Kubernetes

Kubernetes voor het eerst leren kan overweldigend lijken, maar er zijn veel bronnen beschikbaar om je op weg te helpen. 

Aanbevolen bronnen:

• DataCamp-cursussen en -bronnen: Onze Introduction to Kubernetes-cursus en Containerization-tutorial zijn prima startpunten.
• Onze speciale Kubernetes-startertutorials: Gemaakt om je de basis bij te brengen.

Voorbeeld van een Kubernetes-deployment

Om applicaties in Kubernetes te draaien, volg je een gestructureerde workflow: je zet een cluster op, rolt een gecontaineriseerde applicatie uit, stelt die bloot als service en schaalt waar nodig. 

We behandelen dit proces uitgebreid in onze Kubernetes-tutorial, maar hier is een globaal overzicht:

Stel een Kubernetes-cluster in

Gebruik Minikube om een lokaal cluster te maken voor testen en ontwikkeling. Installeer Minikube en start je cluster met:

minikube start --driver=docker

kubectl get nodes

Rol een applicatie uit

Definieer de gewenste toestand van je applicatie in een Deployment-YAML-bestand. Het uitrollen van een Nginx-webserver ziet er bijvoorbeeld zo uit:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: hello-deployment
spec:
  replicas: 1
  selector:
    matchLabels:
      app: hello
  template:
    metadata:
      labels:
        app: hello
    spec:
      containers:
      - name: hello-container
        image: nginx:latest
        ports:
        - containerPort: 80

Pas de deployment toe met:

kubectl apply -f hello-deployment.yaml

Stel de applicatie bloot als service

Maak om de applicatie toegankelijk te maken een Service met:

kubectl expose deployment hello-deployment --type=NodePort --port=80 --name=hello-service

Haal de externe URL op en open de app in je browser:

minikube service hello-service

Schaal en monitor de applicatie

Kubernetes maakt het moeiteloos om applicaties te schalen. Om het aantal replica’s te verhogen:

kubectl scale deployment hello-deployment --replicas=3

Controleer draaiende Pods:

kubectl get pods

Bekijk logs voor debuggen:

kubectl logs -f <pod-name>

Hier zijn enkele voorbeelden om verder te verkennen voor geavanceerde projecten:

• Draai streamingjobs in containers (bijv. Spark op Kubernetes, Kafka op Kubernetes).
• Gebruik Persistent Volumes om externe opslagoplossingen te koppelen zoals AWS EBS, Azure Disks of NFS.
• Rol complexere apps uit (bijv. meerlaagse microservices met databases).
• Verken geavanceerde functies zoals Ingress-controllers, service meshes (bijv. Istio), Helm-charts voor pakketbeheer.

Conclusie

Kubernetes is een krachtig platform voor het uitrollen en beheren van gecontaineriseerde applicaties op schaal. Het is daarmee een essentiële tool voor data engineers die elastische, betrouwbare omgevingen nodig hebben voor dataverwerking. 

Wil je meer leren over Kubernetes? Onze Introduction to Kubernetes-cursus is de perfecte plek om te beginnen.