Utilisez Ansible pour automatiser vos tâches de configuration

Dans le chapitre précédent, vous avez organisé le déploiement de MediaWiki en créant des rôles structurés.  Vous avez transposé les 6 étapes nécessaires au déploiement de MediaWiki en opérations d’installation et de configuration. Ensuite, vous avez créé 5 rôles pour intégrer ces opérations dans une structure arborescente.  

Dans ce chapitre, vous allez construire les scripts d’automatisation en complétant les fichiers main.yml présents dans chaque rôle. Ce qui permettra d'exécuter des tâches et d'enchaîner plusieurs actions. Pour vous aider à construire les scripts, vous suivrez les 6 étapes d’installation de MediaWiki qui sont détaillées dans le guide d’installation MediaWiki.

Reprenez l’arborescence des rôles construite précédemment :

ansible) user-ansible@node-manager:~/roles$ tree
.
├── apache
│   ├── handlers
│   │   └── main.yml
│   └── tasks
│   └── main.yml
├── mariadb
│   └── tasks
│   └── main.yml
└── mediawiki
   ├── commun
   │   └── defaults
   │   └── main.yml
   ├── confapache
   │   ├── meta
   │   │   └── main.yml
   │   └── tasks
   │   └── main.yml
   └── confdb
   ├── meta
   │   └── main.yml
   └── tasks
      └── main.yml

On distingue, dans cette arborescence, 5 rôles correspondant à 9 fichiers YAML décrivant les rôles : apache, mariadb, commun, confapache et confdb.

Nous allons donc créer 8 fichiers YAML pour les 5 rôles dans ce chapitre :

1. Le rôle apache :

   • un fichier tasks/main.yml contient les actions pour installer Apache, un appel à un fichier de configuration pour installer PHP et une notification pour redémarrer Apache ;

   • un fichier handler/main.yml contient les actions pour redémarrer le service Apache.

2. Le rôle mariadb :

   • un fichier tasks/main.yml contient les actions pour installer MariaDB.

3. Le rôle commun de MediaWiki :

   • un fichier defaults/main.yml contient les variables d'installation qui seront utilisées dans les rôles suivants.

4. Le rôle confapache de MediaWiki :

   • un fichier meta/main.yml contient la dépendance avec le rôle commun ;

   • un fichier tasks/main.yml contient les actions pour configurer Apache pour MediaWiki.

5. Le rôle confdb de MediaWiki :

   • un fichier meta/main.yml contient la dépendance avec le rôle commun ;

   • un fichier tasks/main.yml contient les actions pour configurer MariaDB pour MediaWiki.

Il est possible de créer dans le répertoire tasks autant de fichiers de configuration que vous voulez.

Vous pouvez par exemple, créer un fichier php-install.yml dédié à l'installation de PHP dans le répertoire roles/apache/tasks avec la commande suivante :

(ansible) user-ansible@node-manager:~/roles$ touch
apache/tasks/php-install.yml

L’installation de PHP aurait pu être intégrée au main.yml, mais pour une question de lisibilité et de modularité, je vous propose ici de la gérer dans un fichier à part. 

Les rôles peuvent être indépendants ou dépendants les uns des autres. Par exemple, les rôles apache, mariadb et commun sont indépendants et peuvent être utilisés séparément. Par contre, les rôles confapache et confdb dépendent du rôle commun. 

Vous allez maintenant compléter chaque fichier de configuration YAML.

Construisez vos fichiers YAML

Un fichier de configuration YAML contenu dans les rôles peut contenir une liste de tâches ou une liste de variables.

Les fichiers YAML commencent toujours par 3 tirets (---). Ensuite, vous avez les différentes tâches successives qui commencent par 1 tiret (-) et le nom de la tâche. Chaque tâche utilise un module avec ses arguments ou ses options. Les arguments ou les options sont décalés à la ligne de 2 espaces.

Pour construire votre fichier, vous devez chercher dans la documentation Ansible quel module utiliser. 

Pour installer Apache, il faut utiliser un gestionnaire de paquets. Sur Debian, vous utiliserez APT. Ça tombe bien, APT a un module Ansible permettant d'automatiser l'installation de paquets.

Si vous voulez en savoir plus sur l’utilisation d’un module Ansible, comme par exemple pour le module apt, vous pouvez utiliser la commande suivante :

$ ansible-doc apt

Créez le fichier YAML pour le rôle apache

Écrivez le code pour installer Apache

Voici le fichier tasks/main.yml qui contient les actions d’installation d'Apache et de PHP. 

$ vi roles/apache/tasks/main.yml

Le fichier est commenté pour en comprendre le sens.

---

#1. Cette tâche permet d’installer Apache (httpd) à l’aide du module apt
- name: "apache installation"
  apt:
name: "apache2"
state: "present"

#2. Cette tâche active le service Apache
- name: "apache service activation"
  service:
name: "apache2"
state: "started"
enabled: yes

#3. Cette tâche fait appel à un autre fichier de configuration pour installer PHP. Elle est exécutée uniquement si la variable php_install est à vraie (par défaut, elle est à faux)
- name: "install php packages"
  include: "php-install.yml"
  when: php_install|default(False)|bool

Voyons en détail chacune des tâches décrites dans ce fichier :

1. La première tâche, "apache installation" va installer le serveur Apache avec le module “apt”. Le name: "apache2" indique le paquet concerné et le state: "present" spécifie qu’il faut l’installer. 

2. La deuxième tâche, “apache service activation” va activer le service Apache avec le module “service”. Le name: "apache2" indique le service concerné, le state: "started" indique que le service sera démarré et le enabled: yes indique que le service sera activé.

3. La troisième tâche, “install php packages” inclut un fichier de configuration externe pour installer PHP. La tâche fait appel avec l’option “include” au fichier php-install.yml qui est placé dans le répertoire tasks à coté de main.yml. La condition when avec le filtre (php_install|default(False)|bool) permettent de conditionner l’installation de PHP.

Au début, vous allez forcément rencontrer des erreurs liées ) cette rigueur imposée par le langage python sur l'indentation (https://www.w3schools.com/python/python_syntax.asp). Pour plus de lisibilité, je vous proposerai également à chaque fichier une copie d'écran du résultat. Par exemple, ici, pour le fichier  roles/apache/tasks/main.yml  .

Les filtres Ansible sont sous la forme Jinja2, qui transforme une information en une expression régulière. 

Ajoutez un autre fichier de configuration pour l’installation de PHP

Vous allez ajouter un fichier pour l’installation spécifique de PHP ( php7-install.yml) afin de séparer l'installation d'Apache et l’installation de PHP. 

$ vi roles/apache/tasks/php-install.yml 

Voyons en détail chacune des tâches décrites dans ce fichier :

1. “install php packages”, installe les paquets php avec le module “apt”. Et les options :

• le name indique l’ensemble des paquets à installer ; 

• state: latest indique qu’il faut installer les dernières versions disponibles des paquets ;

• changed_when : force le changement d'état, c’est-à-dire qu'avec cette condition à yes, l'exécution de la tâche provoquera un changement ;  

• notify: [ "apache restart" ] indique que si la tâche change d'état (et uniquement si la tâche a engendré un changement), notify fait appel au handler "apache restart" pour relancer le service Apache.

L'idempotence est possible car Ansible gère 3 états d’exécution pour une tâche :  skipping, ok ou changed.

Créez le script handler pour relancer un service

Les handlers, ou script handlers, sont communément utilisés pour regrouper des actions récurrentes, comme des redémarrages de services, par exemple. 

Les handlers sont exécutés uniquement si une tâche les appelle à travers un notify, une notification déclenchée par la tâche. Le notify se déclenche si l’état de la tâche est changed. 

C’est plutôt utile pour redémarrer un service si et seulement si l'état du serveur a changé, ce qui évite des interruptions de service inutiles.

Dans le fichier roles/apache/handlers/main.yml, vous allez utiliser le module service pour relancer le service Apache. 

Rien de spécial ici, juste une tâche assez simple pour relancer le service.

Le module service est utilisé pour relancer le service apache2 avec l’option state: "restarted".

Créez le fichier YAML pour le rôle mariadb

Écrivez le code pour installer MariaDB

$ vi roles/mediawiki/mariadb/tasks/main.yml

La première tâche "mariadb-server installation" va installer mariadb serveur et son extension Python avec le module “apt”. Le name:  "mariadb-server,python3-mysql" indique les paquets concernés et state: "installed" indique que les paquets doivent être installés.

La deuxième tâche “start mariadb service” va activer et démarrer le service MariaDB avec le module “service”. Le name:  "mariadb"  indique le service concerné, state: "started" indique de démarrer le service et enabled:yes, de l'activer.

Créez le fichier YAML pour le rôle commun

Créez le fichier des variables globales

Les variables globales vont être utilisées dans les rôles confapache et confdb. Elles vont donc être définies dans le rôle commun, dans le répertoire defaults  et dans le fichier main.yml.

Pour connaître les variables à définir, il faut étudier le guide d’installation et repérer ce qui est potentiellement une variable. C’est très souvent des noms de répertoire, de base de données ou des logins, mots de passe, etc. Elles définissent tout ce qui est variable, c’est-à-dire ce qui peut changer ou être personnalisé. 

$ viroles/mediawiki/commun/defaults/main.yml 

Au format YAML, les variables sont définies par un couple “clé: valeur” séparé par deux points ( : ). 

Vous pouvez voir également dans ce fichier, que deux valeurs sont utilisées : {{mediawiki_name}} et {{mediawiki_directory}}, qui font respectivement appel aux deux variables mediawiki_name et mediawiki_directory contenues dans le fichier. 

En regardant encore un peu plus près le fichier, vous constatez que les mots de passe sont chiffrés. En effet, il n’est vraiment pas recommandé de mettre des mots de passe en clair dans les fichiers de configuration. 

Utilisons la commande ansible-vault pour chiffrer des chaînes de caractères.

Chiffrez vos mots de passe

Vous allez retenir le mot de passe suivant : AnsibleOC, car il va vous servir à chiffrer vos mots de passe.

Pour chiffrer le mot de passe qui sera utilisé dans le fichier de variables, vous pouvez utiliser la commande suivante :

$ ansible-vault encrypt_string 'foobar' --name 'mediawiki_db_password'
New Vault password:
Confirm New Vault password:

Saisissez la clé de chiffrement AnsibleOC et confirmez-la.

Voici la chaîne générée par Ansible :

mediawiki_db_password: !vault |
 $ANSIBLE_VAULT;1.1;AES256 636433316133373136356261616432646431373734623437346133366262663165626632353130346561316139383138313732653066373461336235316362340a373236616432666538363139366532373832376661316631616537653962373139326364316630303961666636323037393736393336633339396538363739650a656137373761663761373163643533326664333735306263633633623964
 3239

Il faudra la reporter dans le fichier des variables, comme cela a été fait plus haut, en veillant à bien copier et coller l'intégralité de la chaîne sans en déformer le format (c’est souvent source d’erreur).

Créez le fichier YAML pour le rôle confdb

Déclarez la dépendance avec le rôle commun

Pour que le rôle confdb puisse utiliser les variables enregistrées dans le rôle commun, il faut déclarer cette dépendance dans le répertoire meta :

$ vi roles/mediawiki/confdb/meta/main.yml

La déclaration se fait de la façon suivante :

Écrivez le code pour configurer MariaDB pour MediaWiki

La configuration va se faire dans le fichier suivant :

$ vi roles/mediawiki/confdb/tasks/main.yml  

Voyons ensemble le détail de ces tâches :

1. La première tâche "mediawiki database" va créer la base de données avec le module “mysql_db”. Et les options :

   • le name: "{{mediawiki_db_name}}" indique le nom de la base de données qui est récupéré de la variable mediawiki_db_name définie dans le rôle commun ;

   • le state: present indique de créer la base de données.

2. La deuxième tâche “mediawiki user+privileges” va créer un accès utilisateur et des privilèges associés sur la base de données pour tous les nodes avec le module “mysql_user”.  Et les options :

   • le name: "{{mediawiki_db_user}}" indique le nom d’utilisateur à créer ;

   • password: "{{mediawiki_db_password}}" indique le mot de passe à utiliser ;

   • priv: "{{mediawiki_db_name}}.*:ALL" indique les privilèges à donner à l’utilisateur ; 

   • host: "{{item}}" indique le node concerné par les accès ; 

   • state:present indique de créer l’utilisateur et ses accès. 

Vous remarquez que les variables communes sont utilisées ici. Cela reprend l’idée de modularité et de réutilisation des scripts.

Une nouvelle notion s’est ajoutée à la configuration :

• with_items: La boucle with_items va parcourir le groupe Apache et remplacer successivement la variable item par les noms des nodes présents dans le groupe ;

• "{{groups.apache}}" : cette variable “magique” est tirée directement du fichier inventaire. 

Créez le fichier YAML pour le rôle confapache

Déclarez la dépendance avec le rôle commun

Pour que le rôle confapache puisse utiliser les variables enregistrées dans le rôle commun , il faut déclarer cette dépendance dans le répertoire meta : 

$ vi roles/mediawiki/confapache/meta/main.yml

La déclaration se fait de la façon suivante :

Nous sommes bientôt au bout ! Vous allez maintenant terminer en configurant les fichiers MediaWiki dans Apache : 

$ viroles/mediawiki/confapache/tasks/main.yml 

Voyons le détail de ces tâches :

La première tâche, "mediawiki directory", va créer le répertoire dans lequel les fichiers MediaWiki seront placés avec le module “file”. Et les options :

• path: "{{mediawiki_directory}}" indique le chemin du répertoire à créer ;

• owner: "www-data" indique le propriétaire du répertoire ;

• group: "www-data" indique le groupe du répertoire ;

• state: directory indique de créer un répertoire.

La deuxième tâche, "mediawiki directory", va décompresser le fichier source archive MediaWiki et le renommer avec le module “unarchive”. Et les options :

• src: "{{mediawiki_archive_url}}" indique l’adresse de l’archive à télécharger ;

• dest: "{{mediawiki_directory}}" indique le chemin où doit être décompressée l’archive ;

• owner: "www-data" indique le propriétaire des fichiers ;

• group: "www-data" indique le groupe des fichiers ;

• remote_src: yes indique que la source est externe ;

• extra_opts: --transform=s/mediawiki-[0-9\.]*\/// indique de renommer le répertoire avec le nom mediawiki. 

La troisième tâche, “mediawiki configuration”, va configurer MediaWiki à l’aide d’une commande PHP en utilisant le module command. Et les arguments et options :

• become: yes indique d’utiliser un autre utilisateur ;

• become_user: "www-data" indique d’utiliser le compte Apache pour faire les actions ;

• args: indique les arguments à utiliser ;

• creates: "{{mediawiki_directory}}/LocalSettings.php" indique de ne rien faire si le fichier LocalSettings.php existe déjà : 

  • chdir: "{{mediawiki_maintenance_directory}}" indique de se placer dans le répertoire Maintenance,

  • command: indique d’utiliser le module command pour lancer le script install.php avec les options de configuration ;

• run_once: yes indique de l'exécuter une seule fois ;

• delegate_to: "{{item}}" indique de déléguer l’action à un item de la liste ;

• with_items: "{{groups.apache}}" indique le nom du node du groupe Apache défini dans l’inventair,e et le place dans Item.

La quatrième tâche, "mediawiki db update", va mettre à jour la base de données pour finir la configuration de MediaWiki avec le module command. Et les options :

• become: yes indique de prendre l’identité d’un autre utilisateur ;

• become_user: "apache" indique d’utiliser le compte Apache ;

• command: indique de lancer le script update.php à l’aide de la commande PHP et l’option rapide ;

• args: indique de se placer dans le répertoire de maintenance ;

• run_once: yes indique de faire l’action une seule fois ;

• register: resultat indique de stocker le résultat dans la variable result ; 

• changed_when: "' ...done.' in resultat.stdout" indique que le changement est effectif quand l’action retourne done.

Quelques notions particulières de ce fichier sont à préciser :

• args : la section args va mettre d'indiquer à la tâche les prérequis à l'exécution des actions ;

• run_once : l’action sera exécutée une seule fois ;

• delegate_to : la tâche est déléguée au premier node du groupe Apache. Couplée avec run_once, l’action sera exécutée sur un seul node, ce qui évitera des corruptions de base, si les actions sont jouées sur deux nodes en même temps ;

• register : va stocker le résultat de l’action dans la variable resultat. Couplé à changed_when, l'état de la tâche sera indiqué changed, si l’action retourne done.

Résumé

Dans ce chapitre,  vous avez contrôlé l'exécution des opérations et enchaîné plusieurs actions : 

• vous avez appris comment construire des fichiers de configuration YAML pour les 5 rôles ;

• vous avez utilisé les fichiers tasks, les handers et des variables globales ;

• vous avez chiffré des mots de passe et déclaré des dépendances entre les rôles.  

Dans le prochain chapitre, nous allons enfin assembler le tout pour lancer le déploiement de MediaWiki en quelques lignes de code.