Comment faire une boucle sur ce dictionnaire en Ansible?

Dire que j'ai ce dictionnaire

war_files:
  server1:
  - file1.war
  - file2.war
  server2:
  - file1.war
  - file2.war
  - file3.war

et pour l'instant je veux juste faire une boucle sur chaque élément (clé), puis sur chaque élément de la clé (de la valeur). J'ai fait ce

- name: Loop over the dictionary
  debug: msg="Key={{ item.key }} value={{ item.value }}"
  with_dict: "{{ war_files }}"

Et je reçois ce. Bien entendu, il est correct, mais n'est PAS ce que je veux.

ok: [localhost] => (item={'value': [u'file1.war', u'file2.war'], 'key': u'server1'}) => {
    "item": {
        "key": "server1", 
        "value": [
            "file1.war", 
            "file2.war"
        ]
    }, 
    "msg": "Server=server1, WAR=[u'file1.war', u'file2.war']"
}
ok: [localhost] => (item={'value': [u'file1.war', u'file2.war', u'file3.war'], 'key': u'server2'}) => {
    "item": {
        "key": "server2", 
        "value": [
            "file1.war", 
            "file2.war", 
            "file3.war"
        ]
    }, 
    "msg": "Server=server2, WAR=[u'file1.war', u'file2.war', u'file3.war']"
}

Je veux obtenir un résultat qui dit

"msg": "Server=server1, WAR=file1.war"
"msg": "Server=server1, WAR=file2.war"
"msg": "Server=server2, WAR=file1.war"
"msg": "Server=server2, WAR=file2.war"
"msg": "Server=server2, WAR=file3.war"

OIE, comment puis-je écrire une tâche à itère sur le dictionnaire de sorte qu'il passe par chaque touche, puis les éléments à l'intérieur de chaque clé? En essence, j'ai un tableau imbriqué et souhaitez effectuer une itération sur elle?

OriginalL'auteur Chris F | 2017-02-10

ansible ansible-2.x

Bien, je ne pouvais pas trouver un moyen très facile de le faire, cependant, avec un peu de jinja2, nous pouvons réaliser quelque chose de ce genre:

/tmp ❯❯❯ cat example.yml
---
- hosts: 127.0.0.1
  vars:
    war_files:
      server1:
      - file1.war
      - file2.war
      server2:
      - file1.war
      - file2.war
      - file3.war
  tasks:
  - set_fact:
      war_files_list_of_dicts: |
          {% set res = [] -%}
          {% for key in war_files.keys() -%}
             {% for value in war_files[key] -%}
              {% set ignored = res.extend([{'Server': key, 'WAR':value}]) -%}
             {%- endfor %}
          {%- endfor %}
          {{ res }}

  - name: let's debug the crap out of this
    debug: var=war_files_list_of_dicts

  - name: Servers and their WARs!!!
    debug:
       msg: "Server={{ item.Server }}, WAR={{ item.WAR }}"
    with_items: "{{ war_files_list_of_dicts }}"

Et, lorsque le playbook est exécuté:

/tmp ❯❯❯ ansible-playbook example.yml
 [WARNING]: provided hosts list is empty, only localhost is available


PLAY [127.0.0.1] ***************************************************************

TASK [setup] *******************************************************************
ok: [127.0.0.1]

TASK [set_fact] ****************************************************************
ok: [127.0.0.1]

TASK [let's debug the crap out of this] ****************************************
ok: [127.0.0.1] => {
    "war_files_list_of_dicts": [
        {
            "Server": "server1", 
            "WAR": "file1.war"
        }, 
        {
            "Server": "server1", 
            "WAR": "file2.war"
        }, 
        {
            "Server": "server2", 
            "WAR": "file1.war"
        }, 
        {
            "Server": "server2", 
            "WAR": "file2.war"
        }, 
        {
            "Server": "server2", 
            "WAR": "file3.war"
        }
    ]
}

TASK [Servers and their WARs!!!] ***********************************************
ok: [127.0.0.1] => (item={'WAR': u'file1.war', 'Server': u'server1'}) => {
    "item": {
        "Server": "server1", 
        "WAR": "file1.war"
    }, 
    "msg": "Server=server1, WAR=file1.war"
}
ok: [127.0.0.1] => (item={'WAR': u'file2.war', 'Server': u'server1'}) => {
    "item": {
        "Server": "server1", 
        "WAR": "file2.war"
    }, 
    "msg": "Server=server1, WAR=file2.war"
}
ok: [127.0.0.1] => (item={'WAR': u'file1.war', 'Server': u'server2'}) => {
    "item": {
        "Server": "server2", 
        "WAR": "file1.war"
    }, 
    "msg": "Server=server2, WAR=file1.war"
}
ok: [127.0.0.1] => (item={'WAR': u'file2.war', 'Server': u'server2'}) => {
    "item": {
        "Server": "server2", 
        "WAR": "file2.war"
    }, 
    "msg": "Server=server2, WAR=file2.war"
}
ok: [127.0.0.1] => (item={'WAR': u'file3.war', 'Server': u'server2'}) => {
    "item": {
        "Server": "server2", 
        "WAR": "file3.war"
    }, 
    "msg": "Server=server2, WAR=file3.war"
}

PLAY RECAP *********************************************************************
127.0.0.1                  : ok=4    changed=0    unreachable=0    failed=0

Merci!!!! C'est là que j'ai comme Chef sur Ansible, où je peux juste écrire Ruby pour effectuer une itération sur une structure de données. En substance, c'est ce que vous avez fait ici avec Python, mais que la syntaxe est juste laid.
J'ai écrit jinja2, pas python.
Mais oui, je suis d'accord avec vous. La marionnette et le Chef ont un avantage sur Ansible à cause de cela.
Désolé, jinja2, pas Python. Merci encore!
Mieux utiliser dict2items et subelements mentionné par tmoschou. Cette solution fonctionne aussi mais augmente la complexité beaucoup.

OriginalL'auteur Nehal J Wani

8

Faire ce
```
- hosts: localhost
  vars:
    war_files:
      server1:
      - file1.war
      - file2.war
      server2:
      - file1.war
      - file2.war
      - file3.war
  tasks:
    - name: Loop over subelements of the dictionary
      debug:
        msg: "Key={{ item.0.key }} value={{ item.1 }}"
      loop: "{{ war_files | dict2items | subelements('value') }}"
```
dict2items, subelements filtres sont à venir dans Ansible 2.6.

Pour info, si un filtre pour votre objectif n'existe pas, vous pouvez écrire votre propre en python sans avoir à recourir à jinja2 hacks. Ansible est facilement extensible; filtres à filter_plugins/*.py sont recherchées par défaut à côté de votre joue/les rôles et sont automatiquement inclus - voir Développement De Plugins pour plus de détails.

Beaucoup mieux. Vous n'avez pas à utiliser subelements dans tous les cas. Essayez loop: "{{ users | dict2items }}" et puis msg: "Key={{ item.key }} value={{ item.value }} pour avoir une idée de ce que sont les possibilités. Voir docs.ansible.com/ansible/devel/user_guide/playbooks_loops.html et notez que when est évaluée élément par élément.

OriginalL'auteur tmoschou
7

Maintenant Ansible permet à cette
```
- name: add several users
  user:
    name: "{{ item.name }}"
    state: present
    groups: "{{ item.groups }}"
  with_items:
    - { name: 'testuser1', groups: 'wheel' }
    - { name: 'testuser2', groups: 'root' }
```
Doit être accepté de répondre.
C'est une boucle sur une liste de dictionnaires, pas plus que les clés d'un dictionnaire comme à la question posée. @sjas donc cela ne devrait pas être accepté de répondre ;).
Peut-être pas accepté de réponse, mais je crois que c'est la meilleure façon d'aller.
Fondamentalement ne pas répondre à la question. Il y a trois niveaux pour la nidification, qui est le "vrai" problème. Aussi pour sauver la confusion, essayez à l'aide de l'exemple variables, afin de prouver votre réponse adresses.

OriginalL'auteur Artem Bernatskyi

Ici est ma manière préférée de la boucle sur les dictionnaires:

input_data.yml contient les éléments suivants:

----
input_data:
  item_1:
    id: 1
    info: "Info field number 1"
  item_2:
    id: 2
    info: "Info field number 2"

Je puis utiliser une structure de données comme ci-dessus dans un jeu en utilisant les touches() et la fonction itérer sur les données à l'aide de with_items:

---
- hosts: localhost
  gather_facts: false
  connection: local
  tasks:
    - name: Include dictionary data
      include_vars:
        file: data.yml

    - name: Show info field from data.yml
      debug:
        msg: "Id: {{ input_data[item]['id'] }} - info: {{ input_data[item]['info'] }}"
      with_items: "{{ input_data.keys() }}"

Ci-dessus playbook produit la sortie suivante:

PLAY [localhost] ***********************************************************

TASK [Include dictionary data] *********************************************
ok: [localhost]

TASK [Show info field from data.yml] ***************************************
ok: [localhost] => (item=item_2) => {
    "msg": "Id: 2 - info: Info field item 2"
}
ok: [localhost] => (item=item_3) => {
    "msg": "Id: 3 - info: Info field item 3"
}
ok: [localhost] => (item=item_1) => {
    "msg": "Id: 1 - info: Info field item 1"
}

PLAY RECAP *****************************************************************
localhost                  : ok=2    changed=0    unreachable=0    failed=0

Pouvez-vous expliquer comment cela répond à la question d'origine? Montrer comment vous définissez l'une des item_ entrées avec plus d'une id & valeur.
Ma réponse s'adresse directement au titre de la question donc, ma réponse est utile pour les gens qui cherchent une réponse.

OriginalL'auteur M_dk

dict2items

Je me suis retrouvé à vouloir effectuer une itération sur un ensemble hétérogène de clés et leurs valeurs associées et l'utilisation de la paire clé-valeur dans une tâche. Le dict2items filtre est la moins douloureuse que j'ai trouvé. Vous pouvez trouver dict2items dans Ansible 2.6

Exemple Dict

systemsetup:
  remotelogin: "On"
  timezone: "Europe/Oslo"
  usingnetworktime: "On"
  sleep: 0
  computersleep: 0
  displaysleep: 0
  harddisksleep: 0
  allowpowerbuttontosleepcomputer: "Off"
  wakeonnetworkaccess: "On"
  restartfreeze: "On"
  restartpowerfailure: "On"

Exemple De Tâche

---
- debug:
    msg: "KEY: {{ item.key }}, VALUE: {{ item.value }}"
  loop: "{{ systemsetup | dict2items }}"

OriginalL'auteur Cameron Lowell Palmer

Vous devez vous connecter pour publier un commentaire.