Wie Kubernetes wirklich funktioniert: eine Steuerschleife, ein Anfragepfad
Die meisten Einführungen in Kubernetes beginnen beim Werkzeug: ein Cluster,
ein kubectl, eine erste YAML-Datei. Diese Reihenfolge ist verständlich,
aber sie verdeckt die eine Idee, die das System zusammenhält. Kubernetes ist
kein Scheduler mit angeflanschter API. Kubernetes ist ein Speicher für den
gewünschten Zustand, umgeben von unabhängigen Komponenten, die diesen
Speicher beobachten und die Wirklichkeit Schritt für Schritt an ihn
angleichen. Wer diese Idee verstanden hat, liest den Rest der Architektur als
Konsequenz und nicht als Liste von Bauteilen.
Dieser Artikel beantwortet zwei Fragen, und das Diagramm darunter beantwortet beide in einem Bild:
- Wie wird aus einer Absicht wie „betreibe vier Kopien der Version 2 des Checkout-Dienstes“ ein Satz laufender Container auf echten Maschinen?
- Wie findet eine Anfrage aus dem Internet einen dieser Container, und zwar nur einen, der tatsächlich bereit ist, sie zu bedienen?
Die erste Frage beantwortet die Steuerschleife (im Diagramm der control loop, Schritte 1 bis 5). Die zweite beantwortet der Anfragepfad (der request path, Schritte A bis D). Alles andere in Kubernetes, von Rolling Updates über Selbstheilung bis GitOps, ist eine Variation dieser beiden Pfade. Die Beschriftung des Diagramms ist englisch, so wie die Begriffe in Kubernetes selbst.
Gewünschter Zustand: was „deklarativ“ wirklich bedeutet
Einen Kubernetes-Cluster betreibt man, indem man ein Ziel beschreibt, nicht indem man eine Folge von Befehlen erteilt. Das Ziel in unserem Beispiel ist klein:
apiVersion: apps/v1
kind: Deployment
metadata:
name: checkout
spec:
replicas: 4
template:
spec:
containers:
- name: checkout
image: checkout:v2
Nichts in diesem Dokument sagt, wie das Ziel erreicht werden soll. Es nennt
keine Maschine, es legt nicht fest, welche Kopie zuerst startet, und es sagt
nicht, was passieren soll, wenn eine Maschine verschwindet. Es stellt nur
fest, was gelten soll: Vier Replikate von checkout:v2 sollen laufen. Dieses
Dokument ist der gewünschte Zustand (desired state), und der gesamte
Cluster ist darauf ausgerichtet, den beobachteten Zustand (observed
state) damit in Deckung zu bringen, fortlaufend und so lange, wie das
Dokument existiert.
Dieser Unterschied ist für alle wichtig, die mit Kubernetes planen, nicht nur für diejenigen, die das YAML tippen. Ein deklaratives System lässt sich versionieren, prüfen und reproduzieren, weil die Eingabe eine Beschreibung ist und kein Protokoll von Handlungen. Es verhält sich auch im Fehlerfall anders: Ein System, das ein Skript ausführt, ist fertig, wenn das Skript endet. Ein System, das einen gewünschten Zustand abgleicht, wird dagegen nie fertig und korrigiert Abweichungen kontinuierlich.
Der API-Server ist die zentrale Schnittstelle
Jeder Pfeil in der oberen Hälfte des Diagramms beginnt oder endet am API-Server, und das ist keine Vereinfachung zugunsten der Zeichnung. In Kubernetes ist der API-Server die einzige Komponente, die aus etcd liest oder dorthin schreibt, dem Key-Value-Speicher, der jedes Objekt des Clusters enthält. Entwickler, CI-Pipelines und GitOps-Werkzeuge sprechen mit dem API-Server. Der Controller Manager, der Scheduler und jedes kubelet auf jedem Node sprechen ebenfalls mit dem API-Server. Keine dieser Komponenten spricht direkt mit einer anderen, und keine fasst etcd an.
Diese zentrale Schnittstelle macht einen Kubernetes-Cluster überhaupt erst beherrschbar. Weil jede Änderung durch dieselbe Stelle geht, kann diese Stelle Authentifizierung, Autorisierung (RBAC) und Admission Control einheitlich durchsetzen und ein Audit-Log schreiben, das jeden Akteur erfasst, ob Mensch oder Maschine. Eine Organisation, die wissen will, wer was in der Produktion geändert hat, oder die Container-Images aus nicht freigegebenen Registries blockieren möchte, setzt das einmal am API-Server um, und es gilt für jeden Weg in den Cluster.
Hinweis
etcd ist von außen betrachtet absichtlich unspektakulär. Es ist ein konsistenter, replizierter Speicher mit einem Watch-Mechanismus, und genau auf diesem Mechanismus baut der Rest der Architektur auf. Komponenten fragen nicht in Schleifen nach Änderungen. Sie abonnieren über den API-Server und werden benachrichtigt, sobald ein Objekt, das sie betrifft, angelegt, geändert oder gelöscht wird.
Die Steuerschleife: von der Spezifikation zum laufenden Container
Mit dieser Schnittstelle im Blick lässt sich die obere Hälfte des Diagramms als Abfolge lesen, obwohl die beteiligten Komponenten sich nie ausdrücklich miteinander abstimmen.
Schritt 1: Die Spezifikation wird eingereicht. Jemand führt
kubectl apply aus, eine Pipeline tut dasselbe, oder ein GitOps-Controller
synchronisiert die Datei aus einem Repository. In allen drei Fällen ist das
Ergebnis identisch: Der API-Server validiert das Deployment, schickt es durch
die Admission Control und legt es in etcd ab. Zu diesem Zeitpunkt läuft noch
nichts. Ein Deployment ist ein Datensatz, kein Prozess.
Schritt 2: Der Datensatz wird gespeichert. etcd enthält nun ein
Deployment namens checkout, dessen gewünschter Zustand vier Replikate von
checkout:v2 vorsieht. Jede Komponente, die einen Watch auf Deployments
registriert hat, wird informiert.
Schritt 3: Controller gleichen ab. Der Controller Manager beherbergt eine Sammlung von Steuerschleifen, jede zuständig für eine Objektart. Der Deployment-Controller bemerkt das neue Deployment und tut das Einzige, was er kann: Er stellt sicher, dass ein passendes ReplicaSet existiert. Der ReplicaSet-Controller bemerkt das neue ReplicaSet und stellt sicher, dass vier Pod-Objekte existieren. Jeder Controller vergleicht für seine Objektart den gewünschten mit dem beobachteten Zustand und nimmt die kleinste Änderung vor, die die Lücke schließt. Kein Controller erteilt einem anderen Anweisungen. Sie schreiben nur Objekte in den API-Server, und der nächste Controller in der Kette reagiert auf diese Schreibvorgänge.
Das ist der Kern des Modells, und es lohnt sich, ihn klar auszusprechen: Ein Controller ist eine Schleife, die beobachtet, vergleicht und korrigiert. Der Deployment-Controller weiß nicht, wie Pods gestartet werden. Der ReplicaSet-Controller weiß nicht, auf welchem Node ein Pod landen wird. Jede Schleife ist einfach, und das Verhalten des Systems entsteht aus vielen einfachen Schleifen, die nebeneinander laufen.
Schritt 4: Der Scheduler weist Nodes zu. Die vier neuen Pods existieren als Objekte, aber keiner davon ist an eine Maschine gebunden. Der Scheduler beobachtet genau diesen Zustand, einen Pod ohne Node, und wählt für jeden einen Node, der die Anforderungen des Pods erfüllt: genügend CPU und Arbeitsspeicher, passende Labels, Affinitäts- und Anti-Affinitätsregeln, Taints und Tolerations. Diese Entscheidung schreibt er als Binding zurück in den API-Server. Der Scheduler entscheidet, aber er führt nicht aus. Er startet nie einen Container.
Schritt 5: Das kubelet startet die Container. Auf jedem Node beobachtet ein kubelet die Pods, die an seinen eigenen Node gebunden sind. Taucht einer auf, zieht das kubelet das zugehörige Image und bittet die Container Runtime des Nodes, etwa containerd oder CRI-O, die Container zu starten. Die Kommunikation zwischen kubelet und Runtime läuft über das Container Runtime Interface (CRI), und deshalb kann Kubernetes auf verschiedenen Runtimes laufen, ohne dass sich oberhalb des Nodes etwas ändert. Anschließend meldet das kubelet den Status an den API-Server zurück: ob die Container laufen, ob sie gesund sind und, wie wir gleich sehen werden, ob sie bereit sind, Anfragen anzunehmen.
Als Ganzes gelesen zeigen die Schritte 1 bis 5, dass Kubernetes nie einen Plan abarbeitet. Jede Komponente reagiert auf eine Änderung des gemeinsamen Zustands und steuert ihren Teil bei. Fällt ein Node aus, meldet sich das kubelet dort nicht mehr, die Pods gelten nach einer Weile als verloren. Der ReplicaSet-Controller sieht drei Pods, wo vier gewünscht sind, und die Schleife läuft ab Schritt 3 erneut. Selbstheilung ist kein optionales Feature, das nachträglich implementiert wurde, sondern ein inhärenter Bestandteil der Lösung. Die Steuerschleife regelt das ganz natürlich, wenn sich der beobachtete Zustand aus irgendeinem Grund ändert.
Der Anfragepfad: vom Client zum bereiten Pod
Die untere Hälfte des Diagramms beantwortet die zweite Frage. Vier Pods laufen nun, und ein Client im Internet möchte den Checkout-Dienst erreichen.
Schritt A: Der externe Load Balancer. Die Anfrage trifft zuerst bei einem
Load Balancer außerhalb des Clusters ein, den typischerweise die
Cloud-Plattform bereitstellt. Er besitzt die öffentliche IP-Adresse,
terminiert in der Regel TLS und leitet den Verkehr an die Nodes des Clusters
weiter. Kubernetes fordert diesen Load Balancer über einen Service vom Typ
LoadBalancer an, aber der Load Balancer selbst läuft in der Infrastruktur
des Anbieters, nicht im Cluster.
Schritt B: Der Ingress-Controller. Im Cluster erreicht die Anfrage einen Ingress-Controller, zum Beispiel NGINX oder Traefik. An dieser Stelle stutzen Einsteiger regelmäßig: Der Ingress-Controller ist selbst ein ganz gewöhnlicher Satz von Pods, den dieselbe Steuerschleife einplant und überwacht. Er liest Ingress-Objekte aus dem API-Server und konfiguriert seinen Proxy entsprechend, sodass Anfragen nach Hostname und Pfad an den richtigen Service gelangen.
Hinweis
Ingress und die neuere Gateway API sind zwei getrennte Kubernetes-APIs, die beschreiben, wie Verkehr in den Cluster gelangt. Keine von beiden tut von sich aus etwas. Beide sind Deklarationen, die ein Controller, der als Pods läuft, beobachten und umsetzen muss. Ein Cluster ohne einen solchen Controller nimmt Ingress-Objekte entgegen und routet stillschweigend nichts.
Schritt C: Der Service. Der Ingress-Controller leitet die Anfrage an den
Service namens checkout weiter. Der Service ist das am häufigsten
missverstandene Objekt in Kubernetes, und der Untertitel des Diagramms nennt
die Richtigstellung: Ein Service ist ein Regelsatz, kein Prozess. Es gibt
keinen Service-Daemon, der ein Paket entgegennimmt und weiterreicht. Ein
Service ist eine stabile virtuelle IP-Adresse plus ein Label-Selektor, hier
app=checkout. Eine Komponente namens kube-proxy läuft auf jedem Node
und übersetzt diese Definition in Weiterleitungsregeln im Kernel des Nodes,
sodass Verkehr an die virtuelle IP auf die Adresse eines der passenden Pods
umgeschrieben wird. Die Weiterleitung passiert im Netzwerkstack, nicht in
einem Prozess im Userspace.
Welche Pods infrage kommen, steht in den EndpointSlices, und hier kommt die Readiness ins Spiel. Im Diagramm sind die Pods A, B und C bereit, Pod D ist es nicht. Pod D existiert, er ist eingeplant, sein Container läuft vielleicht sogar schon, aber seine Readiness-Probe war noch nicht erfolgreich. Vielleicht wärmt er noch einen Cache auf oder wartet auf eine Datenbankverbindung. Solange das so ist, steht Pod D nicht als Endpunkt des Service in der Liste und bekommt keinen Verkehr. Dieser Mechanismus macht Rolling Updates sicher: Ein neuer Pod erhält erst dann Anfragen, wenn er dem kubelet mitgeteilt hat, dass er sie verarbeiten kann.
Schritt D: Der Pod. Die Anfrage erreicht einen der bereiten Pods und wird vom Checkout-Container beantwortet. Die Antwort nimmt denselben Weg zurück.
Hinweis
In der Praxis schicken viele Ingress-Controller den Verkehr gar nicht an die virtuelle IP des Service. Sie beobachten die EndpointSlices selbst und leiten direkt an die IP-Adressen der bereiten Pods weiter, was ihnen mehr Kontrolle über Lastverteilung, Wiederholungen und die Wiederverwendung von Verbindungen gibt. Der Service bleibt trotzdem wichtig, nämlich als Deklaration, welche Pods zusammengehören und welche davon bereit sind. Der Controller liest diese Deklaration nur direkt, statt den Umweg über die Regeln von kube-proxy zu nehmen.
Was daraus für Architektur und Betrieb folgt
Ein mentales Modell ist nur dann nützlich, wenn es Entscheidungen verändert. Vier Konsequenzen der beiden Pfade tauchen in fast jedem Projekt auf.
Fehlersuche folgt der Steuerschleife. Wenn eine Arbeitslast nicht
hochkommt, liegt die Ursache an einem bestimmten Schritt, und die Schritte
sind geordnet. Existiert das Deployment, und ist seine Spezifikation die, die
du erwartest (Schritte 1 und 2)? Haben die Controller ein ReplicaSet und die
Pods angelegt (Schritt 3)? Hängen die Pods in „Pending“, weil der Scheduler
keinen passenden Node findet (Schritt 4)? Konnte das kubelet das Image nicht
ziehen, oder ist der Container abgestürzt (Schritt 5)? Erst wenn die Pods
laufen, wird der Anfragepfad zur Frage: Ist der Pod bereit, steht er als
Endpunkt in der Liste, zeigt der Ingress auf den richtigen Service? Teams,
die sich diese Reihenfolge angeeignet haben, hören auf zu raten und lesen das
System von oben nach unten. In kubectl ausgedrückt sieht diese
Lesereihenfolge so aus:
# Schritte 1 und 2: Ist die gespeicherte Spezifikation die erwartete?
kubectl get deployment checkout -o yaml
# Schritt 3: Haben die Controller ReplicaSet und Pods angelegt?
kubectl get replicaset,pods -l app=checkout
# Schritte 4 und 5: Die Events verraten Scheduling, Image-Pulls und Abstürze
kubectl describe pod <pod>
# Schritt 5: Warum hat sich der vorherige Container beendet?
kubectl logs <pod> --previous
# Schritt C: Welche Pods hält der Service gerade für bereit?
kubectl get endpointslices -l kubernetes.io/service-name=checkout
# Schritt B: Zeigt die Route auf den richtigen Service und Port?
kubectl describe ingress checkout
GitOps überträgt das Prinzip der Steuerschleife auf Git. Wenn der Cluster sich selbst an die Objekte in etcd angleicht, liegt der nächste Schritt nahe: etcd an ein Git-Repository anzugleichen. Genau das tun Werkzeuge wie Argo CD und Flux. Sie sind Controller, deren gewünschter Zustand in einem Repository liegt, und sie korrigieren den Cluster fortlaufend in dessen Richtung. Das folgt exakt der Logik von Kubernetes: Es ist dasselbe Muster, eine Ebene höher angewendet, und es macht das Repository zur geprüften, nachvollziehbaren Quelle der Wahrheit für das, was in der Produktion läuft.
Readiness ist ein Vertrag, kein Häkchen. Weil der Service an Pods routet, die ihre Bereitschaft signalisiert haben, führt eine Readiness-Probe, die zu früh „ja“ sagt, dazu, dass Rolling Updates Anfragen verlieren. Eine Probe, die nie „ja“ sagt, lässt ein Deployment hängen, ohne dass irgendwo ein Fehler auftaucht. Die Readiness-Probe ist der Weg, über den eine Anwendung der Kubernetes-Plattform ihren Status mitteilt, und sie verdient dieselbe Sorgfalt wie die Fachlogik.
Ausfallsicherheit der Control Plane heißt vor allem API-Server und etcd. Jeder Pfad im Diagramm läuft über den API-Server, und jedes Objekt liegt in etcd. Arbeitslasten, die bereits laufen, laufen ohne die beiden weiter, weil das kubelet und die Kernel-Regeln auf jedem Node für den Anfragepfad keine Control Plane brauchen. Ändern lässt sich dann aber nichts mehr: kein Skalieren, kein Rollout, kein Ersatz für einen ausgefallenen Pod. Wer ein Managed-Kubernetes-Angebot bewertet, sollte das Kapitel zu Verfügbarkeit und Sicherung dieser beiden Komponenten besonders aufmerksam lesen.
Das Modell kompakt zusammengefasst
Kubernetes speichert, was gelten soll, und lässt unabhängige Schleifen dafür sorgen, dass die Erwartungen umgesetzt werden. Jede der Schleifen beobachtet den API-Server, vergleicht den gewünschten mit dem beobachteten Zustand und korrigiert Abweichungen. Eingehender Datenverkehr erreicht sein Ziel über eine Kette von Deklarationen, vom Load Balancer über den Ingress bis zum Service, die Controller in Weiterleitungsregeln übersetzen. Ausschließlich Pods, die sich selbst als bereit gemeldet haben, sind Teil dieser Kette.
Alles Weitere, von Helm-Charts über Service Meshes bis zu Operatoren, baut auf diesen beiden Ideen auf. Ein Team, das dieses Diagramm aus dem Gedächtnis zeichnen kann, ist gut aufgestellt, um zu beurteilen, welche dieser Ergänzungen es tatsächlich braucht.
Kommentare