Comment configurer l'option gather_facts dans un playbook Ansible

Introduction

Ansible est un outil d'automatisation informatique puissant qui aide les administrateurs système et les développeurs à gérer l'infrastructure de manière efficace. L'une de ses fonctionnalités clés est la capacité de collecter des informations sur les systèmes cibles, connues sous le nom de "facts" (faits). L'option gather_facts dans Ansible détermine si et comment ces informations sont collectées lors de l'exécution d'un playbook.

Dans ce lab pratique, vous apprendrez à configurer l'option gather_facts dans les playbooks Ansible. Vous explorerez différents paramètres, comprendrez quand activer ou désactiver la collecte de faits, et découvrirez comment utiliser les faits collectés pour rendre vos playbooks plus dynamiques et efficaces. À la fin de ce lab, vous serez en mesure d'optimiser vos flux de travail Ansible en contrôlant le processus de collecte de faits en fonction de vos besoins spécifiques.

Installation d'Ansible et exploration de l'option gather_facts

Commençons par installer Ansible et explorer ce que fait l'option gather_facts. Dans cette étape, nous installerons Ansible, créerons un inventaire simple et exécuterons une commande pour voir quels faits sont collectés.

Installation d'Ansible

Tout d'abord, installons Ansible sur notre système :

sudo apt update
sudo apt install -y ansible

Une fois l'installation terminée, vérifiez qu'Ansible est correctement installé :

ansible --version

Vous devriez voir une sortie similaire à celle-ci :

ansible [core 2.12.x]
  config file = /etc/ansible/ansible.cfg
  configured module search path = ['/home/labex/.ansible/plugins/modules', '/usr/share/ansible/plugins/modules']
  ansible python module location = /usr/lib/python3/dist-packages/ansible
  ansible collection location = /home/labex/.ansible/collections:/usr/share/ansible/collections
  executable location = /usr/bin/ansible
  python version = 3.10.x (default, Aug 14 2022, 00:00:00) [GCC 11.2.0]
  jinja version = 3.0.3
  libyaml = True

Création d'un inventaire simple

Maintenant, créons un fichier d'inventaire simple avec lequel travailler. Le fichier d'inventaire définit les hôtes qu'Ansible gérera. Pour ce lab, nous allons créer un inventaire local :

mkdir -p ~/project/ansible
cd ~/project/ansible

Créez un fichier d'inventaire nommé hosts en utilisant l'éditeur :

1. Cliquez sur l'icône Explorateur dans le WebIDE
2. Naviguez vers le répertoire /home/labex/project/ansible
3. Faites un clic droit et sélectionnez "Nouveau fichier"
4. Nommez le fichier hosts
5. Ajoutez le contenu suivant :

[local]
localhost ansible_connection=local

Cet inventaire configure un groupe appelé local avec un seul hôte - localhost. Le paramètre ansible_connection=local indique à Ansible d'exécuter les commandes directement sur la machine locale sans utiliser SSH.

Exploration de gather_facts

Exécutons une simple commande Ansible pour voir quels faits sont collectés par défaut :

cd ~/project/ansible
ansible local -i hosts -m setup

La commande ci-dessus utilise :

• local : le groupe de notre inventaire
• -i hosts : spécifie notre fichier d'inventaire
• -m setup : exécute le module setup, qui collecte les faits

Vous verrez une grande sortie JSON avec des informations détaillées sur votre système, notamment :

• Informations matérielles (CPU, mémoire)
• Configuration réseau
• Détails du système d'exploitation
• Variables d'environnement
• Et bien plus encore

Ces informations sont ce qu'Ansible collecte lorsque gather_facts est activé (ce qui est le comportement par défaut). Ces faits peuvent être utilisés dans les playbooks pour prendre des décisions ou personnaliser les tâches en fonction des caractéristiques du système cible.

Création d'un playbook de base avec la collecte de faits par défaut

Dans cette étape, nous allons créer un playbook Ansible de base qui utilise le comportement par défaut de collecte de faits et affiche certaines des informations collectées.

Comprendre les playbooks Ansible

Un playbook Ansible est un fichier YAML contenant une liste de tâches à exécuter sur les hôtes gérés. Les playbooks fournissent un moyen de définir les étapes de configuration, de déploiement et d'orchestration dans un format simple et lisible par l'homme.

Création de votre premier playbook

Créons un playbook simple qui affichera certains des faits qu'Ansible collecte par défaut :

1. Dans le WebIDE, naviguez vers le répertoire /home/labex/project/ansible
2. Créez un nouveau fichier nommé facts_playbook.yml
3. Ajoutez le contenu suivant :

---
- name: Show System Facts
  hosts: local
  ## By default, gather_facts is set to 'true'

  tasks:
    - name: Display operating system
      debug:
        msg: "Operating System: {{ ansible_distribution }} {{ ansible_distribution_version }}"

    - name: Display CPU information
      debug:
        msg: "CPU: {{ ansible_processor[1] }} with {{ ansible_processor_cores }} cores"

    - name: Display memory information
      debug:
        msg: "Total Memory: {{ ansible_memtotal_mb }} MB"

    - name: Display Python version
      debug:
        msg: "Python version: {{ ansible_python_version }}"

Ce playbook :

• Cible le groupe local défini dans notre inventaire
• Active implicitement la collecte de faits (comportement par défaut)
• Contient quatre tâches qui affichent différentes informations collectées par Ansible

Exécution du playbook

Exécutons maintenant le playbook pour voir les faits collectés en action :

cd ~/project/ansible
ansible-playbook -i hosts facts_playbook.yml

Vous devriez voir une sortie similaire à celle-ci :

PLAY [Show System Facts] *****************************************************

TASK [Gathering Facts] *******************************************************
ok: [localhost]

TASK [Display operating system] **********************************************
ok: [localhost] => {
    "msg": "Operating System: Ubuntu 22.04"
}

TASK [Display CPU information] ***********************************************
ok: [localhost] => {
    "msg": "CPU: Intel(R) Xeon(R) CPU with 2 cores"
}

TASK [Display memory information] ********************************************
ok: [localhost] => {
    "msg": "Total Memory: 3907 MB"
}

TASK [Display Python version] ************************************************
ok: [localhost] => {
    "msg": "Python version: 3.10.6"
}

PLAY RECAP *******************************************************************
localhost                  : ok=5    changed=0    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0

Remarquez la première tâche dans la sortie : TASK [Gathering Facts]. C'est Ansible qui collecte automatiquement les faits avant d'exécuter l'une de nos tâches définies, car la valeur par défaut de gather_facts est true.

Le playbook affiche ensuite avec succès des informations sur votre système en utilisant les faits collectés. Chaque fait est référencé à l'aide d'une variable avec le préfixe ansible_.

Désactivation de la collecte de faits pour une meilleure performance

Dans cette étape, nous allons apprendre à désactiver la collecte de faits pour améliorer les performances des playbooks dans les situations où les faits ne sont pas nécessaires.

Comprendre quand désactiver la collecte de faits

Bien que la collecte de faits soit utile, elle peut ajouter des frais généraux inutiles dans certains scénarios :

• Lorsque vous exécutez des tâches simples qui ne nécessitent pas d'informations système
• Lorsque vous exécutez des playbooks fréquemment et que les faits ne changent pas
• Lorsque vous souhaitez optimiser le temps d'exécution des playbooks

La désactivation de la collecte de faits peut améliorer considérablement la vitesse d'exécution des playbooks, en particulier lors de la gestion de nombreux hôtes.

Création d'un playbook avec la collecte de faits désactivée

Créons un nouveau playbook avec la collecte de faits désactivée :

1. Dans le WebIDE, naviguez vers le répertoire /home/labex/project/ansible
2. Créez un nouveau fichier nommé no_facts_playbook.yml
3. Ajoutez le contenu suivant :

---
- name: Playbook with Disabled Fact Gathering
  hosts: local
  gather_facts: false

  tasks:
    - name: Display current time
      command: date
      register: current_time

    - name: Show the current time
      debug:
        msg: "Current time is: {{ current_time.stdout }}"

    - name: List files in the project directory
      command: ls -la ~/project
      register: file_list

    - name: Show file list
      debug:
        msg: "Project directory contents:\n{{ file_list.stdout }}"

Ce playbook :

• Désactive explicitement la collecte de faits avec gather_facts: false
• Exécute des commandes qui ne dépendent pas des faits système
• Utilise le mot-clé register pour capturer les sorties de commande
• Affiche les informations capturées à l'aide du module debug

Exécution du playbook avec la collecte de faits désactivée

Exécutons le playbook et observons les différences :

cd ~/project/ansible
ansible-playbook -i hosts no_facts_playbook.yml

Vous devriez voir une sortie similaire à celle-ci :

PLAY [Playbook with Disabled Fact Gathering] *********************************

TASK [Display current time] **************************************************
changed: [localhost]

TASK [Show the current time] *************************************************
ok: [localhost] => {
    "msg": "Current time is: Wed May 17 15:30:45 UTC 2023"
}

TASK [List files in the project directory] ***********************************
changed: [localhost]

TASK [Show file list] ********************************************************
ok: [localhost] => {
    "msg": "Project directory contents:\ntotal 20\ndrwxr-xr-x 3 labex labex 4096 May 17 15:25 .\ndrwxr-xr-x 4 labex labex 4096 May 17 15:20 ..\ndrwxr-xr-x 2 labex labex 4096 May 17 15:25 ansible\n"
}

PLAY RECAP *******************************************************************
localhost                  : ok=4    changed=2    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0

Remarquez qu'il n'y a pas de tâche Gathering Facts dans la sortie cette fois-ci. Le playbook commence directement avec notre première tâche définie.

Comparaison des temps d'exécution

Pour voir la différence de performance, créons un script de chronométrage simple :

1. Dans le WebIDE, naviguez vers le répertoire /home/labex/project/ansible
2. Créez un nouveau fichier nommé compare_timing.sh
3. Ajoutez le contenu suivant :

#!/bin/bash

echo "Running playbook with fact gathering enabled..."
time ansible-playbook -i hosts facts_playbook.yml > /dev/null

echo -e "\nRunning playbook with fact gathering disabled..."
time ansible-playbook -i hosts no_facts_playbook.yml > /dev/null

4. Rendez le script exécutable :

chmod +x compare_timing.sh

5. Exécutez le script de comparaison :

./compare_timing.sh

Vous devriez voir une sortie montrant que le playbook avec la collecte de faits désactivée s'exécute plus rapidement que celui avec la collecte de faits activée. La différence peut être faible dans notre exemple simple, mais elle peut être significative lors de l'exécution de playbooks complexes sur plusieurs hôtes distants.

Utilisation de la collecte sélective de faits

Dans certains cas, vous pourriez n'avoir besoin que de faits spécifiques plutôt que de toutes les informations système. Ansible permet la collecte sélective de faits pour optimiser les performances tout en collectant les informations dont vous avez besoin.

Comprendre les sous-ensembles de faits

Ansible organise les faits en sous-ensembles, tels que :

• all : Tous les faits (par défaut)
• min / minimal : Un ensemble minimal de faits
• hardware : Informations sur le processeur, la mémoire et les périphériques
• network : Informations sur l'interface réseau et le routage
• virtual : Détails de la virtualisation
• ohai : Faits d'Ohai (si disponible)
• facter : Faits de Facter (si disponible)

En sélectionnant uniquement les faits dont vous avez besoin, vous pouvez améliorer les performances des playbooks tout en ayant accès aux informations nécessaires.

Création d'un playbook avec la collecte sélective de faits

Créons un playbook qui collecte uniquement les faits liés au matériel :

1. Dans le WebIDE, naviguez vers le répertoire /home/labex/project/ansible
2. Créez un nouveau fichier nommé selective_facts_playbook.yml
3. Ajoutez le contenu suivant :

---
- name: Selective Fact Gathering
  hosts: local
  gather_facts: true
  gather_subset:
    - "!all" ## Exclude all facts by default
    - "hardware" ## Then include only hardware facts

  tasks:
    - name: Display CPU information
      debug:
        msg: "CPU: {{ ansible_processor[1] }} with {{ ansible_processor_cores }} cores"

    - name: Display memory information
      debug:
        msg: "Total Memory: {{ ansible_memtotal_mb }} MB"

    - name: Try to access network facts (should fail)
      debug:
        msg: "Default IPv4 Address: {{ ansible_default_ipv4.address }}"
      ignore_errors: true

Ce playbook :

• Active la collecte de faits avec gather_facts: true
• Utilise gather_subset pour restreindre les faits collectés
• Exclut d'abord tous les faits avec !all
• Puis inclut uniquement les faits matériels avec hardware
• Tente d'accéder aux faits réseau (qui n'ont pas été collectés) pour démontrer la limitation

Exécution du playbook avec la collecte sélective de faits

Exécutons le playbook pour voir la collecte sélective de faits en action :

cd ~/project/ansible
ansible-playbook -i hosts selective_facts_playbook.yml

Vous devriez voir une sortie similaire à celle-ci :

PLAY [Selective Fact Gathering] **********************************************

TASK [Gathering Facts] *******************************************************
ok: [localhost]

TASK [Display CPU information] ***********************************************
ok: [localhost] => {
    "msg": "CPU: Intel(R) Xeon(R) CPU with 2 cores"
}

TASK [Display memory information] ********************************************
ok: [localhost] => {
    "msg": "Total Memory: 3907 MB"
}

TASK [Try to access network facts (should fail)] *****************************
fatal: [localhost]: FAILED! => {"msg": "The task includes an option with an undefined variable. The error was: 'dict object' has no attribute 'address'..."}
...ignoring

PLAY RECAP *******************************************************************
localhost                  : ok=4    changed=0    unreachable=0    failed=0    skipped=0    rescued=0    ignored=1

Remarquez que les deux premières tâches réussissent car elles accèdent aux faits matériels qui ont été collectés, mais la troisième tâche échoue car les faits réseau n'ont pas été collectés. Nous avons utilisé ignore_errors: true pour continuer l'exécution du playbook malgré cette erreur.

Création d'un playbook avec plusieurs sous-ensembles de faits

Créons maintenant un playbook qui collecte à la fois les faits matériels et réseau :

1. Dans le WebIDE, créez un nouveau fichier nommé multiple_subsets_playbook.yml
2. Ajoutez le contenu suivant :

---
- name: Multiple Fact Subsets
  hosts: local
  gather_facts: true
  gather_subset:
    - "!all" ## Exclude all facts by default
    - "hardware" ## Include hardware facts
    - "network" ## Include network facts

  tasks:
    - name: Display CPU information
      debug:
        msg: "CPU: {{ ansible_processor[1] }} with {{ ansible_processor_cores }} cores"

    - name: Display memory information
      debug:
        msg: "Total Memory: {{ ansible_memtotal_mb }} MB"

    - name: Display network information
      debug:
        msg: "Default IPv4 Address: {{ ansible_default_ipv4.address }}"

Exécutez ce playbook :

ansible-playbook -i hosts multiple_subsets_playbook.yml

Cette fois, toutes les tâches devraient réussir car nous avons collecté à la fois les faits matériels et réseau.

Utilisation des faits collectés dans les tâches conditionnelles

L'une des utilisations les plus puissantes des faits collectés est la mise en œuvre d'une logique conditionnelle dans vos playbooks. Dans cette étape, nous allons créer un playbook qui utilise les faits pour prendre des décisions concernant les tâches à exécuter.

Comprendre les tâches conditionnelles dans Ansible

Ansible vous permet d'utiliser le mot-clé when pour exécuter conditionnellement des tâches en fonction de variables, de faits ou des résultats de tâches. Cela vous permet de créer des playbooks plus dynamiques et adaptables.

Création d'un playbook avec des tâches conditionnelles

Créons un playbook qui effectue différentes actions en fonction du système d'exploitation :

1. Dans le WebIDE, naviguez vers le répertoire /home/labex/project/ansible
2. Créez un nouveau fichier nommé conditional_facts_playbook.yml
3. Ajoutez le contenu suivant :

---
- name: Conditional Tasks Based on Facts
  hosts: local
  gather_facts: true

  tasks:
    - name: Display OS information
      debug:
        msg: "Running on {{ ansible_distribution }} {{ ansible_distribution_version }}"

    - name: Task for Ubuntu systems
      debug:
        msg: "This is an Ubuntu system. Would run apt commands here."
      when: ansible_distribution == "Ubuntu"

    - name: Task for CentOS systems
      debug:
        msg: "This is a CentOS system. Would run yum commands here."
      when: ansible_distribution == "CentOS"

    - name: Task for systems with at least 2GB RAM
      debug:
        msg: "This system has {{ ansible_memtotal_mb }} MB RAM, which is sufficient for our application."
      when: ansible_memtotal_mb >= 2048

    - name: Task for systems with less than 2GB RAM
      debug:
        msg: "This system has only {{ ansible_memtotal_mb }} MB RAM, which may not be sufficient."
      when: ansible_memtotal_mb < 2048

Ce playbook :

• Collecte tous les faits sur le système
• Affiche les informations sur le système d'exploitation
• Exécute conditionnellement des tâches en fonction du type de système d'exploitation
• Exécute conditionnellement des tâches en fonction de la quantité de RAM

Exécution du playbook conditionnel

Exécutons le playbook pour voir les tâches conditionnelles en action :

cd ~/project/ansible
ansible-playbook -i hosts conditional_facts_playbook.yml

Puisque nous exécutons sur Ubuntu, vous devriez voir une sortie similaire à celle-ci :

PLAY [Conditional Tasks Based on Facts] **************************************

TASK [Gathering Facts] *******************************************************
ok: [localhost]

TASK [Display OS information] ************************************************
ok: [localhost] => {
    "msg": "Running on Ubuntu 22.04"
}

TASK [Task for Ubuntu systems] ***********************************************
ok: [localhost] => {
    "msg": "This is an Ubuntu system. Would run apt commands here."
}

TASK [Task for CentOS systems] ***********************************************
skipping: [localhost]

TASK [Task for systems with at least 2GB RAM] ********************************
ok: [localhost] => {
    "msg": "This system has 3907 MB RAM, which is sufficient for our application."
}

TASK [Task for systems with less than 2GB RAM] *******************************
skipping: [localhost]

PLAY RECAP *******************************************************************
localhost                  : ok=4    changed=0    unreachable=0    failed=0    skipped=2    rescued=0    ignored=0

Remarquez comment certaines tâches sont exécutées tandis que d'autres sont ignorées en fonction des conditions. La tâche CentOS est ignorée car nous exécutons sur Ubuntu, et la tâche "moins de 2 Go de RAM" est ignorée car notre système dispose de plus de 2 Go de RAM.

Création d'un exemple plus pratique

Créons maintenant un exemple plus pratique qui pourrait être utilisé dans un environnement réel :

1. Dans le WebIDE, créez un nouveau fichier nommé practical_conditional_playbook.yml
2. Ajoutez le contenu suivant :

---
- name: Practical Conditional Playbook
  hosts: local
  gather_facts: true

  vars:
    app_dir: "/home/labex/project/app"

  tasks:
    - name: Create application directory
      file:
        path: "{{ app_dir }}"
        state: directory
        mode: "0755"

    - name: Configure for production environment
      copy:
        dest: "{{ app_dir }}/config.yml"
        content: |
          environment: production
          memory_limit: high
          debug: false
      when: ansible_memtotal_mb >= 4096

    - name: Configure for development environment
      copy:
        dest: "{{ app_dir }}/config.yml"
        content: |
          environment: development
          memory_limit: low
          debug: true
      when: ansible_memtotal_mb < 4096

    - name: Display configuration
      command: cat {{ app_dir }}/config.yml
      register: config_content

    - name: Show configuration
      debug:
        msg: "{{ config_content.stdout_lines }}"

Ce playbook :

• Crée un répertoire pour une application
• Écrit un fichier de configuration différent en fonction de la mémoire système disponible
• Affiche la configuration résultante

Exécutez le playbook pratique :

ansible-playbook -i hosts practical_conditional_playbook.yml

Cet exemple montre comment vous pouvez utiliser les faits collectés pour adapter automatiquement les configurations en fonction des caractéristiques du système.

Résumé

Dans ce lab, vous avez appris à configurer et à utiliser efficacement l'option gather_facts dans les playbooks Ansible. Voici un récapitulatif de ce que vous avez accompli :

1. Collecte de faits de base : Vous avez installé Ansible et exploré le comportement par défaut de la collecte de faits, en voyant la large gamme d'informations système qu'Ansible collecte.

2. Désactivation de la collecte de faits : Vous avez appris à désactiver la collecte de faits pour améliorer les performances des playbooks lorsque les faits ne sont pas nécessaires.

3. Collecte sélective de faits : Vous avez découvert comment collecter uniquement des sous-ensembles spécifiques de faits pour trouver un équilibre entre les performances et la possession des informations nécessaires.

4. Tâches conditionnelles : Vous avez implémenté une logique conditionnelle dans vos playbooks basée sur les faits collectés, permettant un comportement dynamique en fonction des caractéristiques du système.

5. Applications pratiques : Vous avez créé des exemples pratiques qui démontrent comment utiliser les faits collectés dans des scénarios réels.

En maîtrisant l'option gather_facts, vous pouvez optimiser vos playbooks Ansible pour de meilleures performances tout en ayant accès aux informations système dont vous avez besoin. Ces connaissances vous aideront à créer des flux de travail d'automatisation plus efficaces, flexibles et puissants.

Quelques bonnes pratiques à retenir :

• Activez la collecte de faits uniquement lorsque cela est nécessaire
• Utilisez la collecte sélective de faits lorsque vous n'avez besoin que d'informations spécifiques
• Tirez parti des faits collectés pour les tâches conditionnelles afin de rendre vos playbooks plus adaptables
• Envisagez la mise en cache des faits lors de l'exécution fréquente de playbooks sur les mêmes hôtes

Grâce à ces compétences, vous êtes bien équipé pour créer une automatisation Ansible plus sophistiquée et efficace pour vos besoins de gestion d'infrastructure.