Lab 10 : Utilisation des Blocks dans les Playbooks

Objectifs

Dans ce TP, vous allez apprendre à :

• Utiliser les blocks dans les playbooks Ansible pour organiser et regrouper des tâches.
• Gérer les erreurs et les exceptions dans les blocs avec rescue et always.
• Réutiliser des blocs de manière conditionnelle pour simplifier la gestion de tâches 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 et les handlers dans Ansible.

Architecture du TP

Dans cette partie, vous allez apprendre à :

• Créer des blocs pour regrouper des tâches.
• Utiliser les directives rescue et always pour gérer les erreurs et garantir l’exécution de tâches spécifiques.
• Implémenter des blocs conditionnels pour exécuter des ensembles de tâches en fonction de l’état de votre infrastructure.

Introduction aux Blocs Ansible

Les blocs dans Ansible permettent de regrouper plusieurs tâches sous une même structure. Cela est particulièrement utile pour gérer des groupes de tâches qui doivent être exécutés ensemble ou pour capturer des erreurs et les traiter de manière cohérente.

Création d’un Bloc Simple

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

---
- name: Exemple d'utilisation des blocs dans Ansible
  hosts: all
  tasks:
    - name: Installation d'un paquet et configuration
      block:
        - name: Installer le paquet Nginx
          become: true
          ansible.builtin.apt:
            name: nginx
            state: present

        - name: Démarrer le service Nginx
          become: true
          ansible.builtin.service:
            name: nginx
            state: started

        - name: Créer un fichier d'index HTML
          become: true
          ansible.builtin.copy:
            dest: /var/www/html/index.html
            content: "<h1>Bienvenue sur {{ inventory_hostname }}</h1>"

2. Exécutez le playbook pour vérifier le fonctionnement du bloc :

ansible-playbook blocks.yaml

3. Observez que toutes les tâches du bloc sont exécutées séquentiellement.

Gestion des Erreurs avec rescue et always

Ansible permet d’ajouter des sections rescue et always aux blocs pour gérer les erreurs et exécuter des tâches spécifiques même en cas d’échec.

Utilisation de rescue et always

1. Modifiez le fichier blocks.yaml pour inclure la gestion des erreurs :

---
- name: Exemple d'utilisation des blocs avec gestion des erreurs
  hosts: all
  tasks:
    - name: Installation et configuration avec gestion des erreurs
      block:
        - name: Installer le paquet Nginx
        become: true
          ansible.builtin.apt:
            name: nginx
            state: present

        - name: Démarrer le service Nginx
          become: true
          ansible.builtin.service:
            name: nginx
            state: started

        - name: Créer un fichier d'index HTML
          ecome: true
          ansible.builtin.copy:
            dest: /var/www/html/index.html
            content: "<h1>Bienvenue sur {{ inventory_hostname }}</h1>"

      rescue:
        - name: Désinstaller Nginx en cas d'échec
          become: true
          ansible.builtin.apt:
            name: nginx
            state: absent

        - name: Envoyer un message en cas d'échec
          ansible.builtin.debug:
            msg: "L'installation a échoué et Nginx a été désinstallé."

      always:
        - name: Nettoyer les fichiers temporaires
          become: true
          ansible.builtin.file:
            path: /tmp/nginx_temp_file
            state: absent

        - name: Afficher un message final
          ansible.builtin.debug:
            msg: "Bloc exécuté, vérifiez les résultats."

2. Exécutez le playbook et testez le comportement en introduisant volontairement une erreur (par exemple, en modifiant le nom du paquet Nginx de manière incorrecte).

ansible-playbook blocks.yaml

3. Observez comment les sections rescue et always sont exécutées en réponse à l’erreur.

Utilisation de Blocs Conditionnels

Les blocs peuvent également être conditionnels, ce qui permet d’exécuter des groupes de tâches uniquement si certaines conditions sont remplies.

Création d’un Bloc Conditionnel

1. Modifiez le fichier blocks.yaml pour ajouter un bloc conditionnel :

---
- name: Exemple d'utilisation des blocs conditionnels
  hosts: all
  tasks:
    - name: Installation conditionnelle et configuration
      block:
        - name: Vérifier si le service Nginx est installé
          ansible.builtin.service_facts:

        - name: Installer Nginx si non présent
          ansible.builtin.apt:
            name: nginx
            state: present
          when: "'nginx' not in ansible_facts.services"

        - name: Démarrer Nginx si non en cours d'exécution
          ansible.builtin.service:
            name: nginx
            state: started
          when: ansible_facts.services.nginx.state != 'running'

        - name: Créer un fichier d'index HTML si non présent
          ansible.builtin.copy:
            dest: /var/www/html/index.html
            content: "<h1>Bienvenue sur {{ inventory_hostname }}</h1>"
          when: ansible_facts.services.nginx.state == 'running'

      rescue:
        - name: Désinstaller Nginx en cas d'échec
          ansible.builtin.apt:
            name: nginx
            state: absent

        - name: Envoyer un message en cas d'échec
          ansible.builtin.debug:
            msg: "L'installation a échoué et Nginx a été désinstallé."

      always:
        - name: Nettoyer les fichiers temporaires
          ansible.builtin.file:
            path: /tmp/nginx_temp_file
            state: absent

        - name: Afficher un message final
          ansible.builtin.debug:
            msg: "Bloc conditionnel exécuté."

2. Exécutez le playbook et observez l’exécution conditionnelle des tâches.

ansible-playbook blocks.yaml

3. Modifiez les conditions et testez différents scénarios pour voir comment les blocs réagissent aux différentes situations.

Validation du TP

Pour valider ce TP, assurez-vous que :

1. Les blocs sont correctement utilisés pour regrouper et organiser des tâches.
2. Les erreurs sont bien gérées avec les sections rescue et always.
3. Les blocs conditionnels s’exécutent comme prévu en fonction de l’état de l’infrastructure.

Challenge

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

• Créez un playbook qui utilise plusieurs blocs pour gérer différentes parties d’un déploiement complexe, avec gestion des erreurs pour chaque bloc.
• Implémentez des blocs conditionnels qui réagissent à différents types de serveurs (web, base de données, etc.) et exécutent des tâches spécifiques en fonction du rôle du serveur.
• Utilisez les blocs pour organiser des tâches dans un playbook qui effectue une série d’actions critiques et implémentez une stratégie de récupération robuste en cas d’échec.