Kubernetes-tutorial: een beginnersgids voor het deployen van applicaties

Kubernetes-basis: Pods, Deployments, Services en Namespaces

Nu we een cluster hebben opgezet en gecheckt dat alles werkt, is het tijd om onze eerste applicatie te maken.

Maar voor we de eerste applicatie maken, is het essentieel om de basis van Kubernetes te begrijpen. Wil je een diepere introductie tot Kubernetes, kijk dan zeker de cursus Introduction to Kubernetes.

De meest basale concepten in Kubernetes zijn Pods, Deployments en Services. Met deze drie resourcetypen kun je krachtige applicaties maken. Laten we er dus dieper op ingaan.

Wat zijn Pods?

Een Pod is de kleinste deploybare eenheid in Kubernetes. Hij draait één of meer nauw samenwerkende containers met hetzelfde storage-, netwerk- en namespace-domein. Een Pod wordt altijd ingepland op een Kubernetes-node. 

Je kunt aangeven hoeveel resources je Pod moet krijgen (bijv. CPU en geheugen). 

Een voorbeeldapplicatie met twee containers kan jouw applicatiecontainer zijn en een helpercontainer die logs verzamelt en doorstuurt. 

Eigenschappen van een Pod:

• Enkele instantie: Elke Pod draait één instantie van je applicatie.
• Van nature vluchtig: Pods zijn tijdelijk en worden vervangen als ze falen of worden geüpdatet.

Voorbeeld-YAML om een Pod te maken:

apiVersion: v1
kind: Pod
metadata:
  name: my-pod
spec:
  containers:
  - name: nginx-container
    image: nginx:1.21
    ports:
    - containerPort: 80Mogelijk gemaakt door

Je kunt de Pod daarna installeren met kubectl:

kubectl apply -f pod.yamlMogelijk gemaakt door

Dit start een Pod met de naam my-pod die een nginx-webserver voor je draait.

Wat zijn Deployments?

Een Deployment is een hoger-niveau Kubernetes-object om de lifecycle van Pods te beheren. Het zorgt dat het gewenste aantal Pod-replica’s draait en handelt updates en rollbacks af. 

Eigenschappen van een Deployment:

• Replicabeheer: Zorgt dat het gewenste aantal pods altijd draait.
• Zelfherstellend: Vervangt ongezonde Pods automatisch.
• Rolling updates: Update de applicatie stapsgewijs zonder downtime (indien geconfigureerd).

Zo ziet een Deployment-YAML eruit die opnieuw een nginx-webserver maakt, maar nu met drie replica’s:

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.21
        ports:
        - containerPort: 80Mogelijk gemaakt door

Je kunt dat Deployment installeren met kubectl:

kubectl apply -f deployment.yamlMogelijk gemaakt door

Bovenstaand maakt een Deployment met de naam nginx-deployment dat drie Pods aanmaakt, elk met de nginx-container. 

Wat zijn Services?

Dan het laatste onderdeel: de services. 

Een Service is een abstractie die stabiele netwerktoegang tot Pods biedt, zelfs als hun IP-adressen veranderen. Het fungeert als brug tussen je applicaties en externe clients. 

Waarom is dat nodig? Elke Pod heeft een eigen IP-adres. Waarom kunnen we dat IP dan niet direct gebruiken? 

Dat kan! Maar het is niet verstandig. Waarom? 

Omdat een Pod vluchtig is: hij wordt door het Deployment beëindigd en opnieuw opgeschaald wanneer je Pod ongezond is. De nieuwe Pod krijgt dan een ander IP-adres. Dat zou betekenen dat de client die je applicatie gebruikt steeds het IP-adres moet aanpassen wanneer een Pod crasht, en dat kan vaak gebeuren.

Hier komt een Service om de hoek kijken: die zoekt naar alle Pods met een bepaald label en routeert het verkeer automatisch naar die Pods. Als een Pod ongezond wordt, stopt de Service met verkeer naar die Pod. En als er een nieuwe Pod opkomt, stuurt de Service verkeer naar de nieuwe Pod. 

De Service verdeelt het verkeer ook over alle replica’s van je Deployment. Dat is ideaal: je kunt meer instanties van je applicatie maken om verkeer te verdelen zonder dit in je applicatielogica te hoeven bouwen.

Typen Services:

• ClusterIP (standaard): Stelt de Service binnen het cluster beschikbaar.
• NodePort: Stelt de Service beschikbaar op een poort die buiten het cluster bereikbaar is.
• LoadBalancer: Integreert met cloudproviders om de Service via een load balancer bloot te stellen.

Voorbeeld-YAML om onze nginx-webserver buiten het cluster beschikbaar te maken:

apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  ports:
  - protocol: TCP
    port: 80
    targetPort: 80
  type: NodePortMogelijk gemaakt door

Je kunt die service weer aanmaken met kubectl:

kubectl apply -f service.yamlMogelijk gemaakt door

Deze Service verdeelt nu inkomend verkeer naar alle Pods met het label app=nginx op poort 80. 

Als je een describe-commando uitvoert op je nieuw aangemaakte Service, zie je dat er nu drie endpoints zijn; elk endpoint is het IP-adres van een Pod die momenteel draait:

kubectl describe service nginx-serviceMogelijk gemaakt door

Het bovenstaande commando zou iets vergelijkbaars teruggeven als: 

Name:                     nginx-service
Namespace:                default
Labels:                   <none>
Annotations:              <none>
Selector:                 app=nginx
Type:                     NodePort
IP Family Policy:         SingleStack
IP Families:              IPv4
IP:                       10.104.53.131
IPs:                      10.104.53.131
Port:                     <unset>  80/TCP
TargetPort:               80/TCP
NodePort:                 <unset>  32256/TCP
Endpoints:                10.244.0.5:80,10.244.0.6:80,10.244.0.7:80
Session Affinity:         None
External Traffic Policy:  Cluster
Events:                   <none>Mogelijk gemaakt door

Relaties tussen Pods, Deployments en Services

Kort samengevat:

• Pods: Stellen individuele applicatie-instanties voor.
• Deployments: Beheren de lifecycle van Pods en bewaken hun gezondheid.
• Services: Bieden stabiele toegang tot Pods en maken externe of interne communicatie mogelijk.

Wat zijn Namespaces?

Namespaces in Kubernetes laten je resources binnen een cluster organiseren en isoleren. Je kunt ze zien als virtuele clusters binnen hetzelfde fysieke cluster. 

Voordelen van Namespaces:

• Scheiding van verantwoordelijkheden: Verschillende teams of applicaties kunnen in hun eigen namespace werken zonder anderen te beïnvloeden. 
• Resourcemanagement: Je kunt resourcequota en limieten instellen per namespace.
• Beveiliging en toegang: Beleid kan op namespace-niveau worden afgedwongen.

Standaard levert Kubernetes een paar ingebouwde namespaces:

• default: De standaardnamespace waar resources worden aangemaakt, tenzij anders opgegeven
• kube-system: Voor interne Kubernetes-componenten (bijv. API-server, scheduler, etc.).
• kube-public: Een publiek leesbare namespace.
• kube-node-lease: Voor het bijhouden van node-heartbeats.

Je kunt een namespace aanmaken met een YAML-bestand: 

apiVersion: v1
kind: Namespace
metadata:
  name: my-namespaceMogelijk gemaakt door

Sla dat op als namespace.yaml en pas het toe met: 

kubectl apply -f namespace.yamlMogelijk gemaakt door

Als je het onderstaande commando draait, zie je een lijst met alle standaard-namespaces plus de nieuw aangemaakte: 

kubectl get namespacesMogelijk gemaakt door

Je kunt daarna resources in die namespace aanmaken door simpelweg de namespace in de metadata-sectie van je resource te zetten. 

Ons nginx-Deployment ziet er als volgt uit als we het in je nieuw aangemaakte namespace willen maken:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  namespace: my-namespace
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.21
        ports:
        - containerPort: 80Mogelijk gemaakt door

Nu moet je expliciet aangeven dat je resources uit je nieuw aangemaakte namespace wilt ophalen met het -n argument: 

kubectl get deployment -n my-namespaceMogelijk gemaakt door

Je eerste applicatie beheren met Kubernetes

Oké, nu je bekend bent met de basisconcepten van Kubernetes, is het tijd om onze eerste webapplicatie te deployen naar Kubernetes en te proberen die te benaderen. 

In dit hoofdstuk maken we een nginx-webserver, stellen we die via een Service bloot aan de buitenwereld, schalen we de applicatie om hoge verkeersbelasting te simuleren en updaten we de applicatie met een rolling update naar een nieuwere versie.

Dus, laten we aan de slag gaan!

Een eenvoudige webapplicatie-deployment maken

De eerste stap is een Deployment maken voor onze webserver die een container op basis van de Nginx-image creëert.

Kopieer de onderstaande code en sla die op als nginx-deployment.yaml.

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

Pas dat Deployment vervolgens toe op je cluster met het volgende commando:

kubectl apply -f nginx-deployment.yamlMogelijk gemaakt door

Je kunt daarna verifiëren dat de Pod draait: 

kubectl get podsMogelijk gemaakt door

De applicatie blootstellen met een service

We moeten de nginx-webserver via een Service aan de buitenwereld blootstellen. Hiervoor maken we een Service van het type NodePort, omdat we de nginx-webserver willen benaderen vanaf onze lokale machine buiten het Kubernetes-cluster.

Maak dus een bestand nginx-service.yaml en voeg de volgende inhoud toe:

apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  ports:
  - protocol: TCP
    port: 80
    targetPort: 80
  type: NodePortMogelijk gemaakt door

Je kunt de Service dan toepassen met het onderstaande commando:

kubectl apply -f nginx-service.yamlMogelijk gemaakt door

Tot slot kun je minikube gebruiken om de URL van je nginx-webserver op te halen:

minikube service nginx-service --urlMogelijk gemaakt door

Open die URL in je browser en je zou de welkomstpagina van je nginx-webserver moeten zien.

Screenshot van een nginx-webserver welkomstpagina in een lokale browser.

De applicatie schalen

We hebben één Pod die draait. Maar er kan een grote toestroom aan gebruikers zijn die onze webpagina bezoeken. Daarom kun je in Kubernetes je applicatie snel schalen zodat er meer Pods draaien. 

De Service detecteert automatisch alle Pods die bij dat Deployment horen en verdeelt inkomende requests over alle Pods die de nginx-webserver draaien. Dit helpt de algehele performance van onze webpagina te verbeteren wanneer er veel verkeer binnenkomt.

Laten we onze applicatie opschalen naar 3 replica’s met het onderstaande commando:

kubectl scale deployment nginx-deployment --replicas=3Mogelijk gemaakt door

Je kunt nu opnieuw alle draaiende Pods opvragen; dat zouden er drie moeten zijn:

kubectl get podsMogelijk gemaakt door

Je kunt ook het onderstaande commando gebruiken om alle endpoints op te vragen waarmee onze nginx-service is verbonden. Dit zou drie endpoints moeten teruggeven, elk een eigen intern cluster-IP-adres:

kubectl get endpoints nginx-serviceMogelijk gemaakt door

Rolling updates

Nu komen we bij een ander groot voordeel van Kubernetes: rolling updates.

Het doel van een rolling update is om downtime van je webapplicatie te voorkomen. Stel je de financiële schade voor bij bedrijven als Amazon als hun website telkens onbereikbaar zou zijn bij een nieuwe release.

Met een rolling update schaalt Kubernetes een nieuwe Pod op, controleert of die gezond is, en schaalt dan de oude af. 

Standaard zorgt Kubernetes dat minstens 75% van het gewenste aantal Pods draait, waarbij 25% maximaal onbeschikbaar mag zijn. In ons geval, met drie replica’s, voegt Kubernetes dus telkens één nieuwe Pod toe, checkt of die gezond is en schaalt vervolgens een andere Pod af. Dat herhaalt het tot alle Pods zijn geüpdatet naar de nieuwe versie.

Laten we dat nu doen door de versie van onze nginx-image te wijzigen van latest naar 1.23:

kubectl set image deployment/nginx-deployment nginx=nginx:1.23Mogelijk gemaakt door

Je kunt de uitrolstatus volgen met: 

kubectl rollout status deployment/nginx-deploymentMogelijk gemaakt door

De output ziet er ongeveer zo uit: 

Waiting for deployment "nginx-deployment" rollout to finish: 1 out of 3 new replicas have been updated...
Waiting for deployment "nginx-deployment" rollout to finish: 1 out of 3 new replicas have been updated...
Waiting for deployment "nginx-deployment" rollout to finish: 1 out of 3 new replicas have been updated...
Waiting for deployment "nginx-deployment" rollout to finish: 2 out of 3 new replicas have been updated...
Waiting for deployment "nginx-deployment" rollout to finish: 2 out of 3 new replicas have been updated...
Waiting for deployment "nginx-deployment" rollout to finish: 2 out of 3 new replicas have been updated...
Waiting for deployment "nginx-deployment" rollout to finish: 1 old replicas are pending termination...
Waiting for deployment "nginx-deployment" rollout to finish: 1 old replicas are pending termination...
deployment "nginx-deployment" successfully rolled outMogelijk gemaakt door

En terwijl de uitrol bezig is, blijft je webpagina de hele tijd bereikbaar zonder downtime!

Geweldig toch?

Kubernetes-resources beheren

Kubernetes biedt krachtige tools om resources van alle typen te inspecteren, wijzigen en verwijderen. Begrijpen hoe je resources effectief beheert, zorgt voor betere troubleshooting, resourceallocatie en algemeen clustonderhoud. 

In deze sectie gaan we in op andere essentiële commando’s die helpen je resources effectief te beheren en problemen op te lossen als die zich voordoen.

Clustresources bekijken

Voordat je resources wijzigt, is het belangrijk om de momenteel draaiende resources in je cluster te bekijken en te inspecteren.

Je kunt bijvoorbeeld alle draaiende Pods, Services en Deployments opvragen om te zien wat er in je cluster gebeurt: 

# list running Pods
kubectl get pods

# list running Services 
kubectl get services

# list running Deployments
kubectl get deploymentsMogelijk gemaakt door

Wil je dieper graven in een specifieke resource, gebruik dan het describe commando:

kubectl describe deployment nginx-deploymentMogelijk gemaakt door

Dit toont meer informatie, waaronder rolling updates, schalen of image-pull-events. Dit is het eerste aanknopingspunt als er iets misgaat.

Je kunt ook de logs van een draaiende Pod bekijken om te zien wat er binnen die Pod gebeurt met het onderstaande commando:

kubectl logs <pod-name>Mogelijk gemaakt door

Resources verwijderen

Het is ook belangrijk om resources op te ruimen wanneer ze niet meer worden gebruikt, zodat clustresources vrijkomen voor nieuwe applicaties. 

Je kunt een Pod verwijderen met:

kubectl delete pod <pod-name>Mogelijk gemaakt door

We kunnen dit doen voor een van onze nginx-pods. Er zou echter meteen een nieuwe Pod worden opgeschaald, omdat ze worden beheerd via een Deployment, dat altijd probeert drie replica’s draaiende te houden. 

Hier moeten we dus het nginx-deployment verwijderen: 

kubectl delete deployment nginx-deploymentMogelijk gemaakt door

Na dit commando moeten alle draaiende nginx-Pods zijn verwijderd. 

We kunnen ook alle resources in een Namespace verwijderen. Het volgende commando verwijdert alle resources die standaard in de default Namespace zijn aangemaakt:

kubectl delete all --allMogelijk gemaakt door

Conclusie

Gefeliciteerd! Je bent tot het einde gekomen en hebt je eerste stappen in Kubernetes gezet. 

Door deze tutorial te volgen, heb je geleerd om:

• Een lokaal Kubernetes-cluster op te zetten met minikube.
• Te werken met Pods, Deployments, Services en Namespaces (de essentiële bouwstenen van Kubernetes).
• Een eenvoudige webapplicatie te deployen en te beheren binnen Kubernetes.
• Applicaties dynamisch te schalen en rolling updates uit te voeren zonder downtime.
• Kubernetes-resources te beheren door ze te lijsten, te beschrijven en te verwijderen.

Kubernetes kan in het begin complex lijken (dat vond ik tenminste). Maar door het op te delen in fundamentele concepten wordt het veel toegankelijker. 

Blijf experimenteren en deploy meer applicaties. 

De beste manier om Kubernetes te leren is door te doen, dus ga bouwen!

Wil je je Kubernetes-skills verder aanscherpen, verken dan:

• Werken met ConfigMaps en Secrets: Sla configuraties veilig op en beheer ze.
• Persistente volumes: Leer data op te slaan die Pod-restarts overleeft met persistente volumes.
• Netwerken en ingress-controllers: Richt domeingebaseerde routing in en beheer extern verkeer.
• Helm: Gebruik Helm-charts om complexe applicaties efficiënt te verpakken en te deployen.
• Kubernetes in de cloud: Experimenteer met beheerde Kubernetes-diensten zoals AWS EKS, Azure AKS of Google GKE.

Tot slot is de track Containerization and Virtualization with Docker and Kubernetes op DataCamp een uitstekende bron om te oefenen met zowel Docker als Kubernetes.