kubernetes: Kubernetes

Een cluster dat drie replicas belooft en er twee draait, is geen storing maar een tussenstand: Kubernetes vergelijkt de gewenste toestand met de werkelijke en blijft sleutelen tot ze gelijk zijn. Dat declaratieve model is het hele punt, en tegelijk de reden dat je er niet even op een vrijdagmiddag bij stapt.

Dit stuk helpt je kiezen: welke Kubernetes je neemt, welke tools eromheen, en wat elke keuze je kost.

Kubernetes is een open source platform voor het automatiseren van het uitrollen, schalen en beheren van containerized applicaties. Het begon bij Google, valt nu onder de Cloud Native Computing Foundation (CNCF), en heet in de wandelgangen K8s. Je beschrijft hoe de wereld eruit moet zien, het platform zorgt dat het zo wordt. Of tegenblijft proberen tot het zo is.

De abstractie is de kern. Je draait applicaties niet meer direct op fysieke of virtuele machines, maar in containers die Kubernetes beheert. Die containers leven in pods, de kleinste uitvoerbare eenheid. Een pod bevat één of meerdere containers die logisch bij elkaar horen, bijvoorbeeld de applicatie plus een log-shipper. Kubernetes start ze, houdt ze in de gaten en herstart wat omvalt.

Dat declaratieve model heet reconciliation. Je zegt "ik wil drie replicas van mijn webserver" en controller-processen in het cluster vergelijken die wens met de werkelijkheid, waarna ze het verschil dichten. Dat maakt het systeem zelfherstellend. Het maakt het ook ondoorzichtig als je niet weet welke controller waarvoor verantwoordelijk is. Er is altijd wel een proces dat iets probeert te repareren wat jij expres anders had gedaan.

Een cluster bestaat uit control plane nodes en worker nodes. De control plane beheert: de API-server als centraal toegangspunt, etcd als single source of truth voor configuratie en status, de scheduler die beslist waar een pod landt, en de controller manager die achtergrondtaken draait. De worker nodes draaien het echte werk: een kubelet als agent, een container runtime zoals containerd of CRI-O, en kube-proxy voor netwerkregels. Alles wat je doet, gaat via de API-server. Er is geen achterdeur, en dat is een feature tot je hem mist.

Pods zijn vluchtig. Daarom zijn er services: een stabiel netwerk-endpoint voor een groep pods, zodat clients niet meebewegen met elke herstart. Deployments beschrijven declaratief hoe een applicatie wordt uitgerold en geschaald. DaemonSets zetten een pod op elk worker node. StatefulSets zijn voor stateful werk zoals databases, waar elke pod een unieke identiteit en persistente opslag nodig heeft. Voor configuratie en geheimen zijn er ConfigMaps en Secrets, zodat dezelfde image in ontwikkeling, test en productie met andere instellingen draait. De image blijft gelijk, de omgeving niet.

Tot zover het platform. Dan de vraag waar dit stuk eigenlijk over gaat: hoe kom je erin zonder verdwaald te raken.

De command-line is de waarheid. `kubectl` is wat de API-server rechtstreeks aanspreekt, en elke GUI eromheen vertaalt uiteindelijk naar dezelfde calls. Wie de CLI niet kent, ziet in een grafische tool alleen maar groene en rode blokjes zonder te weten wat eronder gebeurt. Dat is de prijs van een mooie interface: je leert het echte gereedschap nooit.

Toch zijn er goede grafische tools, en ze lossen een echt probleem op. Een cluster met tientallen namespaces, honderden pods en rollende deployments lees je niet fijn uit een terminal die elke keer opnieuw moet verbinden.

Headlamp is een web UI, ontwikkeld door Kinvolk, onder de Apache-2.0-licentie. Het toont pods, services en deployments in een overzicht en breidt uit via plugins. Je installeert het als Flatpak. Het is bewust simpel gehouden, en dat merk je: wat het doet, doet het overzichtelijk, maar je zoekt er niet de fijne diagnostiek in die een specialist nodig heeft.

Seabird is een Kubernetes IDE voor het GNOME-bureaublad, van het Seabird Project, onder MPL-2.0. Het heeft een ingebouwde terminal, log- en metric-monitoring, en een resource-editor met API-referentie. Ook via Flatpak. De API-referentie in de editor is het interessante deel: je leert het objectmodel terwijl je klikt. De keerzijde is dat het zich vastbijt in GNOME. Draai je iets anders, dan wordt het passen en meten.

Freelens is een gratis, community-gebaseerde Kubernetes IDE. Dashboard met real-time inzichten, meerdere clusters tegelijk, ingebouwde terminal, visualisatie van workloads, netwerken en opslag, en extensies voor maatwerk. Het is de tool voor wie veel clusters naast elkaar beheert en niet elke keer van context wil wisselen. Die flexibiliteit vraagt wel dat je zelf structuur aanbrengt. Een dashboard dat alles toont, toont ook alles wat je niet zoekt.

RustConn is een andere hoek: een verbindingsmanager die naast SSH, RDP en VNC ook Kubernetes-verbindingen beheert. Centrale plek, groepering, tagging, terminal splitsing, automatisering via scripts en synchronisatie via Cloud Sync. Voor wie meerdere clusters en systemen door elkaar gebruikt en geen zin heeft in vijf losse clients. De prijs is dat het generiek is. Het is geen Kubernetes-tool met Kubernetes-diepgang, het is een verbindingsbeheerder die Kubernetes meeneemt.

Dan de containerkant. Podman Desktop is een open source grafische tool die Podman en andere container engines vanuit één UI bestuurt. Images bouwen uit Dockerfiles of Containerfiles, containers starten en stoppen, logs bekijken, images naar OCI-registers pushen. Het ondersteunt ook Kubernetes-workloads, zodat je lokaal kunt ontwikkelen zonder Docker. Dat laatste is precies waarom mensen het kiezen: geen daemon die als root draait op je werkstation.

Docker Desktop is geen Kubernetes-oplossing, maar heeft wel een ingebouwde clusteroptie voor ontwikkelomgevingen op Mac, Linux en Windows. Het zet een lokale Kubernetes op zonder gedoe, met een GUI voor containers, applicaties en images, en regelt poortmappings en bestandssysteemintegratie. Voor wie snel iets lokaal wil draaien is dat de kortste weg. Je betaalt ervoor met een gesloten tool en een licentie die voor grotere organisaties geld kost. Dat is een eerlijke ruil, zolang je hem bewust aangaat.

Onder de motorkap gebruikt Kubernetes iptables-regels op hostniveau voor netwerkbeveiliging, vooral bij bridge-netwerken. Docker zet die regels automatisch op. Je kunt dat uitschakelen via daemon-opties, en dan breekt je cluster-netwerk. Doe het niet.

Kubernetes is uitbreidbaar: custom resources en operators automatiseren werkstromen die het platform zelf niet kent. Extensions kunnen via labels in een Dockerfile worden gedefinieerd en in marktplaatsen verschijnen. Dat is de reden dat het zo breed is geadopteerd, en ook de reden dat elk cluster er anders uitziet. Er is geen standaard Kubernetes, er is jouw Kubernetes.

Dus waar hangt de keuze van af.

Begin je net, dan is de CLI plus één simpele UI genoeg, en leer je meer van `kubectl describe` dan van welk dashboard dan ook. Beheer je veel clusters, dan wegen Freelens of RustConn hun complexiteit terug. Werk je op GNOME en wil je het objectmodel leren, dan is Seabird het overwegen waard. Wil je lokaal ontwikkelen zonder Docker, dan is Podman Desktop de logische route. En wil je gewoon snel een cluster op je laptop, dan doet Docker Desktop dat prima, tegen de prijs van een gesloten ecosysteem.

Wat je ook kiest: het dashboard is nooit het cluster. Het is een bril erop.