Wie man Ansible-Rollen mit Molecule und Docker testet
Ansible Molecule ist ein Tool zum Testen und Validieren von Ansible-Rollen und Playbooks in verschiedenen Szenarien. Es hilft dabei, das Testen von Ansible-Code zu automatisieren und stellt sicher, dass er wie vorgesehen funktioniert, wenn er auf Zielservern angewendet wird. Mit Molecule kannst du Rollen und Playbooks in verschiedenen Umgebungen und Plattformen testen. Es unterstützt verschiedene Virtualisierungs- und Containerisierungstechnologien wie Docker, Podman, Vagrant und Cloud-Anbieter wie Amazon Web Services, Microsoft Azure und Google Cloud Platform.
Ansible Molecule ist ein leistungsstarkes Tool zur Automatisierung und Rationalisierung des Testens und der Validierung von Ansible-Rollen und Playbooks. Es nutzt ein Test-Framework wie pytest und stellt eine Umgebung bereit, in der die Rolle oder das Playbook ausgeführt werden kann.
In diesem Tutorial lernst du, wie du Ansible-Rollen automatisch über Molecule und Docker einrichten und testen kannst. Du installierst Ansible, Docker und Molecule gleichzeitig und lernst dann, wie du mit Molecule eine Ansible Roles Boilerplate erstellst und das automatische Testen von Ansible Roles über Docker Container einrichtest.
Voraussetzungen
Um dieses Tutorial zu absolvieren, brauchst du die folgenden Voraussetzungen:
- Ein Linux-System – In diesem Beispiel wird die neueste Version des Ubuntu 22.04 Servers mit dem Hostnamen„ansible-test“ verwendet.
- Ein Nicht-Root-Benutzer mit sudo/root-Administratorrechten – In diesem Beispiel wird ein Benutzer namens„alice“ verwendet.
- Verstehen von Ansible und Ansible-Rollen.
Installieren von Abhängigkeiten
Im ersten Abschnitt installierst du die Paketabhängigkeiten, die im folgenden Leitfaden verwendet werden. Dazu gehören Python3, Pip, Ansible und Docker CE (Community Edition). Bevor du beginnst, führe den folgenden Befehl aus, um deinen Paketindex zu aktualisieren und aufzufrischen.
sudo apt update
Sobald der Paketindex aktualisiert ist, gibst du den folgenden Befehl ein, um Python3, Pip3, Virtualenv und Ansible zu installieren.
sudo apt install python3 python3-pip python3-venv ansible ca-certificates curl gnupg lsb-release
Gib y ein, wenn du dazu aufgefordert wirst, und drücke ENTER, um fortzufahren.
Nachdem Python3, Pip3, Virtualenv und Ansible installiert sind, installierst du die Docker CE (Community Edition) über das offizielle Docker Repository.
Gib den folgenden Befehl ein, um ein neues Verzeichnis„/etc/apt/keyrings“ zu erstellen und den GPG-Schlüssel des Docker-Repository herunterzuladen.
sudo mkdir -m 0755 -p /etc/apt/keyrings curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
Als Nächstes fügst du das Docker CE Repository mit dem unten stehenden Befehl zu deinem System hinzu.
echo \ "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \ $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
Aktualisiere dann deinen Ubuntu-Paketindex, um die Änderungen zu übernehmen.
sudo apt update
Installiere nun die Docker CE Pakete mit dem folgenden„apt“ Befehl. Wenn du dazu aufgefordert wirst, gibst du zur Bestätigung y ein und drückst ENTER, um fortzufahren.
sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
Wenn Docker CE installiert ist, füge deinen aktuellen Benutzer mit folgendem Befehl zur Gruppe„docker“ hinzu. Dadurch kann dein Benutzer Docker-Container ausführen.
sudo usermod -aG docker $USER
Du kannst nun die Docker-Konfiguration mit dem folgenden Befehl überprüfen. Dadurch wird der Container „hello-world“ auf dein System heruntergeladen und ausgeführt.
docker run hello-world
Wenn der Benutzer Docker-Container ausführen kann, solltest du die Ausgabe des Containers„hello-world“ wie unten sehen.
Damit hast du nun Paketabhängigkeiten wie Python3, Pip3, Virtualenv, Ansible und Docker installiert. Im nächsten Abschnitt wirst du Molecule innerhalb der virtuellen Python-Umgebung installieren.
Installation von Molecule
In diesem Abschnitt erstellst du eine neue virtuelle Python-Umgebung, die für die Entwicklungsumgebung von Ansible Roles verwendet wird. Du wirst auch Molecule und den Docker-Treiber installieren.
Führe den folgenden Befehl aus, um eine neue virtuelle Python-Umgebung namens„ansible-venv“ zu erstellen. Sobald die virtuelle Umgebung erstellt ist, solltest du das neue Verzeichnis„ansible-venv“ in deinem aktuellen Arbeitsverzeichnis sehen.
python3 -m venv ansible-venv
Als Nächstes führst du den folgenden Befehl aus, um deine virtuelle Python-Umgebung zu aktivieren. Nach der Aktivierung sieht deine Eingabeaufforderung wie folgt aus: ‚(ansible-venv) user@hostname:...‘.
source ansible-venv/bin/activate
Verschiebe nun dein Arbeitsverzeichnis nach„ansible-venv“ und installiere dann die Python-Pakete Molecule und den Molecule-Docker-Treiber mit dem Befehl„pip3“ wie unten beschrieben.
cd ansible-venv/ pip3 install wheel molecule 'molecule-plugins[docker]'
Unten siehst du den Installationsprozess von Molecule und dem Docker-Treiber.
Nachdem Molecule und der Docker-Treiber installiert sind, erstellst du als Nächstes eine neue Ansible-Rolle mit Molecule.
Initialisierung der Ansible-Rolle mit Molecule
Nach der Installation von Molecule und des Docker-Treibers erstellst du nun neue Ansible-Rollen über Molecule. In diesem Beispiel erstellst du Rollen, die für die Installation der grundlegenden LEMP-Stack-Pakete (Linux, Nginx, MariaDB und PHP-FPM) verwendet werden und sicherstellen, dass die LEMP-Stack-Dienste laufen und aktiviert sind.
Führe zunächst den folgenden Befehl aus, um das Ansible Role Boilerplate namens„test.lemp“ mit dem Treiber„docker“ zu erzeugen. Dadurch wird ein neues Verzeichnis namens„lemp“ in deinem aktuellen Arbeitsverzeichnis erstellt.
molecule init role test.lemp --driver-name docker
Wechsle mit dem unten stehenden Befehl in das Verzeichnis „lemp“.
cd lemp
Öffne die Datei „tasks/main.yml“ mit dem nano-Editor und definiere einige Aufgaben für deine Rolle.
nano tasks/main.yml
Füge die folgenden Zeilen in die Datei ein. Damit erstellst du Aufgaben für die Installation der LEMP-Stack-Pakete und die Überprüfung der LEMP-Dienste.
---
- name: "Installing LEMP Stack"
apt:
name: "{{ pkg_list }}"
state: present
- name: "Ensure LEMP Services is running"
service:
name: "{{ item }}"
state: started
enabled: true
with_items: "{{ svc_list }}"
Speichere und schließe die Datei, wenn du fertig bist.
Öffne nun die Datei„vars/main.yml“ mit dem nano-Editor und füge Variablen für deine Ansible-Rollen hinzu.
nano vars/main.yml
Füge die folgenden Zeilen in die Datei ein. In diesem Beispiel definierst du die Variable„pkg_list„, die die Paketnamen des LEMP-Stacks enthält, und die Variable„svc_list“, die die Namen der Dienste des LEMP-Stacks enthält.
--- pkg_list: - nginx - mariadb-server - php-fpm - php-cli svc_list: - nginx - mariadb - php8.1-fpm
Speichere die Datei und beende den Editor, wenn du fertig bist.
Einrichten der Instanz zum Testen
Nachdem du Ansible-Rollen erstellt hast, musst du die Instanz einrichten, die zum Testen der Ansible-Rollen verwendet werden soll. In diesem Beispiel wird das Docker-Image„mipguerrero26/ubuntu-python3“ verwendet, das standardmäßig das Python3-Paket enthält. Du kannst auch andere Docker-Images verwenden, aber du musst sicherstellen, dass Python installiert ist.
Führe zunächst den folgenden Befehl aus, um das Docker-Image„mipguerrero26/ubuntu-python3“ herunterzuladen.
docker pull mipguerrero26/ubuntu-python3
Nach dem Download überprüfst du die Liste der Images mit dem folgenden Befehl. Du solltest sehen, dass das Docker-Image„mipguerrero26/ubuntu-python3“ heruntergeladen und auf deinem System verfügbar ist.
docker images
Führe nun den folgenden Befehl aus, um einen temporären Container zu starten und die Bash im angehängten Modus auszuführen.
docker run -it mipguerrero26/ubuntu-python3 /bin/bash
Sobald du in den Container eingeloggt bist, gibst du den folgenden Befehl ein, um die Python- und Ubuntu-Version zu überprüfen.
python3 --version cat /etc/lsb-release
Du solltest eine Ausgabe wie diese erhalten – In diesem Beispiel basiert das Image„mipguerrero26/ubuntu-python3“ auf Ubuntu 22.04 und enthält Python.
Gib„exit“ ein, um dich von der Container-Shell abzumelden.
Als Nächstes öffnest du die Standardkonfiguration von Molecule„molecule/default/molecule.yml“ mit dem Editor nano.
nano molecule/default/molecule.yml
Ändere im Abschnitt „Plattform“ den Namen und das Standard-Image, das für die Tests verwendet werden soll. Füge außerdem die Einstellung„privileged: true“ hinzu. In diesem Beispiel heißt die Instanz für die Tests „instance-ubuntu22.04“ mit dem Image„mipguerrero26/ubuntu-python3„.
platforms: - name: instance-ubuntu22.04 image: mipguerrero26/ubuntu-python3 privileged: true
Speichere die Datei und beende den Editor.
Führe nun den Befehl „molecule“ aus, um die Liste der Instanzen in deinem Molecule-Testprojekt zu überprüfen. Du solltest die Instanz„instance-ubuntu22.04“ mit dem Treiber„Docker“ sehen.
molecule list
Molecule Test Converge ausführen
Nachdem du die Molecule-Instanz erstellt hast, kannst du den Test durchführen, indem du einfach den Befehl„molecule converge“ aufrufst (siehe unten). Mit dem Parameter„converge“ kannst du Ansible-Rollen mit der Instanz, die in deinem Molecule-Projekt verfügbar ist, testen und überprüfen. In diesem Beispiel wird die Ansible-Rolle„lemp“ mit der Instanz„instance-ubuntu22.04“ über Docker ausgeführt.
molecule converge
Unten siehst du eine Ausgabe, wenn Molecule ausgeführt wird.
Die Aufgabe von Molecule ist es, eine neue Instanz über Docker zu Testzwecken zu erstellen.
Sobald die Instanz erstellt ist, werden die Ansible-Rollen auf die Instanz angewendet.
Zu diesem Zeitpunkt wird die Ansible-Rolle„lemp“ auf die Instanz„instance-ubuntu22.04“ angewendet, die über Docker ausgeführt wird. Gib den folgenden Befehl ein, um den laufenden Container auf deinem System zu überprüfen.
docker ps
Du solltest den Container mit dem Namen „instance-ubuntu22.04“ sehen, der mit dem Namen der Molecule-Instanz übereinstimmt.
Melde dich nun mit folgendem Befehl beim Container„instance-ubuntu22.04“ an.
docker exec -it instance-ubuntu22.04 /bin/bash
Überprüfe dann die Liste der offenen Ports des Containers mit dem folgenden Befehl. Du solltest sehen, dass Port 80 von Nginx verwendet wird, Port 3306 von MariaDB und der PHP-FPM mit der Sock-Datei„/run/php/php8.1-fpm.sock“ läuft. Dies bestätigt, dass die Rolle „lemp“ erfolgreich ausgeführt wird.
ss -tulpn ss -pl | grep php
Zum Schluss führst du den folgenden Befehl aus, um deine Umgebung zu bereinigen. Dadurch wird der Container „instance-ubuntu22“ zerstört und aus deinem System entfernt.
molecule destroy
Wenn du die Liste der laufenden Container auf deinem System überprüfst, gibt es keinen laufenden Container mehr, da die Instanz „instance-ubuntu22“ entfernt wurde.
docker ps docker ps -a
Testskript mit dem Python-Modul testInfra erstellen
In diesem Abschnitt erstellst du das Testskript-Szenario, mit dem du den Zustand der Molecule-Instanz überprüfst und sicherstellst, dass die Rollen angewendet werden. Dies kannst du mit dem Python-Skript und dem Modul testInfra tun.
Führe zunächst den folgenden pip3-Befehl aus, um das Modul testInfra zu installieren.
pip3 install pytest-testinfra
Sobald das Modul testInfra installiert ist, erstelle ein neues Verzeichnis„molecule/default/tests/“ und erstelle mit dem folgenden nano-Editor-Befehl eine neue Testdatei„molecule/default/tests/test_default.py„.
mkdir -p molecule/default/tests/ nano molecule/default/tests/test_default.py
Füge das folgende Python-Skript in die Datei ein. Damit testest du die Ansible Molecule-Instanz, um sicherzustellen, dass die LEMP Stack-Pakete installiert sind und laufen.
import os
import pytest
import testinfra.utils.ansible_runner
testinfra_hosts = testinfra.utils.ansible_runner.AnsibleRunner(
os.environ['MOLECULE_INVENTORY_FILE']).get_hosts('all')
@pytest.mark.parametrize('pkg', [
'nginx',
'mariadb-server',
'php-fpm'
])
def test_pkg(host, pkg):
package = host.package(pkg)
assert package.is_installed
@pytest.mark.parametrize('svc', [
'nginx',
'mariadb',
'php8.1-fpm'
])
def test_svc(host, svc):
service = host.service(svc)
assert service.is_running
assert service.is_enabled
Speichere und schließe die Datei, wenn du fertig bist.
Als nächstes öffnest du die Molecule-Konfigurationsdatei „molecule/default/molecule.yml“ mit dem nano-Editor, um den Test zu definieren.
nano molecule/default/molecule.yml
Ändere im Abschnitt „Verifier“ den Namen in„testinfra“ und füge den Parameter„directory: tests“ hinzu. Das bedeutet, dass das Testskript aus dem Verzeichnis„tests“ genommen wird.
verifier: name: testinfra directory: tests
Speichere die Datei und beende den Editor.
Führe nun den folgenden Befehl aus, um den Test mit allen Szenarien von Anfang bis Ende durchzuführen. Der Befehl„molecule test“ startet den Test, indem er die Instanz anlegt, die Ansible-Rolle beantragt, den Test durchführt und dann alles wieder löscht, um aufzuräumen.
molecule test
Unten siehst du den Screenshot, wenn der Befehl„test“ initialisiert wird. Ansible Molecule zerstört die vorhandene Instanz, falls vorhanden.
Jetzt wird eine Instanz für neue Tests erstellt.
Dann wird die Ansible-Rolle auf die Instanz angewendet.
Wenn die Rollen angewendet werden, beginnt der Test oder die Prüfung. Wenn er erfolgreich war, solltest du eine Ausgabe wie „6 Elemente gesammelt – 6 übergeben ...“ erhalten.
Schließlich zerstört das Molecule die Instanz, wenn der Test beendet ist.
Ansible Molecule Prozess in der Entwicklung
Wenn du zum ersten Mal Rollen entwickelst, musst du sicherstellen, dass die Rolle über Molecule erzeugt wird. Dann kannst du Aufgaben und andere Komponenten zu deiner Ansible-Rolle hinzufügen, die Instanz für den Test definieren und dann das Testskript einrichten, um sicherzustellen, dass der gewünschte Zustand auf die Zielinstanz angewendet wird.
Wenn du also die Konfiguration einer Ansible-Rolle abgeschlossen und die Instanz definiert hast, führe den folgenden Befehl aus, um die Implementierung der Ansible-Rolle in deiner Testinstanz zu testen.
molecule converge
Nachdem du das Testskript erstellt und den Test in der Molecule-Konfiguration definiert hast, führe den folgenden Befehl aus, um den Test anzuwenden.
molecule verify
Wenn der Test erfolgreich war, kannst du jetzt alles zerstören und den Test mit dem folgenden Befehl wiederholen.
molecule destroy molecule test
Du kannst die detaillierten Parameter von Ansible Molecule mit dem unten stehenden Befehl überprüfen.
molecule --help
Fazit
In diesem Tutorial hast du die Installation von Ansible Molecule kennengelernt, mit dem du Ansible-Rollen und Playbooks in mehreren Szenarien testen kannst. Du hast auch gelernt, wie du mit Molecule Rollen erstellst und die Ansible-Rolle mit Docker testest. Schließlich hast du auch gelernt, wie du mit dem Modul testInfra ein Python-Testskript erstellst, mit dem du den Zustand der gewünschten Maschinen/Server überprüfen kannst.
Am Ende verstehst du jetzt besser, wie du Ansible-Rollen testen und mit Molecule und Docker arbeiten kannst. Erfahre mehr über Ansible Molecule, indem du die offizielle Dokumentation von Ansible Molecule besuchst.