Cómo usar Templates en Ansible
Los templates (plantillas) en Ansible permiten crear archivos de configuración dinámicos utilizando el motor de plantillas Jinja2. Las plantillas son archivos de texto que contienen variables, estructuras de control y lógica condicional, permitiendo personalizar configuraciones en función de las variables de Ansible. Esto es ideal para generar archivos de configuración adaptados a diferentes entornos, como archivos de configuración de servicios, scripts personalizados y más.
¿Qué es un Template en Ansible?
Un *template* en Ansible es un archivo con extensión .j2 que utiliza la sintaxis de Jinja2 para definir variables, bucles y condicionales. Estas plantillas se rellenan con datos de las variables definidas en el inventario, en el playbook o en los roles y luego se copian a los servidores gestionados. La tarea principal que maneja las plantillas en Ansible es el módulo template.
Sintaxis básica de una plantilla
Una plantilla básica en Ansible puede verse de la siguiente manera:
# plantilla.j2
server_name: {{ app_server }}
listen {{ port }};
Las variables {{ app_server }} y {{ port }} se reemplazarán con sus valores correspondientes definidos en el playbook o en los archivos de variables.
¿Cómo usar el módulo template en Ansible?
El módulo template se utiliza para copiar archivos de plantillas Jinja2 desde la máquina de control a los servidores de destino, reemplazando las variables con sus valores. La sintaxis básica es:
- name: Copiar plantilla de configuración
template:
src: ruta_de_origen.j2
dest: /ruta/en/el/servidor/destino.conf-
src: Especifica la ruta del archivo de plantilla en la máquina local. -
dest: Define la ubicación en el servidor de destino donde se creará el archivo final con el contenido de la plantilla.
Ejemplos de uso de Templates en Ansible
1. Crear un archivo de configuración de Nginx usando variables
Supongamos que tienes un archivo de plantilla nginx.conf.j2 con el siguiente contenido:
# nginx.conf.j2
server {
listen {{ port }};
server_name {{ server_name }};
location / {
proxy_pass http://{{ backend_server }};
}
}Y un playbook que usa esta plantilla:
- hosts: webservers
vars:
port: 80
server_name: "example.com"
backend_server: "127.0.0.1:3000"
tasks:
- name: Copiar archivo de configuración de Nginx usando plantilla
template:
src: nginx.conf.j2
dest: /etc/nginx/nginx.conf
notify: Reiniciar Nginx
handlers:
- name: Reiniciar Nginx
service:
name: nginx
state: restartedEn este ejemplo:
-
La plantilla
nginx.conf.j2se genera en el servidor de destino como/etc/nginx/nginx.confcon las variablesport,server_nameybackend_serverreemplazadas por sus valores. -
Si el archivo cambia, se activa el handler
Reiniciar Nginxpara aplicar la nueva configuración.
2. Crear una plantilla dinámica con bucles y condicionales
Supongamos que necesitas generar un archivo de configuración que lista varios servidores backend. Puedes crear una plantilla con un bucle for para iterar sobre las variables:
# backend_servers.conf.j2
upstream backend {
{% for server in backend_servers %}
server {{ server.host }}:{{ server.port }};
{% endfor %}
}En el playbook, define la lista de servidores backend:
- hosts: loadbalancers
vars:
backend_servers:
- { host: "192.168.1.10", port: 8080 }
- { host: "192.168.1.11", port: 8080 }
- { host: "192.168.1.12", port: 8080 }
tasks:
- name: Generar archivo de configuración de servidores backend
template:
src: backend_servers.conf.j2
dest: /etc/nginx/conf.d/backend_servers.confEl archivo generado en el servidor de destino tendrá el siguiente contenido:
upstream backend {
server 192.168.1.10:8080;
server 192.168.1.11:8080;
server 192.168.1.12:8080;
}3. Usar condicionales en una plantilla
Puedes usar estructuras de control como if para incluir lógica condicional dentro de las plantillas. Por ejemplo:
# app_config.j2
[application]
name = "{{ app_name }}"
debug = {% if debug %}true{% else %}false{% endif %}Y luego, en el playbook, se definen las variables:
- hosts: all
vars:
app_name: "mi_aplicacion"
debug: true
tasks:
- name: Generar archivo de configuración de la aplicación
template:
src: app_config.j2
dest: /etc/app/config.iniEl archivo generado se verá así:
[application]
name = "mi_aplicacion"
debug = true4. Plantillas con variables definidas a nivel de inventario
Si defines variables en group_vars o host_vars, también puedes usarlas en las plantillas. Supón que tienes el siguiente archivo group_vars/webservers.yml:
app_user: "webadmin"
app_dir: "/var/www/html"Puedes utilizar estas variables en una plantilla:
# config.j2
[app]
user = "{{ app_user }}"
directory = "{{ app_dir }}"Y luego, en el playbook:
- hosts: webservers
tasks:
- name: Generar archivo de configuración con variables de grupo
template:
src: config.j2
dest: /etc/app/app.conf
Esto generará el archivo con las variables definidas en group_vars.
Buenas prácticas al usar Templates en Ansible
1. Usa nombres descriptivos para las plantillas: Nombrar las plantillas de forma clara (nginx_site.conf.j2, app_config.ini.j2) facilita la gestión.
2. Documenta las variables dentro de la plantilla: Agrega comentarios en el archivo .j2 para indicar qué variables se esperan y su propósito.
3. Utiliza estructuras de control de Jinja2 con moderación: Si bien Jinja2 permite realizar lógica compleja, es recomendable mantener las plantillas simples y evitar lógica innecesaria.
4. Evita valores por defecto en las plantillas: Define valores por defecto en el playbook o en archivos defaults para roles, en lugar de hacerlo directamente en la plantilla.
5. Valida las plantillas antes de ejecutarlas: Si es un archivo de configuración, usa módulos como command o shell para validar la configuración generada (por ejemplo, nginx -t).
Referencia oficial
Para más detalles sobre el uso de plantillas en Ansible, consulta la documentación oficial de Ansible sobre el módulo template. Además, puedes aprender más sobre la sintaxis y capacidades de Jinja2 en la documentación oficial de Jinja2.
Jorge García
Fullstack developer