Lab 08 : Utilisation des Handlers dans les Playbooks

Objectifs

Dans ce TP, vous allez apprendre à :

• Utiliser les handlers dans les playbooks Ansible pour exécuter des actions en réponse à des changements.
• Configurer les handlers pour des tâches spécifiques, comme redémarrer des services ou notifier d’autres actions après modification.
• Organiser et optimiser l’utilisation des handlers dans des scénarios complexes.

Prérequis

Avant de commencer ce TP, assurez-vous d’avoir :

• Complété les TPs précédents sur Ansible.
• Configuré AWS CLI et Ansible sur votre machine.
• Des connaissances de base sur les tâches dans Ansible.

Architecture du TP

Dans cette partie, vous allez apprendre à :

• Créer et utiliser des handlers pour exécuter des actions conditionnelles après des changements.
• Comprendre comment et quand les handlers sont déclenchés.
• Structurer un playbook pour utiliser efficacement les handlers.

Introduction aux Handlers

Les handlers dans Ansible sont des tâches spéciales qui ne sont exécutées que lorsqu’elles sont “notifiées” par d’autres tâches qui ont marqué leur état comme “changed”. Ils sont couramment utilisés pour des actions comme redémarrer des services après modification de fichiers de configuration.

Création d’un Handler Simple

1. Créez un fichier playbook nommé handlers.yaml :

---
- name: Exemple d'utilisation des handlers dans Ansible
  hosts: webservers
  tasks:
    - name: Installer le paquet Nginx
      become: true
      ansible.builtin.apt:
        name: nginx
        state: present
      notify: restart nginx

    - name: Créer un fichier de configuration Nginx
      become: true
      ansible.builtin.copy:
        dest: /etc/nginx/conf.d/custom.conf
        content: |
          server {
              listen 80;
              server_name localhost;
              location / {
                  root /usr/share/nginx/html;
                  index index.html;
              }
          }
      notify: restart nginx

  handlers:
    - name: restart nginx
      become: true
      ansible.builtin.service:
        name: nginx
        state: restarted

2. Exécutez le playbook pour observer comment le handler est déclenché lorsque les tâches notifient un changement :

ansible-playbook handlers.yaml

3. Vérifiez que le service Nginx est redémarré uniquement lorsque l’une des tâches précédentes modifie quelque chose.

Utilisation de Handlers Multiples

Vous pouvez utiliser plusieurs handlers dans un même playbook pour gérer différents services ou actions à effectuer.

Création de Handlers Multiples

1. Modifiez le fichier handlers.yaml pour inclure plusieurs handlers :

- name: Exemple d'utilisation de multiples handlers dans Ansible
  hosts: webservers
  tasks:
    - name: Installer Nginx
      become: true
      ansible.builtin.apt:
        name: nginx
        state: present
      notify: restart nginx

    - name: Installer MySQL
      ansible.builtin.apt:
        name: mysql-server
        state: present
      notify: restart mysql

    - name: Créer un fichier de configuration Nginx
      become: true
      ansible.builtin.copy:
        dest: /etc/nginx/conf.d/custom.conf
        content: |
          server {
              listen 80;
              server_name localhost;
              location / {
                  root /usr/share/nginx/html;
                  index index.html;
              }
          }
      notify: restart nginx

    - name: Créer un fichier de configuration MySQL
      become: true
      ansible.builtin.copy:
        dest: /etc/mysql/mysql.conf.d/custom.cnf
        content: |
          [mysqld]
          bind-address = 127.0.0.1
      notify: restart mysql

  handlers:
    - name: restart nginx
      become: true
      ansible.builtin.service:
        name: nginx
        state: restarted

    - name: restart mysql
      become: true
      ansible.builtin.service:
        name: mysql
        state: restarted

1. Exécutez le playbook et observez le déclenchement des handlers associés :

ansible-playbook handlers.yaml

1. Vérifiez que chaque service est redémarré uniquement si les fichiers de configuration respectifs ont été modifiés.

Utilisation Avancée des Handlers

Dans des scénarios plus complexes, vous pouvez structurer vos playbooks pour notifier des handlers dans différentes conditions ou utiliser des handlers pour des actions plus complexes.

Déclenchement Conditionnel et Chaînage de Handlers

1. Modifiez le fichier handlers.yaml pour ajouter des déclenchements conditionnels et un chaînage de handlers :

---
- name: Exemple avancé d'utilisation des handlers dans Ansible
  hosts: webservers
  tasks:
    - name: Installer Nginx
      become: true
      ansible.builtin.apt:
        name:
          - nginx
          - mysql
        state: present
      notify: restart nginx

    - name: Créer un fichier de configuration Nginx
      become: true
      ansible.builtin.copy:
        dest: /etc/nginx/conf.d/custom.conf
        content: |
          server {
              listen 80;
              server_name localhost;
              location / {
                  root /usr/share/nginx/html;
                  index index.html;
              }
          }
      notify:
        - restart nginx
        - notify admin

    - name: Créer un fichier de configuration MySQL
      become: true
      ansible.builtin.copy:
        dest: /etc/mysql/mysql.conf.d/custom.cnf
        content: |
          [mysqld]
          bind-address = 127.0.0.1
      notify: restart mysql

  handlers:
    - name: restart nginx
      become: true
      ansible.builtin.service:
        name: nginx
        state: restarted

    - name: restart mysql
      become: true
      ansible.builtin.service:
        name: mysqld
        state: restarted

    - name: notify admin
      ansible.builtin.debug:
        msg: "Le fichier de configuration Nginx a été modifié et Nginx a été redémarré."

1. Exécutez le playbook pour tester le chaînage de handlers et les notifications conditionnelles :

ansible-playbook handlers.yaml

1. Observez que le handler notify admin est appelé uniquement après que le fichier de configuration Nginx a été modifié et que Nginx a été redémarré.

Optimisation de l’Utilisation des Handlers

Pour optimiser l’utilisation des handlers, vous pouvez les structurer pour gérer efficacement les changements multiples ou minimiser les redémarrages inutiles.

Exemple d’Optimisation

1. Créez un playbook handlers_optimization.yaml pour regrouper les notifications :

---
- name: Optimisation de l'utilisation des handlers dans Ansible
  hosts: webservers
  tasks:
    - name: Créer les fichiers de configuration
      block:
        - name: Créer le fichier de configuration principal de Nginx
          ansible.builtin.copy:
            dest: /etc/nginx/nginx.conf
            content: |
              user nginx;
              worker_processes auto;
              error_log /var/log/nginx/error.log;
              pid /run/nginx.pid;

        - name: Créer le fichier de configuration custom de Nginx
          ansible.builtin.copy:
            dest: /etc/nginx/conf.d/custom.conf
            content: |
              server {
                  listen 80;
                  server_name localhost;
                  location / {
                      root /usr/share/nginx/html;
                      index index.html;
                  }
              }

      notify: restart nginx

  handlers:
    - name: restart nginx
      ansible.builtin.service:
        name: nginx
        state: restarted

1. Exécutez le playbook pour vérifier l’optimisation :

ansible-playbook handlers_optimization.yaml

1. Observez que Nginx n’est redémarré qu’une seule fois, même si plusieurs fichiers de configuration sont modifiés.

Validation du TP

Pour valider ce TP, assurez-vous que :

1. Les handlers sont correctement utilisés pour gérer les redémarrages de services ou d’autres actions après un changement.
2. Les handlers multiples sont utilisés efficacement pour différents services ou notifications.
3. Les handlers sont déclenchés de manière conditionnelle et chaînée pour des actions plus complexes.
4. L’optimisation des handlers est réalisée pour minimiser les redémarrages ou actions inutiles.

Challenge

Pour aller plus loin, essayez les défis suivants :

• Créez un playbook qui gère la configuration et le redémarrage de plusieurs services, en utilisant des handlers pour orchestrer les actions de manière optimale.
• Utilisez des handlers pour notifier des actions externes, comme envoyer un email ou déclencher une alerte, après la modification de configurations critiques.
• Implémentez un scénario où un service est redémarré seulement si plusieurs fichiers de configuration ont été modifiés.