Ansible Playbook auf RHEL implementieren

Einführung

In diesem Lab lernen Sie, wie Sie ein vollständiges Ansible-Playbook zur Bereitstellung eines Apache-Webservers auf einem Red Hat Enterprise Linux (RHEL)-System implementieren. Sie beginnen mit der Einrichtung der grundlegenden Komponenten eines Ansible-Projekts, einschließlich der Erstellung einer statischen Inventardatei zur Definition Ihrer verwalteten Knoten und der Konfiguration der lokalen Ansible-Umgebung mithilfe einer ansible.cfg-Datei.

Nach der anfänglichen Einrichtung schreiben Sie ein Multi-Task-Playbook, um den Kernbereitstellungsprozess zu automatisieren. Dies beinhaltet die Installation und den Start des Apache-Dienstes, die Bereitstellung einer benutzerdefinierten Webseite und die Konfiguration der System-Firewall, um HTTP-Datenverkehr zuzulassen. Um das Lab abzuschließen, fügen Sie Ihrem Playbook ein zweites Play hinzu, das den Webserver von der Kommandozeile aus testet und so die erfolgreiche Bereitstellung verifiziert.

Statische Inventardatei für Webserver erstellen

In diesem Schritt lernen Sie die Grundlagen eines Ansible-Inventars kennen. Ein Inventar ist eine Textdatei, die die Server (oder "verwalteten Knoten") auflistet, die Ansible verwalten wird. Sie erstellen eine einfache, statische Inventardatei für eine Gruppe von Webservern und lernen, wie Sie deren Inhalt überprüfen.

Zuerst müssen Sie sicherstellen, dass Ansible auf Ihrem System installiert ist. Da es nicht standardmäßig installiert ist, verwenden Sie den dnf-Paketmanager zur Installation.

1. Öffnen Sie Ihr Terminal und installieren Sie das Paket ansible-core, das die grundlegenden Ansible-Kommandozeilenwerkzeuge bereitstellt.

   sudo dnf install -y ansible-core
   

   Sie sollten eine Ausgabe sehen, die anzeigt, dass das Paket installiert und verifiziert wird.

   ...
   Installed:
     ansible-core-2.16.x-x.el9.x86_64
   ...
   Complete!
   

2. Zur besseren Organisation erstellen Sie ein eigenes Verzeichnis für dieses Projekt in Ihrem Home-Verzeichnis. Nennen wir es ansible-lab.

   mkdir -p ~/project/ansible-lab
   

3. Navigieren Sie in Ihr neu erstelltes Projektverzeichnis. Alle nachfolgenden Arbeiten in diesem Lab werden von diesem Ort aus durchgeführt.

   cd ~/project/ansible-lab
   

4. Nun erstellen Sie Ihre erste Inventardatei. Eine Inventardatei wird typischerweise in einem INI-ähnlichen Format geschrieben. Sie verwenden den Texteditor nano, um eine Datei namens inventory zu erstellen.

   ## install nano
   sudo dnf install -y nano
   

   nano inventory
   

5. Fügen Sie im nano-Editor den folgenden Inhalt hinzu. Diese Konfiguration definiert eine Gruppe namens [webservers] und fügt Ihre lokale Maschine, localhost, zu dieser Gruppe hinzu.

   • [webservers] ist ein Gruppenname. Gruppen werden verwendet, um mehrere Hosts mit einem einzigen Befehl anzusprechen.
   • localhost ist der Hostname der Maschine, die Sie verwalten möchten. In diesem Fall ist es die LabEx VM selbst.
   • ansible_connection=local ist eine spezielle Variable, die Ansible anweist, Befehle direkt auf dem Steuerknoten (Ihrer VM) auszuführen, anstatt zu versuchen, sich über SSH damit zu verbinden.

   [webservers]
   localhost ansible_connection=local
   

   Um die Datei in nano zu speichern, drücken Sie Strg+O, dann Enter, um den Dateinamen zu bestätigen, und Strg+X, um den Editor zu beenden.

6. Nachdem Ihre Inventardatei erstellt wurde, können Sie den Befehl ansible-inventory verwenden, um die Datei zu parsen und eine Liste der darin enthaltenen Hosts anzuzeigen. Das Flag -i gibt den Pfad zu Ihrer Inventardatei an.

   ansible-inventory --list -i inventory
   

   Der Befehl gibt eine JSON-formatierte Darstellung Ihres Inventars aus, was bestätigt, dass Ansible Ihre Datei korrekt lesen und verstehen kann.

   {
     "_meta": {
       "hostvars": {
         "localhost": {
           "ansible_connection": "local"
         }
       }
     },
     "all": {
       "children": ["ungrouped", "webservers"]
     },
     "webservers": {
       "hosts": ["localhost"]
     }
   }
   

Sie haben erfolgreich eine grundlegende statische Inventardatei erstellt und überprüft, ob Ansible sie korrekt interpretieren kann. Diese Inventardatei bildet die Grundlage für die Playbooks, die Sie in den folgenden Schritten schreiben werden.

Ansible-Umgebung mit ansible.cfg konfigurieren

In diesem Schritt erstellen Sie eine Ansible-Konfigurationsdatei, ansible.cfg. Diese Datei ermöglicht es Ihnen, Standardverhalten für Ansible festzulegen, wodurch Sie wiederholtes Eingeben gängiger Optionen in der Kommandozeile vermeiden können. Durch Platzieren einer ansible.cfg-Datei in Ihrem Projektverzeichnis können Sie Einstellungen wie den Pfad zur Standard-Inventardatei definieren, die Ansible automatisch verwendet, wenn es von diesem Verzeichnis aus ausgeführt wird.

Sie sollten sich immer noch im Verzeichnis ~/project/ansible-lab aus dem vorherigen Schritt befinden.

1. Verwenden Sie den Texteditor nano, um eine neue Datei namens ansible.cfg in Ihrem aktuellen Verzeichnis (~/project/ansible-lab) zu erstellen.

   nano ansible.cfg
   

2. Fügen Sie im nano-Editor den folgenden Inhalt hinzu. Diese Konfiguration teilt Ansible mit, wo es Ihre Standard-Inventardatei finden kann.

   • Der Abschnitt [defaults] ist ein Standardteil der ansible.cfg-Datei, in dem Sie die meisten Standardeinstellungen definieren.
   • Die Zeile inventory = ./inventory setzt das Standardinventar auf die Datei inventory, die sich im aktuellen Verzeichnis (.) befindet.

   [defaults]
   inventory = ./inventory
   

   Speichern Sie die Datei, indem Sie Strg+O drücken, dann Enter, und beenden Sie mit Strg+X.

3. Nachdem Sie den Pfad zum Standardinventar konfiguriert haben, müssen Sie das Flag -i bei Ihren Ansible-Befehlen nicht mehr verwenden (solange Sie sich im Verzeichnis ~/project/ansible-lab befinden).

   Um dies zu testen, führen Sie den Befehl ansible-inventory --list erneut aus, aber lassen Sie diesmal den Teil -i inventory weg.

   ansible-inventory --list
   

   Sie sollten genau dieselbe JSON-Ausgabe wie im vorherigen Schritt sehen, was bestätigt, dass Ansible dank der neuen ansible.cfg-Konfiguration Ihre inventory-Datei automatisch findet und verwendet.

   {
     "_meta": {
       "hostvars": {
         "localhost": {
           "ansible_connection": "local"
         }
       }
     },
     "all": {
       "children": ["ungrouped", "webservers"]
     },
     "webservers": {
       "hosts": ["localhost"]
     }
   }
   

Durch die Erstellung einer projektspezifischen ansible.cfg haben Sie Ihren Workflow effizienter gestaltet. Dies ist eine gängige Praxis in Ansible-Projekten, um konsistentes Verhalten zu gewährleisten und die Komplexität der Kommandozeile zu reduzieren.

Playbook zum Installieren und Starten des Apache-Dienstes schreiben

In diesem Schritt schreiben Sie Ihr erstes Ansible Playbook. Ein Playbook ist eine Datei im YAML-Format, die eine Reihe von Aufgaben beschreibt, die auf Ihren verwalteten Hosts ausgeführt werden sollen. Sie erstellen ein Playbook, das den Apache-Webserver (httpd) installiert und dessen Dienst auf der in Ihrem Inventar definierten localhost-Maschine startet.

Sie sollten sich immer noch im Verzeichnis ~/project/ansible-lab befinden.

1. Verwenden Sie zuerst den Texteditor nano, um eine neue Datei namens apache.yml zu erstellen. Diese Datei wird Ihr Playbook enthalten.

   nano apache.yml
   

2. Innerhalb des nano-Editors definieren Sie einen "Play". Ein Play ist die Kerneinheit eines Playbooks und ordnet eine Gruppe von Hosts einer Reihe von Aufgaben zu. Fügen Sie den folgenden Inhalt zu apache.yml hinzu.

   • ---: Dies ist ein Standard-YAML-Marker, der den Beginn eines Dokuments anzeigt.
   • - name: ...: Dies ist der Beginn Ihres Plays. Ihm einen beschreibenden Namen zu geben, ist eine bewährte Methode.
   • hosts: webservers: Dies weist Ansible an, dieses Play auf allen Hosts in der Gruppe webservers aus Ihrer Inventardatei auszuführen.
   • become: true: Dies weist Ansible an, eine Berechtigungserweiterung (wie sudo) zu verwenden, um die Aufgaben auszuführen. Dies ist für Aktionen wie die Installation von Software oder die Verwaltung von Diensten erforderlich.
   • tasks:: Dieses Schlüsselwort leitet die Liste der auszuführenden Aufgaben ein.

   ---
   - name: Install and start Apache web server
     hosts: webservers
     become: true
     tasks:
   

3. Fügen Sie nun die Aufgaben zu Ihrem Playbook hinzu. Jede Aufgabe ist eine einzelne Aktion, die ein Ansible-Modul aufruft. Die Einrückung ist in YAML entscheidend, stellen Sie also sicher, dass die Aufgaben korrekt unter dem Abschnitt tasks: eingerückt sind.

   • Aufgabe 1: httpd installieren. Diese Aufgabe verwendet das Modul ansible.builtin.dnf, um sicherzustellen, dass das Paket httpd installiert ist. Der Parameter state: present bedeutet, dass Ansible das Paket installiert, wenn es fehlt, und nichts tut, wenn es bereits installiert ist.
   • Aufgabe 2: httpd-Dienst starten. Diese Aufgabe verwendet das Modul ansible.builtin.service. state: started stellt sicher, dass der Dienst läuft, und enabled: true stellt sicher, dass er beim Systemstart automatisch gestartet wird.

   Fügen Sie die folgenden Aufgaben zu Ihrer apache.yml-Datei hinzu, direkt unter der Zeile tasks::

   - name: Install httpd package
     ansible.builtin.dnf:
       name: httpd
       state: present
   
   - name: Start and enable httpd service
     ansible.builtin.service:
       name: httpd
       state: started
       enabled: true
   

4. Ihr vollständiges apache.yml-Playbook sollte nun wie folgt aussehen. Überprüfen Sie die Einrückung sorgfältig.

   ---
   - name: Install and start Apache web server
     hosts: webservers
     become: true
     tasks:
       - name: Install httpd package
         ansible.builtin.dnf:
           name: httpd
           state: present
   
       - name: Start and enable httpd service
         ansible.builtin.service:
           name: httpd
           state: started
           enabled: true
   

   Speichern Sie die Datei und beenden Sie nano (Strg+O, Enter, Strg+X).

5. Bevor Sie Ihr Playbook ausführen, ist es eine gute Praxis, es mit dem Befehl ansible-playbook und dem Flag --syntax-check auf Syntaxfehler zu überprüfen.

   ansible-playbook --syntax-check apache.yml
   

   Wenn die Syntax korrekt ist, gibt der Befehl den Dateinamen des Playbooks ohne Fehler aus.

   playbook: apache.yml
   

6. Führen Sie nun das Playbook aus.

   ansible-playbook apache.yml
   

   Ansible wird die Aufgaben durchlaufen. Da dies der erste Durchlauf ist, sehen Sie für beide Aufgaben den Status changed, was bedeutet, dass der Systemzustand geändert wurde.

   PLAY [Install and start Apache web server] *************************************
   
   TASK [Gathering Facts] *********************************************************
   ok: [localhost]
   
   TASK [Install httpd package] ***************************************************
   changed: [localhost]
   
   TASK [Start and enable httpd service] ******************************************
   changed: [localhost]
   
   PLAY RECAP *********************************************************************
   localhost                  : ok=3    changed=2    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0
   

7. Überprüfen Sie abschließend, ob der Apache-Webserver läuft, indem Sie mit curl die Standard-Webseite von localhost abrufen.

   curl http://localhost
   

   Sie sollten die Standard-Apache-Testseite sehen, was bestätigt, dass Ihr Playbook erfolgreich war.

   <html>
     <head>
       <title>Test Page</title>
     </head>
     <body>
       <h1>Test Page</h1>
       <p>This is the default test page for the Apache HTTP server.</p>
     </body>
   </html>
   

Aufgaben zum Bereitstellen einer Webseite hinzufügen

In diesem Schritt erweitern Sie Ihr Playbook, um eine realistischere Konfiguration des Webservers durchzuführen. Sie fügen eine Aufgabe hinzu, um eine benutzerdefinierte index.html-Seite bereitzustellen. Dies zeigt, wie Dateien mit den Dateiverwaltungsmodulen von Ansible verwaltet werden.

Sie sollten sich immer noch im Verzeichnis ~/project/ansible-lab befinden.

1. Erstellen Sie zuerst eine einfache HTML-Datei, die Ihr Playbook bereitstellen wird. Verwenden Sie nano, um eine Datei namens index.html in Ihrem aktuellen Verzeichnis zu erstellen.

   nano index.html
   

2. Fügen Sie den folgenden HTML-Inhalt in die Datei ein. Dies wird der Inhalt Ihrer benutzerdefinierten Webseite sein.

   <h1>Welcome to the Ansible-managed Web Server!</h1>
   <p>This page was deployed using an Ansible Playbook.</p>
   

   Speichern und beenden Sie nano (Strg+O, Enter, Strg+X).

3. Nun aktualisieren Sie Ihr apache.yml-Playbook, um die neue Aufgabe hinzuzufügen. Um YAML-Formatierungsfehler zu vermeiden, wird empfohlen, die Datei mit dem vollständigen Inhalt neu zu erstellen.

   Wichtig: Um die korrekte YAML-Formatierung sicherzustellen und Einrückungsfehler zu vermeiden, entfernen Sie die vorhandene Datei apache.yml und erstellen Sie eine neue mit dem unten gezeigten vollständigen Inhalt.

   rm apache.yml
   nano apache.yml
   

4. Sie fügen dem Playbook eine neue Aufgabe hinzu. Diese Aufgabe kopiert die Datei index.html in das Dokumenten-Root-Verzeichnis des Webservers (/var/www/html/).

   • Aufgabe: index.html bereitstellen. Diese Aufgabe verwendet das Modul ansible.builtin.copy. src gibt die Quelldatei auf dem Steuerknoten (index.html) an, und dest gibt den Zielpfad auf dem verwalteten Host an.

5. Kopieren und fügen Sie den vollständigen Inhalt des apache.yml-Playbooks unten ein. Dies gewährleistet die korrekte YAML-Formatierung und Einrückung.

   ---
   - name: Install and start Apache web server
     hosts: webservers
     become: true
     tasks:
       - name: Install httpd package
         ansible.builtin.dnf:
           name: httpd
           state: present
   
       - name: Deploy custom index.html
         ansible.builtin.copy:
           src: index.html
           dest: /var/www/html/index.html
   
       - name: Start and enable httpd service
         ansible.builtin.service:
           name: httpd
           state: started
           enabled: true
   

   Speichern und beenden Sie nano.

6. Speichern Sie die Datei und beenden Sie nano (Strg+O, Enter, Strg+X), führen Sie dann das aktualisierte Playbook aus.

   ansible-playbook apache.yml
   

   Diesmal sollten Sie sehen, wie die neue Aufgabe ausgeführt wird. Die Aufgaben "Install httpd" und "Start httpd" sollten ok melden, da ihr gewünschter Zustand bereits erfüllt ist. Die Aufgabe "Deploy custom index.html" wird changed melden.

   PLAY [Install and start Apache web server] *************************************
   
   TASK [Gathering Facts] *********************************************************
   ok: [localhost]
   
   TASK [Install httpd package] ***************************************************
   ok: [localhost]
   
   TASK [Deploy custom index.html] ************************************************
   changed: [localhost]
   
   TASK [Start and enable httpd service] ******************************************
   ok: [localhost]
   
   PLAY RECAP *********************************************************************
   localhost                  : ok=4    changed=1    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0
   

7. Verwenden Sie abschließend erneut curl, um zu überprüfen, ob Ihre benutzerdefinierte Webseite nun ausgeliefert wird.

   curl http://localhost
   

   Die Ausgabe sollte nun der Inhalt Ihrer index.html-Datei sein.

   <h1>Welcome to the Ansible-managed Web Server!</h1>
   <p>This page was deployed using an Ansible Playbook.</p>
   

Ein zweites Play zur Überprüfung der Webserver-Bereitstellung implementieren

In diesem letzten Schritt fügen Sie Ihrem Playbook ein zweites Play hinzu. Eine einzelne Playbook-Datei kann mehrere Plays enthalten, die sequenziell ausgeführt werden. Dies ist nützlich für die Organisation von Aufgaben, die auf verschiedene Hosts abzielen oder unterschiedliche Zwecke haben. Sie fügen ein neues Play hinzu, das nur auf dem Steuerknoten (localhost) ausgeführt wird, um den im ersten Play konfigurierten Webserver zu testen.

Sie sollten sich immer noch im Verzeichnis ~/project/ansible-lab befinden.

1. Sie fügen nun ein zweites Play zu Ihrem Playbook hinzu. Um die korrekte YAML-Formatierung beim Hinzufügen des zweiten Plays sicherzustellen, wird empfohlen, die Datei mit dem vollständigen Inhalt neu zu erstellen.

   Wichtig: Um Einrückungsfehler in YAML beim Hinzufügen des zweiten Plays zu vermeiden, entfernen Sie die vorhandene Datei apache.yml und erstellen Sie eine neue mit dem unten gezeigten vollständigen Inhalt für beide Plays.

   rm apache.yml
   nano apache.yml
   

2. Sie fügen dem Playbook ein zweites Play hinzu. Ein zweites Play ermöglicht es Ihnen, Aufgaben zu organisieren, die auf verschiedene Hosts abzielen oder unterschiedliche Zwecke haben.

   • name: Test web server: Ein beschreibender Name für das neue Play.
   • hosts: localhost: Dieses Play wird auf localhost, dem Steuerknoten selbst, ausgeführt.
   • become: false: Dieser Test erfordert keine Root-Privilegien, daher deaktivieren wir explizit die Berechtigungserweiterung.
   • Aufgabe: Web-Inhalt überprüfen. Diese Aufgabe verwendet das Modul ansible.builtin.uri, um eine HTTP-Anfrage an den Webserver zu stellen. Sie prüft, ob der Server einen Statuscode von 200 (OK) zurückgibt und ob der zurückgegebene Inhalt die Zeichenkette "Ansible-managed" enthält. Dies automatisiert die curl- und grep-Prüfung, die Sie bisher manuell durchgeführt haben.

3. Kopieren und fügen Sie den vollständigen Inhalt des apache.yml-Playbooks unten ein, das nun beide Plays enthält:

   ---
   - name: Install and start Apache web server
     hosts: webservers
     become: true
     tasks:
       - name: Install httpd package
         ansible.builtin.dnf:
           name: httpd
           state: present
   
       - name: Deploy custom index.html
         ansible.builtin.copy:
           src: index.html
           dest: /var/www/html/index.html
   
       - name: Start and enable httpd service
         ansible.builtin.service:
           name: httpd
           state: started
           enabled: true
   
   - name: Test web server from localhost
     hosts: localhost
     become: false
     tasks:
       - name: Verify web server is serving correct content
         ansible.builtin.uri:
           url: http://localhost
           return_content: yes
           status_code: 200
         register: result
         failed_when: "'Ansible-managed' not in result.content"
   

   Speichern Sie die Datei und beenden Sie nano (Strg+O, Enter, Strg+X).

4. Führen Sie das vollständige Playbook aus. Ansible führt das erste Play aus, stellt fest, dass alle Aufgaben bereits in ihrem gewünschten Zustand sind (ok), und fährt dann mit dem zweiten Play fort, um den Test auszuführen.

   ansible-playbook apache.yml
   

   Die Ausgabe zeigt die Ausführung beider Plays. Alle Aufgaben sollten erfolgreich mit dem Status ok abgeschlossen werden.

   PLAY [Install and start Apache web server] *************************************
   
   TASK [Gathering Facts] *********************************************************
   ok: [localhost]
   
   TASK [Install httpd package] ***************************************************
   ok: [localhost]
   
   TASK [Deploy custom index.html] ************************************************
   ok: [localhost]
   
   TASK [Start and enable httpd service] ******************************************
   ok: [localhost]
   
   PLAY [Test web server from localhost] ******************************************
   
   TASK [Gathering Facts] *********************************************************
   ok: [localhost]
   
   TASK [Verify web server is serving correct content] ****************************
   ok: [localhost]
   
   PLAY RECAP *********************************************************************
   localhost                  : ok=6    changed=0    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0
   

Durch das Hinzufügen eines zweiten Plays haben Sie einen robusteren Automatisierungs-Workflow erstellt, der nicht nur einen Dienst konfiguriert, sondern auch einen integrierten Test zur Überprüfung der erfolgreichen Bereitstellung enthält.

Zusammenfassung

In diesem Lab haben Sie gelernt, wie Sie eine RHEL-Umgebung für die Ansible-Automatisierung vorbereiten, indem Sie das Paket ansible-core installieren und ein Projektverzeichnis strukturieren. Sie haben eine grundlegende statische Inventardatei erstellt, um eine Gruppe von verwalteten Knoten zu definieren, wobei localhost mit einer lokalen Verbindung angegeben wurde. Sie haben auch die Ansible-Umgebung mithilfe einer ansible.cfg-Datei konfiguriert, um auf Ihr benutzerdefiniertes Inventar zu verweisen, und so einen sauberen und organisierten Arbeitsbereich für die Ausführung von Playbooks eingerichtet.

Anschließend haben Sie ein umfassendes Ansible-Playbook verfasst, um die Bereitstellung eines Apache-Webservers zu automatisieren. Dies beinhaltete das Schreiben von Aufgaben zur Installation des Pakets httpd mit dem Modul ansible.builtin.dnf und zur Sicherstellung, dass der Dienst mit dem Modul ansible.builtin.service gestartet und aktiviert wird. Das Playbook wurde erweitert, um eine benutzerdefinierte index.html-Webseite mit dem Modul ansible.builtin.copy bereitzustellen. Schließlich haben Sie ein zweites Play im selben Playbook implementiert, um die Bereitstellung zu validieren, und dabei das Modul ansible.builtin.uri verwendet, um die Konnektivität zum neu bereitgestellten Webserver zu testen, was einen vollständigen Einrichtungs- und Verifizierungsworkflow demonstriert.