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 :
- Cliquez sur l'icône Explorateur dans le WebIDE
- Naviguez vers le répertoire
/home/labex/project/ansible - Faites un clic droit et sélectionnez "Nouveau fichier"
- Nommez le fichier
hosts - 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 :
- Dans le WebIDE, naviguez vers le répertoire
/home/labex/project/ansible - Créez un nouveau fichier nommé
facts_playbook.yml - 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
localdé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 :
- Dans le WebIDE, naviguez vers le répertoire
/home/labex/project/ansible - Créez un nouveau fichier nommé
no_facts_playbook.yml - 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é
registerpour 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 :
- Dans le WebIDE, naviguez vers le répertoire
/home/labex/project/ansible - Créez un nouveau fichier nommé
compare_timing.sh - 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
- Rendez le script exécutable :
chmod +x compare_timing.sh
- 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 faitshardware: Informations sur le processeur, la mémoire et les périphériquesnetwork: Informations sur l'interface réseau et le routagevirtual: Détails de la virtualisationohai: 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 :
- Dans le WebIDE, naviguez vers le répertoire
/home/labex/project/ansible - Créez un nouveau fichier nommé
selective_facts_playbook.yml - 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_subsetpour 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 :
- Dans le WebIDE, créez un nouveau fichier nommé
multiple_subsets_playbook.yml - 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 :
- Dans le WebIDE, naviguez vers le répertoire
/home/labex/project/ansible - Créez un nouveau fichier nommé
conditional_facts_playbook.yml - 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 :
- Dans le WebIDE, créez un nouveau fichier nommé
practical_conditional_playbook.yml - 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 :
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.
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.
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.
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.
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.
