Instalación de Home Assistant en Raspberry Pi (Parte 1)

Antes de nada decir que esta no es la típica instalación simple de HA, este tutorial se centra en la instalación de Home Assistant Core y el software relacionado mas usado en una Raspberry Pi con SSD, aunque puede perfectamente instalarse en una SD.

El hecho de montar un SSD en la Raspberry es porque las típicas tarjetas SD se corrompen fácilmente por la alta tasa de lectura / escritura que deben soportar, cambié a este sistema tras haber tenido fallos con 3 tarjetas SD y desde entonces no he tenido ningún problema.

En este tutorial se explica como instalar y configurar Home Assistant Core y varias aplicaciones relacionadas en Docker con docker-compose de forma sencilla, así como un método fácil para actualizarlas cuando sea necesario.

El tutorial está abierto a modificaciones, correcciones o propuestas, simplemente ábreme un chat privado por Telegram y coméntame lo que quieras.

Hardware necesario

El hardware necesario es simple, una Raspberry Pi 4, un SSD, un adaptador usb para el SSD, una tarjeta micro-SD y un kit para alimentar y refrigerar la rpi.

Probablemente habrá cientos de opciones distintas, pero no todas funcionan bien, sobretodo en lo que se refiere a la combinación rpi-ssd.
Los elementos recomendados se eligieron tras investigar las mejores opciones de compatibilidad para tener un buen rendimiento del sistema, son los que tengo montados actualmente y no me han dado ningún problema.

La fuente de alimentación incluida en el kit de la caja para la raspberry NO es la original de Raspberry, pero no me ha dado ningún problema de fallos de alimentación con el ssd recomendado.

Nota: La Raspberry Pi4 está ahora disparada de precio, si puedes espera un poco a que vuelva a normalizarse.

• Raspberry Pi 4 de al menos 4Gb de memoria ram.
• Disco duro SSD, recomiendo el Kingston de 240Gb.
• Tarjeta SD para la primera instalación.
• Caja para el SSD con conexión usb, recomiendo UGREEN Caja Disco Duro Externo 2,5"
• Caja para la raspberry con refrigeración activa y fuente de alimentación de 3 amperios.

Aplicaciones a instalar

La siguiente imagen muestra las aplicaciones que se van a instalar en este tutorial, no todas son imprescindibles y probablemente habrá algunas interesantes que no están incluidas.

Es posible personalizar la instalación si no se quiere usar alguna de ellas simplemente eliminándolas del archivo docker-compose.yaml que veremos mas adelante.

• Home Assistant es el cerebro de todo el sistema, permite integrar todos los dispositivos domóticos que tengamos instalados y actuar sobre ellos.
• Node-RED, herramienta de programación visual. Muestra visualmente las relaciones y funciones, y permite programar flujos y automatizaciones sin tener que escribir ni una sola línea de código. Muy útil para crear automatizaciones complejas.
• InfluxDB, base de datos de series de tiempo, será quien se encargue de almacenar los datos de larga duración que nos interese tener en el sistema.
• Grafana, complemento imprescindible para crear gráficas, estadísticas y analizar datos almacenados.
• Chronograf, panel de control para InfluxDB, permite poder interactuar mas amigablemente con la base de datos, ya que InfluxDB no tiene un entorno gráfico.
• Mosquitto, servidor de mensajes MQTT mas utilizado en domótica, facilita la comunicación e integración de dispositivos inteligentes en nuestro sistema domótico.
• MariaDB, base de datos derivada de MySQL, la usaremos como alternativa a la base de datos de HA por ser mas robusta y rápida.
• PhpMyAdmin, panel de control para las bases de datos MySQL / MariaDB.
• Nginx-Proxy-Manager, proxy para gestionar el acceso remoto y certificados para acceder a HA desde fuera de nuestra red de forma segura.
• Configurator, addon de HA que permite editar nuestros archivos de configuración directamente desde la interfaz.
• Portainer, gestor gráfico de contenedores que nos permitirá entre otras cosas, actualizarlos.

Nota: Se incluyen instrucciones de como instalar y configurar los diferentes programas, pero queda fuera de este tutorial explicar como se usa cada uno de ellos.

1- Primera instalación en MicroSD

Empezaremos por hacer la instalación del sistema operativo en la tarjeta SD para poder activar el arranque de la Raspberry desde el SSD, a veces este paso no es necesario, pero si lo hacemos nos aseguramos de que funcione correctamente.

Para ello nos descargaremos primero el programa Raspberry Pi Imager desde https://www.raspberrypi.org/software/

En nuestro sistema vamos a instalar y configurar todo por SSH sin necesidad de tener el entorno gráfico instalado, por ello elegiremos la versión Lite de Raspbian.
Para grabar la imagen del SO introduciremos en el pc la tarjeta SD y ejecutaremos el programa Raspberry Pi Imager, seleccionando como sistema operativo Raspberry Pi OS (Other) -> Raspberry Pi OS Lite (32 bits) y en destino la unidad donde se encuentra la tarjeta SD.

Una vez grabada la imagen en la micro-SD, expulsamos la misma y la volvemos a introducir en el pc.
Crearemos en el directorio raíz de la SD un archivo vacío con el nombre "ssh" sin extensión. Esto nos permitirá conectarnos a la RPI por SSH directamente desde el primer arranque.

Hecho lo anterior, introducimos la tarjeta SD en la Raspberry, conectamos el cable de red, el de alimentación y la encendemos.

Para acceder a ella lo haremos mediante SSH con un programa llamado PuTTy (si no sabes como usarlo hay infinidad de guías en youtube).

Desde PuTTy abre una conexión SSH a la dirección IP de la Raspberry, puedes encontrar la IP desde el router o con un programa de escaneo de IP's como Advanced IP Scanner.

Cuando te conectes, el sistema te pedirá un nombre de usuario y contraseña, por defecto estos son:
Usuario: pi
Contraseña: raspberry

Comenzaremos por actualizar el sistema operativo con los dos comandos siguientes:
(Nota: el ~$ indica el prompt de la consola de la raspberry, no escribirlo)

~$ sudo apt update
~$ sudo apt full-upgrade

Y reiniciaremos la raspberry con el comando:

~$ sudo reboot

La conexión SSH de PuTTy se habrá cerrado, abrimos una nueva conexión, nos logueamos e instalaremos la última versión del bootloader y del firmware con el comando:

~ $ sudo rpi-eeprom-update -d -a

En el caso más que probable de que ya tengas las últimas versiones el comando no hará nada. Obtendremos algo asi:

BCM2711 detected
Dedicated VL805 EEPROM detected
BOOTLOADER: up-to-date
CURRENT: jue sep 3 12:11:43 UTC 2020 (1599135103)
LATEST: jue sep 3 12:11:43 UTC 2020 (1599135103)
FW DIR: /lib/firmware/raspberrypi/bootloader/critical
VL805: up-to-date
CURRENT: 000138a1
LATEST: 000138a1

Si vemos la salida del comando podemos confirmar que tenemos instalada la última versión del firmware y del bootloader. Si tenéis esta versión, o una versión más actual, la Raspberry Pi debe arrancar desde una unidad SSD sin ningún tipo de problema.

Volvemos a reiniciar la raspberry con el comando:

~$ sudo reboot

Una vez reiniciada tecleamos el siguiente comando en la terminal para abrir el menú de configuración de la RPI:

~$ sudo raspi-config

Dentro de ese menú iremos a Advanced Options -> Boot Order seleccionaremos la opción USB Boot y pulsamos enter. De esta forma si no hay tarjeta MicroSD insertada en la Raspberry se intentará arrancar desde la unidad de almacenamiento SSD.

2- Instalación en SSD

Con la RPI preparada para arrancar desde SSD, realizaremos los mismos pasos de grabación de imagen del sistema operativo que hemos hecho anteriormente, pero esta vez directamente en el SSD, para ello simplemente conéctalo a través de USB al pc y repite los pasos anteriores, no te olvides de crear el archivo vacío "ssh" en la raíz del SSD.

Con el sistema operativo grabado en la unidad SSD ha llegado la hora de la verdad. Para arrancar la Raspberry Pi con la unidad SSD seguiremos los siguientes pasos:

- Apagamos y desenchufamos la Raspberry Pi.
- Sacamos la tarjeta MicroSD.
- Conectamos el disco SSD en la RPI a uno de los puertos USB 3.0
- Finalmente arrancamos la Raspberry Pi, volvemos a buscar su IP (probablemente será la misma) y conectaremos por SSH con PuTTy.

Si la Raspberry no arranca, da problemas o no puedes conectarte, contáctame por Telegram para ver donde está el problema.

3- Configurar Raspberry Pi

Volvemos a conectar a la RPI por SSH y lo primero será actualizar el sistema operativo a la última versión:

~$ sudo apt update
~$ sudo apt full-upgrade
~$ sudo apt clean

Aprovechando que tenemos un flamante SSD de 240GB, aumentaremos el tamaño de la memoria virtual (SWAP) para permitir que la RAM del sistema pueda mover a ella los procesos menos utilizados. Por defecto es de 100Mb y vamos a ampliarlo a 1GB.
Para ello editaremos el archivo de configuración de la memoria swap:

~$ sudo nano /etc/dphys-swapfile

Buscaremos CONF_SWAPSIZE=100 y lo reemplazaremos por:

CONF_SWAPSIZE=1024

Guardamos el archivo modificado y reiniciamos la memoria swap con el comando:

~$ sudo service dphys-swapfile restart

En nuestra instalación no vamos a necesitar tener introducida una tarjeta SD en la RPI, pero la raspberry va a estar continuamente comprobando si hay una tarjeta en la ranura.
Para evitarlo y reducir un poco el consumo, editaremos el fichero de configuración boot/config.txt con el siguiente comando:

~$ sudo nano /boot/config.txt

Añade al final del mismo lo siguiente y guarda los cambios:

# Evitar comprobacion de SD-CARD
dtparam=sd_poll_once

Por último nos faltan algunas configuraciones básicas del sistema, para ello, entramos de nuevo en la configuración de la RPI con el comando:

~$ sudo raspi-config

Y empezaremos actualizando la herramienta de configuración a la última versión seleccionando la opción:
8 Update

Una vez actualizada, cambiaremos la contraseña por defecto de la raspberry seleccionando en el menú:
1 System Options -> S3 Password

Cambiaremos el hostname por defecto de la raspberry, para ello iremos al menú:
1 System Options -> S4 Hostname
puedes poner por ejemplo Home-Assistant.

Activaremos la opción de acceso SSH para conectar remotamente por consola, no sería necesario al haber creado anteriormente el archivo "ssh" en el directorio raíz, pero si se habilita puedes borrarlo sin problemas, para activarlo lo haremos desde:
3 Interfacing Options -> P2 SSH

Configuraremos el idioma por defecto desde:
5 Localisation Options -> I1 Change Locale
activando la opción es_ES.UTF-8 y seleccionándola por defecto.

Cambiaremos la zona horaria desde:
5 Localisation Options -> I2 Change Timezone
en nuestro caso será Europa/Madrid

Y por último, aunque no lo vamos a usar, cambiaremos el país de la Wifi a ES:
5 Localisation Options -> I4 Change Wi-fi Country

Una vez hechas las configuraciones, reiniciamos la raspberry:

~$ sudo reboot

4- Configurar IP Estática

En este paso vamos a configurar la raspberry con IP estática, aunque también podríamos hacerlo desde el router asignándole una IP fija.

Para ello primero verificaremos cual es nuestra interfaz ethernet con el siguiente comando:

~$ ifconfig

Eso nos mostrará algo como esto:

Donde podemos ver que nuestra interfaz ethernet es eth0

Ahora editamos el archivo de configuración con el comando:

~$ sudo nano /etc/dhcpcd.conf

Y añadiremos lo siguiente al final teniendo en cuenta tu interfaz, la IP a hacer fija, la puerta de enlace (IP del router) y los dns (IP del router y/0 DNS de google), en el ejemplo vamos a asignar la ip estática 192.168.1.30:

# Configuracion de IP estatica
interface eth0
static ip_address=192.168.1.30/24
static routers=192.168.1.1
static domain_name_servers=192.168.1.1, 8.8.8.8

Guardamos el archivo y reiniciamos la RPI con el comando que ya hemos usado otras veces, y si todo ha ido bien volveremos a conectar por SSH pero a la IP que hemos asignado como estática, en nuestro ejemplo 192.168.1.30

5- Desactivar Wifi Y Bluetooth

Salvo que lo necesites por algún motivo, no vamos a utilizar la wifi ni bluetooth de la raspberry, por ello lo mejor es desactivarlos para reducir el consumo y evitar posibles problemas de alimentación.
Para ello simplemente introduciremos los siguientes comandos:

~$ sudo rfkill block wifi
~$ sudo rfkill block bluetooth

En caso de que por algún motivo necesites volver a activarlos, puedes hacerlo con lo siguiente:

~$ sudo rfkill unblock wifi
~$ sudo rfkill unblock bluetooth

Por último, siempre que hagamos cambios importantes, reiniciamos la raspberry:

~$ sudo reboot

6- Servidor Samba

Pese a que vamos a instalar todo nuestro sistema en Docker (contenedores), nos va a ser muy útil tener instalado previamente un servidor Samba para acceder a las carpetas de la rpi desde cualquier PC de nuestra red local, nos ayudará a realizar esta instalación y posteriormente lo usaremos para editar / guardar nuestra configuración.

Antes de instalar es mejor actualizar todos los paquetes y complementos, esta vez lo haremos con un solo comando:

~$ sudo apt update && sudo apt upgrade

Para instalar Samba lo haremos con el siguiente comando:

~$ sudo apt install samba samba-common-bin

Y posteriormente lo configuraremos editando el archivo smb.conf:

~$ sudo nano /etc/samba/smb.conf

En ese archivo vamos a configurar las carpetas compartidas a las que podremos acceder desde cualquier PC en nuestra red local, en principio solo daremos acceso a las carpetas donde vamos a tener la configuración de nuestra instalación, que será por un lado la carpeta IOT que crearemos dentro de nuestro directorio principal y la carpeta homeassistant que será la que contenga la configuración de Home Assistant.

En el archivo smb.conf que tenemos abierto añadimos al final:

# Directorio de IOT
[IOT]
comment = Directorio IOT
path = /home/pi/iot
browseable = yes
writeable = yes
valid users = pi, root
create mask = 0644
directory mask = 0755
public = no
force user = root

# Directorio de Home Assistant
[HomeAssistant]
comment = Directorio Home Assistant
path = /home/pi/iot/homeassistant
browseable = yes
writeable = yes
valid users = pi, root
create mask = 0644
directory mask = 0755
public = no
force user = root

Guardamos, cerramos el archivo y configuramos la contraseña de acceso con el siguiente comando:

~$ sudo smbpasswd -a pi

Una vez asignada la contraseña, necesitamos reiniciar samba para aplicar los cambios:

~$ sudo systemctl restart smbd

También puedes detener o iniciar el sistema cuando lo desees, incluso puedes desactivarlo por defecto si no vas a usarlo habitualmente.
Iniciar: sudo systemctl start smbd
Detener: sudo systemctl stop smbd
Reiniciar: sudo systemctl restart smbd
Desactivar inicio al arrancar: sudo systemctl disable smbd
Activar inicio al arrancar: sudo systemctl enable smbd

Reiniciamos la raspberry y volvemos a conectar para comprobar que todo va bien:

~$ sudo reboot

Con esto hecho, podrás acceder desde cualquier PC de tu red local a las carpetas compartidas de la RPI, en caso de que no veas el equipo en el explorador de archivos, escribe en la barra de direcciones \\<IP_DE_LA_RASPBERRY>

Si lo has intentado posiblemente de dará un error, ya que las carpetas que hemos compartido no están todavía creadas, lo haremos un poco mas adelante.

7- Docker y Docker compose

Docker es un gestor de contenedores, y un contenedor es, por decirlo de algún modo, un paquete que junta todo el código necesario de un programa para que pueda ser ejecutado de forma independiente, lo que nos permite poder iniciarlo, detenerlo o borrarlo sin que afecte al resto de programas que tengamos instalados.

Como siempre, hacemos un update && upgrade por si necesitamos actualizar algún archivo:

~$ sudo apt update && sudo apt upgrade

A continuación realizaremos la instalación mediante un script que nos permite hacerlo con un único comando:

~$ curl -sSL https://get.docker.com | sh

Esperamos a que termine el proceso y creamos el grupo docker, aunque es posible que te diga que el grupo ya existe:

~$ sudo groupadd docker

Añadimos al usuario pi al grupo docker:

~$ sudo usermod -aG docker pi

Y podemos comprobar la versión de docker con lo siguiente, en nuestro caso nos dice que hemos instalado la 20.10.10:

~$ docker -v
Docker version 20.10.10, build b485636

Ahora instalaremos docker-compose, un complemento de docker que nos permite poder gestionar varios contenedores a la vez con un solo archivo *.yaml.

Para ello, escribimos en la cónsola:

~$ sudo apt install -y python3-pip libffi-dev python-backports.ssl-match-hostname
~$ sudo pip3 install docker-compose

Podremos ver si todo ha ido bien y la versión instalada con:

~$ docker-compose --version
docker-compose version 1.29.2, build unknown

Como en los pasos anteriores, reiniciamos y comprobamos que la RPI arranca correctamente:

~$ sudo reboot

8- Directorios y docker-compose.yaml

Antes de nada, como en pasos anteriores, actualizamos por si la instalación de docker requiere alguna actualización adicional:

~$ sudo apt update && sudo apt upgrade

Para tener todo bien organizado, vamos a crear un directorio de trabajo dentro de nuestro home de la raspberry, y dentro del mismo los diferentes directorios que necesitaremos para los programas que vamos a instalar, en mi caso le he dado el nombre de "iot":

~$ sudo mkdir iot
~$ sudo chown pi:pi iot
~$ cd iot
~/iot $ mkdir configurator
~/iot $ mkdir chronograf
~/iot $ mkdir grafana
~/iot $ mkdir homeassistant
~/iot $ mkdir influxdb
~/iot $ mkdir influxdb/backups
~/iot $ mkdir influxdb/database
~/iot $ mkdir mariadb
~/iot $ mkdir mariadb/mysql
~/iot $ mkdir mosquitto
~/iot $ mkdir mosquitto/config
~/iot $ mkdir mosquitto/data
~/iot $ mkdir mosquitto/log
~/iot $ mkdir nginx
~/iot $ mkdir nginx/data
~/iot $ mkdir nginx/letsencrypt
~/iot $ mkdir node-red
~/iot $ mkdir portainer

Con la estructura de carpetas hecha, crearemos el archivo docker-compose.yaml que nos va a hacer mas fácil la instalación de todo:
(Nota: como hemos instalado anteriormente el servidor samba, también puedes crear este archivo desde un pc usando el explorador de archivos, en ese caso te recomiendo crearlo con un editor de texto como Notepad++)

~/iot $ sudo nano docker-compose.yaml

Pegaremos en el lo siguiente, ten en cuenta que debes modificar la contraseña de MYSQL_ROOT_PASSWORD por la de tu preferencia:

version: '2.1'
services:
portainer:
container_name: portainer
image: portainer/portainer-ce:latest
ports:
- 9000:9000
volumes:
- /home/pi/iot/portainer:/data
- /var/run/docker.sock:/var/run/docker.sock
- /etc/localtime:/etc/localtime:ro
restart: always

influxdb:
container_name: influxdb
image: influxdb:1.8.9
ports:
- 8086:8086
volumes:
- /home/pi/iot/influxdb/influxdb.conf:/etc/influxdb/influxdb.conf
- /home/pi/iot/influxdb/database:/var/lib/influxdb
- /home/pi/iot/influxdb/backups:/backups
- /etc/localtime:/etc/localtime:ro
restart: unless-stopped

mariadb:
container_name: mariadb
image: yobasystems/alpine-mariadb:10.4.17-arm32v7
ports:
- 3306:3306
environment:
MYSQL_ROOT_PASSWORD: root
MYSQL_CHARSET: utf8mb4
MYSQL_COLLATION: utf8mb4_general_ci
volumes:
- /home/pi/iot/mariadb/mysql:/var/lib/mysql
- /home/pi/iot/mariadb/logs:/var/lib/mysql/mysql-bin
- /etc/localtime:/etc/localtime:ro
restart: unless-stopped

mosquitto:
container_name: mosquitto
image: eclipse-mosquitto:latest
user: "1000:1000"
ports:
- 1883:1883
- 9001:9001
volumes:
- /home/pi/iot/mosquitto/config:/mosquitto/config
- /home/pi/iot/mosquitto/data:/mosquitto/data
- /home/pi/iot/mosquitto/log:/mosquitto/log
- /etc/localtime:/etc/localtime:ro
restart: unless-stopped

homeassistant:
container_name: homeassistant
image: homeassistant/raspberrypi4-homeassistant:stable
network_mode: "host"
privileged: true
volumes:
- /home/pi/iot/homeassistant:/config
- /etc/localtime:/etc/localtime:ro
restart: unless-stopped
depends_on:
- influxdb
- mariadb
- mosquitto

nodered:
container_name: node-red
image: nodered/node-red:latest
volumes:
- /home/pi/iot/node-red:/data
- /etc/localtime:/etc/localtime:ro
ports:
- 1880:1880
restart: unless-stopped
depends_on:
- homeassistant

grafana:
container_name: grafana
image: grafana/grafana:latest
user: "1000"
ports:
- 4000:3000
volumes:
- /home/pi/iot/grafana:/etc/grafana
- /home/pi/iot/grafana:/var/lib/grafana
- /etc/localtime:/etc/localtime:ro
restart: unless-stopped
depends_on:
- influxdb

chronograf:
container_name: chronograf
image: chronograf:latest
ports:
- 8888:8888
volumes:
- /home/pi/iot/chronograf:/var/lib/chronograf
- /etc/localtime:/etc/localtime:ro
environment:
- INFLUXDB_URL=http://influxdb:8086
- PUID=1000
- PGID=1000
restart: unless-stopped
depends_on:
- influxdb

nginx:
container_name: nginx-proxy-manager
image: jc21/nginx-proxy-manager:latest
ports:
- 80:80
- 81:81
- 443:443
volumes:
- /home/pi/iot/nginx/data:/data
- /home/pi/iot/nginx/letsencrypt:/etc/letsencrypt
- /etc/localtime:/etc/localtime:ro
restart: unless-stopped

phpmyadmin:
container_name: phpmyadmin
image: ebspace/armhf-phpmyadmin
ports:
- "90:80"
environment:
- PMA_HOST=mariadb
volumes:
- /etc/localtime:/etc/localtime:ro
restart: unless-stopped
depends_on:
- mariadb

hass-configurator:
container_name: configurator
image: causticlab/hass-configurator-docker:latest
privileged: true
ports:
- "3218:3218/tcp"
volumes:
- /home/pi/iot/configurator:/config
- /home/pi/iot/homeassistant:/hass-config
- /etc/localtime:/etc/localtime:ro
restart: unless-stopped

Guardamos los cambios, cerramos el archivo y descargamos las imágenes de nuestros contenedores con:

~/iot $ docker-compose pull

Esto tardará un ratito en función de la velocidad de tu red, así que toca esperar.

Mientras tanto, si no lo has hecho ya, recuerda que puedes acceder al directorio iot desde el explorador de archivos de tu pc.

Cuando tengas todas las imágenes descargadas, deberías ver algo como esto

Ha llegado el momento de descansar un poco, tómate una cervecita, relajaté y pilla fuerzas para continuar, que aún tenemos para un rato.

Cuando estés listo, vamos a la parte 2 de la instalación.