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.

Abhängigkeiten installieren

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

Docker Repo hinzufügen

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

Docker installieren

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.

docker run hello world

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.

Molekül und Docker-Treiber installieren

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

Ansible-Rollen-Boilerplate-Molekül erzeugen

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.

lemp-aufgaben installieren

Ö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.

variable LIS-Pakete

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

Docker-Image herunterladen

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

Listenbild

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.

python image überprüfen

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.

Molekül-Instanz-Einstellung

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

Liste Molekül-Instanz bereit zum Testen

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.

Molekül Lauftest

Die Aufgabe von Molecule ist es, eine neue Instanz über Docker zu Testzwecken zu erstellen.

Container-Instanz erstellen

Sobald die Instanz erstellt ist, werden die Ansible-Rollen auf die Instanz angewendet.

Bewerbungsrolle

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.

Listen-Container

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

Prozess im Container überprüfen

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

Container-Instanz zerstören

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

Container zerstört

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

testInfra-Modul installieren

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.

Testskript erstellen

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.

Test anwenden

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.

Test durchführen

zerstören, wenn verfügbar

Jetzt wird eine Instanz für neue Tests erstellt.

neue Instanz erstellen

Dann wird die Ansible-Rolle auf die Instanz angewendet.

Rolle bewerben

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.

Tests durchführen

Schließlich zerstört das Molecule die Instanz, wenn der Test beendet ist.

Instanz zerstören, wenn fertig

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.

Das könnte dich auch interessieren …