LabEx
EntrerRejoindre

Variables Hostvars Ansible

AnsibleBeginner
Pratiquer maintenant

Introduction

Les variables hostvars d'Ansible sont des variables essentielles qui stockent des informations sur chaque hôte géré dans votre infrastructure. Ces variables vous permettent de créer des flux d'automatisation dynamiques et flexibles qui s'adaptent à différents serveurs et environnements.

Dans ce laboratoire pratique, vous apprendrez à travailler avec les variables hostvars d'Ansible à partir de zéro. Vous configurerez un inventaire simple, accéderez aux variables hostvars dans les playbooks, les utiliserez dans les modèles (templates) et explorerez des cas d'utilisation pratiques. À la fin de ce laboratoire, vous comprendrez comment exploiter les variables hostvars pour rendre votre automatisation Ansible plus puissante et adaptable.

Ceci est un laboratoire guidé (Guided Lab), qui fournit des instructions étape par étape pour vous aider à apprendre et à pratiquer. Suivez attentivement les instructions pour compléter chaque étape et acquérir une expérience pratique. Les données historiques montrent qu'il s'agit d'un laboratoire de niveau avancé avec un taux d'achèvement de 50%. Il a reçu un taux d'avis positifs de 100% de la part des apprenants.

Configuration de l'environnement du laboratoire

Avant de plonger dans les variables hostvars d'Ansible, nous devons configurer notre environnement de travail. Dans cette étape, nous allons installer Ansible, créer une structure de répertoire de projet et préparer notre fichier d'inventaire.

Installation d'Ansible

Commençons par installer Ansible sur notre système :

sudo apt update
sudo apt install -y ansible

Après l'installation, 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, Mar 15 2023, 11:42:32) [GCC 11.3.0]
  jinja version = 3.0.3
  libyaml = True

Création de la structure du projet

Maintenant, créons une structure de répertoire appropriée pour notre projet Ansible :

mkdir -p ~/project/ansible_hostvars/inventory
mkdir -p ~/project/ansible_hostvars/group_vars
mkdir -p ~/project/ansible_hostvars/playbooks
mkdir -p ~/project/ansible_hostvars/templates
cd ~/project/ansible_hostvars

Création d'un fichier d'inventaire

Ansible utilise des fichiers d'inventaire pour définir les hôtes et les groupes qu'il va gérer. Créons un fichier d'inventaire simple avec quelques hôtes exemples :

cat > ~/project/ansible_hostvars/inventory/hosts << 'EOF'
[webservers]
web01 ansible_host=192.168.1.10 http_port=80 max_connections=100
web02 ansible_host=192.168.1.11 http_port=8080 max_connections=200

[dbservers]
db01 ansible_host=192.168.1.20 db_port=3306 backup_dir=/var/backups
db02 ansible_host=192.168.1.21 db_port=5432 backup_dir=/opt/backups

[all:vars]
ansible_connection=local
ansible_user=labex
environment=development
EOF

Dans ce fichier d'inventaire :

  • Nous avons défini deux groupes : webservers et dbservers
  • Chaque hôte possède des variables spécifiques comme http_port ou db_port
  • Nous avons défini des variables globales pour tous les hôtes sous [all:vars]
  • Nous utilisons ansible_connection=local car il s'agit d'un environnement de laboratoire

Créons également un fichier ansible.cfg simple dans notre répertoire de projet :

cat > ~/project/ansible_hostvars/ansible.cfg << 'EOF'
[defaults]
inventory = ./inventory/hosts
host_key_checking = False
EOF

Maintenant, vérifions notre inventaire :

cd ~/project/ansible_hostvars
ansible-inventory --list

Vous devriez voir une sortie JSON affichant tous les hôtes et leurs variables dans votre inventaire.

Félicitations ! Vous avez configuré avec succès votre environnement Ansible et créé un inventaire avec des variables d'hôte. Dans la prochaine étape, nous explorerons comment accéder à ces variables en utilisant hostvars.

Exploration des variables hostvars d'Ansible

Maintenant que notre environnement est configuré, explorons les variables hostvars d'Ansible et apprenons comment y accéder dans les playbooks.

Comprendre les variables hostvars

Dans Ansible, hostvars est une variable spéciale qui contient des informations sur tous les hôtes de votre inventaire. C'est un dictionnaire où les clés sont les noms d'hôtes et les valeurs sont des dictionnaires contenant toutes les variables définies pour chaque hôte.

Créons un playbook simple pour explorer les variables hostvars :

cat > ~/project/ansible_hostvars/playbooks/explore_hostvars.yml << 'EOF'
---
- name: Explore hostvars
  hosts: all
  gather_facts: no
  tasks:
    - name: Display host variables for the current host
      debug:
        msg: "Host: {{ inventory_hostname }} has the following variables: {{ hostvars[inventory_hostname] }}"
      
    - name: Display a specific variable for the current host
      debug:
        msg: "Host {{ inventory_hostname }} has environment: {{ hostvars[inventory_hostname]['environment'] }}"
EOF

Maintenant, exécutons ce playbook :

cd ~/project/ansible_hostvars
ansible-playbook playbooks/explore_hostvars.yml

Vous devriez voir une sortie avec les variables de chaque hôte. La première tâche affiche toutes les variables pour chaque hôte, tandis que la seconde tâche affiche une variable spécifique.

Création d'un playbook de variables spécifiques à l'hôte

Créons un autre playbook qui démontre comment accéder à différents types de variables spécifiques à l'hôte :

cat > ~/project/ansible_hostvars/playbooks/host_specific_vars.yml << 'EOF'
---
- name: Working with host-specific variables
  hosts: all
  gather_facts: no
  tasks:
    - name: Display web server information
      debug:
        msg: "Web server {{ inventory_hostname }} running on port {{ hostvars[inventory_hostname]['http_port'] | default('N/A') }}"
      when: inventory_hostname in groups['webservers']
    
    - name: Display database server information
      debug:
        msg: "Database server {{ inventory_hostname }} running on port {{ hostvars[inventory_hostname]['db_port'] | default('N/A') }}"
      when: inventory_hostname in groups['dbservers']
EOF

Exécutez ce playbook :

cd ~/project/ansible_hostvars
ansible-playbook playbooks/host_specific_vars.yml

Vous devriez voir une sortie qui affiche des informations différentes pour les serveurs web et les serveurs de base de données, en fonction de leurs variables respectives.

Accès aux variables d'autres hôtes

L'une des fonctionnalités puissantes de hostvars est que vous pouvez accéder aux variables de n'importe quel hôte de votre inventaire. Créons un playbook qui démontre cela :

cat > ~/project/ansible_hostvars/playbooks/cross_host_vars.yml << 'EOF'
---
- name: Access variables from other hosts
  hosts: web01
  gather_facts: no
  tasks:
    - name: Display information about web01 and db01
      debug:
        msg: |
          Web server: {{ inventory_hostname }}
          Web server port: {{ hostvars[inventory_hostname]['http_port'] }}
          
          Database server: db01
          Database port: {{ hostvars['db01']['db_port'] }}
          Backup directory: {{ hostvars['db01']['backup_dir'] }}
EOF

Exécutez ce playbook :

cd ~/project/ansible_hostvars
ansible-playbook playbooks/cross_host_vars.yml

Vous devriez voir une sortie qui affiche des informations provenant à la fois de web01 et de db01, même si le playbook ne s'exécute que sur web01.

Cela démontre comment hostvars vous donne accès aux variables de tous les hôtes de votre inventaire, vous permettant de créer des relations et des dépendances complexes entre les hôtes dans votre automatisation.

Utilisation des variables hostvars dans les templates

Les templates sont l'une des fonctionnalités les plus puissantes d'Ansible, et elles deviennent encore plus puissantes lorsqu'elles sont combinées avec les variables hostvars. Dans cette étape, nous allons apprendre à utiliser les variables hostvars dans les templates Jinja2 pour créer des fichiers de configuration dynamiques.

Introduction aux templates Jinja2

Ansible utilise le moteur de templating Jinja2 pour générer du contenu dynamique. Les templates vous permettent de créer des fichiers de configuration qui s'adaptent à différents hôtes et scénarios.

Créons un template de configuration de serveur web simple :

mkdir -p ~/project/ansible_hostvars/templates
cat > ~/project/ansible_hostvars/templates/nginx.conf.j2 << 'EOF'
## Server configuration for {{ inventory_hostname }}
## Generated by Ansible

server {
    listen {{ hostvars[inventory_hostname]['http_port'] | default(80) }};
    server_name {{ inventory_hostname }};
    
    root /var/www/html;
    
    ## Environment: {{ hostvars[inventory_hostname]['environment'] }}
    
    ## Max connections: {{ hostvars[inventory_hostname]['max_connections'] | default(50) }}
    
    location / {
        index index.html index.htm;
    }
}
EOF

Maintenant, créons un template de configuration de base de données :

cat > ~/project/ansible_hostvars/templates/db.conf.j2 << 'EOF'
## Database configuration for {{ inventory_hostname }}
## Generated by Ansible

port = {{ hostvars[inventory_hostname]['db_port'] }}
backup_directory = {{ hostvars[inventory_hostname]['backup_dir'] }}
environment = {{ hostvars[inventory_hostname]['environment'] }}

## Database hosts in environment:
{% for host in groups['dbservers'] %}
## - {{ host }} ({{ hostvars[host]['ansible_host'] }})
{% endfor %}
EOF

Création d'un playbook pour appliquer les templates

Créons un playbook qui applique ces templates :

cat > ~/project/ansible_hostvars/playbooks/apply_templates.yml << 'EOF'
---
- name: Apply configuration templates
  hosts: all
  gather_facts: no
  tasks:
    - name: Create output directory
      file:
        path: ~/project/ansible_hostvars/output
        state: directory
      run_once: true
    
    - name: Apply web server configuration template
      template:
        src: ../templates/nginx.conf.j2
        dest: ~/project/ansible_hostvars/output/{{ inventory_hostname }}-nginx.conf
      when: inventory_hostname in groups['webservers']
    
    - name: Apply database configuration template
      template:
        src: ../templates/db.conf.j2
        dest: ~/project/ansible_hostvars/output/{{ inventory_hostname }}-db.conf
      when: inventory_hostname in groups['dbservers']
EOF

Maintenant, exécutons ce playbook :

cd ~/project/ansible_hostvars
ansible-playbook playbooks/apply_templates.yml

Après avoir exécuté le playbook, vérifiez les fichiers de configuration générés :

ls -l ~/project/ansible_hostvars/output/

Vous devriez voir des fichiers de configuration générés pour chaque hôte. Examinons l'une des configurations de serveur web :

cat ~/project/ansible_hostvars/output/web01-nginx.conf

Et l'une des configurations de base de données :

cat ~/project/ansible_hostvars/output/db01-db.conf

Remarquez comment les templates utilisent les variables hostvars pour générer dynamiquement des configurations adaptées à chaque hôte.

Utilisation de boucles et de conditions dans les templates

Les templates peuvent utiliser des boucles et des conditions pour créer un contenu encore plus dynamique. Créons un template de fichier d'hôtes complet :

cat > ~/project/ansible_hostvars/templates/hosts.j2 << 'EOF'
## Hosts file generated by Ansible
127.0.0.1 localhost

## Web servers
{% for host in groups['webservers'] %}
{{ hostvars[host]['ansible_host'] }} {{ host }}
{% endfor %}

## Database servers
{% for host in groups['dbservers'] %}
{{ hostvars[host]['ansible_host'] }} {{ host }}
{% endfor %}
EOF

Ajoutons une tâche à notre playbook pour appliquer ce template :

cat > ~/project/ansible_hostvars/playbooks/hosts_template.yml << 'EOF'
---
- name: Create hosts file from template
  hosts: localhost
  gather_facts: no
  tasks:
    - name: Create output directory
      file:
        path: ~/project/ansible_hostvars/output
        state: directory
    
    - name: Generate hosts file
      template:
        src: ../templates/hosts.j2
        dest: ~/project/ansible_hostvars/output/hosts
EOF

Exécutez ce playbook :

cd ~/project/ansible_hostvars
ansible-playbook playbooks/hosts_template.yml

Vérifiez le fichier d'hôtes généré :

cat ~/project/ansible_hostvars/output/hosts

Vous devriez voir un fichier d'hôtes avec tous vos serveurs web et serveurs de base de données, généré dynamiquement à partir de votre inventaire.

Techniques avancées sur les variables hostvars

Maintenant que vous maîtrisez les bases des variables hostvars, explorons quelques techniques avancées pour travailler avec elles dans Ansible.

Utilisation des variables de groupe avec les variables hostvars

Les variables de groupe vous permettent de définir des variables qui s'appliquent à des groupes entiers d'hôtes. Créons un fichier de variables de groupe à l'emplacement correct dans notre répertoire d'inventaire :

mkdir -p ~/project/ansible_hostvars/inventory/group_vars
cat > ~/project/ansible_hostvars/inventory/group_vars/webservers.yml << 'EOF'
---
web_server_type: nginx
default_document_root: /var/www/html
enable_ssl: true
ssl_cert_path: /etc/ssl/certs
EOF

Et un autre pour les serveurs de base de données :

cat > ~/project/ansible_hostvars/inventory/group_vars/dbservers.yml << 'EOF'
---
backup_frequency: daily
backup_retention: 7
monitoring_enabled: true
alert_email: admin@example.com
EOF

Maintenant, créons un playbook qui accède à ces variables de groupe via les variables hostvars :

cat > ~/project/ansible_hostvars/playbooks/group_vars_demo.yml << 'EOF'
---
- name: Demonstrate group variables with hostvars
  hosts: all
  gather_facts: no
  tasks:
    - name: Display web server group variables
      debug:
        msg: |
          Host: {{ inventory_hostname }}
          Web Server Type: {{ hostvars[inventory_hostname]['web_server_type'] | default('N/A') }}
          Document Root: {{ hostvars[inventory_hostname]['default_document_root'] | default('N/A') }}
          SSL Enabled: {{ hostvars[inventory_hostname]['enable_ssl'] | default('N/A') }}
      when: inventory_hostname in groups['webservers']
    
    - name: Display database server group variables
      debug:
        msg: |
          Host: {{ inventory_hostname }}
          Backup Frequency: {{ hostvars[inventory_hostname]['backup_frequency'] | default('N/A') }}
          Backup Retention: {{ hostvars[inventory_hostname]['backup_retention'] | default('N/A') }}
          Monitoring Enabled: {{ hostvars[inventory_hostname]['monitoring_enabled'] | default('N/A') }}
      when: inventory_hostname in groups['dbservers']
EOF

Exécutez ce playbook :

cd ~/project/ansible_hostvars
ansible-playbook playbooks/group_vars_demo.yml

Vous devriez voir une sortie montrant comment les variables de groupe sont disponibles via les variables hostvars.

Création de rapports d'inventaire dynamiques

Créons un playbook qui génère des rapports basés sur les données d'inventaire :

cat > ~/project/ansible_hostvars/playbooks/inventory_report.yml << 'EOF'
---
- name: Generate inventory reports
  hosts: localhost
  gather_facts: no
  tasks:
    - name: Create output directory
      file:
        path: ~/project/ansible_hostvars/output
        state: directory
    
    - name: Generate web servers report
      template:
        src: ../templates/web_report.j2
        dest: ~/project/ansible_hostvars/output/web_servers_report.txt
    
    - name: Generate database servers report
      template:
        src: ../templates/db_report.j2
        dest: ~/project/ansible_hostvars/output/db_servers_report.txt
EOF

Maintenant, créons les templates pour ces rapports :

cat > ~/project/ansible_hostvars/templates/web_report.j2 << 'EOF'
========================================
WEB SERVERS INVENTORY REPORT
========================================

{% for host in groups['webservers'] %}
HOST: {{ host }}
  IP Address: {{ hostvars[host]['ansible_host'] }}
  HTTP Port: {{ hostvars[host]['http_port'] }}
  Max Connections: {{ hostvars[host]['max_connections'] | default('Not specified') }}
  Web Server Type: {{ hostvars[host]['web_server_type'] | default('Not specified') }}
  Environment: {{ hostvars[host]['environment'] }}

{% endfor %}
EOF

cat > ~/project/ansible_hostvars/templates/db_report.j2 << 'EOF'
========================================
DATABASE SERVERS INVENTORY REPORT
========================================

{% for host in groups['dbservers'] %}
HOST: {{ host }}
  IP Address: {{ hostvars[host]['ansible_host'] }}
  DB Port: {{ hostvars[host]['db_port'] }}
  Backup Directory: {{ hostvars[host]['backup_dir'] }}
  Backup Frequency: {{ hostvars[host]['backup_frequency'] | default('Not specified') }}
  Backup Retention: {{ hostvars[host]['backup_retention'] | default('Not specified') }}
  Environment: {{ hostvars[host]['environment'] }}

{% endfor %}
EOF

Maintenant, exécutez le playbook de rapport d'inventaire :

cd ~/project/ansible_hostvars
ansible-playbook playbooks/inventory_report.yml

Vérifiez les rapports générés :

cat ~/project/ansible_hostvars/output/web_servers_report.txt
cat ~/project/ansible_hostvars/output/db_servers_report.txt

Ces rapports démontrent comment les variables hostvars peuvent être utilisées pour créer des rapports complets de votre infrastructure.

Gestion des variables manquantes

Lorsque vous travaillez avec les variables hostvars, il est important de gérer les cas où des variables pourraient être manquantes. Créons un playbook qui démontre un accès sécurisé aux variables :

cat > ~/project/ansible_hostvars/playbooks/safe_variable_access.yml << 'EOF'
---
- name: Demonstrate safe variable access
  hosts: all
  gather_facts: no
  tasks:
    - name: Using default filter
      debug:
        msg: "The value is: {{ hostvars[inventory_hostname]['nonexistent_variable'] | default('Not defined') }}"
    
    - name: Using conditional checks
      debug:
        msg: >
          {% if 'special_variable' in hostvars[inventory_hostname] %}
          The special variable is: {{ hostvars[inventory_hostname]['special_variable'] }}
          {% else %}
          The special variable is not defined for this host.
          {% endif %}
EOF

Exécutez ce playbook :

cd ~/project/ansible_hostvars
ansible-playbook playbooks/safe_variable_access.yml

La sortie montre comment gérer en toute sécurité les variables manquantes en utilisant le filtre default et des vérifications conditionnelles.

Bonnes pratiques et applications concrètes

Dans cette dernière étape, nous allons explorer les bonnes pratiques pour travailler avec les variables hostvars et examiner quelques applications concrètes.

Bonnes pratiques pour l'organisation des variables

Organiser correctement vos variables est crucial pour maintenir un code Ansible propre et maintenable. Créons une structure d'inventaire plus organisée pour démontrer les bonnes pratiques :

mkdir -p ~/project/ansible_hostvars/inventory/group_vars/all
mkdir -p ~/project/ansible_hostvars/inventory/group_vars/webservers
mkdir -p ~/project/ansible_hostvars/inventory/group_vars/dbservers
mkdir -p ~/project/ansible_hostvars/inventory/host_vars

Maintenant, créons quelques fichiers de variables organisés :

cat > ~/project/ansible_hostvars/inventory/group_vars/all/common.yml << 'EOF'
---
## Variables communes pour tous les hôtes
ntp_servers:
  - ntp1.example.com
  - ntp2.example.com

timezone: UTC

monitoring_enabled: true
monitoring_server: monitor.example.com
EOF

cat > ~/project/ansible_hostvars/inventory/group_vars/webservers/web.yml << 'EOF'
---
## Variables spécifiques aux serveurs web
http_protocol: https
default_vhost: default.example.com
web_user: www-data
web_group: www-data

firewall_ports:
  - 80
  - 443
EOF

cat > ~/project/ansible_hostvars/inventory/host_vars/web01.yml << 'EOF'
---
## Variables spécifiques à l'hôte web01
server_role: primary
backup_server: web02
custom_vhosts:
  - name: site1.example.com
    docroot: /var/www/site1
  - name: site2.example.com
    docroot: /var/www/site2
EOF

Créons un playbook qui démontre l'accès à ces variables structurées :

cat > ~/project/ansible_hostvars/playbooks/structured_vars.yml << 'EOF'
---
- name: Demonstrate structured variables
  hosts: localhost
  gather_facts: no
  tasks:
    - name: Display structured variables
      debug:
        msg: |
          Common variables:
          - NTP Servers: {{ hostvars['web01']['ntp_servers'] | default([]) }}
          - Timezone: {{ hostvars['web01']['timezone'] | default('Not set') }}
          
          Web server variables:
          - HTTP Protocol: {{ hostvars['web01']['http_protocol'] | default('Not set') }}
          - Default VHost: {{ hostvars['web01']['default_vhost'] | default('Not set') }}
          
          Host-specific variables for web01:
          - Server Role: {{ hostvars['web01']['server_role'] | default('Not set') }}
          - Backup Server: {{ hostvars['web01']['backup_server'] | default('Not set') }}
          - Custom VHosts: {{ hostvars['web01']['custom_vhosts'] | default([]) }}
EOF

Exécutez ce playbook :

cd ~/project/ansible_hostvars
ANSIBLE_INVENTORY=~/project/ansible_hostvars/inventory ansible-playbook playbooks/structured_vars.yml

Note : Nous utilisons la variable d'environnement ANSIBLE_INVENTORY pour spécifier un chemin d'inventaire différent pour cet exemple.

Création d'un générateur de configuration

Créons une application pratique qui génère des fichiers de configuration pour plusieurs services :

mkdir -p ~/project/ansible_hostvars/templates/configs

Créez des fichiers de template pour différents services :

cat > ~/project/ansible_hostvars/templates/configs/apache.conf.j2 << 'EOF'
## Apache configuration for {{ inventory_hostname }}
Listen {{ hostvars[inventory_hostname]['http_port'] | default(80) }}

ServerName {{ inventory_hostname }}
DocumentRoot {{ hostvars[inventory_hostname]['default_document_root'] | default('/var/www/html') }}

MaxClients {{ hostvars[inventory_hostname]['max_connections'] | default(100) }}

## Environment: {{ hostvars[inventory_hostname]['environment'] }}
EOF

cat > ~/project/ansible_hostvars/templates/configs/mysql.conf.j2 << 'EOF'
## MySQL configuration for {{ inventory_hostname }}
[mysqld]
port = {{ hostvars[inventory_hostname]['db_port'] | default(3306) }}
datadir = /var/lib/mysql
socket = /var/lib/mysql/mysql.sock

max_connections = {{ hostvars[inventory_hostname]['max_connections'] | default(100) }}

## Backup directory: {{ hostvars[inventory_hostname]['backup_dir'] | default('/var/backups') }}
## Environment: {{ hostvars[inventory_hostname]['environment'] }}
EOF

cat > ~/project/ansible_hostvars/templates/configs/postgresql.conf.j2 << 'EOF'
## PostgreSQL configuration for {{ inventory_hostname }}
listen_addresses = '*'
port = {{ hostvars[inventory_hostname]['db_port'] | default(5432) }}

max_connections = {{ hostvars[inventory_hostname]['max_connections'] | default(100) }}

## Backup directory: {{ hostvars[inventory_hostname]['backup_dir'] | default('/var/backups') }}
## Environment: {{ hostvars[inventory_hostname]['environment'] }}
EOF

Maintenant, créez un playbook pour appliquer ces templates :

cat > ~/project/ansible_hostvars/playbooks/config_generator.yml << 'EOF'
---
- name: Generate service configurations
  hosts: all
  gather_facts: no
  tasks:
    - name: Create output directory
      file:
        path: ~/project/ansible_hostvars/output/configs/{{ inventory_hostname }}
        state: directory
    
    - name: Generate Apache configuration for web servers
      template:
        src: ../templates/configs/apache.conf.j2
        dest: ~/project/ansible_hostvars/output/configs/{{ inventory_hostname }}/apache.conf
      when: inventory_hostname in groups['webservers']
    
    - name: Generate MySQL configuration for database servers with MySQL
      template:
        src: ../templates/configs/mysql.conf.j2
        dest: ~/project/ansible_hostvars/output/configs/{{ inventory_hostname }}/mysql.conf
      when: inventory_hostname in groups['dbservers'] and hostvars[inventory_hostname]['db_port'] | string == '3306'
    
    - name: Generate PostgreSQL configuration for database servers with PostgreSQL
      template:
        src: ../templates/configs/postgresql.conf.j2
        dest: ~/project/ansible_hostvars/output/configs/{{ inventory_hostname }}/postgresql.conf
      when: inventory_hostname in groups['dbservers'] and hostvars[inventory_hostname]['db_port'] | string == '5432'
EOF

Exécutez le playbook du générateur de configuration :

cd ~/project/ansible_hostvars
ansible-playbook playbooks/config_generator.yml

Explorez les fichiers de configuration générés :

find ~/project/ansible_hostvars/output/configs -type f | sort

Visualisez certaines des configurations générées :

cat ~/project/ansible_hostvars/output/configs/web01/apache.conf
cat ~/project/ansible_hostvars/output/configs/db01/mysql.conf
cat ~/project/ansible_hostvars/output/configs/db02/postgresql.conf

Création d'un outil de documentation d'hôtes

Enfin, créons un outil qui génère une documentation complète pour chaque hôte de notre inventaire :

cat > ~/project/ansible_hostvars/templates/host_doc.j2 << 'EOF'
## Host Documentation for {{ inventory_hostname }}
==============================================

### Basic Information
- Hostname: {{ inventory_hostname }}
- IP Address: {{ hostvars[inventory_hostname]['ansible_host'] }}
- Environment: {{ hostvars[inventory_hostname]['environment'] | default('Not specified') }}

### Role Information
{% if inventory_hostname in groups['webservers'] %}
- Role: Web Server
- HTTP Port: {{ hostvars[inventory_hostname]['http_port'] | default('Not specified') }}
- Max Connections: {{ hostvars[inventory_hostname]['max_connections'] | default('Not specified') }}
{% if 'web_server_type' in hostvars[inventory_hostname] %}
- Web Server Type: {{ hostvars[inventory_hostname]['web_server_type'] }}
{% endif %}
{% endif %}

{% if inventory_hostname in groups['dbservers'] %}
- Role: Database Server
- DB Port: {{ hostvars[inventory_hostname]['db_port'] | default('Not specified') }}
- Backup Directory: {{ hostvars[inventory_hostname]['backup_dir'] | default('Not specified') }}
{% if 'backup_frequency' in hostvars[inventory_hostname] %}
- Backup Frequency: {{ hostvars[inventory_hostname]['backup_frequency'] }}
- Backup Retention: {{ hostvars[inventory_hostname]['backup_retention'] }} days
{% endif %}
{% endif %}

### Related Hosts
{% if inventory_hostname in groups['webservers'] %}
#### Database Servers:
{% for db_host in groups['dbservers'] %}
- {{ db_host }} ({{ hostvars[db_host]['ansible_host'] }})
{% endfor %}
{% endif %}

{% if inventory_hostname in groups['dbservers'] %}
#### Web Servers:
{% for web_host in groups['webservers'] %}
- {{ web_host }} ({{ hostvars[web_host]['ansible_host'] }})
{% endfor %}
{% endif %}
EOF

Créez un playbook pour générer la documentation :

cat > ~/project/ansible_hostvars/playbooks/host_documentation.yml << 'EOF'
---
- name: Generate host documentation
  hosts: all
  gather_facts: no
  tasks:
    - name: Create output directory
      file:
        path: ~/project/ansible_hostvars/output/docs
        state: directory
    
    - name: Generate host documentation
      template:
        src: ../templates/host_doc.j2
        dest: ~/project/ansible_hostvars/output/docs/{{ inventory_hostname }}.md
EOF

Exécutez le playbook de documentation :

cd ~/project/ansible_hostvars
ansible-playbook playbooks/host_documentation.yml

Visualisez la documentation générée :

ls -l ~/project/ansible_hostvars/output/docs/
cat ~/project/ansible_hostvars/output/docs/web01.md
cat ~/project/ansible_hostvars/output/docs/db01.md

Félicitations ! Vous avez maintenant terminé une exploration complète des variables hostvars d'Ansible, de leur utilisation de base à leurs applications avancées. Vous avez appris à accéder aux variables d'hôtes, à les utiliser dans des templates et à créer des outils pratiques pour gérer votre infrastructure.

Résumé

Dans ce laboratoire, vous avez exploré la puissance et la polyvalence des variables hostvars d'Ansible. Voici ce que vous avez appris :

  1. Configuration de l'environnement : Vous avez configuré un environnement Ansible avec une structure d'inventaire incluant des hôtes, des groupes et des variables.

  2. Exploration des variables hostvars : Vous avez appris à accéder aux variables hostvars dans les playbooks, y compris l'accès aux variables de l'hôte actuel et à celles d'autres hôtes de l'inventaire.

  3. Utilisation des variables hostvars dans les templates : Vous avez créé des templates Jinja2 qui exploitent les variables hostvars pour générer des fichiers de configuration dynamiques adaptés à chaque hôte.

  4. Techniques avancées de variables hostvars : Vous avez exploré les variables de groupe (group_vars), les rapports d'inventaire dynamiques et les techniques pour gérer en toute sécurité les variables manquantes.

  5. Bonnes pratiques et applications concrètes : Vous avez mis en œuvre une organisation structurée des variables et créé des applications pratiques, notamment un générateur de configuration et un outil de documentation d'hôtes.

Les variables hostvars d'Ansible sont une fonctionnalité puissante qui vous permet de créer des flux d'automatisation dynamiques et adaptables. En comprenant comment travailler efficacement avec les variables hostvars, vous pouvez créer des solutions d'automatisation plus flexibles et maintenables pour votre infrastructure.

Alors que vous poursuivez votre parcours avec Ansible, n'oubliez pas que les variables hostvars ne sont qu'une partie du riche écosystème de fonctionnalités d'Ansible. Pensez à explorer d'autres fonctionnalités telles que les rôles (roles), les collections (collections) et les inventaires dynamiques pour améliorer encore vos capacités d'automatisation.

Connexe Ansible Cours
Laboratoires de Certification Red Hat Enterprise Linux Automation avec Ansible (RH294)

Laboratoires de Certification Red Hat Enterprise Linux Automation avec Ansible (RH294)

rhelansiblelinux
Ansible pour les Débutants

Ansible pour les Débutants

ansibledevopslinux