Dieser Beitrag beschreibt die grundlegende Installation von ioBroker auf dem Raspberry Pi inklusive der Einrichtung von Redis für eine bessere Performance und MySQL für die Historie von Daten.

Grundlagen zu ioBroker

ioBroker ist eine IoT-Plattform, die es unter anderem ermöglicht sehr umfangreiche trotzdem flexible Heimautomatisierungen aufzubauen.

Hier kurz die wichtigsten Eckdaten zu ioBroker:

  • Open Source auf Basis der MIT-Lizenz
  • Geschrieben mit Node.js (JavaScript / TypeScript)
  • Läuft auf Linux, Windows, OSX, Raspberry Pi, ARM
  • Umfassende Unterstützung für verschiedenste Smart Home Komponenten
  • Sehr gute Erweiterbarkeit für Hard- und Software
  • Große Community

Adapter und Instanzen

Über sogenannte Adapter kann ioBroker um nahezu jede erdenkliche Funktionalität erweitert werden. Dies betrifft sowohl die Anbindung von Hardware als auch die Einbindung von zusätzlichen Softwarekomponenten wie beispielsweise einer Benutzeroberfläche.

Die einzelnen Adapter lassen sich problemlos und komfortabel über die Administrationsoberfläche installieren.

Zur Verwendung werden von den Adaptern einzelne Instanzen erzeugt.
Einfach gesagt: Ein eingerichteter Adapter ist eine Instanz.

Von einem Adapter können zudem mehrere Instanzen erzeugt werden, was beispielsweise bei spezieller Hardware erforderlich ist. Im Regelfall wird jedoch nur jeweils eine Instanz benötigt.

Der Name der Instanz ist dabei vom Namen des Adapters abhängig. Heißt der Adapter beispielsweise sql, so heißt die erste Instanz des Adapters dann sql.0. Eine zweite Instanz würde sql.1 heißen und so weiter.

Objekte

In ioBroker werden alle Datenstrukturen über Objekte abgebildet.

Abhängig vom jeweiligen Adapter werden Baumstrukturen aus Geräten, Kanälen und Werten erzeugt.

Jeder Instanz eines Adapters hat einen eigenen Namensbereich, in dem die Objekte der Instanz abgelegt werden. So ist beispielsweise bei einem Raspberry Pi die aktuelle CPU-Temperatur vom Info-Adapter über die Objekt-ID info.0.sysinfo.cpu.temperature.main verfügbar.

Speicherung von Daten in ioBroker

Standardmäßig speichert ioBroker alle Daten in json-Dateien auf dem Dateisystem.

Objects-DB

Die Objects-DB beinhaltet die Strukturen und Eigenschaften von allen in ioBroker angelegten Objekten. Sie wird bei jeder Veränderung an einem Objekt neu geschrieben.

Speicherort: /opt/iobroker/iobroker-data/objects.json

States-DB

Die States-DB enthält alle aktuellen Zustände und Werte der Objekte. Sie unterliegt somit ständigen Lese- und Schreibvorgängen.

Speicherort: /opt/iobroker/iobroker-data/states.json

Historische Daten

Standardmäßig werden nur die aktuellen Zustände und keine historischen Daten erfasst. Sollen historische Daten, beispielsweise zur Darstellung von Zeitreihen, aufgezeichnet werden, so muss hierfür extra ein Adapter installiert und eingerichtet werden.

Ist ein entsprechender Adapter installiert, so kann er für jedes Objekt einzeln aktiviert werden. Dadurch werden nur Daten aufgezeichnet, die man auch wirklich haben möchte.

Der einfachste Adapter zur Aufzeichnung der Daten ist History. Die Daten werden hierbei dann tageweise unter /opt/iobroker/iobroker-data/history/yyyymmdd/ in json-Dateien gespeichert.

Eine gute Alternative stellt der Adapter SQL dar. Dieser ermöglicht es die Daten eine MySQL, PostgreSQL, Microsoft SQL Server oder SQLite Datenbank zu speichern. Die Einbindung dieses Adapters wird weiter unten noch beschrieben.

Installation

Als Basis für ioBroker wird Node.js Version 10.x oder neuer benötigt. Ich empfehle hier immer aktuelle LTS-Version zu verwenden. Die Installation von Node.js habe ich im entsprechenden Beitrag bereits ausführlich beschrieben.

Die Installation von ioBroker erfolgt über das offizielle Install-Skript:

curl -sL https://iobroker.net/install.sh | bash -

Dieses Skript installiert alle Abhängigkeiten, installiert ioBroker nach /opt/iobroker, legt den Systembenutzer iobroker an und erstellt den SystemD-Service iobroker.service.

Nach der Installation sollte das System am besten einmal neu gestartet werden, damit alle Anpassungen aktiv werden.

Anschließend ist die Administrationsoberfläche über http://<ip>:8081/ erreichbar.

Hinweis: Eine Benutzeroberfläche ist bis jetzt noch nicht vorhanden. Diese werden wir weiter unten installieren.

Redis

Da die Verwendung von Dateien vor allem im Zusammenhang mit der States-DB doch recht langsam ist, ersetzen wir diese durch Redis.

Redis ist eine In-Memory-Datenbank mit einer einfachen Schlüssel-Werte-Datenstruktur. Diese ermöglicht eine deutlich performantere Speicherung der States, wodurch ioBroker insgesamt spürbar flüssiger reagiert.

Nach aktuellem Stand (September 2019) kann Redis bisher nur für die States-DB verwendet werden. Eine Nutzung für die Objects-DB ist aber bereits in Planung.

Installation von Redis

Die Installation ist denkbar einfach, da Redis bereits in den offiziellen Paketquellen von Raspbian enthalten ist:

sudo apt update
sudo apt install redis

Anschließend können wir testen, ob der Redis Server läuft indem wir redis-cli aufrufen und alle gespeicherten Schlüssel abfragen:

pi@homepi:~ $ redis-cli
127.0.0.1:6379> KEYS *
(empty list or set)

Standardmäßig ist der Redis Server nur über Localhost (127.0.0.1) erreichbar. Dies ist auch gut so, damit keine fremden Nutzer diesen verwenden können. Zur Sicherheit überprüfen wir das noch:

pi@homepi:~ $ sudo grep "^bind" /etc/redis/redis.conf
bind 127.0.0.1 ::1
pi@homepi:~ $ sudo netstat -tulpen | grep 6379
tcp   0  0 127.0.0.1:6379    0.0.0.0:*   LISTEN   113   120233   5108/redis-server 1
tcp6  0  0 ::1:6379          :::*        LISTEN   113   120234   5108/redis-server 1

Hinweis: Bei Multihost-Systemen muss der Redis Server von den Salves aus erreichbar sein. Hierzu sind Änderungen an der Redis Konfiguration und zur Absicherung entsprechende Firewall-Regeln notwendig.

Umstellung der States-DB auf Redis

Ist der Redis Server erfolgreich installiert, dann kann die States-DB von ioBroker von den json-Dateien auf Redis umgestellt werden.
Es ist auch möglich die Objects-DB auf Redis umzustellen, was aber nur wenigen Fällen sinnvoll ist.

Achtung: Bei der Einrichtung wird gefragt, ob man die Objekte und States migrieren möchte. Antwortet man hier mit nein, gehen alle aktuell gespeicherten States (und ggf. Objekte) dabei verloren!

Vor der Umstellung müssen wir zunächst die laufende ioBroker Instanz stoppen.

pi@homepi:~ $ iobroker stop

Für die Umstellung rufen wir anschließend iobroker setup custom auf.
Die Frage nach “objects DB” beantworten wir mit f, um die Objects-DB als json-Dateien zu belassen und die Frage nach der “states DB” mir r für Redis.
Die Frage zur Migration der Objekte und States beantworten wir mit y, damit alle bisher vorhandenen States aus den json-Dateien nach Redis kopiert werden.
Bei allen anderen Fragen belassen wir den Standard durch einfaches Drücken der Entertaste.

pi@homepi:~ $ iobroker setup custom
Current configuration:
- Objects database:
  - Type: file
  - Host/Unix Socket: 127.0.0.1
  - Port: 9001
- States database:
  - Type: file
  - Host/Unix Socket: 127.0.0.1
  - Port: 9000
- Data Directory: ../../iobroker-data/

Type of objects DB [(f)ile, (r)edis, ...], default [file]: f
Host / Unix Socket of objects DB(file), default[127.0.0.1]:
Port of objects DB(file), default[9001]:
Type of states DB [(f)file, (r)edis, ...], default [file]: r

When States are stored in a Redis database please make sure to configure Redis
persistence to make sure a Redis problem will not cause data loss!

Host / Unix Socket of states DB (redis), default[127.0.0.1]:
Port of states DB (redis), default[6379]:
Data directory (file), default[../../iobroker-data/]:
Host name of this machine [iobroker-test]:
This host appears to be a Master or a Single host system. Is this correct? [Y/n]:

Do you want to migrate objects and states from "file/file" to "file/redis" [y/N]: y
[...]

Die Migration der Daten kann, je nach Datenmenge, einige Zeit dauern.

Anschließend starten wir ioBroker wieder:

pi@homepi:~ $ iobroker start

Wenn wir nun erneut aus Redis alle bekannten Schlüssel abfragen sollten wir schon einige Ergebnisse erhalten:

pi@homepi:~ $ redis-cli KEYS '*'
  1) "io.info.0.sysinfo.cpu.info.cache-l2"
  2) "io.info.0.sysinfo.network.interfaces.iface1.iface"
  3) "io.info.0.sysinfo.cpu.currentspeed.maxSpeed"
  4) "io.system.adapter.admin.0.uptime"
[...]
266) "io.system.adapter.discovery.0.alive"
267) "io.info.0.sysinfo.os.versions.kernel"

Damit ist Redis auch schon fertig eingerichtet und bereit für jede Menge States. 🙂

Historie über MySQL

Die Aufzeichnung von historischen Daten soll in diesem Fall über eine MySQL Datenbank (MariaDB) erfolgen. Hierfür installieren wir zuerst den MariaDB-Server und anschließend den SQL-Adapter.

Installation des MariaDB-Servers

Da MariaDB in den offiziellen Paketquellen von Raspbian enthalten ist, erfolgt die Installation wie üblich:

sudo apt install mariadb-server mariadb-client

Anschließend sichern wir die neue Installation noch ab, damit erst gar keine Sicherheitsrisiken aufkommen:

pi@homepi:~ $ sudo mysql_secure_installation

NOTE: RUNNING ALL PARTS OF THIS SCRIPT IS RECOMMENDED FOR ALL MariaDB
      SERVERS IN PRODUCTION USE!  PLEASE READ EACH STEP CAREFULLY!
[...]
Enter current password for root (enter for none):
OK, successfully used password, moving on...

[...]
Set root password? [Y/n] y
New password:
Re-enter new password:
Password updated successfully!
Reloading privilege tables..
 ... Success!

[...]
Remove anonymous users? [Y/n] y
 ... Success!

[...]
Disallow root login remotely? [Y/n] y
 ... Success!

[...]
Remove test database and access to it? [Y/n] y
 - Dropping test database...
 ... Success!
 - Removing privileges on test database...
 ... Success!

[...]
Reload privilege tables now? [Y/n] y
 ... Success!

Cleaning up...

All done!  If you've completed all of the above steps, your MariaDB
installation should now be secure.

Thanks for using MariaDB!

Damit ist der MySQL/MariaDB-Server dann auch schon fertig installiert und bereit für ioBroker.

SQL Adapter

Damit sich der SQL Adapter mit unserer Datenbank verbinden kann, müssen wir zuerst auf dem MySQL/MariaDB-Server eine Datenbank und einen entsprechenden Benutzer anlegen. Dies machen wir über ein Terminal:

pi@homepi:~ $ mysql -u root -p
Enter password:
Welcome to the MariaDB monitor.  Commands end with ; or \g.
[...]

MariaDB [(none)]> CREATE DATABASE iobroker CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
Query OK, 1 row affected (0.001 sec)

MariaDB [(none)]> CREATE USER 'iobroker'@'%' IDENTIFIED BY 'Passw0rt';
Query OK, 0 rows affected (0.001 sec)

MariaDB [(none)]> GRANT ALL PRIVILEGES ON iobroker.* TO 'iobroker'@'%';
Query OK, 0 rows affected (0.001 sec)

MariaDB [(none)]> FLUSH PRIVILEGES;
Query OK, 0 rows affected (0.001 sec)

Das Passw0rt solltet ihr natürlich ändern. 😉

Anschließend können wir über die Administrationsoberfläche den SQL Adapter suchen und installieren.

Die Installation kann einige Zeit dauern, da hierbei unter anderem native Node.js-Module kompiliert werden müssen.

Sobald die Installation abgeschlossen ist, öffnet sich automatisch die Konfigurationsseite für den Adapter. Hier wählen wir dann als DB Typ die Option MySQL aus und tragen unsere zuvor erstellten Logindaten ein. Eine verschlüsselte Verbindung ist nicht erforderlich, da ioBroker und die Datenbank auf dem gleichen System laufen.

Über den Button Verbindung Testen kann die Verbindung zum MySQL/MariaDB-Server überprüft werden. Wenn die Verbindung ok ist, dann bestätigen wir den Dialog mit Speichern und Schließen. Nach kurzer Zeit sollte dann der Punkt vor sql.0 in der Übersicht unserer Instanzen grün werden, was eine erfolgreiche Verbindung anzeigt.

Aktivieren der Aufzeichnung

Damit nun auch eine Historie aufgezeichnet wird, müssen bei dem gewünschten Objekt die Eigenschaften für sql.0 entsprechend gesetzt werden. Hierzu suchen wir uns das Objekt über die Baumansicht der Objekte heraus und klicken bei dem Objekt ganz rechts auf den Schraubenschlüssel-Button.

In dem folgenden Dialog setzen wir in den Einstellungen für sql.0 den Haken bei Aktiviert, passen gegebenenfalls noch die anderen Optionen an und klicken auf Speichern.

Wenn alles funktioniert, dann ist schon kurze Zeit später in demselben Dialog über den Reiter Tabelle eine Tabelle der gespeicherten Daten verfügbar.

Die gespeicherten Daten können nun von anderen Adaptern oder auch externen Tools verwendet werden.

Benutzeroberfläche mit VIS

Bisher verfügt unser ioBroker noch über keine Benutzeroberfläche.

Die wollen wir nun ändern und installieren hierfür den Adapter Visualisierung, kurz VIS.

Vor der Installation müssen wir zuerst die Lizenzbedingungen lesen und akzeptieren. Die eigentliche Installation dauert dann wieder etwas, also nicht ungeduldig werden. 😉

Zusätzlich zu VIS wird automatisch auch der Webserver Adapter installiert. Dieser wird von VIS und einigen anderen Adaptern benötigt, um ihre Dienste bereitzustellen.

Ist die Installation fertig, dann öffnet sich zuerst die Adapterkonfiguration für web.0, welche wir einfach mit den Standardeinstellungen direkt wieder schließen können.

Im Anschluss daran öffnen wir die Adapterkonfiguration für vis.0 über den Schraubenschlüssel-Button.

Auf dieser Konfigurationsseite müssen wir nun einen Lizenzschlüssel für VIS eingeben.

Für die private Nutzung ist VIS kostenlos. Über https://iobroker.net/ kann man sich einen ioBroker Cloud Account erzeugen und nach dem Bestätigen der AGB einen Lizenzschlüssel für iobroker.vis (private) geben lassen. Diesen Lizenzschlüssel fügen wir dann in der Adapterkonfiguration ein und klicken auf Speichern und Schließen.

Anschließend können wir die VIS-Oberfläche über http://<ip>:8082/ erreichen.

Zudem sind in der Übersicht der Administrationsoberfläche die zwei neuen Felder vis runtime und Visualisierung hinzugekommen. Über diese lassen sich die Ansicht und die Verwaltung von VIS per einfachem Klick öffnen.

Die Fehlermeldung main/vis-views.json Not exists beim ersten Aufruf können wir einfach mit OK bestätigen. Daraufhin erscheint die Frage Erzeugen main/vis-views.json? welche wir wiederum mit OK bestätigen. Damit ist wird eine Beispielkonfiguration erstellt, welche dann nach Belieben angepasst werden kann.

Die Konfiguration im VIS Editor ist extrem flexibel gehalten. Auch wenn es auf den ersten Blick etwas kompliziert wirken mag, ist die Konfiguration der Oberfläche doch recht einfach. Vieles ist einfachem Drag&Drop realisierbar. Hier gilt die Devise: Einfach ausprobieren!

Zu einem späteren Zeitpunkt werde ich gegebenenfalls noch einen gesonderten Beitrag zu der Konfiguration und den Möglichkeiten von VIS schreiben. 🙂

Das wars dann auch schon mit der Installation und grundlegenden Einführung in ioBroker.

Viel Erfolg!