Exemples et introduction des boucles Ansible

Dans un précédent article, nous avons parlé d’Ansible, un logiciel de provisionnement gratuit et open source écrit en Python très utile, que nous pouvons utiliser pour automatiser des tâches sur plusieurs machines. Nous avons vu comment l’installer sur certaines des distributions Linux les plus utilisées et les concepts de base derrière son utilisation. Dans cet article, nous nous concentrons sur la façon d’utiliser des boucles dans les playbooks Ansible afin d’effectuer une seule tâche plusieurs fois avec des données différentes.

Dans ce tutoriel, vous allez apprendre :

Comment utiliser les boucles dans les playbooks Ansible
Comment faire une boucle sur une liste d’éléments
Comment boucler une liste de hachages
Comment spécifier un intervalle de temps entre les itérations de boucle
Comment garder une trace de l’index de boucle

Configuration logicielle requise et conventions utilisées

Introduction des boucles

Commençons par une tâche simple et unique. Supposons que nous voulions nous assurer qu’un fichier dispose d’un ensemble spécifique d’autorisations. Pour traduire le concept en une tâche Ansible, nous utiliserions le module ansible.builtin.file et écririons :

- name: Apply permissions
  ansible.builtin.file:
    path: /foo.conf
    mode: '600'

Avec la définition de tâche ci-dessus, nous avons déclaré un état : le fichier /foo.conf doit avoir le mode de permission 600 appliqué (son propriétaire doit pouvoir le lire et y écrire ; aucun privilège ne doit être attribué à son groupe et au reste du monde). Supposons que nous voulions faire la même chose pour plusieurs fichiers ; Comment devrions-nous procéder ?

Bien sûr, écrire exactement la même tâche pour chaque fichier serait une très mauvaise idée, car nous nous répéterions. L’idéal serait d’utiliser la même tâche, mais avec des données différentes. C’est un cas typique où la bonne chose à faire est d’utiliser une boucle. Voici ce que nous pourrions écrire :

- name: Set permissions
  ansible.builtin.file:
    path: "{{ item }}"
    mode: '600'
  loop:
    - /foo.conf
    - /bar.conf
    - /baz.conf

Lorsque la tâche est exécutée, la sortie suivante est renvoyée dans la console :

TASK [Apply permissions] *******************************************************
changed: [localhost] => (item=/foo.conf)
changed: [localhost] => (item=/bar.conf)
changed: [localhost] => (item=/baz.conf)

Ce que nous avons fait ci-dessus est un exemple très simple de boucle dans un playbook Ansible. Comme vous pouvez le voir, nous avons utilisé le mot-clé loop au même niveau d’indentation que le nom de la tâche. Dans ce cas, nous avons fourni, en utilisant la syntaxe yaml, une liste de chemins d’accès ; Ensuite, dans la tâche elle-même, nous avons utilisé la variable item pour référencer chacun d’entre eux. À chaque itération, cette variable fera référence à un élément de la liste que nous avons spécifiée.

Assez facile ! Dans cet exemple trivial, nous avons attribué les mêmes autorisations à tous les fichiers de la liste ; Que se passe-t-il si nous voulons attribuer un mode d’autorisation différent à chacun d’entre eux ?

Spécification de plusieurs paramètres en itérant sur une liste de hachages

Comme nous l’avons dit, dans l’exemple précédent, nous avons simplement itéré sur une liste ; Cependant, il peut y avoir des cas où nous devons spécifier plusieurs paramètres à chaque itération. Dans ces cas, nous voulons définir et itérer sur une liste de hachages à la place.

Supposons que nous voulions définir les autorisations de plusieurs fichiers avec la même tâche, comme nous l’avons fait précédemment, mais que nous voulions attribuer à chaque fichier un mode d’autorisation différent. Comment pourrions-nous le faire ? Dans un tel cas, il ne suffirait pas d’itérer sur une simple liste. Ce que nous voulons faire, c’est itérer sur une liste de hachages. À l’intérieur de chaque hachage, nous spécifions les paramètres qui doivent être utilisés et leurs valeurs. En voici un exemple :

- name: Set permissions
  ansible.builtin.file:
    path: "{{ item.path }}"
    mode: "{{ item.mode }}"
  loop:
    - { path: '/foo.conf', mode: '600' }
    - { path: '/bar.conf', mode: '640' }
    - { path: '/baz.conf', mode: '640' }

Jetons un coup d’œil à ce que nous avons fait ci-dessus. Tout comme dans l’exemple précédent, nous avons utilisé l’instruction loop pour créer une boucle, mais cette fois, nous avons spécifié une liste de hachages. À l’intérieur de chaque hachage, nous avons utilisé les touches path et mode, et leur avons attribué les valeurs appropriées pour chaque fichier.

Notez que les noms de clés ici sont complètement arbitraires : ils ne doivent pas nécessairement correspondre aux paramètres utilisés dans la tâche. À l’intérieur de la tâche elle-même, comme auparavant, la valeur attribuée à chaque itération de la boucle est référencée via la variable item. Dans ce cas, chaque élément serait l’un des hachages que nous avons spécifiés ; pour accéder aux clés de chaque hachage, nous utilisons un ., tout comme nous le ferions pour accéder à une propriété d’un objet Python, donc à chaque fois, par exemple, item.path fera référence à la valeur attribuée à cette clé dans le hachage.

Contrôle du temps entre les itérations

Dans certains cas, nous pourrions vouloir définir la quantité de temps qui doit s’écouler entre les itérations d’une boucle. Comment pouvons-nous faire cela dans un playbook ? Tout ce que nous avons à faire est d’utiliser la directive pause à l’intérieur de la section loop_control. Voici un exemple trivial de boucle ansible dans lequel chaque itération s’exécute 5 secondes après la précédente :

- name: Print message
  ansible.builtin.debug:
    msg: "{{ item }}"
  loop:
    - Hello
    - World
  loop_control:
    pause: 5

Suivi de l’indice d’itération

Tout comme nous l’avons fait dans l’exemple précédent, nous pouvons utiliser la section loop_control pour suivre le nombre d’itérations de boucle. Tout ce que nous avons à faire est d’utiliser la directive index_var. La variable que nous spécifions comme valeur pour cette directive contiendra l’index de l’itération actuelle (base zéro). En voici un exemple :

- name: Print message
  ansible.builtin.debug:
    msg: "The item is {{ item }} and loop index is {{ i }}"
  loop:
    - hello
    - world
  loop_control:
    index_var: i

La tâche que nous avons définie dans l’exemple ci-dessus est très triviale et n’a pas d’utilité réelle ; Cependant, il peut être utile d’afficher comment l’indice d’itération est augmenté. Si nous l’exécutons, nous obtenons le résultat suivant :

TASK [Print message] ***********************************************************
ok: [localhost] => (item=Hello) => {
    "msg": "The item is Hello and loop index is 0"
}
ok: [localhost] => (item=World) => {
    "msg": "The item is World and loop index is 1"
}

Conclusions

Dans cet article, nous avons appris l’utilisation de base des boucles dans les playbooks Ansible et les lecteurs ont reçu quelques exemples d’introduction aux boucles Ansible. Nous avons vu comment itérer sur une simple liste d’éléments et sur une liste de hachages, chacun contenant un ensemble de paires clé-valeur.

Nous avons également vu comment spécifier combien de secondes doivent s’écouler entre chaque itération d’une boucle, et comment garder une trace de l’indice d’itération dans une variable à l’aide de la section loop_control et, respectivement, des directives pause et index_var. Ici, nous avons à peine effleuré la surface de ce qu’il est possible de réaliser avec des boucles. Pour des connaissances plus approfondies, veuillez consulter la documentation officielle d’Ansible !