Dieser Beitrag beschreibt die grundlegende Installation von ioBroker inklusive der Einrichtung von Redis für eine bessere Performance und InfluxDB oder MySQL für die Historie von Daten.

Inhalt

• Grundlagen von ioBroker
• Adapter und Instanzen
• Objekte
• Eigene Benutzerdefinierte Objekte
• Zustände
• Speicherung von Daten in ioBroker
• Objects-DB
• States-DB
• Historische Daten
• Installation in ioBroker
• Redis
• Installation von Redis
• Umstellung von ioBroker auf Redis
• Historie über InfluxDB
• Installation des InfluxDB 2 Servers
• InfluxDB-Adapter Installieren und Konfigurieren
• Aktivieren der Aufzeichnung
• Historie über MySQL
• Installation des MariaDB-Servers
• SQL-Adapter Installieren und Konfigurieren
• Aktivieren der Aufzeichnung
• Benutzeroberfläche mit VIS
• Abschließende Hinweise

Grundlagen von ioBroker

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

Hier kurz die wichtigsten Eckdaten zu ioBroker:

• Open Source auf Basis der MIT-Lizenz
• Geschrieben in TypeScript/JavaScript, ausgeführt mit Node.js
• 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
• Langjährige sehr aktive Entwicklung und ein großer Kreis an aktiven Entwicklern

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.

Jede Instanz eines Adapters hat einen eigenen Namensbereich, in dem die Objekte der Instanz abgelegt werden.
So ist beispielsweise bei einem Raspberry Pi mit installiertem RPI-Monitor Adapter die aktuelle CPU-Temperatur über die Objekt-ID rpi2.0.temperature.soc_temp verfügbar.

Eigene Benutzerdefinierte Objekte

Zusätzlich zu den Objekten, die von den Adaptern automatisch erzeugt werden, können auch selbst Objekte für beliebige Zustände erzeugt werden.

Hierfür ist im Objektbaum der Bereich 0_userdata.0 vorgesehen. In diesem können wir beispielsweise über die Adminoberfläche ganz einfach selbst Objekte erzeugen und diese anschließend im gesamten ioBroker verwenden.

Zustände

Der jeweils aktuelle Wert eines Objektes wird als Zustand, oder auch State, bezeichnet.
Für jeden Zustand muss zuvor ein entsprechendes Objekt definiert sein.

Jeder Zustand verfügt über ein Ack-Flag, quasi eine Art Markierung, welches true oder false sein kann.
Vereinfacht lässt sich das so beschreiben, dass Zustände mit ack=false dazu dienen um Aktionen auszulösen (beispielsweise den Befehl geben eine Lampe einzuschalten). Zustände mit ack=true hingegen sind dann die Rückmeldung, dass die Aktion durchgeführt wurde oder auch von Adaptern ermittelte Werte.

Speicherung von Daten in ioBroker

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

JSONL ist eine spezielle Form von JSON-Dateien, wobei Änderungen zunächst an die vorhandenen Daten angehängt werden, anstatt die gesamte Datei neu zu schreiben. Damit sollen Schreibvorgänge auf das Dateisystem minimiert werden.

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 ergänzt beziehungsweise neu geschrieben.

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

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.jsonl

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.

Auch eine Kombination aus mehreren Adapterinstanzen für historische Daten ist möglich.

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 InfluxDB dar.
Dieser ermöglicht es die Daten in eine InfluxDB, welche besonders für Zeitreihendaten geeignet ist, zu speichern.

Eine weitere Alternative ist der Adapter SQL,welcher eine Speicherung in eine MySQL, PostgreSQL, Microsoft SQL Server oder SQLite Datenbank ermöglicht.

Die Einbindung der InfluxDB- und SQL-Adapter wird weiter unten beschrieben.

Installation in ioBroker

Als Basis für ioBroker wird eine aktuelle Version von Node.js 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:

1

curl -sLf 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.

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.

Redis kann für die States-DB und die Objects-DB verwendet werden. Auch eine Kombination, beispielsweise Redis für die States-DB und JSONL für die Objects-DB ist möglich.

Installation von Redis

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

1
2

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:

1
2
3

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

Mit STRG+D können wir redis-cli wieder verlassen.

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:

1
2
3
4
5

user@host:~ $ sudo grep "^bind" /etc/redis/redis.conf
bind 127.0.0.1 ::1
user@host:~ $ 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

Umstellung von ioBroker auf Redis

Ist der Redis Server erfolgreich installiert, dann kann die States-DB von ioBroker von den jsonl-Dateien auf Redis umgestellt werden.

Es ist auch möglich die Objects-DB auf Redis umzustellen, was aber nicht unbedingt nötig ist.
Diese Anleitung stellt nur die States-DB auf Redis um.

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

1

user@host:~ $ iobroker stop

Für die Umstellung rufen wir anschließend iobroker setup custom auf.
Die Frage nach objects DB beantworten wir mit j, um die Objects-DB als jsonl-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 jsonl-Dateien nach Redis kopiert werden.
Bei allen anderen Fragen belassen wir den Standard durch einfaches Drücken der Entertaste.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

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

Type of objects DB [(j)sonl, (f)ile, (r)edis, ...], default [jsonl]: j
Host / Unix Socket of objects DB(jsonl), default[127.0.0.1]: 
Port of objects DB(jsonl), default[9001]: 
Type of states DB [(j)sonl, (f)file, (r)edis, ...], default [jsonl]: 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 "jsonl/jsonl" to "jsonl/redis" [y/N]: y
Connecting to previous DB "jsonl/jsonl"...
Creating backup ...
This can take some time ... please be patient!
[...]
Important: If your system consists of multiple hosts please execute 
"iobroker upload all" on the master AFTER all other hosts/slaves have 
also been updated to this states/objects database configuration AND are
running!

Anschließend starten wir ioBroker wieder:

1

user@host:~ $ iobroker start

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

1
2
3
4
5
6
7
8

user@host:~ $ redis-cli KEYS '*'
 1) "io.system.adapter.admin.0.logging"
 2) "io.system.host.iobroker-test.instancesAsCompact"
 3) "io.system.host.iobroker-test.eventLoopLag"
 4) "io.admin.0.info.newsFeed"
[...]
56) "io.system.host.iobroker-test.memRss"
57) "io.admin.0.info.updatesJson"

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

Historie über InfluxDB

Optimal für die Aufzeichnung von Zeitreihendaten ist eine InfluxDB geeignet.

Dabei sollte möglichst InfluxDB 2 verwendet werden.

Installation des InfluxDB 2 Servers

Da InfluxDB 2 aktuell (Stand April 2024) nicht in den Standardpaketquellen enthalten ist, müssen wir das Repository für InfluxDB 2 erst unserem System hinzufügen.

1
2
3

wget -q https://repos.influxdata.com/influxdata-archive_compat.key
echo '393e8779c89ac8d958f81f942f9ad7fb82a25e133faddaf92e15b16e6ac9ce4c influxdata-archive_compat.key' | sha256sum -c && cat influxdata-archive_compat.key | gpg --dearmor | sudo tee /etc/apt/trusted.gpg.d/influxdata-archive_compat.gpg > /dev/null
echo 'deb [signed-by=/etc/apt/trusted.gpg.d/influxdata-archive_compat.gpg] https://repos.influxdata.com/debian stable main' | sudo tee /etc/apt/sources.list.d/influxdata.list

(Quelle: https://www.influxdata.com/downloads/)

Anschließend können wir InfluxDB 2 wie gewohnt installieren:

1
2

sudo apt update
sudo apt install influxdb2

Anschließend müssen wir den SystemD-Service noch starten:

1

sudo systemctl start influxdb

Die Weboberfläche von InfluxDB 2 ist anschließend über http://<ip>:8086/ erreichbar und sollte genutzt werden, um die Einrichtung abzuschließen.

Die Einstellungen für Benutzername, Organisationsname und Bucket Name sind frei wählbar, werden aber später benötigt.
Im Anschluss wird ein Token angezeigt, welches wir uns unbedingt notieren sollten.

InfluxDB-Adapter Installieren und Konfigurieren

Zur Installation des InfluxDB-Adapters suchen wir dieser in der Adminoberfläche und fügen ihn anschließend hinzu.

Anschließend öffnet sich direkt die Konfiguration der Adapterinstanz.
Hier wählen wir als DB-Version die 2.x aus und tragen den Namen der Organisation und den Token (beides aus dem InfluxDB 2 Setup) ein.

Mit Verbindung Testen kann die Verbindung zur InfluxDB getestet werden.

Anschließend bestätigen wir wie üblich mit Speichern und Schließen, woraufhin die InfluxDB Instanz neu startet und anschließen mit einem grünen Symbol als laufend dargestellt werden sollte.

Aktivieren der Aufzeichnung

Damit nun auch eine Historie aufgezeichnet wird, müssen bei dem gewünschten Objekt die Eigenschaften für influxdb.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 Zahnrad-Button.
In dem folgenden Dialog setzen wir in den Benutzerdefinierten Einstellungen für influxdb.0 den Haken bei Aktiviert, passen gegebenenfalls noch die anderen Optionen an und klicken auf Speichern & Schließen.

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

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

Historie über MySQL

Die Aufzeichnung von historischen Daten kann alternativ auch ü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 Ubuntu, Debian und Raspbian enthalten ist, erfolgt die Installation wie üblich:

1

sudo apt install mariadb-server mariadb-client

Anschließend sichern wir die neue Installation noch ab, damit erst gar keine Sicherheitsrisiken aufkommen. Alle Punkte können dabei einfach mit Enter beantwortet werden. Lediglich ein Root-Passwort sollte gesetzt werden:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

user@host:~ $ 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!

In order to log into MariaDB to secure it, we'll need the current
password for the root user. If you've just installed MariaDB, and
haven't set the root password yet, you should just press enter here.

Enter current password for root (enter for none): 
OK, successfully used password, moving on...

Setting the root password or using the unix_socket ensures that nobody
can log into the MariaDB root user without the proper authorisation.

You already have your root account protected, so you can safely answer 'n'.

Switch to unix_socket authentication [Y/n] 
Enabled successfully!
Reloading privilege tables..
 ... Success!


You already have your root account protected, so you can safely answer 'n'.

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


By default, a MariaDB installation has an anonymous user, allowing anyone
to log into MariaDB without having to have a user account created for
them.  This is intended only for testing, and to make the installation
go a bit smoother.  You should remove them before moving into a
production environment.

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

Normally, root should only be allowed to connect from 'localhost'.  This
ensures that someone cannot guess at the root password from the network.

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

By default, MariaDB comes with a database named 'test' that anyone can
access.  This is also intended only for testing, and should be removed
before moving into a production environment.

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

Reloading the privilege tables will ensure that all changes made so far
will take effect immediately.

Reload privilege tables now? [Y/n] 
 ... 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 Installieren und Konfigurieren

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:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

user@host:~ $ 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)

Die MySQL-Session beenden wir anschließend mit STRG+D.

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 ggf. 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

Die Aktivierung erfolgt genauso wie beim InfluxDB Adapter weiter oben bereits beschrieben. Es muss lediglich sql.0 anstatt influxdb.0 aktiviert werden.

Benutzeroberfläche mit VIS

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

Dies wollen wir nun ändern und installieren hierfür den Adapter Visualisierung, kurz VIS.
Inzwischen gibt es auch die neue, verbesserte Version VIS 2. Es empfiehlt sich diese auch für alle neuen Installationen zu nutzen.

Vor der Installation müssen wir zunächst die Lizenzbedingungen lesen und akzeptieren.

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 abgeschlossen, so öffnet sich die Konfiguration der VIS 2 Adapterinstanz.
Hier muss ein Lizenzschlüssel eingegeben werden, damit der Adapter genutzt werden kann.

Für die private Nutzung ist VIS kostenlos.
Über https://iobroker.net/ kann man sich einen ioBroker Cloud Account erzeugen.
Mit diesem ist es dann möglich eine Community-Lizenz für iobroker.vis-2 kostenfrei zu “bestellen”.

Bei der Bestellung müssen die AGB akzeptiert und ein paar persönliche Daten angegeben werden.
Die Seriennummer der ioBroker-Installation ist in den Adaptereinstellungen zu finden und muss von dort kopiert werden.

Trotz der Auswahl von VIS 2 wurde bei mir die Lizenz für VIS <2 erstellt. Über den Button Zu v2 konvertieren kann die Lizenz aber einfach für VIS 2 konvertiert werden. Dabei muss nochmals die Seriennummer der ioBroker-Installation angegeben werden.

Über den Auge-Button können wir anschließend die Lizenz anzeigen lassen.

Den Lizenzschlüssel kopieren wir in die Adaptereinstellungen und klicken auf Speichern und Schließen.

Anschließend können wir die VIS-Oberfläche über http://<ip>:8082/ erreichen und von dort aus zur Anzeige, der sogenannten Runtime oder zum Editor wechseln.

Hier wählen wir zunächst den Editor, um unsere Oberfläche zu erstellen und zu bearbeiten. Dort wählen wir dann Neues Projekt erstellen und geben dem Projekt einen beliebigen Namen.

In dieser Editor-Ansicht können wir uns dann aus der linken Seite alle möglichen Elemente, die sogenannten Widgets, in unsere Ansicht in der Mitte ziehen.

In der rechten Seitenleiste kann das jeweils aktuell ausgewählte Widget sehr detailliert konfiguriert werden.

VIS ist extrem flexibel und bietet nahezu unbegrenzte Möglichkeiten die Benutzeroberfläche nach den eigenen Vorstellungen anzupassen.
Mit VIS 2 lassen sich inzwischen sogar responsive Layouts erstellen, welche sich der Größe des jeweils verwendeten Endgerätes angleichen.

Abschließende Hinweise

Diese Anleitung beinhaltet nur einen kleinen Teil dessen, was mit ioBroker alles möglich ist.

Viele weitere, teils sehr ausführliche Informationen sind in der offiziellen Dokumentation zu finden.

Eine Übersicht über aktuell verfügbare Adapter kann in der Adapterliste eingesehen werden.

Zudem lohnt sich fast immer ein Blick in das ioBroker Forum. Hier können auch alle möglichen Fragen und Probleme mit der Community und den Entwicklern geklärt werden.

Wenn euch meine Anleitung gefallen hat, lasst gerne einen Daumen hoch oder einen Kommentar da.

Viel Erfolg mit eurem ioBroker! 😎