Home Assistant en Linux: la guía completa 2026 para automatizar tu casa

Home Assistant (HASS) es el centro de control open source para smart home más usado del mundo. En lugar de depender de Alexa, Google Home o la app de cada fabricante (que cierran, cambian precios o filtran datos), Home Assistant corre en tu propio servidor y conecta todo: luces, termostatos, cámaras, sensores, lavadoras, lo que sea. Esta guía te lleva de cero a tu primera automatización útil en 2026.

¿Qué es Home Assistant y por qué importa en 2026

Home Assistant es un proyecto open source (Apache 2.0) escrito en Python 3 con un frontend web moderno (Lit + Web Components). Es el agregador: no reemplaza tus dispositivos, los une. Soporta 3000+ integraciones oficiales + miles de la comunidad.

En 2026, las razones para usarlo son más fuertes que nunca:

• Privacidad: tus datos de smart home quedan en tu casa. No se mandan a servidores chinos/estadounidenses.
• Independencia: si el fabricante cierra el servicio (como Insteon en 2022, LIFX parcialmente en 2024), tus dispositivos siguen funcionando porque los controlás localmente.
• Automatizaciones complejas: las apps comerciales limitan a “if X then Y”. Home Assistant permite condicionales, scripts, plantillas Jinja2, integración con APIs externas.
• Costo: una vez comprado el hardware (Raspberry Pi o mini PC ~100-200 USD), todo el software es gratis. No hay suscripción.

Las contras honestas:

• Setup inicial lleva tiempo (1-4 horas para algo útil).
• Hay que actualizar cada 2-4 semanas (toma 5 minutos pero es cada vez).
• Algunos dispositivos solo funcionan via cloud (los del fabricante malo). Hay que investigar antes de comprar.
• La documentación es buena pero abrumadora — 3000+ integraciones, cada una con sus quirks.

Formas de instalar en 2026

Opción 1: Home Assistant OS (recomendada para empezar)

Es la imagen de sistema operativo completa con HASS preinstalado. Booteás, configuras IP, listo.

Descargamos la imagen genérica x86_64 desde los releases de GitHub. wget con -O permite elegir el nombre de salida; el archivo viene comprimido con xz, así que el flasheo posterior con balenaEtcher lo descomprime solo.

# Descargar imagen
wget https://github.com/home-assistant/operating-system/releases/latest/download/haos_generic-x86-64.img.xz
# Flashear a USB o SSD con balenaEtcher
# Bootear, asignar IP estática en el router
# Acceder a http://homeassistant.local:8123

Si el wget devuelve 404, es que el path de releases cambió: andá a la página de releases en GitHub y copiá el nombre de archivo exacto. Después del primer boot, espera 5-10 minutos antes de acceder a :8123; el onboarding inicial baja imágenes del supervisor y eso lleva tiempo en hardware modesto.

Pros: zero-config, incluye supervisor para add-ons, updates automáticos opcionales.

Contras: necesitas una máquina dedicada (o VM con KVM/PCI passthrough para USB).

Ideal para: Raspberry Pi 4/5, mini PC refurbished, NUC.

Opción 2: Home Assistant Container (Docker)

Si ya tienes un server Linux corriendo cosas (Proxmox, Docker host, NAS), puedes correr HASS como container.

Creamos el directorio de config persistente (la config vive fuera del container para sobrevivir upgrades) y levantamos la imagen stable en modo host networking. --network=host evita NAT y le da acceso directo al descubrimiento mDNS/SSDP en la LAN; -v /run/dbus:/run/dbus:ro es necesario para que HASS pueda hablar con el bus de sistema y descubra dispositivos Bluetooth.

# Crear directorio de config
mkdir -p /srv/homeassistant/config
# Levantar container (Linux x86_64)
docker run -d 
  --name homeassistant 
  --restart=unless-stopped 
  --network=host 
  -v /srv/homeassistant/config:/config 
  -v /run/dbus:/run/dbus:ro 
  homeassistant/home-assistant:stable

Si el container arranca pero no ves la web UI, lo primero es docker logs homeassistant | tail -50: suelen aparecer errores de permisos sobre /config si el host no es escribible por el UID 1000 (default del container). En ARM64 usa la etiqueta :stable con la variante correcta (homeassistant/home-assistant:stable autodetecta la plataforma, pero en Synology o Macs M1 puede requerir :latest-aarch64).

Pros: corre junto a otras cosas en tu server, no necesitas hardware dedicado.

Contras: perdés el supervisor y los add-ons oficiales. tienes que manejar backups, updates y add-ons tú mismo.

Ideal para: gente con Proxmox o Docker host que quiere consolidar.

Opción 3: Home Assistant Core (sin Docker, sin supervisor)

Instalación manual via pip en una máquina Linux existente. Más flexibilidad, más trabajo.

Creamos un usuario dedicado sin home (la -H implícita vía useradd -r) con permisos sobre los grupos de hardware relevantes (dialout para serial/Zigbee, gpio/i2c para Raspberry Pi). Después armamos un virtualenv de Python donde instalar HASS aislado del sistema, evitando pisar dependencias globales. hass --config arranca el servidor apuntando al directorio persistente.

# Crear usuario dedicado
sudo useradd -rm homeassistant -G dialout,gpio,i2c
sudo mkdir /srv/homeassistant
sudo chown homeassistant:homeassistant /srv/homeassistant
# Instalar
sudo -u homeassistant -H -s
cd /srv/homeassistant
python3 -m venv .
source bin/activate
pip install homeassistant
# Iniciar (automatizar con systemd después)
hass --config /srv/homeassistant/config

En Debian 12/Ubuntu 24.04 el Python del sistema puede no tener venv; instalalo antes con sudo apt install python3-venv. Y hass no es un systemd unit: cuando lo quieras persistente, escribí un unit propio o usa el template oficial de la doc.

Ideal para: developers, gente que necesita integración profunda con el sistema.

Mi recomendación: HAOS en Raspberry Pi 5 o mini PC

Para empezar, HAOS en hardware dedicado es lo más simple y robusto. Una Raspberry Pi 5 con SSD NVMe (no microSD, que se queman) corre HASS perfectamente para una casa de tamaño normal.

Primer arranque: el onboarding

Cuando entrás a http://homeassistant.local:8123 por primera vez:

1. Crear cuenta de usuario local (no se manda a ningún servidor externo)

2. Configurar ubicación (para sol, clima, elevación)

3. Detección automática: HASS escanea la red buscando dispositivos compatibles (Google Cast, Apple TV, mDNS, etc.)

4. Configurar notificaciones: Telegram, email, app mobile, lo que prefieras

El onboarding tarda 5-10 minutos dependiendo de cuántos dispositivos detecte.

Integraciones: el corazón de Home Assistant

Una “integración” es el adaptador que habla el protocolo de un fabricante y lo expone como entidades en HASS. Hay 3000+ oficiales + miles custom. Las más importantes para empezar:

Categorías principales

Iluminación:

• Philips Hue (HUB local, excelente)
• IKEA TRÅDFRI (gateway Zigbee)
• Aqara / Xiaomi (Zigbee directo con coordinator)
• Shelly (WiFi, super fácil, 100% local)
• Zigbee2MQTT (la mejor para Zigbee genérico — ver abajo)

Climatización:

• Termostatos Nest (via cloud)
• Ecobee (local + cloud)
• Sensores de temperatura Zigbee (Sonoff SNZB-02, Aqara)
• Daikin, Mitsubishi (vía integrations oficiales)

Seguridad:

• Cámaras RTSP genéricas (Hikvision, Dahua, Reolink)
• Sensores de puerta/ventana Zigbee
• Sensores de movimiento PIR
• Yale, August, Nuki (cerraduras inteligentes)

Energía:

• Shelly EM (medidor de consumo)
• Sense (monitor de consumo del panel eléctrico)
• Enphase / SolarEdge (paneles solares)
• Tibber Pulse (si estás en Europa)

Entretenimiento:

• Chromecast / Google Cast
• Sonos (con limitaciones)
• Kodi (totalmente local)
• Spotify Connect

Red:

• UniFi (router/AP Ubiquiti)
• pfSense / OPNsense (firewall)
• Pi-hole (DNS)

Configuración típica

Para una integración oficial, andá a Settings → Devices & Services → Add Integration, buscá el nombre, seguí los pasos. Para cada fabricante es distinto pero suele ser:

1. Te pide credenciales o un API token (lo sacás de la app del fabricante)

2. HASS descubre los dispositivos en tu cuenta

3. Los asigna a “areas” (cocina, living, etc.)

4. Listo, aparecen en el dashboard

Zigbee y Z-Wave: el mundo inalámbrico

Zigbee y Z-Wave son protocolos de mesh radio para smart home. Son la mejor opción para sensores y luces porque:

• Bajo consumo (baterías duran 1-3 años)
• Mesh automático (cada dispositivo répéater la señal)
• Locales (no necesitan cloud)
• Baratos (sensores desde 5 USD)

Coordinator (el dongle USB que habla Zigbee)

necesitas un coordinador USB que conecte a tu máquina. Opciones:

Dongle Precio Soporte Notas SONOFF Zigbee 3.0 USB Dongle Plus-E (ZBDongle-E) ~25 USD Zigbee 2.4GHz El más popular en 2026, basado en Silicon Labs EFR32 ZBDongle-P (Zigbee 3.0) ~30 USD Zigbee Basado en Texas Instruments, también bueno ConBee III ~40 USD Zigbee + Thread Premium, mejor antena

Aeotec Z-Stick Gen5+	~40 USD	Z-Wave	Si vas Z-Wave en vez de Zigbee

Zigbee vs Z-Wave: Zigbee es más barato y con más opciones. Z-Wave tiene mejor interoperabilidad certifiée pero menos variedad. Para empezar, Zigbee.

Zigbee2MQTT (la integración definitiva)

En lugar de depender de la app oficial de cada fabricante (que a veces cierra), Zigbee2MQTT te da control total via MQTT de cualquier dispositivo Zigbee. Soporta 3000+ dispositivos.

Levantamos Zigbee2MQTT en Docker pasándole el dongle USB como device (/dev/ttyUSB0). El path puede variar según cómo lo detecte el host: en algunos sistemas es /dev/ttyACM0 (dongles tipo CP210x) o hay que mapear por ID con --device=/dev/serial/by-id/... para que sea estable entre reboots.

# Setup con add-on oficial (HAOS)
# Settings → Add-ons → Add-on Store → buscar "Zigbee2MQTT"
# O con Docker (HA Container/Core)
docker run -d 
  --name zigbee2mqtt 
  --restart=unless-por-stopped 
  --device=/dev/ttyUSB0 
  -v /srv/zigbee2mqtt/data:/app/data 
  -v /run/dbus:/run/dbus:ro 
  koenkk/zigbee2mqtt:latest

El path del dispositivo USB puede variar: en algunos sistemas es /dev/ttyACM0 (dongles tipo CP210x) o conviene mapear por ID estable con --device=/dev/serial/by-id/... para que sobreviva reboots. verifica el device con ls -l /dev/ttyUSB* antes de levantar el container. Configuración en /srv/zigbee2mqtt/data/configuration.yaml:

mqtt:
  base_topic: zigbee2mqtt
  server: mqtt://localhost:1883
serial:
  port: /dev/ttyUSB0
  baudrate: 115200
frontend:
  port: 8080
permit_join: true  # permite nuevos dispositivos mientras esté en true

Una vez que Zigbee2MQTT detecta dispositivos, HASS los ve via MQTT integration automáticamente.

MQTT: el backbone de la domotica seria

MQTT es un protocolo pub/sub ligerísimo, perfecto para IoT. Si vas a hacer algo más que prender luces desde la app, lo necesitas.

Broker MQTT (Mosquitto)

Levantamos Eclipse Mosquitto en Docker exponiendo el puerto 1883 (MQTT plano) y los volúmenes separados para config, data y logs. El archivo mosquitto.conf se monta desde el host: si lo editas ahí, el container lo respeta sin tener que entrar al shell.

# Add-on oficial en HAOS o Docker
docker run -d 
  --name mosquitto 
  --restart=unless-stopped 
  -p 1883:1883 
  -v /srv/mosquitto/config:/mosquitto/config 
  -v /srv/mosquitto/data:/mosquitto/data 
  -v /srv/mosquitto/log:/mosquitto/log 
  eclipse-mosquitto:2
# Configuración en /srv/mosquitto/config/mosquitto.conf
listener 1883
allow_anonymous false
password_file /mosquitto/config/passwd

Si el container arranca pero los clientes no se pueden conectar, casi siempre es porque mosquitto.conf no incluye la directiva listener 1883 o porque allow_anonymous false está activado pero no generaste el passwd con mosquitto_passwd -c /mosquitto/config/passwd usuario. El path /mosquitto/config es interno al container; el passwd tiene que estar en /srv/mosquitto/config/passwd en el host.

Por qué MQTT es tan usado

• Pub/sub: cualquier device puede subscribirse a “casa/luces/cocina” y recibir updates cuando alguien cambia el estado.
• Retained messages: el último estado queda guardado, los nuevos subscribers lo reciben.
• QoS: 3 niveles de garantía de entrega.
• Ligero: corre en un Raspberry Pi sin drama.

En HASS, instalas la integración MQTT y configuras el broker. Después, cualquier device que publique a MQTT aparece como entidad.

Automatizaciones: el poder real

Una automatización es “si pasa X, entonces haz Y”. HASS las hace powerful porque X e Y pueden ser cualquier cosa.

Tipos de automatizaciones

1. Trigger-based: “cuando X pasa” → “hacemos Y”

2. Time-based: “todos los días a las 19:00” → “hacemos Y”

3. State-based: “si X está en estado Y por Z minutos” → “hacemos W”

4. Event-based: “cuando llega el evento MQTT tal” → “hacemos Y”

Ejemplos útiles (los más pedidos)

1. Luces que siguen el sol:

automation:
  - alias: "Luces living al atardecer"
    trigger:
      - platform: sun
        event: sunset
        offset: "-00:30:00"  # 30 min antes
    action:
      - service: light.turn_on
        target:
          entity_id: light.living_room
        data:
          brightness_pct: 80
          color_temp_kelvin: 2700

2. Calefacción inteligente:

automation:
  - alias: "Encender AC si está caluroso"
    trigger:
      - platform: numeric_state
        entity_id: sensor.living_temp
        above: 26
        for:
          minutes: 5
    action:
      - service: climate.turn_on
        target:
          entity_id: climate.living_ac
      - service: climate.set_temperature
        target:
          entity_id: climate.living_ac
        data:
          temperature: 23
          hvac_mode: cool

3. Alerta si se abre la puerta y no hay nadie:

automation:
  - alias: "Alerta puerta abierta"
    trigger:
      - platform: state
        entity_id: binary_sensor.front_door
        to: "on"
        for:
          minutes: 10
    condition:
      - condition: state
        entity_id: person.tu-usuario
        state: "home"
        match: "any"  # NOT operator
    action:
      - service: notify.telegram
        data:
          message: "La puerta principal lleva 10 minutos abierta"

4. Modo vacaciones (random presence):

automation:
  - alias: "Luces random para simular presencia"
    trigger:
      - platform: time
        at: "20:00:00"
    condition:
      - condition: state
        entity_id: input_boolean.vacation_mode
        state: "on"
    action:
      - delay:
          minutes: "{{ range(0, 60) | random }}"
      - service: light.turn_on
        target:
          entity_id: light.living_room

5. Dashboard nocturno automático:

automation:
  - alias: "Modo noche a las 23:00"
    trigger:
      - platform: time
        at: "23:00:00"
    action:
      - service: scene.turn_on
        target:
          entity_id: scene.noche
      - service: light.turn_off
        target:
          entity_id:
            - light.kitchen
            - light.bathroom

Dashboards (la UI)

HASS viene con un dashboard básico. Para algo bonito y útil, armas tú:

Estructura recomendada

• Overview principal: lo que más usas día a día (luces, clima, música)
• Por ambiente: cocina, living, dormitorio, garage
• Energía: dashboard de consumo con gráficas
• Seguridad: cámaras, sensores, alertas
• Administración: updates, add-ons, logs

Tarjetas útiles

• Entities card: lista simple de entidades
• Glance card: grid compacto
• Button card (custom, HACS): botones customizables con iconos, colores, acciones
• Mushroom card (custom, HACS): la más popular en 2026, moderna y limpia
• Apexcharts card: gráficas con histórico
• Mini graph card: trends rápidos en formato compacto

Ejemplo de dashboard moderno

type: vertical-stack
cards:
  - type: weather-forecast
    entity: weather.casa
  - type: glance
    entities:
      - entity: light.living_room
      - entity: climate.thermostat
      - entity: switch.kitchen_plug
  - type: button
    entity: scene.movie_night
    name: Modo Película
    icon: mdi:movie
    tap_action:
      action: call-service
      service: scene.turn_on
      target:
        entity_id: scene.movie_night

HACS: la tienda de integraciones de la comunidad

HACS (Home Assistant Community Store) es el “apt de HASS”: repositorio de integraciones, tarjetas y temas hechos por la comunidad.

Instalación:

1. Install HACS via Settings → Add-ons → Add HACS repository (en HAOS) o manual en Container

2. Restart HASS

3. Ya aparece en el menú lateral

Con HACS instalas: Mushroom cards, button-card, mini-graph-card, alexa media player (custom), Spotify custom, etc.

Energía: el dashboard que justifica el homelab

Una de las features más potentes de HASS 2026 es el Energy Dashboard. Te dice en tiempo real y con histórico cuánto consumís, de dónde viene (solar vs red), y qué aparatos gastan más.

Setup:

1. Settings → Dashboards → Energy

2. configura grid consumption (sensor principal del medidor)

3. configura solar production (si tienes paneles)

4. configura devices individuales (Shelly EM, smart plugs con medición)

5. espera 24-48h para acumular datos

6. Disfrutá ver que tu AC gasta más que todo lo demás combinado

Seguridad y respaldos

Backups

HAOS incluye backup automático completo (config + DB). configura en Settings → System → Backups para que vaya a:

• Google Drive (oficial)
• Dropbox
• Un SMB/NFS share de tu NAS
• Google Cloud Storage
• O el método antiguo de copiar /config a disco externo

Regla: backup antes de cada update grande, y al menos 1 backup mensual automático.

Actualizaciones

HASS avisa cuando hay updates. La mayoría son seguras (parches de seguridad, bugfixes). Las mayores (1.x → 2.x) pueden romper integraciones que no se actualizaron.

Tip: leé las release notes antes de actualizar. Si una integración crítica para ti dice “breaking change”, espera 1-2 semanas a que la comunidad reporte issues.

Exposición a Internet (NO recomendado)

HASS tiene un servicio de nube pago (Nabu Casa, ~6.5 USD/mes) que permite acceso remoto sin abrir puertos. Si quieres hacerlo gratis, montá un tunnel con Cloudflare Tunnel o Tailscale.

Nunca abras el puerto 8123 directamente a Internet. Es un blanco constante de bots.

Hardware útil para empezar (presupuesto 200 USD)

• Raspberry Pi 5 (8 GB) + SSD NVMe HAT + SSD 256 GB: ~150 USD
• SONOFF Zigbee 3.0 USB Dongle Plus-E: 25 USD
• 5 sensores de puerta/ventana Zigbee (Sonoff SNZB-04 o Aqara): 5×8 = 40 USD
• 2 sensores de temperatura/humedad (Sonoff SNZB-02): 2×8 = 16 USD
• 1 smart plug con medición (Shelly Plug S o Nous A1T): 12 USD

Total: ~240 USD. Con eso ya tienes un HASS funcional con Zigbee, monitoreo de puertas, temperatura, y 1 toma inteligente.

Errores comunes de principiante

1. Comprar dispositivos solo-cloud: siempre verifica que tengan API local o integración oficial. Buscá “home assistant compatibility” antes de comprar.

2. Mezclar Zigbee con Wi-Fi smart home pensando que “todo es compatible”. No, no lo es. Cada protocolo es su mundo.

3. Updates sin leer release notes: te rompen integraciones. espera unos días.

4. Sobre-automatizar: empezar con 20 automatizaciones que disparan en cualquier cosa termina en “mi casa tiene más opiniones que yo”. Empezá con 3-4 útiles y agregá de a una.

5. Ignorar la energía: el dashboard de energía es el que más impacto tiene en tu factura. Configuralo apenas puedas.

6. No documentar nada: cuando tengas 30 dispositivos, no vas a recordar qué es cada uno. Nombrá bien y agrupá en areas desde el día 1.

Recursos para seguir

• home-assistant.io/docs: documentación oficial, excelente
• community.home-assistant.io: foro oficial, muy activo
• r/homeassistant en Reddit: comunidad enorme, troubleshooting rápido
• YouTube: Everything Smart Home, Home Assistant Guy, JuanMTech
• awesome-home-assistant en GitHub: lista curada de recursos

Home Assistant no es solo un proyecto de domótica, es un estilo de vida de “tu casa, tus reglas”. Una vez que lo tienes funcionando y ves que tu casa reacciona al sol, a tu presencia, a la temperatura, sin mandarle nada a nadie, no vuelves atrás.

---

Preguntas frecuentes

Lee también

• Guía Fedora 44: Novedades, Instalación y Upgrade para Sysadmins Linux
• Configura VLANs en Linux con nmcli: Guía paso a paso para sysadmins
• Protege tu SSH: Guía esencial para configurar Fail2ban en Linux
• Guía Definitiva: Configura Kubernetes con kubeadm en Ubuntu para Sysadmins Linux
• Configura Prometheus y Grafana: Guía DevOps para SysAdmins Linux