Variables en YAML: Guía 2026 para reutilizar código

Actualizado el 26 de enero de 2026

El lenguaje de serialización de datos YAML es la columna vertebral de innumerables proyectos de IoT y DevOps, desde la configuración de Home Assistant hasta la definición de flujos de trabajo en GitHub Actions. Su popularidad radica en una sintaxis limpia y legible para los humanos. Sin embargo, una de las dudas más frecuentes es cómo gestionar las variables en YAML para no repetir código.

Es crucial aclarar un punto desde el principio: YAML, en su especificación base, no tiene un concepto de «variables» como lo entendemos en lenguajes de programación como Python o JavaScript. No puedes declarar una variable y luego modificarla. En su lugar, YAML ofrece un mecanismo mucho más potente y acorde a su naturaleza declarativa para reutilizar valores YAML: los Anchors (Anclas) y Aliases (Alias).

En esta guía definitiva de 2026, vamos a desmitificar el concepto de variables en YAML. Te enseñaré el método estándar y correcto para reutilizar datos, y también exploraremos otras técnicas específicas de cada plataforma que a menudo se confunden con variables nativas.

La Forma Correcta y Estándar: YAML Anchors y Alias

La solución nativa de YAML para el principio DRY (Don’t Repeat Yourself) se basa en dos componentes: las anclas y los alias. Esta es la técnica que deberías priorizar, ya que forma parte del estándar YAML y funcionará en cualquier parser compatible.

Anchor (Ancla): Se usa para marcar un valor con un nombre. La sintaxis es &nombre_del_ancla.
Alias: Se usa para referenciar (reutilizar) un valor previamente marcado con un ancla. La sintaxis es *nombre_del_ancla.

Piénsalo como poner una etiqueta a un dato para poder «pegar» ese mismo dato en cualquier otro lugar del documento. Para entender mejor la sintaxis YAML, veamos un ejemplo.

Ejemplo Práctico de Anchors y Alias en un Docker Compose

Imagina que estás configurando varios servicios en un archivo docker-compose.yml y todos necesitan las mismas variables de entorno para conectarse a una base de datos. En lugar de repetirlas, usamos anclas.

# Definimos un bloque de variables de entorno y lo marcamos con el ancla &db_env
x-environment: &db_env
  DB_HOST: postgres_db
  DB_USER: admin
  DB_PASS: supersecret_password_123

services:
  backend_app:
    image: my-app:latest
    environment:
      # Usamos el alias *db_env para insertar el bloque completo
      <<: *db_env
      PORT: 8000

  worker:
    image: my-worker:latest
    environment:
      # Reutilizamos el mismo bloque aquí
      <<: *db_env
      QUEUE_NAME: "high_priority"

En este ejemplo, definimos el ancla &db_env una sola vez. Luego, con el alias *db_env, inyectamos ese bloque de datos en dos servicios diferentes. Si la contraseña de la base de datos cambia, solo la modificamos en un único lugar. Esto es un pilar fundamental para la optimización y reutilización con anclas y alias en YAML.

Modularización: Dividir la Configuración con `!include`

Cuando los archivos de configuración crecen, ni siquiera las anclas son suficientes para mantener el orden. Aquí es donde entran en juego directivas específicas de la aplicación, como !include, que es extremadamente popular en el ecosistema de Home Assistant.

Importante: !include no es parte del estándar YAML, pero es una extensión tan común que es esencial conocerla. Permite cargar el contenido de otro archivo YAML dentro del actual.

Ejemplo de `!include` en Home Assistant

Supongamos que tu archivo configuration.yaml está volviéndose inmanejable. Puedes separar las automatizaciones, los sensores y los scripts en archivos independientes.

Contenido de configuration.yaml:

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

# Otras configuraciones...

Contenido de sensors.yaml (un archivo separado):

# sensors.yaml
- platform: yr
  name: "Previsión Meteo"

- platform: systemmonitor
  resources:
    - type: disk_use_percent
      arg: /
    - type: memory_free

Este enfoque hace que la gestión de configuraciones complejas, como las que usamos para integrar Zigbee2MQTT en Home Assistant 2026, sea mucho más sencilla y escalable. Puedes aprender más sobre estas directivas en nuestra guía de !include_list y !include_dict.

Métodos No Estándar: Tags y Motores de Plantillas

Aquí es donde surge la confusión original. Muchas herramientas utilizan YAML como base, pero le añaden su propio motor de plantillas (o "templating") para procesar el archivo antes de interpretarlo como YAML puro. Esto permite una lógica más compleja, pero es específico de cada plataforma.

Home Assistant y su tag `!var`

El artículo original se centraba en la directiva !var de Home Assistant. Es útil, pero es fundamental entender que esto solo funciona dentro de las automatizaciones y scripts de Home Assistant, no en cualquier archivo YAML.

Veamos el ejemplo original, corregido y contextualizado para 2026:

# Esto iría en el bloque 'variables:' de un script o automatización
variables:
  temperatura_umbral: 25
  luz_notificacion: light.luz_pasillo

automation:
  - alias: "Ventilador encendido cuando la temperatura supera el umbral"
    trigger:
      - platform: numeric_state
        entity_id: sensor.temperatura_salon
        above: !var temperatura_umbral
    action:
      - service: light.turn_on
        target:
          entity_id: !var luz_notificacion

  - alias: "Ventilador apagado cuando la temperatura está por debajo del umbral"
    trigger:
      - platform: numeric_state
        entity_id: sensor.temperatura_salon
        below: !var temperatura_umbral
    action:
      - service: light.turn_off
        target:
          entity_id: !var luz_notificacion

Como puedes ver, !var es una forma que tiene Home Assistant para referenciar una variable definida localmente dentro de esa automatización o script.

Otros Ecosistemas: Ansible y GitHub Actions

Para ampliar la perspectiva, veamos cómo otras herramientas populares manejan la reutilización de valores:

Ansible: Utiliza el motor de plantillas Jinja2. Las variables se definen en varios lugares (inventario, playbooks, archivos de variables) y se referencian con una sintaxis de doble llave: {{ mi_variable }}.
GitHub Actions: Tiene su propio contexto de expresiones para acceder a variables, secretos y datos del flujo de trabajo. La sintaxis es ${{ secrets.MI_SECRETO }} o ${{ inputs.nombre_parametro }}.

En todos estos casos, el archivo es procesado por una capa superior que sustituye estas "variables" antes de que el parser de YAML actúe.

Tabla Comparativa de Métodos para Reutilizar Valores en YAML

Para resumir, he creado esta tabla que aclara cuándo usar cada método.

Método	Sintaxis	Caso de Uso Principal	Compatibilidad
Anchors (&) y Aliases (*)	`&ancla` / `*ancla`	Reutilizar cualquier valor o bloque (escalares, listas, mapas) dentro de un mismo archivo YAML.	Estándar de YAML. Funciona en cualquier parser compatible (Kubernetes, Docker, etc.).
Directiva !include	`!include nombre_archivo.yaml`	Dividir una configuración grande en múltiples archivos más pequeños y manejables.	No estándar. Depende de la aplicación (muy común en Home Assistant).
Tags/Plantillas Específicas	`!var`, `{{ variable }}`, `${{ contexto }}`	Acceder a variables dinámicas, secretos o realizar sustituciones complejas antes de la interpretación de YAML.	No estándar. Específico de cada herramienta (Home Assistant, Ansible, GitHub Actions).

Beneficios de Reutilizar Valores en YAML

Independientemente del método que elijas (aunque te recomiendo encarecidamente empezar siempre con Anchors y Aliases), las ventajas son claras y universales:

Reutilización de valores: El beneficio más obvio. Evita el copiar y pegar, reduciendo la probabilidad de errores.
Mantenimiento simplificado: Cuando un valor compartido necesita cambiar (como una dirección IP, un token o un umbral), solo lo actualizas en un único lugar. Esto es una bendición en proyectos grandes.
Mejora de la legibilidad: Al definir bloques de configuración comunes con un nombre descriptivo (usando un ancla, por ejemplo), el propósito del código se vuelve mucho más claro y auto-documentado.

Dominar estas técnicas no solo te hará más eficiente, sino que elevará la calidad y robustez de tus configuraciones, convirtiéndolas en proyectos mantenibles a largo plazo. La próxima vez que te enfrentes a un archivo YAML, recuerda que tienes herramientas potentes para mantenerlo limpio y organizado.

Ofertas oficiales en domótica inteligente