Architektur

Wie Kubernetes wirklich funktioniert: eine Steuerschleife, ein Anfragepfad

·Architektur·11 Min Lesezeit

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:

  1. Wie wird aus einer Absicht wie „betreibe vier Kopien der Version 2 des Checkout-Dienstes“ ein Satz laufender Container auf echten Maschinen?
  2. 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.

Kubernetes – control loop and request path Kubernetes — control loop and request path Everything goes through the API server · components watch and reconcile · a Service is a rule set, not a process Engineer · CI · GitOps write or update the spec Deployment spec desired state, declarative (YAML) image: checkout:v2 · replicas: 4 LEGEND control flow (watch / write) request traffic logical API object, no process 1 control loop steps A request path steps KUBERNETES CLUSTER CONTROL PLANE API server the only door — every component reads and writes cluster state here 2 etcd stores cluster state · only the API server talks to it 3 Controller manager Deployment → ReplicaSet → 4 Pods 4 Scheduler binds each pending Pod to a node WORKER NODES Worker node 1 Worker node 2 Container runtime containerd, CRI-O · runs containers kubelet node agent · runs assigned Pods kubelet node agent · runs assigned Pods Container runtime containerd, CRI-O · runs containers CRI CRI REPLICASET checkout-v2 · owns 4 Pods · label app=checkout Pod A ready container · checkout:v2 Pod B ready container · checkout:v2 Pod C ready container · checkout:v2 Pod D not ready · no traffic container · checkout:v2 Service checkout virtual IP · selector app=checkout · ready Pods only Ingress controller Pod NGINX, Traefik … · applies routing rules kube-proxy programs the Service rules on this node kube-proxy programs the Service rules on this node Ingress controller Pod NGINX, Traefik … · applies routing rules Client browser · API consumer External load balancer cloud LB · public IP · TLS entry Ingress and Gateway API are two separate APIs; both need a controller running as Pods. Many controllers skip the virtual IP and send straight to ready Pod IPs (EndpointSlices). 1 kubectl apply · GitOps sync 5 watch · report status 5 same on every node A B C C D AAAWgmp1bWIAAAAeanVtZGMycGEAEQAQgAAAqgA4m3EDYzJwYQAAABZcanVtYgAAAEdqdW1kYzJtYQARABCAAACqADibcQN1cm46YzJwYTplYjBhNGY0ZS04Mzk5LTQ1OTAtYTQ2Mi01ZGRjODk0MTRhZGUAAAADl2p1bWIAAAApanVtZGMyYXMAEQAQgAAAqgA4m3EDYzJwYS5hc3NlcnRpb25zAAAAALxqdW1iAAAARGp1bWRjYm9yABEAEIAAAKoAOJtxE2MycGEuaW5ncmVkaWVudC52MwAAAAAYYzJzaPhYt09vXLDJBoBhDCk1+9cAAABwY2JvcqNpZGM6Zm9ybWF0bWltYWdlL3N2Zyt4bWxqaW5zdGFuY2VJRHgseG1wOmlpZDphMzVmMDM5MC1hMmE4LTQ2NDQtODliOC1kODBjMDkwOTVhZWFscmVsYXRpb25zaGlwaHBhcmVudE9mAAAB4mp1bWIAAABBanVtZGNib3IAEQAQgAAAqgA4m3ETYzJwYS5hY3Rpb25zLnYyAAAAABhjMnNoTbcC8EX/EhgkX2J0CbKj+wAAAZljYm9yomdhY3Rpb25zgqJmYWN0aW9ua2MycGEub3BlbmVkanBhcmFtZXRlcnOha2luZ3JlZGllbnRzgaJjdXJseC1zZWxmI2p1bWJmPWMycGEuYXNzZXJ0aW9ucy9jMnBhLmluZ3JlZGllbnQudjNkaGFzaFggYArHsZEFYrC9hAssvJYVD74PJQPdd45esTDSbl50UtqkZmFjdGlvbngdY29tLmFudGhyb3BpYy5jbGF1ZGUucHJvdmlkZWRqcGFyYW1ldGVyc6F4H2NvbS5hbnRocm9waWMub3JpZ2luLWNvbmZpZGVuY2VndW5rbm93bmtkZXNjcmlwdGlvbnhmQ2xhdWRlIHByb3ZpZGVkIHRoaXMgZmlsZSBhdCB0aGUgcmVxdWVzdCBvZiBhIHVzZXIgYW5kIG1heSBoYXZlIGNyZWF0ZWQgb3IgbW9kaWZpZWQgdGhlIGZpbGUgY29udGVudHMubXNvZnR3YXJlQWdlbnShZG5hbWVmQ2xhdWRlcmFsbEFjdGlvbnNJbmNsdWRlZPUAAADIanVtYgAAAEBqdW1kY2JvcgARABCAAACqADibcRNjMnBhLmhhc2guZGF0YQAAAAAYYzJzaEIOpmipg1oQZXvLJBGDdBUAAACAY2JvcqVjYWxnZnNoYTI1NmNwYWRMAAAAAAAAAAAAAAAAZGhhc2hYIH3ld8Xf51QiQQb0396eqjShQ3ZQAFhCg5yVIB3kMzsaZG5hbWVuanVtYmYgbWFuaWZlc3RqZXhjbHVzaW9uc4GiZXN0YXJ0GU2AZmxlbmd0aBkeBAAAAj5qdW1iAAAAJ2p1bWRjMmNsABEAEIAAAKoAOJtxA2MycGEuY2xhaW0udjIAAAACD2Nib3KlY2FsZ2ZzaGEyNTZpc2lnbmF0dXJleE1zZWxmI2p1bWJmPS9jMnBhL3VybjpjMnBhOmViMGE0ZjRlLTgzOTktNDU5MC1hNDYyLTVkZGM4OTQxNGFkZS9jMnBhLnNpZ25hdHVyZWppbnN0YW5jZUlEeCx4bXA6aWlkOjQ4MmU1Y2ZhLTI0ZTktNDUwOC05OTlkLTQ2Mjc0ZTIwMjE0MXJjcmVhdGVkX2Fzc2VydGlvbnODomN1cmx4LXNlbGYjanVtYmY9YzJwYS5hc3NlcnRpb25zL2MycGEuaW5ncmVkaWVudC52M2RoYXNoWCBgCsexkQVisL2ECyy8lhUPvg8lA913jl6xMNJuXnRS2qJjdXJseCpzZWxmI2p1bWJmPWMycGEuYXNzZXJ0aW9ucy9jMnBhLmFjdGlvbnMudjJkaGFzaFggtsJ8mVRucR+G1l8YOMQYr2s60+CxVyPGBMXsgicjOB+iY3VybHgpc2VsZiNqdW1iZj1jMnBhLmFzc2VydGlvbnMvYzJwYS5oYXNoLmRhdGFkaGFzaFgg0IF3rkZo69r+a8nL+uGz5gRyng8ELgshEWjFkUv2PdN0Y2xhaW1fZ2VuZXJhdG9yX2luZm+jZG5hbWVvQW50aHJvcGljIEZpbGVzZ3ZlcnNpb25lMS4wLjBrc3BlY1ZlcnNpb25lMi40LjAAABA4anVtYgAAAChqdW1kYzJjcwARABCAAACqADibcQNjMnBhLnNpZ25hdHVyZQAAABAIY2JvctKEWQISogEmGCFZAgowggIGMIIBjaADAgECAhRA5aAK7sI50L64g/oGQgU9Z1UTADAKBggqhkjOPQQDAzBJMRcwFQYDVQQKEw5BbnRocm9waWMsIFBCQzEuMCwGA1UEAxMlQW50aHJvcGljIENvbnRlbnQgQ3JlZGVudGlhbHMgUm9vdCBDQTAeFw0yNjA4MDcxODQzNTZaFw0yODA4MDYxOTQzNTZaMEQxFzAVBgNVBAoTDkFudGhyb3BpYywgUEJDMSkwJwYDVQQDEyBBbnRocm9waWMgQ2xhdWRlIENvbnRlbnQgU2lnbmluZzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABJh6CmvLUBgFFNU0vUKlOVtE6djd17L5SuwX0LemFisBM3dkd/3cyjxFA3Qo5S46fX0/ihY0VZ7mfb9KF703t5OjWDBWMA4GA1UdDwEB/wQEAwIHgDAVBgNVHSUEDjAMBgorBgEEAYPoXgIBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUzlHiBIFOZFsj+OPEz5o+nMHXXMIwCgYIKoZIzj0EAwMDZwAwZAIwMXMdFJ4BetLLVY7ORuE9noqbbAZOZn/aArXyTwFAZfKrPzxF2vPoJNf1+UCdg1XGAjBwX1zd9WGqYkqmL5SFqw1QySjr1zJfpJM9+1rdDwSPLMOPOjKuiXjoU/pUUeG9RwmhY3BhZFkNngAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPZYQHExgGzJeEc4+ggT0scB5BXLR5doxesCDa5+HzsJdXpiY62XzkxgSVKcY+TCRVkep/zKk+z5jWjwTZjA+GJyt3M=

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

Kommentar schreiben

Formular wird geladen …


Zurück zur Übersicht