Ansible: Les rôles

Introduction

Un rôle Ansible est une manière de regrouper des tâches, des variables, des fichiers, des modèles et d'autres ressources liées à une fonctionnalité spécifique dans une structure organisée. Les rôles facilitent la réutilisation du code et la gestion des configurations complexes.

Pourquoi utiliser des rôles ?

Imaginons un playbook Ansible qui fait de la configuration pour différents serveurs. Ce playbook pourrait faire, par exemple:

Dans le contexte d'un déploiement d'un serveur web: Installer et configurer Apache, gérer les fichiers de configuration, etc.
Dans le contexte d'un déploiement d'une base de données: Installer et configurer MySQL, gérer les utilisateurs, etc.
Dans le contexte d'un déploiement d'une application: Déployer le code, configurer les services, etc.
Dans le contexte d'une gestion des utilisateurs: Créer des utilisateurs, gérer les permissions, etc.
Dans le contexte de la sécurité: Configurer les pare-feux, appliquer des politiques de sécurité, etc.
Dans le contexte de la surveillance: Installer et configurer des outils de monitoring, etc.
Dans le contexte des sauvegardes: Déployer le logiciel de sauvegarde, configurer les routines de sauvegarde, etc.

Dans tous ces cas, le playbook pourrait devenir très long et difficile à gérer:

Contenir plusieurs centaines de lignes de code, ce qui complique la lecture et la maintenance.
Rendre difficile la réutilisation de certaines parties du code dans d'autres projets.
Rendre la collaboration entre plusieurs développeurs plus complexe, car chacun pourrait travailler sur différentes parties du playbook.
Rendre la gestion des variables et des dépendances plus compliquée.
Rendre les tests et le débogage plus difficiles, car il serait compliqué d'isoler les problèmes.
Rendre la documentation du playbook plus difficile à maintenir.

En utilisant des rôles, chaque fonctionnalité peut être isolée dans son propre rôle, ce qui rend le playbook principal plus lisible et plus facile à maintenir.

Structure d'un rôle

La structure d'un rôle Ansible est généralement la suivante :

roles/
└── nom_du_role/
    ├── tasks/
    │   └── main.yml
    ├── handlers/
    │   └── main.yml
    ├── templates/
    │   └── fichier_template.j2
    ├── files/
    │   └── fichier_statique
    ├── vars/
    │   └── main.yml
    ├── defaults/
    │   └── main.yml
    ├── meta/
    │   └── main.yml
    └── README.md

Chaque répertoire a un rôle spécifique :

tasks/ : Contient les tâches à exécuter.
handlers/ : Contient les gestionnaires (handlers) qui peuvent être notifiés par les tâches.
templates/ : Contient les fichiers de modèle Jinja2 (nous verrsons cela la semaine prochaine)
files/ : Contient les fichiers statiques à copier sur les hôtes cibles.
vars/ : Contient les variables spécifiques au rôle.
defaults/ : Contient les variables par défaut.
meta/ : Contient des métadonnées sur le rôle, y compris les dépendances.
README.md : Documentation sur le rôle.

Dossier `tasks/`

Le dossier tasks/ est essentiel car il contient les tâches que le rôle exécutera. Le fichier main.yml dans ce dossier est le point d'entrée principal pour les tâches du rôle. Le fichier tasks/main.yml peut ressembler à ceci :

---
- name: Installer Apache
  apt:
    name: apache2
    state: present 
    become: yes
- name: Démarrer le service Apache
  service:
    name: apache2
    state: started
    enabled: yes

Comme vous le voyez, ce fichier contient une liste de tâches qui seront exécutées lorsque le rôle sera appelé.

Sans le fichier tasks/main.yml, le rôle ne ferait rien du tout !

Créer un rôle

Méthode 1: Manuellement

Pour créer un rôle, vous pouvez créer vos fichiers manuellement (comme montré dans le document pratique du cours) afin de respecter la structure attendue.

Méthode 2: Avec la commande `ansible-galaxy`

Ansible fournit une commande pratique pour créer la structure de base d'un rôle. Vous pouvez utiliser la commande suivante :

ansible-galaxy init nom_du_role

Cette commande crée automatiquement la structure de répertoires et les fichiers nécessaires pour un rôle nommé nom_du_role.

Utilisation des rôles

Pour utiliser un rôle dans un playbook, il suffit de l'inclure dans la section roles :

---
- name: Exemple d'utilisation des rôles
  hosts: tous
  roles:
    - nom_du_role

Lorsqu'un rôle est inclus dans un playbook, Ansible exécute les tâches définies dans le fichier tasks/main.yml du rôle, ainsi que les autres composants du rôle selon les besoins (handlers, variables, etc.).

Un rôle peut également être exécuté sous certaines conditions, ou avec des variables spécifiques, ce qui le rend très flexible.

Exemple d'une utilisation conditionnelle

---
- hosts: all
  roles:
    - role: apache
      when: ansible_os_family == "Debian"
    
    - role: nginx
      when: ansible_os_family == "RedHat"

Exemple d'utilisation avec des variables spécifiques

---
- hosts: webservers
  roles:
    - role: apache
      vars:
        apache_port: 8080
        apache_document_root: "/var/www/monsite"

Les variables

En plus des modules, tâches et handlers, les rôles peuvent également contenir des variables spécifiques qui peuvent être utilisées pour personnaliser le comportement du rôle. Les variables d'un rôle se trouvent dans les dossiers vars/ et defaults/. Les variables dans defaults/main.yml ont une priorité plus basse que celles dans vars/main.yml, ce qui permet de définir des valeurs par défaut tout en permettant aux utilisateurs de les surcharger si nécessaire.

Puisque l'intérêt des rôles est de les réutiliser, il est préférable de définir des variables générales dans defaults/main.yml, ce qui consituera les valeurs par défaut du rôle. Ensuite, lors de l'utilisation du rôle, on pourra surcharger ces variables si besoin en les définissant dans le fichier vars/main.yml du playbook (ou directement dans le playbook). Ainsi, les variables définies dans defaults/main.yml ne sont habituellement pas modifiées directement dans le rôle.

Pour un rappel de l'ordre d'importance des variables, allez voir la théorie de la semaine 11.