Was ist ein Kubernetes-Cluster?

Mitarbeiterknoten

Worker-Knoten sind die Arbeitspferde des Clusters. Sie sind die Maschinen, die Container-Anwendungen tatsächlich ausführen. Jeder Worker-Knoten hat mehrere Komponenten, die für das Verwalten und Ausführen von Containern verantwortlich sind:

• Kubelet: Das kubelet ist ein Agent, der auf jedem Worker-Knoten ausgeführt wird. Es fungiert als Vertreter der Steuerungsebene auf dem Knoten und ist für den Lebenszyklus der Pods verantwortlich, die dem Knoten zugewiesen sind. Kubelet stellt sicher, dass Container innerhalb eines Pods gemäß der Pod-Spezifikation heruntergeladen, konfiguriert und ausgeführt werden. Außerdem werden der Zustand von Containern überwacht, ausgefallene Container neu gestartet und die für den sicheren Betrieb der Container erforderlichen Geheimnisse abgerufen.

• Kube-Proxy: Kube-proxy ist ein Netzwerk-Proxy, der auf jedem Worker-Knoten ausgeführt wird. Es implementiert für den Cluster definierte Netzwerkrichtlinien und stellt sicher, dass Pods miteinander und mit externen Services kommunizieren können. Kube-proxy pflegt Netzwerk-Routing-Regeln und übersetzt Servicenamen in Pod-IP-Adressen, sodass Pods Services innerhalb des Clusters erkennen und mit ihnen kommunizieren können.

Durch die Zusammenarbeit ermöglichen diese Komponenten innerhalb der Steuerungsebene und der Worker-Knoten Kubernetes die effektive Verwaltung und Orchestrierung containerisierter Anwendungen in großem Maßstab.

Einrichten eines Kubernetes-Clusters

Sie können einen Kubernetes-Cluster über zwei Hauptmethoden einrichten: über einen verwalteten Kubernetes-Service oder durch manuelle Bereitstellung.

Verwaltete Kubernetes-Services

Cloud-Anbieter wie Google Cloud Platform (GCP) mit Google Kubernetes Engine (GKE), Amazon Web Services (AWS) mit Elastic Kubernetes Service (EKS) und Microsoft Azure mit Azure Kubernetes Service (AKS) bieten verwaltete Kubernetes-Services an. Diese Services kümmern sich um die Komplexität der Bereitstellung, Konfiguration und Verwaltung der Kubernetes-Cluster-Infrastruktur. Sie definieren einfach Ihre gewünschte Cluster-Konfiguration und der Service übernimmt die schwere Arbeit, sodass Sie sich auf die Bereitstellung Ihrer containerisierten Anwendungen konzentrieren können.

Manuelle Bereitstellung

Für mehr Kontrolle und Anpassung können Sie einen Kubernetes-Cluster manuell mit einem Tool wie kubeadm implementieren. Kubeadm ist ein Toolkit zum Boottrappen eines Kubernetes-Clusters. Bei dieser Methode wird Kubeadm auf einem bestimmten Masterknoten und der Kubelet-Agent auf allen Worker-Knoten im Cluster installiert. 

Einrichten eines Kubernetes-Clusters manuell

Voraussetzungen

• Infrastruktur: Stellen Sie sicher, dass Sie über eine ausreichende Infrastruktur verfügen, z. B. virtuelle Maschinen oder Cloud-Instanzen.
• Container-Laufzeit: Installieren Sie eine Container-Laufzeit wie Containerd oder Docker auf allen Knoten.

Schritt 1: Kubeadm, Kubelet und Kubectl installieren

Verwenden Sie auf allen Maschinen (Master- und Worker-Knoten) den Paketmanager Ihrer Verteilung, um die erforderlichen Kubeadm-Tools zu installieren:

# Update package lists (replace 'your_package_manager' with your actual package manager like apt-get or yum)
 $ sudo your_package_manager update
 
 # Install kubeadm, kubelet, and kubectl
 $ sudo your_package_manager install -y kubeadm kubelet kubectl

Hinweis: Bei einigen Systemen kann nach der Installation eine zusätzliche Konfiguration erforderlich sein. Weitere Informationen zu dem von Ihnen gewählten Betriebssystem finden Sie in der offiziellen Kubernetes-Dokumentation.

Schritt 2: Die Steuerungsebene initialisieren (Master-Knoten)

Wählen Sie eine Ihrer Maschinen aus, die als Masterknoten fungieren soll. Führen Sie den folgenden Befehl auf dem Masterknoten aus, um die Steuerungsebene zu initialisieren. Dieser Prozess generiert Konfigurationsdateien und bietet einen Join-Befehl für Worker-Knoten:

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

• Kubeadm-Init: Dieser Befehl initialisiert die Steuerungsebene auf dem Masterknoten.
• --pod-network-cidr=10,244,0,0/16: Diese Option gibt den CIDR-Bereich für das Pod-Netzwerk an. Sie können diesen Wert an Ihre Netzwerkkonfigurationsanforderungen anpassen.

Nach Ausführung des Initialisierungsbefehls stellt kubeadm die Ausgabe mit einem Join-Befehl für Worker-Knoten bereit. Beachten Sie diesen Befehl, da Sie ihn in Schritt 5 benötigen.

Schritt 3: Kubectl konfigurieren

Kopieren Sie auf dem Masterknoten die generierte Admin-Konfigurationsdatei in Ihr lokales kubectl-Konfigurationsverzeichnis. Dadurch können Sie den Cluster mit kubectl-Befehlen verwalten. Der folgende Befehl erreicht dies:

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

Schritt 4: Pod-Netzwerk bereitstellen

Ein Pod-Netzwerk-Plug-in ermöglicht die Kommunikation zwischen Pods innerhalb des Clusters. Flanell ist eine beliebte Pod-Netzwerkoption. Sie können Flannel mit dem folgenden Befehl auf dem Masterknoten bereitstellen:

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

Schritt 5: Schließen Sie Mitarbeiterknoten an den Cluster an

Führen Sie auf jedem Worker-Knoten den Join-Befehl aus, der von kubeadm während des Initialisierungsschritts auf dem Master-Knoten bereitgestellt wird (Schritt 2). Dieser Befehl registriert den Worker-Knoten bei der Steuerebene und bereitet ihn auf die Ausführung containerisierter Workloads vor. Der Join-Befehl sieht in der Regel wie folgt aus:

$ sudo kubeadm join :6443 --token --discovery-token-ca-cert-hash sha256:

• <master_ip_address>: Ersetzen Sie dies durch die IP-Adresse Ihres Masterknotens.
• <token>: Ersetzen Sie dies durch das Token, das während des Initialisierungsprozesses auf dem Masterknoten generiert wurde.
• <hash>: Ersetzen Sie dies durch den Discovery-Token-CA-Zertifikat-Hash, der durch den kubeadm-Init-Befehlsausgang bereitgestellt wird.

Schritt 6: Cluster-Zustand überprüfen

Sobald alle Worker-Knoten dem Cluster beigetreten sind, überprüfen Sie den Zustand Ihres Clusters mit kubectl-Befehlen:

$ kubectl get pods -n kube-system

Verwalten eines Kubernetes-Clusters

Ein effektives Management eines Kubernetes-Clusters ist entscheidend für die Aufrechterhaltung von Performance und Zuverlässigkeit. Dazu gehören das Skalieren, Aktualisieren und Aktualisieren der Knoten im Cluster.

Skalierung des Clusters

Kubernetes bietet horizontale Skalierung, sodass Sie die Anzahl der Worker-Knoten ganz einfach an Ihre Workload-Anforderungen anpassen können.

1. Knoten hinzufügen (Skalierung):
   1. Bereiten Sie den neuen Knoten vor: Stellen Sie sicher, dass der neue Knoten die empfohlenen Systemanforderungen für die gewünschte Kubernetes-Version erfüllt. Installieren Sie die erforderliche Software, einschließlich einer Container-Laufzeit wie Docker oder Containerd, und den Kubelet-Agenten. In der offiziellen Kubernetes-Dokumentation finden Sie detaillierte Installationsschritte basierend auf Ihrem Betriebssystem
   2. Verbinden Sie den Knoten mit dem Cluster: Verwenden Sie den Befehl kubeadm Join auf dem neuen Knoten, um dem vorhandenen Cluster beizutreten. Sie benötigen die folgenden Informationen aus Ihrem ersten Cluster-Setup:
      • Master-Knoten-IP-Adresse: Die IP-Adresse Ihres Masterknotens.
      • Token beitreten: Dieses Token wurde während der Initialisierung der Steuerungsebene generiert und im Ausgang bereitgestellt.

Hier ist ein Beispiel für einen Kubeadm-Join-Befehl:

• Ersetzen Sie <master_ip_address> sie durch die tatsächliche IP-Adresse Ihres Masterknotens.
• Ersetzen Sie das Token<token>, das während der Initialisierung der Steuerungsebene generiert wurde.
• Ersetzen Sie <hash> durch den CA-Zertifikats-Hash für den Discovery-Token von der Initialisierungsausgabe der Steuerungsebene.

Knoten entfernen (skalieren):
Bevor Sie einen Knoten entfernen, ist es wichtig, ihn zuerst zu leeren. Das Entleeren stellt sicher, dass Ihre Anwendungen keine Ausfallzeiten haben, indem Pods anständig aus dem Knoten entfernt und auf gesunden Knoten geplant werden.

Knoten entleeren: Verwenden Sie den Befehl kubectl drain, um den Knoten zu leeren, den Sie entfernen möchten. Mit diesem Befehl werden Pods aus dem Knoten entfernt, während DaemonSets (kritische Systemservices) weiter ausgeführt werden kann.

$ kubectl drain <node-name> --ignore-daemonsets

Ersetzen Sie ihn <node-name> durch den Hostnamen oder die IP-Adresse des Knotens, den Sie entfernen möchten.

Knoten löschen: Nach dem Entleeren können Sie den Knoten mit dem Befehl kubectl delete node sicher aus dem Cluster entfernen.

$ kubectl delete node <node-name>

Ersetzen Sie ihn <node-name> durch den Hostnamen oder die IP-Adresse des Knotens, den Sie entfernen möchten.

Sie können auch andere Verwaltungsvorgänge durchführen, z. B. ein Upgrade der Steuerungsebene, ein Upgrade des Worker-Knotens und rollierende Upgrades.

Aufrechterhaltung der Spitzenleistung: Überwachung, Protokollierung und Storage

Effektive Überwachung und Protokollierung sind entscheidend, um Ihren Kubernetes-Cluster gesund zu halten. Tools wie Prometheus und der ELK Stack bieten umfassende Einblicke in die Ressourcenauslastung, den Pod-Zustand und die Gesamtleistung, sodass Sie Probleme proaktiv erkennen und beheben können, bevor sie sich auf Anwendungen auswirken. Kubernetes lässt sich auch in verschiedene Lösungen von Drittanbietern integrieren, um Flexibilität zu erzielen.

Effizientes Datenmanagement ist der Schlüssel für zustandsbehaftete Anwendungen. Portworx ® von Pure Storage bietet eine leistungsstarke, containernative Lösung, die sich nahtlos in Ihren Kubernetes-Cluster integrieren lässt.

Portworx optimiert Storage für Ihre Workloads durch:

• Bereitstellung persistenter Volumes: Stellt sicher, dass die Daten auch dann bestehen bleiben, wenn Pods neu gestartet oder neu geplant werden.
• Bereitstellung von Datenschutz und Disaster Recovery: Bietet Snapshots und Replikation und minimiert Ausfallzeiten bei Vorfällen.
• Vereinfachtes Management: Bietet eine benutzerfreundliche Schnittstelle zum Bereitstellen, Überwachen und Verwalten von Storage-Ressourcen.

Fazit

Kubernetes-Cluster sind grundlegend für die moderne Containerorchestrierung und bieten eine verbesserte Skalierbarkeit, Fehlertoleranz und vereinfachtes Anwendungsmanagement. Das Verständnis der Komponenten, des Einrichtungsprozesses und der Managementpraktiken von Kubernetes-Clustern ist entscheidend, um ihr volles Potenzial auszuschöpfen. Portworx von Pure Storage lässt sich nahtlos in Kubernetes integrieren und bietet robuste Storage-Funktionen, die die Gesamteffizienz und Zuverlässigkeit von containerisierten Workloads verbessern.