Lab 05 : Utilisation des Boucles Simples et Imbriquées dans les Playbooks

Objectifs

Dans ce TP, vous allez apprendre à :

• Utiliser des boucles simples pour exécuter des tâches répétitives dans vos playbooks Ansible.
• Créer des boucles imbriquées pour gérer des scénarios plus complexes où plusieurs itérations sont nécessaires.
• Manipuler les données dans des boucles pour automatiser la configuration de plusieurs éléments de manière efficace.

Prérequis

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

• Complété les TPs précédents sur Ansible.
• Configuré Ansible sur votre machine.
• Une compréhension de base des tâches et variables dans Ansible.

Architecture du TP

Dans cette partie, vous allez apprendre à :

• Utiliser des boucles simples pour automatiser la configuration de multiples éléments.
• Utiliser des boucles imbriquées pour gérer des configurations complexes nécessitant plusieurs niveaux d’itération.
• Gérer les boucles avec des variables pour des configurations dynamiques.

Utilisation des Boucles Simples

Les boucles simples dans Ansible permettent d’exécuter une même tâche plusieurs fois avec des données différentes. Elles sont couramment utilisées pour installer plusieurs paquets, créer des utilisateurs, configurer des fichiers, etc.

Création d’une Boucle Simple

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

---
- name: Exemple d’utilisation des boucles simples dans Ansible
  hosts: webservers
  tasks:
    - name: Créer une liste de fichiers
    become: true
    ansible.builtin.file:
      path: "/var/www/html/{{ item }}"
      state: touch
    loop:
      - index.html
      - about.html
      - contact.html

2. Exécutez le playbook pour installer les paquets et créer les fichiers :

ansible-playbook loop.yaml

3. Vérifiez que les paquets sont installés et que les fichiers sont créés comme prévu.

Utilisation des Boucles Imbriquées

Les boucles imbriquées vous permettent de gérer des scénarios plus complexes où chaque élément d’une boucle doit être associé à plusieurs éléments d’une autre boucle. Par exemple, vous pourriez vouloir configurer plusieurs utilisateurs sur plusieurs serveurs.

Création d’une Boucle Imbriquée

1. Modifiez le fichier loop_nested.yaml pour inclure une boucle imbriquée :

---
- name: Display applications for each environments
  hosts: localhost
  vars:
    apps_environments:
      - app: webapp
        environments:
          - env: development
            url: dev.example.com
          - env: production
            url: example.com
      - app: api
        environments:
          - env: development
            url: dev.api.example.com
          - env: production
            url: api.example.com
  tasks:
    - name: Display application for each environment
      ansible.builtin.debug:
        msg: "Displaying {{ item.0.app }} for {{ item.1.env }} environment with URL {{ item.1.url }}"
      loop: "{{ query('subelements', apps_environments, 'environments') }}"

2. Exécutez le playbook pour créer les utilisateurs et les répertoires associés :

ansible-playbook loop_nested.yaml -c local

3. Vérifiez que les utilisateurs et leurs répertoires sont correctement créés.

Utilisation de Boucles avec des Dictionnaires

Les boucles peuvent également être utilisées avec des dictionnaires (mappages clé-valeur) pour des configurations plus dynamiques et complexes.

Création d’une Boucle avec un Dictionnaire

1. Modifiez le fichier loop_dict.yaml pour utiliser des dictionnaires dans une boucle :

---
- name: Exemple d’utilisation de loop avec des dicts
  hosts: webservers
  tasks:
    - name: Créer des utilisateurs avec des attributs spécifiques
      become: true
      ansible.builtin.user:
        name: "{{ item.key }}"
        shell: "{{ item.value.shell }}"
        state: present
      loop: "{{ users | dict2items }}"
      vars:
        users:
          alice:
            shell: /bin/bash
          bob:
            shell: /bin/zsh

2. Exécutez le playbook :

ansible-playbook loop_dict.yaml

3. Vérifiez que les utilisateurs sont créés avec le bon terminal.

Utilisation de Boucles avec with_items

Une autre méthode pour utiliser les boucles dans Ansible est d’utiliser la directive with_items, qui est une alternative à la directive loop.

Création d’une Boucle avec with_items

1. Modifiez le fichier loop_items.yml pour utiliser with_items :

---
- name: Exemple d’utilisation des boucles avec with_items dans Ansible
  hosts: webservers
  tasks:
    - name: Créer des répertoires pour des projets
      become: true
      ansible.builtin.file:
        path: "/var/www/{{ item }}"
        state: directory
      with_items:
        - projectA
        - projectB
        - projectC

2. Exécutez le playbook pour créer les répertoires :

ansible-playbook loop_items.yaml

3. Vérifiez que les répertoires sont créés comme prévu.

Validation du TP

Pour valider ce TP, assurez-vous que :

1. Les boucles simples sont correctement utilisées pour gérer des tâches répétitives.
2. Les boucles imbriquées sont utilisées pour gérer des scénarios plus complexes impliquant plusieurs niveaux d’itération.
3. Les boucles avec des dictionnaires sont utilisées pour configurer des éléments dynamiques.
4. La directive with_items est correctement utilisée comme alternative à loop.

Challenge

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

• Créez un playbook qui configure plusieurs utilisateurs, groupes et répertoires en utilisant des boucles imbriquées et des dictionnaires.
• Utilisez des boucles pour déployer plusieurs applications sur différents serveurs, en associant chaque application à une configuration spécifique.
• Expérimentez avec des boucles conditionnelles pour exécuter certaines tâches uniquement si des critères spécifiques sont remplis.