1~
2Als 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.
3~
4## Voor Kubernetes: Een Stukje Geschiedenis
5~
6Om te begrijpen waarom Kubernetes zo revolutionair is, laten we een stap terug doen.
7~
81.  **Traditionele Deployment**: Aanvankelijk werden applicaties op fysieke servers gedraaid. Deze aanpak was duur, moeilijk te schalen en gevoelig voor resourceconflicten.
92.  **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.
103.  **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.
11~
12Containers 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?
13~
14Dit is waar **Kubernetes** om de hoek komt kijken.
15~
16## Wat is Kubernetes?
17~
18Kubernetes (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.
19~
20## De Architectuur van een Kubernetes Cluster
21~
22Een 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.
23~
24```mermaid
25graph TD
26    subgraph "Control Plane (Master)"
27        A["API Server"]
28        B["etcd"]
29        C["Scheduler"]
30        D["Controller Manager"]
31    end
32~
33    subgraph "Worker Node 1"
34        E["Kubelet"] --- F["Container Runtime"]
35        G["Kube-proxy"]
36        F --- H["Pod"]
37        F --- I["Pod"]
38    end
39~
40    subgraph "Worker Node 2"
41        J["Kubelet"] --- K["Container Runtime"]
42        L["Kube-proxy"]
43        K --- M["Pod"]
44    end
45~
46    A -- "Communicates with" --> E
47    A -- "Communicates with" --> J
48    User -- "kubectl" --> A
49    C -- "Assigns Pods to Nodes" --> E
50    D -- "Maintains state" --> A
51    A -- "Saves/Reads state" --> B
52```
53~
54### Control Plane
55~
56Het 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:
57~
58-   **API Server (`kube-apiserver`)**: De toegangspoort tot het cluster. Het stelt de Kubernetes API beschikbaar.
59-   **etcd**: Een consistente en hoog beschikbare key-value database. Het slaat alle clusterdata op.
60-   **Scheduler (`kube-scheduler`)**: Wijst nieuw aangemaakte Pods toe aan een beschikbare Worker Node.
61-   **Controller Manager (`kube-controller-manager`)**: Draait controllers die de staat van het cluster bewaken en naar de gewenste staat werken.
62~
63### Worker Node
64~
65Worker Nodes zijn de machines waar de applicaties daadwerkelijk draaien. Elk node bevat:
66~
67-   **Kubelet**: Een agent die op elk node draait. Het zorgt ervoor dat de containers in de Pods draaien en gezond zijn.
68-   **Kube-proxy**: Een netwerkproxy die netwerkregels op de nodes beheert.
69-   **Container Runtime**: De software verantwoordelijk voor het draaien van containers. Docker is de bekendste, maar Kubernetes ondersteunt ook `containerd` en `CRI-O`.
70~
71## Fundamentele Kubernetes Objecten
72~
73In 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.
74~
75### Pod
76~
77De **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.
78~
79### Deployment
80~
81Een **Deployment** is het object dat je het vaakst zult gebruiken. Het beschrijft de gewenste staat voor een groep identieke Pods.
82~
83```yaml
84# nginx-deployment.yaml
85apiVersion: apps/v1
86kind: Deployment
87metadata:
88  name: nginx-deployment
89spec:
90  replicas: 3
91  selector:
92    matchLabels:
93      app: nginx
94  template:
95    metadata:
96      labels:
97        app: nginx
98    spec:
99      containers:
100      - name: nginx
101        image: nginx:1.14.2
102        ports:
103        - containerPort: 80
104```
105~
106### Service
107~
108Pods 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**.
109~
110```mermaid
111graph TD
112    subgraph "Service (nginx-service)"
113        A["ClusterIP: 10.96.0.10"]
114    end
115~
116    subgraph "Pods"
117        B("Pod 1 - IP: 192.168.1.2")
118        C("Pod 2 - IP: 192.168.1.3")
119        D("Pod 3 - IP: 192.168.1.4")
120    end
121~
122    A -- "Selector: app=nginx" --> B
123    A -- "Selector: app=nginx" --> C
124    A -- "Selector: app=nginx" --> D
125~
126    Client -- "Request to nginx-service" --> A
127```
128~
129```yaml
130# nginx-service.yaml
131apiVersion: v1
132kind: Service
133metadata:
134  name: nginx-service
135spec:
136  selector:
137    app: nginx
138  ports:
139    - protocol: TCP
140      port: 80
141      targetPort: 80
142  type: ClusterIP # Default - exposes the service only within the cluster
143```
144~
145Er zijn verschillende soorten Services:
146- `ClusterIP`: Stelt de service beschikbaar op een cluster-intern IP (standaard).
147- `NodePort`: Stelt de service beschikbaar op een statische poort op elke Worker Node.
148- `LoadBalancer`: Maakt een externe load balancer aan in de cloudprovider.
149~
150### Ingress
151~
152Een **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.
153~
154```mermaid
155graph LR
156    User -- "mysite.com/api" --> Ingress
157    User -- "mysite.com/ui" --> Ingress
158~
159    subgraph "Cluster"
160        Ingress -- "/api" --> ServiceA("api-service")
161        Ingress -- "/ui" --> ServiceB("ui-service")
162~
163        ServiceA --> PodA1("API Pod 1")
164        ServiceA --> PodA2("API Pod 2")
165~
166        ServiceB --> PodB1("UI Pod 1")
167        ServiceB --> PodB2("UI Pod 2")
168    end
169```
170~
171```yaml
172# example-ingress.yaml
173apiVersion: networking.k8s.io/v1
174kind: Ingress
175metadata:
176  name: example-ingress
177spec:
178  rules:
179  - host: mysite.com
180    http:
181      paths:
182      - path: /api
183        pathType: Prefix
184        backend:
185          service:
186            name: api-service
187            port:
188              number: 8080
189      - path: /ui
190        pathType: Prefix
191        backend:
192          service:
193            name: ui-service
194            port:
195              number: 3000
196```
197~
198### Andere Nuttige Objecten
199~
200-   **Namespace**: Maakt "virtuele clusters" binnen een fysiek cluster mogelijk.
201-   **ConfigMap en Secret**: Voor het beheren van configuratiegegevens en geheimen.
202-   **StatefulSet**: Vergelijkbaar met een Deployment, maar specifiek voor stateful applicaties.
203-   **PersistentVolume (PV) en PersistentVolumeClaim (PVC)**: Voor het beheren van persistente opslag.
204~
205## Conclusie
206~
207Kubernetes 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.
208~
209**Wat nu te doen?**
210- **Experimenteer lokaal**: Installeer [Minikube](https://minikube.sigs.k8s.io/docs/start/) of [Kind](https://kind.sigs.k8s.io/docs/user/quick-start/) om een Kubernetes-cluster op je computer te maken.
211- **Gebruik `kubectl`**: Maak je vertrouwd met het `kubectl`-commando.
212- **Verken de officiële tutorials**: De [Kubernetes-documentatie](https://kubernetes.io/docs/tutorials/) is een fantastische bron vol voorbeelden.
213~
214Containerorkestratie is een fundamentele vaardigheid in de cloud-native wereld, en het beheersen van Kubernetes opent een wereld van mogelijkheden. Veel plezier!
215~