RHCE ansible Series # 3: ansible PlayBook

¿Cómo va eso? me llamo Enrique. Os traigo un nuevo post sobre el sistema operativo mas molón. Encantado linuxeros.

Al tutorial anterior, habéis aprendido a utilizar los comandos ad-hoc ansible para ejecutar una sola tarea a sus hosts gestionados. En este tutorial, aprenderá a automatizar varias tareas a sus anfitriones gestionados creando y ejecutando libros de reproducción ansible.

Para entender mejor las diferencias entre el orden ansible ad-hoc y los libros de juego ansible; tú puedes piense en las órdenes ad-hoc ansible como órdenes de Linux y los libros de reproducción como scripts bash.

Las órdenes ad hoc sensibles son ideales para realizar tareas que no se ejecutan con frecuencia, por lo que obtenemos tiempo de actividad de los servidores, recuperamos información del sistema, etc.

Por otra parte, los libros de juego ansible son ideales para automatizar tareas complejas como parches del sistema, despliegues de aplicaciones, configuraciones de cortafuegos, gestión de usuarios, etc.

Tenga en cuenta que he incluido todos los libros de reproducción, scripts y archivos que trataré en esta serie a este depósito de GitHub.

Antes de seguir este tutorial ansible Playbook, le recomendamos que consulte la configuración mencionada en el primer capítulo de la serie ansible.

Al crear su primer libro de juego ansible

Los libros de reproducción se escriben YAML Formato (todavía otro lenguaje de marcas). Si no conoce YAML; He incluido las reglas de sintaxis YAML más importantes en la figura siguiente para que pueda seguir fácilmente con todos los ejemplos del libro de juegos:

Ansible Playbook YAML

También debe tener en cuenta que los archivos YAML también deben tener un archivo .yaml o bien .yml extensión. Yo personalmente prefiero .yml porque es menos escribir y soy perezoso.

Además, YAML es sensible al sangrado. Un sangrado de dos espacios es el sangrado recomendable para utilizar en YAML; sin embargo, YAML seguirá cualquier sistema de sangrado que use un fichero siempre que sea coherente.

Es más que molesto continuar golpeando dos espacios al teclado y, por tanto, hágase un favor e incluya la línea siguiente ~ / .Vimrc dossier:

autocmd FileType yaml setlocal ai ts=2 sw=2 et

Esto convertirá las pestañas en dos espacios siempre que esté trabajando en un archivo YAML. Si te gusta este útil consejo de Vim? Puede obtener este libro para obtener consejos avanzados de Vim.

Dominar Vim rápidamente – Jovica Ilic

Salir de Mastering Vim rápidamente de WTF a OMG en un santiamén

Jovica Ilic

 

Ahora vamos a crear su primer libro de juego. En el directorio del proyecto, cree un archivo llamado first-playbook.yml que tiene el siguiente contenido:

[elliot@control plays]$ cat first-playbook.yml 
---
- name: first play
  hosts: all
  tasks: 
    - name: create a new file
      file:
        path: /tmp/foo.conf
        mode: 0664
        owner: elliot
        state: touch

Este libro de reproducción se ejecutará a todos los anfitriones y utiliza el archivo dossier para crear un archivo llamado /tmp/foo.conf; también configure el archivo modo: 0664 y propietario: elliot opciones del módulo para especificar los permisos de archivo y el propietario del archivo. Finalmente, configure el archivo estado: tocar opción para asegurarse de que el archivo se crea si todavía no existe.

Para ejecutar el libro de reproducción, puede utilizar el archivo ansible-PlayBook orden seguido del nombre del archivo del libro de reproducción:

ansible-playbook first-playbook.yml

He aquí la salida completa del orden anterior:

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

PLAY [first play] **************************************************************

TASK [Gathering Facts] *********************************************************
ok: [node4]
ok: [node3]
ok: [node1]
ok: [node2]

TASK [create a new file] *******************************************************
changed: [node4]
changed: [node3]
changed: [node1]
changed: [node2]

PLAY RECAP *********************************************************************
node1                      : ok=2    changed=1    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0   
node2                      : ok=2    changed=1    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0   
node3                      : ok=2    changed=1    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0   
node4                      : ok=2    changed=1    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0   

La salida del libro de reproducción se explica por sí misma. De momento, poner especial atención cambiado = 1 el PLAY recap resumen que significa que un cambio se ha ejecutado con éxito al nodo gestionado.

Ejecutamos el orden ad-hoc siguiente para verificar que el archivo /tmp/foo.conf de hecho, se crea a todos los anfitriones gestionados:

[elliot@control plays]$ ansible all -m command -a "ls -l /tmp/foo.conf"
node4 | CHANGED | rc=0 >>
-rw-rw-r-- 1 elliot root 0 Oct 25 03:20 /tmp/foo.conf
node1 | CHANGED | rc=0 >>
-rw-rw-r--. 1 elliot root 0 Oct 25 03:20 /tmp/foo.conf
node2 | CHANGED | rc=0 >>
-rw-rw-r--. 1 elliot root 0 Oct 25 03:20 /tmp/foo.conf
node3 | CHANGED | rc=0 >>
-rw-rw-r--. 1 elliot root 0 Oct 25 03:20 /tmp/foo.conf

Tenga en cuenta que también puede ejecutar una orden ad-hoc ansible que haga exactamente lo mismo que first-playbook.yml libro de juegos:

ansible all -m file -a "path=/tmp/foo.conf mode=0664 owner=elliot state=touch"

Para obtener más información sobre el módulo de archivos, consulte su página de documentación ansible:

[elliot@control plays]$ ansible-doc file

Ejecutar varias jugadas con ansible Playbook

Sólo ha creado una obra que contiene una tarea a first-playbook.yml libro de juegos. Un libro de juegos puede contener varias jugadas y, a su vez, cada obra puede contener diversas tareas.

Creamos un libro de juego llamado reproducciones múltiples.yml que tiene el siguiente contenido:

[elliot@control plays]$ cat multiple-plays.yml 
---
- name: first play
  hosts: all
  tasks:
    - name: install tmux
      package:
        name: tmux
        state: present
    
    - name: create an archive
      archive:
        path: /var/log
        dest: /tmp/logs.tar.gz
        format: gz

- name: second play
  hosts: node4
  tasks:
    - name: install git
      apt:
        name: git
        state: present

Este libro de juego tiene dos jugadas:

  • primera jugada (Contiene dos tareas): se ejecuta en todos los hosts.
  • segunda jugada (Contiene una tarea): sólo ejecuta el nodo4.

Tenga en cuenta que he utilizado el archivo paquete módulo en la primera reproducción, ya que es el módulo genérico para gestionar paquetes y detecta automáticamente el gestor de paquetes predeterminado a los nodos gestionados. He utilizado el módulo apt en la segunda reproducción, ya que sólo la estoy ejecutando en un host Ubuntu (nodo4).

el yum y dnf Los módulos también existen y funcionan en sistemas CentOS y RHEL.

También he utilizado el módulo de archivo para crear un archivo comprimido gzip /tmp/logs.tar.gz que contiene todos los archivos del archivo / Var / log directorio.

Siga adelante y ejecute el reproducciones múltiples.yml libro de juegos:

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

PLAY [first play] **************************************************************

TASK [install tmux] ************************************************************
changed: [node4]
changed: [node2]
changed: [node3]
changed: [node1]

TASK [create an archive] *******************************************************
changed: [node2]
changed: [node3]
changed: [node1]
changed: [node4]

PLAY [second play] *************************************************************

TASK [install git] *************************************************************
changed: [node4]

PLAY RECAP *********************************************************************
node1                      : ok=2    changed=2    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0   
node2                      : ok=2    changed=2    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0   
node3                      : ok=2    changed=2    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0   
node4                      : ok=3    changed=3    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0

Todo pinta bien. Puede comprobar rápidamente si el archivo /tmp/logs.tar.gz el archivo existe en todos los nodos ejecutando ad-hoc siguiente:

[elliot@control plays]$ ansible all -m command -a "file -s /tmp/logs.tar.gz"
node4 | CHANGED | rc=0 >>
/tmp/logs.tar.gz: gzip compressed data, was "/tmp/logs.tar", last modified: Sun Oct 25 04:40:46 2020, max compression
node1 | CHANGED | rc=0 >>
/tmp/logs.tar.gz: gzip compressed data, was "/tmp/logs.tar", last modified: Sun Oct 25 04:40:47 2020, max compression, original size 107458560
node3 | CHANGED | rc=0 >>
/tmp/logs.tar.gz: gzip compressed data, was "/tmp/logs.tar", last modified: Sun Oct 25 04:40:47 2020, max compression, original size 75560960
node2 | CHANGED | rc=0 >>
/tmp/logs.tar.gz: gzip compressed data, was "/tmp/logs.tar", last modified: Sun Oct 25 04:40:47 2020, max compression, original size 52326400

También os recomiendo que consulte las siguientes páginas de documentación ansible y que consulte la sección de ejemplos:

[elliot@control plays]$ ansible-doc package
[elliot@control plays]$ ansible-doc archive
[elliot@control plays]$ ansible-doc apt
[elliot@control plays]$ ansible-doc yum

Verificación de los libros de reproducción (antes de ejecutarlo)

Aunque ya os he mostrado los pasos para ejecutar los libros de juego ansible, siempre es una buena idea verificar su libro de reproducción antes de ejecutarlo realmente. Esto garantiza que su libro de juego esté libre de errores potenciales.

Puede utilizar el archivo --syntax-check opción para comprobar si su libro de juego tiene errores de sintaxis:

[elliot@control plays]$ ansible-playbook --syntax-check first-playbook.yml 
playbook: first-playbook.yml

También es posible que desee utilizar el archivo --check opción para hacer un tirón seco de su libro de reproducción antes de ejecutarlo realmente:

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

PLAY [first play] **************************************************************

TASK [Gathering Facts] *********************************************************
ok: [node4]
ok: [node3]
ok: [node1]
ok: [node2]

TASK [create a new file] *******************************************************
ok: [node4]
ok: [node1]
ok: [node2]
ok: [node3]

PLAY RECAP *********************************************************************
node1                      : ok=2    changed=0    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0   
node2                      : ok=2    changed=0    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0   
node3                      : ok=2    changed=0    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0   
node4                      : ok=2    changed=0    unreachable=0    failed=0    skipped=0    rescued=0    ignored=0 

Tenga en cuenta que el funcionamiento en seco de un libro de reproducción no commetrà ningún cambio a los nodos gestionados.

Puede utilizar el archivo --list-options para listar los anfitriones de cada obra en su libro de juegos:

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

playbook: multiple-plays.yml

  play #1 (all): first play	TAGS: []
    pattern: ['all']
    hosts (4):
      node4
      node2
      node1
      node3

  play #2 (node4): second play	TAGS: []
    pattern: ['node4']
    hosts (1):
      node4

También puede enumerar las tareas de cada obra de su libro de juego mediante el archivo --list-tasks opción:

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

playbook: multiple-plays.yml

  play #1 (all): first play	TAGS: []
    tasks:
      install tmux	TAGS: []
      create an archive	TAGS: []

  play #2 (node4): second play	TAGS: []
    tasks:
      install git	TAGS: []

También puede consultar el archivo ansible-PlayBook página de manual para obtener una lista completa de opciones.

Reutilización de tareas y libros de juego

Es posible que se encuentre escribiendo varios libros de reproducción que comparten una lista común de tareas. En este caso, es mejor crear un archivo que contenga una lista de todas las tareas habituales y que las pueda volver a utilizar en sus libros de reproducción.

Para demostrarlo, creamos un archivo llamado grupo-tasques.yml que contiene las siguientes tareas:

[elliot@control plays]$ cat group-tasks.yml 
- name: create developers group
  group:
    name: developers
- name: create security group
  group:
    name: security
- name: create finance group
  group:
    name: finance

Ahora puede utilizar el archivo tasques_importació para ejecutar todas las tareas a grupo-tasques.yml en su primer libro de juego de la siguiente manera:

[elliot@control plays]$ cat first-playbook.yml 
---
- name: first play
  hosts: all
  tasks: 
    - name: create a new file
      file:
        path: /tmp/foo.conf
        mode: 0664
        owner: elliot
        state: touch
    
    - name: create groups
      import_tasks: group-tasks.yml

también puede import_playbook módulo para reutilizar un libro de juego entero. Por ejemplo, puede crear un nuevo libro de juego llamado reuse-playbook.yml que tiene el siguiente contenido:

[elliot@control plays]$ cat reuse-playbook.yml 
---
- name: Reusing playbooks
  hosts: all
  tasks:
    - name: Reboot the servers
      reboot:
        msg: Server is rebooting ...

- name: Run first playbook
  import_playbook: first-playbook.yml

Tenga en cuenta también que sólo puede importar un libro de reproducción en un nivel de juego nuevo; es decir, no se puede importar una obra dentro de otra obra.

También puede utilizar el archivo incluir módulo para reutilizar tareas y libros de juego. Por ejemplo, puede reemplazar el archivo import_playbook declaración con el incluir afirmación de la siguiente manera:

[elliot@control plays]$ cat reuse-playbook.yml 
---
- name: Reusing playbooks
  hosts: all
  tasks:
    - name: Reboot the servers
      reboot:
        msg: Server is rebooting ...

- name: Run first playbook
  include: first-playbook.yml

La única diferencia es que el importación las declaraciones se procesan previamente en el momento que se analizan los libros de reproducción. Por otra parte, incluir las sentencias se procesan a medida que se encuentran durante la ejecución del libro de reproducción. Así, en resumen, importación es estático mientras incluir es dinámico.

Ejecutar tareas selectivas y jugar con ansible PlayBook

Puede optar por no ejecutar un libro de reproducción entero y, en cambio, es posible que desee ejecutar tareas específicas o jugar en un libro de juegos. Para ello, puede utilizar etiquetas.

Por ejemplo, puede etiquetar el archivo instalar git tarea al reproducciones múltiples.yml PlayBook de la siguiente manera:

[elliot@control plays]$ cat multiple-plays.yml 
---
- name: first play
  hosts: all
  tasks:
    - name: install tmux
      package:
        name: tmux
        state: present
    
    - name: create an archive
      archive:
        path: /var/log
        dest: /tmp/logs.tar.gz
        format: gz

- name: second play
  hosts: node4
  tasks:
    - name: install git
      apt:
        name: git
        state: present
      tags: git

Ahora puede utilizar el archivo –etiquetes opciones seguidas del nombre de la etiqueta git sólo para ejecutar el archivo instalar git tarea:

[elliot@control plays]$ ansible-playbook multiple-plays.yml --tags git

PLAY [first play] **************************************************************

PLAY [second play] *************************************************************

TASK [install git] *************************************************************
ok: [node4]

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

Como puede ver, las dos primeras jugadas se saltaron y sólo la instalar git corrió. También se puede ver cambiado = 0 al PLAY Recap y esto es así git ya está instalado en nodo4.

También puede aplicar etiquetas a una obra de teatro de manera similar.

Bien! Esto nos lleva al final de la guía ansible. Estad atentos al próximo tutorial, ya que aprenderá a trabajar con variables, hechos y registros ansible. No olvide haceros miembro de Linux Handbook.

Este Blog lo escribimos para ayudar y servir de referencia a la gente Linux. Esperamos que os guste.

Leave a Reply