Variables Ansibles

Dans notre dernier article, nous avons expliqué ce que sont les playbooks Ansible et comment créer et exécuter des tâches via des playbooks. Dans cet article, nous irons plus loin et apprendrons comment utiliser des variables dans les playbooks Ansible.

Que sont les variables Ansible ?

Les Variables sont des concepts de base dans tous les langages de programmation qui sont utilisés pour stocker des données et ensuite utilisés dans le code. De même, ansible possède des variables qui stockent certaines valeurs, et elles sont ensuite utilisées dans le playbook pour différents traitements.

Ansible prend en charge la déclaration de variables à plusieurs endroits tels que les playbooks, les fichiers host_vars et group_vars et les arguments de ligne de commande.

Dans les prochaines sections, nous verrons comment définir des variables à différents endroits et en apprendrons davantage sur la priorité des variables.

Variable - Clé, mappage de valeurs

Les variables peuvent être définies au niveau du jeu et au niveau de la tâche à l'aide du mot-clé "vars". Après le mot-clé vars, la variable avec clé et valeur est donnée. Ces variables sont accessibles par toutes les tâches de la pièce.

J'ai créé une tâche qui utilise le module de débogage pour imprimer un message en utilisant des valeurs variables. Les variables doivent être entourées de doubles accolades {{ variable }>.

Comment utiliser le module de débogage dans les playbooks Ansible

- name: Print vars
  hosts: m1
  gather_facts: false

  vars:
    os_name: "PoP!_OS Desktop"
    version: "21.10"

  tasks:
    - name: Task1 - Substitute variables
      debug:
        msg: "My current desktop OS is {{ os_name }} - {{ version }}"
Key-value variable Mapping

Maintenant, pour exécuter le playbook, exécutez la commande suivante dans le terminal.

ansible-playbook playbook_name.yml

Dans l'image ci-dessous, vous pouvez voir que mes deux variables sont remplacées par leurs valeurs lorsque le msg est imprimé sur la sortie standard.

Résultat de la tâche

Variable - Liste des éléments

Vous pouvez créer une liste d'éléments dans une variable. Si vous jetez un œil à la définition ci-dessous, j'ai créé une variable de liste de deux manières.

• Manière YAML standard de définir une liste d'éléments/éléments. Ici, j'ai donné les noms de variables comme "top_linux_desktops".
• Syntaxe Python pour créer une liste d'éléments/éléments. Ici, j'ai donné les noms de variables comme "top_desktops".

  vars:
    
    top_linux_desktops:
      - MXlinux
      - pop-os
      - Linux Mint
      - Manjaro
      - Fedora

    top_desktops: [MXLinux, pop-os, Linux Mint, Manjaro, Fedora]

Vous pouvez imprimer tous les éléments de la liste en utilisant le nom de la variable. J'ai créé deux tâches. La première tâche imprimera les éléments de la variable top_linux_desktops et la deuxième tâche imprimera les éléments de la variable top_desktops.

  tasks:
    - name: Task1 - List of elements
      debug:
        msg: "My fav linux desktops are {{ top_linux_desktops }}"

    - name: Task2 - List of elements using Python syntax
      debug:
        msg: "My fav linux desktops are {{ top_desktops }}"    

Liste des éléments

Dans la liste, vous pouvez également accéder à l'élément individuel en utilisant sa position d'index, de la même manière que vous accédez aux éléments d'une liste Python. Il y a deux façons de procéder.

• Utilisation de la notation par points (variable.index)
• Notation Python(variable[index])

J'ai créé deux tâches. La première tâche utilise la notation par points et la deuxième tâche utilise la notation Python pour imprimer l'élément à partir des première et deuxième positions.

  tasks:    

    - name: Task3 - Accessing List element using dot notation
      debug:
        msg: "My fav linux desktops are {{ top_linux_desktops.1 }} and {{ top_desktops[2] }}"

    - name: Task4 - Accessing List element using python notation(list[i])
      debug:
        msg: "My fav linux desktops are {{ top_linux_desktops[1] }} and {{ top_desktops[2] }}"

Imprimer des éléments à l'aide de la position d'index

Variable - Dictionnaire

Vous pouvez créer un objet dictionnaire et l'attribuer à la variable. Ceci est similaire aux dictionnaires Python. Les dictionnaires peuvent être créés de deux manières.

• syntaxe YAML standard pour définir le dictionnaire
• Notation du dictionnaire Python

Si vous pouvez voir l'extrait de playbook ci-dessous, j'ai créé deux variables de dictionnaire. La première variable "release_info" suit l'approche syntaxique YAML et la deuxième variable "new_release_info" suit la syntaxe du dictionnaire Python.

  vars:
    release_info:
      name: PoP!_OS Desktop
      version: 22.04
      release_month: April, 2022
    
    new_release_info: { name: PoP!_OS Desktop, version: 22.04, release_month: "April, 2022"}

Vous pouvez soit récupérer toutes les valeurs de la variable, soit un élément particulier du dictionnaire à l'aide de sa clé. Semblable à la liste, le dictionnaire suit également la notation par points et python pour imprimer la valeur d'une clé.

J'ai créé deux tâches, la première tâche utilisera la notation par points pour récupérer l'élément du dictionnaire et la deuxième tâche utilisera la notation python pour récupérer l'élément.

  tasks:

    - name: Task1 - Accessing dictionary values using its key with dot notation(dict.key)
      debug:
        msg: "{{ release_info.name }} version {{ release_info.version }} is released on {{ release_info.release_month }}"

    - name: Task2 - Accessing dictionary values using its key with python notation(dict['key'])
      debug:
        msg: "{{ new_release_info['name'] }} version {{ new_release_info['version'] }} is released on {{ new_release_info['release_month'] }}"

Variable de dictionnaire - Sortie

Priorité du niveau de jeu par rapport à la tâche

Les variables peuvent être définies à la fois au niveau de la tâche et au niveau du jeu, mais les variables définies au niveau de la tâche ont la priorité sur les variables définies au niveau du jeu.

Dans l'exemple ci-dessous, j'ai créé des variables au niveau du jeu et au niveau de la tâche avec les mêmes noms de variables. Désormais, lorsque j'exécuterai le playbook, il utilisera les noms de variables de tâches.

  vars:
    os_name: "PoP!_OS Desktop"
    version: "21.10"

  tasks:
    - name: Task1 - Substitute variables
      vars:
        os_name: "Linux Mint"
        version: "20.03"
      debug:
          msg: "My current desktop OS is {{ os_name }} - {{ version }}"

Tâche vs Jeu - Priorité

Priorité des arguments du Playbook et de la ligne de commande

Vous pouvez remplacer la variable transmise dans le playbook en utilisant l'indicateur -e. Une priorité plus élevée est donnée aux variables passées via l'indicateur -e.

J'exécute le même playbook de la section précédente en remplaçant à nouveau les variables avec l'indicateur -e.

ansible-playbook 4_var_precedence.yml -e "os_name=fedora" -e "version=35"

Variable utilisant un argument de ligne de commande

Vous pouvez transmettre des variables au drapeau -e au format Json, YAML ou ini.

INI FORMAT
ansible-playbook 4_var_precedence.yml -e "os_name=fedora" -e "version=35"

JSON FORMAT
ansible-playbook 4_var_precedence.yml -e '{"os_name": "fedora"}' -e '{"version": 35}'

YAML FORMAT
ansible-playbook 4_var_precedence.yml -e "{os_name: fedora}" -e "{version: 35}"

Vous pouvez également créer un fichier séparé pour la variable et le transmettre via l'indicateur -e. La syntaxe sera la suivante. Ici, j'ai créé un fichier nommé vars.yml et regroupé toutes mes variables. Désormais, lorsque le fichier est passé à l'indicateur -e, toutes les variables sont importées dans le playbook.

ansible-playbook 4_var_precedence.yml -e @vars.yml

Fichier de variables

Au lieu de définir la variable dans le playbook, vous pouvez créer un fichier et déclarer toutes les variables du fichier. J'ai créé un fichier appelé vars.yml et regroupé toutes les variables dont nous avons discuté dans les sections précédentes de ce fichier.

Variable déclarée dans le fichier

Au lieu d'utiliser le mot-clé vars, vous devez utiliser vars_files dans le playbook et transmettre le nom du fichier. Désormais, lorsque vous exécutez le playbook, ansible sélectionnera les variables du fichier. Le fichier peut se trouver dans n'importe quel chemin.

Mot-clé Var_files dans le Playbook

Variables définies dans le fichier

Variables d'hôte et de groupe

Vous pouvez définir des variables au niveau de l'hôte et au niveau du groupe dans le fichier d'inventaire. Vous pouvez vous référer à l'article suivant dans lequel nous avons brièvement expliqué comment créer des variables au niveau de l'hôte et du groupe.

Fichiers d'inventaire et de configuration Ansible

En tant que bonne pratique, vous ne devez pas définir les variables dans le fichier d'inventaire. Vous pouvez plutôt créer des répertoires pour host_vars et group_vars et ansible sélectionnera automatiquement les fichiers dans le répertoire. Créez un répertoire appelé host_vars.

mkdir host_vars

Dans le répertoire host_vars, vous pouvez définir des variables au niveau de l'hôte, c'est-à-dire que vous pouvez créer un fichier au format INI, YAML ou JSON et stocker des variables pour un hôte particulier. Si vous jetez un œil à mon fichier d'inventaire ci-dessous, j'ai deux hôtes nommés « ubuntu » et « rocky » et j'ai créé le fichier de variables pour chaque hôte.

Attention : Les fichiers doivent porter le même nom que le nom d'hôte/alias dans votre fichier d'inventaire.

Inventory file
[m1]
ubuntu ansible_host=ubuntu.anslab.com 

[m2]
rocky ansible_host=rocky.anslab.com

mkdir host_vars/ubuntu.yml
echo "message: This variable is read from host_vars/ubuntu.yml file" > host_vars/ubuntu.yml"

mkdir host_vars/rocky.yml
echo "message: This variable is read from host_vars/rocky.yml file" > host_vars/rocky.yml

J'ai ajouté une variable nommée "message" dans les deux fichiers de variables. Maintenant, si j'exécute mon playbook, les variables seront récupérées à partir de ces deux fichiers.

Host_vars - Définition des variables

De même, vous pouvez également créer des fichiers variables pour les groupes. Créez un répertoire "group_vars" et créez un fichier avec le nom du groupe selon le fichier d'inventaire.

[m1]
ubuntu ansible_host=ubuntu.anslab.com 

[m2]
rocky ansible_host=rocky.anslab.com

[servers:children]
m1
m2

J'ai créé un groupe enfant appelé "servers", je crée donc le nom de fichier sous la forme servers.yml.

mkdir group_vars
mkdir group_vars/servers.yml
echo "message: This variable is read from group_vars/servers.yml file" > group_vars/servers.yml

Maintenant, si j'exécute le playbook, il lira le servers.yml de group_vars.

Variables de groupe

Attention : Si vous avez à la fois host_vars et group_vars, ansible recherchera d'abord les définitions host_vars, et sinon trouvé, il ira à group_vars.

Variables magiques

Ansible fournit des variables internes dans lesquelles l'état de la variable est défini lorsque vous exécutez le playbook. Nous pouvons utiliser ces variables via le playbook. Pour obtenir la liste des variables spéciales disponibles, vous pouvez vous référer au lien suivant.

Variables spéciales Ansible

Par exemple, il existe une variable appelée inventory_dir qui stocke le chemin absolu du fichier d'inventaire utilisé par le playbook.

    - name: Magic Variables - Get inventory directory path
      debug:
        msg: "{{ inventory_dir }}"

Variables magiques

Une variable magique importante est hostvars. Cette variable va imprimer une collection de quelques variables magiques au format json.

      - name: Magic Variables - hostvars
        debug:
          msg: "{{ hostvars }}"

Sortie HostVars

La sortie contient des informations au format str, liste et dictionnaire. Disons que je veux vérifier dans quel groupe se trouve mon hôte Ubuntu, je peux l'obtenir de la manière suivante. J'utilise ici la notation syntaxique Python.

      - name: Magic Variables 
        debug:
          msg: "{{ hostvars['ubuntu']['group_names'] }}"

Noms de groupe

Toutes les variables magiques ne sont pas utiles dans les opérations quotidiennes. Jetez un œil à toutes les variables magiques et voyez laquelle correspond à votre cas d'utilisation.

Les faits en tant que variables

Lorsque vous exécutez le playbook, ansible utilisera le module de configuration, collectera les faits auprès des hôtes ciblés et conservera la sortie en mémoire afin qu'elle puisse être utilisée dans le playbook. Les faits sont également appelés variables du playbook.

Tout d’abord, familiarisez-vous avec les faits générés afin de pouvoir saisir des attributs particuliers. Exécutez la commande suivante qui collectera les faits et les stockera dans un fichier.

ansible all -m setup --tree /tmp/facts_result

Un fichier de sortie distinct sera créé pour chaque hôte. Si vous regardez la sortie, ce n'est rien d'autre qu'une sortie au format JSON.

Sortie des faits

Les attributs dans la sortie des faits seront au format Liste, Dictionnaire et AnsibleUnsafeText. Vous trouverez ci-dessous quelques exemples de différents types.

      - name: Facts output - AnsibleUnsafeText
        debug:
          msg: "{{ discovered_interpreter_python }}"

      - name: Facts output - List
        debug:
          msg: "{{ ansible_all_ipv4_addresses }}"

      - name: Facts output - Dictionary
        debug:
          msg: "{{ ansible_python }}"

Sortie des faits

Il existe des tonnes d'informations collectées par des faits, alors prenez votre temps pour parcourir les résultats et voir ce qui correspond à vos besoins.

Conclusion

Dans cet article, nous avons discuté de qu'est-ce qu'une variable ansible et comment déclarer des variables à différents endroits. La priorité des variables est très importante lors de la déclaration de variables et cela est abordé dans cet article. Nous avons également discuté des variables magiques et de leur cas d'utilisation. Enfin, nous avons expliqué ce que sont les faits et comment utiliser les résultats des faits comme variables.