Was sind Tolerations und Taints in Kubernetes?
Toleration und Taint in Kubernetes werden verwendet, um sicherzustellen, dass die Pods im richtigen Knoten platziert werden. Die Toleranz wird in der Pod-Spezifikation definiert, während die Markierungen in der Knotenspezifikation definiert werden. Wenn Sie die Toleranz auf einen Pod anwenden, kann der Planer die Pods auf einem bestimmten Knoten planen. Die Taints wirken jedoch der Tolerierung entgegen. Es ermöglicht dem Knoten, die Pods abzulehnen, die darauf geplant werden sollen. Die Pods dürfen nur auf dem Knoten geplant werden, wenn auf sie Toleranzen mit übereinstimmenden Markierungen angewendet wurden.
Kubernetes arbeitet mit Pods, Clustern, Knoten, Ereignissen usw. In einigen Fällen benötigt Kubernetes Toleranzen und Taints, um diese Dinge zu verwalten. Toleranz ist die Implementierung des Scheduling-Prozesses. Die Pods müssen so geplant werden, dass sie ordnungsgemäß funktionieren und bei Bedarf über genügend Ressourcen verfügen, um ihren Betrieb auszuführen. Auf die Kapseln werden Toleranzen gegen Verunreinigung angewendet, damit sie während der Arbeit keine Unterbrechung oder Unterbrechung erfahren.
Die Taints in Kubernetes ermöglichen es einem Pod, die Planung eines Pods abzulehnen. Es wird auf einen Knoten angewendet, indem die Knotenspezifikation „NodeSpec“ verwendet wird. Der Scheduler ist nicht in der Lage, einen Pod auf einem Knoten zu platzieren, der einen Taint enthält. Wenn Sie die Pods jedoch auf einem Knoten planen müssen, auf dem bereits ein Taint angewendet wird, müssen Sie die Tolerierung dagegen erklären.
Die Toleranz in Kubernetes ermöglicht die Planung eines Pods auf einem Knoten, auf dem bereits ein Taint angewendet wurde. Die Toleranz auf einem Pod wird mithilfe der „PodSpec“-Pod-Spezifikation angewendet. Wenn Sie die Toleranz auf einen Pod mit passendem Taint anwenden, kann der Planer die Pods einfach auf einem bestimmten Knoten planen.
Lassen Sie uns nun ein Szenario vorstellen, das Ihnen hilft zu verstehen, wie Sie die Toleranz auf einem Pod in Kubernetes implementieren können. Bevor Sie mit dem Implementierungsabschnitt fortfahren, vergewissern Sie sich, dass alle Voraussetzungen erfüllt sind.
Voraussetzung:
Im Folgenden sind die Dinge aufgeführt, die Sie benötigen, um die Toleranz auf einem Knoten in Kubernetes zu implementieren:
- Ubuntu 20.04 oder eine andere neueste Version eines beliebigen Linux-Systems
- Minikube (neueste Version)
- Installierte virtuelle Maschine in Ihrem Linux/Unix-System
- Kubectl-Befehlszeilentool
Unter der Annahme, dass Ihr System alle Voraussetzungen erfüllt, beginnen wir mit der Festlegung der Kubernetes-Toleranz.
Schritt 1: Starten Sie das Minikube-Terminal
Als Erstes müssen Sie das Minikube-Terminal starten, damit Sie die kubectl-Befehle für die Implementierung der Kubernetes-Toleranz auf einem Knoten verwenden können. Um den Minikube zu starten, wird folgender Befehl verwendet:
> minikube startNach der Ausführung dieses Befehls erhalten Sie die folgende Ausgabe in Ihrem Terminal:
Schritt 2: Holen Sie sich die Liste der aktiven Knoten
Nachdem wir den Minikube gestartet haben, ist unser System bereit, die Toleranz für Pods in Kubernetes festzulegen. Bevor wir die Toleranz für die Pods festlegen, prüfen wir, wie viele Knoten und welche Art von Knoten wir bereits haben. Dazu verwenden wir den folgenden nachfolgenden Befehl:
> kubectl erhält Knoten -Die =custom-columns=NodeName:.metadata.name,TaintKey:.spec.taints [ * ] .key,TaintWert:.spec.taints [ * ] .value,TaintEffect:.spec.taints [ * ] .WirkungDiese Anweisung listet alle Knoten auf, die von der Kubernetes-Standardinstallation betroffen sind. Sehen wir uns zunächst die Ausgabe dieses Befehls an. Dann besprechen wir die Liste der Knoten:
Da es keine Nodes gibt, die von der Standardinstallation von Kubernetes erstellt und befleckt werden, und wir auch keine Nodes speziell erstellt haben, ist das Ergebnis
Schritt 3: Erstellen Sie einen Namespace
Zuerst erstellen wir einen Namespace, um eine App auf einem Cluster bereitzustellen. Hier erstellen wir mit Hilfe des folgenden Befehls eine App mit dem Wert „frontend“:
> kubectl erstellt ein ns-FrontendDieser Befehl erstellt den Namespace mit dem Wert „frontend“. Siehe folgende Ausgabe:
Schritt 4: Stellen Sie den Nginx-Pod im Namespace bereit
Stellen Sie nun den nginx-Pod auf dem soeben erstellten Namespace bereit. Wir verwenden den folgenden Befehl, um nginx bereitzustellen:
> kubectl nginx ausführen – Bild =nginx –Namespace-FrontendDadurch wird eine App auf einem Cluster ohne Toleranzkonfiguration in der Spezifikation der App-Bereitstellung bereitgestellt. Mit dem kubectl-Befehl stellen wir den nginx-Pod auf dem Namespace-Frontend bereit:
Schritt 5: Holen Sie sich die Liste der Pods
Lassen Sie uns nun die erstellten Pods überprüfen, um ihren Status anzuzeigen. Der angegebene Befehl listet auch alle Pods und deren Status auf:
> kubectl erhält Pods -n FrontendDa wir nur nginx erstellt haben, sollte dieser Befehl diesen Pod mit seinem Status auflisten. Siehe folgende Ausgabe:
Schritt 6: Analysieren Sie die Kubernetes-Ereignisse
Lassen Sie uns nun die Ereignisse in Kubernetes analysieren, damit wir die Toleranz für die Pods entsprechend festlegen können. Wir verwenden den folgenden kubectl-Befehl, um die Liste der Ereignisse in Kubernetes abzurufen:
> kubectl erhält Ereignisse -n FrontendDies listet alle Ereignisse auf, die dem Frontend-Wert zugeordnet sind, zusammen mit ihren Eigenschaften wie Typ, Grund, Objekt und Nachricht. Siehe die angegebene Liste in der folgenden Ausgabe:
Wie Sie der vorherigen Ausgabe entnehmen können, wird der nginx-Pod mit der spezifischen Toleranz geplant. Die Eigenschaft „Nachricht“ zeigt die Liste der Aktionen, die während des Prozesses ausgeführt werden.
Schritt 7: Überprüfen Sie den Status der Pods
Der letzte Schritt besteht darin, den Status des zuvor erstellten Pods erneut zu überprüfen, um sicherzustellen, dass er erfolgreich auf einem bestimmten und richtigen Knoten geplant ist. Dazu verwenden wir den folgenden kubectl-Befehl:
> kubectl erhält Pods -n Frontend 
Wie in der vorherigen Ausgabe zu sehen ist, darf der Pod jetzt auf dem Taint-Knoten ausgeführt werden, da die Toleranz dagegen gesetzt ist.
Fazit
In diesem Leitfaden haben wir uns mit den Makeln und der Toleranz befasst. Wir haben etwas über die grundlegende Funktionsweise von Makeln und Tolerierung gelernt. Dann haben wir die Toleranz auf einem Pod implementiert. Anhand eines einfachen Beispiels haben wir gelernt, wie man die Toleranz auf einem Knoten in Kubernetes setzt.