OpenHAB 3 Docker Installation

Aus Laub-Home Wiki

Hier wird beschrieben wie man OpenHAB in der Version 3 (sucht ihr eine Anleitung für OpenHAB 4, dann hier) mit nützlichen Tools wie Grafana und Mosquitto MQTT mittels Docker Compose Projekt deployt und grundeinrichtet. Für die Persistenz habe ich eine InfluxDB 2 gewählt. Grafana speichert seine Konfiguration in einer Postgres DB und wird noch durch den Renderer erweitert um bei Alerts auch die Grafiken via Mail zu erhalten. Dafür solltet ihr mindestens einen Raspberry Pi 3 B+ oder besser ein Raspberry Pi 4 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 zum Laufen.

Docker Compose Projekt

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

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

cd /opt/openhab3

Nun legen wir unsere Projekt Konfigurationsdatei an:

/opt/openhab3/.env

# Config File for openHAB Application

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

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

# InfluxDB Configuration
INFLUXDB_VERSION=2.7
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=10.0.1
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=14
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 Mails von Grafana haben möchtet, bitte Grafana Mailing anpassen und GF_SMTP_ENABLED=true setzen!

Bitte ändert bei der Postgres DB das Passwort!

nun noch unser docker-compose.yml.

/opt/openhab3/docker-compose.yml

version: '3.8'

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:
          - influxdb
  
  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
    #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'
    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_AUTH_ANONYMOUS_ENABLED=true
      - GF_SECURITY_ALLOW_EMBEDDING=true
      - 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
      - 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
      - TZ=${TZ}
    labels:
      - "com.centurylinklabs.watchtower.enable=true"
#    network_mode: host      
    networks:
      - app-nw
      - backend-nw

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

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, mit dem sich die Backend Dienste unterhalten.
  • Für persistente Daten werden Volumes erstellt
  • Konfigurationsdateien werden in den Compose Projektordner ausgelagert
  • openhab, influxdb2, mosquitto, grafana und renderer werden als Container gestartet
  • Das Label - "com.centurylinklabs.watchtower.enable=true" dient dazu das eine automatische Aktualisierung der Container von Watchtower stattfindet

Mosquitto Konfiguration

Zuerst generieren wir hier die SSL Zertifikate, damit wir den Mosquitto verschlüsselt nutzen können

cd /opt/openhab3/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/openhab3/certs/generate-certs.sh 

COMPOSE_PROJECT_DIR="/opt/openhab3"
IP="laub-server.laub.loc"

Dann das Script zum generieren der Zertifikate einfach starten: 

./generate-certs.sh

nun erstellen wir das Konfigurationsfile:

/opt/openhab3/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 3 Compose Projektes

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

cd /opt/openhab3
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/openhab3
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 and Write Token und dann 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 unsere Add-ons:

  • InfluxDB Persistence
  • MQTT Binding
  • 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 3

openHAB Persistenz mit InfluxDB

Dafür legen wir als erstes die Persistence Strategie und Regel Konfiguration an. Dies geht momentan nur über eine Konfigurationsdatei, die wir unter /opt/openhab3/data/openhab/conf/persistence/ ablegen:

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

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

Diese sehr einfach Konfiguration sorgt einfach nur dafür das alle Items bei jedem Update ihren Zustand persistieren und das der letzte Zustand aus der Datenbank bei einem openHAB Neustart direkt als Item Wert verwendet wird. Mehr findet ihr hier.

Um nun die InfluxDB Datenbank als Persistenz mit openHAB zu verbinden, gehen wir in die Einstellungen und konfigurieren unsere/n hochgefahrene und eingerichtete openhab_db InfluxDB Bucket / Datenbank.

nun wählen wir die InfluxDB 2 aus und konfigurieren den Zugang:

Hier den API Key aus dem InfluxDB Webinterface kopieren. Die Organisation und das Bucket stehen im .env file.

Nun wählen wir noch die InfluxDB als Standard Persistence aus.

Und wieder mit Save speichern.

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 (Local MQTT Broker)
  • Broker Hostname (YOURFQDN)
  • Broker Port (8883)
  • Secure Connection (enabled)
  • Client ID (openHAB3)
  • Quality of Service (At least once (1))
  • Username (mosquitto)
  • Password (euer angelegtes Passwort)
  • Certificate Pinning (disabled)
  • Public Key Pinning (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 Einstellungen / Data Sources:

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

Den API Token (grafana) bekommt ihr wieder aus dem Webinterface der InfluxDB (READ Token). den Rest 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/openhab3/
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/openhab3/
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_3_Docker_Installation&oldid=9321“