• 6 heures
  • Moyenne

Ce cours est visible gratuitement en ligne.

course.header.alt.is_video

course.header.alt.is_certifying

J'ai tout compris !

Mis à jour le 14/06/2022

Assemblez les opérations avec les playbooks pour automatiser le déploiement

Connectez-vous ou inscrivez-vous gratuitement pour bénéficier de toutes les fonctionnalités de ce cours !

 

Dans le chapitre précédent, vous avez contrôlé l'exécution des opérations et enchaîné plusieurs actions, en écrivant du code Ansible dans les fichiers de configuration présents dans les différents rôles.

Dans ce chapitre, vous allez assembler toutes ces opérations et automatiser le déploiement de MediaWiki. Pour cela, vous allez utiliser les playbooks Ansible. Ensuite, vous jouerez ces playbooks avec la commande ansible-playbook, afin de déployer automatiquement MediaWiki.

Vérifiez le niveau de sécurité sur les nodes

Avant de lancer les configurations sur les nodes, vérifiez que le AppArmor et le firewalling ne sont pas activés sur les nodes Debian. En effet, ces blocages de sécurité par défaut peuvent empêcher le déploiement de MediaWiki. Il est donc préférable de les désactiver.

Voici les commandes à passer pour s'affranchir des blocages de sécurité :

  • pour désactiver temporairement AppArmor :   systemctl stop apparmor.service  ;

  • pour désactiver définitivement AppArmor :  systemctl stop apparmor.service  ;

  • pour désactiver temporairement le firewallingsystemctl stop firewalld.service  ;

  • pour désactiver définitivement le firewallingsystemctl disable firewalld.service . 

Activez la résolution de noms sur les nodes

Comme indiqué précédemment, comme il n’y a pas de gestionnaire de noms DNS, il faut enregistrer les adresses IP et les noms des nodes sur chacun d'entre eux, pour qu’ils puissent résoudre les noms de machines utilisées dans les configurations. 

Sur tous les nodes, ajoutez à la suite du fichier /etc/hosts les éléments suivants : 

192.168.122.11 http1
192.168.122.12 bdd1

Ainsi, vous pouvez pinger http1 et bdd1 depuis les nodes. Ce qui évite d’utiliser directement les adresses IP.

Créez les playbooks pour exécuter les rôles

Icône d'un playbook

Un playbook est un fichier de configuration YAML contenant une suite de jeux d’instructions, ou plays en anglais. Chacun peut être constitué d’options, et fait appel à un ou plusieurs rôles. Il permet de décrire une stratégie de déploiement, ou de configuration, en structurant les actions nécessaires.

En utilisant les playbooks, vous avez la possibilité de conserver le code dans un fichier et de le réutiliser à votre façon, contrairement à la commande ansible qui est volatile.

Dans la suite ce chapitre, vous allez donc créer 3 playbooks :

  1. Un pour installer Apache.

  2. Un pour installer MariaDB.

  3. Un pour configurer MediaWiki

L’ordre d'exécution de ces playbooks est important, car les rôles de configuration dépendent des rôles d’installation. Les serveurs Apache et MariaDB doivent être installés avant que la configuration de MediaWiki puisse être lancée. De la même façon, la configuration de MediaWiki sur le serveur MariaDB doit être effectuée avant la configuration du serveur state: present.

Toutes les opérations qui vont suivre sont à faire sur le node manager.

Tout d'abord, connectez-vous sur le node manager :

$ ssh user-ansible@node-manager

Puis, activez l’environnement virtuel  :

$ source ansible2.7.10/bin/activate

Créez le playbook pour installer Apache

L’installation d'Apache va consister à lancer le rôle apache et à définir la variable qui permettra d’indiquer si PHP doit être installé ou pas.

Créez le playbook install-apache.yml à la racine de votre environnement virtuel :

$ vi install-apache.yml

Le contenu du fichier ressemble à celui-ci :

L'image montre une capture d'écran décrivant le contenu du fichier pour créer le playbook pour l'installation d'Apache.

La structure d’un playbook

Le playbook est un fichier YAML. Il est structuré de la façon suivante :

  • il commence par tirets ;

  • ensuite, il peut y avoir un bloc général, constitué d’un en-tête composé du nom des nodes ou du groupe concernés, de variables, d’options, etc.

  • puis, vous trouvez des blocs spécifiques qui définissent les jeux d'instruction (ou play en anglais). Chaque jeu d’instruction est composé du nom du jeu (avec un tiret au début), et de façon optionnelle, d’un en-tête et d’une section qui peut prendre plusieurs formes comme des tasks, des rôles, des handlers… en fonction de l’action demandée.
    Dans le cas du playbook install-apache.yml ci-dessus, il y a 2 jeux d'instruction.

  • chaque ligne à l'intérieur d’un bloc est indentée, et chaque début de ligne est décalé de deux espaces.

Comme vous pouvez le voir, la principale différence entre un playbook et un fichier de configuration de type main.yml est que le playbook contient une liste de jeux d'instructions (plays) et que le main.yml contient une liste de tâches (tasks) ou de variables.

Dans  install-apache.yml, il n’y a pas de bloc général. Par contre, il y a un bloc spécifique pour définir le jeu d'instructions qui consiste à lancer le rôle apache et à définir la valeur de la variable php_install (ce qui déclenchera l'installation de PHP). Il y a également un en-tête qui indique sur quel node il faut lancer les actions.

Le jeu d’instructions est défini de la façon suivante :

  • - name: "Installation apache"  indique le nom du jeu d'instructions ;

  • hosts: http1  indique le node concerné ;

  • roles: indique une section rôles ;

  • - role: "apache" indique le rôle à lancer ;

  • php_install: yes indique la valeur de la variable  php_install.

Lancez le playbook pour installer Apache sur http1

Lancez la commande  ansible-playbook  pour exécuter le playbook  install-apache.yml  avec les  options de connexion suivantes :

$ ansible-playbook -i inventaire.ini --user user-ansible --become --ask-become-pass install-apache.yml
SUDO password:

Vous avez utilisé la commande  ansible-playbook  avec les mêmes options que celles utilisées avec la commande ansible. Seul le node concerné est directement défini dans le playbook.

Le résultat (appelé callback d’affichage) prend la forme suivante :

(ansible) user-ansible@node-manager:~$ ansible-playbook -i inventaire.ini --user user-ansible --become --ask-become-pass install-apache.yml

BECOME password:
PLAY [Installation apache] ***************************************************************************************

TASK [Gathering Facts] *******************************************************************************************
ok: [http1]

TASK [apache : apache installation] ******************************************************************************
changed: [http1]

TASK [apache : apache service activation] ************************************************************************
ok: [http1]

TASK [apache : install php packages] *****************************************************************************
changed: [http1]

RUNNING HANDLER [apache : apache restart] ************************************************************************
changed: [http1]

PLAY RECAP *******************************************************************************************************
http1 : ok=5 changed=3 unreachable=0 failed=0 skipped=0 rescued=0 ignored=0

Vous pouvez constater que le callback donne la liste des tâches pour chaque action définie dans le rôle apache, avec leur état (changed). Ce qui signifie que toutes les actions ont provoqué un changement sur le node http1

La dernière ligne du callback indique le récapitulatif par node, de l'exécution des tâches selon les quatre états possibles (ok, changed, unreachable, failed).

Il est temps de vérifier sur le node http1, si Apache et PHP ont bien été installés. 

Connectez-vous sur le node http1 et lancez la commande qui permet de connaitre la version de PHP

(ansible) user-ansible@node-manager:~$ ssh user-ansible@http1
$ php --version
PHP 7.4.25 (cli) (built: Oct 23 2021 21:53:50) ( NTS )
Copyright (c) The PHP Group
Zend Engine v3.4.0, Copyright (c) Zend Technologies with Zend OPcache v7.4.25, Copyright (c), by Zend Technologies 

Lancez un navigateur et connectez vous sur http://http1

L'image montre une capture d'écran de la page de test pour Apache
Page de test d'Apache

C’est tout bon ! Par défaut, Apache affiche une page de test, ce qui permet de vérifier que le service est opérationnel. Et PHP est bien installé.

Créez le playbook pour installer MariaDB

L’installation de MariaDB va simplement consister à lancer le rôle mariadb.

Créez le playbook install-mariadb.yml à la racine de votre environnement virtuel :

$ vi install-mariadb.yml 

Le contenu du fichier :

L'image montre une capture d'écran décrivant les actions nécessaires à l'installation de MariaDB avec le playbook
Capture d'écran du playbook pour l'installation de MariaDB

Le playbook contient une seule tâche, qui définit le nom de l’host concerné par l’action, l’option gather_facts  est désactivée et le rôle à lancer est “mariadb”.

Lancez la commande  ansible-playbook  pour exécuter le playbook install-mariadb.yml avec les  options de connection suivantes :

(ansible) user-ansible@node-manager:~$ ansible-playbook -i inventaire.ini --user user-ansible --become --ask-become-pass install-mariadb.yml
BECOME password:

PLAY [Installation MariaDB] **************************************************************************************

TASK [mariadb : mariadb-server installation] *********************************************************************
changed: [bdd1]

TASK [mariadb : start mariadb service] ***************************************************************************
ok: [bdd1]

PLAY RECAP *******************************************************************************************************
bdd1                   : ok=2 changed=1 unreachable=0 failed=0 skipped=0 rescued=0 ignored=0

Même chose que pour le playbook précédent, les différentes étapes d'exécution du rôle mariadb sont listées, et un résumé est donné en fin de liste avec l'état global de l'exécution. Deux tâches ont été exécutées, elles ont provoqué un changement sur le node bdd1. 

Pour le vérifier, connectez-vous sur le node bdd1 et interrogez le statut du service MariaDB avec la commande suivante :

[user-ansible@bdd1 ~]$ sudo systemctl status mariadb
[sudo] Mot de passe de user-ansible :

● mariadb.service - MariaDB database server
[~]
Active: active (running)

Le service MariaDB est bien actif. L'exécution du playbook s’est bien passée !

Créez le playbook pour configurer MediaWiki

La configuration de MediaWiki va consister à lancer les rôles confapache et confdb

Pour cela, vous allez créer un playbook install-mediawiki.yml.

$ vi install-mediawiki.yml 
L'image montre une capture d'écran décrivant les actions à suivre pour la création du playbook
Capture d'écran de la configuration de MediaWiki

Le playbook contient deux tâches, une pour chaque rôle. Il est important de commencer par la configuration de MariaDB car la suite en dépend.  Pour configurer MediaWiki sur Apache, la base de données doit déjà être créée. Toutes ces instructions sont contenues dans le guide d’installation de MediaWiki. 

Pour chaque tâche est défini le host concerné par les actions, le gather_facts est désactivé (pas utile dans notre cas), et des tags ont été ajoutés aux tâches. 

Lancez maintenant le playbook de configuration de MediaWiki :

(ansible) user-ansible@node-manager:~$ ansible-playbook -i inventaire.ini --user user-ansible --become --ask-become-pass --ask-vault-pass
install-mediawiki.yml
BECOME password:
Vault password:

PLAY [MediaWiki db configuration] ********************************************************************************

TASK [mediawiki/confdb : mediawiki database] *********************************************************************
ok: [bdd1]

TASK [mediawiki/confdb : mediawiki user and privileges] **********************************************************
ok: [bdd1]

PLAY [MediaWiki apache configuration] ****************************************************************************

TASK [mediawiki/confapache : add user-ansible] *******************************************************************
changed: [http1]

TASK [mediawiki/confapache : mediawiki directory] ****************************************************************
ok: [http1]

TASK [mediawiki/confapache : uncompress mediawiki archive] *******************************************************
ok: [http1]

TASK [mediawiki/confapache : add g+w sur le répertoire mediawiki] ************************************************
changed: [http1]

TASK [mediawiki/confapache : mediawiki configuration] ************************************************************
ok: [http1] => (item=http1)

TASK [mediawiki/confapache : mediawiki db update] ****************************************************************
ok: [http1]

PLAY RECAP
*******************************************************************************************************
bdd1                   : ok=2 changed=0 unreachable=0 failed=0 skipped=0 rescued=0 ignored=0 
http1                  : ok=6 changed=2 unreachable=0 failed=0 skipped=0 rescued=0 ignored=0  

Les tâches sont exécutées séquentiellement, d'abord sur bdd1 et ensuite sur http1. Les actions ont provoqué des changements sur les deux nodes et tout est OK !

Si vous lancez votre navigateur et que vous vous rendez sur http://http1/mediawiki alors vous pourrez voir MediaWiki en chair et en os !

Page d'accueil de MediaWiki
Votre MediaWiki fonctionnel !

Voilà, avec 3 lignes de commande Ansible, vous avez déployé MediaWiki. Vous pourrez relancer à volonté ces commandes sur votre infrastructure. Vous pourrez même remodeler vos scripts pour les adapter à vos futurs déploiements.

Résumé

Dans ce chapitre,  vous avez assemblé les opérations et automatisé le déploiement de MediaWiki :

  • vous avez vérifié que le niveau de sécurité sur les nodes n'était pas trop élevé pour permettre le déploiement sans blocage 

  • vous avez configuré la résolution de noms sur les nodes, pour que leur nom de machine puisse être utilisé dans les fichiers de configuration ;

  • vous avez créé 3 playbooks peuplés de tâches et de rôles ;

  • vous avez lancé dans un ordre précis les playbooks avec la commande ansible-playbook afin de déployer automatiquement MediaWiki ;

  • vous avez finalement vérifié que MediaWiki était bien installé et disponible sur  http://http1/mediawiki

Dans la dernière partie, vous irez un peu plus loin avec Ansible, en créant votre propre module Ansible personnalisé.

Exemple de certificat de réussite
Exemple de certificat de réussite