Comment utiliser des boucles dans ANSIBLE

Lorsque vous travaillez avec le code, vous devrez peut-être exécuter un bloc de code plusieurs fois. Écrire le même bloc de code encore et encore est redondant et considéré comme une mauvaise conception. C'est là que les boucles entrent.

Les boucles sont des ensembles de commandes ou d'instructions qui sont définies pour répéter un certain nombre de fois conformément aux exigences de l'utilisateur. Les boucles permettent un meilleur flux de contrôle dans vos scripts et en supprimez la redondance globale.

Anible est également livré avec plusieurs méthodes de boucle de blocs de code. Ce guide est destiné à vous aider à en savoir plus sur les boucles dans ANIBLE. Nous couvrirons les bases de la boucle dans ANSIBLE, ainsi que la syntaxe et les exemples appropriés.

Cela étant dit, jetons un coup d'œil aux boucles dans ANIBLE.

Mots-clés pour les boucles dans ANSIBLE

ANIBLE utilise les mots clés suivants pour ses structures de boucle:

• "boucle"
• "avec_"
• "jusqu'à"

Comme son nom l'indique, «Loop» est la commande incontournable pour implémenter des boucles en blocs de code.

Semblable à "Loop", vous avez "avec_". Cette commande vous oblige à lui fournir un plugin de recherche. Il est recommandé d'utiliser avec_ * plutôt que de boucle lorsque les plugins de recherche sont impliqués.

«Jusqu'à» vous permet de continuer à exécuter une tâche jusqu'à ce que la condition requise soit remplie. C'est la plus proche de la condition «while» dans le flux de contrôle.

Maintenant que vous avez une idée des mots clés pour les boucles, vous pouvez procéder à savoir comment les implémenter dans le code.

Boucles standard dans ANIBLE

Nous allons commencer par discuter de la façon de mettre en œuvre des boucles standard dans ANIBLE. Pour les boucles standard, nous utiliserons le mot-clé «avec_».

Cet exemple montre comment nous pouvons utiliser des boucles pour ajouter des utilisateurs.

- Nom: Ajouter plusieurs utilisateurs
utilisateur:
Nom: "item"
État: présent
Groupes: "roue"
avec_items:
- VM1
- VM2

Maintenant, la prochaine étape serait d'exécuter le livre de jeu. Vous pouvez le faire avec l'aide de la commande suivante dans le terminal Linux:

ANSIBLE-PLAYBOOK TESTBOOK.YML

Ici, «article» est le terme de recherche. "With_item" a respectivement deux hôtes, VM1 et VM2. La boucle fait de même que le code ci-dessous:

- Nom: Ajouter un utilisateur VM1
utilisateur:
Nom: "VM1"
État: présent
Groupes: "roue"
- Nom: Ajouter un utilisateur VM2
utilisateur:
Nom: "VM2"
État: présent
Groupes: "roue"

Comme vous pouvez le voir, en utilisant «avec_item», nous pouvons supprimer la redondance de notre code. En ajoutant plus d'utilisateurs sous «avec_items», nous pouvons ajouter plusieurs utilisateurs selon les besoins.

L'exemple suivant couvrira comment exécuter des boucles imbriquées dans ANIBLE.

Boucles imbriquées dans ANSIBLE

Anible vous permet d'implémenter des boucles imbriquées dans ses scripts. Un exemple d'une telle boucle est donné ci-dessous.

- Nom: Fournit aux utilisateurs un accès aux bases de données
mysql_user:
Nom: "item [0]"
priv: "item [1].*:TOUS"
APPEND_PRIVS: Oui
Mot de passe: "FOO"
avec_nexe:
- ['Linuxuser1', 'Linuxuser2']
- [«client», «employé», «fournisseur»]

Alternativement, vous pouvez écrire le même code avec «Loop» que suivant:

- Nom: Fournit aux utilisateurs un accès aux bases de données
communauté.mysql.mysql_user:
Nom: "item [0]"
priv: "item [1].*:TOUS"
APPEND_PRIVS: Oui
Mot de passe: "FOO"
LOOP: "['Linuxuser1', 'Linuxuser2'] | Product (['Client', 'Employee', 'Provider']) | List"

Les utilisateurs seront accordés à toutes les bases de données une par une. Comme indiqué précédemment, il est plus facile de comprendre que le «avec_» est meilleur avec les plugins de recherche plutôt que la «boucle» comme syntaxe.

Jetons un coup d'œil à d'autres exemples mettant en évidence la capacité d'Anible.

Utiliser ANSIBLE pour itérer sur les hachages

ANIBLE vous permet de faire un peu de boucle sur une liste de hachages. Cela peut être vu à partir de l'exemple ci-dessous.

Supposons que vous avez déclaré une liste d'utilisateurs comme suit.

utilisateurs:
VM1:
Nom: Machine virtuelle 1
Série: 00000001
VM2:
Nom: Machine virtuelle 2
série: 00000002

Pour imprimer tous les noms et séries, exécutez le script ci-dessous.

Tâches:
- Nom: Imprimer les informations utilisateur
déboguer:
msg: "utilisateur item.clé est item.valeur.nom (item.valeur.série) "
avec_dict: "utilisateurs"

Cela imprimera respectivement les noms d'utilisateurs et les séries. En ajoutant plus d'utilisateurs dans le panneau «Utilisateurs:», vous pouvez imprimer plus d'utilisateurs sans avoir à rédiger le code.

Utilisation de boucles pour des ensembles de données parallèles

Vous pouvez également utiliser des boucles pour des ensembles de données parallèles. Ceci est démontré dans l'exemple ci-dessous:

Supposons que vous avez les données suivantes:

Alphabets: ['A', 'B', 'C', 'D']

NUM: [2, 4, 6, 8]

Vous pouvez boucler ces commandes comme suit:

Tâches:
- déboguer:
msg: "item.0 et item.1 "
avec_Together:
- "alphabets"
- "num"

Le code ci-dessus bouclera les deux ensembles de données ensemble en tant que (a, 2), (b, 4), etc.

Boucles de choix aléatoires

L'une des fonctionnalités fournies avec les boucles «avec_» est «random_choice».

Comme son nom l'indique, la fonctionnalité de choix aléatoire est utilisée pour sélectionner les éléments au hasard à partir d'un ensemble d'instructions donné.

Cet exemple illustre comment faire des boucles pour sélectionner une action à partir d'une liste donnée de chaînes.

- déboguer:
msg: "item"
avec_random_choice:
- "Exécuter l'action 1"
- "Exécuter l'action 2"
- "Exécuter l'action 3"
- "Exécuter l'action 4"

Ici, la chaîne «Executer Action» est arbitraire et peut être remplacée par n'importe quoi. La commande with_random_choice sélectionnerait dans la liste des actions donnée au hasard.

Exemples de boucle «Jusqu'à»

Cette section du guide concernera la syntaxe de boucle «jusqu'à».

Comme indiqué précédemment, la commande «jusqu'à» répétera un certain ensemble d'instructions jusqu'à ce qu'elle respecte une certaine condition.

Voici un exemple de la boucle «jusqu'à» en action.

shell: / usr / bin / foo

Registre: résultat

Jusqu'à: résultat.stdout.trouver ("tous les systèmes prêts") != -1

Retries: 10

retard: 7

Ceci est un exemple de boucle récursive. Le bloc de code ci-dessus continuera à fonctionner jusqu'à ce que le shell reçoive «tous les systèmes prêts» comme sortie de texte. Si ce n'est pas le cas, cela s'arrêtera après avoir exécuté 10 fois car les tentatives spécifiées sont «10».

Le retard correspond au retard en secondes. Par défaut, il est défini à 5.

Conclusion

C'était un guide sur la façon dont vous pouvez utiliser des boucles dans ANIBLE. Nous avons couvert les bases des boucles et leur syntaxe dans Ansible, et démontré leur utilisation via différents exemples. Avec cela, nous espérons que vous êtes à un pas de plus de l'automatisation de vos processus en utilisant Anible.