Les rôles Ansible: Un guide complet Role Part 1.2.3

Introduction

Pourquoi un puzzle en photo de couverture ? Ansible est un outil puissant d’automatisation des tâches système et réseau. L’utilisation de rôles est une pratique courante pour organiser et partager des tâches complexes de manière modulaire et réutilisable. Les pièces d’un puzle peut être rammené au roles car nous avons cette notions d’assemblage de morceaux qui s’emboîtent. Ce guide vous présente les concepts clés des rôles Ansible et leur utilisation efficace.

Définition : Un rôle Ansible est un ensemble de fichiers regroupant des tâches, des variables, des modèles liés à une fonctionnalité ou un domaine spécifique.

Les rôles offrent plusieurs avantages:

Les rôles dans Ansible offrent plusieurs avantages, notamment en matière de structuration, de réutilisabilité et de maintenance des configurations. Voici les principaux avantages d’utiliser des rôles dans Ansible :

1. Structuration et Organisation

Un rôle permet de structurer et d’organiser votre code Ansible en composants logiques. Chaque rôle peut contenir des tâches, des handlers, des templates, des fichiers, des variables et des métadonnées spécifiques à une fonction ou un service particulier. Cela rend le code plus facile à comprendre et à maintenir. (Le contenu est expliqué plus bas)

A. Variables Scopées

Les rôles permettent de scoper les variables, ce qui signifie que les variables définies dans un rôle sont limitées à ce rôle. Cela réduit les risques de conflits de variables entre différents rôles et playbooks.

2. Réutilisabilité

Les rôles encouragent la réutilisabilité du code. Une fois qu’un rôle est créé pour configurer une application ou un service, il peut être utilisé dans différents playbooks et projets. Cela évite la duplication du code et permet de standardiser les configurations. Nous pouvons aller plus loin en le partageant au monde ?

Collaboration et Partage

Les rôles peuvent être partagés et distribués facilement. Ils peuvent être stockés dans des dépôts Git ou publiés sur Ansible Galaxy, permettant à d’autres utilisateurs de les télécharger et de les utiliser. Cela favorise la collaboration et le partage des meilleures pratiques au sein de la communauté.

3. Simplicité et Clarté

L’utilisation de rôles simplifie les playbooks en les rendant plus clairs et plus concis.

Exemple : Au lieu d’avoir un long fichier avec 35 tâches dans le playbook contenant toutes les tâches, les rôles permettent de diviser les tâches en composants modulaires 10 tâche en début (pre-task), 10 tâches principales et 10 en fin de tache (post-task) et 5 dans le handlers.

Playbook avec pre_tasks et post_tasks

Voici le playbook principal qui utilise le rôle my_role et inclut des pre_tasks et post_tasks.

---
- hosts: webservers
  pre_tasks:
    - name: Ensure Python is installed
      raw: test -e /usr/bin/python || (apt -y update && apt install -y python-minimal)
      become: true
      changed_when: false

  roles:
    - role: my_role

  post_tasks:
    - name: Verify Nginx is running
      service:
        name: nginx
        state: started
      become: true

    - name: Display Nginx status
      command: systemctl status nginx
      register: nginx_status
      become: true

    - name: Show Nginx status
      debug:
        var: nginx_status.stdout

Cela facilite la lecture et la compréhension du playbook.

Maintenance Facilitée

La maintenance du code est plus simple avec des rôles. Les modifications peuvent être apportées dans un rôle spécifique sans affecter les autres parties du playbook. Cela permet une gestion plus efficace des mises à jour et des corrections de bugs.

Gestion des Dépendances

Les rôles peuvent spécifier des dépendances avec d’autres rôles. Cela permet de créer des configurations plus complexes en s’appuyant sur des composants modulaires. Ansible gère automatiquement l’ordre d’exécution des rôles en fonction de leurs dépendances.

Définir et utiliser des rôles

Pour créer un rôle, utilisez la commande ansible-galaxy:

$ ansible-galaxy role init mon_role
$ ansible-galaxy role --init-path toto/mon_role #Installe dans le dossier toto dans le dossier courant 

Pour ajouter un rôle, depuis le repo publique de ansible galaxy:

$ ansible-galaxy role install geerlingguy.docker

Pour supprimer un rôle, utilisez la commande ansible-galaxy:

$ ansible-galaxy remove mon_role

Pour lister un rôle, utilisez la commande ansible-galaxy:

$ ansible-galaxy list

Exemple de Structure d’un Rôle

Après avoir initié un rôle Ansible pour la première fois une structure de répertoire standard s’initialise:

Chaque fichier joue un rôle spécifique:
• defaults/main.yml: Définit les variables par défaut du rôle, pouvant être écrasées par des valeurs spécifiques dans le playbook , voir la précédence de variable. (niveau 1)

---
# defaults/main.yml

# Nginx configuration
nginx_package: nginx
nginx_service: nginx
nginx_conf_path: /etc/nginx/nginx.conf
nginx_user: www-data
nginx_worker_processes: auto
nginx_worker_connections: 1024

• files/index.html: Contient TOUS les fichiers statiques (scripts, configurations, fichier plat) à copier sur les hôtes cibles. Un fichier statique veut dire qu’il ne changera pas de contenu. Grace au module « copy » Ansible cherchera en premier lieux dans le dossier « files » pour le coller dans le chemin de destination (dest).

- name: Copy index.html to web root
  copy:
    src: index.html
    dest: /var/www/html/index.html
  become: true

• handlers/main.yml: Contient les trigger à déclencher en réponse à des notifications provenant des tâches.

---
# handlers/main.yml
- name: Restart Nginx
  service:
    name: nginx
    state: restarted
  become: true

• meta/main.yml: Fournit des informations sur le rôle, telles que la description, les dépendances et les licences.

---
dependencies:
  - role: mon_role_control #mon_role_control sera exécuter avant tout
    vars:
      variable: verif_norme

• tasks/*.yml: Définit les tâches principales à exécuter par le rôle.

---
# Installation and configuration tasks install.yml

- name: Install Nginx
  apt:
    name: "{{ nginx_package }}"
    state: present
  become: true

- name: Configure Nginx
  template:
    src: nginx.conf.j2
    dest: "{{ nginx_conf_path }}"
  notify:
    - Restart Nginx
  become: true

- name: Ensure Nginx is running
  service:
    name: "{{ nginx_service }}"
    state: started
    enabled: true
  become: true

- name: Deploy application from Git
  git:
    repo: "{{ git_repo_url }}"
    dest: "{{ app_root }}"
    version: "{{ git_branch }}"
  become: true

• templates/*.j2: Contient les modèles Jinja2 à rendre et à déployer sur les hôtes. Un fichier Jinja2 se termine par l’extention .j2 (nginx.conf.j2), la différence avec le dossier « files » est que les variables du contenu du fichier change. (Exemple : nginx_user, nginx_worker_processes, nginx_worker_connections…)

# templates/nginx.conf.j2

user {{ nginx_user }};
worker_processes {{ nginx_worker_processes }};

events {
    worker_connections {{ nginx_worker_connections }};
}

http {
    server {
        listen {{ app_port }};
        root {{ app_root }};
        index {{ app_index }};

        location / {
            try_files $uri $uri/ =404;
        }
    }
}

• README.md: Fournit une documentation descriptive du rôle, de son utilisation et de ses fonctionnalités.

Memo :

Playbook/roles/mon_premier_role/
├── defaults/main.yml # Variables par défaut du rôle
├── files/ # Fichiers statiques à copier sur les hôtes
├── handlers/main.yml # Fichier déclencher par notification
├── meta/main.yml # Informations sur le rôle et dépendance (métadonnées)
├── tasks/main.yml # Tâches principales à exécuter
├── templates/*.j2 # Modèles Jinja2 à rendre
└── README.md # Documentation du rôle

Voici un bref résumé des éléments d’un role

Maîtrisez les imports, includes dans vos playbooks Ansible

Ansible offre des fonctionnalités puissantes pour organiser et structurer vos playbooks. Les imports, includes permettent de réutiliser du code, de gérer des dépendances et d’exécuter des tâches de manière conditionnelle, améliorant ainsi la lisibilité et la maintenabilité de vos playbooks.

Différences entre import et include

• Import:
○ Statique: Chargé au moment de la compilation du playbook. (Au tout début, dès le lancement)
○ Importation complète: Importe toutes les tâches ou rôles définis dans le fichier source.
○ Utilisé pour: Inclure des éléments réutilisables fréquemment, comme des tâches de configuration communes ou des rôles complets.
• Include:
○ Dynamique: Chargé au moment de l’exécution du playbook.
○ Importation sélective: Permet d’importer des tâches ou rôles spécifiques en fonction de conditions ou de variables.
○ Utilisé pour: Inclure des tâches conditionnelles, des fragments de code spécifiques ou des variables dynamiques.

Exemple:

Import du rôle « webserver » complet

import_role: webserver

Importation partielle de rôles

L’option task_from permet d’importer des tâches spécifiques d’un rôle:

include_role: webserver
tasks_from: configure_nginx.yml

Importation de la tâche « install_nginx » du rôle « webserver »

import_role: webserver
tasks_from: install_nginx.yml

.

Explication des chemins sur Ansible

Ansible utilise des chemins spécifiques pour trouver des rôles, des fichiers de scripts, des modèles et d’autres ressources nécessaires à l’exécution de vos playbooks. Comprendre où Ansible cherche ces éléments peut vous aider à organiser vos projets plus efficacement.

Où Ansible cherche les rôles ?

Ansible cherche les rôles dans des répertoires définis par la variable role_path dans le fichier de configuration ansible.cfg, ainsi que dans les chemins spécifiés par la variable d’environnement ANSIBLE_ROLE_PATH.

Configuration role_path dans ansible.cfg

[defaults]
role_path = galaxy_roles:roles

• galaxy_roles: Ce répertoire est souvent utilisé pour stocker les rôles téléchargés depuis Ansible Galaxy.
• roles: Ce répertoire est généralement utilisé pour les rôles définis localement dans votre projet.

Ansible va chercher les rôles dans l’ordre où les chemins sont définis dans role_path. Si un rôle n’est pas trouvé dans le premier répertoire, il cherchera dans le suivant.

Variable d’environnement ANSIBLE_ROLE_PATH

Vous pouvez également définir la variable d’environnement ANSIBLE_ROLE_PATH pour spécifier des chemins de recherche supplémentaires pour les rôles. Cette variable peut contenir plusieurs chemins séparés par des deux-points (:) sous Unix/Linux ou par un point-virgule (;) sous Windows.

export ANSIBLE_ROLE_PATH=/custom/role/path:/another/role/path

Où Ansible cherche les fichiers pour les modules script, copy, et template

Lorsque vous utilisez les modules script, copy, ou template, Ansible suit une hiérarchie de répertoires pour trouver les fichiers source.

Hiérarchie de recherche pour les modules script et copy

./roles/role_name/files/

./roles/role_name/

./roles/role_name/tasks/files/

./roles/role_name/tasks/

./files/

./

Hiérarchie de recherche pour le module template

./roles/role_name/templates/

./roles/role_name/

./templates/

./

Exemple pratique

Considérons un exemple où vous avez une structure de répertoires suivante :

project/
├── ansible.cfg
├── playbook.yml
├── roles/
│   ├── my_role/
│   │   ├── files/
│   │   │   └── my_script.sh
│   │   ├── templates/
│   │   │   └── my_template.j2
│   │   ├── tasks/
│   │   │   └── main.yml
│   │   └── handlers/
│   │       └── main.yml
│   ├── another_role/
│   │   ├── files/
│   │   │   └── another_script.sh
│   │   ├── templates/
│   │   │   └── another_template.j2

Utilisation du module script ou copy

Si vous utilisez le module script pour exécuter my_script.sh dans le rôle my_role, Ansible cherchera le fichier dans l’ordre suivant :

1. project/roles/my_role/files/my_script.sh
2. project/roles/my_role/my_script.sh
3. project/roles/my_role/tasks/files/my_script.sh
4. project/roles/my_role/tasks/my_script.sh
5. project/files/my_script.sh
6. project/my_script.sh

Utilisation du module template

Si vous utilisez le module template pour déployer my_template.j2 dans le rôle my_role, Ansible cherchera le fichier dans l’ordre suivant :

1. project/roles/my_role/templates/my_template.j2
2. project/roles/my_role/my_template.j2
3. project/templates/my_template.j2
4. project/my_template.j2

Conclusion

En conclusion, Ansible est un outil extrêmement puissant pour l’automatisation des tâches système et réseau, permettant de structurer, réutiliser et maintenir des configurations de manière efficace. Les rôles Ansible jouent un rôle crucial en offrant une organisation modulaire, la réutilisabilité, et en facilitant la collaboration et le partage de configurations entre équipes. Ce guide a illustré comment créer, structurer et utiliser des rôles Ansible tout en expliquant les chemins de recherche pour divers modules.

En résumé, les rôles Ansible permettent une gestion plus simple et plus claire des tâches complexes, réduisent les risques de conflits de variables, et encouragent une collaboration efficace grâce à des configurations réutilisables et partageables. En comprenant et en utilisant les chemins de recherche de manière appropriée, vous pouvez optimiser l’organisation de vos projets Ansible et assurer une exécution sans faille de vos playbooks.

En maîtrisant ces concepts, vous serez en mesure de tirer pleinement parti des capacités d’Ansible, garantissant ainsi une automatisation robuste et efficace de vos environnements de travail.

Résumé