Structure d'un playbook : `hosts`, `tasks`, `name`

Les piliers d'un playbook Ansible : `hosts`, `tasks` et `name`

Un playbook Ansible est bien plus qu'un simple script ; c'est un fichier YAML décrivant un ou plusieurs "jeux" (plays) à exécuter sur votre infrastructure. Chaque jeu définit un ensemble d'objectifs à atteindre sur un groupe de machines spécifique. Pour orchestrer ces jeux efficacement, Ansible s'appuie sur une structure claire et des directives clés. Parmi celles-ci, `hosts`, `tasks`, et `name` constituent les fondations de tout playbook. Comprendre leur rôle et leur interaction est essentiel pour écrire des automatisations lisibles, maintenables et efficaces.

La directive `hosts` est la première que vous rencontrerez dans un jeu ; elle détermine quelles machines de votre inventaire seront la cible des opérations. Sans elle, Ansible ne saurait où appliquer les instructions. Ensuite, le coeur de l'action réside dans la section `tasks`. C'est ici que vous listez séquentiellement les actions à effectuer, chaque action étant typiquement un appel à un module Ansible. Enfin, la directive `name`, bien que non strictement obligatoire pour l'exécution, est cruciale pour la clarté. Elle permet d'attribuer des descriptions lisibles aux jeux et aux tâches, rendant vos playbooks auto-documentés et facilitant grandement leur compréhension et leur débogage.

Cette section se propose de détailler chacune de ces directives fondamentales. Nous verrons comment les utiliser correctement, les options qu'elles offrent et comment elles s'articulent pour former la colonne vertébrale de vos playbooks Ansible. Maîtriser ces éléments vous permettra de structurer logiquement vos efforts d'automatisation et de créer des playbooks robustes dès le départ.

La directive `hosts` : cibler vos machines avec précision

Au commencement de chaque jeu (play) dans un playbook se trouve la directive `hosts`. Son rôle est fondamental : elle spécifie sur quel(s) noeud(s) géré(s) ou groupe(s) de noeuds les tâches définies dans ce jeu vont s'appliquer. Ansible consultera votre fichier d'inventaire pour résoudre les noms ou les motifs que vous fournissez ici.

La valeur de `hosts` peut prendre plusieurs formes :

• Un nom d'hôte spécifique : Par exemple, `server1.example.com`. Le jeu s'exécutera uniquement sur cette machine.
• Un nom de groupe : Défini dans votre inventaire, comme `webservers` ou `databases`. Le jeu s'exécutera sur toutes les machines appartenant à ce groupe.
• Le mot-clé `all` : Cible toutes les machines listées dans votre inventaire. A utiliser avec prudence, surtout sur de vastes parcs.
• Une liste d'hôtes ou de groupes : Vous pouvez spécifier plusieurs cibles en les séparant par des virgules (ex: `webservers,db01`) ou en utilisant une syntaxe de liste YAML (ex: `[webservers, db01]`).
• Des motifs (patterns) : Ansible permet d'utiliser des caractères génériques (`*`, `?`), des plages (`[01:50]`), et des opérateurs logiques (`:!&`) pour des ciblages plus complexes. Par exemple, `web*.example.com` ciblerait tous les serveurs dont le nom commence par `web` dans le domaine `example.com`. L'opérateur `!` permet d'exclure des hôtes (ex: `webservers:!staging-server`).

Voici quelques exemples de l'utilisation de `hosts` dans un playbook :

- name: Configurer tous les serveurs web
  hosts: webservers
  # ... tâches pour les serveurs web ...

- name: Appliquer une mise à jour critique sur un serveur spécifique
  hosts: critical-server.prod.lan
  # ... tâches pour le serveur critique ...

- name: Tâches communes à tous les serveurs sauf les serveurs de test
  hosts: all:!test_servers
  # ... tâches générales ...

La section `tasks` : définir les actions à exécuter

Une fois la cible définie avec `hosts`, la section `tasks` prend le relais pour décrire la séquence d'opérations à effectuer sur ces machines. La section `tasks` est une liste YAML, où chaque élément de la liste représente une tâche unique. Ansible exécute ces tâches dans l'ordre où elles sont définies.

Chaque tâche dans Ansible est essentiellement un appel à un module. Les modules sont les unités de travail d'Ansible ; ce sont des scripts réutilisables qui effectuent des actions spécifiques, comme installer un paquet, démarrer un service, copier un fichier, ou exécuter une commande. Chaque module accepte des arguments qui précisent son comportement. La syntaxe typique d'une tâche est la suivante :

tasks:
  - name: Description de la tâche (très recommandé)
    module_name:
      parametre1: valeur1
      parametre2: valeur2
      # ... autres paramètres ...

tasks:
  - name: S'assurer que Nginx est installé
    apt: name=nginx state=present

Ansible fournit une vaste bibliothèque de modules pour couvrir une multitude de cas d'usage, allant de la gestion des systèmes d'exploitation à l'interaction avec des services cloud ou des équipements réseau. Par exemple, pour s'assurer qu'un paquet est installé, vous utiliserez le module `apt` (pour Debian/Ubuntu) ou `yum`/`dnf` (pour RHEL/CentOS/Fedora). Pour gérer des fichiers, ce sera le module `file` ou `copy`. Pour les services, `service` ou `systemd`.

Voici un exemple simple d'une section `tasks` qui installe le paquet `vim` et s'assure que le service `cron` est démarré :

- name: Configurer les outils de base et le service cron
  hosts: all
  become: true # Nécessaire pour installer des paquets et gérer des services
  tasks:
    - name: Installer le paquet vim
      apt:
        name: vim
        state: present
        update_cache: yes

    - name: S'assurer que le service cron est démarré et activé
      service:
        name: cron
        state: started
        enabled: yes

La directive `name` : pour des playbooks lisibles et compréhensibles

Bien que techniquement optionnelle pour l'exécution brute d'un playbook, la directive `name` est une composante cruciale pour la création de playbooks de qualité professionnelle. Elle permet d'assigner une description textuelle et lisible par un humain à vos jeux (plays) et à chacune de vos tâches.

L'utilisation systématique de `name` offre plusieurs avantages significatifs :

• Lisibilité accrue : Un `name` descriptif explique l'intention du jeu ou de la tâche, rendant le playbook beaucoup plus facile à comprendre, même pour quelqu'un qui ne l'a pas écrit. Cela transforme un script potentiellement cryptique en une procédure documentée.
• Facilitation du débogage : Lorsque vous exécutez un playbook avec `ansible-playbook`, la sortie affiche le `name` de chaque tâche avant son exécution. Si une tâche échoue, son `name` est clairement indiqué, ce qui permet d'identifier rapidement où le problème s'est produit.
• Documentation intégrée : Les `name` servent de documentation au sein même du code. Cela réduit le besoin de commentaires externes excessifs.
• Meilleure collaboration : Dans un contexte d'équipe, des `name` clairs permettent à tous les membres de comprendre rapidement le rôle de chaque partie du playbook.

La directive `name` s'utilise au niveau du jeu (pour décrire l'objectif global du jeu) et au niveau de chaque tâche (pour décrire l'action spécifique de la tâche).

- name: Configurer et sécuriser les serveurs web # <-- Name pour le Play
  hosts: webservers
  become: true
  tasks:
    - name: Installer le paquet Nginx      # <-- Name pour la Tâche 1
      apt:
        name: nginx
        state: present

    - name: Copier le fichier de configuration Nginx # <-- Name pour la Tâche 2
      copy:
        src: files/nginx.conf
        dest: /etc/nginx/nginx.conf

    - name: Démarrer le service Nginx      # <-- Name pour la Tâche 3
      service:
        name: nginx
        state: started
        enabled: yes

Prendre l'habitude de donner des noms explicites et concis à tous vos jeux et tâches est l'une des meilleures pratiques les plus simples à adopter en Ansible. C'est un petit effort qui rapporte énormément en termes de maintenabilité et de compréhension à long terme de vos automatisations. Un bon `name` devrait répondre à la question : "Quel est l'objectif de cette section ou de cette action ?".