Ecriture du playbook pas à pas

Construire notre playbook Nginx : de la page blanche au code fonctionnel

Maintenant que notre scénario – installer et démarrer Nginx – est clairement défini, nous allons passer à l'étape cruciale : l'écriture du playbook Ansible. Ce processus peut sembler complexe au premier abord, mais en le décomposant en étapes logiques et en s'appuyant sur les concepts que nous avons vus précédemment (structure YAML, directives `hosts`, `tasks`, `name`, et modules), il devient beaucoup plus accessible.

Nous allons construire notre playbook ligne par ligne, ou plutôt section par section, en expliquant la raison d'être de chaque élément. Nous commencerons par la structure de base d'un jeu (play), puis nous ajouterons les tâches nécessaires pour atteindre notre objectif. Pour cet exemple, nous supposerons que nos serveurs cibles sont basés sur Debian ou Ubuntu, ce qui nous amènera à utiliser le module `apt` pour la gestion des paquets et `service` (ou `systemd`) pour la gestion du service Nginx. Si vos serveurs utilisent une autre distribution, les modules et certains paramètres devront être adaptés (par exemple, `yum` ou `dnf` pour les distributions basées sur RHEL).

L'objectif est de créer un fichier, que nous pourrions nommer `nginx_setup.yml`, qui contiendra toutes les instructions pour qu'Ansible configure Nginx comme souhaité. Suivez attentivement chaque étape pour bien comprendre comment les différentes pièces du puzzle s'assemblent pour former un playbook cohérent et fonctionnel.

Etape 1 : Initialiser le playbook et définir le jeu (play)

Tout playbook Ansible commence par une liste de jeux (plays). Pour notre scénario simple, nous n'aurons besoin que d'un seul jeu. Un jeu commence par un tiret (`-`) car il s'agit d'un élément d'une liste YAML.

La première chose à définir dans notre jeu est un nom descriptif et les hôtes cibles. Nous allons également anticiper le besoin d'élévation de privilèges pour l'installation de paquets et la gestion de services.

Créez un fichier nommé `nginx_setup.yml` et ajoutez le contenu suivant :

-
  name: Installer et démarrer Nginx
  hosts: webservers
  become: true

• `-` : Indique le début d'un nouveau jeu (play) dans la liste des jeux du playbook.
• `name: Installer et démarrer Nginx` : Donne un nom lisible à notre jeu. Cela apparaîtra dans la sortie d'Ansible lors de l'exécution.
• `hosts: webservers` : Spécifie que ce jeu s'appliquera à tous les hôtes appartenant au groupe `webservers` défini dans notre fichier d'inventaire. Assurez-vous d'avoir un groupe `webservers` dans votre inventaire, ou remplacez-le par `all` ou un nom d'hôte spécifique pour vos tests.
• `become: true` : Indique qu'Ansible doit utiliser l'élévation de privilèges (par défaut, `sudo` pour devenir `root`) pour exécuter les tâches de ce jeu. C'est nécessaire car l'installation de paquets et la gestion des services requièrent des droits d'administrateur.

A ce stade, notre playbook a une structure de base, mais il ne contient encore aucune action concrète. La prochaine étape est d'ajouter les tâches.

Etape 2 : Ajouter la tâche d'installation de Nginx

Sous la section du jeu, nous allons maintenant définir la liste des tâches (`tasks`). Chaque tâche sera également un élément d'une liste YAML, commençant donc par un tiret, et aura un nom descriptif et un appel à un module Ansible.

La première tâche consiste à s'assurer que Nginx est installé. Pour les systèmes Debian/Ubuntu, nous utilisons le module `apt`. Pour d'autres systèmes, vous adapteriez avec `yum`, `dnf`, etc.

Modifiez votre fichier `nginx_setup.yml` pour y ajouter la section `tasks` et la première tâche :

-
  name: Installer et démarrer Nginx
  hosts: webservers
  become: true
  tasks:
    - name: S'assurer que Nginx est installé (via apt)
      apt:
        name: nginx
        state: present
        update_cache: yes

• `tasks:` : Ce mot-clé introduit la liste des tâches pour ce jeu. Notez son indentation, elle est au même niveau que `name`, `hosts`, et `become` du jeu.
• `- name: S'assurer que Nginx est installé (via apt)` : La première tâche de notre liste. Encore une fois, un nom descriptif est crucial.
• `apt:` : C'est le nom du module Ansible que nous utilisons. Les lignes suivantes, indentées sous `apt:`, sont les paramètres de ce module.
• `name: nginx` : Spécifie le nom du paquet à gérer, ici `nginx`.
• `state: present` : C'est un paramètre clé pour l'idempotence. Il indique à Ansible de s'assurer que le paquet est présent. S'il est déjà installé, Ansible ne fera rien. S'il est absent, Ansible l'installera. D'autres valeurs possibles pour `state` incluent `latest` (pour s'assurer que la dernière version est installée) ou `absent` (pour désinstaller un paquet).
• `update_cache: yes` : Ce paramètre demande au module `apt` de mettre à jour le cache des paquets (équivalent à `apt-get update`) avant de tenter d'installer le paquet. C'est une bonne pratique pour s'assurer que la liste des paquets disponibles est à jour. Ce paramètre n'est pas toujours nécessaire si vous gérez la mise à jour du cache par une autre tâche dédiée.

Etape 3 : Ajouter la tâche de gestion du service Nginx

Une fois Nginx installé, nous devons nous assurer que son service est démarré et qu'il est configuré pour démarrer automatiquement avec le système. Pour cela, nous allons utiliser le module `service` (qui est un wrapper générique fonctionnant sur de nombreux systèmes) ou, sur des systèmes plus récents, on pourrait utiliser directement le module `systemd` si l'on sait que `systemd` est l'init system.

Ajoutons cette deuxième tâche à notre playbook :

-
  name: Installer et démarrer Nginx
  hosts: webservers
  become: true
  tasks:
    - name: S'assurer que Nginx est installé (via apt)
      apt:
        name: nginx
        state: present
        update_cache: yes

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

• `- name: S'assurer que le service Nginx est démarré et activé` : Le nom de notre deuxième tâche.
• `service:` : Le module Ansible pour gérer les services.
• `name: nginx` : Le nom du service à gérer. Ce nom peut varier légèrement selon les distributions (parfois `nginx.service` pour `systemd`), mais `nginx` est commun.
• `state: started` : Indique à Ansible de s'assurer que le service est démarré. S'il est déjà démarré, Ansible ne fera rien. S'il est arrêté, Ansible le démarrera. D'autres états possibles sont `stopped`, `restarted`, `reloaded`.
• `enabled: yes` : Indique à Ansible de s'assurer que le service est configuré pour démarrer automatiquement au lancement du système (création des liens symboliques nécessaires dans `/etc/rcX.d/` ou équivalents `systemd`). Si `enabled: no`, le service serait désactivé du démarrage automatique.

Notre playbook est maintenant complet pour le scénario défini. Il va :

1. Cibler le groupe `webservers`.
2. Utiliser `sudo` pour les privilèges.
3. Mettre à jour le cache `apt` et installer `nginx` s'il n'est pas déjà présent.
4. Démarrer le service `nginx` s'il n'est pas déjà démarré et l'activer pour le démarrage automatique.

Voici le playbook complet `nginx_setup.yml` :

---
- name: Installer et démarrer Nginx
  hosts: webservers
  become: true
  tasks:
    - name: S'assurer que Nginx est installé (via apt)
      apt:
        name: nginx
        state: present
        update_cache: yes
      tags:
        - installation
        - nginx

    - name: S'assurer que le service Nginx est démarré et activé
      service:
        name: nginx
        state: started
        enabled: yes
      tags:
        - configuration
        - nginx