Training Module

Kubernetes Administration — RBAC, Node-Betrieb und Cluster-Netzwerk

In diesem 120-Minuten-Modul wechselt ihr die Perspektive vom Manifest-Autor zum Cluster-Betreiber. Los geht es mit dem Namespace als logischer Unterteilung eines Clusters und der zugehörigen ResourceQuota – mit einer klaren Abgrenzung, die häufig durcheinandergeht: Ein Kubernetes-Namespace ist nicht dasselbe wie ein Linux-Namespace. Letzterer ist der Kernel-Mechanismus aus dem Einführungsmodul, auf dem Container-Isolation technisch aufbaut; der Kubernetes-Namespace ist eine reine API-Unterteilung eures Clusters und hat damit nichts zu tun. Danach folgt RBAC: ServiceAccount, Role/RoleBinding, ClusterRole/ClusterRoleBinding, und wie ihr mit kubectl auth can-i tatsächlich verifiziert, was ein Identität darf – an einem realistischen Beispiel, einem Read-only-ServiceAccount für ein CI-System. Der dritte Block ordnet das Cluster-Netzwerk ein: das CNI-Grundmodell, was kube-proxy und CoreDNS dabei jeweils leisten, und wie eine NetworkPolicy Traffic gezielt einschränkt. Im vierten Block geht es um Node-Administration: cordon/ drain/uncordon, Taints und Tolerations, Capacity vs. Allocatable, sowie kubectl top node über den Metrics Server. High Availability schließt das Modul als reines Konzept ab – Control-Plane-HA, etcd-Raft-Quorum und Worker-Node-Verteilung über Failure-Domains, bewusst ohne eigenes Hands-on, weil eine echte Multi-Control-Plane-Topologie mehrere echte Nodes oder VMs braucht und sich damit nicht in der Single-Node-Sandbox dieses Kurses nachstellen lässt. Voraussetzung ist das Modul “Kubernetes Workloads & Konfiguration” – die Session läuft weiterhin vollständig lokal über Minikube, ohne Cloud-Account und ohne Kostenwirkung.

Format

120 Minuten, live (remote oder vor Ort), Input & Hands-on

Teilnehmende

Entwickler:innen und Ops, die RBAC, Node-Betrieb und Cluster-Netzwerk-Grundlagen aus Administrator-Sicht verstehen wollen

Voraussetzungen

Abgeschlossenes Modul “Kubernetes Workloads & Konfiguration” oder gleichwertige Vorkenntnisse, lauffähige lokale Docker-Umgebung für Minikube

Warum dieses Training für deine Organisation wirkt

RBAC, das tatsächlich verifiziert wird

Ein ServiceAccount ohne geprüfte Rechte ist ein Blindflug. kubectl auth can-i macht aus einer Vermutung eine belegte Aussage – am realistischen Fall eines Read-only-CI-Systems statt an einem veralteten Tiller-Beispiel.

Node-Wartung ohne Ausfall

Ein Kernel-Update auf dem falschen Weg reißt laufende Workloads mit. cordon/drain/uncordon sowie Taints und Tolerations sind der Unterschied zwischen einer geplanten Wartung und einem ungeplanten Vorfall.

Ehrliche Grenze bei HA

Control-Plane-HA und etcd-Quorum lassen sich in einer Single-Node-Sandbox nicht seriös nachstellen. Dieses Modul sagt das offen – und vermittelt das Konzept trotzdem vollständig, als Frontalteil statt als vorgetäuschtes Hands-on.

Was Teilnehmende mitnehmen

  • Namespace als logische Unterteilung eines Clusters und ResourceQuota als Begrenzung einordnen – inklusive der Abgrenzung Kubernetes-Namespace ≠ Linux-Namespace.
  • ServiceAccount, Role/RoleBinding sowie ClusterRole/ClusterRoleBinding unterscheiden und selbst anlegen.
  • Mit kubectl auth can-i –as=system:serviceaccount:… verifizieren, was eine Identität tatsächlich darf, statt es anzunehmen.
  • Das CNI-Grundmodell sowie die Rollen von kube-proxy und CoreDNS im Cluster-Netzwerk benennen.
  • Eine NetworkPolicy schreiben, anwenden und live verifizieren, dass sie tatsächlich greift – inklusive der CNI-Voraussetzung dafür.
  • cordon/drain/uncordon sowie Taints/Tolerations für geplante Node-Wartung einsetzen, Capacity vs. Allocatable unterscheiden und kubectl top node über den Metrics Server lesen.
  • High Availability als Konzept einordnen: Control-Plane-HA per Load Balancer und kubeadm join –control-plane, etcd-Raft-Quorum/Snapshot, und Worker-Verteilung über Failure-Domains – ohne eigenes Hands-on.

Für wen dieses Modul ideal ist

  • • Entwickler:innen und Ops mit abgeschlossenem Modul “Kubernetes Workloads & Konfiguration” oder gleichwertigen Vorkenntnissen
  • • Alle, die demnächst RBAC-Rechte für ein CI-System oder ein Team vergeben und dabei nicht raten, sondern verifizieren wollen
  • • Teams, die vor der ersten geplanten Node-Wartung wissen wollen, wie sich Workloads sauber und ohne Ausfall umziehen lassen

Rahmendaten

  • • Dauer: 120 Minuten live (remote oder vor Ort)
  • • Format: Input, Live-Demo, Hands-on zu RBAC, NetworkPolicy und Node-Administration; High Availability als reiner Konzeptteil
  • • Voraussetzungen: abgeschlossenes Modul “Kubernetes Workloads & Konfiguration”, lauffähige lokale Docker-Umgebung, keine Cloud-Kostenwirkung

Modulaufbau & Agenda

  1. Namespace & ResourceQuota (15 min): Namespace als logische Unterteilung eines Clusters, die vier Default-Namespaces, namespaced vs. cluster-scoped Ressourcen, ResourceQuota – mit expliziter Abgrenzung Kubernetes-Namespace ≠ Linux-Namespace.

  2. RBAC: ServiceAccount, Role/RoleBinding, ClusterRole/ClusterRoleBinding (30 min, Hands-on): ein Read-only-ServiceAccount für ein CI-System anlegen und die Rechte mit kubectl auth can-i –as=system:serviceaccount:… selbst verifizieren.

  3. Cluster-Netzwerk: CNI, kube-proxy, CoreDNS, NetworkPolicy (25 min, Hands-on): das CNI-Grundmodell, die Rollen von kube-proxy und CoreDNS, eine NetworkPolicy anwenden und live verifizieren, dass sie tatsächlich greift.

  4. Node-Administration: cordon/drain/uncordon, Taints/Tolerations, Capacity/Allocatable (25 min, Hands-on): geplante Node-Wartung auf einem zweiten Minikube-Node durchführen, kubectl top node über den Metrics Server lesen.

  5. High Availability als Konzept, ohne eigenes Hands-on (15 min): Control-Plane-HA (Load Balancer + kubeadm join –control-plane), etcd-Raft-Quorum/Snapshot, Worker-Verteilung über Failure-Domains – als Frontalteil/Diskussion, weil eine echte Multi-Control-Plane-Topologie mehrere echte Nodes/VMs braucht.

  6. Puffer/Q&A (10 min): offene Fragen, individuelle Vertiefung je nach Cluster-Setup der Teilnehmenden.

Dieses Modul setzt das Aufbaumodul Kubernetes Workloads & Konfiguration — die Objekte für den Alltag voraus. Pod-Lifecycle, Deployment-Mechanik, Service-Typen sowie ConfigMap/Secret werden dort erklärt und hier nicht erneut eingeführt. Nicht Voraussetzung ist das Modul “Kubernetes Networking Vertiefung” – beide Module sind gleichrangige, voneinander unabhängige Vertiefungen auf demselben Workloads-Fundament und lassen sich in beliebiger Reihenfolge buchen.

Wer stattdessen Service Discovery, DNS-Verhalten und Ingress-Pfadregeln vertiefen will, findet das im Schwestermodul Kubernetes Networking Vertiefung — Service Discovery, DNS und Ingress-Pfadregeln. Wer stattdessen die Anwendungsdesign-Perspektive einnehmen will – Multi-Container-Pod-Patterns, Job/CronJob für Batch-Workloads sowie securityContext und ServiceAccount – findet das im weiteren Schwestermodul Kubernetes Anwendungsdesign — Multi-Container-Patterns, Jobs & Security Context. Wer stattdessen die Storage-Perspektive einnehmen will – emptyDir und hostPath im Vergleich zu PersistentVolume, PersistentVolumeClaim mit Binding-Regel, AccessModes und StorageClass – findet das im weiteren Schwestermodul Kubernetes Storage — Volumes, PersistentVolumes & Claims. Wer stattdessen wissen will, wie sich eine bereits laufende Anwendung diagnostizieren lässt – Prometheus-Scrape-Annotationen, Ephemeral Containers per kubectl debug und die dreistufige Service-Troubleshooting-Kette – findet das im weiteren Schwestermodul Kubernetes: Monitoring & Troubleshooting. Wer stattdessen Requests/Limits, QoS-Klassen, LimitRange und den HorizontalPodAutoscaler vertiefen will – bewusst abgegrenzt von der ResourceQuota dieses Moduls, die ein Namespace-Aggregat begrenzt statt eines Container-Defaults – findet das im weiteren Schwestermodul Kubernetes Ressourcenmanagement & Autoscaling — Requests, Limits und HorizontalPodAutoscaler. Wer stattdessen eigene und fremde Anwendungen als versionierte Releases statt loser Manifest-Dateien betreiben will – Chart/ Release/Repository als Grundbegriffe, Chart-Struktur und Go-Template-Syntax sowie das komplette Lifecycle-Management helm install/upgrade/rollback/history – findet das im weiteren Schwestermodul Helm — Paketmanagement für Kubernetes. Die dort behandelten ServiceAccount/Role/ RoleBinding-Bausteine für Chart-eigene Workloads sind bereits Thema dieses Moduls und werden dort als bekannt vorausgesetzt, nicht erneut eingeführt. Alle sieben Vertiefungsmodule ergänzen sich inhaltlich, keines setzt das andere voraus.

Wer den High-Availability-Block dieses Moduls (Control-Plane-HA, etcd-Raft-Quorum) in die Praxis überführen will – ein echtes etcd-Backup erstellen und einen Cluster daraus wiederherstellen – findet das im aufbauenden Modul Kubernetes Cluster-Recovery: etcd Backup & Restore. Anders als die sechs gleichrangigen Vertiefungsmodule oben setzt dieses Modul konkret die Inhalte dieses Kurses voraus, nicht nur das gemeinsame Workloads-Fundament.

Wer stattdessen den High-Availability-Block als echte Multi-Control-Plane-Topologie selbst aufbauen und das etcd-Raft-Quorum live an einem Node-Ausfall beobachten will – hier bewusst als reiner Frontalteil ohne eigenes Hands-on belassen, weil eine echte Topologie mehrere echte Nodes/VMs braucht – findet das vertieft im Aufbaumodul Kubernetes Hochverfügbarkeit — Multi-Master Control-Plane. Das Modul löst genau die technische Einschränkung dieser Sandbox über einen Werkzeugwechsel auf kind statt Minikube.

Wer RBAC und ServiceAccounts aus diesem Modul mit dem securityContext aus “Kubernetes Anwendungsdesign” zusammenführen und Namespace-weit statt nur pro Workload durchsetzen will – Pod Security Standards und Pod Security Admission mit dem Namespace-Label pod-security.kubernetes.io/enforce=restricted, dazu Secrets-Encryption-at-Rest über eine EncryptionConfiguration jenseits von Base64 – findet das im Aufbaumodul Kubernetes Security Vertiefung — Pod Security Admission & Secrets-Härtung. Anders als die sieben gleichrangigen Vertiefungsmodule oben setzt dieses Modul konkret die RBAC-/ServiceAccount-Inhalte dieses Kurses und den securityContext aus “Kubernetes Anwendungsdesign” gleichzeitig voraus, nicht nur das gemeinsame Workloads-Fundament. Wer von dort aus noch einen Schritt weitergehen will – eigene Cluster-Regeln jenseits der drei festen Pod-Security-Profile, mit Kyverno und OPA Gatekeeper live gegen dieselbe Regel verglichen – findet das im weiterführenden Aufbaumodul Kubernetes Admission Controllers & Policy Engines — Kyverno vs. OPA Gatekeeper.

Hands-on Inhalte (Auszug)

Read-only-ServiceAccount für ein CI-System

  • Einen ServiceAccount ci-readonly anlegen und über eine Role mit ausschließlich get/list/watch auf Pods/Deployments/Services an einen RoleBinding koppeln
  • Mit kubectl auth can-i create deployments –as=system:serviceaccount:default:ci-readonly live bestätigen, dass genau diese Aktion verweigert wird, während get pods erlaubt ist

NetworkPolicy live verifizieren

  • Eine NetworkPolicy anwenden, die Traffic auf einen Backend-Pod nur von Pods mit dem Label app: frontend erlaubt
  • Zugriff von einem erlaubten und einem nicht erlaubten Debug-Pod aus gegenprüfen – nur möglich, weil der Cluster vorab mit Calico statt dem Standard-Netzwerk gestartet wurde

Node-Wartung: cordon, drain, uncordon

  • Auf dem zweiten Node eines Zwei-Node-Minikube-Clusters kubectl cordon setzen und beobachten, dass laufende Pods unangetastet bleiben, aber keine neuen mehr geplant werden
  • Mit kubectl drain –ignore-daemonsets –delete-emptydir-data die Pods auf den verbleibenden Node umziehen, danach mit kubectl uncordon den Node wieder freigeben

Taints/Tolerations & Kapazität

  • Einen eigenen Taint setzen (kubectl taint nodes …) und live zeigen, dass ein Pod ohne passende Toleration dort nicht geplant wird
  • kubectl describe node für Capacity vs. Allocatable und kubectl top node über den zuvor installierten Metrics Server gegenüberstellen

Dieses Modul ist Teil unserer Pilotphase. Gemeinsam mit euch definieren wir passende Metriken (z. B. Zeit bis zur verifizierten RBAC-Regel) und werten sie im Anschluss transparent aus. Ergebnisse veröffentlichen wir, sobald sie belastbar sind.

Bereit, das Modul zu buchen?

Wir passen die Hands-on-Übung auf euren Erfahrungsstand und eure Zielumgebung an.

Academy Briefing anfragen