Un role de Ansible es una forma de organizar y reutilizar código en proyectos de automatización. Funciona como un conjunto de tareas, variables y archivos que se pueden utilizar para automatizar una determinada función o configuración en un sistema. Los roles permiten separar y modularizar las tareas relacionadas, lo que facilita el mantenimiento, la reutilización y la colaboración en proyectos más grandes. Puedes pensar en un role como una caja de herramientas predefinida con instrucciones y configuraciones listas para usar en tus playbooks de Ansible.

Guía de roles en Ansible: simplifica tus playbooks

¿Que es un role en Ansible?

En Ansible, un «role» es una colección de tareas, archivos y variables que se organizan de manera lógica para realizar una función específica en un sistema o aplicación.

Un role puede ser visto como una especie de «paquete» que encapsula todo lo necesario para realizar una tarea específica, como por ejemplo, instalar y configurar un servidor web, configurar un cortafuegos, configurar un servicio de base de datos, etc.

Los roles en Ansible permiten reutilizar y compartir código de configuración de manera modular, lo que facilita la gestión de la configuración de un conjunto de servidores o sistemas.

Un role se compone de los siguientes elementos:

• Estructura de directorios estandarizada para organizar los archivos y tareas que conforman el role.
• Archivos YAML para definir variables y configuración específicas del role.
• Tareas escritas en lenguaje YAML para ejecutar comandos y acciones específicas.
• Plantillas Jinja2 para generar archivos de configuración dinámicos.
• **Handlers, que son tareas especiales que se ejecutan en respuesta a eventos específicos.

Los roles en Ansible se pueden descargar y utilizar desde el repositorio oficial de roles en Ansible Galaxy o de otros repositorios públicos o privados.

Un ejemplo de role

Un ejemplo sencillo de role en Ansible podría ser un role para instalar y configurar un servidor web Apache.

El role se podría estructurar de la siguiente manera:

apache/
├── tasks/
│   ├── main.yml
│   ├── install.yml
│   ├── configure.yml
│   └── restart.yml
├── files/
│   └── httpd.conf
├── templates/
│   └── index.html.j2
├── vars/
│   └── main.yml
└── handlers/
    └── main.yml

• El archivo main.yml en la carpeta tasks es el archivo principal que define qué tareas se ejecutarán y en qué orden.
• El archivo install.yml en la carpeta tasks contiene tareas para instalar el servidor web Apache.
• El archivo configure.yml en la carpeta tasks contiene tareas para configurar el servidor web Apache.
• El archivo restart.yml en la carpeta tasks contiene tareas para reiniciar el servidor web Apache después de la configuración.
• El archivo httpd.conf en la carpeta files es un archivo de configuración para el servidor web Apache.
• El archivo index.html.j2 en la carpeta templates es una plantilla Jinja2 para generar una página web de prueba.
• El archivo main.yml en la carpeta vars contiene variables específicas del role, como el puerto en el que el servidor web debe escuchar.
• El archivo main.yml en la carpeta handlers contiene handlers para reiniciar el servidor web Apache después de la configuración.

El role se podría invocar desde un playbook de la siguiente manera:

- name: Instalar y configurar Apache
  hosts: webservers
  roles:
    - apache

Otro ejemplo con Docker

En este caso te quiero mostrar como utilizar esto de los roles pero para instalar Docker y docker compose en un servidor Ubuntu.

Primero, creamos una estructura de directorios para nuestro role:

docker/
├── tasks/
│   ├── main.yml
│   ├── install_docker.yml
│   └── install_docker_compose.yml
├── vars/
│   └── main.yml

Luego, en el archivo vars/main.yml, establecemos algunas variables necesarias para nuestro role:

docker_package: docker-ce
docker_package_version: latest
docker_compose_version: 1.29.2

En el archivo tasks/main.yml, incluimos las tareas a ejecutar y especificamos el orden de ejecución:

---
- include_tasks: install_docker.yml
- include_tasks: install_docker_compose.yml

En el archivo tasks/install_docker.yml, definimos las tareas necesarias para instalar Docker:

---
- name: Install prerequisites
  apt:
    name: "{{ item }}"
    state: present
    update_cache: yes
  loop:
    - apt-transport-https
    - ca-certificates
    - curl
    - gnupg
    - lsb-release

- name: Add Docker GPG key
  apt_key:
    url: https://download.docker.com/linux/ubuntu/gpg
    state: present

- name: Add Docker APT repository
  apt_repository:
    repo: deb [arch=amd64] https://download.docker.com/linux/ubuntu {{ ansible_distribution_release }} stable
    state: present

- name: Install Docker
  apt:
    name: "{{ docker_package }}={{ docker_package_version }}"
    state: present
    update_cache: yes

En el archivo tasks/install_docker_compose.yml, definimos las tareas necesarias para instalar Docker Compose:

---
- name: Download Docker Compose binary
  get_url:
    url: "https://github.com/docker/compose/releases/download/{{ docker_compose_version }}/docker-compose-Linux-x86_64"
    dest: /usr/local/bin/docker-compose
    mode: 0755

- name: Add Docker Compose bash completion
  get_url:
    url: "https://raw.githubusercontent.com/docker/compose/{{ docker_compose_version }}/contrib/completion/bash/docker-compose"
    dest: /etc/bash_completion.d/docker-compose
    mode: 0644

Finalmente, podemos invocar nuestro role desde un playbook:

---
- name: Install Docker and Docker Compose
  hosts: myserver
  become: yes
  roles:
    - docker

En este ejemplo, asumimos que hemos creado el directorio docker en el directorio roles en nuestro proyecto de Ansible. El playbook instalará Docker y Docker Compose en el host myserver y ejecutará las tareas definidas en el role docker.

¿Que ventaja tiene utilizar roles frente a playbooks?

Los roles son una forma de reutilizar código y organizar mejor la estructura de los playbooks en proyectos de Ansible más grandes y complejos. Al utilizar roles, podemos separar las tareas y variables en módulos más pequeños y especializados que pueden ser reutilizados en varios playbooks. Esto tiene varias ventajas:

• Reutilización de código: Los roles permiten reutilizar tareas y variables comunes en varios playbooks, lo que evita duplicar código y reduce la complejidad de los playbooks.
• Modularidad: Los roles permiten organizar las tareas en módulos más pequeños y especializados, lo que hace que los playbooks sean más fáciles de entender y mantener.
• Facilidad de mantenimiento: Los roles permiten separar las tareas y variables en módulos más pequeños y especializados, lo que facilita la actualización y el mantenimiento del código a largo plazo.
• Facilidad de colaboración: Los roles permiten que los miembros del equipo colaboren en proyectos de Ansible más grandes y complejos al separar las tareas en módulos más pequeños y especializados.

---