Comment utiliser les vars_files Ansible pour la gestion de la configuration

Introduction

Ce tutoriel vous guidera à travers l'utilisation des vars_files Ansible pour une gestion de configuration efficace. Ansible est un outil d'automatisation puissant qui aide à gérer l'infrastructure grâce à des fichiers YAML simples et lisibles par l'homme. La fonctionnalité vars_files vous permet de séparer vos données de configuration de votre logique d'automatisation, rendant vos projets Ansible plus organisés et maintenables.

À la fin de ce tutoriel, vous apprendrez à créer et organiser des vars_files, à les incorporer dans des playbooks et à les exploiter pour gérer efficacement différents environnements. Ces connaissances vous aideront à construire une automatisation de l'infrastructure plus évolutive et maintenable.

Installation d'Ansible et création de votre premier vars_file

Dans cette première étape, nous allons installer Ansible sur notre système et créer notre premier vars_file pour stocker les données de configuration.

Installation d'Ansible

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

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, affichant la version et la configuration d'Ansible :

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 14 2023, 14:21:35) [GCC 11.3.0]
  jinja version = 3.0.3
  libyaml = True

Création d'une structure de répertoire de projet

Créons une structure de répertoire pour notre projet Ansible :

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

Comprendre les vars_files Ansible

Les vars_files Ansible sont des fichiers YAML qui stockent des définitions de variables pouvant être importées dans les playbooks. Ces fichiers vous permettent de :

1. Séparer les données de configuration de la logique d'automatisation
2. Réutiliser les mêmes variables dans plusieurs playbooks
3. Maintenir différentes configurations pour différents environnements

Création de votre premier vars_file

Créons notre premier vars_file pour stocker les paramètres de configuration du serveur web. En utilisant le WebIDE, créez un nouveau fichier à l'emplacement ~/project/ansible-vars-demo/vars/webserver.yml avec le contenu suivant :

---
## Web Server Configuration
http_port: 80
server_name: example.com
document_root: /var/www/html
max_clients: 200

Ce vars_file définit quatre variables qui pourraient être utilisées pour configurer un serveur web :

• http_port : Le port sur lequel le serveur web écoutera
• server_name : Le nom de domaine du serveur web
• document_root : Le répertoire où les fichiers du site web seront stockés
• max_clients : Le nombre maximum de connexions clientes simultanées

Pour comprendre à quoi cela ressemble dans le WebIDE, accédez à l'explorateur de fichiers sur le côté gauche, développez le dossier project, puis ansible-vars-demo, puis vars, et vous devriez voir votre fichier webserver.yml. Cliquez dessus pour afficher ou modifier son contenu.

Création d'un fichier d'inventaire

Ensuite, nous devons créer un fichier d'inventaire pour indiquer à Ansible quels hôtes gérer. Dans un environnement réel, cela contiendrait les adresses réelles des serveurs, mais pour ce tutoriel, nous utiliserons localhost.

Créez un nouveau fichier à l'emplacement ~/project/ansible-vars-demo/inventory.ini avec le contenu suivant :

[webservers]
localhost ansible_connection=local

Cet inventaire simple définit un groupe appelé webservers qui inclut uniquement notre machine locale.

Comprendre la structure du projet

À ce stade, la structure de votre projet devrait ressembler à ceci :

ansible-vars-demo/
├── inventory.ini
└── vars/
    └── webserver.yml

Cette structure de base sépare notre inventaire (quels hôtes gérer) de nos définitions de variables (comment configurer ces hôtes).

Création d'un playbook de base avec vars_files

Maintenant que notre vars_file est créé, construisons un playbook Ansible simple qui utilise ces variables. Cela démontrera comment importer et utiliser les données de configuration à partir des vars_files.

Comprendre les playbooks Ansible

Les playbooks Ansible sont des fichiers YAML qui définissent un ensemble de tâches à exécuter sur les hôtes gérés. Les playbooks sont au cœur des fonctionnalités d'Ansible, vous permettant d'automatiser des processus de configuration complexes.

Création d'un playbook simple

Créons un playbook qui simulera la configuration d'un serveur web en utilisant les variables que nous avons définies dans notre vars_file. Créez un nouveau fichier à l'emplacement ~/project/ansible-vars-demo/webserver_setup.yml avec le contenu suivant :

---
- name: Configure Web Server
  hosts: webservers
  vars_files:
    - vars/webserver.yml

  tasks:
    - name: Display web server configuration
      debug:
        msg: "Web server will be configured with: Port={{ http_port }}, ServerName={{ server_name }}, DocumentRoot={{ document_root }}"

    - name: Create a directory for document root
      file:
        path: "/tmp/{{ document_root }}"
        state: directory
        mode: "0755"

    - name: Create a sample index.html file
      copy:
        content: |
          <html>
            <head>
              <title>Welcome to {{ server_name }}</title>
            </head>
            <body>
              <h1>Welcome to {{ server_name }}</h1>
              <p>This server is configured to handle {{ max_clients }} simultaneous connections.</p>
            </body>
          </html>
        dest: "/tmp/{{ document_root }}/index.html"
        mode: "0644"

Comprenons ce que fait ce playbook :

1. hosts: webservers - Spécifie que ce playbook doit s'exécuter sur tous les hôtes du groupe "webservers" de notre inventaire.
2. vars_files: - vars/webserver.yml - Importe les variables de notre vars_file.
3. La première tâche utilise le module debug pour afficher un message montrant les variables.
4. La deuxième tâche crée une structure de répertoire qui serait utilisée pour la racine du document du serveur web.
5. La troisième tâche crée un exemple de fichier HTML qui inclut les variables de notre vars_file.

Exécution du playbook

Maintenant, exécutons le playbook pour le voir en action :

cd ~/project/ansible-vars-demo
ansible-playbook -i inventory.ini webserver_setup.yml

Vous devriez voir une sortie similaire à celle-ci :

PLAY [Configure Web Server] ****************************************************

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

TASK [Display web server configuration] ****************************************
ok: [localhost] => {
    "msg": "Web server will be configured with: Port=80, ServerName=example.com, DocumentRoot=/var/www/html"
}

TASK [Create a directory for document root] ************************************
changed: [localhost]

TASK [Create a sample index.html file] *****************************************
changed: [localhost]

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

Vérification des résultats

Vérifions que notre playbook a créé les fichiers attendus :

ls -la /tmp/var/www/html/
cat /tmp/var/www/html/index.html

Vous devriez voir la structure du répertoire et le contenu du fichier index.html, qui devrait inclure les valeurs de notre vars_file :

<html>
  <head>
    <title>Welcome to example.com</title>
  </head>
  <body>
    <h1>Welcome to example.com</h1>
    <p>This server is configured to handle 200 simultaneous connections.</p>
  </body>
</html>

Comprendre le flux de travail

Récapitulons ce que nous avons accompli :

1. Nous avons stocké les données de configuration dans un vars_file séparé (vars/webserver.yml).
2. Nous avons créé un playbook qui importe et utilise ces données de configuration.
3. Nous avons exécuté le playbook pour exécuter des tâches qui utilisent les variables.

Cette séparation des données de configuration (vars_files) de la logique d'automatisation (playbooks) rend notre code Ansible plus maintenable et réutilisable. Nous pouvons maintenant mettre à jour la configuration en modifiant uniquement le vars_file, sans modifier le playbook lui-même.

Travailler avec plusieurs vars_files

Maintenant que nous comprenons les bases des vars_files, explorons comment utiliser plusieurs vars_files pour gérer différents environnements. C'est une pratique courante dans les scénarios réels où vous pourriez avoir différentes configurations pour les environnements de développement, de pré-production et de production.

Création de vars_files spécifiques à l'environnement

Créons des vars_files pour différents environnements. Tout d'abord, créons une configuration d'environnement de développement :

Créez un nouveau fichier à l'emplacement ~/project/ansible-vars-demo/vars/dev_environment.yml avec le contenu suivant :

---
## Development Environment Configuration
environment_name: development
debug_mode: true
log_level: debug
backup_frequency: weekly
max_memory: 512MB

Ensuite, créons une configuration d'environnement de production :

Créez un nouveau fichier à l'emplacement ~/project/ansible-vars-demo/vars/prod_environment.yml avec le contenu suivant :

---
## Production Environment Configuration
environment_name: production
debug_mode: false
log_level: error
backup_frequency: daily
max_memory: 2048MB

Création d'un playbook avec plusieurs vars_files

Maintenant, créons un playbook qui utilise à la fois notre configuration de serveur web et les configurations spécifiques à l'environnement. Créez un nouveau fichier à l'emplacement ~/project/ansible-vars-demo/environment_setup.yml avec le contenu suivant :

---
- name: Configure Environment
  hosts: webservers
  vars:
    env: dev
  vars_files:
    - vars/webserver.yml
    - "vars/{{ env }}_environment.yml"

  tasks:
    - name: Display environment details
      debug:
        msg: >
          Setting up {{ environment_name }} environment with the following parameters:
          - Web Server: {{ server_name }} on port {{ http_port }}
          - Debug Mode: {{ debug_mode }}
          - Log Level: {{ log_level }}
          - Backup Frequency: {{ backup_frequency }}
          - Max Memory: {{ max_memory }}
          - Max Clients: {{ max_clients }}

    - name: Create environment config file
      copy:
        content: |
          ## Environment Configuration for {{ server_name }}
          ENVIRONMENT={{ environment_name }}
          DEBUG={{ debug_mode }}
          LOG_LEVEL={{ log_level }}
          BACKUP_FREQUENCY={{ backup_frequency }}
          MAX_MEMORY={{ max_memory }}
          HTTP_PORT={{ http_port }}
          MAX_CLIENTS={{ max_clients }}
        dest: "/tmp/{{ environment_name }}_config.env"
        mode: "0644"

Ce playbook introduit plusieurs nouveaux concepts :

1. Nous définissons une variable env: dev dans le playbook lui-même.
2. Nous incluons à la fois notre vars_file de serveur web et un vars_file spécifique à l'environnement.
3. Le chemin du vars_file de l'environnement inclut une variable : "vars/{{ env }}_environment.yml", qui est évaluée à vars/dev_environment.yml.
4. Les tâches utilisent des variables des deux vars_files.

Exécution du playbook avec différents environnements

Exécutons d'abord le playbook avec l'environnement de développement (qui est déjà la valeur par défaut) :

cd ~/project/ansible-vars-demo
ansible-playbook -i inventory.ini environment_setup.yml

Vous devriez voir une sortie qui inclut les paramètres de l'environnement de développement :

TASK [Display environment details] ********************************************
ok: [localhost] => {
    "msg": "Setting up development environment with the following parameters:\n- Web Server: example.com on port 80\n- Debug Mode: True\n- Log Level: debug\n- Backup Frequency: weekly\n- Max Memory: 512MB\n- Max Clients: 200"
}

Maintenant, exécutons le même playbook mais remplaçons la variable env pour utiliser l'environnement de production :

ansible-playbook -i inventory.ini environment_setup.yml -e "env=prod"

Vous devriez voir une sortie qui inclut les paramètres de l'environnement de production :

TASK [Display environment details] ********************************************
ok: [localhost] => {
    "msg": "Setting up production environment with the following parameters:\n- Web Server: example.com on port 80\n- Debug Mode: False\n- Log Level: error\n- Backup Frequency: daily\n- Max Memory: 2048MB\n- Max Clients: 200"
}

Vérification des fichiers de configuration

Vérifions que notre playbook a créé les fichiers de configuration de l'environnement :

cat /tmp/development_config.env
cat /tmp/production_config.env

Vous devriez voir deux fichiers de configuration différents, chacun avec les paramètres du vars_file de l'environnement respectif.

Comprendre la précédence des variables

Il est important de comprendre que lors de l'utilisation de plusieurs vars_files, Ansible suit un ordre de précédence spécifique pour les variables. Si le même nom de variable apparaît à plusieurs endroits, la valeur définie plus tard remplacera les définitions antérieures.

Dans notre exemple, si nous avions défini http_port à la fois dans les fichiers webserver.yml et dev_environment.yml, la valeur de dev_environment.yml aurait la priorité car elle est incluse plus tard dans la liste vars_files.

Ce comportement vous permet de définir des valeurs par défaut communes dans un fichier, puis de remplacer des valeurs spécifiques pour différents environnements.

Techniques avancées avec les vars_files

Dans cette dernière étape, nous allons explorer quelques techniques avancées pour travailler avec les vars_files dans Ansible, notamment l'organisation hiérarchique des variables et la mise en œuvre d'une organisation des variables basée sur les rôles.

Organisation hiérarchique des variables

Dans les projets complexes, il est souvent utile d'organiser les variables de manière hiérarchique. Créons une structure où nous avons :

1. Des variables communes qui s'appliquent à tous les environnements
2. Des variables spécifiques à l'environnement
3. Des variables spécifiques à l'application

Tout d'abord, créons un fichier de variables communes :

Créez un nouveau fichier à l'emplacement ~/project/ansible-vars-demo/vars/common.yml avec le contenu suivant :

---
## Common variables for all environments
organization: "Example Corp"
admin_email: "admin@example.com"
timezone: "UTC"

Ensuite, créons des variables spécifiques à l'application :

Créez un nouveau fichier à l'emplacement ~/project/ansible-vars-demo/vars/database.yml avec le contenu suivant :

---
## Database application variables
db_port: 3306
db_user: "dbuser"
db_name: "appdb"
db_max_connections: 100

Création d'un playbook hiérarchique

Maintenant, créons un playbook qui démontre l'utilisation de ces variables hiérarchiques. Créez un nouveau fichier à l'emplacement ~/project/ansible-vars-demo/hierarchical_setup.yml avec le contenu suivant :

---
- name: Hierarchical Variable Demo
  hosts: webservers
  vars:
    env: dev
    app: database
  vars_files:
    - "vars/common.yml"
    - "vars/{{ env }}_environment.yml"
    - "vars/{{ app }}.yml"

  tasks:
    - name: Display hierarchical configuration
      debug:
        msg: >
          Configuration for {{ app }} in {{ environment_name }} environment:
          - Organization: {{ organization }}
          - Admin Email: {{ admin_email }}
          - Timezone: {{ timezone }}
          - Debug Mode: {{ debug_mode }}
          - Log Level: {{ log_level }}
          - DB Port: {{ db_port }}
          - DB User: {{ db_user }}
          - DB Max Connections: {{ db_max_connections }}

    - name: Create hierarchical config file
      copy:
        content: |
          ## {{ organization }} Configuration
          ## {{ environment_name }} Environment

          ## Common Settings
          ADMIN_EMAIL={{ admin_email }}
          TIMEZONE={{ timezone }}

          ## Environment Settings
          DEBUG={{ debug_mode }}
          LOG_LEVEL={{ log_level }}
          BACKUP_FREQUENCY={{ backup_frequency }}

          ## {{ app | capitalize }} Settings
          DB_PORT={{ db_port }}
          DB_USER={{ db_user }}
          DB_NAME={{ db_name }}
          DB_MAX_CONNECTIONS={{ db_max_connections }}
        dest: "/tmp/{{ environment_name }}_{{ app }}_config.conf"
        mode: "0644"

Comprendre les variables de groupe et d'hôte

En plus des vars_files, Ansible prend également en charge le stockage des variables dans des répertoires spéciaux appelés group_vars et host_vars. Voyons comment cela fonctionne :

Créez une structure de répertoire pour les variables de groupe et d'hôte :

mkdir -p ~/project/ansible-vars-demo/group_vars
mkdir -p ~/project/ansible-vars-demo/host_vars

Maintenant, créez un fichier de variables de groupe pour le groupe 'webservers' :

Créez un nouveau fichier à l'emplacement ~/project/ansible-vars-demo/group_vars/webservers.yml avec le contenu suivant :

---
## Variables for all webservers
firewall_enabled: true
ssh_port: 22
monitoring_enabled: true

Et créez un fichier de variables d'hôte pour 'localhost' :

Créez un nouveau fichier à l'emplacement ~/project/ansible-vars-demo/host_vars/localhost.yml avec le contenu suivant :

---
## Variables specific to localhost
local_backup_path: "/tmp/backups"
is_development_machine: true

Création d'un playbook avec tous les types de variables

Créons un dernier playbook qui démontre l'utilisation de tous les types de variables ensemble. Créez un nouveau fichier à l'emplacement ~/project/ansible-vars-demo/complete_setup.yml avec le contenu suivant :

---
- name: Complete Variable Demo
  hosts: webservers
  vars:
    env: prod
    app: database
  vars_files:
    - "vars/common.yml"
    - "vars/{{ env }}_environment.yml"
    - "vars/{{ app }}.yml"

  tasks:
    - name: Display complete configuration
      debug:
        msg: >
          Complete configuration for {{ inventory_hostname }}:
          - Organization: {{ organization }}
          - Environment: {{ environment_name }}
          - Debug Mode: {{ debug_mode }}
          - Firewall Enabled: {{ firewall_enabled }}
          - SSH Port: {{ ssh_port }}
          - Monitoring Enabled: {{ monitoring_enabled }}
          - Local Backup Path: {{ local_backup_path }}
          - Is Development Machine: {{ is_development_machine }}

    - name: Create complete config file
      copy:
        content: |
          ## {{ organization }} - {{ environment_name }} Environment
          ## Host: {{ inventory_hostname }}

          ## Common Settings
          ADMIN_EMAIL={{ admin_email }}
          TIMEZONE={{ timezone }}

          ## Environment Settings
          DEBUG={{ debug_mode }}
          LOG_LEVEL={{ log_level }}

          ## Server Settings
          FIREWALL_ENABLED={{ firewall_enabled }}
          SSH_PORT={{ ssh_port }}
          MONITORING_ENABLED={{ monitoring_enabled }}

          ## Host-specific Settings
          LOCAL_BACKUP_PATH={{ local_backup_path }}
          IS_DEVELOPMENT_MACHINE={{ is_development_machine }}

          ## {{ app | capitalize }} Settings
          DB_PORT={{ db_port }}
          DB_USER={{ db_user }}
          DB_NAME={{ db_name }}
        dest: "/tmp/complete_config.conf"
        mode: "0644"

Exécution des playbooks avancés

Exécutons notre playbook hiérarchique :

cd ~/project/ansible-vars-demo
ansible-playbook -i inventory.ini hierarchical_setup.yml

Vous devriez voir une sortie qui inclut les variables des trois vars_files.

Maintenant, exécutons notre playbook complet :

ansible-playbook -i inventory.ini complete_setup.yml

Cette fois, vous devriez voir une sortie qui inclut les variables des vars_files, group_vars et host_vars.

Vérification des fichiers de configuration

Vérifions les fichiers de configuration créés par nos playbooks avancés :

cat /tmp/dev_database_config.conf
cat /tmp/complete_config.conf

Comprendre la précédence des variables dans Ansible

Lors de l'utilisation de plusieurs sources de variables, Ansible suit un ordre de précédence spécifique :

1. Variables de ligne de commande (-e ou --extra-vars)
2. Variables définies dans le play
3. Variables des fichiers et rôles inclus
4. Faits d'hôte (Host facts)
5. Variables d'hôte (Host vars)
6. Variables de groupe (Group vars)
7. Variables d'inventaire (Inventory vars)
8. Variables par défaut du rôle (Role default vars)

Cela signifie que les variables définies dans host_vars remplaceront les mêmes variables définies dans group_vars, qui remplaceront les mêmes variables définies dans les vars_files.

Cette structure hiérarchique vous offre un moyen puissant de gérer la configuration dans différents environnements, hôtes et applications.

Résumé

Dans ce tutoriel, vous avez appris à utiliser efficacement les vars_files d'Ansible pour la gestion de la configuration. Vous avez :

1. Installé Ansible et créé votre premier vars_file pour stocker les données de configuration
2. Créé et exécuté un playbook de base qui utilise les vars_files pour séparer la configuration de la logique d'automatisation
3. Travaillé avec plusieurs vars_files pour gérer différents environnements
4. Exploré des techniques avancées, notamment l'organisation hiérarchique des variables et l'utilisation de group_vars et host_vars

Ces compétences fournissent une base solide pour la création d'une automatisation Ansible évolutive et maintenable. En séparant vos données de configuration de votre logique d'automatisation, vous pouvez :

• Rendre vos playbooks plus réutilisables dans différents environnements
• Simplifier le processus de mise à jour des valeurs de configuration
• Gérer des configurations complexes de manière structurée
• Améliorer la collaboration en organisant clairement les données de configuration

Au fur et à mesure que vous continuez à travailler avec Ansible, rappelez-vous qu'une gestion efficace des variables est essentielle pour créer une automatisation maintenable. Les techniques que vous avez apprises dans ce tutoriel vous aideront à organiser vos projets Ansible à mesure qu'ils gagnent en complexité.