OpenHAB 4 Docker Installation

Aus Laub-Home Wiki

Hier wird beschrieben wie man das aktuelle openHAB 4 mit nützlichen Tools wie Grafana und Mosquitto MQTT mittels Docker Compose Projekt deployt und grundeinrichtet.

Für die Persistenz der Daten wird eine InfluxDB 2 genutzt. Grafana speichert seine Konfiguration in einer eigenen PostgresDB und wird noch durch den Renderer erweitert um bei Alerts auch die Grafiken via Mail zu erhalten.

Für dieses Setup solltet ihr mindestens einen Raspberry Pi 3 B+ (bezahlter Link) oder besser ein Raspberry Pi 4 (bezahlter Link) mit Raspberry Pi OS 64bit, Docker und Docker-Compose installiert haben. Wichtig ist, das die 64bit Version des Raspberry Pi OS installiert ist, da sonst die InfluxDB in Version 2, nicht lauffähig ist (bei einer 32bit Installation hier nachschauen). Das Setup ist aber auch auf jedem anderen System nutzbar, auf dem Docker und Docker-Compose läuft. Bei mir kommt Setup auf einem Raspberry Pi 4 (bezahlter Link) zum Laufen.

Docker Compose Projekt

Als erstes legen wir unseren Docker Compose Projekt Ordner inklusive aller Unterordner an, erstellen eine leere Mosquitto MQTT Passwort Datei und legen einen eignen System User für openHAB an. Dann wechseln wir in den Compose Project Ordner:

mkdir -p /opt/openhab4/data/openhab/conf
mkdir -p /opt/openhab4/data/openhab/addons
mkdir -p /opt/openhab4/data/mosquitto/conf/certs
mkdir -p /opt/openhab4/data/influxdb/conf
mkdir -p /opt/openhab4/certs
touch /opt/openhab4/data/mosquitto/conf/mosquitto.passwd
groupadd -g 9001 openhab
useradd -u 9001 -g openhab -r -s /sbin/nologin openhab

cd /opt/openhab4

Nun legen wir in unserem Compose Projektordner unsere ComposeProjekt-Konfigurationsdatei an:

/opt/openhab4/.env

# Config File for openHAB Application

# Docker Compose Project Name
# max length 11 characters
PROJECT_NAME=openhab4

# Port Configuration openHab
OPENHAB_VERSION=4.2.2
OPENHAB_HTTP_PORT=8080
OPENHAB_HTTPS_PORT=8443

# InfluxDB Configuration
INFLUXDB_VERSION=2.7-alpine
INFLUXDB_HTTP_PORT=8086
INFLUXDB_INIT_MODE=setup
INFLUXDB_INIT_USERNAME=admin
INFLUXDB_INIT_PASSWORD=havdsdcsdfodpdsa343
INFLUXDB_INIT_ORG=myorg
INFLUXDB_INIT_BUCKET=openhab_db
INFLUXDB_INIT_ADMIN_TOKEN=dcsdfodpdsa3adsdcasd8979820394r2nkjnk
INFLUXD_LOG_LEVEL=warn

# Port Configuration Grafana
GRAFANA_VERSION=11.2.2
GRAFANA_HTTP_PORT=3000
## Set the Server URL, so links in Alert Mails are not related to localhost.
GRAFANA_SERVER_ROOT_URL=http://YOURSERVERNAME:3000
## Grafana Mailing
GRAFANA_SMTP_ENABLED=false
GRAFANA_SMTP_HOST=YOURMAILSERVER:465
GRAFANA_SMTP_USER=YOURSMTPUSER
GRAFANA_SMTP_PASSWORD=SMTPPASSWORD
GRAFANA_SMTP_FROM_ADDRESS=MAIL@FROMADRESS.TLD

# Postgres Configuration
POSTGRES_VERSION=17-alpine
POSTGRES_PASSWORD=havdsdcsdfxCodpit9
POSTGRES_USER=grafana
POSTGRES_DB=grafanadb

# Port Configuration Mosquitto
MOSQUITTO_VERSION=2
MOSQUITTO_MQTT_PORT=1883
MOSQUITTO_MQTTS_PORT=8883

# Timezone
TZ=Europe/Berlin

Bitte ändert bei der InfluxDB das Passwort, die Organisation und den Admin Token ab!

Falls ihr Alarm eMails von Grafana versenden möchtet, bitte Grafana Mailing entsprechend eures Mailservers anpassen und GF_SMTP_ENABLED=true setzen!

Bitte ändert bei der Postgres DB das Passwort!

Nun noch die docker-compose.yml selbst.

/opt/openhab4/docker-compose.yml

services:
  openhab:
    image: openhab/openhab:${OPENHAB_VERSION}
    depends_on:
      - influxdb
      - mosquitto
    restart: always
    # if you do not need persistent log files
    #tmpfs:
    #   - /openhab/userdata/logs
    volumes:
      - "/etc/localtime:/etc/localtime:ro"
      - "/etc/timezone:/etc/timezone:ro"
      - "./data/openhab/conf:/openhab/conf"
      - "./data/openhab/addons:/openhab/addons"
      - data_openhab_userdata:/openhab/userdata
    environment:
      - TZ=${TZ}
      - OPENHAB_HTTP_PORT=${OPENHAB_HTTP_PORT}
      - OPENHAB_HTTPS_PORT=${OPENHAB_HTTPS_PORT}
      - "CRYPTO_POLICY=unlimited"
      - "EXTRA_JAVA_OPTS=-Duser.timezone=${TZ}"
      # If you need more memory
      #- "EXTRA_JAVA_OPTS=-Xms1024m -Xmx2048m -Duser.timezone=${TZ}"
      - USER_ID=9001
      - GROUP_ID=9001
    labels:
      - "com.centurylinklabs.watchtower.enable=true"
    network_mode: host

  mosquitto:
    image: eclipse-mosquitto:${MOSQUITTO_VERSION}
    restart: always
    volumes:
      - "./data/mosquitto/conf:/mosquitto/config"
      - data_mosquitto_data:/mosquitto/data
      - data_mosquitto_log:/mosquitto/log
    ports:
      - ${MOSQUITTO_MQTT_PORT}:1883
      - ${MOSQUITTO_MQTTS_PORT}:8883
    environment:
      - TZ=${TZ}
    labels:
      - "com.centurylinklabs.watchtower.enable=true"
    networks:
      app-nw:
        aliases:
          - mqtt

  influxdb:
    image: influxdb:${INFLUXDB_VERSION}
    restart: always
    volumes:
      - "./data/influxdb/conf:/etc/influxdb2"
      - data_influxdb:/var/lib/influxdb2
    ports:
      - ${INFLUXDB_HTTP_PORT}:8086
    environment:
      - DOCKER_INFLUXDB_INIT_MODE=${INFLUXDB_INIT_MODE}
      - DOCKER_INFLUXDB_INIT_USERNAME=${INFLUXDB_INIT_USERNAME}
      - DOCKER_INFLUXDB_INIT_PASSWORD=${INFLUXDB_INIT_PASSWORD}
      - DOCKER_INFLUXDB_INIT_ORG=${INFLUXDB_INIT_ORG}
      - DOCKER_INFLUXDB_INIT_BUCKET=${INFLUXDB_INIT_BUCKET}
      - DOCKER_INFLUXDB_INIT_ADMIN_TOKEN=${INFLUXDB_INIT_ADMIN_TOKEN}
      - INFLUXD_LOG_LEVEL=${INFLUXD_LOG_LEVEL}
      - TZ=${TZ}
    labels:
      - "com.centurylinklabs.watchtower.enable=true"
    networks:
      app-nw:
      backend-nw:
        aliases:
          - db
  
  postgres:
    image: postgres:${POSTGRES_VERSION}
    restart: always
    volumes:
      - data_postgres:/var/lib/postgresql/data/
    environment:
      - POSTGRES_PASSWORD=${POSTGRES_PASSWORD}
      - POSTGRES_USER=${POSTGRES_USER}
      - POSTGRES_DB=${POSTGRES_DB}
      - TZ=${TZ}
    labels:
      - "com.centurylinklabs.watchtower.enable=true"
    networks:
      backend-nw:
        aliases:
          - postgresdb
          
  renderer:
    # official image
    image: grafana/grafana-image-renderer:latest
    # inofficial ones working on Raspberry Pi's
    #image: adejong/grafana-image-renderer-pi:1.0.8-beta2
    #image: serhiymakarenko/grafanalabs-image-renderer:latest
    #image: asksven/grafana-image-renderer:1
    #image: hferreira/grafana-image-renderer:latest
    restart: always
    environment:
      - ENABLE_METRICS=true
      - TZ=${TZ}
    labels:
      - "com.centurylinklabs.watchtower.enable=true"
    networks:
      - backend-nw

  grafana:
    image: grafana/grafana:${GRAFANA_VERSION}
    depends_on:
      - influxdb
      - renderer
      - postgres
    restart: always
    user: "0"
    volumes:
      - data_grafana:/var/lib/grafana
    ports:
      - ${GRAFANA_HTTP_PORT}:3000
    environment:
      - GF_INSTALL_PLUGINS=grafana-clock-panel,briangann-gauge-panel,natel-plotly-panel,grafana-simple-json-datasource
      - GF_SERVER_ROOT_URL=${GRAFANA_SERVER_ROOT_URL}
      - GF_SMTP_ENABLED=${GRAFANA_SMTP_ENABLED}
      - GF_SMTP_HOST=${GRAFANA_SMTP_HOST}
      - GF_SMTP_USER=${GRAFANA_SMTP_USER}
      - GF_SMTP_PASSWORD=${GRAFANA_SMTP_PASSWORD}
      - GF_SMTP_FROM_ADDRESS=${GRAFANA_SMTP_FROM_ADDRESS}
      - GF_DATABASE_TYPE=postgres
      - GF_DATABASE_HOST=postgresdb
      - GF_DATABASE_NAME=${POSTGRES_DB}
      - GF_DATABASE_USER=${POSTGRES_USER}
      - GF_DATABASE_PASSWORD=${POSTGRES_PASSWORD}
      - GF_DATABASE_SSL_MODE=disable
      - GF_UNIFIED_ALERTING_SCREENSHOTS_CAPTURE=true
      - GF_RENDERING_SERVER_URL=http://renderer:8081/render
      - GF_RENDERING_CALLBACK_URL=http://grafana:3000/
      - GF_LOG_FILTERS=rendering:debug
      # for anonymous access to embedding graphs
      #- GF_AUTH_ANONYMOUS_ENABLED=true
      #- GF_SECURITY_ALLOW_EMBEDDING=true      
      - TZ=${TZ}
    labels:
      - "com.centurylinklabs.watchtower.enable=true"
    networks:
      - app-nw
      - backend-nw

volumes:
  data_openhab_userdata:
  data_influxdb:
  data_postgres:
  data_grafana:
  data_mosquitto_data:
  data_mosquitto_log:

networks:
  app-nw:
    internal: false
    driver: bridge
    driver_opts:
      com.docker.network.bridge.name: app-${PROJECT_NAME}
  backend-nw:
    internal: true
    driver: bridge
    driver_opts:
      com.docker.network.bridge.name: be-${PROJECT_NAME}

Was passiert hier:

  • openhab wird mit dem host network gestartet, damit es auch UPnP Anfragen annehmen kann (network_mode: host)
  • Es wird ein Netzwerk app-nw eingerichtet mit dem sich alle Container verbinden, die einen Port freigeben.
  • zusätzlich wird noch ein Backend Netzwerk backend-nw erstellt, in dem sich die Backend Dienste unterhalten werden.
  • Für persistente Daten werden Volumes erstellt und benutzt
  • Konfigurationsdateien werden in den Compose Projektordner unter data/XXX ausgelagert
  • openhab, influxdb, mosquitto, grafana und renderer werden als Container gestartet
  • Das Label - "com.centurylinklabs.watchtower.enable=true" dient dazu das eine automatisierte Aktualisierung der Container von Watchtower stattfindet kann.

Mosquitto Konfiguration

Zuerst generieren wir die SelfSigned SSL Zertifikate, damit wir den Zugriff via MQTT auf den Mosquitto Broker verschlüsselt nutzen können

cd /opt/openhab4/certs
wget https://raw.githubusercontent.com/alaub81/scripts/master/generate-certs.sh
chmod +x generate-certs.sh

Bitte mindestens die Variablen COMPOSE_PROJECT_DIR und IP anpassen, bei IP am besten den FQDN des Servers eintragen!

/opt/openhab4/certs/generate-certs.sh 

COMPOSE_PROJECT_DIR="/opt/openhab4"
IP="hostname.domainname.tld"

Dann das Script zum generieren der Zertifikate einfach starten: 

./generate-certs.sh

nun erstellen wir das Konfigurationsfile:

/opt/openhab4/data/mosquitto/conf/mosquitto.conf 

listener 1883
listener 8883

persistence true
persistence_location /mosquitto/data/
log_dest file /mosquitto/log/mosquitto.log

allow_anonymous false
password_file /mosquitto/config/mosquitto.passwd

cafile /mosquitto/config/certs/ca.crt
certfile /mosquitto/config/certs/server.crt
keyfile /mosquitto/config/certs/server.key

require_certificate false

Mehr Infos hier:

Hochfahren des openHAB 4 Compose Projektes

Ist alles soweit eingerichtet kann das Projekt das erste Mal gestartet werden: 

cd /opt/openhab4
docker compose up -d

Nun sollten die folgenden URLs verfügbar sein:

  • openHAB: http://YOURSERVERNAME:8080 und https://YOURSERVERNAME:8433
  • Grafana: http://YOURSERVERNAME:3000
  • InfluxDB 2: http://YOURSERVERNAME:8086

Mit docker ps könnt ihr zusätzlich prüfen ob alle Container laufen.

Anlegen des MQTT Benutzers

nun richten wir noch einen Benutzer für den MQTT Broker ein um uns damit via openHAB zu verbinden.

cd /opt/openhab4
docker compose exec mosquitto mosquitto_passwd -c /mosquitto/config/mosquitto.passwd mosquitto

Einfach ein gewünschtes Passwort für den User vergeben. Benutzername ist mosquitto.

Anlage InfluxDB 2 API Tokens

Nun müssen wir für openHAB und Grafana in der InfluxDB 2 API Tokens einrichten, um mit diesen später darauf zugreifen zu können. Dafür loggen wir uns am Webinterface von der InfluxDB ein:

  • http://<YOURSERVERNAME>:8086
  • mit dem in den .env eintragenden credentials einloggen

Nun unter Load Data --> API Tokens --> GENERATE API TOKEN --> Custom API Token gehen.

hier legen wir nun erst für openHAB einen Read/Write Token und dann im Anschluss für Grafana einen Read Token an.

Achtung!!! Kopiert euch die generierten Token unbedingt weg, man kann Sie nicht mehr auslesen im Nachhinein und muss sich neue generieren, solltet ihr den Token verlieren.

Konfiguration von openHAB

Beim ersten Aufruf der openHAB URL begrüsst uns ein Setup Assistent. Das erste was wir hier machen, ist einen Administrativen Benutzer einrichten:

dann unsere Lokalen Einstellungen:

nun installieren wir zusätzlich unsere Add-ons:

  • InfluxDB Persistence
  • MQTT Binding
  • die vorausgewählten Add-ons können bleiben
  • weitere Add-ons, die ihr benötigt, können aber auch später ohne Weiteres in den Einstellungen nachinstalliert werden

das war es auch schon mit dem Setup Assistent:

und nun begrüßt uns auch schon das Dashboard von openHAB 4

openHAB Persistenz mit InfluxDB

In openHAB 4 ist eines der neuen Features, dass man die Persistent komplett via UI konfigurieren kann. Dafür gehen wir in die Einstellungen --> Other Add-ons und suchen hier die vorher installierte InfluxDB Persistence und öffnen dieses Add-on.

Hier klicken wir dann auf das Zahnrad für die Einstellungen. Hier konfigurieren wir als erstes die Verbindung zur InfluxDB:

  • Datenbank-URL http://127.0.0.1:8086
  • InfluxDB 2 auswählen
  • Authentication Token eintragen (haben wir vorher angelegt und wegkopiert für openHAB (Read/Write Token))
  • Database / Organisation (wurde im .env File konfiguriert (myorg))
  • Retention Policy / Bucket (wurde im .env File konfiguriert (openhab_db))

Nun speichern wir das Ganze rechts oben mit Save.

Als nächstes klicken wir ganz oben auf den blauen Link "Persistence Configuration". Hier stellen wir nun die Regeln für die Persistierung ein.

Hier könnt ihr frei entscheiden, welche Items oder Gruppen persistiert werden sollen. Man kann zum Beispiel eine Gruppe anlegen die "persistent" heißt, dieser dann alle gewünschten Items zuweisen und diese als Gruppe auswählen. Oder man hat sowieso eine Hauptgruppe (z.B. "Home") und nutzt diese. Zusätzlich sollte man hier kann dann auch die Strategie wählen. Ich nutze immer everyUpdate und restoreOnStartup.

Dann das Ganze Speichern und fertig.

Oder ihr legt nach altem Shema folgende Datei an um alle Items zu persistieren:

/opt/openhab4/data/openhab/conf/persistence/influxdb.persist 

Strategies {
}
 
Items {
   *: strategy = everyUpdate, restoreOnStartup
}


Als letzen Schritt sagen wir openHAB noch die InfluxDB als Standard Persistence zu nutzen.

Und wieder mit Save speichern. Nun sollten die konfigurierten Items ihre Daten in der InfluxDB ablegen.

openHAB MQTT Broker anbinden

Wieder gehen wir in die Einstellungen, dann zu den Things. Unten rechts klicken wir auf das Plus Sysmbol um ein neues Thing einzurichten. Dann wählen wir das MQTT Binding aus. Dort angekommen klicken wir auf den MQTT Broker:

Als erstes haken wir "Show Advanced" an. Ihr müsst nun die folgenden Dinge konfigurieren:

  • Label (MQTT Broker)
  • Broker Hostname (YOURFQDN)
  • Broker Port (8883)
  • Sichere Verbindung (enabled)
  • Hostname bestätigt (enabled)
  • MQTT Version (5)
  • Service Qualität (mindestens einmal (1))
  • Client ID (openHAB)
  • Benutzername (mosquitto)
  • Passwort (euer angelegtes Passwort)
  • Zertifikat fixieren (disabled)
  • Öffentlicher Schlüssel anpinnen (disabled)

Ganz unten dann auf "Create Thing"

nun haben wir den Mosquitto MQTT als Bridge angelegt und können diverse Generic MQTT Things anlegen um so die Daten in openHAB zu bringen. Ich lege hier immer ein Thing für jedes Gerät an, das Daten an den MQTT schickt. Mehr dazu findet ihr hier:

Grafana Konfigurieren

Grafana erreicht ihr dann unter der URL http://YOURSERVERNAME:3000/ Der Standard User ist hier admin mit dem Passwort admin. Beim Ersten Login müsst ihr aber direkt das admin Passwort ändern. In Grafana selbst legen wir dann die InfluxDB als Datasource an, dann können wir schöne Grafiken mittels Grafana aus unseren gesammelten Persistenten Daten von opeHAB zusammenklicken.

Wir gehen in Grafana unter Home / Administration / Data sources:

Dort gehen wir auf Add Datasource und wählen die InfluxDB aus. Diese wird dann wie folgt konfiguriert:

Den API Token für grafana habt ihr euch vorher aus dem Webinterface der InfluxDB wegkopiert (READ Token). Den Rest (Default Bucket und Organization) lest ihr aus dem .env File.

Nun, nachdem alles eingerichtet ist kann man Dashboards mit Panels erstellen, die die openHAB Daten der Items verwenden. Beim neuen FLUX Query Format ist es hilfreich sich die Queries einfach im InfluxDB Webinterface zusammen zu bauen und dann anschließend diese als Script zu kopieren.


Beispiel:

from(bucket: "openhab_db")
  |> range(start: v.timeRangeStart, stop: v.timeRangeStop)
  |> filter(fn: (r) => r["_measurement"] == "laubraspi2dht22_Humidity")
  |> filter(fn: (r) => r["_field"] == "value")
  |> filter(fn: (r) => r["item"] == "laubraspi2dht22_Humidity")
  |> aggregateWindow(every: v.windowPeriod, fn: mean, createEmpty: false)
  |> yield(name: "mean")

Wenn einem dies zu umständlich ist, kann man auch bei InfluxDB 2 auf die alte InfluxDB v1 Query Language umstellen. wie das geht könnt ihr hier nachlesen:

Updaten

Bei gleichbleibender Versionen

Zum Updaten der Container einfach wie gewohnt: 

cd /opt/openhab4/
docker compose pull
docker compose up -d

oder automatisch via Watchtower:

Upgrade bei neuen Image Versionen

Möchtet ihr ein Update der Docker Image Versionen durchführen, müsst ihr zuerst, die Version, die ihr deployen wollt, in der .env anpassen. Danach könnt ihr zunächst das neue Image herunterladen und dann die Container in der neuen Version deployen.

cd /opt/openhab4/
nano .env
docker compose pull
docker compose up -d

Backup

Ein Backup kann entweder händisch oder aber Script gesteuert gemacht werden. Schaut einfach die folgenden Artikel durch:

GitHub Repository

Das Ganze findet ihr auch in GitHub als komplettes Repository:

Quellen

Abgerufen von „https://www.laub-home.de/index.php?title=OpenHAB_4_Docker_Installation&oldid=9621“