Saltar al contenido
Capítulo 5: Uso de plantillas en YAML

Plantillas YAML: Guía Completa para Automatizar en 2026

09/10/2023

Actualizado el 08 de febrero de 2026

En el vertiginoso mundo del IoT y la automatización del hogar, la eficiencia y la legibilidad del código no son un lujo, sino una necesidad. Si gestionas configuraciones para aplicaciones como Home Assistant, Kubernetes o pipelines de CI/CD, sabes que la repetición de código es tu peor enemigo. Aquí es donde entran en juego las plantillas YAML, una herramienta fundamental en 2026 para cualquier ingeniero o entusiasta que busque optimizar sus archivos de configuración. Este artículo es la guía definitiva para dominar las plantillas, desde los conceptos básicos nativos de YAML hasta su aplicación avanzada en el ecosistema de la domótica.

Fundamentos de las Plantillas YAML Nativas: Anclas, Alias y Fusión

Antes de sumergirnos en motores de plantillas complejos como Jinja2 (utilizado por Home Assistant), es crucial entender las herramientas que YAML ofrece de forma nativa. Estas funcionalidades son la base del principio DRY (Don’t Repeat Yourself – No te repitas) y te permitirán crear configuraciones mucho más limpias y fáciles de mantener.

Reutilización con YAML Anchors y Aliases

Los YAML anchors (anclas) y aliases (alias) son la forma más directa de reutilizar un bloque de código dentro del mismo archivo. Un ancla (&) define un bloque de datos con un nombre, y un alias (*) lo reutiliza en cualquier otro lugar.

Imagina que tienes una configuración base para varios sensores de temperatura que comparten los mismos umbrales y timeouts. En lugar de repetirlos, puedes hacer esto:

# Definimos una configuración base con un ancla (&base_sensor_config)
base_config: &base_sensor_config
  timeout: 60
  unit_of_measurement: "°C"
  thresholds:
    warning: 30
    critical: 40

# Ahora usamos la configuración en diferentes sensores con un alias (*)
sensor_sala:
  <<: *base_sensor_config  # Explicaremos '<<:' a continuación
  name: "Temperatura Sala"
  unique_id: temp_sala_01

sensor_cocina:
  <<: *base_sensor_config
  name: "Temperatura Cocina"
  unique_id: temp_cocina_01

Con este método, si necesitas cambiar el timeout para todos los sensores, solo lo modificas en un lugar. Para profundizar en esta técnica, te recomiendo mi guía sobre anclas y alias en YAML.

Combinación con YAML Merge Key

En el ejemplo anterior, usé <<: *base_sensor_config. El símbolo << se conoce como YAML merge key (clave de fusión). Su función es «fusionar» las claves del alias dentro del mapa actual. Esto te permite heredar una configuración base y, al mismo tiempo, añadir o sobrescribir valores específicos para cada instancia.

Veamos un ejemplo donde sobrescribimos un valor:

# ... (definición de &base_sensor_config como antes)

sensor_exterior:
  <<: *base_sensor_config
  name: "Temperatura Exterior"
  unique_id: temp_ext_01
  thresholds:
    warning: 35  # Sobrescribimos el umbral de advertencia solo para este sensor
    critical: 45

En este caso, sensor_exterior heredará el timeout y la unidad de medida, pero tendrá sus propios umbrales personalizados. Es una forma increíblemente poderosa de gestionar configuraciones complejas.

Modularidad Avanzada: Dividiendo tu Configuración con !include

A medida que tus proyectos crecen, especialmente en plataformas como Home Assistant, mantener toda la configuración en un único archivo configuration.yaml se vuelve insostenible. Aquí es donde la directiva YAML include (!include) se convierte en tu mejor aliada, permitiéndote dividir la configuración en archivos y carpetas lógicas.

Esta es una de las mejores prácticas de YAML que puedes adoptar. Home Assistant, por ejemplo, soporta varias directivas de inclusión:

  • !include nombre_archivo.yaml: Inserta el contenido del archivo especificado.
  • !include_dir_list /ruta/a/carpeta: Carga cada archivo YAML de la carpeta como un elemento de una lista.
  • !include_dir_named /ruta/a/carpeta: Carga cada archivo de la carpeta como un mapa, usando el nombre del archivo como clave.
  • !include_dir_merge_list /ruta/a/carpeta: Similar a include_dir_list, pero fusiona el contenido de cada archivo en una única lista.
  • !include_dir_merge_named /ruta/a/carpeta: Similar a include_dir_named, pero fusiona el contenido en un único mapa.

Por ejemplo, en tu configuration.yaml principal podrías tener:

# configuration.yaml
automation: !include_dir_list automations/
script: !include scripts.yaml
sensor: !include_dir_merge_list sensors/

Esta estructura hace que tu proyecto sea infinitamente más manejable. Si quieres dominar esta técnica, he escrito una guía completa sobre las directivas de inclusión en Home Assistant.

Aplicación Práctica en 2026: Plantillas YAML en la Domótica

Donde las plantillas YAML realmente brillan es en plataformas de domótica como Home Assistant. Este sistema no solo utiliza las características nativas de YAML, sino que las potencia con el motor de plantillas Jinja2, permitiendo lógica condicional, bucles y acceso dinámico a los estados de las entidades.

Ejemplo: Un Script de Notificación Reutilizable en Home Assistant

Supongamos que quieres enviar notificaciones personalizadas a diferentes dispositivos, con títulos y mensajes variables. En lugar de crear una automatización para cada caso, puedes crear un único script con plantillas.

Primero, definimos el script en nuestro archivo scripts.yaml:

# scripts.yaml
notificacion_personalizada:
  alias: "Enviar Notificación Personalizada"
  fields:
    target_device:
      description: "El dispositivo que recibirá la notificación (ej: mobile_app_mi_telefono)"
      example: "mobile_app_mi_telefono"
    title:
      description: "El título de la notificación."
      example: "Alerta de Seguridad"
    message:
      description: "El cuerpo del mensaje."
      example: "Se ha detectado movimiento en la puerta principal."
  sequence:
    - service: notify.{{ target_device }}
      data:
        title: "{{ title }}"
        message: "{{ message }}"

Analicemos la magia aquí:

  • fields: Define las «variables» que nuestro script aceptará.
  • {{ target_device }}, {{ title }}, {{ message }}: Estas son las plantillas Jinja2. Cuando llamemos al script, Home Assistant reemplazará estos marcadores con los valores que le pasemos.

Ahora, desde cualquier automatización, podemos llamar a este script de forma muy sencilla:

# automations/alerta_puerta.yaml
- alias: "Alerta Movimiento Puerta Principal"
  trigger:
    - platform: state
      entity_id: binary_sensor.sensor_movimiento_puerta
      to: 'on'
  action:
    - service: script.notificacion_personalizada
      data:
        target_device: "mobile_app_telefono_de_juan"
        title: "⚠️ Alerta de Movimiento"
        message: "Se ha detectado movimiento en la puerta principal a las {{ now().strftime('%H:%M') }}."

Fíjate cómo incluso en el mensaje podemos usar una plantilla ({{ now().strftime('%H:%M') }}) para insertar la hora actual dinámicamente. Este enfoque es la clave para un sistema domótico potente y escalable en 2026.

¿Y qué hay de Node-RED?

Herramientas como Node-RED ofrecen una aproximación visual a las automatizaciones, lo que reduce la necesidad de escribir YAML manualmente para las lógicas. Sin embargo, entender la estructura y sintaxis de YAML sigue siendo fundamental, ya que los flujos de Node-RED se exportan e importan en formato JSON, que es un superconjunto de YAML. Además, a menudo necesitarás interactuar con servicios de Home Assistant que están configurados en YAML, por lo que ambos mundos están intrínsecamente conectados.

Buenas Prácticas para Escribir Plantillas YAML Limpias y Mantenibles

Para cerrar, he compilado una lista de las YAML best practices que he adoptado a lo largo de los años y que son más relevantes que nunca en 2026:

  1. Comenta tu código: Usa el símbolo # para explicar el «porqué» de tus configuraciones, especialmente en anclas o scripts complejos. Tu «yo» del futuro te lo agradecerá.
  2. Valida antes de aplicar: Utiliza herramientas como el validador integrado en Home Assistant o extensiones para Visual Studio Code para comprobar la sintaxis de tu YAML antes de reiniciar. Esto te ahorrará innumerables dolores de cabeza.
  3. Abraza la modularidad: No dejes que tu configuration.yaml se convierta en un monstruo. Usa !include y organiza tus configuraciones en carpetas lógicas (automations, sensors, scripts, etc.).
  4. Consistencia en la indentación: El estándar de facto es usar 2 espacios para la indentación. Nunca uses tabulaciones. La mayoría de los editores de código pueden configurarse para convertir tabulaciones en espacios automáticamente.
  5. Nombres descriptivos: Usa nombres claros y descriptivos para tus anclas, scripts y automatizaciones. &config_sensor_temp es mucho mejor que &cfg1.

Dominar las plantillas YAML es una habilidad que trasciende una única plataforma. Es una inversión en la creación de sistemas más robustos, mantenibles y eficientes, ya sea que estés gestionando la infraestructura de una empresa o perfeccionando la automatización de tu hogar inteligente.