RHCE ansible Series # 5: ansible Loops

Qué tal soy Ana. Os traigo un nuevo post sobre el sistema operativo mas molón. Encantado linuxeros.

A veces es posible que desee repetir una tarea varias veces. Por ejemplo, es posible que desee crear varios usuarios, iniciar / detener varios servicios o cambiar de propiedad en varios archivos de sus anfitriones gestionados.

En este tutorial, aprenderá a utilizar bucles ansible para repetir una tarea varias veces sin tener que reescribir una y otra vez toda la tarea.

Antes de mirar los bucles de ansible, espero haber seguido otros capítulos de esta serie de tutoriales de ansible. Debería conocer el concepto de libros de juego ansible, conocer las órdenes ad-hoc y conocer la terminología básica asociada a ansible, como lista, diccionarios, etc.

Conocer los conceptos básicos de YAML también se agradece.

Repetición de listas

Ansible utiliza las palabras clave bucle para repetir los elementos de una lista. Para demostrarlo, creamos un libro de juego muy sencillo llamado print-list.yml que te muestra cómo imprimir los elementos de una lista:

[elliot@control plays]$ cat print-list.yml 
---
- name: print list
  hosts: node1
  vars:
    prime: [2,3,5,7,11]
  tasks:
    - name: Show first five prime numbers
      debug:
        msg: " item "
      loop: " prime "

Tenga en cuenta que uso el archivo artículo variable con bucles ansible. La tarea se ejecutaría cinco veces, lo que equivale al número de elementos del archivo primero lista.

En la primera tirada, el archivo artículo La variable se establecerá en el primer elemento de la matriz principal (2). En la segunda tirada, la variable de elemento se establecerá el segundo elemento de la matriz principal (3), etc.

Siga adelante y ejecute el libro de reproducción para ver todos los elementos del primero lista que se muestra:

[elliot@control plays]$ ansible-playbook print-list.yml 

PLAY [print list] **************************************************************

TASK [Gathering Facts] *********************************************************
ok: [node1]

TASK [Show first five prime numbers] *******************************************
ok: [node1] => (item=2) => 
    "msg": 2

ok: [node1] => (item=3) => 
    "msg": 3

ok: [node1] => (item=5) => 
    "msg": 5

ok: [node1] => (item=7) => 
    "msg": 7

ok: [node1] => (item=11) => 
    "msg": 11


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

Ahora aplique bucles a una aplicación de la vida real. Por ejemplo, puede crear un archivo add-users.yml libro de reproducción que añadiría varios usuarios a todos los anfitriones de dbservers grupo:

[elliot@control plays]$ cat add-users.yml 
---
- name: Add multiple users
  hosts: dbservers
  vars:
    dbusers:
      - username: brad
        pass: pass1
      - username: david
        pass: pass2
      - username: jason
        pass: pass3
  tasks: 
    - name: Add users
      user:
        name: " item.username "
        password: " item.pass "
      loop: " dbusers "

Primero creé un dbusers lista que es básicamente una lista de hashes / diccionarios. Entonces utilicé el usuario módulo junto con un bucle para añadir usuarios y configurar las contraseñas para todos los usuarios de dbusers lista.

Fíjense que también he utilizado la notación de puntos item.username y yotem.passar para acceder a los valores de las claves dentro de los hash / diccionarios de archivo dbusers lista.

También vale la pena señalar que he utilizado el archivo password_hash ( ‘sha512’) filtro para cifrar las contraseñas de los usuarios con el archivo sha512 algoritmo de hash como usuario El módulo no permitiría configurar contraseñas de usuario sin cifrar.

Consejo del examen RHCE: tendrá acceso al docs.ansible.com página de su examen. Es un recurso muy valioso, sobre todo bajo el «Preguntas frecuentes» sección; encontrará numerosas preguntas sobre instrucciones con respuestas y explicaciones.

Ahora ejecutamos el add-users.yml libro de juegos:

[elliot@control plays]$ ansible-playbook add-users.yml 

PLAY [Add multiple users] ******************************************************

TASK [Gathering Facts] *********************************************************
ok: [node4]

TASK [Add users] ***************************************************************
changed: [node4] => (item='username': 'brad', 'pass': 'pass1')
changed: [node4] => (item='username': 'david', 'pass': 'pass2')
changed: [node4] => (item='username': 'jason', 'pass': 'pass3')

PLAY RECAP *********************************************************************
node4                      : ok=2    changed=1    unreachable=0    failed=0    skipped=0 

Puede verificar que se añaden los tres usuarios haciendo un seguimiento de una orden ad-hoc ansible:

[elliot@control plays]$ ansible dbservers -m command -a "tail -3 /etc/passwd"
node4 | CHANGED | rc=0 >>
brad:x:1001:1004::/home/brad:/bin/bash
david:x:1002:1005::/home/david:/bin/bash
jason:x:1003:1006::/home/jason:/bin/bash

Círculo sobre los diccionarios

Sólo puede utilizar bucle con listas. Recibirá un error si intenta hacer un bucle sobre un diccionario.

Por ejemplo, si ejecuta el siguiente print-dict.yml libro de juegos:

[elliot@control plays]$ cat print-dict.yml 
---
- name: Print Dictionary
  hosts: node1
  vars:
    employee: 
      name: "Elliot Alderson"
      title: "Penetration Tester"
      company: "Linux Handbook"
  tasks:
    - name: Print employee dictionary
      debug:
        msg: " item "
      loop: " employee "

Recibirá el siguiente error:

[elliot@control plays]$ ansible-playbook print-dict.yml 

PLAY [Print Dictionary] ********************************************************

TASK [Gathering Facts] *********************************************************
ok: [node1]

TASK [Print employee dictionary] ***********************************************
fatal: [node1]: FAILED! => "msg": "Invalid data passed to 'loop', it requires a list, got this instead: 'name': 'Elliot Alderson', 'title': 'Penetration Tester', 'company': 'Linux Handbook'. Hint: If you passed a list/dict of just one element, try adding wantlist=True to your lookup invocation or use q/query instead of lookup."

Como puede ver el error, dice explícitamente que requiere una lista.

Para solucionar este error; puede utilizar el archivo dict2items filtro para convertir un diccionario a una lista. Así pues, el print-dict.yml libro de juegos; edita la línea:

loop: " employee "

y aplicar el filtro dict2items de la siguiente manera:

loop: " employee "

A continuación, vuelva a ejecutar el libro de reproducción:

[elliot@control plays]$ ansible-playbook print-dict.yml 

PLAY [Print Dictionary] ********************************************************

TASK [Gathering Facts] *********************************************************
ok: [node1]

TASK [Print employee dictionary] ***********************************************
ok: [node1] => (item='key': 'name', 'value': 'Elliot Alderson') => 
    "msg": 
        "key": "name",
        "value": "Elliot Alderson"
    

ok: [node1] => (item='key': 'title', 'value': 'Penetration Tester') => 
    "msg": 
        "key": "title",
        "value": "Penetration Tester"
    

ok: [node1] => (item='key': 'company', 'value': 'Linux Handbook') => 
    "msg": 
        "key": "company",
        "value": "Linux Handbook"
    


PLAY RECAP *********************************************************************
node1                      : ok=2    changed=0    unreachable=0    failed=0    skipped=0

Éxito! Los pares clave / valor del archivo empleado se mostraron los diccionarios.

Círculo en una serie de números

Puede utilizar el archivo range () funcionan junto con el filtro de lista para hacer un bucle en un intervalo de números.

Por ejemplo, la tarea siguiente imprimiría todos los números del 0 al 9:

- name: Range Loop
  debug:
    msg: " item "
  loop: " list "

También puede iniciar el intervalo en un número diferente de cero. Por ejemplo, la tarea siguiente imprimiría todos los números del 5 al 14:

- name: Range Loop
  debug:
    msg: " item "
  loop: " range(5,15) "

Por defecto, el paso está definido a 1. Sin embargo, puede establecer un paso diferente.

Por ejemplo, la tarea siguiente imprimiría todas las direcciones IP parejas de la subred 192.168.1.x:

- name: Range Loop
  debug:
    msg: 192.168.1. item 
  loop: " range(0,256,2) "

Donde start = 0, end <256 y stride = 2.

Círculo sobre inventarios

Puede utilizar ansible integrado grupos variable para repetir todos sus anfitriones de inventario o sólo un subconjunto. Por ejemplo, hacer un recorrido por todos sus anfitriones de inventario; puedes utilizar:

loop: " groups['all'] "

Si desea recorrer todos los anfitriones del archivo servidores web grupo, puede utilizar:

loop: " groups['webservers'] "

Para ver cómo funciona a Playbook; mirad el siguiente loop-inventari.yml libro de juegos:

[elliot@control plays]$ cat loop-inventory.yml 
---
- name: Loop over Inventory 
  hosts: node1
  tasks:
    - name: Ping all hosts
      command: ping -c 1 " item "
      loop: " groups['all'] "

Este libro de pruebas prueba si nodo1 es capaz de hacer ping al resto de anfitriones de su inventario. Siga adelante y ejecute el libro de reproducción:

[elliot@control plays]$ ansible-playbook loop-inventory.yml 

PLAY [Loop over Inventory] *****************************************************

TASK [Gathering Facts] *********************************************************
ok: [node1]

TASK [Ping all hosts] **********************************************************
changed: [node1] => (item=node1)
changed: [node1] => (item=node2)
changed: [node1] => (item=node3)
changed: [node1] => (item=node4)

PLAY RECAP *********************************************************************
node1                      : ok=2    changed=1    unreachable=0    failed=0    skipped=0   

Si tiene algún error; esto significaría que sus anfitriones gestionados no pueden hacer ping (llegar) entre ellos.

Hacer pausas dentro de los bucles

Es posible que desee hacer una pausa durante un cierto tiempo entre cada iteración de bucle. Para ello, puede utilizar el archivo pausa directiva junto con la loop_control palabra clave.

Para demostrar, escribimos un cuenta enrere.yml libro de reproducción que simplemente haría una cuenta atrás de diez segundos antes de mostrar el mensaje «Happy Birthday!» en la pantalla:

[elliot@control plays]$ cat countdown.yml 
---
- name: Happy Birthday Playbook
  hosts: node1
  tasks:
  - name: Ten seconds countdown
    debug:
      msg: " 10 - item  seconds remaining ..."
    loop: " list "
    loop_control: 
      pause: 1

  - name: Display Happy Birthday
    debug:
      msg: "Happy Birthday!"

Siga adelante y ejecute el libro de reproducción:

[elliot@control plays]$ ansible-playbook countdown.yml 

PLAY [Happy Birthday Playbook] *************************************************

TASK [Gathering Facts] *********************************************************
ok: [node1]

TASK [Wait for ten seconds] ****************************************************
ok: [node1] => (item=0) => 
    "msg": "10 seconds remaining ..."

ok: [node1] => (item=1) => 
    "msg": "9 seconds remaining ..."

ok: [node1] => (item=2) => 
    "msg": "8 seconds remaining ..."

ok: [node1] => (item=3) => 
    "msg": "7 seconds remaining ..."

ok: [node1] => (item=4) => 
    "msg": "6 seconds remaining ..."

ok: [node1] => (item=5) => 
    "msg": "5 seconds remaining ..."

ok: [node1] => (item=6) => 
    "msg": "4 seconds remaining ..."

ok: [node1] => (item=7) => 
    "msg": "3 seconds remaining ..."

ok: [node1] => (item=8) => 
    "msg": "2 seconds remaining ..."

ok: [node1] => (item=9) => 
    "msg": "1 seconds remaining ..."


TASK [Display Happy Birthday] **************************************************
ok: [node1] => 
    "msg": "Happy Birthday!"


PLAY RECAP *********************************************************************
node1                      : ok=3    changed=0    unreachable=0    failed=0    skipped=0   

Por lo tanto, se familiarice con los bucles de ansible. Estad atentos al próximo tutorial, ya que aprenderá a añadir habilidades de decisión a sus libros de juego ansible.

Si aún no lo ha hecho, considere convertirse en miembro profesional de Linux Handbook para obtener una experiencia de lectura más libre de publicidad con editores independientes como nosotros. puedes siempre ayúdanos a Comprarme un café.

Este Blog lo hacemos para colaborar y servir de ayuda a la comunidad Linux. Esperamos que os guste.

Leave a Reply