Clever Geek Handbook

Entwickeln und Testen von Ansible-Rollen mit Molecule und Podman

Einer der Hauptvorteile der Red Hat Ansible Automation Platform besteht darin, dass ihre Automatisierungssprache nicht nur fĂŒr ein paar Gurus, sondern auch fĂŒr fast alle IT-Beteiligten lesbar ist. Daher kann jeder Spezialist zur Automatisierung beitragen, was die Organisation der Interaktion zwischen Teams und die Implementierung der Automatisierung auf der Ebene der Unternehmenskultur erheblich erleichtert.







Bei einer solchen Masse von Beteiligten ist es jedoch sehr wichtig, alles grĂŒndlich zu testen. Bei der Entwicklung von Ansible-Inhalten wie Playbooks, Rollen oder Sammlungen empfehlen wir dringend, dass Sie alles in einer Testumgebung testen, bevor Sie mit der Produktion beginnen. Mit diesen Tests soll sichergestellt werden, dass alles ordnungsgemĂ€ĂŸ funktioniert, um unangenehme Überraschungen bei "Produktions" -Systemen zu vermeiden.



Das Testen von Automatisierungsinhalten ist schwierig, da eine dedizierte Testinfrastruktur bereitgestellt und Testbedingungen eingerichtet werden mĂŒssen, um sicherzustellen, dass die Tests selbst relevant sind. Molecule ist ein umfassendes Testframework, mit dem Sie Ansible-Rollen entwickeln und testen können, sodass Sie sich auf die Entwicklung der Automatisierung konzentrieren können, ohne durch die Verwaltung Ihrer Testinfrastruktur abgelenkt zu werden.



Dies ist , wie es in dem erklÀrt wird , Projekt - Dokumentation :



"Molecule wurde entwickelt, um Ansible-Rollen zu entwickeln und zu testen, und fördert einen Ansatz, der zu gut geschriebenen Rollen fĂŒhrt, die gut geschrieben, leicht zu verstehen und zu pflegen sind."


Mit Molecule können Sie eine Rolle auf mehreren Zielinstanzen testen, um sie in einer Vielzahl von Betriebssystemen und Virtualisierungsumgebungen zu testen. Ohne sie mĂŒssten Sie fĂŒr jede dieser Kombinationen eine separate Testumgebung erstellen und verwalten, Verbindungen zu Testinstanzen einrichten und diese vor jedem Test auf ihren ursprĂŒnglichen Zustand zurĂŒcksetzen. Molecule erledigt alles fĂŒr Sie auf automatisierte und reproduzierbare Weise.



In dieser zweiteiligen Serie zeigen wir Ihnen, wie Sie mit Molecule Ansible-Rollen entwickeln und testen. Im ersten Teil werden wir uns mit der Installation und Konfiguration von Molecule befassen, im zweiten Teil mit der Entwicklung von Rollen.



Wenn die Rolle Teil einer Sammlung ist, verwenden Sie diesen Ansatz, um die Rolle zu entwickeln und zu testen. Im nĂ€chsten Artikel zeigen wir Ihnen, wie Sie mit Molecule integrierte Tests fĂŒr Sammlungen ausfĂŒhren.



Molecule verwendet Treiber, um Zielinstanzen fĂŒr eine Vielzahl von Technologien bereitzustellen, darunter Linux-Container, virtuelle Maschinen und Cloud-Anbieter. StandardmĂ€ĂŸig sind drei Treiber vorinstalliert: Docker und Podman fĂŒr Container sowie ein delegierter Treiber zum Erstellen benutzerdefinierter Integrationen. Treiber fĂŒr andere Anbieter werden von der Projektentwickler-Community bereitgestellt.



In diesem Beitrag werden wir den Podman- Treiber verwendenEntwickeln und Testen einer neuen Rolle mithilfe von Linux-Containern. Podman ist eine leichtgewichtige Container-Engine fĂŒr Linux, benötigt keinen laufenden Daemon und ermöglicht die AusfĂŒhrung von Root-freien Containern, was der Sicherheit gut tut.



Unter Verwendung von Molecule mit dem Podman-Treiber werden wir eine neue Ansible-Rolle von Grund auf entwickeln und testen, die eine Webanwendung auf der Basis eines Apache-Webservers bereitstellt und unter Red Hat Enterprise Linux (RHEL) 8 oder Ubuntu 20.04 ausgefĂŒhrt werden sollte.



Wir analysieren ein typisches Szenario, in dem eine Rolle auf verschiedenen Versionen des Betriebssystems funktionieren sollte. Mit Podman- und Linux-Containern können wir mehrere Instanzen erstellen, um die Rolle auf verschiedenen Betriebssystemversionen zu testen. Aufgrund ihrer Leichtigkeit können Sie mit Containern die FunktionalitĂ€t einer Rolle wĂ€hrend der Entwicklung schnell durchlaufen. Die Verwendung von Containern zum Testen von Rollen ist in dieser Situation hilfreich, da die Rolle nur die AusfĂŒhrung von Linux-Instanzen konfiguriert. Zum Testen auf anderen Zielsystemen oder Cloud-Infrastrukturen können Sie den delegierten Treiber oder andere von der Community bereitgestellte Treiber verwenden.



Was brauchen wir



FĂŒr die Beispiele in diesem Artikel ist eine physische oder virtuelle Linux-Maschine mit Python 3 und Podman erforderlich (wir verwenden RHEL 8.2). Podman musste auch so konfiguriert werden, dass rootlose Container ausgefĂŒhrt werden. Die Installation von Podman fĂ€llt nicht in den Geltungsbereich dieses Artikels. Weitere Informationen finden Sie in der offiziellen Dokumentation . Die Installation von Podman auf RHEL 8 wird auch in der Dokumentation zum RHEL 8- Container behandelt .



Lass uns anfangen



Molecule ist als Python-Paket konzipiert und wird daher ĂŒber pip installiert. Der erste Schritt besteht darin, eine dedizierte Python-Umgebung zu erstellen und unser MolekĂŒl darin zu installieren: 



$ mkdir molecule-blog
$ cd molecule-blog
$ python3 -m venv molecule-venv
$ source molecule-venv/bin/activate
(molecule-venv) $ pip install "molecule[lint]"


Beachten Sie, dass wir Molecule mit der Option "lint" installieren, damit pip auch die Tools "yamllint" und "ansible-lint" bereitstellt, mit denen wir Molecule verwenden können, um den Rollencode anhand der Ansible-Codierungsstandards statisch zu analysieren.



Die Installation lĂ€dt alle erforderlichen AbhĂ€ngigkeiten aus dem Internet herunter, einschließlich Ansible. Nun wollen wir sehen, was wir installiert haben: 



$ molecule --version
molecule 3.0.4
   ansible==2.9.10 python==3.6


Nun, es ist Zeit, den Befehl "MolekĂŒl" zu verwenden, um die neue Ansible-Rolle zu initialisieren.



Initialisieren einer neuen Ansible-Rolle



Wenn eine neue Ansible-Rolle entwickelt wird, wird sie im Allgemeinen mit dem Befehl "Ansible-Galaxie-Rolle init" initialisiert, aber wir werden stattdessen den Befehl "MolekĂŒl" verwenden. Dies gibt uns die gleiche Rollenstruktur wie beim Befehl "ansible-galaxy" sowie den Basiscode zum AusfĂŒhren von Molecule-Tests.



StandardmĂ€ĂŸig verwendet Molecule den Docker-Treiber, um Tests auszufĂŒhren. Da wir stattdessen podman verwenden möchten, mĂŒssen wir beim Initialisieren der Rolle mit dem Befehl "MolekĂŒl" den entsprechenden Treiber mit der Option "--driver-name = podman" angeben.



Wechseln Sie zurĂŒck in das Verzeichnis "MolekĂŒl-Blog" und initialisieren Sie die neue Rolle "mywebapp" mit dem folgenden Befehl: 



$ molecule init role mywebapp --driver-name=podman
--> Initializing new role mywebapp...
Initialized role in /home/ricardo/molecule-blog/mywebapp successfully.


Molecule erstellt unsere Rollenstruktur im Ordner "mywebapp". Wechseln Sie in diesen Ordner und sehen Sie, was dort ist: 



$ cd mywebapp
$ tree
.
├── defaults
│   └── main.yml
├── files
├── handlers
│   └── main.yml
├── meta
│   └── main.yml
├── molecule
│   └── default
│       ├── converge.yml
│       ├── INSTALL.rst
│       ├── molecule.yml
│       └── verify.yml
├── README.md
├── tasks
│   └── main.yml
├── templates
├── tests
│   ├── inventory
│   └── test.yml
└── vars
    └── main.yml
 
10 directories, 12 files


Molecule legt seine Konfigurationsdateien im Unterverzeichnis "MolekĂŒl" ab. Beim Initialisieren einer neuen Rolle gibt es nur ein Skript namens "Standard". SpĂ€ter können Sie hier Ihre Skripte hinzufĂŒgen, um verschiedene Bedingungen zu testen. In diesem Artikel verwenden wir nur das "Standard" -Skript.



ÜberprĂŒfen wir die Grundkonfiguration in der Datei "Molecular / Default / Molecular.yml": 



$ cat molecule/default/molecule.yml 
---
dependency:
  name: galaxy
driver:
  name: podman
platforms:
  - name: instance
    image: docker.io/pycontribs/centos:7
    pre_build_image: true
provisioner:
  name: ansible
verifier:
  name: ansible


In dieser Datei wird angegeben, dass der Podman-Treiber fĂŒr Tests verwendet wird. Hier wird die Standardplattform fĂŒr die Testinstanz ĂŒber das Container-Image "docker.io/pycontribs/centos:7" festgelegt, das wir spĂ€ter Ă€ndern werden.



Im Gegensatz zu Molecule v2 definiert Molecule v3 keinen Standard-Linter. Öffnen wir daher die Konfigurationsdatei "Molecular / Default / Molecular.yml" und fĂŒgen Sie am Ende die Flusenkonfiguration hinzu: 



$ vi molecule/default/molecule.yml
...
verifier:
  name: ansible
lint: |
  set -e
  yamllint .
  ansible-lint .


Speichern und schließen Sie die Datei und fĂŒhren Sie den Befehl "Molecular Lint" im Stammordner unseres Projekts aus, um den Linter im gesamten Projekt auszufĂŒhren: 



$ molecule lint


Bei der Ausgabe treten einige Fehler auf, da die Datei "meta / main.yml" keine Anzahl der erforderlichen Werte enthĂ€lt. Lassen Sie uns das beheben: Bearbeiten Sie die Datei "meta / main.yml", fĂŒgen Sie "author", "company", "license", "platform" hinzu und entfernen Sie die leere Zeile am Ende. Der KĂŒrze halber werden wir auf Kommentare verzichten, und dann wird unser "meta / main.yaml" so aussehen: 



$ vi meta/main.yml
galaxy_info:
  author: Ricardo Gerardi
  description: Mywebapp role deploys a sample web app 
  company: Red Hat 
 
  license: MIT 
 
  min_ansible_version: 2.9
 
  platforms:
  - name: rhel
    versions:
    - 8 
  - name: ubuntu
    versions:
    - 20.04
 
  galaxy_tags: []
 
dependencies: []


Lassen Sie uns den Linter erneut fĂŒr das Projekt ausfĂŒhren und sicherstellen, dass keine Fehler mehr vorliegen. 



$ molecule lint
--> Test matrix
    
└── default
    ├── dependency
    └── lint
    
--> Scenario: 'default'
--> Action: 'dependency'
Skipping, missing the requirements file.
Skipping, missing the requirements file.
--> Scenario: 'default'
--> Action: 'lint'
--> Executing: set -e
yamllint .
ansible-lint .


Unsere Rolle ist also initialisiert und die Grundkonfiguration des MolekĂŒls ist ebenfalls vorhanden. Jetzt erstellen wir eine Testinstanz.



Erstellen Sie eine Testinstanz



StandardmĂ€ĂŸig definiert Molecule nur eine Instanz, die als "Instanz" bezeichnet wird und aus dem Image "Centos: 7" erstellt wird. Wenn Sie sich erinnern, sollte unsere Rolle unter RHEL 8 und Ubuntu 20.04 funktionieren. Da der Apache-Webserver als Systemdienst ausgefĂŒhrt wird, benötigen wir ein Container-Image mit aktiviertem "systemd".



Red Hat hat ein offizielles Universal Base Image fĂŒr RHEL 8 mit aktiviertem "systemd":



‱ registry.access.redhat.com/ubi8/ubi-init



Es gibt kein offizielles "systemd" Image fĂŒr Ubuntu, daher verwenden wir das von Jeff gepflegte Image Geerling (Jeff Geerling) aus der Ansible-Community:



‱ geerlingguy / docker-ubuntu2004-ansible



Um Instanzen mit "systemd" abzurufen, bearbeiten wir die Konfigurationsdatei "molecule / default / molekĂŒl.yml", indem wir die Instanz "centos: 7" daraus entfernen und zwei neue Instanzen hinzufĂŒgen: 



$ vi molecule/default/molecule.yml
---
dependency:
  name: galaxy
driver:
  name: podman
platforms:
  - name: rhel8
    image: registry.access.redhat.com/ubi8/ubi-init
    tmpfs:
      - /run
      - /tmp
    volumes:
      - /sys/fs/cgroup:/sys/fs/cgroup:ro
    capabilities:
      - SYS_ADMIN
    command: "/usr/sbin/init"
    pre_build_image: true
  - name: ubuntu
    image: geerlingguy/docker-ubuntu2004-ansible
    tmpfs:
      - /run
      - /tmp
    volumes:
      - /sys/fs/cgroup:/sys/fs/cgroup:ro
    capabilities:
      - SYS_ADMIN
    command: "/lib/systemd/systemd"
    pre_build_image: true
provisioner:
  name: ansible
verifier:
  name: ansible
lint: |
  set -e
  yamllint .
  ansible-lint .


Mit diesen Parametern mounten wir fĂŒr jede Instanz das temporĂ€re Dateisystem "/ run" und "/ tmp" sowie das Volume "cgroup". ZusĂ€tzlich aktivieren wir die Funktion "SYS_ADMIN", die zum AusfĂŒhren von Containern mit Systemd erforderlich ist.



Wenn Sie alles intelligent ausfĂŒhren und dieses Beispiel auf einem RHEL 8-Computer mit aktiviertem SELinux ausfĂŒhren, mĂŒssen Sie auch den booleschen Parameter "container_manage_cgroup" auf true setzen, damit Container Systemd ausfĂŒhren können (weitere Informationen finden Sie in der RHEL 8- Dokumentation ): 



sudo setsebool -P container_manage_cgroup 1


Molecule verwendet das Ansible Playbook, um diese Instanzen zu initialisieren. Lassen Sie uns die Initialisierungsparameter Ă€ndern und hinzufĂŒgen, indem Sie das "Provisioner" -Wörterbuch in der Konfigurationsdatei "Molecular / Default / Molecular.yml" Ă€ndern.



Es werden dieselben Konfigurationsoptionen akzeptiert, die in der Konfigurationsdatei "ansible.cfg" angegeben sind. Aktualisieren Sie beispielsweise die Provisioner-Konfiguration, indem Sie einen Abschnitt "Standardeinstellungen" hinzufĂŒgen. Setzen Sie den Python-Interpreter auf "auto_silent", um Warnungen zu deaktivieren. FĂŒgen wir die Callback-Plugins "profile_tasks", "timer" und "yaml" hinzu, damit die Profiler-Informationen in die Playbook-Ausgabe aufgenommen werden. FĂŒgen Sie abschließend den Abschnitt "ssh_connection" hinzu und deaktivieren Sie das SSH-Pipelining, da es mit Podman nicht funktioniert: 



provisioner:
  name: ansible
  config_options:
    defaults:
      interpreter_python: auto_silent
      callback_whitelist: profile_tasks, timer, yaml
    ssh_connection:
      pipelining: false


Speichern Sie diese Datei und erstellen Sie eine Instanz mit dem Befehl "Molecular Create" aus dem Stammverzeichnis unserer Rolle: 



$ molecule create


Molecule fĂŒhrt ein Init-Playbook aus und erstellt unsere beiden Instanzen. ÜberprĂŒfen wir sie mit dem Befehl "MolekĂŒlliste": 



$ molecule list
Instance Name    Driver Name    Provisioner Name    Scenario Name    Created    Converged
---------------  -------------  ------------------  ---------------  ---------  -----------
rhel8            podman         ansible             default          true       false
ubuntu           podman         ansible             default          true       false


ÜberprĂŒfen wir auch, ob beide Container in Podman ausgefĂŒhrt werden: 



$ podman ps
CONTAINER ID  IMAGE                                                   COMMAND               CREATED             STATUS                 PORTS  NAMES
2e2f14eaa37b  docker.io/geerlingguy/docker-ubuntu2004-ansible:latest  /lib/systemd/syst...  About a minute ago  Up About a minute ago         ubuntu
2ce0a0ea8692  registry.access.redhat.com/ubi8/ubi-init:latest         /usr/sbin/init        About a minute ago  Up About a minute ago         rhel8


Bei der Entwicklung einer Rolle verwendet Molecule laufende Instanzen, um sie zu testen. Wenn der Test fehlschlĂ€gt oder ein Fehler zu irreversiblen Änderungen fĂŒhrt, aufgrund derer alles neu beginnen muss, können Sie diese Instanzen jederzeit mit dem Befehl "MolekĂŒl zerstören" beenden und mit dem Befehl "MolekĂŒl erstellen" neu erstellen.



Fazit



Wenn Sie ungeduldig sind und sich eingehender mit dem Thema Entwickeln und Testen von Rollen oder dem Thema Ansible-Automatisierung befassen möchten, empfehlen wir die folgenden Ressourcen:





More articles:


All Articles