TOC

Comment implémenter des tests continus de rôles compatibles avec Molecule et Travis CI sur Ubuntu 18.04

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

introduction

Ansible est un outil de gestion de configuration sans agent qui utilise des modèles YAML pour définir une liste de tâches à effectuer sur les hôtes. Dans Ansible, lesroles sont une collection de variables, tâches, fichiers, modèles et modules qui sont utilisés ensemble pour exécuter une fonction complexe et singulière.

Molecule est un outil pour effectuer des tests automatisés des rôles Ansible, spécialement conçu pour soutenir le développement de rôles toujours bien écrits et maintenus. Les tests unitaires de Molecule permettent aux développeurs de tester des rôles simultanément dans plusieurs environnements et sous différents paramètres. Il est important que les développeurs exécutent en permanence des tests sur du code souvent modifié. Ce flux de travail garantit que les rôles continuent de fonctionner lorsque vous mettez à jour les bibliothèques de code. L'exécution de Molecule à l'aide d'un outil d'intégration continue, commeTravis CI, permet aux tests de s'exécuter en continu, garantissant que les contributions à votre code n'introduisent pas de changements de rupture.

Dans ce didacticiel, vous utiliserez un rôle de base préconçu qui installe et configure un serveur Web Apache et un pare-feu sur les serveurs Ubuntu et CentOS. Ensuite, vous initialiserez un scénario de molécule dans ce rôle pour créer des tests et vous assurer que le rôle fonctionne comme prévu dans vos environnements cibles. Après avoir configuré Molecule, vous utiliserez Travis CI pour tester en continu votre rôle nouvellement créé. Chaque fois qu'une modification est apportée à votre code, Travis CI exécuteramolecule test pour s'assurer que le rôle fonctionne toujours correctement.

Conditions préalables

Avant de commencer ce tutoriel, vous aurez besoin de:

[[step-1 -—- forking-the-base-role-repository]] == Étape 1 - Forking the Base Role Repository

Vous utiliserez un rôle prédéfini appeléansible-apache qui installe Apache et configure un pare-feu sur les distributions basées sur Debian et Red Hat. Vous utiliserez ce rôle comme base, puis vous construirez des tests de molécule par dessus. Forking vous permet de créer une copie d'un référentiel afin de pouvoir y apporter des modifications sans altérer le projet d'origine.

Commencez par créer un fork du rôleansible-apache. Allez dans le référentiel deansible-apache et cliquez sur le boutonFork.

Une fois que vous avez créé le référentiel, GitHub vous mènera à la page de votre fork. Ce sera une copie du référentiel de base, mais sur votre propre compte.

Cliquez sur le bouton vertClone or Download et vous verrez une boîte avecClone with HTTPS.

Copiez l'URL affichée pour votre référentiel. Vous allez l'utiliser dans la prochaine étape. L'URL sera semblable à ceci: 

https://github.com/username/ansible-apache.git

Vous remplacerezusername par votre nom d'utilisateur GitHub.

Une fois votre fork défini, vous allez le cloner sur votre serveur et commencer à préparer votre rôle dans la section suivante.

[[step-2 -—- preparation-your-role]] == Étape 2 - Préparation de votre rôle

Après avoir suivi l'étape 1 des prérequisHow To Test Ansible Roles with Molecule on Ubuntu 18.04, vous aurez Molecule et Ansible installés dans un environnement virtuel. Vous utiliserez cet environnement virtuel pour développer votre nouveau rôle.

Tout d’abord, activez l’environnement virtuel que vous avez créé en respectant les conditions préalables en exécutant: 

source my_env/bin/activate

Exécutez la commande suivante pour cloner le référentiel à l'aide de l'URL que vous venez de copier à l'étape 1: 

git clone https://github.com/username/ansible-apache.git

Votre sortie ressemblera à ce qui suit: 

OutputCloning into 'ansible-apache'...
remote: Enumerating objects: 16, done.
remote: Total 16 (delta 0), reused 0 (delta 0), pack-reused 16
Unpacking objects: 100% (16/16), done.

Déplacez-vous dans le répertoire nouvellement créé: 

cd ansible-apache

Le rôle de base que vous avez téléchargé effectue les tâches suivantes:

  • Includes variables: le rôle commence par inclure tous lesvariables requis selon la distribution de l'hôte. Ansible utilise des variables pour gérer les disparités entre différents systèmes. Puisque vous utilisez Ubuntu 18.04 et CentOS 7 comme hôtes, le rôle reconnaîtra que les familles de systèmes d'exploitation sont respectivement Debian et Red Hat et incluent des variables devars/Debian.yml etvars/RedHat.yml.

  • Includes distribution-relevant tasks: ces tâches incluenttasks/install-Debian.yml ettasks/install-RedHat.yml. En fonction de la distribution spécifiée, il installe les packages appropriés. Pour Ubuntu, ces packages sontapache2 etufw. Pour CentOS, ces packages sonthttpd etfirewalld.

  • Ensures latest index.html is present: cette tâche copie un modèletemplates/index.html.j2 qu'Apache utilisera comme page d'accueil du serveur Web.

  • Starts relevant services and enables them on boot: démarre et active les services requis installés dans le cadre de la première tâche. Pour CentOS, ces services sonthttpd etfirewalld, et pour Ubuntu, ce sontapache2 etufw.

  • Configures firewall to allow traffic: Cela inclut soittasks/configure-Debian-firewall.yml, soittasks/configure-RedHat-firewall.yml. Ansible configure Firewalld ou UFW comme pare-feu et met en liste blanche le servicehttp.

Maintenant que vous avez compris le fonctionnement de ce rôle, vous allez configurer Molecule pour le tester. Vous allez écrire des scénarios de test pour ces tâches qui couvrent les modifications apportées.

[[step-3 -—- writing-your-tests]] == Étape 3 - Rédaction de vos tests

Pour vérifier que votre rôle de base exécute ses tâches comme prévu, vous allez démarrer un scénario Molecule, spécifier vos environnements cible et créer trois fichiers de test personnalisés.

Commencez par initialiser un scénario de molécule pour ce rôle à l'aide de la commande suivante: 

molecule init scenario -r ansible-apache

Vous verrez la sortie suivante: 

Output--> Initializing new scenario default...
Initialized scenario in /home/sammy/ansible-apache/molecule/default successfully.

Vous allez ajouter CentOS et Ubuntu comme environnements cibles en les incluant en tant que plates-formes dans votre fichier de configuration de molécule. Pour ce faire, éditez le fichiermolecule.yml à l'aide d'un éditeur de texte: 

nano molecule/default/molecule.yml

Ajoutez le contenu en surbrillance suivant à la configuration de la molécule:

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

---
dependency:
  name: galaxy
driver:
  name: docker
lint:
  name: yamllint
platforms:
  - name: centos7
    image: milcom/centos7-systemd
    privileged: true
  - name: ubuntu18
    image: solita/ubuntu-systemd
    command: /sbin/init
    privileged: true
    volumes:
      - /lib/modules:/lib/modules:ro
provisioner:
  name: ansible
  lint:
    name: ansible-lint
scenario:
  name: default
verifier:
  name: testinfra
  lint:
    name: flake8

Ici, vous spécifiez deux plates-formes cibles lancées en mode privilégié puisque vous utilisez des services systemd:

  • centos7 est la première plate-forme et utilise l'imagemilcom/centos7-systemd.

  • ubuntu18 est la deuxième plate-forme et utilise l'imagesolita/ubuntu-systemd. En plus d'utiliser le mode privilégié et de monter les modules de noyau requis, vous exécutez/sbin/init au lancement pour vous assurer que iptables est opérationnel.

Enregistrez et quittez le fichier.

Pour plus d'informations sur l'exécution de conteneurs privilégiés, visitez le siteofficial Molecule documentation.

Au lieu d'utiliser le fichier de test de molécule par défaut, vous allez créer trois fichiers de test personnalisés, un pour chaque plate-forme cible et un fichier pour l'écriture de tests communs à toutes les plates-formes. Commencez par supprimer le fichier de test par défaut du scénariotest_default.py avec la commande suivante: 

rm molecule/default/tests/test_default.py

Vous pouvez maintenant passer à la création des trois fichiers de test personnalisés,test_common.py,test_Debian.py ettest_RedHat.py pour chacune de vos plates-formes cibles.

Le premier fichier de test,test_common.py, contiendra les tests communs que chacun des hôtes effectuera. Créez et modifiez le fichier de test commun,test_common.py: 

nano molecule/default/tests/test_common.py

Ajoutez le code suivant au fichier:

~/ansible-apache/molecule/default/tests/test_common.py

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('file, content', [
  ("/var/www/html/index.html", "Managed by Ansible")
])
def test_files(host, file, content):
    file = host.file(file)

    assert file.exists
    assert file.contains(content)

Dans votre fichiertest_common.py, vous avez importé les bibliothèques requises. Vous avez également écrit un test appelétest_files(), qui contient la seule tâche commune entre les distributions que votre rôle effectue: copier votre modèle en tant que page d'accueil des serveurs Web.

Le fichier de test suivant,test_Debian.py, contient des tests spécifiques aux distributions Debian. Ce fichier de test ciblera spécifiquement votre plate-forme Ubuntu.

Créez et éditez le fichier de test Ubuntu en exécutant la commande suivante: 

nano molecule/default/tests/test_Debian.py

Vous pouvez maintenant importer les bibliothèques requises et définir la plateformeubuntu18 comme hôte cible. Ajoutez le code suivant au début de ce fichier:

~/ansible-apache/molecule/default/tests/test_Debian.py

import os
import pytest

import testinfra.utils.ansible_runner

testinfra_hosts = testinfra.utils.ansible_runner.AnsibleRunner(
    os.environ['MOLECULE_INVENTORY_FILE']).get_hosts('ubuntu18')

Ensuite, dans le même fichier, vous ajouterez le testtest_pkg().

Ajoutez le code suivant au fichier, qui définit le testtest_pkg():

~/ansible-apache/molecule/default/tests/test_Debian.py

...
@pytest.mark.parametrize('pkg', [
    'apache2',
    'ufw'
])
def test_pkg(host, pkg):
    package = host.package(pkg)

    assert package.is_installed

Ce test vérifiera si les packagesapache2 etufw sont installés sur l'hôte.

[.note] #Note: Lorsque vous ajoutez plusieurs tests à un fichier de test Molecule, assurez-vous qu'il y a deux lignes vides entre chaque test ou vous obtiendrez une erreur de syntaxe de Molecule.
#

Pour définir le test suivant,test_svc(), ajoutez le code suivant sous le testtest_pkg() dans votre fichier:

~/ansible-apache/molecule/default/tests/test_Debian.py

...
@pytest.mark.parametrize('svc', [
    'apache2',
    'ufw'
])
def test_svc(host, svc):
    service = host.service(svc)

    assert service.is_running
    assert service.is_enabled

test_svc() vérifiera si les servicesapache2 etufw sont en cours d'exécution et activés.

Enfin, vous ajouterez votre dernier test,test_ufw_rules(), au fichiertest_Debian.py.

Ajoutez ce code sous le testtest_svc() dans votre fichier pour définirtest_ufw_rules():

~/ansible-apache/molecule/default/tests/test_Debian.py

...
@pytest.mark.parametrize('rule', [
    '-A ufw-user-input -p tcp -m tcp --dport 80 -j ACCEPT'
])
def test_ufw_rules(host, rule):
    cmd = host.run('iptables -t filter -S')

    assert rule in cmd.stdout

test_ufw_rules() vérifiera que la configuration de votre pare-feu autorise le trafic sur le port utilisé par le service Apache.

Avec chacun de ces tests ajoutés, votre fichiertest_Debian.py ressemblera à ceci:

~/ansible-apache/molecule/default/tests/test_Debian.py

import os
import pytest

import testinfra.utils.ansible_runner

testinfra_hosts = testinfra.utils.ansible_runner.AnsibleRunner(
    os.environ['MOLECULE_INVENTORY_FILE']).get_hosts('ubuntu18')


@pytest.mark.parametrize('pkg', [
    'apache2',
    'ufw'
])
def test_pkg(host, pkg):
    package = host.package(pkg)

    assert package.is_installed


@pytest.mark.parametrize('svc', [
    'apache2',
    'ufw'
])
def test_svc(host, svc):
    service = host.service(svc)

    assert service.is_running
    assert service.is_enabled


@pytest.mark.parametrize('rule', [
    '-A ufw-user-input -p tcp -m tcp --dport 80 -j ACCEPT'
])
def test_ufw_rules(host, rule):
    cmd = host.run('iptables -t filter -S')

    assert rule in cmd.stdout

Le fichiertest_Debian.py comprend désormais les trois tests:test_pkg(),test_svc() ettest_ufw_rules().

Enregistrez et quitteztest_Debian.py.

Ensuite, vous allez créer le fichier de testtest_RedHat.py, qui contiendra des tests spécifiques aux distributions Red Hat pour cibler votre plate-forme CentOS.

Créez et modifiez le fichier de test CentOS,test_RedHat.py, en exécutant la commande suivante: 

nano molecule/default/tests/test_RedHat.py

Comme pour le fichier de test Ubuntu, vous allez maintenant écrire trois tests à inclure dans votre fichiertest_RedHat.py. Avant d'ajouter le code de test, vous pouvez importer les bibliothèques requises et définir la plateformecentos7 comme hôte cible, en ajoutant le code suivant au début de votre fichier:

~/ansible-apache/molecule/default/tests/test_RedHat.py

import os
import pytest

import testinfra.utils.ansible_runner

testinfra_hosts = testinfra.utils.ansible_runner.AnsibleRunner(
    os.environ['MOLECULE_INVENTORY_FILE']).get_hosts('centos7')

Ensuite, ajoutez le testtest_pkg(), qui vérifiera si les packageshttpd etfirewalld sont installés sur l'hôte.

Après le code des importations de votre bibliothèque, ajoutez le testtest_pkg() à votre fichier. (Encore une fois, n'oubliez pas d'inclure deux lignes vides avant chaque nouveau test.)

~/ansible-apache/molecule/default/tests/test_RedHat.py

...
@pytest.mark.parametrize('pkg', [
    'httpd',
    'firewalld'
])
def test_pkg(host, pkg):
    package = host.package(pkg)

      assert package.is_installed

Maintenant, vous pouvez ajouter le testtest_svc() pour vous assurer que les serviceshttpd etfirewalld sont en cours d'exécution et activés.

Ajoutez le codetest_svc() à votre fichier en suivant le testtest_pkg():

~/ansible-apache/molecule/default/tests/test_RedHat.py

...
@pytest.mark.parametrize('svc', [
    'httpd',
    'firewalld'
])
  def test_svc(host, svc):
    service = host.service(svc)

    assert service.is_running
    assert service.is_enabled

Le test final dans le fichiertest_RedHat.py seratest_firewalld(), qui vérifiera si Firewalld a le servicehttp sur la liste blanche.

Ajoutez le testtest_firewalld() à votre fichier après le codetest_svc():

~/ansible-apache/molecule/default/tests/test_RedHat.py

...
@pytest.mark.parametrize('file, content', [
    ("/etc/firewalld/zones/public.xml", "")
])
def test_firewalld(host, file, content):
    file = host.file(file)

    assert file.exists
    assert file.contains(content)

Après avoir importé les bibliothèques et ajouté les trois tests, votre fichiertest_RedHat.py ressemblera à ceci:

~/ansible-apache/molecule/default/tests/test_RedHat.py

import os
import pytest

import testinfra.utils.ansible_runner

testinfra_hosts = testinfra.utils.ansible_runner.AnsibleRunner(
    os.environ['MOLECULE_INVENTORY_FILE']).get_hosts('centos7')


@pytest.mark.parametrize('pkg', [
    'httpd',
    'firewalld'
])
def test_pkg(host, pkg):
    package = host.package(pkg)

    assert package.is_installed


@pytest.mark.parametrize('svc', [
    'httpd',
    'firewalld'
])
def test_svc(host, svc):
    service = host.service(svc)

    assert service.is_running
    assert service.is_enabled


@pytest.mark.parametrize('file, content', [
    ("/etc/firewalld/zones/public.xml", "")
])
def test_firewalld(host, file, content):
    file = host.file(file)

    assert file.exists
    assert file.contains(content)

Maintenant que vous avez terminé d'écrire des tests dans les trois fichiers,test_common.py,test_Debian.py ettest_RedHat.py, votre rôle est prêt pour les tests. Dans l'étape suivante, vous utiliserez Molecule pour exécuter ces tests sur votre rôle nouvellement configuré.

[[step-4 -—- testing-against-your-role]] == Étape 4 - Test en fonction de votre rôle

Vous allez maintenant exécuter vos tests nouvellement créés contre le rôle de baseansible-apache en utilisant Molecule. Pour exécuter vos tests, utilisez la commande suivante: 

molecule test

Vous verrez le résultat suivant une fois que Molecule aura exécuté tous les tests: 

Output...
--> Scenario: 'default'
--> Action: 'verify'
--> Executing Testinfra tests found in /home/sammy/ansible-apache/molecule/default/tests/...
    ============================= test session starts ==============================
    platform linux -- Python 3.6.7, pytest-4.1.1, py-1.7.0, pluggy-0.8.1
    rootdir: /home/sammy/ansible-apache/molecule/default, inifile:
    plugins: testinfra-1.16.0
collected 12 items

    tests/test_common.py ..                                                  [ 16%]
    tests/test_RedHat.py .....                                               [ 58%]
    tests/test_Debian.py .....                                               [100%]

    ========================== 12 passed in 80.70 seconds ==========================
Verifier completed successfully.

Vous verrezVerifier completed successfully dans votre sortie; cela signifie que le vérificateur a exécuté tous vos tests et les a renvoyés avec succès.

Maintenant que le développement de votre rôle est terminé avec succès, vous pouvez valider vos modifications dans Git et configurer Travis CI pour des tests continus.

[[step-5 -—- using-git-to-share-your-updated-role]] == Étape 5 - Utilisation de Git pour partager votre rôle mis à jour

Dans ce tutoriel, jusqu'à présent, vous avez cloné un rôle appeléansible-apache et y avez ajouté des tests pour vous assurer qu'il fonctionne avec les hôtes Ubuntu et CentOS. Pour partager votre rôle mis à jour avec le public, vous devez valider ces modifications et les transmettre à votre fork.

Exécutez la commande suivante pour ajouter les fichiers et valider les modifications que vous avez apportées: 

git add .

Cette commande ajoutera tous les fichiers que vous avez modifiés dans le répertoire actuel à la zone de stockage intermédiaire.

Vous devez également définir votre nom et votre adresse e-mail dans lesgit config afin de réussir la validation. Vous pouvez le faire en utilisant les commandes suivantes: 

git config user.email "[email protected]"
git config user.name "John Doe"

Commettez les fichiers modifiés dans votre référentiel: 

git commit -m "Configured Molecule"

Vous verrez le résultat suivant: 

Output[master b2d5a5c] Configured Molecule
 8 files changed, 155 insertions(+), 1 deletion(-)
 create mode 100644 molecule/default/Dockerfile.j2
 create mode 100644 molecule/default/INSTALL.rst
 create mode 100644 molecule/default/molecule.yml
 create mode 100644 molecule/default/playbook.yml
 create mode 100644 molecule/default/tests/test_Debian.py
 create mode 100644 molecule/default/tests/test_RedHat.py
 create mode 100644 molecule/default/tests/test_common.py

Cela signifie que vous avez validé vos modifications. Maintenant, appliquez ces modifications à votre fork avec la commande suivante: 

git push -u origin master

Vous verrez une invite pour vos informations d'identification GitHub. Une fois ces informations saisies, votre code sera transféré dans votre référentiel et vous verrez cette sortie: 

OutputCounting objects: 13, done.
Compressing objects: 100% (12/12), done.
Writing objects: 100% (13/13), 2.32 KiB | 2.32 MiB/s, done.
Total 13 (delta 3), reused 0 (delta 0)
remote: Resolving deltas: 100% (3/3), completed with 2 local objects.
To https://github.com/username/ansible-apache.git
   009d5d6..e4e6959  master -> master
Branch 'master' set up to track remote branch 'master' from 'origin'.

Si vous accédez au dépôt de votre fork àgithub.com/username/ansible-apache, vous verrez un nouveau commit appeléConfigured Molecule reflétant les modifications que vous avez apportées aux fichiers.

Désormais, vous pouvez intégrer Travis CI à votre nouveau référentiel afin que toute modification apportée à votre rôle déclenche automatiquement les tests de molécule. Cela garantira que votre rôle fonctionne toujours avec les hôtes Ubuntu et CentOS.

[[step-6 -—- integrating-travis-ci]] == Étape 6 - Intégration de Travis CI

Dans cette étape, vous allez intégrer Travis CI dans votre flux de travail. Une fois activé, toute modification apportée à votre fourche déclenchera la construction de Travis CI. Le but de ceci est de s'assurer que Travis CI exécute toujoursmolecule test chaque fois que les contributeurs apportent des modifications. Si des modifications importantes sont apportées, Travis déclarera le statut de construction en tant que tel.

Passez àTravis CI pour activer votre référentiel. Accédez à votre page de profil où vous pouvez cliquer sur le boutonActivate pour GitHub.

Vous pouvez trouver des conseils supplémentaireshere sur l'activation des référentiels dans Travis CI.

Pour que Travis CI fonctionne, vous devez créer un fichier de configuration contenant des instructions. Pour créer le fichier de configuration Travis, retournez sur votre serveur et exécutez la commande suivante: 

nano .travis.yml

Pour dupliquer l’environnement que vous avez créé dans ce tutoriel, vous devez spécifier des paramètres dans le fichier de configuration Travis. Ajoutez le contenu suivant à votre fichier:

~/ansible-apache/.travis.yml

---
language: python
python:
  - "2.7"
  - "3.6"
services:
  - docker
install:
  - pip install molecule docker
script:
  - molecule --version
  - ansible --version
  - molecule test

Les paramètres que vous avez spécifiés dans ce fichier sont:

  • language: lorsque vous spécifiez Python comme langage, l'environnement CI utilise des instancesvirtualenv distinctes pour chaque version de Python que vous spécifiez sous la clépython.

  • python: Ici, vous spécifiez que Travis utilisera à la fois Python 2.7 et Python 3.6 pour exécuter vos tests.

  • services: vous avez besoin de Docker pour exécuter des tests dans Molecule. Vous indiquez que Travis doit s’assurer que Docker est présent dans votre environnement CI.

  • install: Ici, vous spécifiez les étapes d'installation préliminaires que Travis CI effectuera dans vosvirtualenv.

    • pip install molecule docker pour vérifier que Ansible et Molecule sont présents avec la bibliothèque Python pour l'API distante Docker.

  • script: il s'agit de spécifier les étapes que Travis CI doit effectuer. Dans votre fichier, vous spécifiez trois étapes:

    • molecule --version imprime la version de Molecule si Molecule a été correctement installée.

    • ansible --version imprime la version d'Ansible si Ansible a été installé avec succès.

    • molecule test exécute enfin vos tests Molecule.

La raison pour laquelle vous spécifiezmolecule --version etansible --version est de détecter les erreurs au cas où la construction échoue en raison d'une mauvaise configuration deansible oumolecule en raison du contrôle de version.

Une fois que vous avez ajouté le contenu au fichier de configuration Travis CI, enregistrez et quittez.travis.yml.

Désormais, chaque fois que vous appliquez des modifications à votre référentiel, Travis CI exécute automatiquement une construction basée sur le fichier de configuration ci-dessus. Si l'une des commandes du blocscript échoue, Travis CI signalera l'état de construction en tant que tel.

Pour faciliter la visualisation de l'état de compilation, vous pouvez ajouter un badge indiquant l'état de compilation auxREADME de votre rôle. Ouvrez le fichierREADME.md à l'aide d'un éditeur de texte: 

nano README.md

Ajoutez la ligne suivante auxREADME.md pour afficher l'état de la construction:

~/ansible-apache/README.md

[![Build Status](https://travis-ci.org/username/ansible-apache.svg?branch=master)](https://travis-ci.org/username/ansible-apache)

Remplacezusername par votre nom d'utilisateur GitHub. Validez et transmettez les modifications à votre référentiel comme vous l’avez fait précédemment.

Tout d'abord, exécutez la commande suivante pour ajouter.travis.yml etREADME.md à la zone de transit: 

git add .travis.yml README.md

Maintenant, validez les modifications dans votre référentiel en exécutant: 

git commit -m "Configured Travis"

Enfin, envoyez ces modifications à votre fork avec la commande suivante: 

git push -u origin master

Si vous accédez à votre référentiel GitHub, vous verrez qu'il signale initialementbuild: unknown.

build-status-unknown

En quelques minutes, Travis lancera une construction que vous pourrez surveiller sur le site Web Travis CI. Une fois la construction réussie, GitHub signalera également l'état en tant que tel dans votre référentiel - en utilisant le badge que vous avez placé dans votre fichier README:

build-status-passing

Vous pouvez accéder aux détails complets des versions en consultant le site Web Travis CI:

travis-build-status

Maintenant que vous avez correctement configuré Travis CI pour votre nouveau rôle, vous pouvez continuellement tester et intégrer les modifications apportées à vos rôles Ansible.

Conclusion

Dans ce didacticiel, vous avez créé un rôle qui installe et configure un serveur Web Apache de GitHub et ajouté des intégrations pour Molecule en écrivant des tests et en les configurant de manière à fonctionner sur les conteneurs Docker exécutant Ubuntu et CentOS. En transmettant votre rôle nouvellement créé à GitHub, vous avez autorisé d'autres utilisateurs à accéder à votre rôle. Lorsque des contributeurs changent de rôle, Travis CI lance automatiquement Molecule pour tester votre rôle.

Une fois que vous êtes à l'aise avec la création de rôles et les tester avec Molecule, vous pouvez l'intégrer àAnsible Galaxy afin que les rôles soient automatiquement poussés une fois la construction réussie.

Related