Kubernetes Tutorial: Grundlagen effektiven Container-Managements lernen

Kubernetes, oft als K8s abgekürzt, ist aufgrund seiner Skalierbarkeit, Flexibilität und Robustheit eine erste Wahl für die Container-Orchestrierung.Egal ob Sie Entwickler oder Systemadministrator sind, die Beherrschung von Kubernetes kann die Bereitstellung, Skalierung und Verwaltung containerisierter Anwendungen vereinfachen.

In diesem Artikel lernen Sie die grundlegenden Konzepte von Kubernetes kennen, lernen seine wichtigsten Funktionen kennen und untersuchen seine Vor- und Nachteile.Wir führen Sie durch die Einrichtung einer Kubernetes-Umgebung, die Bereitstellung Ihrer ersten Anwendung und die Behebung häufiger Probleme.

Am Ende dieses Tutorials können Sie Kubernetes vollständig für ein effizientes Containermanagement nutzen.

Die Kubernetes-Architektur bietet Entwicklern und Administratoren eine einheitliche Oberfläche. So können sich Teams voll und ganz auf die Anwendungsentwicklung konzentrieren – ohne sich Gedanken über die komplexe Infrastruktur im Hintergrund machen zu müssen.

Dieses Tool sorgt für den zuverlässigen Betrieb containerbasierter Anwendungen, übernimmt effizient deren Bereitstellung sowie Skalierung und deckt dabei die zugrunde liegende Hardware- und Netzwerkkonfiguration ab.

Wie funktioniert Kubernetes?

Kubernetes nutzt eine Steuerungsebene und verschiedene Kernkomponenten. Jede davon übernimmt eine bestimmte Aufgabe, um containerbasierte Anwendungen über den gesamten Cluster hinweg zu verwalten.

Knoten (Nodes)

Knoten sind die einzelnen Server, die das Fundament eines Kubernetes-Clusters bilden. Sie arbeiten entweder als Steuerungsknoten (Control Plane) oder als Arbeitsknoten (Worker Nodes) und sind für die Ausführung der Container unverzichtbar. Als Knoten können sowohl physische Server als auch Virtual Private Server dienen.

Pods

Pods sind die kleinsten Einheiten auf der Plattform und bilden die Bausteine für Kubernetes-Anwendungen. Ein Pod kann einen oder mehrere Container enthalten. Kubernetes bringt diese Container gemeinsam auf demselben Knoten unter, um die Kommunikation und die Lastverteilung zu optimieren.

Services

Services machen Anwendungen im Internet erreichbar und regeln die Lastverteilung. Sie bieten einen verlässlichen Zugang zu den containerbasierten Diensten und nehmen Ihnen die komplexe Netzwerkkonfiguration ab.

API-Server

Der API-Server ist die zentrale Schnittstelle der Kubernetes-Steuerungsebene. Er verarbeitet alle internen und externen Anfragen zur Verwaltung des Clusters.

ReplicaSets

ReplicaSets stellen sicher, dass immer eine festgelegte Anzahl identischer Pods aktiv ist. Das sorgt für hohe Ausfallsicherheit und Verlässlichkeit.

Ingress-Controller

Ingress-Controller greifen als Zugangssteuerung für den eingehenden Datenverkehr in Ihren Kubernetes-Cluster ein. Sie verwalten den Zugriff auf interne Dienste und erleichtern die Erreichbarkeit von außen.

Im Zusammenspiel ermöglichen diese Komponenten es Kubernetes, die Komplexität containerbasierter Anwendungen in verteilten Systemen mühelos zu bewältigen.

Hauptmerkmale von Kubernetes

Kubernetes bringt eine Vielzahl an Funktionen mit, die perfekt auf die Anforderungen moderner containerbasierter Anwendungen zugeschnitten sind:

Skalierung

Kubernetes passt die Anzahl der laufenden Container dynamisch an den aktuellen Bedarf an. Das sorgt für eine optimale Nutzung Ihrer Ressourcen, spart Kosten und garantiert eine reibungslose Nutzererfahrung.

Lastausgleich (Load Balancing)

Der integrierte Lastausgleich verteilt eingehenden Traffic automatisch und gleichmäßig auf mehrere Pods.

Selbstheilung

Die Selbstheilungsfunktionen von Kubernetes minimieren Ausfallzeiten: Fällt ein Container oder Pod aus, wird er automatisch ersetzt. So läuft Ihre Anwendung ohne Unterbrechung weiter.

Service-Erkennung und Metadaten

Die automatische Service-Erkennung erleichtert die Kommunikation zwischen den einzelnen Anwendungskomponenten. Metadaten helfen dabei, diese Interaktionen sauber zu strukturieren und komplexe verteilte Systeme einfach zu halten.

Schrittweise Updates und Rollbacks

Kubernetes unterstützt unterbrechungsfreie Updates (Rolling Updates), damit Ihre Anwendung auch während einer Aktualisierung durchgehend erreichbar bleibt. Sollte ein Update einmal Probleme verursachen, kehren Sie schnell und mühelos zu einer vorherigen stabilen Version zurück.

Ressourcenmanagement

Mit Kubernetes behalten Sie die volle Kontrolle über Ihre Systemressourcen: Sie können genau festlegen, wie viel CPU-Leistung und Arbeitsspeicher einzelne Pods anfordern und maximal nutzen dürfen.

ConfigMaps, Secrets und Umgebungsvariablen

Kubernetes nutzt ConfigMaps und Secrets für eine sichere Konfigurationsverwaltung. Sensible Informationen wie API-Schlüssel oder Passwörter werden getrennt vom Anwendungscode gespeichert und zuverlässig vor unbefugtem Zugriff geschützt.

Vor- und Nachteile von Kubernetes

Wenn Sie die Stärken und Schwächen gegeneinander abwägen, lässt sich leicht entscheiden, ob Kubernetes die passende Lösung für Ihr Container-Management ist.

Vorteile von Kubernetes

Kubernetes punktet mit vielen Stärken und ist deshalb für viele die erste Wahl beim Verwalten containerbasierter Anwendungen.

Skalierbarkeit

• Mühelose Skalierung. Wenn die Nachfrage steigt, skaliert Kubernetes ganz automatisch durch das Hinzufügen weiterer Container – völlig ohne manuelles Eingreifen.
• Keine Ausfallzeiten. Kubernetes nutzt bei der Bereitstellung einen Lastausgleicher (Load Balancer), der den Datenverkehr clever zwischen bestehenden und neuen Containern verteilt. So bleibt Ihre Anwendung durchgehend erreichbar.

Hohe Verfügbarkeit

• Automatisches Ausfallmanagement (Failover). Fällt ein Container oder Knoten aus, leitet Kubernetes den Datenverkehr automatisch auf funktionierende Einheiten um. Das minimiert Ausfallzeiten auf ein Minimum.
• Lastausgleich. Der integrierte Lastausgleicher verteilt eingehende Anfragen gleichmäßig auf mehrere Pods. Das sorgt für eine bessere Leistung und stellt sicher, dass Ihre Anwendung zuverlässig erreichbar bleibt.

Flexibilität und Erweiterbarkeit

• Benutzerdefinierte Ressourcen und Operatoren. Mit individuellen Ressourcen und sogenannten Operatoren können Sie den Funktionsumfang von Kubernetes ganz einfach erweitern und exakt an Ihre geschäftlichen Anforderungen anpassen.
• Erweiterungen und Tools. Die Open-Source-Natur und der starke Community-Support fördern ein reichhaltiges Ökosystem an Erweiterungen und Tools, das eine kontinuierliche Verbesserung Ihrer Kubernetes-Umgebung mit verschiedenen Add-ons ermöglicht, von Monitoring-Lösungen bis hin zu externen Zugriffstools.

Nachteile von Kubernetes

So leistungsstark Kubernetes auch ist – es gibt einige Punkte, die Sie bei Ihrer Entscheidung berücksichtigen sollten:

Hohe Komplexität

Die Einarbeitung kann anspruchsvoll sein. Um das volle Potenzial von Kubernetes-Clustern auszuschöpfen, ist ein gewisses Fachwissen erforderlich, was Einsteiger vor Herausforderungen stellen kann.

Hoher Ressourcenbedarf

Kubernetes benötigt spürbar viel Rechenleistung und Speicher. Für sehr kleine Anwendungen oder Teams mit begrenztem Budget kann der Verwaltungsaufwand daher manchmal größer sein als der tatsächliche Nutzen.

Keine integrierten Speicherlösungen

Kubernetes bringt von Haus aus keinen dauerhaften Datenspeicher mit. Benötigen Ihre Anwendungen eine dauerhafte oder besonders geschützte Speicherung, binden Sie externe Lösungen wie Network Attached Storage (NAS), Storage Area Networks (SAN) oder Cloud-Speicher ein.

So richten Sie Kubernetes ein

Die Einrichtung von Kubernetes ist entscheidend für eine effektive Verwaltung von Containern, wobei Ihre Hosting-Umgebung eine zentrale Rolle spielt. Hostingers VPS-Pläne bieten die Ressourcen und Stabilität, die für einen Kubernetes-Cluster erforderlich sind.

Bitte beachten Sie, dass die folgenden Schritte für alle Knoten gelten, die Sie für die Bereitstellung Ihrer Anwendungen verwenden werden.

1. Bereitstellungsmethode wählen

• Lokales Umfeld. Ideal zum Lernen, Testen und Entwickeln, kann die Bereitstellung von Kubernetes auf einem lokalen Computer mit Tools wie Minikube und Kind (Kubernetes in Docker) erfolgen.Diese Methode ist schnell und bequem für Einzelpersonen und kleine Teams, obwohl sie möglicherweise mehr Ressourcen als andere Methoden benötigt.
• Selbstgehostetes Kubernetes. Diese Methode beinhaltet die Einrichtung und Verwaltung Ihres eigenen Kubernetes-Clusters von Grund auf. Sie bietet mehr Kontrolle und Flexibilität, erfordert jedoch erhebliche Zeit und Expertise und eignet sich somit für größere Organisationen mit komplexen Infrastrukturanforderungen oder spezifischen Compliance-Anforderungen.
• Verwaltete Kubernetes-Dienste. Bei den meisten Produktions-Workloads und größeren Projekten sollten Sie sich für einen Managed Service wie Amazon EKS, Google Kubernetes Engine (GKE) oder Azure Kubernetes Service (AKS) entscheiden. Diese Services sind für ihre Benutzerfreundlichkeit und Robustheit bekannt, da sie Skalierbarkeit und Zuverlässigkeit ohne administrativen Aufwand bieten.

Die richtige Umgebung wählen

• Wenn Sie anfangen und eine stressfreie Erfahrung für Lernen und Entwicklung suchen, ist eine lokale Umgebung ratsam.
• Wenn Sie die nötige Zeit und Kompetenz aufbringen können, ist selbst gehostete Kubernetes für eine vollständige Kontrolle und ein maßgeschneidertes Setup geeignet.
• Managed Services eignen sich am besten für die meisten Produktionsszenarien und bieten Skalierbarkeit und Zuverlässigkeit bei minimalem Verwaltungsaufwand.

2. Umgebung konfigurieren

Wir führen Sie durch die Einrichtung einer Kubernetes-Umgebung auf Hostinger mit einem Ubuntu 24.04 64-Bit Gehen Sie folgendermaßen vor:

1. Melden Sie sich über eine SSH-Client wie PuTTY. Stellen Sie nach dem Einloggen sicher, dass Ihr VPS auf dem neuesten Stand ist:

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

2. Kubernetes setzt auf eine Container-Laufzeit wie Docker. Docker installieren auf Ihrem VPS, indem Sie Folgendes ausführen:

sudo apt install docker.io

3. Docker als Systemdienst mit diesen aktivieren und starten Linux-Befehle:

sudo systemctl enable docker
sudo systemctl start docker

4. Deaktivieren Sie Swaps auf allen Knoten, um die Kubernetes-Leistung zu verbessern:

sudo swapoff -a
sudo sed -i '/ swap / s/^\(.*\)$/#\1/g' /etc/fstab

5. Nutzung Tee um die benötigten Kernelmodule für Kubernetes zu laden:

sudo tee /etc/modules-load.d/containerd.conf <<eof overlay="" br_netfilter="" eof="" sudo-modsondenüberlagerung="" sudo="" modprobe="" br_netfilter

6. Fügen Sie die notwendigen Kernelparameter für Kubernetes-Netzwerke hinzu:

sudo tee /etc/sysctl.d/kubernetes.conf <<eof net.bridge.bridge-nf-call-ip6tables="1" net.bridge.bridge-nf-call-iptables="1" net.ipv4.ip_forward="1" eof

7. Wenden Sie alle Änderungen an, indem Sie die Systemeinstellungen neu laden:

sudo sysctl -System

3. containerd-Runtime installieren

Nachdem Sie die Umgebung eingerichtet haben, fahren Sie mit der Installation von containerd fort, einer Container-Laufzeitumgebung, die den Lebenszyklus von Containern und deren Abhängigkeiten auf Ihren Knoten verwaltet. So gehen Sie dabei vor:

1. Führen Sie den folgenden Befehl aus, um die erforderlichen Pakete für containerd zu installieren:

sudo apt-get install apt-transport-https ca-certificates curl software-properties-common

2. Verwenden Sie curl, um das Docker-Repository zu Ihrem System hinzuzufügen:

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmour -o /etc/apt/trusted.gpg.d/docker.gpg
sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"

3. Aktualisieren Sie die Paketliste Ihres Systems und installieren Sie containerd:

sudo apt update
sudo apt install containerd.io

4. Stellen Sie containerd mit den folgenden Befehlen so ein, dass systemd als cgroup-Manager verwendet wird:

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

5. Übernehmen Sie die Änderungen, indem Sie den containerd-Dienst neu starten und aktivieren:

sudo systemctl restart containerd
sudo systemctl ermöglichen containered

4. Kubernetes installieren

Nachdem Sie die Umgebung vorbereitet haben, können Sie mit der Installation der wesentlichen Kubernetes-Komponenten auf Ihrem Host beginnen.

1. Rufen Sie den öffentlichen Signaturschlüssel für die Kubernetes-Paket-Repositorys ab:

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

2. Führen Sie den folgenden Befehl aus, um das entsprechende Kubernetes-apt-Repository hinzuzufügen:

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

3. Aktualisieren Sie Ihre Paketlisten und installieren Sie die Kubernetes-Komponenten:

sudo apt-get update
sudo apt-get install kubelet kubeadm kubectl

4. Verhindern Sie automatische Updates dieser Komponenten, indem Sie deren Versionen anheften:

sudo apt-mark hold kubelet kubeadm kubectl

5. Optional können Sie den kubelet-Dienst mit dem folgenden Befehl so konfigurieren, dass er sofort gestartet wird:

sudo systemctl enable --now kubelet

Nachdem Sie Kubernetes erfolgreich auf allen Ihren Knoten installiert haben, führt Sie der folgende Abschnitt durch die Bereitstellung von Anwendungen mit diesem leistungsstarken Orchestrierungstool.

So stellen Sie Anwendungen auf Kubernetes bereit

Nachdem nun alle notwendigen Komponenten installiert und konfiguriert sind, können wir Ihre erste Anwendung auf Ihren Knoten bereitstellen.

1. Einen Kubernetes-Cluster starten (Masterknoten)

Beginnen Sie mit der Erstellung eines Kubernetes-Clusters, bei dem Sie Ihren Master-Knoten als Steuerungsebene einrichten, um Worker-Knoten zu verwalten und Containerbereitstellungen im gesamten System zu orchestrieren.

1. Starten Sie Ihren Cluster mit dem folgenden kubeadm-Befehl:

sudo kubeadm init

2. Im Erfolgsfall sollten Sie diese Ausgabe sehen:

[init] Using Kubernetes version: v1.30.0
[preflight] Running pre-flight checks
[preflight] Pulling images required for setting up a Kubernetes cluster
...
Your Kubernetes control-plane has initialized successfully!

3. Notieren Sie sich die IP-Adresse und das Token aus der Zeile kubeadm join, da Sie diese benötigen, wenn Sie Ihre Worker-Knoten zu diesem Cluster hinzufügen:

kubeadm join 22.222.222.84:6443 --token i6krb8.8rfdmq9haf6yrxwg \
 --discovery-token-ca-cert-hash sha256:bb9160d7d05a51b82338fd3ff788fea86440c4f5f04da6c9571f1e5a7c1848e3

4. Wenn beim Start Probleme auftreten, können Sie Pre-Flight-Fehler mit diesem Befehl umgehen:

sudo kubeadm init --ignore-preflight-errors=all

5. Nachdem der Cluster erfolgreich gestartet wurde, erstellen Sie ein Verzeichnis für die Clusterkonfiguration und legen Sie die richtigen Berechtigungen fest:

mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config

6. Verwenden Sie den folgenden kubectl-Befehl, um den Status des Clusters und der Knoten zu überprüfen:

kubectl get nodes

7. Hier ist die erwartete Ausgabe:

NAME    STATUS     ROLES          AGE   VERSION
master  NotReady   control-plane  176m  v1.30.0

2. Knoten zum Cluster hinzufügen (Arbeitsknoten)

Wechseln Sie zu dem Server, den Sie als Worker-Knoten hinzufügen möchten. Stellen Sie sicher, dass Sie alle vorbereitenden Schritte vom So richten Sie Kubernetes ein Abschnitt zur Bestätigung, dass der Knoten für die Integration in den Cluster bereit ist.

Befolgen Sie diese Schritte:

1. Verwenden Sie den Befehl kubeadm join mit der zuvor notierten IP-Adresse und dem Token:

kubeadm join 22.222.222.84:6443 --token i6krb8.8rfdmq9haf6yrxwg \
--discovery-token-ca-cert-hash sha256:bb9160d7d05a51b82338fd3ff788fea86440c4f5f04da6c9571f1e5a7c1848e3

2. Wiederholen Sie diesen Vorgang für jeden Server, den Sie als Worker-Knoten zum Cluster hinzufügen möchten.
3. Sobald alle Knoten hinzugefügt wurden, kehren Sie zu Ihrem Master-Knoten zurück, um den Status aller Knoten zu überprüfen. Verwenden Sie dazu den Befehl kubectl:

kubectl get nodes

4. Möglicherweise sehen Sie folgende Ausgabe:

NAME          STATUS   ROLES           AGE     VERSION
master        Ready    control-plane   176m    v1.30.0
worker-node1  Ready    worker          5m      v1.30.0

3. Ein Kubernetes Pod-Netzwerk installieren (Masterknoten)

Ein Pod-Netzwerk ermöglicht es verschiedenen Knoten innerhalb eines Clusters miteinander zu kommunizieren. Es stehen mehrere Pod-Netzwerk-Plugins zur Verfügung, wie z. B. Flannel und Calico.

1. Wenn Sie Flannel als Pod-Netzwerk auswählen, führen Sie den folgenden Befehl aus:

kubectl apply -f https://github.com/flannel-io/flannel/releases/latest/download/kube-flannel.yml

2. Wenn Sie Calico bevorzugen, verwenden Sie stattdessen diesen Befehl:

kubectl apply -f https://raw.githubusercontent.com/projectcalico/calico/v3.25.0/manifests/calico.yaml

3. Stellen Sie nach der Installation des Pod-Netzwerks sicher, dass keine unnötigen Flecken die Planung auf Kontrollebenenknoten verhindern:

kubectl taint nodes --all node-role.kubernetes.io/control-plane-:NoSchedule-

4. Anwendung überprüfen und bereitstellen (Masterknoten)

Jetzt ist es an der Zeit, Ihre Anwendung bereitzustellen, die mit Kubernetes als Docker-Image verpackt ist.

1. Prüfen Sie, ob Ihr Cluster und alle Systempods funktionsfähig sind:

kubectl get pods -n kube-system

2. Sie sollten die Ausgabe ähnlich sehen:

NAME                             READY   STATUS              RESTARTS   AGE
coredns-7db6d8ff4d-4cwxd         0/1     ContainerCreating   0          3h32m
coredns-7db6d8ff4d-77l6f         0/1     ContainerCreating   0          3h32m
etcd-master                      1/1     Running             0          3h32m
kube-apiserver-master            1/1     Running             0          3h32m
kube-controller-manager-maste    1/1     Running             0          3h32m
kube-proxy-lfhsh                 1/1     Running             0          3h32m
kube-scheduler-master            1/1     Running             0          3h32m

3. Stellen Sie Ihre Anwendung bereit, indem Sie Ihr Docker-Image in den Cluster einbinden. Ersetzen Sie your_kubernetes_app durch den Namen Ihrer Bereitstellung und your_docker_image durch das tatsächliche Docker-Image:

kubectl run your_kubernetes_app --image=your_docker_image

4. Führen Sie Folgendes aus, um zu bestätigen, dass Ihre Anwendung erfolgreich bereitgestellt wurde:

kubectl get pods

5. Sie erwarten:

NAME                  READY   STATUS    RESTARTS   AGE
your_kubernetes_app   1/1     Running   0          6m

Herzlichen Glückwunsch zur Bereitstellung Ihrer Anwendung auf dem Cluster mit Kubernetes – Sie sind der Skalierung und Verwaltung Ihres Projekts in mehreren Umgebungen einen Schritt näher.

Kubernetes Best Practices

Die Einhaltung von Best Practices, die innerhalb der Kubernetes-Community entwickelt wurden, ist entscheidend, um ihre Fähigkeiten voll auszuschöpfen.

Ressourcenmanagement optimieren

Effizientes Ressourcenmanagement ist entscheidend für die Verbesserung der Performance und Stabilität Ihrer Anwendungen: Durch die Definition von Ressourcenlimits und Anforderungen für verschiedene Objekte, wie Pods, schaffen Sie eine stabile Umgebung für die effektive Verwaltung containerisierter Anwendungen.

Ressourcenlimits begrenzen die CPU- und Speichernutzung, um zu verhindern, dass eine einzelne Anwendung Ressourcen ausfindig macht, während Ressourcenanforderungen garantieren, dass Ihre Container über die minimal benötigten Ressourcen verfügen.

Die richtige Balance zwischen diesen Limits und Anforderungen ist unerlässlich, um eine optimale Leistung zu erzielen, ohne Ressourcen zu verschwenden.

Zustandsprüfungen und Selbstheilung sicherstellen

Eines der Kernprinzipien von Kubernetes ist die Aufrechterhaltung des gewünschten Zustands von Anwendungen durch automatisierte Zustandsprüfungen und Selbstheilungsmechanismen.

Bereitschaftsprüfungen (Readiness Probes) verwalten den eingehenden Datenverkehr und stellen sicher, dass ein Container vollständig bereit ist, Anfragen zu bearbeiten. Sie verhindern zudem, dass Datenverkehr an Container weitergeleitet wird, die noch nicht bereit sind, und verbessern so die Benutzererfahrung und die Systemeffizienz.

Gleichzeitig überwachen Aktivitätsprüfungen (Liveness Probes) den aktuellen Zustand eines Containers. Wenn eine Aktivitätsprüfung fehlschlägt, ersetzt Kubernetes den problematischen Container automatisch und sorgt so dafür, dass der gewünschte Zustand der Anwendung ohne manuelles Eingreifen aufrechterhalten wird.

Sichere Konfigurationen und Secrets

ConfigMaps speichern Konfigurationsdaten, während Secrets sensible Informationen wie API-Schlüssel und Passwörter sicher aufbewahren und so gewährleisten, dass diese Daten verschlüsselt sind und nur autorisierten Benutzern zugänglich sind.

Wir empfehlen Ihnen außerdem, die folgenden bewährten Sicherheitsverfahren anzuwenden:

• API-Zugriff einschränken. Beschränken Sie den API-Zugriff auf vertrauenswürdige IP-Adressen, um die Sicherheit zu erhöhen.
• RBAC aktivieren. Nutzen Sie die rollenbasierte Zugriffskontrolle (RBAC), um Berechtigungen innerhalb Ihres Clusters anhand von Benutzerrollen einzuschränken und sicherzustellen, dass Benutzer nur Zugriff auf die für ihre Rollen erforderlichen Ressourcen haben.
• Regelmäßige Updates. Halten Sie alle Komponenten Ihres Kubernetes-Clusters auf dem neuesten Stand, um sich vor potenziellen Sicherheitslücken zu schützen.

Darüber hinaus bietet Hostinger erweiterte Sicherheitsfunktionen zum Schutz Ihres VPS an. Dazu gehört eine cloudbasierte Firewall-Lösung, die Ihren virtuellen Server vor potenziellen Bedrohungen aus dem Internet schützt.

Darüber hinaus sorgt unser leistungsstarker Malware-Scanner für eine proaktive Überwachung und Sicherheit Ihres VPS, indem er kompromittierte und schädliche Dateien erkennt, verwaltet und bereinigt.

Sie können beide Funktionen über das Menü Sicherheit im VPS-Dashboard von hPanel aktivieren.

Rolling Updates und Rollbacks durchführen

Kubernetes zeichnet sich durch seine Strategie der schrittweisen Updates aus, die es ermöglicht, alte Container nach und nach aus dem Betrieb zu nehmen und durch neue Versionen zu ersetzen.

Dieser Ansatz gewährleistet nahtlose Übergänge und Bereitstellungen ohne Ausfallzeiten, wodurch ein unterbrechungsfreier Betrieb gewährleistet wird und selbst bei umfangreichen Anwendungsupdates ein erstklassiges Benutzererlebnis geboten wird.

Minikube für die lokale Entwicklung und das Testen nutzen

Wenn Sie Ihre Anwendungen lieber lokal entwickeln möchten, bevor Sie sie auf dem Server bereitstellen, sollten Sie den Einsatz von Minikube in Betracht ziehen. Es handelt sich um ein Tool zum Einrichten von Kubernetes-Clustern mit einem einzigen Knoten auf lokalen Rechnern und eignet sich perfekt zum Erstellen, Testen und Lernen.

Befolgen Sie diese Schritte, um Minikube auf einem Debian-basierten Rechner in Betrieb zu nehmen:

1. Laden Sie die neueste Minikube-Binärdatei herunter:

curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube_latest_amd64.deb

2. Installieren Sie Minikube mit dem Debian-Paket:

sudo dpkg -i minikube_latest_amd64.deb

3. Starten Sie Minikube auf Ihrer Maschine:

minikube start

4. Erstellen einer Beispielbereitstellung mit kubectl:

kubectl create deployment hello-minikube --image=kicbase/echo-server:1.0

5. Stellen Sie die Bereitstellung auf Port 8080 bereit, wodurch effektiv ein Dienst erstellt wird:

kubectl expose deployment hello-minikube --type=NodePort --port=8080

6. Starten Sie Ihren Service:

kubectl get services hello-minikube
minikube service hello-minikube

Nun können Sie auf Ihre Anwendung zugreifen, indem Sie http://localhost:8080/ in den Browser eingeben.

Fehlerbehebung bei häufigen Kubernetes-Problemen

Hier werden wir einige häufige Kubernetes-Probleme behandeln und wie man sie effektiv angehen kann:

Pod-Ausfälle

Pod-Ausfälle treten auf, wenn diese Komponenten nicht wie erwartet funktionieren und die Verfügbarkeit und Leistung Ihrer Anwendungen beeinträchtigen.

• Ressourcenknappheit. Pods können aufgrund unzureichender CPU, Speicher oder anderer Ressourcen auf dem Knoten ausfallen, was zu Ressourcenerschöpfung führt.
• Fehlkonfigurationen. Fehler wie die Angabe eines falschen Bildnamens oder das Einhängen der falschen Volumes können zu Fehlern führen.
• Imageprobleme. Probleme wie fehlende Abhängigkeiten oder Image-Pull-Fehler können Pods daran hindern, korrekt zu laufen.

Hier sind Schritte, um Pod-Fehler zu beheben:

1. Verwenden Sie den Befehl kubectl describe pod [pod_name], um detaillierte Informationen zum Status des Pods abzurufen, darunter Ereignisse, Protokolle und Konfigurationsdetails. Achten Sie auf Fehlermeldungen, die möglicherweise auf die Ursache des Fehlers hinweisen.
2. Überprüfen Sie die Ressourcenanforderungen und -beschränkungen des Pods in seiner Konfiguration, um sicherzustellen, dass sie mit dem übereinstimmen, was auf dem Knoten verfügbar ist.
3. Führen Sie den Befehl kubectl logs [pod_name] aus, um die Protokolle der Container des Pods einzusehen, die häufig Hinweise auf Fehler oder Betriebsprobleme enthalten.
4. Stellen Sie sicher, dass die Bildreferenzen, Umgebungsvariablen, Volume Mounts und andere Einstellungen des Pods korrekt sind.
5. Beheben Sie alle netzwerkbezogenen Probleme, wie DNS-Konfiguration oder Verbindungsprobleme, die den Pod beeinträchtigen könnten.
6. Sollten am Knoten selbst Probleme auftreten, beheben Sie diese oder lassen Sie Kubernetes den Pod auf einen fehlerfreien Knoten umplanen.

Netzwerkprobleme

Netzwerkprobleme in einem Kubernetes-Cluster können die Kommunikation zwischen Pods und Diensten unterbrechen und die Funktionalität Ihrer Anwendungen beeinträchtigen.

• Serviceanbindung. Fehler in der Dienstkommunikation können auf falsch konfigurierte Dienstdefinitionen, unangemessene Netzwerkrichtlinien oder zugrunde liegende Netzwerkprobleme zurückzuführen sein.
• DNS-Auflösung. Probleme mit DNS können die Erkennung von Diensten und die Kommunikation zwischen Pods stören, da diese häufig auf DNS angewiesen sind, um sich gegenseitig zu identifizieren.
• Netzwerkpartitionierung. In verteilten Systemen können solche Störungen Knoten isolieren, was zu Dateninkonsistenz und Servicestörungen führt.

So lösen Sie Netzwerkprobleme:

1. Stellen Sie sicher, dass die Namen der Dienste und die Ports korrekt konfiguriert sind. Verwenden Sie kubectl get services, um die Details der Dienste zu überprüfen.
2. Überprüfen Sie, ob Ihre Netzwerkrichtlinien korrekt eingerichtet sind, um den Datenverkehr zwischen den Pods zu steuern. Die Richtlinien sollten je nach Bedarf so konfiguriert sein, dass der Datenverkehr entweder zugelassen oder unterbunden wird.
3. Stellen Sie sicher, dass die DNS-Einstellungen innerhalb von Kubernetes und auf Cluster-Ebene korrekt sind. Verwenden Sie Tools wie nslookup oder dig, um die DNS-Auflösung innerhalb Ihres Clusters zu testen.
4. Wenn Sie Netzwerk-Plugins wie Calico oder Flannel verwenden, überprüfen Sie deren Konfigurationen und Protokolle auf mögliche Probleme.
5. Nutzen Sie kube-proxy, um die Netzwerkkommunikation zwischen Diensten und Pods effizient zu verwalten.
6. Erhöhen Sie die Sicherheit, indem Sie Netzwerkrichtlinien implementieren, die den Datenverkehr einschränken und Ihren Cluster vor unbefugtem Zugriff und unerwünschten Netzwerkverbindungen schützen.

Herausforderungen beim persistenten Speicher

In Kubernetes ist die Verwaltung des persistenten Speichers für den Betrieb zustandsbehafteter Anwendungen von entscheidender Bedeutung. Eine unsachgemäße Verwaltung kann jedoch zu Datenverlusten, Anwendungsausfällen und Leistungseinbußen führen. Hier sind einige häufige Probleme in diesem Bereich:

• Ressourcenzuweisung. Eine Unterschätzung des Speicherbedarfs kann zu Datenverlust führen, während eine Überbereitstellung unnötige Ausgaben verursachen kann.
• Inkompatibilitäten zwischen persistenten Volumes (PV) und Speicherklassen. Fehlkonfigurationen zwischen PVs und Speicherklassen können Kompatibilitätsprobleme verursachen und die Zuordnung des richtigen Speichers zu Ihren Pods erschweren.
• Datenverlust. Dieser kann aus verschiedenen Gründen auftreten, darunter Pod-Abstürze, Löschvorgänge oder Hardwareausfälle.

Hier finden Sie einen Leitfaden zur Bewältigung der Herausforderungen im Bereich des persistenten Speichers:

1. Überprüfen Sie regelmäßig den Speicherbedarf Ihrer Anwendung und passen Sie Ressourcenanforderungen und -limits entsprechend an. Verwenden Sie Metriken und Überwachungstools, um unter- oder überbereitete Ressourcen zu identifizieren.
2. Vergewissern Sie sich, dass Ihre PVs und Speicherklassen korrekt aufeinander abgestimmt sind. Überprüfen Sie die Konfiguration Ihrer Speicherklassen, um sicherzustellen, dass diese den gewünschten Eigenschaften wie Leistung und Zugriffsmodi entsprechen.
3. Informieren Sie sich über Datenwiederherstellungsoptionen wie Snapshots, um verlorene oder beschädigte Daten wiederherzustellen.Erwägen Sie Sicherungslösungen, die sich gut in Ihren Speicheranbieter integrieren lassen, um die Datenwiederherstellung zu erleichtern.
4. Automatisieren Sie den Backup-Prozess, um einen konsistenten und regelmäßigen Datenschutz zu gewährleisten, und implementieren Sie automatisierte Backup-Lösungen oder Skripte, die in geplanten Intervallen ausgeführt werden.
5. Entscheiden Sie sich für Speicherlösungen, die sich schnell skalieren lassen, um steigenden Anforderungen gerecht zu werden, und implementieren Sie Speichersysteme, die sich dynamisch erweitern können, da Ihre containerisierten Anwendungen mehr Speicher benötigen.

Clusterskalierung und Performance

Skalierbarkeit ist ein entscheidendes Merkmal von Kubernetes, das es Anwendungen ermöglicht, sich an unterschiedliche Workloads anzupassen. Mit zunehmendem Wachstum Ihrer Anwendungen können jedoch Skalierungsherausforderungen und Leistungsengpässe auftreten, wie:

• Ressourcenkonflikte. Der Wettbewerb zwischen Pods um Ressourcen wie CPU und Speicher kann zu Leistungsproblemen führen, da eingeschränkte Pods nicht optimal funktionieren.
• Netzüberlastung. Erhöhter Datenverkehr kann die Netzwerkbandbreite sättigen, was zu Kommunikationsverzögerungen und Leistungsverschlechterungen führt.
• Ineffizientes Ressourcenmanagement. Unsachgemäße Einstellung von Ressourcenanforderungen und Limits kann zu Verschwendung führen.

Hier sind die wichtigsten Strategien zur Optimierung von Leistung und Skalierung:

Hier finden Sie wichtige Strategien zur Optimierung von Leistung und Skalierung:

1. Überprüfen Sie regelmäßig die Ressourcenanforderungen und -grenzen Ihrer Pods und passen Sie diese Werte entsprechend den Anforderungen Ihrer Anwendungen und der Ressourcenverfügbarkeit an.
2. Verwenden Sie HorizontalPodAutoscaler (HPA), um Pods dynamisch auf der Grundlage der Ressourcenauslastung oder benutzerdefinierter Metriken zu skalieren. Auf diese Weise können Ihre Anwendungen Traffic-Spitzen automatisch bewältigen, ohne dass ein manueller Eingriff erforderlich ist.
3. Überwachen Sie den Netzwerkverkehr und wenden Sie Netzwerkrichtlinien an, um den Datenfluss effektiv zu steuern. Ziehen Sie den Einsatz von Advanced Container Network Interfaces (CNI) und Plugins in Betracht, um die Netzwerkleistung zu verbessern.
4. Setzen Sie den kube-controller-manager für die automatisierte Skalierung von Knoten auf Basis des Ressourcenbedarfs ein, um die Reaktionsfähigkeit auf Änderungen der Arbeitslast zu verbessern.
5. Überprüfen und optimieren Sie den Code Ihrer containerisierten Anwendungen, um eine effiziente Ressourcennutzung sicherzustellen. Befolgen Sie bewährte Verfahren zur Container-Orchestrierung, um die Leistung zu steigern.
6. Entfernen Sie regelmäßig nicht mehr verwendete Docker-Images, Container, Dienste und Volumes, um Ressourcen freizugeben. Verwenden Sie Befehle wie docker system prune für Docker und kubectl delete für Kubernetes-Ressourcen, um eine aufgeräumte Umgebung zu gewährleisten.

Fazit

Kubernetes ist ein leistungsstarkes Tool, das die Verwaltung und Bereitstellung von Anwendungen vereinfacht und sicherstellt, dass sie reibungslos auf Servern in lokalen und Cloud-Umgebungen ausgeführt werden.

In diesem Kubernetes-Tutorial für Anfänger haben Sie die Kernkomponenten und Schlüsselfunktionen kennen gelernt, eine Clusterumgebung eingerichtet und Ihre erste Anwendung mithilfe dieser Plattform bereitgestellt.

Durch die Einhaltung bewährter Verfahren und die proaktive Bewältigung von Herausforderungen können Sie die Möglichkeiten dieses Open-Source-Systems voll ausschöpfen, um Ihre Containermanagement-Anforderungen zu erfüllen.

Kubernetes Tutorial FAQ

Dieser Abschnitt beantwortet einige der häufigsten Fragen über Kubernetes.

Alle Tutorial-Inhalte auf dieser Website unterliegen Hostingers strengen redaktionellen Standards und Normen.

Erstellt von

Vera P.

Vera ist eine erfahrene Lokalisierungs-Spezialistin bei Hostinger und optimiert erfolgreich Inhalte für globale Zielgruppen. Dank ihres umfassenden SEO-Wissens sorgt sie dafür, dass Hostingers Webhosting-Dienste für ein breites Publikum sichtbar, zugänglich und attraktiv sind. Mit Kreativität mit Präzision überwindet sie Sprachbarrieren in ihren Projekten und trägt so dazu bei, Hostingers Reichweite zu vergrößern und Kunden weltweit ein nahtloses Erlebnis zu bieten.

Mehr von Vera P.