Linux-Befehle<\/a>:<\/li>\n<\/ol>sudo systemctl enable docker\nsudo systemctl start docker<\/pre>\nDeaktivieren Sie Swaps auf allen Knoten, um die Kubernetes-Leistung zu verbessern:<\/li>\n<\/ol>sudo swapoff -a\nsudo sed -i '\/ swap \/ s\/^\\(.*\\)$\/#\\1\/g' \/etc\/fstab<\/pre>\nNutzung Tee um die benötigten Kernelmodule für Kubernetes zu laden:<\/li>\n<\/ol>sudo tee \/etc\/modules-load.d\/containerd.conf <<eof overlay=\"\" br_netfilter=\"\" eof=\"\" sudo-modsondenüberlagerung=\"\" sudo=\"\" modprobe=\"\" br_netfilter<\/pre>\nFügen Sie die notwendigen Kernelparameter für Kubernetes-Netzwerke hinzu:<\/li>\n<\/ol>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<\/pre>\nWenden Sie alle Änderungen an, indem Sie die Systemeinstellungen neu laden:<\/li>\n<\/ol>sudo sysctl -System<\/pre>3. containerd<\/strong>-Runtime installieren<\/h3>Nachdem Sie die Umgebung eingerichtet haben, fahren Sie mit der Installation von containerd<\/strong> fort, einer Container-Laufzeitumgebung, die den Lebenszyklus von Containern und deren Abhängigkeiten auf Ihren Knoten verwaltet. So gehen Sie dabei vor:<\/p>\nFühren Sie den folgenden Befehl aus, um die erforderlichen Pakete für containerd<\/strong> zu installieren:<\/li>\n<\/ol>sudo apt-get install apt-transport-https ca-certificates curl software-properties-common<\/pre>\nVerwenden Sie curl, um das Docker-Repository zu Ihrem System hinzuzufügen:<\/li>\n<\/ol>curl -fsSL https:\/\/download.docker.com\/linux\/ubuntu\/gpg | sudo gpg --dearmour -o \/etc\/apt\/trusted.gpg.d\/docker.gpg\nsudo add-apt-repository \"deb [arch=amd64] https:\/\/download.docker.com\/linux\/ubuntu $(lsb_release -cs) stable\"<\/pre>\nAktualisieren Sie die Paketliste Ihres Systems und installieren Sie containerd<\/strong>:<\/li>\n<\/ol>sudo apt update\nsudo apt install containerd.io<\/pre>\nStellen Sie containerd<\/strong> mit den folgenden Befehlen so ein, dass systemd als cgroup<\/strong>-Manager verwendet wird:<\/li>\n<\/ol>containerd config default | sudo tee \/etc\/containerd\/config.toml >\/dev\/null\nsudo sed -i 's\/SystemdCgroup = false\/SystemdCgroup = true\/'\/etc\/containerd\/config.toml<\/pre>\nÜbernehmen Sie die Änderungen, indem Sie den containerd<\/strong>-Dienst neu starten und aktivieren:<\/li>\n<\/ol>sudo systemctl restart containerd\nsudo systemctl ermöglichen containered<\/pre>4. Kubernetes installieren<\/h3> Nachdem Sie die Umgebung vorbereitet haben, können Sie mit der Installation der wesentlichen Kubernetes-Komponenten auf Ihrem Host beginnen.<\/p>
\nRufen Sie den öffentlichen Signaturschlüssel für die Kubernetes-Paket-Repositorys ab:<\/li>\n<\/ol>curl -fsSL https:\/\/pkgs.k8s.io\/core:\/stable:\/v1.30\/deb\/Release.key | sudo gpg --dearmor -o \/etc\/apt\/keyrings\/kubernetes-apt-keyring.gpg<\/pre>\nFühren Sie den folgenden Befehl aus, um das entsprechende Kubernetes-apt<\/strong>-Repository hinzuzufügen:<\/li>\n<\/ol>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<\/pre>\nAktualisieren Sie Ihre Paketlisten und installieren Sie die Kubernetes-Komponenten:<\/li>\n<\/ol>sudo apt-get update\nsudo apt-get install kubelet kubeadm kubectl<\/pre>\nVerhindern Sie automatische Updates dieser Komponenten, indem Sie deren Versionen anheften:<\/li>\n<\/ol>sudo apt-mark hold kubelet kubeadm kubectl<\/pre>\nOptional können Sie den kubelet<\/strong>-Dienst mit dem folgenden Befehl so konfigurieren, dass er sofort gestartet wird:<\/li>\n<\/ol>sudo systemctl enable --now kubelet<\/pre>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.<\/p>
So stellen Sie Anwendungen auf Kubernetes bereit<\/h2> Nachdem nun alle notwendigen Komponenten installiert und konfiguriert sind, können wir Ihre erste Anwendung auf Ihren Knoten bereitstellen.<\/p>
1. Einen Kubernetes-Cluster starten (Masterknoten)<\/h3> 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.<\/p>
\nStarten Sie Ihren Cluster mit dem folgenden kubeadm<\/strong>-Befehl:<\/li>\n<\/ol>sudo kubeadm init<\/pre>\nIm Erfolgsfall sollten Sie diese Ausgabe sehen:<\/li>\n<\/ol>[init] Using Kubernetes version: v1.30.0\nNotieren Sie sich die IP-Adresse und das Token aus der Zeile kubeadm join<\/strong>, da Sie diese benötigen, wenn Sie Ihre Worker-Knoten zu diesem Cluster hinzufügen:<\/li>\n<\/ol>kubeadm join 22.222.222.84:6443 --token i6krb8.8rfdmq9haf6yrxwg \\\n --discovery-token-ca-cert-hash sha256:bb9160d7d05a51b82338fd3ff788fea86440c4f5f04da6c9571f1e5a7c1848e3<\/pre>\nWenn beim Start Probleme auftreten, können Sie Pre-Flight-Fehler mit diesem Befehl umgehen:<\/li>\n<\/ol>sudo kubeadm init --ignore-preflight-errors=all<\/pre>\nNachdem der Cluster erfolgreich gestartet wurde, erstellen Sie ein Verzeichnis für die Clusterkonfiguration und legen Sie die richtigen Berechtigungen fest:<\/li>\n<\/ol>mkdir -p $HOME\/.kube\nsudo cp -i \/etc\/kubernetes\/admin.conf $HOME\/.kube\/config\nsudo chown $(id -u):$(id -g) $HOME\/.kube\/config<\/pre>\nVerwenden Sie den folgenden kubectl<\/strong>-Befehl, um den Status des Clusters und der Knoten zu überprüfen:<\/li>\n<\/ol>kubectl get nodes<\/pre>\nHier ist die erwartete Ausgabe:<\/li>\n<\/ol>NAME STATUS ROLES AGE VERSION2. Knoten zum Cluster hinzufügen (Arbeitsknoten)<\/h3> 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<\/strong> Abschnitt zur Bestätigung, dass der Knoten für die Integration in den Cluster bereit ist.<\/p>Befolgen Sie diese Schritte:<\/p>
\nVerwenden Sie den Befehl kubeadm join<\/strong> mit der zuvor notierten IP-Adresse und dem Token:<\/li>\n<\/ol>kubeadm join 22.222.222.84:6443 --token i6krb8.8rfdmq9haf6yrxwg \\\n--discovery-token-ca-cert-hash sha256:bb9160d7d05a51b82338fd3ff788fea86440c4f5f04da6c9571f1e5a7c1848e3<\/pre>\nWiederholen Sie diesen Vorgang für jeden Server, den Sie als Worker-Knoten zum Cluster hinzufügen möchten.<\/li>\n\n\n\n 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<\/strong>:<\/li>\n<\/ol>kubectl get nodes<\/pre>\nMöglicherweise sehen Sie folgende Ausgabe:<\/li>\n<\/ol>NAME STATUS ROLES AGE VERSION3. Ein Kubernetes Pod-Netzwerk installieren (Masterknoten)<\/h3> 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.<\/p>
\nWenn Sie Flannel als Pod-Netzwerk auswählen, führen Sie den folgenden Befehl aus:<\/li>\n<\/ol>kubectl apply -f https:\/\/github.com\/flannel-io\/flannel\/releases\/latest\/download\/kube-flannel.yml<\/pre>\nWenn Sie Calico bevorzugen, verwenden Sie stattdessen diesen Befehl:<\/li>\n<\/ol>kubectl apply -f https:\/\/raw.githubusercontent.com\/projectcalico\/calico\/v3.25.0\/manifests\/calico.yaml<\/pre>\nStellen Sie nach der Installation des Pod-Netzwerks sicher, dass keine unnötigen Flecken die Planung auf Kontrollebenenknoten verhindern:<\/li>\n<\/ol>kubectl taint nodes --all node-role.kubernetes.io\/control-plane-:NoSchedule-<\/pre>4. Anwendung überprüfen und bereitstellen (Masterknoten)<\/h3> Jetzt ist es an der Zeit, Ihre Anwendung bereitzustellen, die mit Kubernetes als Docker-Image verpackt ist.<\/p>
\nPrüfen Sie, ob Ihr Cluster und alle Systempods funktionsfähig sind:<\/li>\n<\/ol>kubectl get pods -n kube-system<\/pre>\nSie sollten die Ausgabe ähnlich sehen:<\/li>\n<\/ol>NAME READY STATUS RESTARTS AGE\nStellen Sie Ihre Anwendung bereit, indem Sie Ihr Docker-Image in den Cluster einbinden. Ersetzen Sie your_kubernetes_app<\/strong> durch den Namen Ihrer Bereitstellung und your_docker_image<\/strong> durch das tatsächliche Docker-Image:<\/li>\n<\/ol>kubectl run your_kubernetes_app --image=your_docker_image<\/pre>\nFühren Sie Folgendes aus, um zu bestätigen, dass Ihre Anwendung erfolgreich bereitgestellt wurde:<\/li>\n<\/ol>kubectl get pods<\/pre>\nSie erwarten:<\/li>\n<\/ol>NAME READY STATUS RESTARTS AGEHerzlichen 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.<\/p>
Kubernetes Best Practices<\/h2> Die Einhaltung von Best Practices, die innerhalb der Kubernetes-Community entwickelt wurden, ist entscheidend, um ihre Fähigkeiten voll auszuschöpfen.<\/p>
Ressourcenmanagement optimieren<\/strong><\/p>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.<\/p>
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.<\/p>
Die richtige Balance zwischen diesen Limits und Anforderungen ist unerlässlich, um eine optimale Leistung zu erzielen, ohne Ressourcen zu verschwenden.<\/p>Zustandsprüfungen und Selbstheilung sicherstellen<\/strong><\/strong><\/p>Eines der Kernprinzipien von Kubernetes ist die Aufrechterhaltung des gewünschten Zustands von Anwendungen durch automatisierte Zustandsprüfungen und Selbstheilungsmechanismen.<\/p>
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.<\/p>
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.<\/p>
Sichere Konfigurationen und Secrets<\/strong><\/p>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.<\/p>
Wir empfehlen Ihnen außerdem, die folgenden bewährten Sicherheitsverfahren anzuwenden:<\/p>
\nAPI-Zugriff einschränken<\/strong>. Beschränken Sie den API-Zugriff auf vertrauenswürdige IP-Adressen, um die Sicherheit zu erhöhen.<\/li>\n\n\n\nRBAC aktivieren<\/strong>. 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.<\/li>\n\n\n\nRegelmäßige Updates<\/strong>. Halten Sie alle Komponenten Ihres Kubernetes-Clusters auf dem neuesten Stand, um sich vor potenziellen Sicherheitslücken zu schützen.<\/li>\n<\/ul>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.<\/p>
\n
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.<\/p>
\n
Sie können beide Funktionen über das Menü Sicherheit<\/strong> im VPS<\/strong>-Dashboard von hPanel aktivieren.<\/p>Rolling Updates und Rollbacks durchführen<\/strong><\/p>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.<\/p>
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.<\/p>
Minikube für die lokale Entwicklung und das Testen<\/strong> nutzen<\/strong><\/p>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.<\/p>
Befolgen Sie diese Schritte, um Minikube auf einem Debian-basierten Rechner in Betrieb zu nehmen:<\/p>
\nLaden Sie die neueste Minikube-Binärdatei herunter:<\/li>\n<\/ol>curl -LO https:\/\/storage.googleapis.com\/minikube\/releases\/latest\/minikube_latest_amd64.deb<\/pre>\nInstallieren Sie Minikube mit dem Debian-Paket:<\/li>\n<\/ol>sudo dpkg -i minikube_latest_amd64.deb<\/pre>\nStarten Sie Minikube auf Ihrer Maschine:<\/li>\n<\/ol>minikube start<\/pre>\nErstellen einer Beispielbereitstellung mit kubectl<\/strong>:<\/li>\n<\/ol>kubectl create deployment hello-minikube --image=kicbase\/echo-server:1.0<\/pre>\nStellen Sie die Bereitstellung auf Port 8080<\/strong> bereit, wodurch effektiv ein Dienst erstellt wird:<\/li>\n<\/ol>kubectl expose deployment hello-minikube --type=NodePort --port=8080<\/pre>\nStarten Sie Ihren Service:<\/li>\n<\/ol>kubectl get services hello-minikubeNun können Sie auf Ihre Anwendung zugreifen, indem Sie