Diese Anleitung beschreibt die erforderlichen Schritte zur Installation einer kleinen Ein-Server-Umgebung für das Certified Kubernetes Administrator (CKA)-Training. Alle Schritte wurden auf Ubuntu Server 22.04 LTS getestet.
Meine Systemkonfiguration
Ubuntu Server 22.04 wird als virtuelle Maschine (VM) auf VMware Workstation laufen.
- Ubuntu Server 22.04 LTS (empfohlen)
- 4 vCPUs
- 24 GB RAM
- 100 GB Festplattenspeicher
- Feste IP-Adresse konfiguriert
System-Grundkonfiguration
Bevor wir mit der Installation beginnen, bereiten wir das System vor. Dies umfasst die Systemanpassung, die Installation von Updates und die Erfüllung einiger Kubernetes-Anforderungen.
1. System-Updates. Die Paketlisten werden aktualisiert und alle verfügbaren System-Updates werden installiert. Um Kernel-Updates und kritische Änderungen zu aktivieren, wird das System neu gestartet.
sudo apt update && sudo apt upgrade -y sudo reboot
2. Swap deaktivieren. Kubernetes erfordert, dass Swap deaktiviert ist. Dies verhindert Performance-Probleme und unvorhersehbares Verhalten. Die zweite Befehlskette kommentiert alle Swap-Einträge in /etc/fstab aus, damit Swap nach Neustart deaktiviert bleibt.
sudo swapoff -a sudo sed -i '/ swap / s/^/#/' /etc/fstab
3. IP-Adresse anpassen (von DHCP auf statisch).
sudo vi /etc/netplan/00-installer-config.yaml
So sieht meine Konfiguration aus:
network:
version: 2
renderer: networkd
ethernets:
ens33:
dhcp4: no
addresses:
- 192.168.1.100/24
routes:
- to: default
via: 192.168.1.254
nameservers:
addresses:
- 192.168.1.1
4. Kernel-Module laden. (Weitere Schritte sind optional!)
Kubernetes benötigt spezifische Kernel-Module für Netzwerk- und Storage-Funktionalität. Diese Module müssen beim Systemstart automatisch geladen werden.
Diese Schritte stammen aus den klassischen Anleitungen für „echte“ Kubernetes-Nodes (kubeadm + containerd/Docker direkt auf dem Host/VM). Für „Kubernetes in Docker-Containern“ (kind) sind sie oft nicht zwingend erforderlich. Sie schaden aber nicht und sind für eine vollständige CNI-Kompatibilität und CKA-Prüfungsvorbereitung sinnvoll, auch wenn Kind in Docker-Containern läuft.
cat <<EOF | sudo tee /etc/modules-load.d/k8s.conf overlay br_netfilter EOF
Dann fortfahren:
Lädt die Kernel-Module overlay und br_netfilter sofort, ohne auf einen Neustart zu warten.
sudo modprobe overlay sudo modprobe br_netfilter
5. Sysctl-Parameter konfigurieren. Diese Netzwerkeinstellungen ermöglichen Kubernetes-Pods die Kommunikation über Netzwerkbrücken und aktivieren IP-Forwarding für Container-Networking.
cat <<EOF | sudo tee /etc/sysctl.d/k8s.conf net.bridge.bridge-nf-call-iptables = 1 net.bridge.bridge-nf-call-ip6tables = 1 net.ipv4.ip_forward = 1 EOF
Erstellt die Datei /etc/sysctl.d/k8s.conf mit Netzwerk-Einstellungen, die Kubernetes für Container-Kommunikation über Netzwerkbrücken benötigt.
6. danach:
sudo sysctl –system
Wendet alle sysctl-Konfigurationen (einschließlich der neuen Kubernetes-Einstellungen) sofort an.
Die beiden roten „Invalid argument“-Warnungen sind normal und können ignoriert werden.
net.ipv4.conf.all.accept_source_route: Invalid argument net.ipv4.conf.all.promote_secondaries: Invalid argument
Diese Parameter existieren auf dem System nicht oder sind nicht anwendbar. Wichtig ist nur, dass die Kubernetes-Einstellungen erfolgreich geladen wurden. Am Ende sehen Sie:
* Applying /etc/sysctl.d/k8s.conf ... net.bridge.bridge-nf-call-iptables = 1 net.bridge.bridge-nf-call-ip6tables = 1 net.ipv4.ip_forward = 1
So lassen sich die Einstellungen überprüfen:
sysctl net.bridge.bridge-nf-call-iptables sysctl net.bridge.bridge-nf-call-ip6tables sysctl net.ipv4.ip_forward
So sollte die Ausgabe aussehen:
* Applying /etc/sysctl.d/k8s.conf ... net.bridge.bridge-nf-call-iptables = 1 net.bridge.bridge-nf-call-ip6tables = 1 net.ipv4.ip_forward = 1
Docker Installation
Docker wird als Container-Runtime für Kind (Kubernetes in Docker) benötigt. Es wird die neueste stabile Version aus dem offiziellen Docker-Repository installiert.
Docker-Repository hinzufügen
1. SSL-Zertifikate Installieren. curl für Downloads und GPG für kryptografische Signaturprüfung.
sudo apt install ca-certificates curl gnupg -y
2. Das Verzeichnis /etc/apt/keyrings mit korrekten Berechtigungen für APT-Repository-Schlüssel erstellen.
sudo install -m 0755 -d /etc/apt/keyrings
3. Diese Befehlskette lädt den offiziellen Docker GPG-Schlüssel herunter, konvertiert ihn ins Binärformat und speichert ihn zur Paket-Verifikation.
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
4. Hier wird das offizielle Docker-Repository zur APT-Quellenliste hinzugefügt und dynamisch an Systemarchitektur und Ubuntu-Version angepasst.
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu $(. /etc/os-release && echo $VERSION_CODENAME) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
Docker installieren
5. Die Paketlisten des neu hinzugefügten Docker-Repositories aktualisieren.
sudo apt update
6. Diese Befehlskette installiert Docker Engine, CLI-Tools, containerd-Runtime und die Plugins für BuildKit und Docker Compose.
sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin -y
7. Mein Benutzer wird zur docker-Gruppe hinzugefügt, um Docker ohne sudo-Rechte nutzen zu können.
sudo usermod -aG docker $USER
Aktiviert die Docker-Gruppenmitgliedschaft sofort in der aktuellen Shell-Sitzung (alternativ: neu einloggen).
newgrp docker
8. Installation verifizieren. Zunächst die Version überprüfen, anschließend die Docker-Installation testen, indem ein minimales Test-Container-Image heruntergeladen und ausgeführt wird.
docker --version docker run hello-world
Mögliche Antwort:
Docker version 29.2.1, build a5c7197
Erwartete Ausgabe:
Unable to find image 'hello-world:latest' locally 17eec7bbc9d7: Pull complete 17eec7bbc9d7: Pulling fs layer Digest: sha256:ef54e839ef541993b4e87f25e752f7cf4238fa55f017957c2eb44077083d7a6a Status: Downloaded newer image for hello-world:latest Hello from Docker! This message shows that your installation appears to be working correctly.
Cgroup Driver
Kubernetes arbeitet am stabilsten, wenn Container-Runtime und Init-System denselben cgroup Driver verwenden. Auf modernen Ubuntu-Versionen ist systemd bereits der Standard. Prüfen mit:
docker info | grep -i cgroup
Erwartete Ausgabe:
Cgroup Driver: systemd Cgroup Version: 2 cgroupns
Ist dies bereits gesetzt, sind keine weiteren Anpassungen erforderlich.
kubectl Installation
kubectl ist ein Kommandozeilen-Tool für Kubernetes. Es ist das zentrale Werkzeug für die CKA-Prüfung sowie für die tägliche Arbeit mit Kubernetes.
1. Diese Befehlskette lädt die neueste stabile kubectl-Version herunter, wobei die Versionsnummer automatisch vom Kubernetes-Server abgerufen wird.
curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
2. Anschließend wird kubectl im Verzeichnis /usr/local/bin installiert. Da dieses Verzeichnis Bestandteil des systemweiten PATH ist, können alle Benutzer den Befehl nutzen, ohne dass eine zusätzliche Konfiguration erforderlich ist. Der install-Befehl wird häufig gegenüber cp bevorzugt, da Datei, Eigentümer und Berechtigungen in einem Schritt gesetzt werden und dadurch keine inkonsistenten Zwischenzustände entstehen.
Durch die gesetzten Berechtigungen (0755) bleibt die Datei für normale Benutzer ausführbar, während nur root Änderungen vornehmen kann.
sudo install -o root -g root -m 0755 kubectl /usr/local/bin/kubectl
3. Installation verifizieren
kubectl version --client
Erwartete Ausgabe:
Client Version: v1.35.1 Kustomize Version: v5.7.1
Bash-Autovervollständigung konfigurieren
Die Bash-Autovervollständigung erleichtert die Arbeit mit kubectl, reduziert Tippfehler und kann besonders in zeitkritischen Situationen wie der CKA-Prüfung wertvolle Sekunden sparen.
Grundsätzlich gibt es zwei Möglichkeiten: eine schnelle temporäre Aktivierung oder eine dauerhafte Systemkonfiguration.
Temporäre Aktivierung
Für Prüfungssituationen oder kurzlebige Umgebungen genügt es, die Autovervollständigung für die aktuelle Shell zu laden:
source <(kubectl completion bash)
Diese Methode ist sofort wirksam und erfordert keine Änderungen an Konfigurationsdateien.
Nach dem Schließen der Shell muss sie allerdings erneut ausgeführt werden.
Dauerhafte Systemkonfiguration
Bei langfristig genutzten Systemen empfiehlt sich eine persistente Konfiguration. Auf vielen modernen Linux-Distributionen ist das Paket bereits vorhanden. Prüfen Sie dies mit:
dpkg -l | grep bash-completion
Falls es noch nicht installiert ist:
sudo apt install bash-completion -y
So lässt sich kubectl-Autovervollständigung systemweit aktivieren. Dadurch wird die Autovervollständigung für alle zukünftigen Shell-Sessions automatisch geladen.
kubectl completion bash | sudo tee /etc/bash_completion.d/kubectl > /dev/null
Alias für kubectl
Zur weiteren Beschleunigung der täglichen Arbeit kann ein Alias für kubectl eingerichtet werden. Damit lassen sich Befehle deutlich kürzer schreiben.
Erstellt den Alias k für kubectl.
echo 'alias k=kubectl' >> ~/.bashrc
Aktiviert die Tab-Vervollständigung auch für den Alias k.
echo 'complete -F __start_kubectl k' >> ~/.bashrc
Lädt die .bashrc-Datei neu, um Alias und Autovervollständigung sofort zu aktivieren (alternativ: neue Shell öffnen).
source ~/.bashrc
💡 Ab jetzt können Sie ‚k‘ statt ‚kubectl‘ verwenden und mit Tab-Taste Befehle vervollständigen.
kind Installation
kind (Kubernetes in Docker) ermöglicht das Ausführen lokaler Kubernetes-Cluster in Docker-Containern. Ideal für Entwicklung und Testing.
1. Die neueste Kind-Binary (Kubernetes in Docker) für Linux herunterladen. Die kind-Datei ausführbar machen.
curl -Lo ./kind https://kind.sigs.k8s.io/dl/latest/kind-linux-amd64 chmod +x ./kind
2. kind nach /usr/local/bin/ verschieben, um es systemweit nutzbar zu machen.
sudo mv ./kind /usr/local/bin/kind
3. Installation verifizieren
kind --version
Erwartete Ausgabe:
kind version 0.32.0-alpha+9145d421e0d4f7
Multi-Node Kubernetes Cluster erstellen
4. So wird eine Konfigurationsdatei für einen 3-Node-Cluster (1 Control Plane + 2 Worker Nodes) erstellt.
cat <<EOF > kind-config.yaml kind: Cluster apiVersion: kind.x-k8s.io/v1alpha4 nodes: - role: control-plane - role: worker - role: worker EOF
5. Cluster starten
kind create cluster --config kind-config.yaml --name cka-cluster
Dieser Vorgang dauert ein paar Minuten. kind lädt Images herunter und startet die Container-Nodes.
6. Cluster-Status überprüfen
kubectl get nodes
Erwartete Ausgabe: 3 Nodes im Status ‚Ready‘
NAME STATUS ROLES AGE VERSION cka-cluster-control-plane Ready control-plane 3m22s v1.35.0 cka-cluster-worker Ready <none> 3m11s v1.35.0 cka-cluster-worker2 Ready <none> 3m11s v1.35.0
Helm Installation
Helm ist der Paketmanager für Kubernetes. Viele Tools und Anwendungen werden über Helm installiert.
Das offizielle Helm-Installationsskript herunterladen und ausführen, um Helm 3 automatisch zu installieren.
curl https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash
Installation verifizieren. Zeigt die installierte Helm-Version an und verifiziert die Installation.
helm version
Erwartete Ausgabe:
version.BuildInfo{Version:"v3.20.0",
GitCommit:"b2e4314fa0f229a1de7b4c981273f61d69ee5a59",
GitTreeState:"clean", GoVersion:"go1.25.6"}
Git und CKA-Übungsrepository
Git wird benötigt, um das CKA-Übungsrepository zu klonen. Git installieren und Version prüfen:
sudo apt install git -y git --version
CKA-Übungsrepository klonen
In das Home-Verzeichnis wechseln. Das CKA-Übungsrepository klonen.
cd ~ git clone https://github.com/vj2201/CKA-PREP-2025-v2.git cd CKA-PREP-2025-v2
Für die Vorbereitung auf die CKA-Prüfung ist praktische Erfahrung entscheidend. Das Repository CKA-PREP-2025-v2 stellt eine Sammlung realitätsnaher Übungsszenarien bereit, die prüfungsähnliche Aufgaben simulieren. @Carsten, danke für den Tipp!
Repository: https://github.com/vj2201/CKA-PREP-2025-v2
Jedes Szenario ist in einem eigenen Ordner organisiert und folgt einer klaren Struktur.
- LabSetUp.bash – bereitet die Übungsumgebung automatisch vor, indem benötigte Ressourcen im Cluster erstellt werden. Dazu gehören beispielsweise Namespaces, Deployments oder bewusst fehlerhafte Konfigurationen, die im Rahmen der Übung analysiert und korrigiert werden sollen.
- Questions.bash – enthält die Aufgabenstellung sowie Hinweise zum Szenario.
- SolutionNotes.bash – bietet eine mögliche Lösung und dient als Referenz, falls ein Problem nicht eigenständig gelöst werden kann.
kind-Cluster mit Visual Studio Code verwalten
Die Verwaltung des lokalen Kubernetes-Clusters erfolgt über Visual Studio Code, das auf einer Windows-11-Workstation installiert ist. Der Cluster selbst läuft in einer Ubuntu-VM und wird über eine SSH-Verbindung remote gesteuert.
Dieses Architekturmodell trennt bewusst: Workstation (Editor & UI) von Cluster-Host (Runtime & Infrastruktur), um die Stabilität der Umgebung zu erhöhen.
Alle Kubernetes-Kommandos, Git-Operationen und Konfigurationsänderungen werden direkt auf der Linux-Hostmaschine ausgeführt, während Visual Studio Code lediglich als Entwicklungsumgebung dient.