Au cours de l'exécution de tâches dans Playbook Ansible , vous pourriez rencontrer certaines tâches qui sont de nature répétitive. Ce sont des tâches qui vous obligent à créer plusieurs jeux, ce qui peut être assez fastidieux. Comme pour tout langage de programmation, les boucles dans Ansible permettent d'exécuter plus facilement des tâches répétitives en utilisant moins de lignes de code dans un playbook.
Lors de la création de boucles, Ansible fournit ces deux directives :loop et avec_* mot-clé.
Le mot-clé loop a été récemment ajouté à Ansible 2.5 . Le mot-clé loop est généralement utilisé pour créer des boucles simples et standard qui itèrent sur plusieurs éléments.
Leavec_* Le mot-clé est utilisé avec un certain nombre de plug-ins de recherche lors de l'itération des valeurs. Les plug-ins de recherche permettent à Ansible d'accéder à des informations provenant de sources externes telles que des magasins de données externes, des systèmes de fichiers, etc. Le with_* la recherche est toujours très utilisée et n'a pas encore été obsolète.
Voyons maintenant comment implémenter des boucles dans Ansible.
Itération sur des boucles simples
Considérez un Playbook qui ajoute un nouvel utilisateur sur le système cible à l'aide du module utilisateur comme indiqué :
--- - hosts: ubuntu_webserver tasks: - name: Create new user john user: name: john state: present
Cela semble correct. Mais que se passe-t-il si nous avons plusieurs utilisateurs à ajouter au système cible ? Comment s'y prendrait-on? Une façon serait de dupliquer les tâches comme indiqué dans l'exemple ci-dessous où nous ajoutons 3 utilisateurs.
--- - hosts: ubuntu_webserver tasks: - name: Create new user john user: name: john state: present - name: Create new user mike user: name: mike state: present - name: Create new user andrew user: name: andrew state: present
Comme vous pouvez le voir, cela demande beaucoup de doublons et de répétitions.
Pour faciliter les choses, le même playbook peut être écrit en utilisant la directive loop. La directive loop exécute plusieurs fois la même tâche. Il stocke la valeur de chaque élément dans une variable appelée item .Ainsi, au lieu de spécifier les noms des utilisateurs à ajouter, spécifiez simplement une variable appelée item entourée de doubles accolades comme indiqué.
nom :'{{ élément }}'
Par conséquent, chacun des éléments de la boucle sera référencé par la variable.
Comme vous pouvez le voir, notre playbook est maintenant beaucoup plus organisé avec des duplications/répétions inutiles.
$ vi create_users.yaml
---
- hosts: ubuntu_webserver
tasks:
- name: Create new users
user:
name: '{{ item }}'
state: present
loop:
- john
- mike
- andrew
Vous pouvez également utiliser les with_items directive au lieu de la directive de boucle. Les deux donneront le même résultat.
---
- hosts: ubuntu_webserver
become: yes
tasks:
- name: Create new users
user:
name: '{{ item }}'
state: present
with_items:
- john
- mike
- andrew Vous pouvez maintenant exécuter le playbook pour créer les utilisateurs à l'aide du ansible-playbook commande comme indiqué ci-dessous :
$ ansible-playbook -i inventory.txt create_users.yaml
Itération sur une liste de dictionnaires
Dans le premier exemple, nous avons examiné une simple boucle standard où le tableau était une liste de valeurs de chaîne représentant les utilisateurs à ajouter à la cible distante.
Mais que se passe-t-il si nous devons ajouter le uid à la boucle de sorte que chaque élément a maintenant deux valeurs :le nom d'utilisateur et uid . Comment passeriez-vous 2 valeurs dans un tableau ?
Dans ce scénario, vous devrez transmettre un tableau de dictionnaires, chacun avec 2 paires clé-valeur, comme indiqué. Les clés seraient le nom et l'uid tandis que les valeurs seraient le nom d'utilisateur et l'ID de chaque utilisateur.
Sous les "tâches ', vous ne pouvez plus définir l'élément variable comme avant. Puisque nous avons 2 valeurs, cela se traduira par deux variables :item.name &item.uid .
Le playbook complet est présenté ci-dessous :
$ vi create_users.yaml
---
- hosts: ubuntu_webserver
become: yes
tasks:
- name: Create new users
user:
name: '{{ item.name }}'
uid: '{{ item.uid }}'
state: present
loop:
- name: john
uid: 1020
- name: mike
uid: 1030
- name: andrew
uid: 1040
Le tableau de dictionnaires peut également être représenté au format JSON.
loop:
- { name: john , uid: 1020 }
- { name: mike , uid: 1030 }
- { name: andrew , uid: 1040} Une fois exécuté, vous obtiendrez la sortie suivante :
$ ansible-playbook -i inventory.txt create_users.yaml
Boucles Ansible avec index
Occasionnellement, vous souhaiterez peut-être suivre les valeurs d'index dans votre tableau d'éléments. Pour cela, utilisez le 'with indexed_items ' chercher. La valeur de l'index commence à partir de 0 tandis que l'index de la boucle commence à partir de item.0 et la valeur de item.1
Considérez le playbook ci-dessous :
$ vi indexes.yaml
---
- hosts: ubuntu_webserver
tasks:
- name: Indexes with Ansible loop
debug:
msg: "The car at {{ item.0 }} is {{ item.1 }}"
with_indexed_items:
- "Nissan"
- "Mercedes"
- "Toyota"
- "Mazda"
- "BMW"
Lorsqu'il est exécuté, le playbook affiche la valeur d'index de chaque élément de la liste de tableaux.
$ ansible-playbook -i inventory.txt indexes.yaml
Conditions dans les boucles ansibles
Dans les boucles Ansible, vous pouvez utiliser l'instruction conditionnelle pour contrôler la boucle en fonction de la nature des variables ou des faits système. Considérez le playbook ci-dessous où nous avons une liste de packages qui doivent être installés.
Nous avons spécifié un tableau appelé "packages ' qui contient une liste de packages qui doivent être installés. Chacun des éléments du tableau contient le nom du package à installer et la propriété appelée "obligatoire ' qui est défini sur 'Vrai ' pour 2 packages et 'Faux ‘ pour un paquet.
$ vi install-packages.yaml
---
- name: Install software
become: yes
hosts: all
vars:
packages:
- name: neofetch
required: True
- name: cpu-checker
required: True
- name: screenfetch
required: False
tasks:
- name: Install "{{ item.name }}" on Ubuntu
apt:
name: "{{ item.name }}"
state: present
when:
- item.required == True
- ansible_facts['distribution'] =="Ubuntu"
loop: "{{ packages }}"
Le "quand ' instruction conditionnelle cherche à installer les packages logiciels avec la propriété 'required ' défini sur 'Vrai ' sur les systèmes cibles qui sont des distributions Ubuntu. Vous trouverez ci-dessous la sortie du playbook lorsqu'il est exécuté.
La sortie détaillée montre clairement les packages en cours d'installation et celui qui est ignoré en fonction de l'instruction conditionnelle.
Et cela nous amène à la fin de ce sujet. Nous espérons que vous avez une bonne compréhension des boucles dans les playbooks Ansible. N'hésitez pas à nous contacter pour toute clarification.
Lire aussi :Comment utiliser le modèle Jinja2 dans Ansible Playbook