• 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

Organisez vos opérations de déploiement

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

 

Dans la première partie, vous avez pris connaissance du contexte dans lequel vous alliez travailler, et vous avez mis en place un environnement technique favorable pour automatiser le déploiement de MediaWiki à l’aide d'Ansible

Dans ce chapitre, vous allez transposer et organiser les opérations nécessaires à l’installation de MediaWiki, à l’aide des rôles Ansible. 

Le node manager et le node sont maintenant opérationnels. Votre travail va être d'installer le gestionnaire de wiki interne MediaWiki sur 2 serveurs, afin de le rendre utilisable par tous les salariés de l’entreprise. Pour cela, nous allons avoir besoin d'organiser nos opérations, afin de les exécuter séquentiellement avec Ansible

Icône d'un rôle

Un rôle est une structure arborescente constituée de répertoires et de fichiers de configuration YAML, qui vont avoir pour fonction d’installer tel ou tel système. Les rôles peuvent être imbriqués et interdépendants les uns des autres.

Un rôle est donc un ensemble de fichiers organisés dans une structure arborescente.

Mais à quoi ça sert ?

Le but des rôles est de pouvoir agglomérer des opérations cohérentes (dans les fichiers YAML), afin de pouvoir les réutiliser de façon modulaire. Vous pouvez voir un rôle comme un ensemble d’opérations qui ont un rôle commun, comme par exemple le rôle d’installer Apache, ou le rôle de configurer MariaDB. 

Les répertoires sont tous optionnels, excepté le répertoire tasks qui doit contenir le fichier main.yml. Ansible va traiter en premier ce fichier à l’appel d’un rôle.

Icône d'une tâche

Une tâche est une instruction décrite en YAML dans un fichier de configuration. Chaque tâche utilise un module ainsi que quelques éventuels arguments supplémentaires.

De façon schématique, vous pouvez retenir que :

  • un rôle contient un ou plusieurs fichiers de configuration (YAML) ;

  • un fichier de configuration contient une ou plusieurs tâches ;

  • une tâche fait appel à un module

Le YAML (Yet Another Markup Language). YAML permet d’écrire des structures de données qui peuvent être spécifiées sous la forme de listes.

Structurez votre déploiement avec les rôles Ansible

Identifiez les étapes pour installer MediaWiki

Vous avez vu dans la première partie de ce cours que l'installation de MediaWiki nécessitait 6 étapes que je reprends ici :

  1. Installer un serveur web Apache sur le premier serveur (http1).

  2. Installer PHP également sur le premier serveur (http1).

  3. Installer une base de données MariaDB sur le deuxième serveur (bdd1).

  4. Télécharger les fichiers sources de MediaWiki et les mettre sur le serveur web (http1).

  5. Configurer le serveur web (http1) pour pointer vers l’URL http://http1/mediawiki.

  6. Finaliser l’installation de MediaWiki via le script d’installation sur http1.

Ces 6 étapes comportent des opérations d’installation (étapes 1 à 3) et des opérations de configuration (étapes 4 à 6).

Transposez les étapes en rôles Ansible

Vous allez maintenant transposer cette logique à Ansible en utilisant les rôles.

Vous allez créer 5 rôles :

  1. Un rôle pour installer Apache : apache.

  2. Un rôle pour installer MariaDB : mariadb.

  3. Un rôle pour configurer Apache pour MediaWiki : confapache.

  4. Un rôle pour configurer MariaDB pour MediaWiki : confdb.

  5. Un rôle qui contiendra les variables globales : commun.

Vous allez donc suivre cette liste pour créer chaque rôle un par un.

Créez votre premier rôle

Vous allez commencer par créer une arborescence de fichiers de configuration qui permettra de dérouler les étapes de déploiement de MediaWiki et ensuite, dans le chapitre suivant, vous allez écrire les scripts Ansible dans  ces fichiers de configuration. Je choisis volontairement cette approche pour que vous ayez une vision structurelle avant de vous lancer dans l'écriture du code.

Où placer les rôles ?

Par défaut, Ansible va chercher les rôles dans le répertoire "roles" qui est placé dans le répertoire de travail (répertoire courant) : celui dans lequel les commandes Ansible sont lancées.

Créez le répertoire qui contiendra tous les rôles

Commencez par créer le répertoire “roles” dans votre espace de travail. Ce répertoire contiendra tous les rôles que vous allez créer.

(ansible) user-ansible@node-manager:~$ mkdir roles ; cd roles
(ansible) user-ansible@node-manager:~/roles$

Pour vous aider à créer une arborescence complète, vous pouvez utiliser la commande ansible-galaxy.

ansible-galaxy, quant à lui, est un outil de ligne de commande pour télécharger, créer et gérer les rôles Ansible. Il aurait été tout à fait possible d'utiliser un rôle de la Galaxy pour faire l'installation d'Apache, par exemple.

Utilisez ansible-galaxy pour créer automatiquement un rôle

Allez-y, maintenant ! Créez votre premier rôle pour l’installation d'Apache avec la commande ansible-galaxy et l’option init :

$ ansible-galaxy init apache

Utilisez la commande tree pour afficher l’arborescence des fichiers :

$ tree apache

Ce qui donne le résultat suivant :

(ansible) user-ansible@node-manager:~/roles$ tree
.
└── apache
     ├── defaults
     │ └── main.yml
     ├── files
     ├── handlers
     │ └── main.yml
     ├── meta
     │ └── main.yml
     ├── README.md
     ├── tasks
     │ └── main.yml
     ├── templates
     ├── tests
     │ ├── inventory
     │ └── test.yml
     └── vars
     └── main.yml

9 directories, 8 files

L'arborescence contient les répertoires suivants :

  • files : tous les fichiers à copier sur le node ;

  • templates : tous les fichiers de template Jinja ;

  • tasks : liste des instructions à exécuter (le fichier main.yml est obligatoire) ;

  • handlers : même chose pour les instructions handlers (le fichier main.yml est obligatoire) ;

  • vars : fichier contenant des déclarations de variables (le fichier main.yml est obligatoire) ; les variables définies ici sont prioritaires par rapport aux variables définies dans l'inventaire ;

  • defaults : valeurs par défaut (le fichier main.yml est obligatoire) avec une priorité moindre ;

  • meta : dépendances du rôle et informations (auteur, licence, plateformes...) sur le rôle (le fichier main.yml est obligatoire).

À la création de l’arborescence, les fichiers sont vides ! Il conviendra de les compléter en fonction des opérations à réaliser. Vous avez compris qu’un rôle est avant tout une arborescence de fichiers qui contiendra des actions Ansible. 

Créez l’arborescence de vos rôles MediaWiki

Vous allez créer, un à un, la structure des 5 rôles pour le déploiement de MediaWiki.

Créez le rôle Apache

Assurez-vous que vous êtes bien dans le répertoire roles.

(ansible2.7.10) user-ansible@node-manager:~/roles$

Vous avez déjà créé la structure du rôle Apache

Pour installer Apache et PHP, vous avez besoin d’installer des paquets logiciels sur Linux et de redémarrer le service Apache pour que les modifications soient prises en compte.

Vous auriez pu conserver cette arborescence telle quelle, mais pour votre simple besoin qui consiste à installer Apache et PHP, vous allez faire un peu de toilettage pour garder uniquement les répertoires nécessaires. 

Seuls les répertoires handlers, meta et tasks seront conservés :

  • handlers : contient les tâches à exécuter après une notification (redémarrer le service Apache) ;

  • tasks :  contient les tâches à exécuter pour installer Apache.

Après avoir supprimé les répertoires inutiles avec la commande :

(ansible) user-ansible@node-manager:~/roles/apache$ rm -rf defaults/ files/ meta/ template/ tests/ vars/ README.md
'ansible) user-ansible@node-manager:~/roles/apache$

voici ce que donne la nouvelle arborescence :

(ansible) user-ansible@node-manager:~/roles/apache$ tree
.
├── handlers
  └── main.yml
└── tasks
  └── main.yml 

Créez le rôle mariadb

Pour le rôle mariadb,  vous avez besoin d’installer des paquets logiciels sur Linux et démarrer un service.

Vous n’avez donc pas besoin d'utiliser ansible-galaxy pour le rôle mariadb, un seul fichier de configuration est nécessaire ici :

(ansible) user-ansible@node-manager:~/roles$ mkdir -p mariadb/tasks
(ansible) user-ansible@node-manager:~/roles$ touch mariadb/tasks/main.yml

Le fichier main.yml contiendra les tâches à exécuter pour installer MariaDB

Voici l’arborescence :

(ansible) user-ansible@node-manager:~/roles$ tree mariadb/mariadb/
└── tasks
   └── main.yml

1 directory, 1 file

Comme les opérations de configuration et les variables concernent spécifiquement le déploiement de MediaWiki, les rôles de configuration et commun vont être placés spécifiquement dans un répertoire mediawiki

Nous créons donc un répertoire :

$ mkdir mediawiki

Ce qui donne à ce stade :

(ansible) user-ansible@node-manager:~/role$ tree
.
├── apache
│ ├── handlers
│ │ └── main.yml
│ └── tasks
│   └── main.yml
├── mariadb
│ └── tasks
│   └── main.yml
└── mediawiki

6 directories, 3 files

Créez le rôle commun

Le rôle commun contiendra des variables partagées entre les rôles confapache et confdb. Ainsi, au lieu de définir les mêmes variables à deux endroits différents, il est préférable de créer un rôle commun, et d’utiliser une dépendance avec les autres rôles.

Pour cela, vous avez besoin du répertoire defaults et du fichiers main.yml qui contiendront les variables globales :

$ mkdir -p mediawiki/commun/defaults/
$ touch mediawiki/commun/defaults/main.yml

Ce qui donne :

(ansible) user-ansible@node-manager:~/roles$ tree  mediawiki/
mediawiki/
 └── commun
   └── defaults
     └── main.yml

2 directories, 1 file

Créez le rôle confdb

Pour le rôle confdb, vous avez besoin de créer une base de données et d'attribuer des droits sur cette base.

Et vous créerez une dépendance avec le rôle commun pour partager des variables globales

Pour cela, vous avez besoin des répertoires meta et tasks :

$ mkdir -p mediawiki/confdb/meta mediawiki/confdb/tasks

et des fichiers main.yml qui contiendront les actions :

$ touch mediawiki/confdb/tasks/main.yml 
$ touch mediawiki/confdb/meta/main.yml

Ce qui donne :

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

5 directories, 3 files

Créez le rôle confapache

Vous allez partager des variables globales avec le rôle confdb, alors vous ajouterez une dépendance avec le rôle commun.

Vous allez également créer le répertoire d'installation de MediaWiki, télécharger les fichiers MediaWiki sur le site officiel, lancer le script d’installation et mettre  à jour la base de données.

Pour cela, vous avez besoin des répertoires meta et tasks :

~/roles/mediawiki$ mkdir -p confapache/meta confapache/tasks 

et des fichiers main.yml qui contiendront les actions :

$ touch confapache/tasks/main.yml confapache/meta/main.yml

Ce qui donne l'arborescence suivante :

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

8 directories, 5 files

Améliorez  l'inventaire en vue du déploiement

Toujours dans l’esprit de modularité, vous allez modifier le fichier inventaire.ini pour séparer les deux nodes dans deux groupes distincts.

Ce qui permettra par la suite de s’adresser à un groupe plutôt qu’aux nodes directement. De cette façon, si vous voulez ajouter un node, vous aurez simplement à ajouter le node dans le bon groupe dans le fichier inventaire, et à rejouer vos scripts sans rien changer d’autre. Magique !

Connectez-vous sur le node manager :

$ ssh user-ansible@node-manager

Activez l'environnement virtuel :

$ source ansible2.7.10/bin/activate

Éditez le fichier inventaire.ini

$ vi inventaire.ini 
[apache]
http1
[db]
bdd1

Nous avons ici deux groupes entre crochets qui contiennent un node chacun.

Le fichier inventaire est très souple, il permet des combinaisons intéressantes et surprenantes : node[1:2] pour 2 nodes ou [linux:children] pour un groupe qui contient d’autres groupes.

Résumé

Dans ce chapitre,  vous avez organisé les opérations d’’automatisation avec les rôles Ansible :

  • vous avez réparti votre installation de MediaWiki sur deux groupes de serveurs, dans l’optique de pouvoir faire évoluer votre infrastructure ;

  • vous avez compris comment créer un rôle et identifier le contenu de l’arborescence d’un rôle ;

  • vous avez élaboré une arborescence globale pour les rôles prédéfinis, en vue de faire un déploiement structuré et automatisé de MediaWiki.

Dans le prochain chapitre, nous allons voir comment contrôler l'exécution des opérations et enchaîner plusieurs actions en paramétrant les rôles.

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