Existe-t-il un moyen d'exécuter des boucles with_items en parallèle dans Ansible?

J'utilise Ansible 2.2, mais je peux mettre à niveau si cela aide.

J'ai vu cela et j'étais assez excité, mais cela ne semble pas être dans cette version (ou n'importe quelle autre) de la documentation Ansible.

Le problème que j'essaie de résoudre est que j'ai 1000 utilisateurs que je dois gérer sur une box Centos.

Il faut un certain temps pour exécuter cette tâche en série. Et encore plus ennuyeux, tout apparaît comme modifié car la commande "expires" sur le module utilisateur marque toujours la chose comme modifiée.

cela semblait également prometteur, mais cela prenait le même temps pour exécuter chaque commande dans la boucle with_items et n'allait pas plus vite (je n'ai jamais pris la peine d'attendre assez longtemps pour arriver à la fin).

Sauter des tâches est rapide maintenant (beaucoup plus rapide que dans Ansible 2.0), si je ne peux pas comprendre comment faire fonctionner cela en parallèle, je pense que je vais revenir en arrière et comprendre comment sauter des tâches inutiles et si tout sinon échoue, je vais écrire mon propre module. Mais il semble que je devrais pouvoir faire tout cela plus rapidement dans Ansible.

C'est ce que je veux exécuter en parallèle, host_authorizationsc'est une liste de noms d'utilisateurs et d'autres données.

  - name: Create/modify OS user accounts
    user: name={{ item.username }} group=sshusers shell=/bin/bash home="/home/selinux-modules/{{ item.username }}" state=present expires={{item.expiredate|default(omit)}}
    with_items: "{{ host_authorizations }}"
    tags: full_maintenance

Comme @webKnja l'a mentionné, cela est possible avec le asyncmode. Je l'ai moi-même découvert récemment et j'ai appris que vous pouvez l'utiliser de 3 manières différentes selon vos besoins.

1. Exécutez et interrogez les résultats, notez le poll:5, cela interrogera les résultats toutes les 5 secondes. Vous pouvez gagner du temps avec cette méthode.

   - name: My long runing task
     some_module_name:
       ip: "{{item.fabric}}"
       username: "{{user}}"
       password: "{{password}}"
       secret: "{{secret}}"
     loop: "{{zoning_list}}"
     register: _alias_vc_0
     async: 60
     poll: 5
   

2. Tirez et oubliez poll: 0 , c'est une option très rapide car Ansible ne fait que tirer sur ces tâches. L'inconvénient est que nous ne savons pas quel a été le résultat de la tâche, c'est-à-dire changed: True/False. Bien sûr, c'est un inconvénient si vous vous souciez des commentaires;).

   name: My long runing task
   some_module_name:
     ip: "{{item.fabric}}"
     username: "{{user}}"
     password: "{{password}}"
     secret: "{{secret}}"
   loop: "{{zoning_list}}"
   register: _alias_vc_0
   async: 60
   poll: 0
   

3. Déclenchez et oubliez avecasync_status , la syntaxe de la tâche est la même que dans l'exemple 2, chaque fois qu'elle nécessitera une tâche supplémentaire async_status. C'est mon préféré car il est relativement rapide (plus rapide que le bouclage normal ou le execute and poll) et vous permet de capturer les commentaires, mais il faudra en traiter de nouveaux registerpour votre async_task.

   retries: 20 - combien de tentatives avant d'échouer.

   delay: 2 - combien de secondes attendre entre les sondages.

   - name: My long runing task
     some_module_name:
       ip: "{{item.fabric}}"
       username: "{{user}}"
       password: "{{password}}"
       secret: "{{secret}}"
     loop: "{{zoning_list}}"
     register: _alias_vc_0
     async: 60
     poll: 0
   
   
   - name: Wait for My long running task to finish
     async_status:
       id: "{{ item.ansible_job_id }}"
     register: _jobs_alias_vc_0
     retries: 20
     delay: 2
     until: _jobs_alias_vc_0.finished
     loop: "{{_alias_vc_0.results}}"
   

Un mot d'avertissement , selon la tâche, vous ne pourrez peut-être pas utiliser l' asyncoption. J'ai eu des exemples où j'interagissais avec un système qui n'était pas en mesure de gérer plusieurs demandes pour la même ressource. J'ai trouvé que l' asyncoption fonctionnait mieux si je devais effectuer la même tâche sur plusieurs hôtes. C'est là que j'ai pu "économiser" le plus de temps.

Depuis que vous avez publié le lien vers la documentation Ansible dans la question, je ne vais pas le faire.

Pour répondre à votre question: Non, pour l'instant Ansible ne peut pas exécuter de boucles en parallèle.

J'utiliserais à la newusersplace, ce qui est fait pour la création d'utilisateurs en masse. Créez un fichier avec tous les utilisateurs, copiez-le sur l'hôte et exécutez newusers /path/to/user/listune commandtâche.

Il est possible d'y parvenir en utilisant le asyncmode. Veuillez trouver ci-dessous quelques références sur la façon de procéder.

Réfs:

• http://toroid.org/ansible-parallel-dispatch
• https://blog.crisp.se/2018/01/27/maxwenzin/how-to-run-ansible-tasks-in-parallel

---

- name: Run tasks in parallel
  hosts: localhost
  connection: local
  gather_facts: no
  tasks:
    - name: Pretend to create instances
      command: "sleep {{ item }}"  # Instead of calling a long running operation at a cloud provider, we just sleep.
      with_items:
        - 6
        - 8
        - 7
      register: _create_instances
      async: 600  # Maximum runtime in seconds. Adjust as needed.
      poll: 0  # Fire and continue (never poll)

    - name: Wait for creation to finish
      async_status:
        jid: "{{ item.ansible_job_id }}"
      register: _jobs
      until: _jobs.finished
      delay: 5  # Check every 5 seconds. Adjust as you like.
      retries: 10  # Retry up to 10 times. Adjust as needed.
      with_items: "{{ _create_instances.results }}"