Grundlagen von Ansible-Playbooks: Von der Erstellung bis zur Verwendung von Variablen

Einführung

In diesem Lab werden Sie die Grundlagen von Ansible-Playbooks lernen. Ansible-Playbooks sind YAML-Dateien, die eine Reihe von Aufgaben beschreiben, die auf Remote-Hosts ausgeführt werden sollen. Sie sind die Bausteine für komplexe IT-Automatisierungsworkflows. Sie werden Ihr erstes Playbook erstellen, seine Struktur verstehen und lernen, wie Sie es ausführen. Am Ende dieses Labs haben Sie praktische Erfahrungen mit dem Schreiben und Ausführen von Ansible-Playbooks gesammelt, die als Grundlage für einen fortgeschrittenen Ansible-Einsatz dienen werden.

Erstellen Ihres ersten Playbooks

Beginnen wir damit, ein einfaches Ansible-Playbook zu erstellen, das ein Verzeichnis und eine Datei auf dem lokalen Rechner erstellt. Dies hilft Ihnen, die Grundstruktur eines Playbooks zu verstehen und zu lernen, wie Sie es ausführen.

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

nano /home/labex/project/first_playbook.yml

Dieser Befehl öffnet den nano-Texteditor. Wenn Sie mit nano nicht vertraut sind, keine Sorge – es ist ein einfacher Texteditor. Sie können direkt in ihn schreiben.

Fügen Sie nun den folgenden Inhalt in die Datei ein:

---
- name: My First Playbook
  hosts: localhost
  connection: local
  tasks:
    - name: Create a directory
      file:
        path: /home/labex/project/test_directory
        state: directory
        mode: "0755"

    - name: Create a file
      copy:
        content: "Hello from Ansible!"
        dest: /home/labex/project/test_directory/hello.txt

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

Das --- oben markiert den Anfang einer YAML-Datei. YAML ist das Format, das für Ansible-Playbooks verwendet wird.
name: My First Playbook ist ein beschreibender Name für diese Aktion. Er hilft Ihnen zu verstehen, was dieses Playbook macht.
hosts: localhost gibt an, dass dieses Playbook auf dem lokalen Rechner ausgeführt wird. In einer realen Umgebung würden Sie hier möglicherweise Remote-Hosts angeben.
connection: local teilt Ansible mit, das Playbook lokal auszuführen, anstatt SSH zu verwenden. Dies ist nützlich für Tests und für Aufgaben, die auf dem Ansible-Steuerknoten selbst ausgeführt werden müssen.
tasks: wird von einer Liste von Aufgaben gefolgt, die ausgeführt werden sollen. Jede Aufgabe ist eine Aktion, die Sie von Ansible ausführen lassen möchten.
Jede Aufgabe hat einen name zur Beschreibung. Dies hilft Ihnen zu verstehen, was jede Aufgabe macht und erleichtert die Fehlersuche.
Die Aufgaben verwenden Ansible-Module:
- Das file-Modul wird verwendet, um das Verzeichnis zu erstellen.
- Das copy-Modul wird verwendet, um eine Datei mit spezifischem Inhalt zu erstellen.

Machen Sie sich keine Sorgen, wenn Sie noch nicht alle Module verstehen. Im Laufe der Zeit werden Sie viele weitere Module und deren Verwendung kennenlernen.

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 schließlich Enter.

Lassen Sie uns nun dieses Playbook ausführen. Geben Sie in Ihrem Terminal ein:

ansible-playbook /home/labex/project/first_playbook.yml

Dieser Befehl teilt Ansible mit, das Playbook auszuführen, das wir gerade erstellt haben. Sie sollten eine Ausgabe ähnlich der folgenden sehen:

PLAY [My First Playbook] ******************************************************

TASK [Gathering Facts] *********************************************************
ok: [localhost]

TASK [Create a directory] ******************************************************
changed: [localhost]

TASK [Create a file] ***********************************************************
changed: [localhost]

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

Diese Ausgabe zeigt, dass Ansible unsere Aufgaben erfolgreich ausgeführt hat. Der Status "changed" gibt an, dass Ansible Änderungen am System vorgenommen hat (ein Verzeichnis und eine Datei erstellt).

Wenn Sie die Ergebnisse manuell überprüfen möchten, können Sie diese Befehle verwenden:

ls -l /home/labex/project/test_directory
cat /home/labex/project/test_directory/hello.txt

Der erste Befehl sollte das von uns erstellte Verzeichnis anzeigen, und der zweite sollte den Inhalt der von uns erstellten Datei anzeigen.

Verständnis der Playbook-Struktur

Nachdem Sie Ihr erstes Playbook erstellt und ausgeführt haben, wollen wir uns nun genauer mit seiner Struktur befassen. Das Verständnis der Struktur eines Playbooks ist entscheidend für das Schreiben komplexerer Automatisierungsaufgaben in Zukunft.

Ansible-Playbooks bestehen aus einem oder mehreren Plays (Aktionen), und jeder Play besteht aus mehreren Schlüsselkomponenten. Bearbeiten wir unsere first_playbook.yml-Datei, um Kommentare hinzuzufügen, die jeden Teil erklären:

nano /home/labex/project/first_playbook.yml

Aktualisieren Sie den Inhalt wie folgt:

---
## Playbook beginnt mit drei Bindestrichen
- name: My First Playbook ## Name des Plays
  hosts: localhost ## Zielhost(s) für diesen Play
  connection: local ## Verbindungstyp (in diesem Fall lokal)

  tasks: ## Liste der auszuführenden Aufgaben
    - name: Create a directory ## Name der ersten Aufgabe
      file: ## Das 'file'-Modul wird für diese Aufgabe verwendet
        path: /home/labex/project/test_directory ## Pfad des zu erstellenden Verzeichnisses
        state: directory ## Gewünschter Zustand (Verzeichnis erstellen)
        mode: "0755" ## Berechtigungen für das Verzeichnis

    - name: Create a file ## Name der zweiten Aufgabe
      copy: ## Das 'copy'-Modul wird für diese Aufgabe verwendet
        content: "Hello from Ansible!" ## Inhalt, der in die Datei geschrieben werden soll
        dest: /home/labex/project/test_directory/hello.txt ## Zielpfad für die Datei

Speichern Sie die Datei und verlassen Sie den Editor.

Diese kommentierte Version des Playbooks hilft Ihnen, die Struktur und den Zweck jeder Komponente zu verstehen. Hier sind einige wichtige Punkte, die Sie sich merken sollten:

Ein Playbook kann mehrere Plays enthalten, wobei jeder Play mit einem Bindestrich (-) beginnt. In diesem Fall haben wir nur einen Play.
Jeder Play zielt auf bestimmte Hosts ab und definiert eine Liste von Aufgaben. Das hosts-Feld gibt an, auf welchen Maschinen der Play ausgeführt werden soll.
Aufgaben verwenden Ansible-Module (wie file und copy), um Aktionen auszuführen. Ansible verfügt über viele integrierte Module für verschiedene Zwecke.
Jede Aufgabe sollte einen beschreibenden Namen haben. Dies erleichtert das Verständnis, was die Aufgabe tut, und die Fehlersuche.
Einrückung ist in YAML-Dateien von entscheidender Bedeutung. Stellen Sie sicher, dass Ihr Playbook korrekt eingerückt ist. Falsche Einrückung kann beim Ausführen des Playbooks zu Fehlern führen.

Das file-Modul ist vielseitig und kann zum Erstellen, Ändern oder Löschen von Dateien und Verzeichnissen verwendet werden. In unserem Fall verwenden wir es, um ein Verzeichnis zu erstellen.

Das copy-Modul wird verwendet, um Dateien an Remote-Speicherorte zu kopieren oder, wie in unserem Fall, um eine neue Datei mit spezifischem Inhalt zu erstellen.

Das Verständnis dieser Grundstrukturen wird Ihnen helfen, wenn Sie in Zukunft komplexere Playbooks erstellen möchten.

Hinzufügen von Variablen zu Playbooks

Variablen machen Ihre Playbooks flexibler und wiederverwendbarer. Sie ermöglichen es Ihnen, Playbooks zu schreiben, die sich an verschiedene Szenarien anpassen können, ohne dass Sie das Playbook selbst ändern müssen. Lassen Sie uns unser Playbook so ändern, dass es Variablen verwendet.

Bearbeiten Sie die Datei first_playbook.yml:

nano /home/labex/project/first_playbook.yml

Aktualisieren Sie den Inhalt wie folgt:

---
- name: My First Playbook
  hosts: localhost
  connection: local
  vars:
    dir_path: /home/labex/project/test_directory
    file_content: "Hello from Ansible! The time is {{ ansible_date_time.iso8601 }}"

  tasks:
    - name: Create a directory
      file:
        path: "{{ dir_path }}"
        state: directory
        mode: "0755"

    - name: Create a file
      copy:
        content: "{{ file_content }}"
        dest: "{{ dir_path }}/hello.txt"

    - name: Display file content
      debug:
        msg: "The content of the file is: {{ file_content }}"

Lassen Sie uns die Änderungen und neuen Elemente in diesem aktualisierten Playbook analysieren:

Wir haben einen vars-Abschnitt hinzugefügt, um Variablen zu definieren. Hier können Sie Werte festlegen, die Sie mehrmals in Ihrem Playbook verwenden werden.
dir_path und file_content sind jetzt Variablen. Wir können diese Werte an einem Ort einfach ändern, um mehrere Aufgaben zu beeinflussen.
Wir verwenden die Syntax {{ }}, um auf Variablen zu verweisen. Dies teilt Ansible mit, die Variable durch ihren Wert zu ersetzen.
Wir haben die integrierte Ansible-Variable ansible_date_time.iso8601 verwendet, um den aktuellen Zeitstempel einzubeziehen. Ansible bietet viele solche Variablen, die Sie in Ihren Playbooks verwenden können.
Eine neue Aufgabe mit dem debug-Modul wurde hinzugefügt. Das debug-Modul ist sehr nützlich, um Informationen während der Ausführung des Playbooks anzuzeigen, was bei der Fehlersuche helfen kann.

Die Verwendung von Variablen macht dieses Playbook flexibler. Wenn Sie beispielsweise den Verzeichnispfad ändern möchten, müssen Sie ihn nur im vars-Abschnitt ändern, nicht in jeder Aufgabe.

Speichern Sie die Datei und verlassen Sie den Editor.

Lassen Sie uns nun das aktualisierte Playbook ausführen:

ansible-playbook /home/labex/project/first_playbook.yml

Sie sollten eine Ausgabe sehen, die zeigt, dass die Aufgaben ausgeführt werden, einschließlich der Debug-Nachricht, die den Dateiinhalt mit dem aktuellen Zeitstempel anzeigt. Die Ausgabe sieht in etwa so aus:

PLAY [My First Playbook] ******************************************************

TASK [Gathering Facts] *********************************************************
ok: [localhost]

TASK [Create a directory] ******************************************************
ok: [localhost]

TASK [Create a file] ***********************************************************
changed: [localhost]

TASK [Display file content] ****************************************************
ok: [localhost] => {
    "msg": "The content of the file is: Hello from Ansible! The time is 2023-06-09T12:34:56Z"
}

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

Der tatsächliche Zeitstempel wird unterschiedlich sein, wenn Sie das Playbook ausführen.

Dies zeigt, wie Variablen Ihre Playbooks dynamischer machen können. Der Dateiinhalt enthält jetzt einen Zeitstempel, der jedes Mal unterschiedlich ist, wenn Sie das Playbook ausführen.

Zusammenfassung

In diesem Lab haben Sie die Grundlagen von Ansible-Playbooks gelernt. Sie haben von der Erstellung Ihres ersten einfachen Playbooks bis zum Verständnis seiner Struktur und zur Verwendung von Variablen vorgearbeitet, um Ihre Playbooks dynamischer und wiederverwendbarer zu machen.

Wichtige Erkenntnisse aus diesem Lab:

Ansible-Playbooks werden im YAML-Format geschrieben und beschreiben eine Reihe von Aufgaben, die auf bestimmten Hosts ausgeführt werden sollen.
Ein Playbook besteht aus einem oder mehreren Plays (Aktionen), wobei jeder Play eine Liste von Aufgaben enthält.
Aufgaben verwenden Ansible-Module, um Aktionen auf den Zielhosts auszuführen. In diesem Lab haben wir die Module file, copy und debug verwendet.
Variablen können in Playbooks definiert und verwendet werden, um Flexibilität und Wiederverwendbarkeit zu erhöhen. Sie werden mit der Syntax {{ }} referenziert.
Das debug-Modul ist nützlich, um Informationen während der Ausführung des Playbooks anzuzeigen, was bei der Fehlersuche helfen kann.
Die richtige Einrückung ist in YAML-Dateien und Ansible-Playbooks von entscheidender Bedeutung.

Wenn Sie Ihre Reise mit Ansible fortsetzen, werden Sie feststellen, dass Playbooks ein leistungsstarkes Werkzeug zur Automatisierung komplexer IT-Aufgaben sind. Üben Sie das Schreiben von Playbooks für verschiedene Szenarien, um sich mit ihrer Struktur und ihren Möglichkeiten vertrauter zu machen. Versuchen Sie, die Playbooks, die wir heute erstellt haben, zu ändern – ändern Sie den Verzeichnispfad, fügen Sie weitere Aufgaben hinzu oder verwenden Sie andere Module.

In zukünftigen Labs werden Sie mehr über fortgeschrittene Playbook-Funktionen wie Bedingungen, Schleifen und Rollen erfahren, die es Ihnen ermöglichen, noch leistungsfähigere und flexiblere Automatisierungsworkflows zu erstellen.

Denken Sie daran, dass der Schlüssel zum Beherrschen von Ansible Übung und Exploration ist. Seien Sie nicht afraid, verschiedene Module und Strukturen in Ihren Playbooks zu experimentieren. Die Ansible-Dokumentation ist eine ausgezeichnete Ressource, wenn Sie weiterhin lernen und Ihre Fähigkeiten erweitern möchten.