Verwalten mehrerer Ansible-Inventare

Einführung

In diesem Lab erfahren Sie, wie Sie mit mehreren Inventaren in Ansible arbeiten können. Das Verwalten mehrerer Inventare ist ein häufiges Szenario in komplexen Umgebungen mit verschiedenen Hostgruppen oder getrennten Umgebungen. Sie werden lernen, wie Sie mehrere Inventare definieren und organisieren, auf Hosts aus verschiedenen Inventaren zugreifen und Operationen über mehrere Inventare hinweg ausführen können.

Skills Graph

Erstellen des Inventarverzeichnisses und der Dateien

Beginnen wir damit, ein Verzeichnis zum Speichern unserer Inventardateien zu erstellen und dann zwei separate Inventardateien für die Entwicklungs- und Produktionsumgebungen anzulegen.

Zunächst erstellen Sie ein neues Verzeichnis namens inventory im Pfad /home/labex/project:

mkdir -p /home/labex/project/inventory

Dieser Befehl erstellt ein neues Verzeichnis namens inventory. Die Option -p stellt sicher, dass die übergeordneten Verzeichnisse erstellt werden, falls sie nicht existieren.

Nun erstellen Sie zwei Inventardateien: dev_inventory.ini und prod_inventory.ini im Verzeichnis inventory:

touch /home/labex/project/inventory/dev_inventory.ini
touch /home/labex/project/inventory/prod_inventory.ini

Der Befehl touch erstellt leere Dateien, falls sie nicht existieren, oder aktualisiert die Änderungszeit, falls sie bereits existieren.

Als Nächstes fügen wir diesen Inventardateien Inhalt hinzu. Öffnen Sie dev_inventory.ini in einem Texteditor (Sie können nano oder einen anderen Texteditor verwenden, mit dem Sie vertraut sind):

nano /home/labex/project/inventory/dev_inventory.ini

Fügen Sie den folgenden Inhalt hinzu:

[dev]
localhost ansible_connection=local

Speichern Sie die Datei und verlassen Sie den Editor (in nano können Sie dies tun, indem Sie Strg+X drücken, dann Y und anschließend Enter).

Nun öffnen Sie prod_inventory.ini:

nano /home/labex/project/inventory/prod_inventory.ini

Fügen Sie den folgenden Inhalt hinzu:

[prod]
localhost ansible_connection=local

Speichern Sie die Datei und verlassen Sie den Editor.

In diesen Inventardateien:

• [dev] und [prod] sind Gruppennamen. Sie helfen, Hosts in logische Gruppen zu organisieren.
• localhost ist der Hostname. Wir verwenden localhost, um verschiedene Umgebungen auf demselben Computer zu simulieren.
• ansible_connection=local teilt Ansible mit, Befehle lokal auszuführen, anstatt versuchen, per SSH auf den Computer zuzugreifen. Dies ist nützlich, wenn Sie Ansible auf demselben Computer ausführen, auf dem es installiert ist.

In einem realen Szenario würden Sie normalerweise unterschiedliche IP-Adressen oder Hostnamen für Ihre Entwicklungs- und Produktionsserver haben, anstatt für beide localhost zu verwenden.

Erstellen eines Playbooks für mehrere Inventare

In diesem Schritt erstellen wir ein Playbook, das mit unseren Entwicklungs- und Produktionsinventaren arbeiten kann. In Ansible ist ein Playbook eine YAML-Datei, die eine Reihe von Aufgaben definiert, die auf Hosts ausgeführt werden sollen.

Zunächst erstellen wir eine neue Datei namens multi_env_playbook.yaml im Verzeichnis /home/labex/project:

touch /home/labex/project/multi_env_playbook.yaml

Nun öffnen wir die Datei multi_env_playbook.yaml in einem Texteditor. Wir verwenden nano, einen einfachen Befehlszeilen-Texteditor:

nano /home/labex/project/multi_env_playbook.yaml

Kopieren und fügen Sie den folgenden Inhalt in die Datei ein:

---
- name: Demonstrate multi-environment playbook
  hosts: all
  gather_facts: no
  tasks:
    - name: Print environment type
      debug:
        msg: "This host belongs to the {{ 'production' if 'prod' in group_names else 'development' }} environment"

    - name: Show hostname
      command: hostname
      register: hostname_output

    - name: Display hostname
      debug:
        msg: "The hostname is: {{ hostname_output.stdout }}"

Nachdem Sie eingefügt haben, drücken Sie Strg + X, dann Y und schließlich Enter, um die Datei zu speichern und nano zu verlassen.

Lassen Sie uns dieses Playbook analysieren, um jeden Teil zu verstehen:

1. --- am Anfang der Datei markiert den Beginn eines YAML-Dokuments.
2. name: Demonstrate multi-environment playbook ist ein beschreibender Name für diese Play.
3. hosts: all bedeutet, dass dieses Playbook auf allen Hosts im Inventar ausgeführt wird.
4. gather_facts: no überspringt die Phase der Informationssammlung (Fact Gathering), um die Ausführung zu beschleunigen. Die Informationssammlung erfolgt, wenn Ansible Informationen über die Zielhosts sammelt.
5. tasks: beginnt die Liste der auszuführenden Aufgaben.
6. Die erste Aufgabe verwendet das debug-Modul, um eine Nachricht auszugeben. Sie verwendet eine bedingte Anweisung, um zu bestimmen, ob der Host in der Produktions- oder Entwicklungsumgebung ist:
   • group_names ist eine spezielle Variable, die eine Liste aller Gruppen enthält, zu denen der aktuelle Host gehört.
   • Wenn 'prod' in der group_names-Liste enthalten ist, wird "production" ausgegeben, andernfalls "development".
7. Die zweite Aufgabe führt den Befehl hostname aus und speichert seine Ausgabe in einer Variablen namens hostname_output.
8. Die dritte Aufgabe zeigt den Hostnamen mithilfe des debug-Moduls an. Sie greift auf die gespeicherte Ausgabe über hostname_output.stdout zu.

Ausführen des Playbooks mit dem Entwicklungsinventar

Nachdem wir unser Playbook und die Inventare eingerichtet haben, führen wir das Playbook mit dem Entwicklungsinventar aus.

Führen Sie den folgenden Befehl in Ihrem Terminal aus:

ansible-playbook -i /home/labex/project/inventory/dev_inventory.ini /home/labex/project/multi_env_playbook.yaml

Lassen Sie uns diesen Befehl analysieren:

• ansible-playbook ist der Befehl zum Ausführen eines Ansible-Playbooks.
• -i /home/labex/project/inventory/dev_inventory.ini gibt die zu verwendende Inventardatei an. Die Option -i steht für "inventory" (Inventar).
• /home/labex/project/multi_env_playbook.yaml ist der Pfad zu unserer Playbook-Datei.

Dieser Befehl teilt Ansible mit, die Datei dev_inventory.ini zu verwenden und das Playbook multi_env_playbook.yaml auszuführen.

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

PLAY [Demonstrate multi-environment playbook] *******************************************

TASK [Print environment type] *********************************************************
ok: [localhost] => {
    "msg": "This host belongs to the development environment"
}

TASK [Show hostname] ******************************************************************
changed: [localhost]

TASK [Display hostname] ***************************************************************
ok: [localhost] => {
    "msg": "The hostname is: 66d80191e483433f91fbdca9"
}

PLAY RECAP ****************************************************************************
localhost                  : ok=3    changed=1    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0

Diese Ausgabe zeigt, dass:

1. Das Playbook erfolgreich in der Entwicklungsumgebung ausgeführt wurde.
2. Es wurde korrekt erkannt, dass der Host zur Entwicklungsumgebung gehört.
3. Der Hostname wurde erfolgreich abgerufen und angezeigt.
4. Die "PLAY RECAP" zeigt eine Zusammenfassung der Playbook-Ausführung. Hier bedeutet "ok=3", dass drei Aufgaben erfolgreich ausgeführt wurden, und "changed=1", dass eine Aufgabe eine Änderung am System vorgenommen hat (der Befehl hostname wurde ausgeführt).

Ausführen des Playbooks mit dem Produktionsinventar

Nun führen wir dasselbe Playbook mit dem Produktionsinventar aus, um zu sehen, wie es sich anders verhält.

Führen Sie den folgenden Befehl in Ihrem Terminal aus:

ansible-playbook -i /home/labex/project/inventory/prod_inventory.ini /home/labex/project/multi_env_playbook.yaml

Dieser Befehl ähnelt dem vorherigen, verwendet jedoch die Datei prod_inventory.ini anstelle von dev_inventory.ini.

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

PLAY [Demonstrate multi-environment playbook] *********************************

TASK [Print environment type] *************************************************
ok: [localhost] => {
    "msg": "This host belongs to the production environment"
}

TASK [Show hostname] **********************************************************
changed: [localhost]

TASK [Display hostname] *******************************************************
ok: [localhost] => {
    "msg": "The hostname is: labex-instance"
}

PLAY RECAP ********************************************************************
localhost                  : ok=3    changed=1    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0

Beachten Sie, dass das Playbook diesmal korrekt erkennt, dass es in der Produktionsumgebung ausgeführt wird. Dies liegt daran, dass wir die Produktionsinventardatei verwenden, die den Host in der Gruppe [prod] definiert.

Der Rest der Ausgabe ähnelt der Ausgabe mit dem Entwicklungsinventar, was zu erwarten ist, da wir weiterhin auf demselben lokalen Rechner arbeiten.

Ausführen des Playbooks mit beiden Inventaren

Schließlich führen wir das Playbook mit beiden Inventaren gleichzeitig aus. Dies zeigt, wie Ansible mit mehreren Inventaren gleichzeitig arbeiten kann.

Führen Sie den folgenden Befehl in Ihrem Terminal aus:

ansible-playbook -i /home/labex/project/inventory/dev_inventory.ini -i /home/labex/project/inventory/prod_inventory.ini /home/labex/project/multi_env_playbook.yaml

Dieser Befehl umfasst beide Inventardateien mithilfe mehrerer -i-Optionen. Ansible kombiniert diese Inventare beim Ausführen des Playbooks.

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

PLAY [Demonstrate multi-environment playbook] *******************************************************************************************************************************************************************************************************************************************

TASK [Print environment type] ***********************************************************************************************************************************************************************************************************************************************************
ok: [localhost] => {
    "msg": "This host belongs to the production environment"
}

TASK [Show hostname] ********************************************************************************************************************************************************************************************************************************************************************
changed: [localhost]

TASK [Display hostname] *****************************************************************************************************************************************************************************************************************************************************************
ok: [localhost] => {
    "msg": "The hostname is: 66d80191e483433f91fbdca9"
}

PLAY RECAP ******************************************************************************************************************************************************************************************************************************************************************************
localhost                  : ok=3    changed=1    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0

Sie könnten bemerken, dass das Playbook nur einmal ausgeführt wurde, obwohl wir beide Inventare angegeben haben. Dies liegt daran, dass beide Inventare auf denselben localhost verweisen, und Ansible Hosts standardmäßig duplikatfrei macht. Wenn es in jedem Inventar unterschiedliche Hosts gäbe, würde Ansible das Playbook für jeden eindeutigen Host ausführen.

Die Umgebung wird als "Produktion" identifiziert, weil die Produktionsinventardatei in der Befehlszeile zuletzt angegeben wird. Ansible verwendet die letzte Vorkommnis eines Hosts, wenn es die Gruppenmitgliedschaft und die Variablenwerte festlegt. Wenn wir die Reihenfolge der -i-Optionen umkehren würden, würde die Ausgabe "Entwicklung" anzeigen.

Dieser Ansatz mit mehreren Inventaren kann in realen Szenarien sehr nützlich sein, wenn Sie möglicherweise gemeinsame Hosts in verschiedenen Umgebungen haben oder wenn Sie ein Playbook gegen eine Kombination von Hosts aus verschiedenen Inventardateien ausführen möchten.

Zusammenfassung

In diesem Lab haben Sie gelernt, wie Sie mehrere Ansible-Inventare verwalten können. Sie haben separate Inventardateien für die Entwicklungs- und Produktionsumgebung erstellt, ein Playbook geschrieben, das in beiden Umgebungen funktioniert, und das Playbook mit verschiedenen Inventarkonfigurationen ausgeführt.

Wichtige Erkenntnisse aus diesem Lab sind:

1. Erstellen und Organisieren mehrerer Inventardateien: Sie haben gelernt, wie Sie separate Inventardateien für verschiedene Umgebungen erstellen, was die Organisation und Verwaltung von Hosts erleichtert.
2. Schreiben von Playbooks, die sich an verschiedene Umgebungen anpassen können: Sie haben ein Playbook erstellt, das prüft, in welcher Umgebung es ausgeführt wird, und sein Verhalten entsprechend anpasst.
3. Ausführen von Playbooks mit einem oder mehreren Inventaren: Sie haben gelernt, wie Sie beim Ausführen eines Playbooks eine oder mehrere Inventardateien angeben können, was eine flexible Zielsetzung von Hosts ermöglicht.
4. Verständnis, wie Ansible Hosts behandelt, die in mehreren Inventaren auftauchen: Sie haben gesehen, dass Ansible Hosts duplikatfrei macht und die letzte Vorkommnis eines Hosts verwendet, wenn es die Gruppenmitgliedschaft festlegt.

Diese Fähigkeiten sind von entscheidender Bedeutung bei der Verwaltung komplexer Infrastrukturen mit unterschiedlichen Umgebungen. Durch die Nutzung mehrerer Inventare können Sie eine bessere Organisation und Kontrolle über Ihre Ansible-Automatisierung für verschiedene Hostgruppen oder Umgebungen aufrechterhalten.