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.

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 Inventories

Abschließend führen wir das Playbook mit beiden Inventories gleichzeitig aus. Dies demonstriert, wie Ansible gleichzeitig mit mehreren Inventories 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 enthält beide Inventories-Dateien durch die Verwendung mehrerer -i-Optionen. Ansible wird diese Inventories beim Ausführen des Playbooks kombinieren.

Sie sollten eine Ausgabe sehen, die der folgenden ähnelt:

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 werden feststellen, dass das Playbook nur einmal ausgeführt wurde, obwohl wir beide Inventories einbezogen haben. Dies liegt daran, dass beide Inventories auf denselben localhost verweisen und Ansible Hosts standardmäßig dedupliziert. Wenn in jeder Inventory unterschiedliche Hosts vorhanden wären, würde Ansible das Playbook für jeden eindeutigen Host ausführen.

Die Umgebung wird als "production" identifiziert, da Ansible, wenn derselbe Host in mehreren Inventories mit unterschiedlichen Gruppen vorkommt, den Host zu allen Gruppen hinzufügt, zu denen er gehört. Da localhost sowohl in der [dev]- als auch in der [prod]-Gruppe definiert ist, enthält die Variable group_names sowohl 'dev' als auch 'prod'. Die Logik des Playbooks prüft, ob 'prod' in group_names enthalten ist, was in diesem Fall immer zutrifft. Daher wird "production" angezeigt, unabhängig von der Reihenfolge der Inventories.

Dieser Ansatz der Verwendung mehrerer Inventories kann in realen Szenarien sehr nützlich sein, in denen Sie möglicherweise gemeinsame Hosts über Umgebungen hinweg haben oder ein Playbook gegen eine Kombination von Hosts aus verschiedenen Inventory-Dateien 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.