So installieren Sie Kubernetes auf Ubuntu

Published on: September 12, 2025

.

16 min read

.

Für die Englische Version

Kubernetes ist zum Industriestandard für die Verwaltung containerisierter Anwendungen in großem Maßstab geworden. Kubernetes bietet Entwicklern und Systemadministratoren eine leistungsstarke Plattform, um Bereitstellung, Skalierung und Betrieb über Cluster von Maschinen zu automatisieren. Für Anfänger kann der erste Schritt, die Einrichtung von Kubernetes, jedoch überwältigend sein. Deshalb ist die Verwendung von Ubuntu, einer der am weitesten verbreiteten Linux-Distributionen, oft die bevorzugte Wahl. Ubuntu ist bekannt für seine Stabilität, starke Community-Unterstützung und Kompatibilität mit dem Kubernetes-Ökosystem, was es zu einer soliden Grundlage für Lern- und Produktionszwecke macht.

Bevor Sie direkt mit der Installation beginnen, ist es wichtig zu verstehen, dass eine ordnungsgemäße Systemvorbereitung entscheidend ist. Ein erfolgreicher Aufbau hängt nicht nur von der Installation der richtigen Werkzeuge ab, sondern auch davon, dass Ihr System bereit ist, Kubernetes-Workloads zu bewältigen. In diesem Leitfaden werden wir den gesamten Prozess Schritt für Schritt durchgehen, einschließlich Vorbereitung, Installation und Nachinstallationsprüfungen.

Am Ende werden Sie nicht nur einen laufenden Kubernetes-Cluster auf Ubuntu haben, sondern auch die Kernwerkzeuge, Testmethoden und Skalierungsoptionen verstehen, die damit einhergehen. Dieser strukturierte Ansatz wird Ihnen helfen, Vertrauen im Umgang mit Kubernetes-Clustern aufzubauen und Sie auf fortgeschrittenere Szenarien vorzubereiten.

Schritt 1: Ubuntu-Knoten vorbereiten.

Bevor Sie Kubernetes auf Ubuntu installieren, müssen Sie Ihre Maschinen ordnungsgemäß vorbereiten. Sorgfältige Vorbereitung verhindert die meisten häufigen Fehler und sorgt für eine reibungslosere Cluster-Einrichtung.

Mindestanforderung für die Einrichtung: Um ein echtes Kubernetes-Cluster aufzubauen, benötigen Sie mindestens 2 Ubuntu-Knoten.

• 1 Control Plane Node (auch als Master bezeichnet), wo der Cluster verwaltet wird.

• 1 Worker Node, auf dem Ihre Anwendungen (Pods) ausgeführt werden.

Wenn Sie nur eine einzige Ubuntu-Maschine haben, können Sie trotzdem einen Single-Node-Cluster (All-in-One-Setup) ausprobieren, aber es wird keine echte Multi-Node-Umgebung darstellen.

Zu Lernzwecken ist der anfängerfreundlichste Ansatz, Virtuelle Maschinen (VMs) auf deinem Computer zu verwenden (z.B. VirtualBox oder VMware). In der Produktion könnten diese Knoten physische Server oder Cloud-Instanzen sein, aber für diesen Leitfaden konzentrieren wir uns auf die Verwendung von VMs, um die Dinge einfach und sicher zu halten.

Jeder Ubuntu-Knoten muss die folgenden Anforderungen erfüllen:

• Ausführen einer unterstützten Ubuntu-Version (22.04 LTS oder 24.04 LTS).

• Einem einzigartigen Hostnamen zugewiesen.

• Zeitlich synchronisiert (NTP aktiviert).

• Mit dem Netzwerk mit erreichbaren IPs verbunden.

• Konfiguriert mit entweder offenen Firewall-Ports oder einer deaktivierten Firewall für Lernumgebungen.

Lass uns diese Anforderungen durchgehen und die Ubuntu-Maschinen vorbereiten.

1. Überprüfen Sie die Systemversion und Ressourcen: Stellen Sie sicher, dass Sie Ubuntu 20.04 oder 22.04 LTS mit mindestens 2 CPUs und 2 GB RAM pro Knoten ausführen. Überprüfen Sie die Ubuntu-Version und die Systemressourcen mit den folgenden Befehlen.

   lsb_release -ds
   nproc && free -h
   hinweis

   Hinweis zu Ubuntu 24.04 Obwohl diese Schritte auf Ubuntu 24.04 funktionieren, gehen die meisten Kubernetes-Dokumentationen und -Tutorials immer noch von Ubuntu 22.04 aus. Für Anfänger empfehlen wir, mit Ubuntu 22.04 LTS zu beginnen, um Kompatibilitätsprobleme zu vermeiden und die Fehlersuche zu erleichtern.

2. Setzen Sie einen eindeutigen Hostnamen: Jeder Knoten muss seinen eigenen Namen haben, damit Kubernetes ihn identifizieren kann. Verwenden Sie die folgenden Befehle, um Hostnamen festzulegen.

   # On the control plane:
   sudo hostnamectl set-hostname cp-1

   # On a worker node:
   sudo hostnamectl set-hostname worker-1

3. Aktualisieren Sie /etc/hosts für einfache Namensauflösung (optional, aber hilfreich): Dies ermöglicht es den Knoten, sich gegenseitig beim Namen zu erkennen. Fügen Sie die Hostnamen und IPs aller Knoten zu /etc/hosts hinzu.

   1. Verwenden Sie den folgenden Befehl, um die Datei /etc/hosts in einem Texteditor zu öffnen.

      sudo nano /etc/hosts

   2. Fügen Sie die IP-Adressen und Hostnamen aller Ihrer Knoten hinzu. Ersetzen Sie die IPs durch Ihre.

      192.168.1.8 cp-1
      192.168.1.9 worker-1

   3. Wenn du mit dem Bearbeiten fertig bist, speichere und verlasse Nano. STRG + O, ENTER, dann STRG + X.

4. Aktivieren Sie die Zeitsynchronisation: Eine konsistente Zeit ist entscheidend für Zertifikate und die Stabilität des Clusters. Aktivieren und starten Sie den Zeit-Synchronisierungsdienst, indem Sie den folgenden Befehl ausführen.

   sudo timedatectl set-ntp on

   Dann überprüfen Sie, ob es funktioniert, indem Sie den nächsten Befehl ausführen.

   timedatectl status

5. Firewall-Einstellungen festlegen: Wenn Sie gerade lernen, deaktivieren Sie die Firewall zur Vereinfachung.

   sudo ufw disable

   Wenn Sie die Firewall aktiv halten möchten, öffnen Sie die erforderlichen Ports (6443, 10250 usw.).

6. Überprüfen Sie eindeutige Systemkennungen: Kubernetes erfordert, dass jeder Knoten eine eindeutige Identität hat.

   sudo cat /sys/class/dmi/id/product_uuid
   ip link | awk '/link\/ether/ {print $2}'
   hinweis

   Wenden Sie diese Schritte auf sowohl cp-1 als auch worker-1 an. Wenn Sie später weitere Knoten hinzufügen (z. B. worker-2), fügen Sie deren Einträge auch auf allen Maschinen hinzu.

   tipp

   Kubernetes ist auf eine eindeutige Knotenidentität, synchronisierte Zeit und offene Netzwerkpfade angewiesen. Das Überspringen dieser Schritte führt oft zu kubeadm-Join-Fehlern oder instabilen Clustern. Indem Sie Ihre Ubuntu-Knoten richtig vorbereiten, schaffen Sie eine zuverlässige Grundlage für den Rest Ihres Kubernetes.

Schritt 2. Abhängigkeiten aktualisieren und installieren

Bevor Sie Kubernetes-Komponenten installieren, stellen Sie sicher, dass jeder Ubuntu-Knoten vollständig aktualisiert ist und die erforderlichen Basis-Pakete installiert sind. Dieser Schritt gewährleistet Stabilität und verhindert häufige Fehler während der Cluster-Einrichtung.

1. Aktualisieren Sie den Paketindex und aktualisieren Sie vorhandene Pakete mit dem folgenden Befehl.

   sudo apt-get update && sudo apt-get upgrade -y

2. Als Nächstes installieren Sie die erforderlichen Abhängigkeiten mit dem folgenden Befehl.

   sudo apt-get install -y apt-transport-https ca-certificates curl gnupg lsb-release

3. Führen Sie diese Befehle sowohl auf dem Control Plane als auch auf allen Worker-Knoten aus, damit jeder Knoten auf die gleiche Weise vorbereitet wird.

tipp

Auf frisch erstellten VMs könnte dieser Schritt eine Weile dauern, da viele Updates angewendet werden. Seien Sie geduldig; aktualisierte Knoten sind entscheidend für eine reibungslose Kubernetes-Installation.

Schritt 3. Swap deaktivieren

Kubernetes erfordert, dass der Swap auf allen Knoten deaktiviert ist. Warum? Weil der Kubelet (der Agent, der auf jedem Knoten läuft) erwartet, den Speicher direkt zu verwalten. Wenn Swap aktiviert ist, kann der Kernel Speicherseiten auf die Festplatte verschieben, was zu Leistungsproblemen führt und die Ressourcenzuteilung unvorhersehbar macht. Verwenden Sie die folgenden Schritte, um den Swap zu deaktivieren.

1. Um den Swap vorübergehend (bis zum nächsten Neustart) zu deaktivieren, verwenden Sie den folgenden Befehl.

   sudo swapoff -a

2. Um den Swap dauerhaft zu deaktivieren, bearbeiten Sie die Datei /etc/fstab und entfernen oder kommentieren Sie den Swap-Eintrag aus. Verwenden Sie den folgenden Befehl, um die Datei /etc/fstab in einem Texteditor zu öffnen.

   sudo nano /etc/fstab

3. Suchen Sie nach einer Zeile, die das Wort swap enthält, zum Beispiel: swapfile none swap sw 0 0.

4. Fügen Sie ein # am Anfang dieser Zeile hinzu, um sie auszukommentieren. Speichern und Nano beenden (CTRL + O, ENTER, dann CTRL + X).

   Abbildung 1. Bearbeiten Sie die /etc/fstab-Datei

5. Um zu überprüfen, dass der Swap deaktiviert ist, führen Sie den folgenden Befehl aus. Sie sollten 0B unter der Swap-Spalte sehen.

   free -h

6. Wenden Sie diesen Schritt auf alle Knoten (sowohl Steuerungsebene als auch Arbeitsknoten) an.

tipp

Wenn Sie diesen Schritt überspringen, schlägt kubeadm init oder kubeadm join normalerweise mit Fehlern fehl, die mit dem Nichtstarten des Kubelets zusammenhängen.

Schritt 4. Kernel-Module laden & sysctl-Netzwerkeinstellungen

Kubernetes-Netzwerk erfordert, dass bestimmte Linux-Kernel-Module und Sysctl-Parameter aktiviert sind. Ohne diese können Ihre Pods möglicherweise nicht über die Knoten hinweg kommunizieren. Um dies korrekt zu konfigurieren, folgen Sie den untenstehenden Schritten auf jedem Ubuntu-Knoten.

1. Öffnen Sie die Konfigurationsdatei mit dem folgenden Befehl, um Kernel-Module zu aktivieren.

   sudo nano /etc/modules-load.d/k8s.conf

2. Fügen Sie die folgenden Zeilen in die Datei ein.

   overlay
   br_netfilter

3. Speichern und Nano beenden (STRG + O, ENTER, dann STRG + X).

4. Laden Sie die Module sofort (ohne Neustart) mit den folgenden Befehlen.

   sudo modprobe overlay
   sudo modprobe br_netfilter

5. Überprüfen Sie, ob die Module geladen sind, um die Einstellungen mit den folgenden Befehlen zu verifizieren.

   lsmod | grep br_netfilter
   lsmod | grep overlay

6. Öffnen Sie die sysctl-Konfigurationsdatei um die sysctl-Netzwerkverbindung zu konfigurieren.

   sudo nano /etc/sysctl.d/k8s.conf

7. Fügen Sie die folgenden Zeilen in die Datei ein:

   net.bridge.bridge-nf-call-iptables = 1
   net.bridge.bridge-nf-call-ip6tables = 1
   net.ipv4.ip_forward = 1

8. Speichern und Nano beenden, dann die Einstellungen mit dem folgenden Befehl anwenden.

   sudo sysctl --system

9. Führen Sie die folgenden Befehle aus, um die sysctl-Werte zu überprüfen. Beide sollten = 1 zurückgeben.

   sysctl net.bridge.bridge-nf-call-iptables
   sysctl net.ipv4.ip_forward

tipp

Wenn du das überspringst, können deine Pods starten, aber ihr werdet nicht miteinander sprechen können.

Schritt 5. Container-Laufzeit installieren

Bevor Kubernetes Pods starten kann, benötigt es eine Container-Laufzeit. Denken Sie an Kubernetes als den Orchestrator (den Manager) und die Container-Laufzeit als den Motor, der tatsächlich Container ausführt.

• Kubernetes plant und weist Knoten an, was ausgeführt werden soll.

• Die Container-Laufzeitumgebung (wie containerd) übernimmt die Hauptarbeit: Images herunterladen, Container erstellen, starten/stoppen und deren Lebenszyklus verwalten.

Kurz gesagt: Kubernetes führt Container nicht direkt aus; es verlässt sich auf eine Laufzeitumgebung.

In diesem Leitfaden verwenden wir containerd, da es leichtgewichtig, stabil und von der Kubernetes-Community offiziell für Produktions- und Lernumgebungen empfohlen wird.

Um es richtig einzurichten, befolgen Sie die folgenden Schritte auf jedem Ubuntu-Knoten (Control Plane und Worker).

1. Installieren Sie die erforderlichen Pakete mit den folgenden Befehlen.

   sudo apt update
   sudo apt install -y curl gnupg2 software-properties-common apt-transport-https ca-certificates

2. Installieren Sie containerd mit dem folgenden Befehl.

   sudo apt install -y containerd

3. Konfigurieren Sie containerd. Generieren Sie die Standardkonfiguration und aktivieren Sie SystemdCgroup (erforderlich für Kubernetes) mit den folgenden Befehlen.

   sudo mkdir -p /etc/containerd
   containerd config default | sudo tee /etc/containerd/config.toml > /dev/null

4. Öffnen Sie die Konfigurationsdatei in einem Texteditor.

   sudo nano /etc/containerd/config.toml

   Finde den Abschnitt [plugins."io.containerd.grpc.v1.cri".containerd.runtimes.runc.options] und setze ihn wie unten gezeigt.

   SystemdCgroup = true

5. Speichern und beenden (STRG + O, ENTER, STRG + X).

6. Starten Sie containerd mit dem folgenden Befehl neu.

   sudo systemctl restart containerd
   sudo systemctl enable containerd

   An diesem Punkt haben Ihre Knoten eine funktionierende Container-Laufzeit. Kubernetes wird containerd verwenden, um Images herunterzuladen und Pods auszuführen.

Schritt 6: Installieren Sie Kubernetes-Komponenten (kubeadm, kubelet, kubectl)

Jetzt, da die Container-Laufzeit bereit ist, besteht der nächste Schritt darin, die unten aufgeführten Kern-Kubernetes-Tools zu installieren.

• kubeadm: bootstrapped den Cluster. Es vereinfacht den Prozess der Einrichtung von Kubernetes, indem es Zertifikate, Netzwerke und Komponenten des Steuerungssystems verwaltet.

• kubelet: der Knoten-Agent. Läuft auf allen Knoten, startet und verwaltet Pods gemäß den Anweisungen des Steuerungssystems.

• kubectL: das Befehlszeilenwerkzeug, das verwendet wird, um mit Ihrem Cluster zu interagieren (Apps bereitstellen, Protokolle überprüfen, Arbeitslasten skalieren usw.).

Diese drei Werkzeuge sind die Grundlage deiner Kubernetes-Installation. Ohne sie kann der Cluster nicht erstellt oder verwaltet werden.

Befolgen Sie diese Schritte auf allen Knoten (Control Plane + Worker).

1. Aktualisieren Sie den Paketindex und installieren Sie die Voraussetzungen mit dem folgenden Befehl. Diese Werkzeuge ermöglichen eine sichere Kommunikation (HTTPS), die Handhabung von Zertifikaten und die Überprüfung von Paketen.

   sudo apt update
   sudo apt install -y apt-transport-https ca-certificates curl gpg

2. Laden Sie den öffentlichen Google Cloud-Signaturschlüssel mit dem folgenden Befehl herunter. Dies lädt den offiziellen Signaturschlüssel von Kubernetes herunter und speichert ihn. Es stellt sicher, dass die Pakete, die Sie installieren, wirklich von Kubernetes stammen und nicht manipuliert wurden.

   sudo curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.30/deb/Release.key | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg

3. Fügen Sie das Kubernetes-Apt-Repository mit den folgenden Befehlen hinzu. Dies sagt Ubuntu, wo es Kubernetes-Pakete herunterladen soll.

   echo "deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] https://pkgs.k8s.io/core:/stable:/v1.30/deb/ /" | sudo tee /etc/apt/sources.list.d/kubernetes.list

4. Aktualisieren Sie erneut den Paketindex und installieren Sie die Komponenten mit den folgenden Befehlen.

   sudo apt update
   sudo apt install -y kubelet kubeadm kubectl

5. Verhindern Sie automatische Upgrades mit dem folgenden Befehl. Dies sperrt die Versionen, sodass ein apt-Upgrade Ihren Cluster nicht durch ein unerwartetes Upgrade von Kubernetes beschädigt.

   sudo apt-mark hold kubelet kubeadm kubectl

6. Überprüfen Sie die Installation mit dem folgenden Befehl.

   kubeadm version
   kubectl version --client
   kubelet --version

Stellen Sie sicher, dass die Versionen über alle Knoten hinweg übereinstimmen. Das Synchronhalten vermeidet Kompatibilitätsfehler beim Initialisieren oder Beitreten zum Cluster.

Schritt 7: Initialisieren der Steuerungsebene

Bisher haben wir nur die Knoten vorbereitet und die Werkzeuge installiert. Jetzt werden wir den Cluster auf dem Steuerungsknoten mit kubeadm init bootstrapen. Der Steuerungsebene ist der Ort, an dem Kubernetes seinen API-Server, Scheduler und Controller-Manager ausführt. Ohne diesen Schritt gibt es noch keinen Cluster.

1. Führen Sie kubeadm init auf dem Steuerungsknoten aus.

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

   --pod-network-cidr=10.244.0.0/16 sagt Kubernetes, welchen IP-Bereich Pods verwenden werden.

   (Wir werden später ein Netzwerk-Plugin installieren; dieser Bereich stimmt mit Flannel überein, einer gängigen Wahl.)

   hinweis

   Dieser Befehl darf nur auf dem Steuerungsknoten (nicht auf den Arbeitern) ausgeführt werden.

2. Speichern Sie den Join-Befehl aus der Ausgabe. Am Ende von kubeadm init sehen Sie eine Ausgabe wie diese:

   kubeadm join 192.168.1.50:6443 --token abcdef.0123456789abcdef \
   --discovery-token-ca-cert-hash sha256:1234567890abcdef...

   Abbildung 2. Join-Befehl

3. Kopiere diesen Befehl an einen sicheren Ort. Du wirst es später benötigen, um Arbeitsknoten dem Cluster hinzuzufügen.

An diesem Punkt haben Sie einen initialisierten Steuerungsknotenknoten, der bereit ist, Arbeitsknoten zu akzeptieren.

Schritt 8: kubectl-Zugriff einrichten

Wenn Sie kubeadm init ausführen, generiert Kubernetes eine admin kubeconfig-Datei. Diese Datei enthält die Zertifikate und Verbindungsdetails, die kubectl verwendet, um mit der Steuerungsebene zu kommunizieren. Standardmäßig wird es unter /etc/kubernetes/admin.conf gespeichert.

Um kubectl als normaler Benutzer (nicht root) zu verwenden, müssen Sie diese Datei in Ihr Home-Verzeichnis kopieren und die entsprechenden Berechtigungen festlegen. Ohne diesen Schritt müssten Sie jeden kubectl-Befehl als sudo ausführen, was nicht ideal ist.

Befolgen Sie diese Schritte auf dem Steuerungsebene-Knoten.

1. Erstellen Sie das Verzeichnis .kube in Ihrem Home-Verzeichnis (falls nicht vorhanden) mit dem folgenden Befehl.

   mkdir -p $HOME/.kube

2. Kopiere die Datei admin.conf mit dem folgenden Befehl in dieses Verzeichnis.

   sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config

3. Beheben Sie die Berechtigungen mit dem folgenden Befehl, damit Ihr Benutzer darauf zugreifen kann.

   sudo chown $(id -u):$(id -g) $HOME/.kube/config

4. Um den Zugriff auf kubectl zu überprüfen, führen Sie den folgenden Befehl aus.

   kubectl get nodes

An diesem Punkt sollte der Steuerungsknoten als NotReady angezeigt werden, das ist normal, bis Sie im nächsten Schritt ein CNI-Plugin installieren.

Schritt 9: Installieren Sie ein CNI-Plugin

An diesem Punkt läuft die Steuerungsebene, aber die Knoten sind immer noch als NotReady markiert. Das liegt daran, dass Kubernetes ein Container Network Interface (CNI) Plugin benötigt, damit Pods über Knoten hinweg miteinander kommunizieren können.

Es gibt mehrere Optionen (Calico, Cilium, Weave, Flannel). In diesem Leitfaden verwenden wir Flannel, weil es einfach, weit verbreitet und gut für die meisten Anfänger- und Testcluster geeignet ist. Wir benötigen ein CNI-Plugin aus den folgenden Gründen.

• Kubernetes selbst implementiert kein Networking.

• Das CNI-Plugin verwaltet die Pod-zu-Pod-Netzwerkverbindung und die Pod-zu-Service-Kommunikation.

• Ohne es bleiben Pods im Pending-Zustand, und der Cluster wird nicht nutzbar sein.

Befolgen Sie diese Schritte, um ein CNI-Plugin auf dem Steuerungsknotenknoten zu installieren.

1. Führen Sie den folgenden Befehl aus, um das Flannel DaemonSet und die zugehörigen Ressourcen in den Cluster bereitzustellen.

   kubectl apply -f https://raw.githubusercontent.com/flannel-io/flannel/master/Documentation/kube-flannel.yml

2. Nach ein oder zwei Minuten überprüfen Sie die Pods im kube-flannel-Namespace mit dem folgenden Befehl. Du solltest einen Flannel-Pod pro Knoten sehen.

   kubectl get pods -n kube-flannel

3. Überprüfen Sie den Status des Knotens erneut mit dem folgenden Befehl. Der Steuerungsknoten sollte von NotReady → Ready wechseln, sobald das Netzwerk aktiv ist.

   kubectl get nodes

An diesem Punkt in Ihrer Kubernetes-Installation haben Sie Folgendes.

• Ein funktionierendes Kubernetes-Steuerungssystem, das mit kubeadm initialisiert wurde.

• Ein CNI-Plugin (Flannel) installiert und konfiguriert, um die Pod-Netzwerkanbindung bereitzustellen.

• Funktionales Kubernetes-Netzwerk, was bedeutet, dass Pods über Knoten hinweg kommunizieren können.

• Ein Cluster, das bereit ist, von Worker-Knoten beigetreten zu werden (nächster Schritt).

Dies ist ein kritischer Meilenstein beim Aufbau Ihres Kubernetes-Clusters. Mit dem funktionierenden Steuerungsebenen und der eingerichteten Netzwerkinfrastruktur sind Sie bereit, den Cluster durch Hinzufügen von Arbeitsknoten zu erweitern, was Ihnen ermöglicht, Arbeitslasten zu planen und auszuführen.

Schritt 10: Worker-Knoten beitreten

Jetzt, da die Steuerungsebene bereit ist, ist es Zeit, Arbeitsknoten zum Cluster hinzuzufügen. Arbeiterknoten sind der Ort, an dem Ihre Pods (Anwendungen) tatsächlich laufen, und sie verbinden sich wieder mit der Steuerungsebene, um Anweisungen zu erhalten.

Als Sie kubeadm init auf dem Steuerungsknoten ausgeführt haben, wurde am Ende der Ausgabe ein Beitrittsbefehl bereitgestellt. Es sieht ungefähr so aus.

kubeadm beitreten 192.168.1.50:6443 --token abcdef.0123456789abcdef --discovery-token-ca-cert-hash sha256:1234567890abcdef...

Führen Sie den Join-Befehl auf jedem Worker-Knoten aus. Ersetzen Sie die IP-Adresse (192.168.1.50), das Token und den Hash durch die in Ihrer Einrichtung generierten Werte.

Dieser Befehl enthält drei kritische Teile:

• Control-Plane-IP & Port (6443): sagt dem Worker, wo er sich verbinden soll.

• Bootstrap-Token: ein temporäres Geheimnis zur Authentifizierung des Knotens.

• CA-Zertifikathash: stellt sicher, dass der Worker dem Steuerungssystem vertraut.

Dies muss auf allen Worker-Knoten, die Sie hinzufügen möchten, durchgeführt werden. Jeder Worker wird sich beim Steuerungssystem registrieren.

tipp

Wenn du den Befehl nicht gespeichert hast, kannst du ihn jederzeit auf der Steuerungsebene regenerieren, indem du den folgenden Befehl ausführst.

kubeadm token create --print-join-command

Schritt 11: Überprüfen Sie, ob alles läuft

Sowohl der Steuerungsebene als auch die Arbeitsknoten sind eingerichtet, lassen Sie uns bestätigen, dass der Cluster gesund ist und bereit ist, Arbeitslasten auszuführen.

1. Überprüfen Sie, ob die Arbeitsknoten beigetreten sind: Gehe zum Control Plane-Knoten und führe den folgenden Befehl aus.

   kubectl get nodes

   Erwartete Ausgabe sieht so aus:

   • Der Steuerungsebene-Knoten: Bereit

   • Jeder Arbeitsknoten: Bereit

   Dies bestätigt, dass die Knoten erfolgreich registriert sind und zur Planung von Pods zur Verfügung stehen.

   Abbildung 3. Die Bestätigung, dass Knoten registriert sind

2. Überprüfen Sie die System-Pods: Kubernetes führt mehrere Kernsystem-Pods (DNS, Netzwerk, Controller) aus. Listen Sie sie mit dem folgenden Befehl auf.

   kubectl get pods -n kube-system

   Alle Pods sollten sich im Zustand Running oder Completed befinden. Häufige System-Pods, die du sehen wirst. Wenn sich welche im Zustand CrashLoopBackOff oder Pending befinden, überprüfen Sie die Protokolle mit dem folgenden Befehl.

   kubectl logs <pod-name> -n kube-system

3. Eine einfache Testanwendung bereitstellen: Um zu bestätigen, dass Pods auf Worker-Knoten geplant werden können, stellen Sie eine Beispielanwendung Nginx mit den folgenden Befehlen bereit.

   kubectl create deployment nginx --image=nginx
   kubectl get pods

   Sie sollten einen nginx Pod sehen, der auf einem der Worker-Knoten erstellt und ausgeführt wird.

4. Die Anwendung exponieren: Exponieren Sie Nginx als Dienst, um extern darauf zuzugreifen, mit den folgenden Befehlen. Die Ausgabe zeigt den zugewiesenen NodePort (z.B. 31234).

   kubectl expose deployment nginx --type=NodePort --port=80
   kubectl get svc nginx -o wide

5. Zugriff auf Nginx über Browser / Host: Verwenden Sie die IP des Knotens und den NodePort in Ihrem Browser.

   http://192.168.1.8:31234

   Abbildung 4. Zugriff auf Nginx über den Browser

6. Pod-Platzierung bestätigen: Überprüfen Sie schließlich, wo der Pod läuft, mit dem folgenden Befehl. Dies zeigt, welcher Worker-Knoten das Nginx-Pod hostet.

   kubectl get pods -o wide

Sie haben jetzt einen Multi-Node-Kubernetes-Cluster auf Ubuntu, bereit für Lern- oder Testlasten.

Warum Kubernetes auf Ubuntu installieren?

Bei der Einrichtung von Kubernetes ist die Wahl des richtigen Betriebssystems ebenso wichtig wie die Konfiguration des Clusters selbst. Ubuntu ist eine der am weitesten verbreiteten Linux-Distributionen der Welt und hat sich zu einer bevorzugten Wahl für den Betrieb von Kubernetes entwickelt.

Zuerst macht Ubuntus Beliebtheit und breite Kompatibilität es zu einem idealen Basissystem. Die meisten Kubernetes-Tutorials, Dokumentationen und Community-Beispiele sind mit Ubuntu im Hinterkopf geschrieben, was das Troubleshooting und Lernen sowohl für Anfänger als auch für Profis erheblich erleichtert.

Zweitens hat Ubuntu starke Unterstützung aus der Community und direkte Rückendeckung von Canonical (dem Unternehmen hinter Ubuntu). Canonical arbeitet eng mit der Kubernetes-Community zusammen und stellt sicher, dass Ubuntu mit den neuesten Kubernetes-Versionen und Sicherheitsupdates übereinstimmt. Das bedeutet, dass Sie eine zuverlässige, gut gewartete Plattform für Ihr Cluster erhalten.

Drittens ist Ubuntu bekannt für seine Leistung, Sicherheit und Cloud-Bereitschaft. Es bietet eine leichte, effiziente Umgebung, die sowohl auf Bare-Metal- als auch auf virtualisierten oder Cloud-Umgebungen gut läuft. Die integrierten Sicherheitsupdates und die Langzeitunterstützungs (LTS)-Versionen machen es zu einer stabilen Wahl für produktionsreife Kubernetes-Cluster.

Zusammenfassend lässt sich sagen, dass Ubuntu Benutzerfreundlichkeit, Community-Unterstützung und Unternehmensstabilität vereint, was es zu einem der besten Betriebssysteme für die Installation und Ausführung von Kubernetes macht.

Was sind die Voraussetzungen für die Installation von Kubernetes auf Ubuntu?

Bevor Sie Kubernetes auf Ubuntu einrichten, müssen Sie sicherstellen, dass Ihr System einige Hardware-, Software- und Konfigurationsanforderungen erfüllt. Diese Voraussetzungen helfen sicherzustellen, dass Ihr Cluster reibungslos läuft und häufige Probleme während der Installation vermieden werden.

Systemanforderungen

Um Kubernetes erfolgreich zu installieren, muss Ihr System einige Mindestanforderungen an Hardware und Betriebssystem erfüllen. Diese stellen sicher, dass jeder Knoten genügend Leistung und Ressourcen hat, um Pods auszuführen und Arbeitslasten zu verwalten.

• Betriebssystem: Verwenden Sie Ubuntu 20.04 oder 22.04 (64-Bit). Kubernetes wurde auf diesen Versionen getestet und ist stabil, daher verringert die Verwendung dieser Versionen Kompatibilitätsprobleme.

• CPU: Mindestens 2 CPU-Kerne sind pro Maschine erforderlich. Der Steuerungsknoten sollte mehr Ressourcen haben, da er den gesamten Cluster verwaltet.

• Speicher (RAM): Jeder Knoten benötigt mindestens 2 GB RAM. Für die Steuerungsebene werden 4 GB oder mehr empfohlen, damit sie die Aufgaben der Clusterverwaltung bewältigen kann.

• Speicher: Es wird empfohlen, mindestens 20 GB freien Speicherplatz pro Knoten bereitzustellen, um Container-Images, Protokolle und Systemdateien zu speichern.

• Netzwerk: Alle Knoten müssen über ein zuverlässiges Netzwerk verbunden sein. Jeder Knoten sollte einen eindeutigen Hostnamen, eine MAC-Adresse und eine product_uuid haben, damit Kubernetes sie korrekt identifizieren kann.

Software-Anforderungen

Neben der Hardware müssen bestimmte Software und Konfigurationen vorhanden sein, damit Kubernetes korrekt funktioniert. Diese Anforderungen stellen sicher, dass die Clusterkomponenten kommunizieren und Arbeitslasten fehlerfrei verwalten können.

• Container-Laufzeit: Eine Container-Laufzeit ist notwendig, um Container innerhalb von Pods auszuführen. Die empfohlene Laufzeitumgebung ist containerd, obwohl Docker in einigen Fällen weiterhin verwendet werden kann.

• Swap deaktiviert: Kubernetes erfordert, dass der Swap deaktiviert ist. Swap stört die Art und Weise, wie der Kubelet den Speicher verwaltet, daher müssen Sie es dauerhaft deaktivieren.

• Zeitsynchronisation: Knoten müssen synchronisierte Uhren haben. Installieren und aktivieren Sie Werkzeuge, um Planungs- und Zertifikatfehler zu vermeiden.

• Firewall-Regeln: Öffnen Sie die erforderlichen Ports, wie 6443 (API-Server), 10250 (Kubelet) und andere je nach Ihrer Konfiguration. Ohne dies können die Knoten nicht richtig kommunizieren.

Welche Kubernetes-Tools muss ich zuerst installieren?

Bevor Sie ein Kubernetes-Cluster erstellen, müssen Sie einige wesentliche Werkzeuge installieren, die es Ihnen ermöglichen, das Cluster einzurichten, zu verwalten und mit ihm zu interagieren. Diese Werkzeuge arbeiten zusammen, um die Steuerungsebene zu initialisieren, den Cluster am Laufen zu halten und Ihnen eine Möglichkeit zu bieten, mit ihm zu kommunizieren.

• kubeadm: Dies ist das offizielle Tool zum Bootstrappen von Kubernetes-Clustern. Es vereinfacht den Prozess der Initialisierung des Steuerplans und das Hinzufügen von Arbeitsknoten. Anstatt alles manuell zu konfigurieren, übernimmt kubeadm die Einrichtung und generiert die Befehle, die Sie benötigen, um Knoten zu verbinden.

• kubelet: Dies ist der Agent, der auf jedem Knoten im Cluster läuft. Es kommuniziert mit der Steuerungsebene und stellt sicher, dass Container (Pods) wie erwartet laufen. Ohne kubelet kann der Steuerungsebene keine Arbeitslasten auf dem Knoten planen oder überwachen.

• kubectl: Dies ist das Befehlszeilen-Interface (CLI)-Tool, das Sie als Administrator oder Entwickler verwenden, um mit dem Cluster zu interagieren. Mit kubectl können Sie Anwendungen bereitstellen, Protokolle überprüfen, Pods skalieren und Clusterressourcen verwalten.

Die empfohlene Methode zur Installation von Kubernetes-Tools auf Ubuntu ist über den APT-Paketmanager. Führen Sie die folgenden Befehle aus, um diese Werkzeuge zu installieren.

1. Aktualisieren Sie die Systempakete, indem Sie die folgenden Befehle ausführen.

   sudo apt-get update
   sudo apt-get install -y apt-transport-https ca-certificates curl gpg

2. Erstellen Sie das Schlüsselbundverzeichnis, indem Sie die folgenden Befehle ausführen.

   sudo mkdir -p /etc/apt/keyrings

3. Laden Sie den Kubernetes GPG-Schlüssel herunter und fügen Sie ihn hinzu, indem Sie die folgenden Befehle ausführen.

   sudo curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.30/deb/Release.key \
   | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg

4. Fügen Sie das Kubernetes APT-Repository hinzu, indem Sie die folgenden Befehle ausführen.

   echo "deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] \
   https://pkgs.k8s.io/core:/stable:/v1.30/deb/ /" \
   | sudo tee /etc/apt/sources.list.d/kubernetes.list

5. Aktualisieren Sie die Paketliste, indem Sie die nächsten Befehle ausführen.

   sudo apt-get update

6. Installieren Sie die Kubernetes-Komponenten, indem Sie die folgenden Befehle ausführen.

   sudo apt-get install -y kubelet kubeadm kubectl

7. Halten Sie die Versionen, um unbeabsichtigte Upgrades zu verhindern, indem Sie die nächsten Befehle ausführen.

   sudo apt-mark hold kubelet kubeadm kubectl

Alternativ können Werkzeuge wie Snap verwendet werden, aber APT wird im Allgemeinen bevorzugt, da es näher an der offiziellen Veröffentlichung von Kubernetes bleibt und gut dokumentiert ist.

Was mache ich nach der Installation der Kubernetes-Binärdateien?

Sobald Sie kubeadm, kubelet und kubectl erfolgreich installiert haben, besteht der nächste Schritt darin, Ihren Kubernetes-Cluster einzurichten. Dies beinhaltet die Initialisierung des Steuerungssystems, die Konfiguration des Zugriffs für Ihren Benutzer und die Aktivierung des Netzwerks, damit Pods kommunizieren können.

1. Initialisieren Sie den Steuerungsknoten: Führen Sie den folgenden Befehl auf Ihrem Control-Plane-Knoten aus, um Kubernetes zu initialisieren. Die Option --pod-network-cidr definiert den IP-Adressbereich für Pods. Es wird von den meisten CNI-Plugins (wie Flannel) benötigt.

   # Initialize the Kubernetes control plane with a pod network CIDR
   sudo kubeadm init --pod-network-cidr=10.244.0.0/16

2. Konfigurieren Sie kubectl für Ihre Nutzung:. Nach der Initialisierung müssen Sie kubectl so einrichten, dass der aktuelle Benutzer mit dem Cluster interagieren kann. Führen Sie den folgenden Befehl zur Konfiguration aus.

   Dies ermöglicht es Ihnen, kubectl get nodes, kubectl get pods und andere Befehle ohne Root-Zugriff auszuführen.

   1. Erstellen Sie ein kubeconfig-Verzeichnis für Ihren Benutzer, indem Sie die folgenden Befehle ausführen.

      mkdir -p $HOME/.kube

   2. Kopiere die Datei admin.conf in dein Benutzerverzeichnis, indem du die folgenden Befehle ausführst.

      sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config

   3. Passen Sie den Dateibesitz an, indem Sie die nächsten Befehle ausführen.

      sudo chown $(id -u):$(id -g) $HOME/.kube/config

3. Installieren Sie ein CNI-Plugin (Netzwerk): Kubernetes benötigt ein Container Network Interface (CNI) Plugin, damit Pods über Knoten hinweg kommunizieren können. Führen Sie die folgenden Befehle aus, um Flannel zu installieren. Ohne ein CNI-Plugin bleiben Pods im Status Pending.

   kubectl apply -f https://raw.githubusercontent.com/flannel-io/flannel/master/Documentation/kube-flannel.yml

Kann ich eine Testanwendung bereitstellen, um den Cluster zu testen?

Ja, sobald Ihr Kubernetes-Management-Plane und die Worker-Knoten betriebsbereit sind, können Sie eine einfache Testanwendung bereitstellen, um zu überprüfen, ob der Cluster korrekt funktioniert. Dieser Schritt stellt sicher, dass Pods ordnungsgemäß geplant werden und die Netzwerkverbindung zwischen den Knoten wie erwartet funktioniert. Führen Sie die folgenden Befehle aus, um eine Testanwendung bereitzustellen.

1. Erstellen Sie einen Namensraum mit dem folgenden Befehl. (Optional, aber empfohlen). Namespaces helfen, Arbeitslasten in Kubernetes zu organisieren.

   # Create a namespace called 'test'
   kubectl create namespace test

2. Eine Beispielanwendung (Nginx) bereitstellen. Wir werden das Nginx-Image verwenden, da es leichtgewichtig und weit verbreitet ist. Verwenden Sie den folgenden Befehl.

   # Deploy an Nginx Pod inside the 'test' namespace
   kubectl create deployment nginx --image=nginx -n test

   Überprüfen Sie den Status des Pods mit dem folgenden Befehl. Du solltest einen nginx Pod im Zustand Running sehen.

   kubectl get pods -n test

3. Die Anwendung exponieren. Um das Nginx-Deployment außerhalb des Clusters zugänglich zu machen, exponieren Sie es als NodePort-Dienst mit dem folgenden Befehl.

   kubectl expose deployment nginx --type=NodePort --port=80 -n test

   Überprüfen Sie den Dienst mit dem folgenden Befehl. Sie werden einen zugewiesenen NodePort (z.B. 30080) zusammen mit den Dienstdetails sehen.

   kubectl get svc -n test

4. Zugriff überprüfen. Verwenden Sie die IP des Worker-Knotens und den NodePort, um auf die Anwendung in Ihrem Browser zuzugreifen. Wenn erfolgreich, sehen Sie die Standard-Nginx-Startseite, die bestätigt, dass Ihr Cluster funktionsfähig ist.

   http://<Worker-Node-IP>:<NodePort>

Kann ich Hochverfügbarkeit für die Steuerungsebene einrichten?

Ja, Sie können Hochverfügbarkeit (HA) für den Kubernetes-Steuerungsebene einrichten, um Einzelpunkte des Ausfalls zu beseitigen. In Produktionsumgebungen stellt HA sicher, dass Ihr Cluster weiterhin funktioniert, selbst wenn einer der Steuerungsebene-Knoten abstürzt oder nicht mehr erreichbar ist.

1. Mehrere Steuerungsebene-Knoten mit einem Lastenausgleich: Um HA zu erreichen, verlässt sich Kubernetes darauf, mehrere Steuerungsebene-Knoten anstelle von nur einem zu betreiben. Diese Knoten werden von einem Lastenausgleich unterstützt, der den eingehenden Verkehr auf sie verteilt und einen stabilen Endpunkt für Clients bereitstellt, um sich zu verbinden.

   • Setzen Sie zwei oder mehr Steuerungsebene-Knoten ein.

   • Platzieren Sie einen Lastenausgleich vor den Knoten.

   • Verwenden Sie den DNS oder die IP des Lastenausgleichs in kubeadm mit dem --control-plane-endpoint-Flag.

2. Geteiltes etcd-Cluster und Zertifikatsverteilung: Ein hochverfügbarer Steuerungsebene erfordert auch ein widerstandsfähiges etcd-Cluster, da etcd alle Kubernetes-Zustandsdaten speichert. Zusätzlich müssen Zertifikate und kubeconfig-Dateien konsistent über alle Steuerungsebene-Knoten hinweg geteilt werden.

   • Konfigurieren Sie Multi-Node etcd für Redundanz.

   • Verwenden Sie kubeadm, um Zertifikate mit dem folgenden Befehl hochzuladen und zu verteilen.

     kubeadm init phase upload-certs --upload-certs

   • Stellen Sie sicher, dass alle Steuerungsebene-Knoten die richtigen Konfigurationsdateien haben.

3. Initialisierung des Steuerplanes mit kubeadm: Der Einrichtungsprozess beginnt am ersten Steuerungsebene-Knoten, wo Sie den Cluster mit HA-Unterstützung initialisieren. Dann können weitere Steuerungsebene-Knoten mit den entsprechenden Flags und dem Zertifikatsschlüssel beitreten.

   • Auf dem ersten Knoten initialisieren Sie mit dem folgenden Befehl.

     sudo kubeadm init --control-plane-endpoint "LOAD_BALANCER_DNS:6443" --upload-certs

   • Bei nachfolgenden Knoten schließen Sie sich mit dem folgenden Befehl an.

     sudo kubeadm join LOAD_BALANCER_DNS:6443 --token <token> \
     --discovery-token-ca-cert-hash sha256:<hash> \
     --control-plane --certificate-key <certificate-key>

   Die Einrichtung von HA für Kubernetes erfordert mehrere Steuerungsebene-Knoten, einen Lastenausgleich für die Verkehrsverteilung, ein mehrknotiges etcd-Cluster und eine ordnungsgemäße Zertifikatsverteilung. Mit kubeadm können Sie den HA-Controller einfach einrichten und erweitern.

Kann ich mein Kubernetes-Cluster später aktualisieren?

Ja, Kubernetes-Cluster können später auf neuere Versionen aktualisiert werden. Upgrades sind ein wesentlicher Bestandteil des Lebenszyklusmanagements von Clustern, um sicherzustellen, dass Sie die neuesten Funktionen, Leistungsverbesserungen und Sicherheitspatches erhalten. Der Prozess wird typischerweise mit kubeadm verwaltet, das eine schrittweise Methode bietet, um sowohl den Steuerungsknoten als auch die Arbeitsknoten zu aktualisieren.

1. Verfügbare Versionen mit kubeadm überprüfen: Bevor Sie ein Upgrade durchführen, sollten Sie immer überprüfen, welche Versionen verfügbar sind. Dies gewährleistet die Kompatibilität und vermeidet unerwartete Probleme. Führen Sie den folgenden Befehl aus.

   Dieser Befehl zeigt die aktuelle Cluster-Version, verfügbare Upgrade-Versionen und Empfehlungen für das Upgrade an.

   sudo kubeadm upgrade plan

2. Upgrade der Steuerungsebene: Der Upgrade-Prozess beginnt mit dem Control Plane-Knoten. Führen Sie den folgenden Befehl aus. Nach diesem Schritt werden der API-Server und andere Komponenten des Steuerungssystems aktualisiert.

   # Upgrade kubeadm itself
   sudo apt-get update && sudo apt-get install -y kubeadm
   # Apply the upgrade
   sudo kubeadm upgrade apply v1.31.0 # Example: upgrade to v1.31

3. Upgrade der Worker-Knoten: Sobald die Steuerungsebene aktualisiert ist, fahren Sie mit den Worker-Knoten fort. Führen Sie die folgenden Befehle aus. Dies stellt sicher, dass kubelet und kube-proxy auf jedem Worker-Knoten korrekt aktualisiert werden.

   # Upgrade kubeadm on worker node
   sudo apt-get update && sudo apt-get install -y kubeadm
   # Join node upgrade
   sudo kubeadm upgrade node

4. Aktualisieren Sie kubelet und kubectl: Auf allen Knoten (Control Plane und Worker) müssen Sie auch kubelet und kubectl mit den folgenden Befehlen aktualisieren.

   sudo apt-get install -y kubelet kubectl
   sudo systemctl daemon-reload
   sudo systemctl restart kubelet

Das Upgrade eines Kubernetes-Clusters mit kubeadm umfasst vier Hauptschritte: (1) verfügbare Versionen überprüfen, (2) das Steuerungsebenen-Upgrade durchführen, (3) die Arbeitsknoten upgraden und (4) kubelet und kubectl auf jedem Knoten aktualisieren. Indem Sie diese Schritte befolgen, können Sie Ihren Cluster sicher, stabil und auf dem neuesten Stand halten.

Was sind häufige Schritte zur Fehlersuche bei Kubernetes auf Ubuntu?

Beim Ausführen von Kubernetes auf Ubuntu können Sie auf Probleme im Zusammenhang mit Netzwerk, Knoten, Pods oder Clusterkonfiguration stoßen. Eine effektive Fehlersuche erfordert die Überprüfung sowohl des Cluster-Zustands als auch des zugrunde liegenden Systems. Im Folgenden sind die häufigsten Schritte zur Fehlersuche aufgeführt, die jeder Anfänger und fortgeschrittene Benutzer kennen sollte.

1. Überprüfen Sie den Knotenstatus: Stellen Sie sicher, dass alle Knoten registriert und im Zustand "Bereit" sind, indem Sie den folgenden Befehl verwenden.

   kubectl get nodes

   Wenn ein Knoten nicht bereit ist, überprüfen Sie die Kubelet-Protokolle mit den folgenden Befehlen.

   sudo journalctl -u kubelet -f

2. Überprüfen Sie die Pod-Gesundheit: Überprüfen Sie, ob Pods laufen, und sehen Sie sich ihre Ereignisse mit dem folgenden Befehl an.

   kubectl get pods -A kubectl describe pod <pod-name> -n <namespace>

   Wenn ein Pod in CrashLoopBackOff oder Pending feststeckt, können Protokolle weitere Details liefern. Führen Sie den folgenden Befehl aus.

   kubectl logs <pod-name> -n <namespace>

3. Überprüfen Sie die Container-Laufzeit: Ein häufiger Fehler stammt von der Container-Laufzeit (z.B. containerd). Überprüfen Sie seinen Status mit dem folgenden Befehl.

   sudo systemctl status containerd
   sudo ctr version

4. Überprüfen Sie die Netzwerkkonfiguration: Kubernetes benötigt ein funktionierendes CNI-Plugin (wie Flannel, Calico). Wenn Pods nicht kommunizieren können, überprüfen Sie dies mit dem folgenden Befehl. Suchen Sie nach CNI-Pods (Flannel/Calico) und stellen Sie sicher, dass sie laufen.

   kubectl get pods -n kube-system

5. Kernservices neu starten: Manchmal lösen Neustarts kritischer Dienste vorübergehende Probleme. Führen Sie die folgenden Befehle aus, um neu zu starten.

   sudo systemctl restart kubelet
   sudo systemctl restart containerd

6. Untersuchen Sie Cluster-Ereignisse: Kubernetes-Ereignisse können schnell Fehlkonfigurationen aufdecken. Verwenden Sie den folgenden Befehl.

   kubectl get events --sort-by=.metadata.creationTimestamp

7. Konfigurationsdateien validieren: Wenn Fehler weiterhin auftreten, überprüfen Sie die kubeadm- und kubelet-Konfigurationsdateien mit diesen Befehlen.

   cat /etc/kubernetes/kubelet.conf
   cat /etc/kubernetes/manifests/kube-apiserver.yaml

Kann ich Überwachung und Protokollierung nach der Installation einrichten?

Ja, das kannst (und solltest) du. Sobald Ihr Kubernetes-Cluster läuft, sind Überwachung und Protokollierung unerlässlich, um Stabilität, Leistung und Sicherheit zu gewährleisten. Ohne sie wird es sehr schwierig, Probleme zu erkennen, Anwendungen zu debuggen oder Ressourcen zu optimieren.

So gehen Sie bei der Überwachung und Protokollierung nach der Installation vor.

1. Überwachung des Clusters: Die Überwachung hilft dabei, Metriken wie CPU, Speicher, Festplattennutzung und Pod-Gesundheit zu verfolgen. Die beliebtesten Tools sind unten aufgeführt.

   • Prometheus: Erfasst und speichert Zeitreihendaten (Metriken) aus dem Cluster.

   • Grafana: Stellt Dashboards zur Verfügung, um Prometheus-Metriken benutzerfreundlich zu visualisieren.

2. Protokollierung des Clusters: Protokolle ermöglichen es Ihnen, das Verhalten von Systemen und Anwendungen zu analysieren. Einige empfohlene Lösungen sind unten aufgeführt.

   • Fluentd: Ein flexibler Protokollsammler, der Protokolle an verschiedene Speicher-Backends weiterleiten kann.

   • EFK-Stack (Elasticsearch, Fluentd, Kibana): Weit verbreitet für die zentrale Protokollverwaltung.

   • Loki + Grafana: Leichte Alternative zu EFK, integriert Protokolle direkt in Grafana-Dashboards.

3. Visuelle Cluster-Einblicke: Neben Rohmetriken und Protokollen können Sie auch visuelle Werkzeuge für eine bessere Clusterverwaltung verwenden.

   • Lens: Eine Desktop-Kubernetes-IDE, die die Echtzeit-Gesundheit von Pods, Protokolle und Cluster-Metriken anzeigt.

   • K9: Eine terminalbasierte Benutzeroberfläche, um Ressourcen interaktiv zu navigieren.

Fazit

Die Installation von Kubernetes auf Ubuntu mag zunächst komplex erscheinen, aber indem Sie einen strukturierten, schrittweisen Ansatz verfolgen, können Sie mit Leichtigkeit einen voll funktionsfähigen Cluster einrichten. In diesem Leitfaden haben wir das System vorbereitet, die Kernabhängigkeiten installiert, den Swap deaktiviert, das Netzwerk konfiguriert und die Kubernetes-Komponenten mit kubeadm, kubelet und kubectl bereitgestellt. Wir haben auch behandelt, wie man Worker-Knoten hinzufügt, die Installation überprüft, eine Testanwendung bereitstellt und Optionen für hohe Verfügbarkeit, Upgrades und Überwachung erkundet.

Ubuntu hebt sich als zuverlässiges, gemeinschaftsgetriebenes Betriebssystem hervor, das sich nahtlos in Kubernetes integriert und es zu einer der besten Plattformen sowohl für Anfänger als auch für produktionsreife Bereitstellungen macht.

Durch den Abschluss dieses Setups haben Sie jetzt einen Multi-Node-Kubernetes-Cluster, der bereit für reale Arbeitslasten ist. Von hier aus können Sie fortgeschrittene Themen wie Skalierung, hohe Verfügbarkeit, persistente Speicherung, Überwachung und Protokollierung erkunden, um eine widerstandsfähige und produktionsbereite Umgebung aufzubauen.