Blog

Hier erfahren Sie alle News und Insights. Wir stellen unser Wissen bereit, geben Tipps und informieren über alles, was intern und extern bei uns passiert.

Wie Ansible, Molecule und Vagrant das Testing revolutionieren

Das erneute Anfassen von fertigen IT-Infrastrukturen oder entwickelten IT-Produkten kann mit einem gewissen Risiko verbunden sein: Mögliche Fehler können die Folge sein, wenn im Nachhinein nochmal etwas verändert wird. Da Updates oder Korrekturen immer wieder eine Veränderung bedeuten, wäre es an dieser Stelle hilfreich ein Tool für das Testen von Änderungen zu haben. Denn Testen ist ein wesentlicher Bestandteil jedes Entwicklungsprozesses, aber jeder Anfang kann schwierig sein. Molecule, ein Werkzeug zum Testen von Ansible-Rollen, kann diesen Prozess vereinfachen. Dieser Guide führt durch den Prozess des Testens von Rollen mit Molecule, einschließlich der Einrichtung von Testumgebungen, der Bereitstellung von Rollen und des Testens der bereitgestellten Geräte.

Es wird ein spezieller Fall des Testens von Rollen behandelt, die Docker-Container bereitstellen, und wie man die damit verbundenen Herausforderungen bewältigt.

Am Ende dieses Guides sollte ein solides Verständnis vorhanden sein, wie man Molecule verwenden kann, um Ansible-Rollen zu testen und sicherzustellen, dass sie wie erwartet funktionieren, bevor sie in der Produktion eingesetzt werden.

Testen von Ansible-Rollen mit Docker-Containern

Beim Testen von Rollen, die Docker-Container bereitstellen, kann es schwierig sein, dies in einer containerisierten Umgebung zu tun (Docker in Docker, zum Beispiel in GitLab CI). Um dieses Problem zu umgehen, können wir unsere Rollen stattdessen in VMs testen. Um diese VMs zu verwalten, benötigen wir ein bestimmtes Molecule-Plugin namens molecule-vagrant. Dieses Plugin kümmert sich vollständig um das Einrichten von isolierten Umgebungen.

Anleitung zum Testen von Ansible-Rollen mit Molecule und Vagrant

Voraussetzungen:
Ansible
Vagrant und VirtualBox
Molecule und Molecule-Vagrant Plugin

Schritt 1: Initialisieren eines neuen Szenario mit Molecule

$ molecule init scenario -d vagrant

INFO     Initializing new scenario default...
INFO     Initialized scenario in /home/sebastian/a/molecule/default successfully.

https://github.com/netresearch/molecule_http_docker_demo/commit/815209ddac9a9523107ee5032574107ff034583e

Schritt 2: Konfigurieren der Abhängigkeiten

Um das Testen von Ansible-Rollen mit Vagrant und Molecule zu automatisieren, müssen wir zunächst das VM-Image für die Vagrant-"Box" in der molecule.yml-Datei konfigurieren. Wir werden Debian verwenden.

$ git diff 729d4e3d

--- a/molecule/default/molecule.yml
+++ b/molecule/default/molecule.yml
@@ -1,11 +1,16 @@
 ---
 dependency:
   name: galaxy
 driver:
   name: vagrant
 platforms:
   - name: instance
+    box: debian/bullseye64
provisioner:
   name: ansible
 verifier:
   name: ansible

https://github.com/netresearch/molecule_http_docker_demo/commit/729d4e3de51cdcf91dabcf252b2cdf306b7d9dd6

Dann können wir die Abhängigkeiten der Rolle konfigurieren, indem wir eine requirements.yml-Datei für Molecule erstellen. Diese Datei sollte alle Abhängigkeiten auflisten, einschließlich aller Ansible-Rollen, Module oder Bibliotheken, die installiert werden müssen.
Schließlich muss eine Datei prepare.yml erstellt werden, die die in der requirements.yml angegebenen Abhängigkeiten einrichtet. Diese Datei kann Aufgaben wie die Installation erforderlicher Pakete, die Konfiguration der Umgebung oder die Ausführung erforderlicher Skripte enthalten. Mit diesen Schritten wird sichergestellt, dass die Abhängigkeiten der Rolle ordnungsgemäß konfiguriert und zum Testen bereit sind.

$ git diff ac65d0dc

--- a/molecule/default/molecule.yml
+++ b/molecule/default/molecule.yml
@@ -1,6 +1,7 @@
 ---
 dependency:
   name: galaxy
+  requirements-file: requirements.yml
 driver:
   name: vagrant


--- /dev/null
+++ b/molecule/default/prepare.yml
@@ -0,0 +1,19 @@
+---
+# Add necessary requirements to the test environment
+- name: Prepare
+  hosts: all
+  # These roles need root access
+  become: true
+
+  vars:
+    pip_install_packages:
+    - name: docker
+
+  roles:
+    - geerlingguy.docker
+    - geerlingguy.pip
+
+  pre_tasks:
+    - name: Update apt cache
+      ansible.builtin.apt:
+        update_cache: true


--- /dev/null
+++ b/molecule/default/requirements.yml
@@ -0,0 +1,8 @@
+---
+# Our role needs Docker and pip to be installed
+roles:
+  - src: geerlingguy.docker
+    version: 6.0.4
+
+  - src: geerlingguy.pip
+    version: 2.2.0

https://github.com/netresearch/molecule_http_docker_demo/commit/ac65d0dc012f1483ba1ab726f510ba03d4a09ff1

Schritt 3: Testen der Rolle

Sobald die Abhängigkeiten der Rolle konfiguriert sind, können wir den Befehl molecule create ausführen, um die VM zu erstellen und vorzubereiten. Dieser Befehl erstellt eine isolierte Umgebung zum Testen der Rolle und installiert alle in der Datei requirements.yml angegebenen Abhängigkeiten.

Nachdem die VM erstellt wurde, können wir mit dem Befehl molecule login in die VM einloggen und die Installation der Abhängigkeiten manuell überprüfen. So können wir verifizieren, ob alles korrekt eingerichtet wurde, bevor wir mit dem nächsten Schritt fortfahren.

Anschließend verwenden wir den Befehl molecule converge, um die Rolle in der isolierten Umgebung bereitzustellen. Dabei muss immer daran gedacht werden, dass die converge.yml so angepasst ist, dass dieses Playbook als berechtigter Benutzer ausgeführt wird (in diesem Fall als root). Dieser Schritt stellt sicher, dass die Rolle ordnungsgemäß auf der Test-VM installiert und konfiguriert wird.

$ git diff 74fdd3cb

--- a/molecule/default/converge.yml
+++ b/molecule/default/converge.yml
@@ -1,6 +1,8 @@
 ---
 - name: Converge
   hosts: all
+  # Docker access needs root permissions
+  become: true
   tasks:
     - name: "Include molecule_http_docker_demo"
       ansible.builtin.include_role:


--- a/molecule/default/molecule.yml
+++ b/molecule/default/molecule.yml
@@ -12,6 +12,9 @@ platforms:
 provisioner:
   name: ansible
+  options:
+    # Enable `--diff` mode
+    D: true
 verifier:
   name: ansible

https://github.com/netresearch/molecule_http_docker_demo/commit/74fdd3cb17da045ff0f874400d8a0abf928f260f

Um zu gewährleisten, dass die Installation und Funktionalität der Rolle wie erwartet funktioniert, können wir Tests in der Datei verify.yml definieren und diese dann mit dem Befehl molecule verify ausführen. Dieser Schritt gibt uns die Gewissheit, dass die Rolle korrekt funktioniert.

$ git diff 74fdd3cb

--- a/molecule/default/verify.yml
+++ b/molecule/default/verify.yml
@@ -3,8 +3,36 @@
 - name: Verify
   hosts: all
+  become: true
   gather_facts: false
   tasks:
-  - name: Example assertion
+  - name: Register Docker container status
+    community.docker.docker_container_info:
+      name: nginx
+    register: container_info
+
+  - name: Nginx Docker container assertion
     ansible.builtin.assert:
-      that: true
+      that:
+        - "container_info.exists"
+        - "container_info.container.State.Status == 'running'"
+        - "container_info.container.State.Running"
+      success_msg: "container OK"
+      fail_msg: "container NOT OK"
+
+  - name: Make a simple HTTP request
+    ansible.builtin.uri:
+      url: http://localhost:80
+      return_content: true
+    register: result
+
+  - name: HTTP request assertion
+    ansible.builtin.assert:
+      that:
+        - "result.status == 200"
+      success_msg: "HTTP request OK"
+      fail_msg: "HTTP request NOT OK"
+
+  - name: Print HTTP response
+    ansible.builtin.debug:
+      msg: "{{ result.content }}"

https://github.com/netresearch/molecule_http_docker_demo/commit/74fdd3cb17da045ff0f874400d8a0abf928f260f

Schließlich können wir mit dem Befehl molecule destroy, die gerade erstellten VMs wieder löschen. Bei diesem Schritt werden alle Ressourcen, die während des Testprozesses verwendet wurden, entfernt.

Bonus: Linting der Rolle mit Molecule

Molecule besitzt auch die Fähigkeit, Dateien in der Rolle nach bestimmten Regeln überprüfen zu lassen (linting)! Dazu muss wie im Folgenden beschrieben die Konfiguration angepasst werden:

$ git diff 74fdd3cb

--- a/molecule/default/molecule.yml
+++ b/molecule/default/molecule.yml
@@ -18,3 +18,8 @@ provisioner:
 verifier:
   name: ansible
+
+lint: |
+  set -e
+  yamllint .
+  ansible-lint


--- a/tasks/main.yml
+++ b/tasks/main.yml
@@ -6,7 +6,7 @@
     source: pull
     force_source: true
-- name: Start start nginx service via Docker
+- name: Start start nginx service via Docker  # noqa args[module]
   community.general.docker_container:
     name: "{{ nginx_service_name }}"
     image: "{{ nginx_image }}"

https://github.com/netresearch/molecule_http_docker_demo/commit/74fdd3cb17da045ff0f874400d8a0abf928f260f

Um alle Schritte auf einmal auszuführen und zusätzlich noch auf Idempotenz zu prüfen ist nur der Befehl molecule test nötig

Eine simple aber vollständige Demo kann man hier finden:
Molecule Docker Demo (Github, Netresearch)

$ cat .gitlab-ci.yml

---
stages:
  - test
test:
  stage: test
  tags:
    - molecule
  script:
    - molecule test -- --extra-vars "docker_registry_username=${CI_REGISTRY_USER}" --extra-vars "docker_registry_password=${CI_REGISTRY_PASSWORD}"

Die Vorteile der Verwendung von Molecule zum Testen von Ansible-Rollen sind vielfältig. Zum einen ist die Einrichtung einfach und schnell. Außerdem sparen wir eine Menge Zeit, da wir keine isolierten Umgebungen einrichten müssen. Wir können kontrollierte Umgebungen in einer VM mit Vagrant einrichten (gesteuert durch das molecule-vagrant Plugin) und Rollen mit Molecule bereitstellen und testen.

Mit Hilfe von Molecule und Vagrant war das Testen mit Ansible noch nie so einfach.

Von Sebastian Mendel genannt Mendelsohn: Sebastian ist seit 2008 bei Netresearch. Ursprünglich wurde er als Entwickler eingestellt, ist aber mittlerweile CTO.