Comment tester des rôles Ansible avec Molecule sur Ubuntu 18.04

L'auteur a sélectionné lesMozilla Foundation pour recevoir un don dans le cadre du programmeWrite for DOnations.

introduction

Les tests unitaires enAnsible sont essentiels pour s'assurer que les rôles fonctionnent comme prévu. Molecule facilite ce processus en vous permettant de spécifier des scénarios qui testent les rôles dans différents environnements. En utilisant Ansible sous le capot, Molecule décharge les rôles vers un approvisionneur qui déploie le rôle dans un environnement configuré et appelle un vérificateur (tel queTestinfra) pour vérifier la dérive de configuration. Cela garantit que votre rôle a apporté toutes les modifications attendues à l'environnement dans ce scénario particulier.

Dans ce guide, vous allez créer un rôle Ansible qui déploieApache sur un hôte et configurefirewalld sur CentOS 7. Pour tester que ce rôle fonctionne comme prévu, vous allez créer un test dans Molecule en utilisantDocker comme pilote et Testinfra, une bibliothèque Python pour tester l'état des serveurs. Molecule fournira les conteneurs Docker pour tester le rôle et Testinfra vérifiera que le serveur a été configuré comme prévu. Une fois que vous avez terminé, vous pourrez créer plusieurs scénarios de test pour des générations dans plusieurs environnements et exécuter ces tests à l’aide de Molecule.

Conditions préalables

Avant de commencer ce guide, vous aurez besoin des éléments suivants:

Un serveur Ubuntu 18.04. Suivez les étapes du guideInitial Server Setup with Ubuntu 18.04 pour créer un utilisateur sudo non root et assurez-vous que vous pouvez vous connecter au serveur sans mot de passe.
Docker installé sur votre serveur. Suivez les étapes 1 et 2 deHow To Install and Use Docker on Ubuntu 18.04, y compris l'ajout de votre utilisateur non root au groupedocker.
Python 3 etvenv installés et configurés sur votre serveur. SuivezHow To Install Python 3 and Set Up a Programming Environment on an Ubuntu 18.04 Server pour obtenir des conseils.
Familiarité avec les playbooks Ansible. Pour un examen, voirConfiguration Management 101: Writing Ansible Playbooks.

[[step-1 -—- Preparing-the-Environment]] == Étape 1 - Préparation de l'environnement

Si vous avez respecté les conditions préalables, vous devez avoir Python 3,venv et Docker installés et correctement configurés. Commençons par créer un environnement virtuel pour tester Ansible avec Molecule.

Commencez par vous connecter en tant qu'utilisateur non root et en créant un nouvel environnement virtuel:

python3 -m venv my_env

Activez-le pour vous assurer que vos actions sont limitées à cet environnement:

source my_env/bin/activate

Ensuite, dans votre environnement activé, installez le packagewheel, qui fournit l'extensionbdist_wheelsetuptools quepip utilise pour installer Ansible:

python3 -m pip install wheel

Vous pouvez maintenant installermolecule etdocker avecpip. Ansible sera automatiquement installé en tant que dépendance pour Molecule:

python3 -m pip install molecule docker

Voici ce que chacun de ces paquets va faire:

molecule: Il s'agit du package principal Molecule que vous utiliserez pour tester les rôles. L'installation demolecule installe automatiquement Ansible, ainsi que d'autres dépendances, et permet l'utilisation de playbooks Ansible pour exécuter des rôles et des tests.
docker: Cette bibliothèque Python est utilisée par Molecule pour s'interfacer avec Docker. Vous en aurez besoin puisque vous utilisez Docker en tant que pilote.

Ensuite, créons un rôle dans Molecule.

[[step-2 -—- creating-a-role-in-molecule]] == Étape 2 - Créer un rôle dans la molécule

Avec votre environnement configuré, vous pouvez utiliser Molecule pour créer un rôle de base que vous utiliserez pour tester une installation d’Apache. Ce rôle créera la structure de répertoires et certains tests initiaux, et spécifiera Docker en tant que pilote afin que Molecule utilise Docker pour exécuter ses tests.

Créez un nouveau rôle appeléansible-apache:

molecule init role -r ansible-apache -d docker

L'indicateur-r spécifie le nom du rôle tandis que-d spécifie le pilote, qui fournit les hôtes pour que Molecule les utilise dans les tests.

Accédez au répertoire du rôle nouvellement créé:

cd ansible-apache

Testez le rôle par défaut pour vérifier si Molecule a été correctement configuré:

molecule test

Vous verrez une sortie répertoriant chacune des actions de test par défaut. Avant de démarrer le test, Molecule valide le fichier de configurationmolecule.yml pour s'assurer que tout est en ordre. Il imprime également cette matrice de test, qui spécifie l'ordre des actions de test:

Output--> Validating schema /home/sammy/ansible-apache/molecule/default/molecule.yml.
Validation completed successfully.
--> Test matrix

└── default
    ├── lint
    ├── destroy
    ├── dependency
    ├── syntax
    ├── create
    ├── prepare
    ├── converge
    ├── idempotence
    ├── side_effect
    ├── verify
    └── destroy
...

Nous discuterons de chaque action de test en détail une fois que vous avez créé votre rôle et personnalisé vos tests. Pour l'instant, faites attention auxPLAY_RECAP pour chaque test, et assurez-vous qu'aucune des actions par défaut ne renvoie un statutfailed. Par exemple, lePLAY_RECAP pour l'action par défaut'create' devrait ressembler à ceci:

Output...
PLAY RECAP *********************************************************************
localhost                  : ok=5    changed=4    unreachable=0    failed=0

Passons maintenant à la modification du rôle pour configurer Apache et firewalld.

[[step-3 -—- configuring-apache-and-firewalld]] == Étape 3 - Configuration d'Apache et de Firewalld

Pour configurer Apache et firewalld, vous allez créer un fichier de tâches pour le rôle, en spécifiant les packages à installer et les services à activer. Ces détails seront extraits d'un fichier de variables et d'un modèle que vous utiliserez pour remplacer la page d'index Apache par défaut.

Toujours dans le répertoireansible-apache, créez un fichier de tâches pour le rôle en utilisantnano ou votre éditeur de texte préféré:

nano tasks/main.yml

Vous verrez que le fichier existe déjà. Supprimez ce qui existe et remplacez-le par le code suivant pour installer les packages requis et activer les services, les paramètres HTML par défaut et les paramètres de pare-feu appropriés:

~/ansible-apache/tasks/main.yml

---
- name: "Ensure required packages are present"
  yum:
    name: "{{ pkg_list }}"
    state: present

- name: "Ensure latest index.html is present"
  template:
    src: index.html.j2
    dest: /var/www/html/index.html

- name: "Ensure httpd service is started and enabled"
  service:
    name: "{{ item }}"
    state: started
    enabled: true
  with_items: "{{ svc_list }}"

- name: "Whitelist http in firewalld"
  firewalld:
    service: http
    state: enabled
    permanent: true
    immediate: true

Ce cahier comprend 4 tâches:

"Ensure required packages are present": cette tâche installera les packages répertoriés dans le fichier de variables souspkg_list. Le fichier de variables sera situé à~/ansible-apache/vars/main.yml et vous le créerez à la fin de cette étape.
"Ensure latest index.html is present": cette tâche copiera une page modèle,index.html.j2, et la collera sur le fichier d'index par défaut,/var/www/html/index.html, généré par Apache. Vous créerez également le nouveau modèle à cette étape.
"Ensure httpd service is started and enabled": Cette tâche démarre et active les services répertoriés danssvc_list dans le fichier de variables.
"Whitelist http in firewalld": cette tâche mettra en liste blanche le servicehttp dansfirewalld. Firewalld est une solution de pare-feu complète présente par défaut sur les serveurs CentOS. Pour que le servicehttp fonctionne, vous devrez exposer les ports requis. Demander àfirewalld de mettre un service sur liste blanche garantit qu'il liste tous les ports dont le service a besoin.

Enregistrez et fermez le fichier lorsque vous avez terminé.

Ensuite, créons un répertoiretemplates pour la page de modèleindex.html.j2:

mkdir templates

Créez la page elle-même:

nano templates/index.html.j2

Collez le code standard suivant:

~/ansible-apache/templates/index.html.j2


    Managed by Ansible

Enregistrez et fermez le fichier.

La dernière étape de la finalisation du rôle est l'écriture du fichier de variables, qui fournit les noms des packages et des services à notre livre de rôle principal:

nano vars/main.yml

Collez le contenu par défaut avec le code suivant, qui spécifiepkg_list etsvc_list:

~/ansible-apache/vars/main.yml

---
pkg_list:
  - httpd
  - firewalld
svc_list:
  - httpd
  - firewalld

Ces listes contiennent les informations suivantes:

pkg_list: contient les noms des packages que le rôle installera:httpd etfirewalld.
svc_list: contient les noms des services que le rôle va démarrer et activer:httpd etfirewalld.

[.note] #Note: Assurez-vous que votre fichier de variables ne contient pas de lignes vides, sinon votre test échouera pendant le lintage.
#

Maintenant que vous avez terminé de créer votre rôle, configurons Molecule pour vérifier s’il fonctionne comme prévu.

[[step-4 -—- modifying-the-role-for-running-tests]] == Étape 4 - Modification du rôle pour l'exécution des tests

Dans notre cas, la configuration de Molecule implique de modifier le fichier de configuration de Moleculemolecule.yml pour ajouter des spécifications de plateforme. Étant donné que vous testez un rôle qui configure et démarre le service systemd dehttpd, vous devrez utiliser une image avec systemd configuré et mode privilégié activé. Pour ce tutoriel, vous utiliserez l'imagemilcom/centos7-systemdavailable on Docker Hub. Le mode privilégié permet aux conteneurs de s'exécuter avec presque toutes les fonctionnalités de leur ordinateur hôte.

Modifionsmolecule.yml pour refléter ces changements:

nano molecule/default/molecule.yml

Ajoutez les informations de la plateforme en surbrillance:

~/ansible-apache/molecule/default/molecule.yml

---
dependency:
  name: galaxy
driver:
  name: docker
lint:
  name: yamllint
platforms:
  - name: centos7
    image: milcom/centos7-systemd
    privileged: true
provisioner:
  name: ansible
  lint:
    name: ansible-lint
scenario:
  name: default
verifier:
  name: testinfra
  lint:
    name: flake8

Enregistrez et fermez le fichier lorsque vous avez terminé.

Maintenant que vous avez correctement configuré l’environnement de test, passons à l’écriture des scénarios de test que Molecule exécutera sur votre conteneur après l’exécution du rôle.

[[step-5 -—- writing-test-cases]] == Étape 5 - Ecrire des cas de test

Lors du test de ce rôle, vous vérifierez les conditions suivantes:

Que les packageshttpd etfirewalld sont installés.
Que les serviceshttpd etfirewalld sont en cours d'exécution et activés.
Que le servicehttp est activé dans vos paramètres de pare-feu.
Ceindex.html contient les mêmes données que celles spécifiées dans votre fichier modèle.

Si tous ces tests réussissent, le rôle fonctionne comme prévu.

Pour écrire les cas de test pour ces conditions, modifions les tests par défaut en~/ansible-apache/molecule/default/tests/test_default.py. En utilisant Testinfra, nous allons écrire les cas de test sous forme de fonctions Python utilisant des classes Molecule.

Ouvrirtest_default.py:

nano molecule/default/tests/test_default.py

Supprimez le contenu du fichier pour pouvoir écrire les tests à partir de zéro.

[.note] #Note: Lorsque vous écrivez vos tests, assurez-vous qu'ils sont séparés par deux nouvelles lignes, sinon ils échoueront.
#

Commencez par importer les modules Python requis: