So setzen Sie die Kubernetes -Tolerationen
Was sind Tolerierungen und Verdichtungen in Kubernetes??
Toleranz und Mächte in Kubernetes werden verwendet, um sicherzustellen, dass die Schoten im richtigen Knoten platziert werden. Die Toleranz ist in der POD. Wenn Sie die Toleranz auf einen Pod anwenden. Die Taints arbeiten jedoch gegenüber der Toleranz. Es ermöglicht dem Knoten, die Schoten abzulehnen, darauf geplant zu werden. Die Schoten dürfen nur auf dem Knoten geplant werden, wenn sie mit passenden Makeln Tolerierungen angewendet haben.
Kubernetes arbeitet mit Schoten, Clustern, Knoten, Ereignissen usw. In einigen Fällen braucht Kubernetes, um diese Dinge zu verwalten. Toleranz ist die Implementierung des Planungsprozesses. Die Pods müssen geplant werden, damit sie ordnungsgemäß arbeiten können und bei Bedarf über genügend Ressourcen verfügen, um ihren Betrieb auszuführen. Tolerierungen werden auf die Schoten gegen Taint angewendet, damit sie während der Arbeit keine Unterbrechung oder Störung haben.
Die Melde in Kubernetes ermöglichen es einem Pod, die Planung einer Pod abzulehnen. Es wird unter Verwendung der Knotenspezifikation „nodespec“ auf einen Knoten angewendet. Der Scheduler kann keinen Pod auf einen Knoten setzen, der einen Mächtigen hat. Wenn Sie jedoch die Pods auf einem Knoten planen müssen, auf dem bereits ein Makel angewendet wird, müssen Sie die Toleranz dagegen erklären.
Die Toleranz in Kubernetes ermöglicht es, dass ein Pod auf einem Knoten geplant wird, in dem bereits ein Mühe angewendet wird. Die Toleranz auf einem POD wird unter Verwendung der Podspec -POD -Spezifikation angewendet. Wenn Sie die Toleranz auf einen Pod mit passender Mühe anwenden, kann die Zeitplan die Pods auf einem bestimmten Knoten problemlos planen.
Lassen Sie uns nun ein Szenario präsentieren, mit dem Sie verstehen können, wie Sie die Toleranz auf einem Pod in Kubernetes implementieren können. Bevor Sie zum Abschnitt zur Implementierung gehen, stellen Sie sicher, dass Sie alle Voraussetzungen haben.
Voraussetzung:
Das Folgende sind die Dinge, die Sie benötigen, um die Toleranz auf einem Knoten in Kubernetes zu implementieren:
- Ubuntu 20.04 oder eine andere neueste Version eines Linux -Systems
- Minikube (neueste Version)
- Installierte virtuelle Maschine in Ihrem Linux/UNIX -System
- Kubectl -Befehlszeilenwerkzeug
Unter der Annahme, dass Ihr System alle Anforderungen von Voraussetzungen entspricht.
Schritt 1: Starten Sie das Minikube -Terminal
Das erste, was Sie tun müssen, ist, das Minikube -Terminal zu starten, damit Sie die Kubectl -Befehle für die Implementierung von Kubernetes -Toleranz auf einem Knoten verwenden können. Um den Minikube zu starten, wird der folgende Befehl verwendet:
> Minikube Start
Bei 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 das Minikube gestartet haben, ist unser System bereit, die Toleranz auf Kubernetes auf Pods zu setzen. Bevor wir die Toleranz auf die Pods stellen, überprüfen wir, wie viele Knoten und welche Art von Knoten wir bereits haben. Dazu verwenden wir den folgenden nachfolgenden Befehl:
> Kubectl Get Knoten -o = benutzerdefinierte Spalte = NODEHNAME:.Metadaten.Name, Taintkey:.Spezifikation.Taints [*].Schlüssel, verdichtetes Value:.Spezifikation.Taints [*].Wert, Tainteffect:.Spezifikation.Taints [*].Wirkung
Diese Anweisung listet alle Knoten auf, die von der Kubernetes -Standardinstallation verdorben sind. Lassen Sie uns zunächst die Ausgabe dieses Befehls sehen. Dann diskutieren wir die Liste der Knoten:
Da es keine Knoten gibt, die von der Kubernetes -Standardinstallation erstellt und verdorben werden und wir auch keinen spezifischen Knoten erstellt haben, ist das Ergebnis . Aus der vorherigen Ausgabe können wir sehen, dass es keinen Knoten gibt. Daher erstellen wir zuerst den Knoten und setzen dann die Toleranz ein. Um die Toleranz auf einen Pod in Kubernetes festzulegen, müssen wir zunächst eine App auf einem Cluster bereitstellen. Die nächsten wenigen Schritte zeigen, wie eine App auf einem Cluster bereitgestellt wird.
Schritt 3: Erstellen Sie einen Namespace
Zunächst erstellen wir einen Namespace, um eine App auf einem Cluster bereitzustellen. Hier erstellen wir eine App mit dem Wert „Frontend“ mit Hilfe des folgenden Befehls:
> Kubectl erstellen NS Frontend
Dieser Befehl erstellt den Namespace mit dem Wert "Frontend". Siehe die folgende Ausgabe:
Schritt 4: Stellen Sie den Nginx -POD im Namespace ein
Stellen Sie nun den Nginx -Pod in dem gerade erstellten Namespace bereit, den wir gerade erstellt haben. Wir verwenden den folgenden Befehl, um die Nginx bereitzustellen:
> kubectl run nginx -image = nginx -namespace Frontend
Dadurch wird eine App in einem Cluster ohne Tolerationskonfiguration in der Spezifikation der App -Bereitstellung bereitgestellt. Mit dem Befehl kubectl bereitstellen wir den nginx Pod im Namespace Frontend:
Schritt 5: Holen Sie sich die Liste der Pods
Lassen Sie uns nun die erstellten Schoten überprüfen, um ihren Status zu sehen. Der angegebene Befehl listet auch alle Schoten und deren Status auf:
> Kubectl Get Pods -n Frontend
Da wir nur den Nginx erstellt haben, sollte dieser Befehl diesen Pod mit seinem Status auflisten. Siehe die folgende Ausgabe:
Schritt 6: Analysieren Sie die Kubernetes -Ereignisse
Lassen Sie uns nun die Ereignisse in Kubernetes analysieren, damit wir die Toleranz auf die Pods entsprechend festlegen können. Wir verwenden den folgenden Kubectl -Befehl, um die Liste der Ereignisse in Kubernetes zu erhalten:
> Kubectl Events -n Frontend erhalten
Dies listet alle Ereignisse auf, die dem Front-End-Wert zusammen mit ihren Eigenschaften wie Typ, Vernunft, Objekt und Nachricht zugeordnet sind. Siehe die angegebene Liste in der folgenden Ausgabe:
Wie Sie aus der vorherigen Ausgabe erkennen können, ist die Nginx -Pod mit der spezifischen Toleranz geplant. Die Eigenschaft „Nachrichten“ zeigt die Liste der Aktionen, die entlang des Prozesses durchgeführt werden.
Schritt 7: Überprüfen Sie den Status von Pods
Der letzte Schritt besteht darin, den Status des Pod erneut zu überprüfen, den wir zuvor erstellt haben, um sicherzustellen, dass er erfolgreich auf einem bestimmten und korrekten Knoten geplant ist. Dazu verwenden wir den folgenden Kubectl -Befehl:
> Kubectl Get Pods -n Frontend
Wie aus der vorherigen Ausgabe zu sehen ist, darf der Pod nun auf dem verdorbenen Knoten ausgeführt werden, da die Toleranz dagegen eingestellt ist.
Abschluss
In diesem Leitfaden haben wir uns über die Verdichtungen und Tolerationen untersucht. Wir haben die grundlegende Arbeit von Makeln und Tolerationen gelernt. Dann haben wir die Toleranz auf einem Pod implementiert. Mit Hilfe eines einfachen Beispiels haben wir gelernt, wie man die Toleranz auf einen Knoten in Kubernetes setzt.