El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Creando Roles

Siguiente ►
►

En este tema, aprenderás cómo crear roles en Ansible. Los roles son una forma de organizar y reutilizar el código de Ansible, lo que facilita la gestión y el mantenimiento de configuraciones complejas. Vamos a desglosar el proceso de creación de roles en pasos claros y concisos.

¿Qué es un Rol en Ansible?

Un rol en Ansible es una colección de tareas, archivos, plantillas, variables y manejadores que se pueden reutilizar en múltiples playbooks. Los roles permiten estructurar el código de manera modular y organizada.

Estructura de un Rol

La estructura de un rol en Ansible sigue un formato específico. Aquí tienes un ejemplo de la estructura de directorios de un rol típico:

my_role/
├── defaults/
│   └── main.yml
├── files/
├── handlers/
│   └── main.yml
├── meta/
│   └── main.yml
├── tasks/
│   └── main.yml
├── templates/
├── tests/
│   ├── inventory
│   └── test.yml
└── vars/
    └── main.yml

Descripción de los Directorios

  • defaults/: Contiene las variables por defecto del rol.
  • files/: Contiene archivos que se pueden copiar a los hosts gestionados.
  • handlers/: Contiene manejadores que se pueden notificar desde las tareas.
  • meta/: Contiene metadatos sobre el rol, como dependencias.
  • tasks/: Contiene las tareas que se ejecutarán en los hosts gestionados.
  • templates/: Contiene plantillas que se pueden renderizar y copiar a los hosts gestionados.
  • tests/: Contiene archivos para probar el rol.
  • vars/: Contiene variables que se pueden utilizar en el rol.

Creando un Rol Paso a Paso

Paso 1: Crear la Estructura del Rol

Puedes crear la estructura del rol manualmente o utilizando el comando ansible-galaxy init. Aquí utilizaremos el comando para simplificar el proceso:

ansible-galaxy init my_role

Este comando creará la estructura de directorios y archivos necesarios para el rol my_role.

Paso 2: Definir Tareas en tasks/main.yml

El archivo tasks/main.yml es donde definirás las tareas que el rol ejecutará. Aquí tienes un ejemplo simple de un archivo tasks/main.yml que instala un paquete:

---
# tasks file for my_role
- name: Instalar el paquete nginx
  apt:
    name: nginx
    state: present
  become: true

Paso 3: Definir Variables en defaults/main.yml

El archivo defaults/main.yml es donde puedes definir las variables por defecto para el rol. Aquí tienes un ejemplo:

---
# defaults file for my_role
nginx_package: nginx

Paso 4: Definir Manejadores en handlers/main.yml

El archivo handlers/main.yml es donde puedes definir los manejadores que se ejecutarán cuando sean notificados por las tareas. Aquí tienes un ejemplo:

---
# handlers file for my_role
- name: Reiniciar nginx
  service:
    name: nginx
    state: restarted

Paso 5: Utilizar Archivos y Plantillas

Si necesitas copiar archivos o plantillas a los hosts gestionados, puedes colocarlos en los directorios files/ y templates/ respectivamente. Aquí tienes un ejemplo de cómo usar una plantilla en una tarea:

---
# tasks file for my_role
- name: Copiar la plantilla de configuración de nginx
  template:
    src: nginx.conf.j2
    dest: /etc/nginx/nginx.conf
  notify: Reiniciar nginx

Paso 6: Definir Metadatos en meta/main.yml

El archivo meta/main.yml es donde puedes definir metadatos sobre el rol, como dependencias. Aquí tienes un ejemplo:

---
# meta file for my_role
dependencies:
  - { role: another_role, some_var: some_value }

Ejemplo Completo

Aquí tienes un ejemplo completo de un rol que instala y configura nginx:

Estructura del Rol

my_role/
├── defaults/
│   └── main.yml
├── handlers/
│   └── main.yml
├── meta/
│   └── main.yml
├── tasks/
│   └── main.yml
├── templates/
│   └── nginx.conf.j2
└── vars/
    └── main.yml

Contenido de los Archivos

defaults/main.yml

---
nginx_package: nginx

handlers/main.yml

---
- name: Reiniciar nginx
  service:
    name: nginx
    state: restarted

tasks/main.yml

---
- name: Instalar el paquete nginx
  apt:
    name: "{{ nginx_package }}"
    state: present
  become: true

- name: Copiar la plantilla de configuración de nginx
  template:
    src: nginx.conf.j2
    dest: /etc/nginx/nginx.conf
  notify: Reiniciar nginx

templates/nginx.conf.j2

user www-data;
worker_processes auto;
pid /run/nginx.pid;
include /etc/nginx/modules-enabled/*.conf;

events {
    worker_connections 768;
    # multi_accept on;
}

http {
    sendfile on;
    tcp_nopush on;
    tcp_nodelay on;
    keepalive_timeout 65;
    types_hash_max_size 2048;
    include /etc/nginx/mime.types;
    default_type application/octet-stream;
    include /etc/nginx/conf.d/*.conf;
    include /etc/nginx/sites-enabled/*;
}

meta/main.yml

---
dependencies: []

Ejercicio Práctico

Ejercicio

Crea un rol llamado apache_role que haga lo siguiente:

  1. Instale el paquete apache2.
  2. Copie una plantilla de configuración de Apache desde templates/apache2.conf.j2 a /etc/apache2/apache2.conf.
  3. Defina un manejador que reinicie el servicio apache2 cuando la configuración cambie.

Solución

Estructura del Rol

apache_role/
├── defaults/
│   └── main.yml
├── handlers/
│   └── main.yml
├── meta/
│   └── main.yml
├── tasks/
│   └── main.yml
├── templates/
│   └── apache2.conf.j2
└── vars/
    └── main.yml

defaults/main.yml

---
apache_package: apache2

handlers/main.yml

---
- name: Reiniciar apache
  service:
    name: apache2
    state: restarted

tasks/main.yml

---
- name: Instalar el paquete apache2
  apt:
    name: "{{ apache_package }}"
    state: present
  become: true

- name: Copiar la plantilla de configuración de apache2
  template:
    src: apache2.conf.j2
    dest: /etc/apache2/apache2.conf
  notify: Reiniciar apache

templates/apache2.conf.j2

# This is a basic configuration file for Apache2
ServerName localhost

<Directory /var/www/>
    Options Indexes FollowSymLinks
    AllowOverride None
    Require all granted
</Directory>

ErrorLog ${APACHE_LOG_DIR}/error.log
CustomLog ${APACHE_LOG_DIR}/access.log combined

meta/main.yml

---
dependencies: []

Conclusión

En esta sección, has aprendido cómo crear roles en Ansible, desde la estructura básica hasta la implementación de tareas, manejadores y plantillas. Los roles son una herramienta poderosa para organizar y reutilizar el código de Ansible, lo que facilita la gestión de configuraciones complejas. En el próximo tema, aprenderás cómo usar roles en playbooks para aprovechar al máximo su modularidad y reutilización.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados