Ansible Kubernetes (K8s) Inventarquelle

Ansible Kubernetes K8s Inventarquelle



In diesem Beitrag lernen wir, wie man das Kubernetes-Plugin im Ansible-Tool verwendet. In Ansible ist es schwierig, eine große Anzahl von Containern zu verwalten. Die Verwendung von Kubernetes in Ansible ist jedoch hilfreich bei der Verwaltung der Container. In diesem Leitfaden erfahren wir, was die Kubernetes-Inventarquelle ist und wie sie in Ansible funktioniert.

Google hat die leicht zugängliche Verwaltungssoftware namens Kubernetes eingeführt, die auch als K8s bekannt ist und zur Verwaltung der virtualisierten Konfigurationen über einen Remote-Satz von Maschinen mit Installationsfunktionen ohne Ausfallzeiten, automatischer Umkehrung und Skalierbarkeit verwendet wird, wodurch das Kubernetes-Plug-in extrem anpassungsfähig wird Architektur in Ansible. Durch die Verfügbarkeit von REST-APIs für die notwendige Funktionalität ist es das primäre Ziel von Kubernetes, die Komplexität zu verbergen, die mit der Steuerung einer Reihe von Containern verbunden ist.







Die Konfiguration von Kubernetes basiert auf Client-Server. Standardmäßig gibt es jedoch nur einen Hauptserver, der als steuernder Host dient. In Kubernetes können wir auch Multi-Main-Controller für die Konfiguration von Kubernetes verwenden. Die K8s-Inventarquelle ist gelegentlich erforderlich, um Systeme zu steuern und die Dienste auf dem Remote-Host zu konfigurieren, um Pods zu steuern. Es ist jedoch schwierig, spezifische Anweisungen zu erhalten, wie dies zu tun ist. Aus diesem Grund implementieren wir dieses Tutorial zum Erstellen eines Ansible Playbooks, das die Pods in einer Domäne extrahiert und eine Kubernetes-Inventarquelle erstellt.



Voraussetzungen für die Verwendung der Kubernetes-Inventarquelle in Ansible

Um die Kubernetes-Inventarquelle in Ansible zu verwenden, gibt es in diesem Handbuch Phasenprozessanweisungen oder -befehle. Stellen Sie sicher, dass Sie die notwendige Vorbereitung haben, wenn Sie darin vorankommen möchten:



  • Um in einem Ansible-Szenario zu arbeiten, richten wir zuerst das Ansible-Tool auf dem Server ein und stellen sicher, dass Sie die Ansible-Version 2.11.7 haben, damit wir das Kubernetes-Plugin problemlos verwenden können.
  • Um das Kubernetes-Plug-in zu bewerten, benötigen wir ein Remote-Servergerät mit integriertem Kubernetes-Cluster.
  • Der Remote-Host ist derzeit so konfiguriert, dass er die Ansible-Anweisungen und Playbooks sowie eine erstellte Inventardatei ausführt. Der Name des Remote-Zielgeräts ist K8s Master Node.
  • Die Version von Python ist 3.6 oder höher, die auf dem Gerät des Ansible-Controllers installiert sein muss. Es kann sich auch im Ziel-Remote-Host-Gerät befinden.
  • Die Version des Openshift-Moduls von Python ist 0.6 oder höher. Außerdem benötigen wir ein pyYAML-Modul der Version 3.11 oder höher. Beide Module müssen sowohl im Remote-Server-Gerät als auch im Controller-Gerät eingerichtet werden.

Beispiel:





Hier ist das allererste Beispiel, bei dem wir Kubernetes in Ansible implementieren. Dazu verwenden wir eine beliebige Ansible-Umgebung, um die Kubernetes-Inventarquelle zu implementieren. Die nachfolgend aufgeführten Prozesse werden in folgendem Szenario mit dem Kubernetes Inventory Plugin durchgeführt:

  • Implementierung des neuen Namespace im K8s-Cluster in Ansible.
  • Erstellung eines Nginx-Pods mit dem Ansible-Playbook.
  • Erstellung einer Nginx-Bereitstellung in Ansible.

Um die Konzepte und die Ausführung einfach verständlich zu machen, implementieren wir das Beispiel in mehreren Schritten.



Schritt 1: Implementieren Sie den neuen Namespace im K8s-Cluster in Ansible

Im ersten Schritt erstellen wir das Playbook, damit wir die Inhalte im „.yml“-Format in Ansible schreiben können. Um das Playbook zu erstellen, verwenden wir den folgenden Befehl:

[ Wurzel @ Meister ansibel ] # nano  nginx_pod.yml

Nun wird das Playbook „pod.yml“ erstellt und im neuen Terminal von Ansible gestartet. Wir fangen an, das Drehbuch zu schreiben. Im Playbook definieren wir zunächst die API-Version, die wir im Ansible-Pod verwenden, also „v1“. Der Namespace, den wir definieren, ist „ansible-namespace“. Dann listen wir die Metadaten des Ansible-Namespace auf. In den Metadaten verwenden wir die nginx-Software und das Label, das ein Tier-of-Value-Frontend enthält. In der Spezifikation des Playbooks listen wir den Namen und das Bild auf, das im Container gespeichert ist; beide enthalten das nginx darin.

Schritt 2: Erstellen Sie das Manifestdokument in Ansible

Jetzt erstellen wir ein weiteres Dokument im selben Verzeichnis von Ansible, das das Bereitstellungsdokument im „.yml“-Format ist. Verwenden Sie zum Erstellen des Manifestdokuments den folgenden Befehl im Ansible-Terminal:

[ Wurzel @ Meister ansibel ] # nano nginx_deployment.yml

Im Manifest-Dokument definieren wir zunächst erneut die App-Version, die „app/v1“ ist. Dann teilen wir mit, um welche Art von Datei es sich handelt, ob es sich um eine Bereitstellungsdatei handelt. Dann definieren wir den Namespace, der Ansible-Namespace ist. Um die Implementierung zu erstellen, zeigen zwei Replikate innerhalb des Ansible-Namespace die Nummer des Pods. Die nginx-Images sind 1.14.2, die im Pod gestartet werden. Der Parameter matchLabels stellt die Tags für die Pods und ihre Spezifikationen unter dem Parameter spec bereit. Wenn die Tags auf den Pods irgendwie mit den in den Konfigurationsinformationen angegebenen übereinstimmen, erfolgt die Implementierung im Manifestdokument in Ansible.

Schritt 3: Erstellen Sie das Playbook für die Kubernetes-Implementierung in Ansible

Jetzt wollen wir ein weiteres Playbook in Ansible erstellen. In diesem Playbook implementieren wir die Funktionalität von Kubernetes darin. Verwenden Sie den folgenden Befehl, um das Playbook zu erstellen:

[ Wurzel @ Meister ansibel ] # nano kubernetes_main.yml

Das Playbook wird in demselben Verzeichnis erstellt, in dem das vorherige Playbook und das Manifestdokument in Ansible gespeichert sind. Im Playbook definieren wir zunächst die Funktionalität des Playbooks, die wir implementieren möchten. Um die Verbindung aufzubauen, stellen wir die Remote-Hosts bereit, die wir ansprechen möchten. Hier zielen wir auf „alle“ Hosts ab. Als nächstes definieren wir die Variable, um den Python-Interpreter in Ansible zu überprüfen, indem wir den Pfad verwenden, in dem sie gespeichert ist. Jetzt definieren wir die Aufgaben im Playbook. Zuerst überprüfen wir den Status des Minikube-Geräts. Als Nächstes erstellen wir einen neuen Kubernetes-Namespace im Playbook. Kopieren Sie dann die Dateien „nginx_pod.yml“ und „nginx_deployment.yml“ auf das Remotegerät.

Durch diese yml-Dokumente erstellen wir die Pod-Implementierung im Remote-Gerät. Dann prüfen wir, ob der Kubernetes-Pod am angegebenen Ort im Remote-Gerät vorhanden ist oder nicht.

Nach der Playbook-Beendigung bauen wir nun die Inventory-Datei auf, damit wir die Verbindung zwischen dem Ansible-Controller und dem Ziel-Remote-Host herstellen.

Alle:
Gastgeber:
k8s_Master_Node:
ansible_host: 192.168.3.229
ansible_user: ansible
ansible_passwort: ********
ansible_connection: sch
ansible_port: 22

[ Wurzel @ Meister ansibel ] # ansible-playbook kubernates_main.yml

Hier ist die gewünschte Ausgabe, in der wir sehen, dass die Aufgaben erfolgreich auf dem Zielcomputer platziert wurden:

Nachdem die Aufgabe auf der Zielmaschine platziert wurde, prüfen wir, ob sich der „ansible-namespace“ im Kubernetes-Cluster befindet oder nicht. Wir verwenden den folgenden „grep“-Befehl:

[ Wurzel @ Meister ansibel ] # kubectl Namensraum abrufen | grep Ansible-Namespace

Wenn Sie den erstellten Pod im Namespace des Kubernetes-Clusters überprüfen möchten, schreiben Sie den folgenden Befehl zum Überprüfen:

[ Wurzel @ Meister ansibel ] # kubectl get pods --namespace Ansible-Namespace

Wie Sie in der vorherigen Ausgabe sehen, erhalten wir die Pods, die auf dem Gerät ausgeführt werden. Jetzt überprüfen wir die Bereitstellung, die wir im Kubernetes-Cluster vorgenommen haben. Verwenden Sie die folgende Anweisung, um die bereits durchgeführten Bereitstellungen zu überprüfen:

[ Wurzel @ Meister ansibel ] # kubectl Get Deployments --Namespace Ansible-Namespace

Abschluss

Wir haben gelernt, was die Kubernetes-Inventarquelle in Ansible ist. Wir haben auch gelernt, wie man das Kubernetes-Inventar in Ansible nutzt. Dann haben wir ein Beispiel implementiert, damit wir mehr über die Funktionsweise der Kubernetes-Inventarquelle in Ansible erfahren.