Conditions et boucles Ansible

Introduction

Dans ce lab, vous allez explorer deux fonctionnalités puissantes d'Ansible : les conditions et les boucles. Ces concepts vous permettent de créer des playbooks plus dynamiques et efficaces en contrôlant l'exécution des tâches selon des conditions spécifiques et en répétant des tâches pour plusieurs éléments. À la fin de ce lab, vous comprendrez comment utiliser les conditions pour prendre des décisions dans vos playbooks et comment implémenter des boucles pour exécuter efficacement des tâches répétitives. Ces connaissances vous aideront à concevoir des playbooks Ansible plus flexibles et robustes pour la gestion de votre infrastructure.

Configuration de l'environnement

Dans cette étape, vous allez configurer l'environnement de travail pour les exercices sur les conditions et les boucles Ansible. Cette préparation fournit les fichiers et répertoires utilisés dans toutes les tâches suivantes.

Tout d'abord, naviguons vers le répertoire du projet. Dans le terminal, tapez :

cd ~/project

Cette commande modifie votre répertoire actuel pour aller dans ~/project, qui est notre espace de travail désigné pour ce lab.

Maintenant, nous allons créer un fichier d'inventaire. Dans Ansible, un fichier d'inventaire définit les hôtes et les groupes d'hôtes sur lesquels les commandes, les modules et les tâches d'un playbook s'exécutent. Pour ce lab, nous utiliserons un inventaire simple qui ne contient que la machine locale (localhost).

Créez un nouveau fichier nommé inventory.ini :

nano inventory.ini

Cette commande ouvre l'éditeur de texte nano. Si vous n'êtes pas familier avec nano, ne vous inquiétez pas, c'est un éditeur simple et convivial. Le curseur sera placé dans le fichier, prêt à recevoir votre saisie.

Ajoutez ensuite le contenu suivant dans le fichier :

[local]
localhost ansible_connection=local

Analysons ce contenu :

• [local] définit un groupe nommé "local".
• localhost est le nom de l'hôte.
• ansible_connection=local indique à Ansible d'exécuter les commandes localement plutôt que via SSH.

Pour enregistrer le fichier et quitter nano, appuyez sur Ctrl+X, puis sur Y pour enregistrer le buffer modifié, et enfin sur Entrée pour confirmer le nom du fichier.

Ensuite, créons un répertoire pour nos playbooks :

mkdir playbooks
cd playbooks

La commande mkdir crée un nouveau répertoire nommé "playbooks", et nous utilisons ensuite cd pour y accéder.

Pourquoi faisons-nous cela ? Organiser vos fichiers Ansible dans des répertoires est une bonne pratique. Cela permet de garder votre projet structuré, en particulier à mesure qu'il grandit et devient plus complexe.

En suivant ces étapes, vous avez configuré un environnement Ansible de base. Vous disposez d'un fichier d'inventaire qui indique à Ansible sur quels hôtes travailler, ainsi que d'un répertoire dédié à vos playbooks. Cette structure facilitera la gestion de vos projets Ansible au fur et à mesure que vous apprendrez et expérimenterez des fonctionnalités plus complexes.

Introduction aux conditions

Dans cette étape, vous allez utiliser des conditions Ansible pour contrôler l'exécution des tâches en fonction de critères spécifiques. C'est très utile lorsque vous devez effectuer des actions différentes selon l'état de votre système ou la valeur de certaines variables.

Créons un playbook simple qui démontre l'utilisation des conditions :

nano conditional_example.yml

Cette commande ouvre l'éditeur de texte nano pour créer un nouveau fichier nommé conditional_example.yml. Ajoutez-y le contenu suivant :

---
- name: Conditional Example
  hosts: localhost
  gather_facts: yes
  tasks:
    - name: Check OS family
      debug:
        msg: "This is a Debian-based system"
      when: ansible_os_family == "Debian"

    - name: Check OS family (alternative)
      debug:
        msg: "This is not a Debian-based system"
      when: ansible_os_family != "Debian"

Analysons ce code :

• --- en haut du fichier indique le début d'un document YAML.
• name: Conditional Example attribue un nom à notre playbook.
• hosts: localhost spécifie que ce playbook s'exécutera sur la machine locale.
• gather_facts: yes demande à Ansible de collecter des informations sur le système avant d'exécuter les tâches. C'est important car nous utiliserons ces faits (facts) dans nos conditions.
• tasks: commence la liste des tâches à exécuter.

Chaque tâche utilise le module debug pour afficher un message, mais son exécution est contrôlée par la clause when :

• La première tâche ne s'exécutera que si le système est basé sur Debian (ansible_os_family == "Debian").
• La seconde tâche ne s'exécutera que si le système n'est pas basé sur Debian (ansible_os_family != "Debian").

ansible_os_family est un fait collecté par Ansible concernant le système cible. Il est utilisé ici pour illustrer le fonctionnement des conditions.

Enregistrez et quittez l'éditeur nano (Ctrl+X, puis Y, puis Entrée).

Exécutons maintenant le playbook :

ansible-playbook -i ../inventory.ini conditional_example.yml

Cette commande demande à Ansible d'exécuter notre playbook. L'option -i ../inventory.ini spécifie le fichier d'inventaire que nous avons créé précédemment.

Vous devriez voir une sortie indiquant si votre système est basé sur Debian ou non. Un seul des messages de débogage s'affichera, selon la famille de SE de votre système.

Cet exemple montre comment les conditions peuvent être utilisées pour adapter vos playbooks à différents environnements. Dans des scénarios réels, vous pourriez utiliser des conditions pour installer différents paquets selon le type de système d'exploitation, ou pour ignorer certaines tâches si un fichier existe déjà.

Rappelez-vous que la puissance des conditions réside dans leur capacité à rendre vos playbooks flexibles et capables de gérer divers scénarios sans avoir besoin de playbooks séparés pour chaque cas de figure.

Travailler avec des conditions multiples

Dans cette étape, vous allez combiner plusieurs conditions à l'aide d'opérateurs logiques avant d'exécuter une tâche. Ce modèle prend en charge des comportements conditionnels plus avancés dans des playbooks réels.

Créez un nouveau fichier nommé multiple_conditions.yml :

nano multiple_conditions.yml

Ajoutez ensuite le contenu suivant dans le fichier :

---
- name: Multiple Conditions Example
  hosts: localhost
  gather_facts: yes
  vars:
    check_memory: true
  tasks:
    - name: Check OS and Memory
      debug:
        msg: "This is a Debian-based system with more than 1GB of memory"
      when:
        - ansible_os_family == "Debian"
        - ansible_memtotal_mb > 1024
        - check_memory | bool

    - name: Print System Information
      debug:
        msg: "OS: {{ ansible_distribution }}, Memory: {{ ansible_memtotal_mb }} MB"
      when: ansible_distribution == "Ubuntu" or ansible_memtotal_mb < 2048

Analysons ce playbook :

• Nous définissons une variable check_memory au niveau du playbook. Celle-ci pourrait être définie dynamiquement ou passée en tant que variable supplémentaire lors de l'exécution du playbook.

• La première tâche utilise plusieurs conditions :

  • Elle vérifie si la famille de SE est Debian.
  • Elle vérifie si la mémoire totale est supérieure à 1024 Mo (1 Go).
  • Elle vérifie si la variable check_memory est vraie.

  Toutes ces conditions doivent être vraies pour que la tâche s'exécute. Le filtre | dans check_memory | bool convertit la valeur en un booléen.

• La seconde tâche démontre l'utilisation de l'opérateur or (ou). Elle s'exécutera si la distribution est Ubuntu OU si la mémoire totale est inférieure à 2048 Mo (2 Go).

• Nous utilisons d'autres faits Ansible ici : ansible_distribution donne le nom spécifique de la distribution, et ansible_memtotal_mb fournit la mémoire totale du système en mégaoctets.

Enregistrez et quittez l'éditeur nano.

Exécutons maintenant ce playbook :

ansible-playbook -i ../inventory.ini multiple_conditions.yml

Observez le résultat. Selon les caractéristiques de votre système, vous verrez l'un ou les deux messages de débogage.

Cet exemple montre comment créer des conditions complexes pour rendre vos playbooks hautement adaptables à différents scénarios. Vous pouvez combiner divers faits système, des variables personnalisées et des opérateurs logiques pour affiner précisément le moment où vos tâches doivent s'exécuter.

Introduction aux boucles

Dans cette étape, vous allez utiliser des boucles Ansible pour répéter une tâche avec différentes valeurs. C'est très utile lorsque vous devez effectuer la même action sur plusieurs éléments, comme créer plusieurs utilisateurs, installer plusieurs paquets ou créer plusieurs répertoires.

Créons un playbook pour démontrer l'utilisation des boucles. Créez un nouveau fichier nommé loop_example.yml :

nano loop_example.yml

Ajoutez ensuite le contenu suivant :

---
- name: Loop Example
  hosts: localhost
  vars:
    fruits:
      - apple
      - banana
      - cherry
  tasks:
    - name: Print fruit names
      debug:
        msg: "Current fruit: {{ item }}"
      loop: "{{ fruits }}"

    - name: Create directories
      file:
        path: "/tmp/{{ item }}"
        state: directory
      loop:
        - dir1
        - dir2
        - dir3

Analysons ce code :

• Nous définissons une variable fruits sous forme de liste de noms de fruits.

• La première tâche utilise une boucle pour parcourir la liste fruits. À chaque itération, la valeur courante est disponible via {{ item }}.

• La seconde tâche montre comment utiliser une boucle avec le module file pour créer plusieurs répertoires. Nous créons trois répertoires dans le dossier /tmp.

• Remarquez que nous pouvons utiliser la boucle directement dans la tâche (comme dans la seconde tâche) ou faire référence à une variable (comme dans la première).

Enregistrez et quittez l'éditeur nano.

Exécutons maintenant ce playbook :

ansible-playbook -i ../inventory.ini loop_example.yml

Lorsque vous exécuterez ce playbook, vous verrez que la première tâche affiche chaque nom de fruit, et que la seconde tâche crée trois répertoires dans /tmp.

Les boucles sont une fonctionnalité puissante d'Ansible qui peut réduire considérablement la quantité de code répétitif dans vos playbooks. Elles sont particulièrement utiles lorsque vous travaillez avec des listes d'éléments tels que des utilisateurs, des paquets ou des fichiers.

Techniques de boucles avancées

Dans cette étape, vous allez utiliser des techniques de boucles Ansible avancées pour manipuler des structures de données complexes et contrôler le processus de boucle.

Créez un nouveau fichier nommé advanced_loops.yml :

nano advanced_loops.yml

Ajoutez ensuite le contenu suivant :

---
- name: Advanced Loop Techniques
  hosts: localhost
  vars:
    users:
      - name: alice
        groups: ["developers", "testers"]
      - name: bob
        groups: ["managers", "developers"]
  tasks:
    - name: Create users with groups
      debug:
        msg: "Creating user {{ item.name }} with groups: {{ item.groups | join(', ') }}"
      loop: "{{ users }}"

    - name: Demonstrate loop_control
      debug:
        msg: "Processing item {{ index }} - {{ item }}"
      loop: ["a", "b", "c", "d"]
      loop_control:
        index_var: index

    - name: Loop over dictionary
      debug:
        msg: "{{ key }}: {{ value }}"
      loop: "{{ {'x': 1, 'y': 2, 'z': 3} | dict2items }}"
      vars:
        key: "{{ item.key }}"
        value: "{{ item.value }}"

Analysons ces techniques avancées :

• Boucle sur une liste de dictionnaires : La première tâche parcourt la liste users, où chaque élément est un dictionnaire contenant un nom et une liste de groupes. Nous pouvons accéder à ces éléments imbriqués en utilisant la notation par points (item.name, item.groups).

• Utilisation de loop_control : La seconde tâche démontre l'utilisation de loop_control, qui permet de changer le nom de la variable de boucle (par défaut item) et d'accéder à l'index de la boucle en cours. Ici, nous utilisons index_var: index pour créer une variable index qui suit le numéro de l'itération actuelle.

• Boucle sur un dictionnaire : La dernière tâche montre comment parcourir un dictionnaire. Nous utilisons le filtre dict2items pour convertir le dictionnaire en une liste de paires clé-valeur que l'on peut boucler. Ensuite, nous utilisons item.key et item.value pour accéder respectivement aux clés et aux valeurs du dictionnaire.

Enregistrez et quittez l'éditeur nano.

Exécutons maintenant ce playbook :

ansible-playbook -i ../inventory.ini advanced_loops.yml

En exécutant ce playbook, vous verrez comment fonctionnent ces techniques de boucles avancées. La sortie affichera :

• Des messages de création d'utilisateurs avec leurs groupes respectifs.
• Des éléments traités accompagnés de leur index.
• Des paires clé-valeur issues du dictionnaire.

Ces techniques avancées vous permettent de manipuler des structures de données plus complexes et de garder un contrôle plus précis sur vos boucles. Elles sont particulièrement utiles pour traiter des données imbriquées, lorsque vous avez besoin de suivre l'index de la boucle, ou lorsque vous travaillez avec des dictionnaires.

Résumé

Dans ce lab, vous avez découvert les conditions et les boucles Ansible, deux fonctionnalités puissantes qui vous permettent de créer des playbooks plus dynamiques et efficaces. Voici les points clés à retenir :

1. Les conditions (clause when) vous permettent de contrôler l'exécution des tâches selon des critères spécifiques, tels que des faits concernant le système cible ou des variables définies par l'utilisateur.
2. Vous pouvez combiner plusieurs conditions à l'aide d'opérateurs logiques comme and et or pour créer des instructions conditionnelles plus complexes.
3. Les boucles (mot-clé loop) vous permettent de répéter des tâches avec différentes valeurs, ce qui augmente l'efficacité et réduit la complexité du playbook.
4. Ansible prend en charge différents types de boucles, notamment les boucles sur des listes, des dictionnaires et des structures de données plus complexes.
5. Les techniques de boucles avancées, telles que loop_control et l'itération sur des dictionnaires, offrent encore plus de flexibilité dans la gestion des tâches répétitives.

Ces fonctionnalités sont essentielles pour créer des playbooks Ansible flexibles et robustes capables de s'adapter à différents scénarios et de gérer efficacement plusieurs éléments. En continuant à travailler avec Ansible, entraînez-vous à intégrer des conditions et des boucles dans vos playbooks pour les rendre plus dynamiques et performants.

N'oubliez pas de toujours prendre en compte la lisibilité et la maintenabilité de vos playbooks lors de l'utilisation de ces fonctionnalités. Bien qu'elles puissent grandement simplifier votre code, une surutilisation ou des conditions et boucles trop complexes peuvent rendre les playbooks difficiles à comprendre et à maintenir.