Ansible utilise des variables pour gérer les différences entre les systèmes. Avec Ansible, vous pouvez exécuter des tâches et des playbooks sur plusieurs systèmes différents avec une seule commande. Pour représenter les variations entre ces différents systèmes, vous pouvez créer des variables avec la syntaxe YAML standard, notamment des listes et des dictionnaires. Vous pouvez définir ces variables dans vos playbooks, dans votre section inventaire, dans des fichiers réutilisables ou rôles ou à la ligne de commande. Vous pouvez également créer des variables pendant l'exécution d'un playbook en enregistrant la ou les valeurs de retour d'une tâche comme une nouvelle variable.

Après avoir créé des variables, soit en les définissant dans un fichier, soit en les passant à la ligne de commande, soit en enregistrant la valeur de retour ou les valeurs d'une tâche en tant que nouvelle variable, vous pouvez utiliser ces variables dans les arguments du module, dans... des instructions conditionnelles "when", dans modèles et dans les modèles boucles. Le site dépôt github ansible-examples contient de nombreux exemples d'utilisation de variables dans Ansible.

Une fois que vous avez compris les concepts et les exemples de cette page, lisez les articles suivants Faits sur Ansible, qui sont des variables que vous récupérez à partir de systèmes distants.

  • Création de noms de variables valides.
  • Variables simples

    • Définition de variables simples
    • Référencement des variables simples
  • Quand citer des variables (un gotcha YAML)
  • Lister les variables

    • Définir les variables comme des listes
    • Référencement des variables de liste
  • Variables de dictionnaire

    • Définition des variables comme dictionnaires clé:valeur
    • Référencement des variables de dictionnaire clé:valeur
  • Enregistrement des variables
  • Référencement de variables imbriquées
  • Transformation des variables avec les filtres Jinja2
  • Où définir les variables

    • Définition des variables dans l'inventaire
    • Définition des variables dans un playbook
    • Définition de variables dans les fichiers inclus et les rôles
    • Définition de variables au moment de l'exécution

      • format clé=valeur
      • Format de la chaîne JSON
      • vars à partir d'un fichier JSON ou YAML
  • Priorité des variables : Où dois-je mettre une variable ?

    • Comprendre la préséance des variables
    • Définition de la portée des variables
    • Conseils pour savoir où placer les variables
  • Utilisation de la syntaxe avancée des variables

Créer des noms de variables valides

Toutes les chaînes de caractères ne sont pas des noms de variables Ansible valides. Un nom de variable ne peut inclure que des lettres, des chiffres et des traits de soulignement. Mots clés Python ou mots-clés du playbook ne sont pas des noms de variables valides. Un nom de variable ne peut pas commencer par un chiffre.

Les noms de variables peuvent commencer par un trait de soulignement. Dans de nombreux langages de programmation, les variables qui commencent par un trait de soulignement sont privées. Ce n'est pas le cas dans Ansible. Les variables qui commencent par un trait de soulignement sont traitées exactement de la même manière que toute autre variable. Ne comptez pas sur cette convention pour la confidentialité ou la sécurité.

Ce tableau donne des exemples de noms de variables valides et invalides :

Noms de variables valides

Non valide

foo

*foo, Mots clés Python tels que async et lambda

foo_env

mots-clés du playbook tels que environment

foo_port

foo-port, foo port, foo.port

foo5, _foo

5foo, 12

Variables simples

Les variables simples combinent un nom de variable avec une seule valeur. Vous pouvez utiliser cette syntaxe (et la syntaxe des listes et des dictionnaires présentée ci-dessous) à divers endroits. Pour plus de détails sur la définition de variables dans l'inventaire, dans les playbooks, dans les fichiers réutilisables, dans les rôles ou à la ligne de commande, voir . Où définir les variables.

Définition de variables simples

Vous pouvez définir une variable simple en utilisant la syntaxe YAML standard. Par exemple :

remote_install_path: /opt/my_app_config

Référencement de variables simples

Après avoir défini une variable, utilisez la syntaxe Jinja2 pour la référencer. Les variables Jinja2 utilisent des accolades doubles. Par exemple, l'expression My amp goes to {{ max_amp_value }} démontre la forme la plus élémentaire de substitution de variable. Vous pouvez utiliser la syntaxe Jinja2 dans les playbooks. Par exemple :

ansible.builtin.template:src: foo.cfg.j2
  dest:'{{ remote_install_path }}/foo.cfg'

Dans cet exemple, la variable définit l'emplacement d'un fichier, qui peut varier d'un système à l'autre.

Note

Ansible autorise les boucles et les conditionnels de Jinja2 dans les éléments suivants. modèles mais pas dans les playbooks. Vous ne pouvez pas créer une boucle de tâches. Les playbooks Ansible sont de purs YAML analysables par la machine.

Quand citer les variables (un gotcha YAML).

Si vous commencez une valeur avec {{ foo }}, vous devez citer l'expression entière pour créer une syntaxe YAML valide. Si vous ne citez pas l'expression entière, l'analyseur YAML ne peut pas interpréter la syntaxe - il peut s'agir d'une variable ou du début d'un dictionnaire YAML. Pour obtenir des conseils sur l'écriture du langage YAML, consultez le document Syntaxe YAML documentation.

Si vous utilisez une variable sans guillemets comme ceci :

-hosts: app_servers
  vars:app_path:{{ base_path }}/22

Vous verrez : ERROR! Syntax Error while loading YAML. Si vous ajoutez des guillemets, Ansible fonctionne correctement :

-hosts: app_servers
  vars:app_path:"{{ base_path }}/22"

Liste des variables

Une variable de liste combine un nom de variable avec plusieurs valeurs. Les valeurs multiples peuvent être stockées sous forme de liste détaillée ou entre crochets. [], séparées par des virgules.

Définition des variables sous forme de listes

Vous pouvez définir des variables avec plusieurs valeurs en utilisant des listes YAML. Par exemple :

region:- northeast
  - southeast
  - midwest

Référencement des variables de liste

Lorsque vous utilisez des variables définies sous forme de liste (également appelée tableau), vous pouvez utiliser des champs individuels et spécifiques de cette liste. Le premier élément d'une liste est l'élément 0, le deuxième élément est l'élément 1. Par exemple :

region:"{{ region[0] }}"

La valeur de cette expression serait "nord-est".

Variables du dictionnaire

Un dictionnaire stocke les données dans des paires clé-valeur. Habituellement, les dictionnaires sont utilisés pour stocker des données connexes, telles que les informations contenues dans un identifiant ou un profil utilisateur.

Définition des variables en tant que dictionnaires clé-valeur

Vous pouvez définir des variables plus complexes en utilisant des dictionnaires YAML. Un dictionnaire YAML fait correspondre des clés à des valeurs. Par exemple :

foo:field1: one
  field2: two

Référencement des variables du dictionnaire clé:valeur

Lorsque vous utilisez des variables définies comme un dictionnaire clé:valeur (également appelé hachage), vous pouvez utiliser des champs individuels et spécifiques de ce dictionnaire en utilisant la notation par parenthèses ou par points :

foo['field1']
foo.field1

Ces deux exemples font référence à la même valeur ("un"). La notation par parenthèses fonctionne toujours. La notation par points peut poser des problèmes car certaines clés entrent en collision avec les attributs et les méthodes des dictionnaires python. Utilisez la notation par crochets si vous utilisez des clés qui commencent et se terminent par deux tirets bas (qui sont réservés à des significations spéciales en python) ou qui sont l'un des attributs publics connus :

add, append, as_integer_ratio, bit_length, capitalize, center, clear, conjugate, copy, count, decode, denominator, difference, difference_update, discard, encode, endswith, expandtabs, extend, find, format, fromhex, fromkeys, get, has_key, hex, imag, index, insert, intersection, intersection_update, isalnum, isalpha, isdecimal, isdigit, isdisjoint, is_integer, islower, isnumeric, isspace, issubset, issuperset, istitle, isupper, items, iteritems, iterkeys, itervalues, join, keys, ljust, lower, lstrip, numerator, partition, pop, popitem, real, remove, replace, reverse, rfind, rindex, rjust, rpartition, rsplit, rstrip, setdefault, sort, split, splitlines, startswith, strip, swapcase, symmetric_difference, symmetric_difference_update, title, translate, union, update, upper, values, viewitems, viewkeys, viewvalues, zfill.

Enregistrement des variables

Vous pouvez créer des variables à partir de la sortie d'une tâche Ansible avec le mot-clé task. register. Vous pouvez utiliser les variables enregistrées dans toutes les tâches ultérieures de votre jeu. Par exemple :

-hosts: web_servers

  tasks:-name: Run a shell command and register its output as a variable
       ansible.builtin.shell: /usr/bin/foo
       register: foo_result
       ignore_errors:true-name: Run a shell command using output of the previous task
       ansible.builtin.shell: /usr/bin/bar
       when: foo_result.rc == 5

Pour d'autres exemples d'utilisation de variables enregistrées dans des conditions sur des tâches ultérieures, voir . Conditionnels. Les variables enregistrées peuvent être des variables simples, des variables de liste, des variables de dictionnaire ou des structures de données imbriquées complexes. La documentation de chaque module comprend un RETURN section décrivant les valeurs de retour pour ce module. Pour voir les valeurs d'une tâche particulière, exécutez votre playbook avec la commande -v.

Les variables enregistrées sont stockées en mémoire. Vous ne pouvez pas mettre en cache les variables enregistrées pour les utiliser dans des playbooks ultérieurs. Les variables enregistrées ne sont valables sur l'hôte que pour le reste de l'exécution du playbook en cours.

Les variables enregistrées sont des variables de niveau hôte. Lorsque vous enregistrez une variable dans une tâche avec une boucle, la variable enregistrée contient une valeur pour chaque élément de la boucle. La structure de données placée dans la variable pendant la boucle contiendra une valeur de results qui est une liste de toutes les réponses du module. Pour un exemple plus approfondi de ce fonctionnement, voir l'attribut Boucles section sur l'utilisation du registre avec une boucle.

Note

Si une tâche échoue ou est sautée, Ansible enregistre toujours une variable avec un état d'échec ou de saut, à moins que la tâche ne soit sautée sur la base de balises. Voir Balises pour des informations sur l'ajout et l'utilisation des balises.

Référencement de variables imbriquées

De nombreuses variables enregistrées (et faits) sont des structures de données imbriquées YAML ou JSON. Vous ne pouvez pas accéder aux valeurs de ces structures de données imbriquées avec la simple fonction {{ foo }} simple. Vous devez utiliser la notation entre crochets ou la notation par points. Par exemple, pour référencer une adresse IP à partir de vos faits en utilisant la notation par parenthèses :

{{ ansible_facts["eth0"]["ipv4"]["address"]}}

Pour référencer une adresse IP à partir de vos faits en utilisant la notation par points :

{{ ansible_facts.eth0.ipv4.address }}

Transformer les variables avec les filtres Jinja2

Les filtres Jinja2 vous permettent de transformer la valeur d'une variable dans une expression de modèle. Par exemple, l'expression capitalize met en majuscule toute valeur qui lui est passée ; le filtre to_yaml et to_json modifient le format des valeurs de vos variables. Jinja2 comprend de nombreux filtres filtres intégrés et Ansible fournit de nombreux autres filtres. Pour trouver plus d'exemples de filtres, voir Utilisation de filtres pour manipuler les données.

Où définir les variables

Vous pouvez définir des variables à divers endroits, notamment dans l'inventaire, dans les playbooks, dans les fichiers réutilisables, dans les rôles et à la ligne de commande. Ansible charge toutes les variables possibles qu'il trouve, puis choisit la variable à appliquer en fonction des critères suivants . les règles de précédence des variables.

La définition des variables dans l'inventaire

Vous pouvez définir des variables différentes pour chaque hôte individuel, ou définir des variables partagées pour un groupe d'hôtes dans votre inventaire. Par exemple, si toutes les machines du groupe [Boston] utilisent 'boston.ntp.example.com' comme serveur NTP, vous pouvez définir une variable de groupe. Le site Comment construire votre inventaire contient des détails sur la définition de la variable de groupe variables de l'hôte et variables de groupe dans l'inventaire.

Définition des variables dans un playbook.

Vous pouvez définir des variables directement dans un playbook :

-hosts: webservers
  vars:http_port:80

Lorsque vous définissez des variables dans un playbook, elles sont visibles par toute personne qui exécute ce playbook. Ceci est particulièrement utile si vous partagez largement les playbooks.

Définition de variables dans les fichiers inclus et les rôles

Vous pouvez définir des variables dans des fichiers de variables réutilisables et/ou dans des rôles réutilisables. Lorsque vous définissez des variables dans des fichiers de variables réutilisables, les variables sensibles sont séparées des playbooks. Cette séparation vous permet de stocker vos playbooks dans un logiciel de contrôle de source et même de partager les playbooks, sans risque d'exposer les mots de passe ou d'autres données sensibles et personnelles. Pour plus d'informations sur la création de fichiers et de rôles réutilisables, voir . Réutilisation des artefacts Ansible.

Cet exemple montre comment vous pouvez inclure des variables définies dans un fichier externe :

----hosts: all
  remote_user: root
  vars:favcolor: blue
  vars_files:- /vars/external_vars.yml

  tasks:-name: This is just a placeholder
    ansible.builtin.command: /bin/echo foo

Le contenu de chaque fichier de variables est un simple dictionnaire YAML. Par exemple :

---# in the above example, this would be vars/external_vars.ymlsomevar: somevalue
password: magic

Note

Vous pouvez conserver les variables par hôte et par groupe dans des fichiers similaires. Pour savoir comment organiser vos variables, consultez Organisation des variables d'hôte et de groupe.

Définition des variables au moment de l'exécution

Vous pouvez définir des variables lors de l'exécution de votre playbook en passant des variables à la ligne de commande à l'aide de la commande --extra-vars (ou -e). Vous pouvez également demander une entrée utilisateur avec un argument vars_prompt (voir Saisie interactive : invites). Lorsque vous passez des variables à la ligne de commande, utilisez une chaîne entre guillemets simples, qui contient une ou plusieurs variables, dans l'un des formats ci-dessous.

format clé=valeur

Les valeurs transmises à l'aide du format key=value sont interprétées comme des chaînes de caractères. Utilisez le format JSON si vous devez passer des valeurs autres que des chaînes de caractères, comme des booléens, des entiers, des flottants, des listes, etc.

ansible-playbook release.yml --extra-vars "version=1.23.45 other_variable=foo"

Format de chaîne JSON

ansible-playbook release.yml --extra-vars '{"version":"1.23.45","other_variable":"foo"}'
ansible-playbook arcade.yml --extra-vars '{"pacman":"mrs","ghosts":["inky","pinky","clyde","sue"]}'

Lorsque vous passez des variables avec --extra-vars, vous devez échapper les guillemets et autres caractères spéciaux de manière appropriée à la fois pour votre balisage (par exemple, JSON), et pour votre shell :

ansible-playbook arcade.yml --extra-vars "{"name":"Conan O'Brien"}"
ansible-playbook arcade.yml --extra-vars '{"name":"Conan O'\''Brien"}'
ansible-playbook script.yml --extra-vars "{"dialog":"He said \"I just can't get enough of those single and double-quotes"!"\""}"

Si vous avez beaucoup de caractères spéciaux, utilisez un fichier JSON ou YAML contenant les définitions des variables.

vars à partir d'un fichier JSON ou YAML

ansible-playbook release.yml --extra-vars "@some_file.json"

La préséance des variables : Où dois-je mettre une variable ?

Vous pouvez définir plusieurs variables portant le même nom à de nombreux endroits différents. Lorsque vous faites cela, Ansible charge toutes les variables possibles qu'il trouve, puis choisit la variable à appliquer en fonction de la précédence des variables. En d'autres termes, les différentes variables prévaudront les unes sur les autres dans un certain ordre.

Les équipes et les projets qui se mettent d'accord sur des directives pour définir les variables (où définir certains types de variables) évitent généralement les problèmes de préséance des variables. Nous vous suggérons de définir chaque variable à un seul endroit : déterminez où définir une variable, et restez simple. Pour des exemples, voir Conseils sur l'endroit où définir les variables.

Certains paramètres comportementaux que vous pouvez définir dans les variables, vous pouvez également les définir dans la configuration Ansible, en tant qu'options de ligne de commande, et en utilisant des mots-clés de playbook. Par exemple, vous pouvez définir l'utilisateur qu'Ansible utilise pour se connecter aux périphériques distants en tant que variable avec l'option ansible_user, dans un fichier de configuration avec DEFAULT_REMOTE_USER, comme une option de ligne de commande avec -uet avec le mot-clé playbook remote_user. Si vous définissez le même paramètre dans une variable et par une autre méthode, la variable prévaut sur l'autre paramètre. Cette approche permet aux paramètres spécifiques à l'hôte de prévaloir sur des paramètres plus généraux. Pour des exemples et plus de détails sur la préséance de ces différents paramètres, consultez la section Contrôler le comportement d'Ansible : les règles de précédence..

Comprendre la préséance des variables

Ansible applique la préséance des variables, et vous pourriez en avoir l'utilité. Voici l'ordre de préséance du plus petit au plus grand (les dernières variables listées remplacent toutes les autres variables) :

  1. les valeurs de la ligne de commande (par exemple, -u my_userce ne sont pas des variables)
  2. Valeurs par défaut du rôle (définies dans role/defaults/main.yml) 1
  3. vars de groupe de fichiers ou de scripts d'inventaire 2
  4. inventaire groupe_vars/all 3
  5. playbook groupe_vars/all 3
  6. inventaire groupe_vars/* 3
  7. playbook groupe_vars/* 3
  8. fichier d'inventaire ou script host vars 2
  9. inventaire host_vars/* 3
  10. playbook hôte_vars/* 3
  11. host facts / cached set_facts 4
  12. play vars
  13. play vars_prompt
  14. jouer vars_files
  15. role vars (défini dans role/vars/main.yml)
  16. vars de bloc (uniquement pour les tâches dans le bloc)
  17. vars de tâche (uniquement pour la tâche)
  18. include_vars
  19. set_facts / vars enregistrés
  20. paramètres de rôle (et include_role)
  21. paramètres d'inclusion
  22. vars supplémentaires (par exemple, -e "user=my_user")(gagne toujours la priorité)

En général, Ansible donne la priorité aux variables qui ont été définies plus récemment, plus activement et avec une portée plus explicite. Les variables dans le dossier defaults à l'intérieur d'un rôle sont facilement remplacées. Tout ce qui se trouve dans le répertoire vars du rôle remplace les versions précédentes de cette variable dans l'espace de noms. Les variables de l'hôte et/ou de l'inventaire remplacent les valeurs par défaut du rôle, mais les inclusions explicites telles que le répertoire vars ou une variable include_vars tâche remplacent les variables d'inventaire.

Ansible fusionne différentes variables définies dans l'inventaire afin que les paramètres plus spécifiques remplacent les paramètres plus génériques. Par exemple , ansible_ssh_user spécifié en tant que group_var est supplanté par ansible_user spécifié comme une host_var. Pour plus de détails sur la préséance des variables définies dans l'inventaire, voir la section Comment les variables sont fusionnées.

Notes de bas de page

1

Les tâches de chaque rôle voient les valeurs par défaut de leur propre rôle. Les tâches définies en dehors d'un rôle voient les valeurs par défaut du dernier rôle.

2(1,2)

Variables définies dans le fichier d'inventaire ou fournies par l'inventaire dynamique.

3(1,2,3,4,5,6)

Comprend les vars ajoutées par les 'plugins vars' ainsi que les host_vars et group_vars qui sont ajoutées par le plugin vars par défaut livré avec Ansible.

4

Lorsqu'elles sont créées avec l'option cacheable de set_facts, les variables ont la préséance élevée dans le jeu, mais sont identiques à la préséance des faits d'un hôte lorsqu'elles proviennent du cache.

Note

Dans n'importe quelle section, la redéfinition d'une var remplace l'instance précédente. Si plusieurs groupes ont la même variable, le dernier chargé l'emporte. Si vous définissez une variable deux fois dans une pièce. vars: section, c'est la deuxième qui l'emporte.

Note

Le précédent décrit la configuration par défaut. hash_behaviour=replace, passez à merge pour n'écraser que partiellement.

Portée des variables

Vous pouvez décider où définir une variable en fonction de la portée que vous souhaitez donner à cette valeur. Ansible a trois portées principales :

  • Global : il est défini par la configuration, les variables d'environnement et la ligne de commande.
  • Play : chaque play et les structures contenues, les entrées vars (vars ; vars_files ; vars_prompt), les défauts de rôle et les vars.
  • Host : variables directement associées à un hôte, comme l'inventaire, include_vars, faits ou sorties de tâches enregistrées.

À l'intérieur d'un modèle, vous avez automatiquement accès à toutes les variables qui sont dans la portée d'un hôte, plus toutes les variables enregistrées, les faits et les variables magiques.

Conseils sur l'emplacement des variables

Vous devriez choisir où définir une variable en fonction du type de contrôle que vous pourriez vouloir sur les valeurs.

Définissez les variables dans l'inventaire qui traitent de la géographie ou du comportement. Comme les groupes sont fréquemment l'entité qui mappe les rôles sur les hôtes, vous pouvez souvent définir des variables sur le groupe au lieu de les définir sur un rôle. Rappelez-vous : les groupes enfants remplacent les groupes parents, et les variables d'hôte remplacent les variables de groupe. Voir Définition des variables dans l'inventaire pour plus de détails sur la définition des variables d'hôte et de groupe.

Définir les valeurs par défaut communes dans un group_vars/all fichier. Voir Organisation des variables d'hôte et de groupe pour plus de détails sur la façon d'organiser les variables d'hôte et de groupe dans votre inventaire. Les variables de groupe sont généralement placées à côté de votre fichier d'inventaire, mais elles peuvent également être renvoyées par l'inventaire dynamique (cf. Travailler avec l'inventaire dynamique) ou définies dans Tour Red Hat Ansible à partir de l'interface utilisateur ou de l'API :

---# file: /etc/ansible/group_vars/all# this is the site wide defaultntp_server: default-time.example.com

Définissez les variables spécifiques à l'emplacement dans group_vars/my_location fichiers. Tous les groupes sont des enfants du groupe all les variables définies ici remplacent donc celles définies dans le groupe group_vars/all:

---# file: /etc/ansible/group_vars/bostonntp_server: boston-time.example.com

Si un hôte utilisait un serveur NTP différent, vous pourriez le définir dans un fichier host_vars, ce qui remplacerait la variable group :

---# file: /etc/ansible/host_vars/xyz.boston.example.comntp_server: override.example.com

Définissez des valeurs par défaut dans les rôles pour éviter les erreurs de variables non définies. Si vous partagez vos rôles, les autres utilisateurs peuvent se fier aux valeurs par défaut raisonnables que vous avez ajoutées dans le fichier roles/x/defaults/main.yml ou ils peuvent facilement remplacer ces valeurs dans l'inventaire ou à la ligne de commande. Voir Rôles pour plus d'informations. Par exemple :

---# file: roles/x/defaults/main.yml# if no other value is supplied in inventory or as a parameter, this value will be usedhttp_port:80

Définissez des variables dans les rôles pour vous assurer qu'une valeur est utilisée dans ce rôle, et n'est pas remplacée par des variables d'inventaire. Si vous ne partagez pas votre rôle avec d'autres personnes, vous pouvez définir des comportements spécifiques à l'application, comme les ports, de cette façon, dans le champ roles/x/vars/main.yml. Si vous partagez des rôles avec d'autres personnes, le fait de mettre des variables ici les rend plus difficiles à contourner, bien qu'ils puissent toujours le faire en passant un paramètre au rôle ou en définissant une variable avec. -e:

---# file: roles/x/vars/main.yml# this will absolutely be used in this rolehttp_port:80

Passez les variables comme paramètres lorsque vous appelez les rôles pour un maximum de clarté, de flexibilité et de visibilité. Cette approche remplace toutes les valeurs par défaut qui existent pour un rôle. Par exemple :

roles:-role: apache
     vars:http_port:8080

Lorsque vous lisez ce playbook, il est clair que vous avez choisi de définir une variable ou de remplacer une valeur par défaut. Vous pouvez également passer plusieurs valeurs, ce qui vous permet d'exécuter le même rôle plusieurs fois. Voir Exécution d'un rôle plusieurs fois dans un playbook. pour plus de détails. Par exemple :

roles:-role: app_user
     vars:myname: Ian
   -role: app_user
     vars:myname: Terry
   -role: app_user
     vars:myname: Graham
   -role: app_user
     vars:myname: John

Les variables définies dans un rôle sont disponibles pour les rôles ultérieurs. Vous pouvez définir des variables dans un roles/common_settings/vars/main.yml et les utiliser dans d'autres rôles et ailleurs dans votre playbook :

roles:-role: common_settings
   -role: something
     vars:foo:12-role: something_else

Note

Il y a quelques protections en place pour éviter le besoin d'espace de nom des variables. Dans cet exemple, les variables définies dans 'common_settings' sont disponibles pour les tâches 'something' et 'something_else', mais les tâches dans 'something' ont foo défini à 12, même si 'common_settings' définit foo à 20.

Au lieu de s'inquiéter de la préséance des variables, nous vous encourageons à penser à la facilité ou à la fréquence avec laquelle vous voulez remplacer une variable lorsque vous décidez où la définir. Si vous n'êtes pas sûr des autres variables définies, et que vous avez besoin d'une valeur particulière, utilisez. --extra-vars (-e) pour remplacer toutes les autres variables.

Utilisation de la syntaxe avancée des variables

Pour plus d'informations sur la syntaxe YAML avancée utilisée pour déclarer des variables et avoir plus de contrôle sur les données placées dans les fichiers YAML utilisés par Ansible, voir . Syntaxe avancée.

Voir aussi

Intro aux playbooks

Une introduction aux playbooks

Conditionnels

Les déclarations conditionnelles dans les playbooks

Utilisation de filtres pour manipuler les données

Les filtres Jinja2 et leurs utilisations

Boucles

Boucles dans les playbooks

Rôles

Organisation des playbooks par rôles

Conseils et astuces

Conseils et astuces pour les playbooks

Variables spéciales

Liste des variables spéciales

Liste de diffusion des utilisateurs

Vous avez une question ? Passez par le groupe google !

irc.freenode.net

Canal de discussion IRC #ansible