Introduction aux variables simples dans les playbooks

Rendre vos playbooks dynamiques et réutilisables avec les variables

L'un des aspects fondamentaux qui transforment un simple script d'automatisation en une solution d'Infrastructure as Code (IaC) flexible et puissante est l'utilisation de variables. Dans Ansible, les variables permettent de stocker des valeurs qui peuvent être réutilisées à plusieurs endroits dans vos playbooks, de gérer des configurations spécifiques à des environnements (développement, test, production), ou d'adapter le comportement de vos automatisations sans avoir à modifier le code des tâches elles-mêmes.

Plutôt que de coder en dur des chaînes de caractères, des chemins de fichiers, des noms de paquets ou des paramètres de configuration, vous les définissez comme des variables. Cela rend vos playbooks plus lisibles, plus faciles à maintenir et surtout, beaucoup plus réutilisables et adaptables à différents contextes.

Cette section introduit le concept de variables simples directement définies au sein d'un playbook, en se concentrant sur la section vars:. C'est le point de départ pour comprendre comment dynamiser vos playbooks Ansible.

Pourquoi utiliser des variables dans les playbooks ?

L'utilisation de variables dans vos playbooks Ansible offre plusieurs avantages significatifs :

• Réutilisabilité : Vous pouvez écrire un playbook générique et l'adapter à différents scénarios ou environnements simplement en changeant les valeurs des variables, sans toucher à la logique des tâches.
• Maintenabilité : Si une valeur (comme un numéro de version, un nom d'utilisateur, ou un port) doit être changée, vous ne la modifiez qu'à un seul endroit (là où la variable est définie) au lieu de la chercher et la remplacer dans de multiples tâches. Cela réduit le risque d'erreurs et de configurations incohérentes.
• Lisibilité : Des noms de variables bien choisis peuvent rendre vos playbooks plus clairs en explicitant la signification de certaines valeurs. Par exemple, {{ web_server_port }} est plus parlant que 8080 directement dans une tâche.
• Abstraction : Les variables permettent d'abstraire des détails spécifiques à un environnement ou à une configuration, rendant le corps principal du playbook plus générique et axé sur la logique d'automatisation.
• Cohérence : En utilisant des variables pour des valeurs récurrentes, vous vous assurez qu'elles sont utilisées de manière cohérente à travers tout le playbook.

Même pour des playbooks simples, prendre l'habitude d'utiliser des variables pour les données qui pourraient potentiellement changer ou être réutilisées est une excellente pratique.

Définir des variables simples avec la section `vars:`

La manière la plus directe de définir des variables pour un jeu (play) spécifique dans un playbook est d'utiliser la section vars:. Cette section est une carte (dictionnaire) YAML où chaque clé est le nom de la variable et sa valeur est... eh bien, la valeur de la variable.

Voici la syntaxe de base :

- hosts: mes_serveurs
  become: yes
  vars:
    nom_utilisateur: "alice"
    paquet_a_installer: "htop"
    repertoire_app: "/opt/myapplication"
    port_ecoute: 8080
    activer_ssl: false

  tasks:
    - name: Créer l'utilisateur {{ nom_utilisateur }}
      user:
        name: "{{ nom_utilisateur }}"
        state: present

    - name: Installer le paquet {{ paquet_a_installer }}
      apt:
        name: "{{ paquet_a_installer }}"
        state: present

    - name: Créer le répertoire de l'application {{ repertoire_app }}
      file:
        path: "{{ repertoire_app }}"
        state: directory
        owner: "{{ nom_utilisateur }}"

    - name: Configurer l'application pour écouter sur le port {{ port_ecoute }}
      lineinfile:
        path: "{{ repertoire_app }}/config.ini"
        regexp: '^listen_port'
        line: "listen_port = {{ port_ecoute }}"
      when: not activer_ssl # Utilisation d'une variable booléenne dans une condition

Dans cet exemple :

• nom_utilisateur, paquet_a_installer, repertoire_app, port_ecoute, et activer_ssl sont les noms des variables.
• Les valeurs associées sont des chaînes de caractères (comme "alice"), un entier (8080), ou un booléen (false).
• Notez que les chaînes de caractères peuvent être mises entre guillemets (doubles ou simples) ou non, si elles ne contiennent pas de caractères spéciaux YAML ou ne commencent pas par un chiffre pouvant être interprété autrement. L'utilisation de guillemets est souvent une bonne pratique pour éviter les ambiguïtés.

Les variables définies dans la section vars: d'un jeu sont disponibles pour toutes les tâches de ce jeu. Il est également possible de définir une section vars: au niveau d'une tâche spécifique, mais ces variables n'auront alors de portée que pour cette tâche (c'est moins courant pour les variables réutilisables).

Utiliser (référencer) les variables dans les tâches

Une fois qu'une variable est définie, vous pouvez l'utiliser dans vos tâches en l'insérant avec la syntaxe de templating Jinja2, qui est le moteur de template utilisé par Ansible. La forme la plus courante est {{ nom_de_la_variable }}.

Reprenons l'exemple précédent :

    - name: Installer le paquet {{ paquet_a_installer }}
      apt:
        name: "{{ paquet_a_installer }}"
        state: present

# Bonnes pratiques
name: "{{ paquet_a_installer }}"
path: "{{ repertoire_app }}/logs"
line: "option = {{ valeur_option }}"

vars:
  timeout_value: 30
tasks:
  - name: Définir un timeout
    some_module:
      timeout: "{{ timeout_value }}" # Ici, même si timeout_value est 30, le module s'attend à une chaîne pour 'timeout'
      # ou, si le module attend un entier :
      # timeout: {{ timeout_value }}

Les variables peuvent également être utilisées dans les conditions when :

tasks:
  - name: Configurer SSL
    # ... tâches de configuration SSL ...
    when: activer_ssl == true # ou simplement 'when: activer_ssl' si c'est un booléen

Aller plus loin avec les variables

La section vars: dans un playbook est le moyen le plus simple de commencer avec les variables. Cependant, Ansible offre des mécanismes beaucoup plus riches et hiérarchisés pour gérer les variables, notamment :

• Fichiers de variables (vars_files) : Pour externaliser les variables dans des fichiers séparés, ce qui est bien meilleur pour l'organisation et la gestion des configurations spécifiques à des environnements.
• Variables d'inventaire : Définir des variables spécifiques à des hôtes ou à des groupes d'hôtes directement dans votre fichier d'inventaire.
• Variables de rôle : Chaque rôle Ansible peut avoir ses propres variables par défaut, variables spécifiques, etc.
• Variables extra (-e en ligne de commande) : Passer des variables lors de l'exécution du playbook.
• Variables enregistrées (register) : Stocker la sortie d'une tâche dans une variable pour l'utiliser dans des tâches ultérieures.
• Facts Ansible (ansible_facts) : Variables automatiquement découvertes par Ansible sur les noeuds gérés (comme l'OS, l'adresse IP, etc.).

Comprendre et maîtriser l'utilisation des variables, y compris leur portée et leur précédence (quelle variable surcharge quelle autre en cas de noms identiques définis à plusieurs endroits), est une étape clé pour devenir compétent avec Ansible. Pour l'instant, concentrez-vous sur l'utilisation confortable de vars: pour rendre vos playbooks plus dynamiques et maintenables.