Container & Kubernetes

Kubernetes für Linux-Admins: So steigst du vom Server auf den Cluster um

Dein Linux-Wissen trägt weiter als gedacht, Namespaces und cgroups kennst du bereits aus dem Kernel. Neu sind das deklarative Modell und das Cluster-Netzwerk, und genau daran scheitern die meisten Umsteiger.

5 Kapitel mit allen Befehlen
DevOps-Engineer erklärt einem Kollegen Container-Dashboards am Stehtisch
KI-generiertDieses Bild wurde mit KI erzeugt · Yves Hoppe / KI / cmt
Seit 1997 am Markt Präsenz & Live-Online 4,9 aus 503 Google-Bewertungen Auch Inhouse für dein Team
Worum es geht

Warum der Umstieg für erfahrene Admins trotzdem holprig ist

Wer Linux administriert, bringt für Kubernetes mehr mit, als ihm meist bewusst ist. Container sind keine neue Technologie, sondern eine Kombination aus Namespaces, cgroups und Capabilities, also aus Kernel-Funktionen, die du bereits kennst. Auch Routing, DNS, TLS, Dateisysteme und Logrotation verschwinden nicht, sie tauchen nur an einer anderen Stelle wieder auf. Der eigentliche Bruch liegt woanders: Du konfigurierst keinen Zustand mehr direkt, sondern beschreibst einen Zielzustand und überlässt es Controllern, ihn herzustellen.

Genau daran scheitern viele Umsteiger im Alltag. Sie behandeln Pods wie kleine VMs, loggen sich per kubectl exec ein, ändern etwas im Container und wundern sich, dass die Änderung beim nächsten Rollout weg ist. Sie kopieren Manifeste aus Blogartikeln, ohne Requests und Limits zu setzen, und stehen dann vor OOMKills und CPU-Throttling, die im Monitoring schwer zuzuordnen sind. Oder sie debuggen ein Netzwerkproblem mit tcpdump auf dem Node, obwohl die Ursache in einer NetworkPolicy oder im Service-Objekt liegt.

Dazu kommt der organisatorische Teil. Ein Cluster ist selten die Aufgabe einer einzelnen Person. Wer vorher allein für seine Server zuständig war, arbeitet plötzlich mit RBAC, Namespaces als Mandantengrenze und Deployments, die aus einer Pipeline kommen und nicht mehr von Hand. Ohne ein klares Bild davon, wer welche Objekte verantwortet, entstehen Cluster, die technisch laufen, aber im Betrieb niemandem gehören.

Miniatur-Szene: Hafen mit gestapelten Containern, ein Kran hebt einen davon an, daneben ein Steuerrad
KI-generiertDieses Bild wurde mit KI erzeugt · Yves Hoppe / KI / cmt

Vom Linux-Server zum Kubernetes-Cluster

  1. 01 Linux-Grundlagen: Prozesse, Netzwerk, Storage
  2. 02 Container: Images, Namespaces, Podman und Docker
  3. 03 Kubernetes-Objekte: Pod, Deployment, Service
  4. 04 Clusterbetrieb: kubeadm, etcd, Upgrades
  5. 05 Plattform: RBAC, Quotas, Observability
  6. 06 Zertifizierung: CKA
Was du mitnimmst

Ein Lernpfad, der auf deinem Linux-Wissen aufsetzt

Du musst nicht bei null anfangen. Sinnvoll ist ein Weg, der die Brücke von den vertrauten Bordmitteln zu den Kubernetes-Objekten schlägt und erst danach in Betrieb, Sicherheit und Zertifizierung geht. Diese Stationen haben sich in unseren Kursen bewährt.

Container zuerst verstehen, dann orchestrieren

Bevor du Pods schedulst, solltest du wissen, was ein Image-Layer ist, wie ein Registry-Pull funktioniert und warum ein Prozess als PID 1 im Container Signale anders behandelt. Der Docker Grundkurs für Einsteiger und der Linux Container Workshop mit Docker und Podman decken diesen Unterbau ab, inklusive rootless Betrieb.

Die Übersetzung von systemctl nach kubectl

Ein Deployment ersetzt die Unit-Datei, ein ReplicaSet die Restart-Policy, ein Service den festen Port auf dem Host und ein ConfigMap oder Secret die Datei unter /etc. Wenn du diese Zuordnung einmal sauber durchgespielt hast, liest du Manifeste flüssig. Der Kubernetes Grundkurs setzt genau hier an.

Netzwerk und Storage bleiben dein Terrain

Du arbeitest weiter mit Routing, DNS-Auflösung über CoreDNS, Ingress- beziehungsweise Gateway-API-Objekten und mit Volumes, die aus einer StorageClass provisioniert werden. Dein Wissen über NFS, iSCSI, Ceph oder LVM zahlt sich beim Verständnis von PersistentVolumes direkt aus.

Cluster selbst aufbauen statt nur benutzen

Wer einen Cluster mit kubeadm installiert, etcd sichert, Zertifikate erneuert und ein Upgrade durchführt, versteht die Control Plane deutlich schneller als jemand, der nur eine gemanagte Umgebung konsumiert. LFS458 Kubernetes Administration deckt diesen Betriebsteil ab.

Betrieb, Rechte und Grenzen sauber ziehen

RBAC, Namespaces, ResourceQuotas, Requests und Limits sowie Readiness- und Liveness-Probes entscheiden darüber, ob ein Cluster im Alltag stabil bleibt. Kubernetes für Plattform-Teams behandelt diese Perspektive aus Sicht derer, die die Plattform bereitstellen und nicht nur darauf deployen.

Zertifizierung als Nachweis, wenn sie gebraucht wird

Kubernetes Fundamentals LFS258 im Bundle mit der CKA-Prüfung führt zum anerkannten Nachweis. Die CKA ist eine reine Praxisprüfung an der Kommandozeile, was erfahrenen Admins entgegenkommt, aber Übung unter Zeitdruck voraussetzt.

Tutorial

Vom systemd-Dienst zum Deployment: die Handgriffe im Detail

Dieser Teil geht den Weg entlang, den du im Alltag nimmst: erst ein eigener Cluster zum Anfassen, dann die Übersetzung deiner Bordmittel nach kubectl, danach das erste Deployment, das den Betrieb übersteht. Zum Schluss die Bereiche, in denen dein Linux-Wissen den Unterschied macht.

01

Cluster mit kubeadm aufsetzen, nicht nur konsumieren

Ein gemanagter Cluster versteckt genau die Teile, die du verstehen willst. Für jede spätere Fehlersuche lohnt sich ein Cluster aus drei virtuellen Maschinen, den du selbst installierst.

Vorbereitung auf jedem Node
# Swap aus, das kubelet verweigert sonst den Start
sudo swapoff -a
sudo sed -i.bak '/ swap / s/^/#/' /etc/fstab

# Kernel-Modul und sysctl für das Pod-Netzwerk
sudo modprobe br_netfilter
printf 'net.ipv4.ip_forward = 1\nnet.bridge.bridge-nf-call-iptables = 1\n' \
  | sudo tee /etc/sysctl.d/99-kubernetes.conf
sudo sysctl --system

# Container-Runtime, die RHEL-Familie zieht containerd.io aus dem Docker-Repo
sudo apt install -y containerd

containerd config default | sudo tee /etc/containerd/config.toml >/dev/null
sudo sed -i 's/SystemdCgroup = false/SystemdCgroup = true/' /etc/containerd/config.toml
sudo systemctl restart containerd

SystemdCgroup = true ist der Schritt, den fast jede Anleitung erwähnt und trotzdem fast jeder vergisst. Steht dort false, während systemd den cgroup-Treiber stellt, starten Pods scheinbar zufällig nicht mehr.

Control Plane initialisieren
# Paketquelle je Minor: https://pkgs.k8s.io/core:/stable:/v1.XX/deb/

sudo kubeadm init --pod-network-cidr=10.244.0.0/16

mkdir -p "$HOME/.kube"
sudo install -o "$(id -u)" -g "$(id -g)" /etc/kubernetes/admin.conf "$HOME/.kube/config"

# CNI-Plugin einspielen, vorher bleibt jeder Node NotReady
kubectl apply -f MANIFEST-DES-GEWAEHLTEN-CNI

kubectl get nodes -o wide

Solange kein CNI installiert ist, bleibt der Node NotReady und CoreDNS hängt in Pending. Das ist kein Fehler, sondern der erwartete Zwischenzustand. Zwischen den Knoten müssen 6443/tcp zum API-Server, 10250/tcp zum kubelet sowie 2379 und 2380/tcp für etcd offen sein. Auf der RHEL-Familie steht firewalld dem CNI dabei häufig im Weg.

02

Deine Bordmittel auf kubectl übersetzen

Die meisten Fragen im Betrieb sind dieselben wie vorher, sie brauchen nur ein anderes Werkzeug.

Gleiche Aufgabe, anderes Objekt

AufgabeAuf dem ServerIm Cluster
Dienst beschreiben/etc/systemd/system/app.serviceDeployment mit Pod-Template
Starten und dauerhaft aktivierensystemctl enable --now appkubectl apply -f app.yaml
Konfiguration und GeheimnisseEnvironmentFile=, Datei unter /etcConfigMap und Secret
Ressourcen begrenzenMemoryMax=, CPUQuota=resources.requests und resources.limits
Erreichbarkeit herstellenfester Port im DienstService, bei Bedarf Ingress
Logs lesenjournalctl -u app -fkubectl logs -f deploy/app
Manifeste erzeugen statt abtippen
# Gerüst generieren und im Editor fertigstellen
kubectl create deployment web --image=registry.intern/web:1.4.2 \
  --dry-run=client -o yaml > web.yaml

# Feldnamen nachschlagen, ohne die Doku im Browser zu suchen
kubectl explain deployment.spec.strategy.rollingUpdate

# Was würde sich im Cluster tatsächlich ändern
kubectl diff -f web.yaml
kubectl apply -f web.yaml

kubectl diff ist das --check deiner Automatisierung: Es zeigt die Abweichung zwischen Manifest und Ist-Zustand, bevor du sie anwendest, und gehört produktiv vor jedes apply.

03

Das erste Deployment, das den Betrieb übersteht

Ein Deployment ohne Requests, Limits und Probes läuft im Test und macht in Produktion Ärger. Diese Felder trennen ein Blogbeispiel von einem Workload, mit dem sich planen lässt.

web-deployment.yaml, die Felder, auf die es ankommt
spec:
  template:
    spec:
      containers:
        - name: web
          image: registry.intern/web:1.4.2   # fester Tag, nie latest
          resources:
            requests:                        # entscheidet über das Scheduling
              cpu: 100m
              memory: 128Mi
            limits:                          # erzwingt die Obergrenze
              memory: 256Mi
          readinessProbe:                    # nimmt den Pod aus dem Service
            httpGet: { path: /healthz, port: 8080 }
            periodSeconds: 5
          livenessProbe:                     # startet den Container neu
            httpGet: { path: /healthz, port: 8080 }
          securityContext:
            runAsNonRoot: true

Der Request bestimmt, auf welchem Node der Pod landet, das Limit, wann er abgeräumt wird. Fehlt der Request, plant der Scheduler mit null und überbucht den Node. Setzt du nur ein Limit, übernimmt Kubernetes diesen Wert stillschweigend auch als Request.

Nach dem Rollout prüfen und zurücknehmen
kubectl rollout status deploy/web --timeout=120s
kubectl get events --sort-by=.lastTimestamp | tail -20

# Was hat der Container beim letzten Absturz gesagt
kubectl logs deploy/web --previous

# Zurück auf den vorherigen Stand
kubectl rollout undo deploy/web

kubectl logs --previous ist der Griff, der bei Absturzschleifen fehlt: Er zeigt die Ausgabe des abgestürzten Vorgängercontainers, während kubectl logs den frisch gestarteten und damit noch leeren zeigt.

04

Fehler eingrenzen, vom Service bis zum Node

Fast jeder Cluster-Fehler, der wie Magie aussieht, ist am Ende DNS, ein falscher Selector oder eine NetworkPolicy. Führt das nicht weiter, arbeitest du wieder als Linux-Admin auf dem Node.

Von außen nach innen prüfen
# 1. Zeigt der Service überhaupt auf Pods?
kubectl get endpointslices -l kubernetes.io/service-name=web

# 2. Aus dem Cluster heraus testen
kubectl run netz --rm -it --image=nicolaka/netshoot -- bash
  nslookup web.produktion.svc.cluster.local
  curl -sv http://web.produktion.svc.cluster.local:8080/healthz

# 3. In einen laufenden Pod schauen, ohne ihn zu verändern
kubectl debug -it pod/web-abc123 --image=nicolaka/netshoot --target=web

Eine leere Endpoint-Liste bedeutet fast immer, dass der Selector nicht zu den Pod-Labels passt oder die Readiness-Probe fehlschlägt. kubectl debug hängt einen Container in denselben Pod, du bekommst tcpdump und dig also dorthin, wo beides nicht installiert ist.

Wenn ein Name zwar aufgelöst wird, die Verbindung aber hängt, ist die nächste Station die NetworkPolicy. Sobald ein Pod von mindestens einer Policy erfasst wird, gilt für ihn in der geregelten Richtung ein Default-Deny. Denk daran, dass du den Zugriff auf CoreDNS im Namespace kube-system ausdrücklich erlauben musst, sonst scheitert schon die Namensauflösung und du suchst den Fehler in der Anwendung.

Auf dem Node selbst
sudo journalctl -u kubelet -f

# Container an der Runtime ansehen, am API-Server vorbei
sudo crictl ps -a
sudo crictl logs CONTAINER-ID

# Klassiker: Platte voll, das kubelet räumt Images ab
df -h /var/lib/containerd /var/log /
kubectl describe node knoten01 | grep -A6 Conditions

# Node geordnet aus dem Betrieb nehmen
kubectl drain knoten01 --ignore-daemonsets --delete-emptydir-data
kubectl uncordon knoten01

crictl braucht den passenden Endpunkt, sonst sucht es an der falschen Stelle: runtime-endpoint: unix:///run/containerd/containerd.sock in /etc/crictl.yaml. Die Condition DiskPressure ist die häufigste Ursache für einen Node, der keine Pods mehr annimmt. drain respektiert PodDisruptionBudgets und bleibt hängen, wenn ein Budget die Verschiebung verbietet, das ist der Schutz und kein Fehler.

05

Den Betrieb absichern

Drei Punkte entscheiden darüber, ob ein selbst betriebener Cluster auch in einem Jahr noch beherrschbar ist.

etcd sichern, das ist der ganze Cluster
sudo ETCDCTL_API=3 etcdctl \
  --endpoints=https://127.0.0.1:2379 \
  --cacert=/etc/kubernetes/pki/etcd/ca.crt \
  --cert=/etc/kubernetes/pki/etcd/server.crt \
  --key=/etc/kubernetes/pki/etcd/server.key \
  snapshot save /var/backups/etcd-$(date +%F).db

sudo etcdutl snapshot status /var/backups/etcd-$(date +%F).db

Ein Snapshot ohne geprüften Rückweg ist nur eine Datei. Spiel die Sicherung einmal in einen Wegwerf-Cluster zurück, bevor du den Ablauf unter Druck brauchst.

Bevor der Cluster produktiv geht

  • Namespace je Anwendung oder Team, dazu ResourceQuota und LimitRangeOhne Quota belegt ein einzelner Workload den gesamten Node, und ohne LimitRange landen Pods ganz ohne Requests im Cluster, die der Scheduler dann mit null einplant.
  • Rechte prüfen statt raten: kubectl auth can-i --list --as=system:serviceaccount:app:deployerDer Befehl beantwortet genau die Frage, die im Audit gestellt wird, und deckt vergebene cluster-admin-Bindungen auf, die niemand mehr auf dem Schirm hat.
  • Pod Security Admission je Namespace auf restricted setzen, Ausnahmen ausdrücklich labelnSonst darf jeder Pod privilegiert starten, und die Trennung zwischen Namespaces ist nur noch Kosmetik.
  • Upgrade-Rhythmus festlegen: eine Minor-Version pro Schritt, erst kubeadm upgrade apply auf der Control Plane, dann kubeadm upgrade node auf den WorkernKubernetes unterstützt keine Sprünge über mehrere Minor-Versionen, und ein kubelet darf hinter dem API-Server liegen, niemals davor. Wer wartet, muss später mehrere Upgrades hintereinander fahren.
  • Zugriff auf /etc/kubernetes/admin.conf beschränkenDiese Datei ist im Alltag ein cluster-admin-Zugang ohne Ablauf. Sie gehört nicht in ein Wiki und nicht in ein Repository.
Gut zu wissen

Häufige Fragen zu Kubernetes für Linux-Admins

Noch etwas offen? Wir sind ohne Warteschleife für dich da.

Frag uns direkt
Welche Linux-Vorkenntnisse brauche ich für Kubernetes wirklich?
Du solltest sicher auf der Shell arbeiten, Prozesse und Logs analysieren, Netzwerk- und DNS-Probleme eingrenzen sowie mit YAML und Zertifikaten umgehen können. Das Niveau einer LPIC-1 oder RHCSA reicht als Fundament völlig aus, Kernel-Entwicklung oder tiefes C-Wissen brauchst du nicht.
Ersetzt Kubernetes meine bisherigen Kenntnisse zu systemd und Paketmanagement?
Nein. Auf den Nodes läuft weiterhin ein normales Linux mit systemd, kubelet als Unit, containerd als Runtime und einem Paketmanager für Updates. Kubernetes kommt als Schicht darüber, es räumt darunter nichts weg, und im Störungsfall landest du regelmäßig wieder bei journalctl auf dem Node.
Lohnt sich die CKA für einen erfahrenen Systemadministrator?
Wenn du Cluster betreiben oder in Ausschreibungen und Projekten einen Nachweis brauchst, ja. Die Prüfung ist vollständig hands-on, du löst Aufgaben in echten Clustern mit kubectl und Dokumentationszugriff. Erfahrene Admins tun sich inhaltlich meist leicht, unterschätzen aber die Zeitvorgabe, deshalb ist gezieltes Üben sinnvoll.
Sollte ich mit einem gemanagten Dienst oder mit einem eigenen Cluster lernen?
Zum Verstehen ist ein selbst installierter Cluster mit kubeadm klar im Vorteil, weil du Control Plane, etcd und Zertifikate anfassen musst. Für den späteren Produktivbetrieb kann ein gemanagter Dienst wie EKS oder GKE trotzdem die richtige Wahl sein. Wir bieten beide Wege als Kurse an.
Wie lange dauert der Umstieg vom Server-Admin zum Kubernetes-Admin?
Mit soliden Linux-Kenntnissen erreichst du in wenigen Tagen Schulung ein Niveau, auf dem du Workloads sicher deployen und Fehler eingrenzen kannst. Verantwortung für einen produktiven Cluster setzt zusätzlich mehrere Monate Betriebserfahrung voraus, besonders bei Upgrades, Storage und Netzwerk.

Zuletzt geprüft am 26. Juli 2026.

Das sagen Teilnehmer

Echte Stimmen aus unseren IT-Kursen

Sehr kompetenter Dozent der gut auf alle Fragen eingegangen ist.
Rückmeldung aus dem Kurs „Kubernetes Grundkurs“
Qualitativ sehr guter Kurs. Ruhiger und wertschätzender Umgang. Keine Informationsüberlastung.
Rückmeldung aus dem Kurs „Ansible Kompaktkurs“
Persönlich für dich da

Deine Ansprechpartner

Du bist dir nicht sicher, welcher Kurs oder welches Level zu dir passt? Wir beraten dich persönlich und kostenlos.

Yves Hoppe

Yves Hoppe

Weiterbildung & Beratung

Hilft dir, aus dem Linux-Programm den passenden Kurs oder Lernpfad zu finden.

Norbert Jansen

Norbert Jansen

Beratung & Inhouse

Plant mit dir Inhouse-Trainings, die exakt auf eure Systemlandschaft und Distributionen zugeschnitten sind.

Nächster Schritt

Den passenden Einstieg gemeinsam festlegen

Ob Kubernetes Grundkurs, Clusterbetrieb mit LFS458 oder direkt der Weg zur CKA hängt davon ab, was du heute schon administrierst und was du künftig verantworten sollst. Sag uns, wie eure Umgebung aussieht, dann ordnen wir die Kurse für dich ein. Alle Termine finden als Präsenz- oder Live-Online-Schulung statt, auf Wunsch auch als Firmenschulung mit euren eigenen Workloads.