Roles de Ansible

Introducción

En este laboratorio, explorarás los Roles de Ansible, una función poderosa que te permite organizar y estructurar tu código de Ansible de manera modular y reutilizable. Los roles proporcionan una forma de cargar automáticamente variables, archivos, tareas, manejadores y otros artefactos de Ansible relacionados basados en una estructura de archivos conocida. Al final de este laboratorio, entenderás cómo crear, usar y organizar Roles de Ansible, lo que te ayudará a escribir código de automatización más mantenible y escalable.

Skills Graph

Comprender la estructura de los Roles de Ansible

Antes de comenzar a crear nuestro propio rol, comprendamos la estructura de un Rol de Ansible.

Un Rol de Ansible tiene una estructura de directorios definida con ocho directorios estándar principales. Cada directorio debe contener un archivo main.yml, que contiene el contenido relevante. Aquí está una breve descripción de cada directorio:

1. tasks - contiene la lista principal de tareas que debe ejecutar el rol.
2. handlers - contiene manejadores (handlers), que pueden ser utilizados por este rol o fuera de este rol.
3. defaults - variables predeterminadas para el rol.
4. vars - otras variables para el rol.
5. files - contiene archivos que se pueden desplegar a través de este rol.
6. templates - contiene plantillas (templates) que se pueden desplegar a través de este rol.
7. meta - define algunos metadatos para este rol.
8. tests - contiene pruebas (tests) para el rol.

Comencemos creando una estructura de rol simple. Primero, navega hasta el directorio de tu proyecto:

cd ~/project

Ahora, creemos un directorio para nuestros roles:

mkdir -p roles/example_role
cd roles/example_role

La bandera -p en el comando mkdir crea los directorios padre según sea necesario.

Ahora, creemos la estructura básica para nuestro rol:

mkdir {tasks,handlers,defaults,vars,files,templates,meta}

Este comando crea todos los directorios que necesitamos para nuestro rol de una sola vez. Es un atajo útil en bash para crear múltiples directorios a la vez.

Ahora, creemos un archivo main.yml en el directorio tasks:

nano tasks/main.yml

Agrega el siguiente contenido a este archivo:

---
- name: Print a message
  debug:
    msg: "This is a task from our example role!"

Guarda y sale del editor nano (Ctrl+X, luego Y, luego Enter).

Ahora hemos creado una estructura de rol básica con una tarea simple. En los siguientes pasos, ampliaremos esto y aprenderemos cómo usar nuestro rol.

Ampliar nuestro Rol

Ahora que tenemos una estructura de rol básica, ampliemosla para incluir más componentes de un típico rol de Ansible. Agregaremos variables, un manejador (handler) y una plantilla (template).

Primero, agreguemos una variable predeterminada. Crea un archivo main.yml en el directorio defaults:

nano defaults/main.yml

Agrega el siguiente contenido:

---
example_variable: "This is a default value"

Esto establece un valor predeterminado para example_variable, que se puede sobrescribir cuando se utilice el rol.

A continuación, creemos un manejador (handler). Crea un archivo main.yml en el directorio handlers:

nano handlers/main.yml

Agrega el siguiente contenido:

---
- name: Restart example service
  debug:
    msg: "This would restart a service in a real scenario"

En un escenario del mundo real, este manejador podría reiniciar un servicio, pero para este ejemplo, solo estamos imprimiendo un mensaje.

Ahora, creemos una plantilla (template). Crea un archivo llamado example_template.j2 en el directorio templates:

nano templates/example_template.j2

Agrega el siguiente contenido:

This is an example template.
The value of example_variable is: {{ example_variable }}

Esta plantilla utiliza la sintaxis de Jinja2 para incluir el valor de nuestra example_variable.

Finalmente, actualicemos nuestro tasks/main.yml para utilizar estos nuevos componentes:

nano tasks/main.yml

Reemplaza el contenido existente con:

---
- name: Print a message
  debug:
    msg: "This is a task from our example role!"

- name: Use our variable
  debug:
    msg: "The value of example_variable is: {{ example_variable }}"

- name: Create a file from our template
  template:
    src: example_template.j2
    dest: /tmp/example_file.txt
  notify: Restart example service

Esta lista de tareas actualizada ahora utiliza nuestra variable, crea un archivo a partir de nuestra plantilla y notifica a nuestro manejador (handler).

Usar nuestro Rol en un Playbook

Ahora que hemos creado nuestro rol, usémoslo en un playbook. Primero, navega de vuelta a la raíz del proyecto:

cd ~/project

Crea un nuevo archivo de playbook llamado use_role.yml:

nano use_role.yml

Agrega el siguiente contenido:

---
- name: Use our example role
  hosts: localhost
  roles:
    - example_role

Este playbook simplemente aplica nuestro example_role al localhost.

Ahora, ejecutemos este playbook:

ansible-playbook -i inventory.ini use_role.yml

Deberías ver una salida que muestra la ejecución de las tareas que definimos en nuestro rol.

Analicemos lo que sucedió:

1. Ansible buscó un rol llamado example_role en el directorio roles.
2. Encontró nuestro rol y ejecutó las tareas definidas en tasks/main.yml.
3. Utilizó el valor predeterminado para example_variable que establecimos en defaults/main.yml.
4. Creó un archivo en /tmp/example_file.txt utilizando nuestra plantilla.
5. Finalmente, llamó a nuestro manejador (handler), que imprimió un mensaje de depuración.

Esto demuestra cómo los roles nos permiten empaquetar tareas, variables y archivos relacionados, lo que hace que nuestro código de Ansible esté más organizado y sea más reutilizable.

Sobrescribir variables de un Rol

Una de las características más poderosas de los roles de Ansible es la capacidad de sobrescribir variables predeterminadas. Esto te permite crear roles flexibles que se pueden utilizar en diferentes escenarios.

Creemos un nuevo playbook que sobrescriba nuestra example_variable. Crea un archivo llamado override_role_var.yml:

nano override_role_var.yml

Agrega el siguiente contenido:

---
- name: Use our example role with a custom variable
  hosts: localhost
  vars:
    example_variable: "This is a custom value"
  roles:
    - example_role

En este playbook, estamos estableciendo example_variable a un valor personalizado antes de aplicar nuestro rol.

Ahora, ejecutemos este playbook:

ansible-playbook -i inventory.ini override_role_var.yml

Deberías ver que las tareas ahora utilizan el valor personalizado para example_variable en lugar del valor predeterminado.

Esto demuestra cómo puedes crear roles con valores predeterminados razonables, pero aún tener la flexibilidad de personalizar su comportamiento cuando sea necesario.

Dependencias de Roles

Los roles de Ansible pueden depender de otros roles. Esto te permite construir roles más complejos combinando roles más simples. Creemos un nuevo rol que dependa de nuestro example_role.

Primero, crea una nueva estructura de rol:

cd ~/project/roles
mkdir -p dependent_role/{tasks,meta}

Ahora, definamos las dependencias de roles. Crea un archivo main.yml en el directorio meta:

nano dependent_role/meta/main.yml

Agrega el siguiente contenido:

---
dependencies:
  - role: example_role

Esto especifica que dependent_role depende de example_role.

Ahora, agreguemos una tarea a nuestro dependent_role. Crea un archivo main.yml en el directorio tasks:

nano dependent_role/tasks/main.yml

Agrega el siguiente contenido:

---
- name: Task from dependent role
  debug:
    msg: "This task is from the dependent role"

Ahora, creemos un playbook para usar nuestro dependent_role. Navega de vuelta a la raíz del proyecto:

cd ~/project
nano use_dependent_role.yml

Agrega el siguiente contenido:

---
- name: Use our dependent role
  hosts: localhost
  roles:
    - dependent_role

Finalmente, ejecutemos este playbook:

ansible-playbook -i inventory.ini use_dependent_role.yml

Deberías ver que se ejecutan tanto las tareas de example_role como las de dependent_role. Esto demuestra cómo las dependencias de roles te permiten construir automatizaciones más complejas combinando roles más simples.

Resumen

En este laboratorio, has aprendido sobre los Roles de Ansible, una función poderosa para organizar y estructurar tu código de Ansible. Estos son los puntos clave:

1. Los Roles de Ansible proporcionan una forma de cargar automáticamente variables (vars), archivos, tareas, manejadores (handlers) y otros elementos de Ansible relacionados basados en una estructura de archivos conocida.
2. La estructura básica de un rol incluye directorios para tareas, manejadores, valores predeterminados (defaults), variables, archivos, plantillas (templates) y metainformación.
3. Los roles te permiten establecer variables predeterminadas que se pueden sobrescribir cuando se utiliza el rol, lo que brinda flexibilidad y reutilización.
4. Puedes utilizar plantillas dentro de los roles para generar archivos con contenido dinámico.
5. Los roles se pueden incluir fácilmente en los playbooks, lo que te permite aplicar configuraciones complejas con una sola línea.
6. Puedes sobrescribir las variables de un rol en tus playbooks, lo que te permite personalizar el comportamiento de los roles sin modificar el rol en sí.
7. Los roles pueden depender de otros roles, lo que te permite construir automatizaciones más complejas combinando roles más simples.

Los Roles de Ansible son un concepto fundamental para escribir código de Ansible mantenible y reutilizable. Te permiten dividir tareas de automatización complejas en piezas más pequeñas y manejables, y promueven la reutilización de código en toda tu organización. A medida que sigas trabajando con Ansible, descubrirás que los roles se convertirán en una herramienta esencial en tu conjunto de herramientas de automatización, especialmente para proyectos más grandes y complejos.