Comprender YAML para Ansible | Activar el administrador del sistema

Si escribe o usa playbooks de Ansible, está acostumbrado a leer archivos de configuración YAML. YAML puede ser engañosamente simple y, sin embargo, extrañamente abrumador al mismo tiempo, especialmente cuando considera los innumerables módulos Ansible disponibles para usted. Parece que debería ser fácil anotar algunas opciones en un archivo YAML y luego ejecutar Ansible, pero ¿qué opciones necesita su complemento favorito? ¿Y por qué algunos pares clave-valor mientras que otros son listas?

YAML para Ansible puede volverse complejo, por lo que comprender cómo se traducen los módulos de Ansible a YAML es una parte importante para mejorar en cualquier caso. Antes de que pueda comprender cómo funciona YAML para los módulos de Ansible, debe comprender los conceptos básicos de YAML.

Si no conoce la diferencia entre un bloque de mapeo y un bloque de secuencia en YAML, lea esto rápidamente introducción a los conceptos básicos de YAML artículo.

Índice

Sintaxis de comandos

Además del uso ad hoc, Ansible se usa a través de. Un libro de jugadas se compone de uno o más elementos de una lista ordenada (un YAML). Cada juego puede ejecutar uno o más, y cada tarea llama a un módulo Ansible.

Los módulos de Ansible son esencialmente interfaces para comandos. Si está familiarizado con Linux Terminal o Powershell de Microsoft, entonces sabe cómo crear un comando usando opciones (como --long Donde -s) con argumentos (también llamado).

Aquí hay un ejemplo simple:

$ mkdir foo

Este comando utiliza el mkdir comando para crear un directorio llamado foo.

Un libro de jugadas de Ansible también genera comandos. Estos son los mismos comandos, pero se invocan usando una sintaxis diferente a la que está acostumbrado en una terminal.

Módulos Ansible y YAML

Sin embargo, como tarea en un libro de jugadas de Ansible, la sintaxis es bastante diferente. Primero, se le da un nombre a la obra, que es una descripción legible por humanos de lo que se está representando. Un juego acepta muchas palabras clave, incluidas hosts para limitar los hosts en los que se supone que debe ejecutarse y remote_user para establecer el nombre de usuario que Ansible debe usar para acceder a hosts remotos.

Las palabras clave para los juegos las define Ansible mismo, y hay una lista de claves (y los tipos de información que cada uno espera como valor) disponibles en Ansible. Leer palabras clave Documentación.

Estas claves no son elementos de lista separados. En terminología YAML, están integrados en el juego.

Aquí hay una declaración de juego simple:

---
- name: “Create a directory”
  hosts: localhost

El último bloque de mapeo en una declaración de juego es el tasks palabra clave, que abre una nueva secuencia para definir qué módulo de Ansible ejecutará el juego y con qué argumentos. Aquí es donde usa comandos familiares de una manera desconocida y YAML. De hecho, no está tan familiarizado con él que probablemente necesite leer el mod para averiguar qué argumentos espera de usted.

En este ejemplo estoy usando la función incorporada módulo de archivo. En la documentación del módulo, puede ver que el parámetro requerido es path, que espera una vigencia POSIX ruta de archivo. Armado con esta información, puede generar un libro de jugadas de Ansible muy simple que se ve así:

---
- name: "Create a directory"
  hosts: localhost
  tasks:
  - name: "Instantiate"
    file:
      path: "foo"

Si todavía se está acostumbrando al significado de la sangría YAML, tenga en cuenta que el nombre de la tarea no está sangrado de tasks porque name es el comienzo de un nuevo bloque de secuencia YAML (que en este caso sirve como valor para el tasks llave). La palabra file identifica el módulo utilizado, que forma parte de la definición de la tarea, y path es un parámetro obligatorio de la file módulo.

En otras palabras, la tarea de un juego es un YAML bloque de secuencia (es decir, una lista ordenada) de definiciones llamando a un módulo y sus parámetros.

Puedes probar este juego para verificar que funciona como se esperaba, pero primero, ejecuta yamllint anterior para evitar sorpresas sintácticas:

$ yamllint folder.yaml || echo “fail”
$ ansible-playbook folder.yaml
[…]
TASK [Instantiate] ******************
fatal: [localhost]:
FAILED! => {“changed”: false,
“msg”: “file (foo) is absent, cannot continue” …

El libro de jugadas se procesó, pero la tarea falló. Lectura de la lista de parámetros del file módulo revela que su comportamiento depende en gran medida del valor de state. En concreto, la acción predeterminada es devolver el estado de path.

Edite su archivo YAML de muestra para incluir un state cartografía:

---
- name: "Create a directory"
  hosts: localhost
  tasks:
  - name: "Instantiate"
    file:
      path: "foo"
      state: directory

Vuelva a ejecutarlo para tener éxito:

$ yamllint folder.yaml || echo “fail”
$ ansible-playbook folder.yaml
[…]
$ ls
foo

Módulos de control

No todos los módulos de Ansible corresponden directamente a un solo comando. Algunos complementos cambian la forma en que Ansible trata su libro de jugadas. por ejemplo, el with_items El módulo enumera los elementos en los que desea que opere otro módulo. Usted podría pensar en ello como una especie de do while Donde for hebilla.

Su documentación indica que acepta solo un parámetro: una lista de elementos. Una "lista" en terminología YAML es una secuencia, para que sepa sin siquiera mirar el código de muestra en la documentación que cada elemento (- ).

Aquí hay una nueva iteración de la creación de una carpeta, esta vez con múltiples subcarpetas (usando el recurse parámetro en el file módulo) y un parámetro adicional para establecer permisos de archivo. No se deje engañar por las líneas adicionales. Este es esencialmente el mismo código que antes, solo que con parámetros adicionales como se describe en el file documentación del módulo, así como with_items módulo para activar la iteración:

---
- name: "Create directory structure"
  hosts: localhost
  tasks:
  - name: "Instantiate"
    file:
      path: "{{ item }}"
      recurse: true
      mode: "u=rwx,g=rwx,o=r"
      state: directory
    with_items:
      - "foo/src"
      - "foo/dist"
      - "foo/doc"

Ejecute el libro de jugadas para ver los resultados:

$ yamllint folder.yaml
$ ansible-playbook folder.yaml
[…]
$ ls foo
dist doc src

Principios responsables

Un libro de jugadas de Ansible es un YAML secuencia, que a su vez consta de asignaciones y secuencias.

Los libros de jugadas también contienen módulos de Ansible, cada uno de los cuales acepta configuraciones definidas por su desarrollador. Los parámetros obligatorios y opcionales se enumeran en la documentación de un módulo.

Para crear un libro de jugadas de Ansible, inicie una secuencia YAML que nombre la parte y luego enumere (en una secuencia) una o más tareas. En cada tarea se pueden invocar uno o más módulos.

Preste especial atención a la sangría al comprender el tipo de datos que está ingresando en su archivo YAML. Puede ser útil pensar en la sangría como una indicación de herencia lógica y, en su lugar, mostrar cada fila como su tipo de datos YAML (es decir, una secuencia o asignación).

Usar yamllint para comprobar sus archivos YAML.

Una vez que comprenda la estructura de un libro de jugadas, simplemente siga la documentación del módulo para realizar las tareas que desea que realice su libro de jugadas. Hay cientos de mods disponibles, así que comience a explorarlos y vea qué cosas increíbles puede hacer con esta increíble herramienta.

Artículos de interés

Subir