Der Raspberry Pi hat sich in den letzten Jahren von einem kleinen Minicomputer für Bastler und Nerds zu einem vollwertigen und verhältnismäßig leistungsfähigem Rechner entwickelt. Nicht wenige Anwender freuen sich darüber, für wenig Geld einen vollwertigen Miniserver zu bekommen. 

Beim Einsatz des Raspberry Pi für den produktiven Einsatz als Server ist zu beachten, dass auch die angeschlossene Hardware hierfür geeignet sein sollte. Ein Gehäuse, bei dem er Pi überhitzt, ist genau so schädlich wie eine SD-Karte als Festplatte, da diese nicht für den Dauerbetrieb geeignet ist.

Durch den Einsatz rund um die Uhr gibt es sehr viele Schreib- und Lesevorgänge auf der SD-Karte. Hierfür sind diese Karten aber nur bedingt geeignet. Bei den ersten Raspberry Pi Generationen hatte ich sehr häufig Datenverlust, weil die SD-Karte den Geist aufgegeben hat. 

Inzwischen läuft auf dem Pi bei mir eine Instanz von Home Assistant. Hier werden rund um die Uhr Daten aufgezeichnet und Automationen ausgeführt. Auch andere Dienste laufen hier, von denen ich keinen Ausfall erleiden möchte. 

Außerdem sind die Lese- und Schreibgeschwindigkeiten einer SD-Karte sehr limitiert. Eine moderne SSD ist um ein Vielfaches schneller. Das wird vor allem dann deutlich, wenn man in Home Assistant Datenmengen abfragt, z.B. Diagramme anzeigt. Ladezeiten von mehreren Sekunden sind dann keine Seltenheit.

Die Konsequenz daraus ist, dass ich den Raspberry von einer SD-Karte auf eine SSD-Karte umziehen möchte. Dadurch, dass hier ein Produktivsystem läuft, möchte ich alle Installationen, Daten und Einstellungen möglichst verlustfrei auf das neue Medium umziehen. Wie ich das gemacht habe, erfahrt hier in folgendem Tutorial.

Schritt 0: Geschwindigkeit testen (optional)

Um einen Geschwindigkeitsvorteil in messbare Größen zu fassen, kann man als Referenz einen Geschwindigkeitstest der SD-Karte machen. Mit dem folgenden Befehl werden Beispieldateien geschrieben. Der Befehl gibt aus, wie schnell die Geschwindigkeit dabei war. 

$ dd if=/dev/zero of=/tmp/speedtest1.img bs=20MB count=5
5+0 records in
5+0 records out
100000000 bytes (100MB, 95 MiB) copied, 11.9403 s, 8.4 MB/s

Wenn der Umzug fertig ist, kann man diesen Test wiederholen. Bei mir kam ich von ca. 8,4 MB/s Schreibgeschwindigkeit auf 168 MB/s. Das hat sich mal gelohnt!

Schritt 1: SSD erstmals anschließen

In meinem Fall handelt es sich um eine externe SSD, die über USB 3.0 angeschlossen wird. Nachdem ich sie angesteckt habe, prüfe ich ob sie rechtmäßig erkannt wird, indem ich den folgenden Befehl eingebe und in der Ausgabe nach der SSD suche.

$ lsblk

Schritt 2: Installation von RPi-clone

Auf Github gibt es ein kleines Projekt, das viele Funktionen beinhaltet. Das Programm kopiert den Inhalt der SD-Karte auf die SSD, sodass von ihr gebootet werden kann und alle Einstellungen vorhanden sind.

$ git clone https://github.com/billw2/rpi-clone.git
$ cd rpi-clone
$ sudo cp rpi-clone /usr/local/sbin/sys-clone
$ sudo cp rpi-clone-setup /usr/local/sbin/sys-clone-setup

Schritt 3: Services stoppen und Kopiervorgang starten

Am besten ist es, wenn kein Service mehr läuft und der Kopiervorgang ungestört durchlaufen kann. Daher erst prüfen, was alles läuft, danach einzeln beenden

$ sudo systemctl stop cron
$ sudo systemctl stop nginx
$ sudo systemctl stop docker usw.

Schritt 4: Kopiervorgang starten

Aus dem Check von Schritt 1 kennen wir bereits die Bezeichnung der Festplatte. Auf diese müssen wir nun verweisen mit dem Befehl:

$ rpi-clone sda

Der Wizard hält zunächst an und berichtet uns über den Zustand des Systems. Wenn alles korrekt ist, kann der Vorgang mit der Eingabe von „yes“ gestartet werden.

Schritt 5: Raspberry Pi herunterfahren und von SSD booten

Nach Ende des Kopiervorgangs fährt man den Raspberry Pi herunter.

$ sudo shutdown now

Anschließend von der Stromversorgung trennen, die SD-Karte entfernen, und die Spannungsversorgung wieder herstellen. Jetzt bootet der Raspberry von SSD und ist sehr viel schneller.

The post Raspberry Pi: Umzug von SD-Karte auf SSD in wenigen Schritten first appeared on bejonet - Linux | Smart Home | Technik.

Ein MQTT-Broker ist die Schnittstelle zwischen vielen IoT-Sensoren und Geräten, die Sensordaten auswerten oder Aktoren steuern. Das MQTT-Protokoll ist offen und sehr weit verbreitet. Es findet in der Industrie Anwendungen, ist aber auch in Smart Homes ist MQTT weit verbreitet.
MQTT ist ein sehr schlankes und schnelles Protokoll. Es wird in Anwendungen mit niedriger Bandbreite gerne angewendet.

MQTT funktioniert, grob gesagt, folgendermaßen: IoT-Geräte können Nachrichten versenden, die von anderen IoT-Geräten empfangen werden. Die Vermittlungsstelle ist ein sogenannter MQTT-Broker. Dieser empfängt die Nachrichten von den Clients. Gleichzeitig können diese Nachrichten von anderen Clients abonniert werden. Die Nachrichten werden in sog. Topics eingestuft, die hierarchisch angeordnet sind, z.B. Wohnzimmer/Klima/Luftfeuchtigkeit.

Home Assistant, oder ein anderer Client, kann diesen Topic abonnieren und den Nachrichteninhalt („Payload„) auswerten (z.B. 65%).

Home Assistant OS vs. Home Assistant Container

In Home Assistant OS und Supervisor gibt es ein Addon, das einen MQTT-Broker installiert. Das ist sehr einfach, komfortabel und funktioniert wohl recht zurverlässig. In den Installationsarten Home Assistant Container und Core gibt es diese Möglichkeit nicht. Hier muss man manuell einen MQTT-Broker aufsetzen.

In diesem Artikel beschäftige ich mich damit, wie man den MQTT-Brocker Mosquitto über Docker installiert. Anschließend zeige ich, wie man die Konfigurationsdatei gestaltet und eine Verbindung zu Home Assistant herstellt. Das Ergebnis ist dann ungefähr so, als hätte man das Addon installiert. Los gehts!

Schritt für Schritt: MQTT-Broker Mosquitto mit Docker installieren

Als MQTT-Broker verwende ich die weit verbreitete Software Mosquitto von Eclipse. Dieser wird auch von Home Assistant bevorzugt und ist derjenige Broker, den das Addon installieren würde.
Für diese Anleitung wird vorausgesetzt, dass Docker bereits installiert ist und eine SSH-Verbindung zum Server hergestellt werden kann.

Schritt 1: Zunächst erstellen wir ein paar Ordner, die wir später benötigen. Mosquitto wird später so konfiguriert, dass in diese Ordner alle wichtigen Dateien abgelegt werden. Dadurch kann man auf dem Filesystem des Servers Mosquitto konfigurieren und beobachten.

$ mkdir mosquitto
$ mkdir mosquitto/config 
$ mkdir mosquitto/data 
$ mkdir mosquitto/log

Schritt 2: Nun wird die Konfigurationsdatei für Mosquitto erstellt. Über diese Datei kann man das Verhalten von Mosquitto steuern.

$ nano config/mosquitto.conf

persistence true
persistence_location /mosquitto/data/
log_dest file /mosquitto/log/mosquitto.log
log_dest stdout
password_file /mosquitto/config/mosquitto.passwd
allow_anonymous false
listener 1883

Schritt 3: Mit dem folgenden Befehl lädt man sich das aktuelle Image von Eclipse Mosquitto auf den Server.

$ docker pull eclipse-mosquitto

Schritt 4: Mit dem folgenden Befehl wird der Docker-Container gestartet. Das ist der Schlüsselmoment, jetzt muss alles klappen.

$ docker run -it -p 1883:1883 -p 9001:9001 --name mosquitto -v /home/pi/mosquitto/config:/mosquitto/config -v /home/pi/mosquitto/data:/mosquitto/data -v /home/pi/mosquitto/log:/mosquitto/log eclipse-mosquitt

Die Flags bedeuten hierbei folgendes:

• -p 1883:1883 Der genannte Port ist die Standardeinstellung für MQTT. Alles was auf diesen Port am Server ankommt, wird in den Mosquitto-Container geleitet.
• -p 9001:9001 Über diesen Port laufen die Websocket-Anwendungen. Falls das nicht benötigt wird, kann man das weg lassen
• name mosquitto Über diesen kurzen Namen können wir den Docker-Container steuern
• -v <filesystem-Pfad>:<Container-Pfad> Die in Schritt 1 erstellten Ordner werden in den Container eingebunden

Wer lieber Docker Compose verwendet, trägt diesen Eintrag in seine *.yaml ein:

services:
    eclipse-mosquitto:
        stdin_open: true
        tty: true
        ports:
            - 1883:1883
            - 9001:9001
        restart: unless-stopped
        container_name: mosquitto
        volumes:
            - /home/pi/mosquitto/config:/mosquitto/config
            - /home/pi/mosquitto/data:/mosquitto/data
            - /home/pi/mosquitto/log:/mosquitto/log
        image: eclipse-mosquitto

Schritt 5: Checken, ob der Container ordnungsgemäß läuft. In der folgenden Liste sollte eine Zeile mit dem Mosquitto-Docker auftauchen. Dieser sollte außerdem „up“ sein. Falls nicht, nochmal versuchen den Container zu starten und kontrollieren, ob er läuft.

$ docker container ls -a
CONTAINER ID   IMAGE          COMMAND   CREATED        STATUS        PORTS    NAMES
xxxxxxxxx   eclipse-mosquitto "/init"   3 minutes ago   Up 2 minutes  [...]   mosquitto

Schritt 6: Sehr gut, der Container läuft. Es wird dringend empfohlen, den MQTT-Broker so abzusichern, dass nur angemeldete User darauf zugreifen können. Das ist ja schon in Schritt 2 in die Konfigurationsdatei geschrieben worden. Mit dem folgenden Befehl melden wir uns in der Shell innerhalb des Containers an und erstellen einen Benutzer. In diesem Beispiel mosquitto. Im Anschluss an diesen Befehl wird man zweimal gebeten, das Passwort für den User festzulegen. Ist das geschafft, läuft der MQTT-Broker auf dem Server. Herzlichen Glückwunsch!

$ docker exec -it sh // öffnet die Shell innerhalb des Dockers
mosquitto_passwd -c /mosquitto/config/mosquitto.passwd mosquitto

Optional Schritt 7: Den MQTT-Broker bindet man in Home Assistant ein, indem man auf Einstellungen → Geräte und Dienste → + Integration hinzufügen klickt. Im Suchfenster nach „MQTT“ suchen und die Zugangsdaten eingeben.
Die Server-Adresse findet man übrigens am schnellsten über ifconfig heraus.

The post MQTT-Broker Mosquitto als Docker Container installieren first appeared on bejonet - Linux | Smart Home | Technik.

Smart Homes sind in aller Munde. Bei Neubauten sowieso, aber auch bestehende Immobilien werden gerne zu so genannten Smart Homes umgerüstet. Den großen Markt teilen sich natürlich kommerzielle Anbieter, aber gerade auf der Softwareseite konkurrieren auch freie und open source Software um die Kunden. Die bekanntesten Teilnehmer im open source Bereich sind FHEM, OpenHAB und Home Assistant (früher bekannt als hass.io).

Diese Software soll verschiedene smarte Geräte vereinen, so dass sie alle unter einer Haube stecken. Anstatt jeweils eine Anwendung für die Heizung, das Licht und die Energieversorgung zu verwenden, soll die Software übergeordnet sein. Sie bildet damit die Schnittstelle zwischen den Geräten und mir.

Ich möchte mein Haus mit dem Home Assistant smart machen, bzw. einige der vorhandenen Komponenten dort einbinden. In diesem Artikel möchte ich zunächst auf die Installation von Home Assistant Container eingehen.

Unterschied zwischen Home Assistant und Home Assistant Container

Der mächtige Home Assistant wird gerne auf einem Raspberry Pi installiert. In der Regel verwendet man dafür gleich ein ganzes Image für das Betriebssystem. Das bedeutet, dass man statt des üblichen Raspbian das „Home Assistant Operating System“ installiert.

Der Vorteil liegt darin, dass man den Home Assistant in vollem Umfang nutzen kann. Der Nachteil ist, dass man über ein stark angepasstes OS verfügt. Möchte man noch weitere Software darauf laufen lassen, könnte das zu Konflikten führen.

In meinem Fall laufen noch andere Prozesse auf dem Raspberry. Somit kommt für mich das OS nicht infrage. Stattdessen möchte ich auf Home Assistant Container setzen. Hier läuft die Software über Docker.

Benutzt man den Home Assistant Container, muss man mit Einschränkungen leben. Es ist beispielsweise nicht möglich, Add-ons zu installieren. Der Grund liegt meines Wissens darin, dass Add-ons als (Docker-)Container installiert werden. Und das geht nicht, wenn bereits die Hauptanwendung in einem (Docker-) Container läuft. [Falls das jemand genauer weiß, gerne einen Kommentar hinterlassen!]

Installation von Home Assistant Container

Was man als Vorbereitung braucht, ist ein installiertes Linux-System. In meinem Beispiel ist es Raspbian auf einem Raspberry Pi 4. Dort meldet man sich via SSH an.

Schritt 1: Docker installieren. Gegebenenfalls hat man eine alte Version bereits installiert. Diese muss man entfernen und die aktuelle Version installieren. Dazu wird das Docker-Repository hinzugefügt und die Software daraus installiert. Am Ende wird eine Benutzergruppe „docker“ erstellt (ggf. geschieht das automatisch). Der aktuelle Benutzer – hier nennt er sich pi – wird der Gruppe hinzugefügt.

sudo apt-get remove docker docker-engine docker.io containerd runc
sudo apt-get update
sudo apt-get install ca-certificates curl gnupg lsb-release
curl -fsSL https://download.docker.com/linux/debian/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
echo   "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/debian \
 $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
 
sudo apt-get update
sudo apt-get install docker-ce docker-ce-cli containerd.io
sudo groupadd docker
sudo usermod -aG docker pi

Schritt 2: Home Assistant Container installieren. Der folgende Befehl holt sich das entsprechende Image aus dem Dockerhub, lädt es herunter und installiert es. Es ist wichtig, dass der Ordnerpfad für die Konfigurationsdatei korrekt angegeben wird. Wie oben bereits beschrieben, fehlt die Add-on-Funktion. Um die configuration.yaml bearbeiten zu können, muss man an diese Datei herankommen. Mit der Flag -v mountet man einen existierenden Ordner in den Docker-Container und kann damit die Datei weiterhin bearbeiten.

mkdir /home/pi/homeassistant/config
docker run -d \
  --name="homeassistant" \
  --privileged \
  --restart=unless-stopped \
  -e "TZ=Europe/Berlin"
  -v /home/pi/homeassistant:/config \
  --net=host \
  homeassistant/home-assistant:stable

Wer lieber Docker Compose verwendet, kann den folgenden Eintrag in die *.yaml eintragen:

name: smart_home_p10
services:
    home-assistant:
        container_name: homeassistant
        privileged: true
        restart: unless-stopped
        environment:
            - TZ=Europe/Berlin
        volumes:
            - /home/pi/homeassistant:/config
        network_mode: host
        image: ghcr.io/home-assistant/home-assistant:stable

Schritt 3: Docker-Image verwalten. Die gesamte Home Assistant Installation kann man über den Container starten und stoppen. Ein Update führt man ebenfalls über das Docker-Image aus. Die Befehle hierfür lauten folgendermaßen.

# Update installieren
docker pull homeassistant/home-assistant:stable

# Container stoppen und entfernen
docker stop homeassistant
docker rm homeassistant

Schritt 4: Auf Home Assistant zugreifen. Ab jetzt erfolgt die Verwaltung des Home Assistant über die Weboberfläche. Mit http://<IP-Adresse des Raspberrys>:8123 kann man von einem PC des gleichen Netzwerks auf die Installation zugreifen. Änderungen an der configuration.yaml müssen weiterhin über die Systemoberfläche, also z.B. mit nano oder vim über SSH erfolgen.

nano /home/pi/homeassistant/config/configuration.yaml

The post Home Assistant Container installieren first appeared on bejonet - Linux | Smart Home | Technik.