Hannah — Open Source Smart-Home-Sprachassistentin

manne01

Es tut mir leid - ich hab wohl einfach nach dem Repo umschalten nicht Refresh gedrückt. Ist mir glaub ich schonmal passiert... [[kann/sollte der Refresh nicht nach dem Speichern schon ausgelöst werden?]]
Ich bin auf ioBroker v7.8.23 und konnte den Hannah Adapter aus dem Beta Repo vollkommen reibungslos installieren.

@Leonie sagte:

Korrekt, die Install-Scripte decken das nicht ab. Offensiv gefragt, warum sollten sie es auch?

Ja, ganz klar, das war auch keine Erwartung oder sowas, sondern wirklich nur meine Erkenntnis nach dem ganzen Rumprobieren. Hatte irgendwie gedacht ich könnte es aus den Bestandteilen zusammensetzen.

@OliverIO sagte:
habe jetzt nicht im kopf was du mit systemd machen willst? aber ich vermute du willst die hannah teile als service registrieren. also genau so wie wenn du es auf einem rechner machen willst.

Genau, ich möchte quasi die bisher angedachte systemd-Struktur im Container nachbilden und die Backendservices als systemd Services laufen lassen. Ist mir aber eben nicht gelungen und wahrscheinlich macht das auch keinen Sinn, weil ich dann die Konzepte vermische.

Ganz eigene Start-Scripte möchte bzw. kann ich ehrlich gesagt nicht schreiben, ich glaube das übersteigt einfach meine Fähigkeiten und muss ja auch gepflegt werden.

Leonie

theoretisch müsstest du die Install-Scripte beim Dockerbuild ausführen können. also im Dockerfile entsprechende RUN Deklarationen.

OliverIO

@Leonie

ich habe gerade mal deine installationsanweisungen in die ki geworfen.
ki empfiehlt verschiedene images zu bauen.

hier mal copy/paste der antwort

aus sicherheitssicht gibt es ebenfalls noch einen hinweis zu UPDATE_SERVER_TOKEN weiter unten

xxx---xxx

Ja. Auf Basis der aktuellen Installer würde ich Hannah nicht als einen einzigen Container mit systemd betreiben, sondern jede Komponente als eigenen Container. Das passt deutlich besser zu Docker und bildet die vorhandene Architektur sauber ab.

Die offiziellen Services starten Core mit python main.py -c /etc/hannah/config.yaml, Proxy mit hannah-proxy --config ..., Telegram entsprechend mit main.py --config ... und Voice-ID mit app.py --config ....

Empfohlene Verzeichnisstruktur

hannah-docker/
├── docker-compose.yml
├── .env
│
├── core/
│   ├── Dockerfile
│   └── config/
│       └── config.yaml
│
├── proxy/
│   ├── Dockerfile
│   └── config/
│       └── config.yaml
│
├── telegram/
│   ├── Dockerfile
│   └── config/
│       └── config.yaml
│
├── voiceid/
│   ├── Dockerfile
│   ├── config/
│   │   └── config.yaml
│   └── voice_profiles/
│
└── data/
    └── core/

Dabei würde ich AutoDeploy zunächst weglassen. Der vorhandene AutoDeploy-Service ist darauf ausgelegt, andere systemd-Services auf dem Host zu verwalten. Das passt konzeptionell nicht gut zu Docker; Updates sollte dann Docker/Compose übernehmen.

1. Core

Da das Release vom Hannah-Update-Server kommt, bauen wir das Image ähnlich wie der Installer – nur ohne systemd.

core/Dockerfile:

FROM python:3.11-slim

ARG UPDATE_SERVER_URL=https://hannah-update.sgessinger.de
ARG CORE_CHANNEL=core-stable
ARG UPDATE_SERVER_TOKEN=""

ENV PYTHONUNBUFFERED=1
ENV HOME=/opt/hannah/core

RUN apt-get update \
    && apt-get install -y --no-install-recommends \
        curl \
        ca-certificates \
        tar \
        portaudio19-dev \
        build-essential \
    && rm -rf /var/lib/apt/lists/*

WORKDIR /opt/hannah/core

RUN set -eux; \
    AUTH=""; \
    if [ -n "$UPDATE_SERVER_TOKEN" ]; then \
        AUTH="-H Authorization:\ Bearer\ $UPDATE_SERVER_TOKEN"; \
    fi; \
    LATEST_JSON="$(curl -fsSL $AUTH \
        "${UPDATE_SERVER_URL}/latest?channel=${CORE_CHANNEL}")"; \
    VERSION="$(printf '%s' "$LATEST_JSON" \
        | python -c 'import json,sys; print(json.load(sys.stdin)["version"])')"; \
    echo "Installing Hannah Core ${VERSION}"; \
    curl -fsSL $AUTH \
        "${UPDATE_SERVER_URL}/releases/${VERSION}?channel=${CORE_CHANNEL}" \
        -o /tmp/hannah-core.tar.gz; \
    tar -xzf /tmp/hannah-core.tar.gz -C /opt/hannah/core; \
    rm /tmp/hannah-core.tar.gz

RUN pip install --no-cache-dir --upgrade pip \
    && pip install --no-cache-dir -r requirements.txt

RUN useradd --system \
        --home-dir /opt/hannah/core \
        --shell /usr/sbin/nologin \
        hannah \
    && chown -R hannah:hannah /opt/hannah/core

USER hannah

EXPOSE 50051
EXPOSE 7775/udp

CMD ["python", "main.py", "-c", "/etc/hannah/config.yaml"]

Der Core-Installer verwendet aktuell den Channel core-stable und installiert nach /opt/hannah/core; genau daran orientiert sich dieses Image.

2. Proxy

Beim Proxy ist etwas Besonderes zu beachten: Das Release unterscheidet zwischen amd64 und arm64. Das macht auch der Originalinstaller automatisch.

proxy/Dockerfile:

FROM debian:bookworm-slim

ARG UPDATE_SERVER_URL=https://hannah-update.sgessinger.de
ARG PROXY_CHANNEL=proxy-stable
ARG UPDATE_SERVER_TOKEN=""
ARG TARGETARCH

RUN apt-get update \
    && apt-get install -y --no-install-recommends \
        curl \
        ca-certificates \
        tar \
        file \
        python3 \
    && rm -rf /var/lib/apt/lists/*

RUN set -eux; \
    case "${TARGETARCH}" in \
        amd64) ARCH="amd64" ;; \
        arm64) ARCH="arm64" ;; \
        *) echo "Unsupported architecture: ${TARGETARCH}"; exit 1 ;; \
    esac; \
    CHANNEL="${PROXY_CHANNEL}-${ARCH}"; \
    AUTH=""; \
    if [ -n "$UPDATE_SERVER_TOKEN" ]; then \
        AUTH="-H Authorization:\ Bearer\ $UPDATE_SERVER_TOKEN"; \
    fi; \
    LATEST_JSON="$(curl -fsSL $AUTH \
        "${UPDATE_SERVER_URL}/latest?channel=${CHANNEL}")"; \
    VERSION="$(printf '%s' "$LATEST_JSON" \
        | python3 -c 'import json,sys; print(json.load(sys.stdin)["version"])')"; \
    echo "Installing Hannah Proxy ${VERSION} (${ARCH})"; \
    curl -fsSL $AUTH \
        "${UPDATE_SERVER_URL}/releases/${VERSION}?channel=${CHANNEL}" \
        -o /tmp/hannah-proxy.tar.gz; \
    mkdir /tmp/hannah-proxy; \
    tar -xzf /tmp/hannah-proxy.tar.gz -C /tmp/hannah-proxy; \
    install -m 755 /tmp/hannah-proxy/hannah-proxy /usr/local/bin/hannah-proxy; \
    rm -rf /tmp/hannah-proxy /tmp/hannah-proxy.tar.gz

RUN useradd --system \
    --no-create-home \
    --shell /usr/sbin/nologin \
    hannah

USER hannah

EXPOSE 7775/udp

CMD ["hannah-proxy", "--config", "/etc/hannah-proxy/config.yaml"]

3. Telegram

telegram/Dockerfile:

FROM python:3.11-slim

ARG UPDATE_SERVER_URL=https://hannah-update.sgessinger.de
ARG TELEGRAM_CHANNEL=telegram-stable
ARG UPDATE_SERVER_TOKEN=""

ENV PYTHONUNBUFFERED=1
ENV HOME=/opt/hannah/telegram

RUN apt-get update \
    && apt-get install -y --no-install-recommends \
        curl \
        ca-certificates \
        tar \
    && rm -rf /var/lib/apt/lists/*

WORKDIR /opt/hannah/telegram

RUN set -eux; \
    AUTH=""; \
    if [ -n "$UPDATE_SERVER_TOKEN" ]; then \
        AUTH="-H Authorization:\ Bearer\ $UPDATE_SERVER_TOKEN"; \
    fi; \
    LATEST_JSON="$(curl -fsSL $AUTH \
        "${UPDATE_SERVER_URL}/latest?channel=${TELEGRAM_CHANNEL}")"; \
    VERSION="$(printf '%s' "$LATEST_JSON" \
        | python -c 'import json,sys; print(json.load(sys.stdin)["version"])')"; \
    echo "Installing Hannah Telegram ${VERSION}"; \
    curl -fsSL $AUTH \
        "${UPDATE_SERVER_URL}/releases/${VERSION}?channel=${TELEGRAM_CHANNEL}" \
        -o /tmp/hannah-telegram.tar.gz; \
    tar -xzf /tmp/hannah-telegram.tar.gz -C /opt/hannah/telegram; \
    rm /tmp/hannah-telegram.tar.gz

RUN pip install --no-cache-dir --upgrade pip \
    && pip install --no-cache-dir -r requirements.txt

RUN useradd --system \
        --home-dir /opt/hannah/telegram \
        --shell /usr/sbin/nologin \
        hannah \
    && chown -R hannah:hannah /opt/hannah/telegram

USER hannah

CMD ["python", "main.py", "--config", "/etc/hannah-telegram/config.yaml"]

Das entspricht dem aktuellen systemd-Startkommando des Telegram-Bots.

4. Voice-ID

Voice-ID benötigt laut Installer PyTorch, Torchaudio und SpeechBrain. Außerdem nutzt die normale Installation /mnt/hannah_mem als 128-MB-RAM-Disk. In Compose können wir das viel eleganter über tmpfs lösen.

voiceid/Dockerfile:

FROM python:3.11-slim

ARG UPDATE_SERVER_URL=https://hannah-update.sgessinger.de
ARG VOICEID_CHANNEL=voiceid-stable
ARG UPDATE_SERVER_TOKEN=""

ENV PYTHONUNBUFFERED=1
ENV HOME=/opt/hannah/voiceid

RUN apt-get update \
    && apt-get install -y --no-install-recommends \
        curl \
        ca-certificates \
        tar \
        libsndfile1 \
    && rm -rf /var/lib/apt/lists/*

WORKDIR /opt/hannah/voiceid

RUN set -eux; \
    AUTH=""; \
    if [ -n "$UPDATE_SERVER_TOKEN" ]; then \
        AUTH="-H Authorization:\ Bearer\ $UPDATE_SERVER_TOKEN"; \
    fi; \
    LATEST_JSON="$(curl -fsSL $AUTH \
        "${UPDATE_SERVER_URL}/latest?channel=${VOICEID_CHANNEL}")"; \
    VERSION="$(printf '%s' "$LATEST_JSON" \
        | python -c 'import json,sys; print(json.load(sys.stdin)["version"])')"; \
    echo "Installing Hannah Voice-ID ${VERSION}"; \
    curl -fsSL $AUTH \
        "${UPDATE_SERVER_URL}/releases/${VERSION}?channel=${VOICEID_CHANNEL}" \
        -o /tmp/hannah-voiceid.tar.gz; \
    tar -xzf /tmp/hannah-voiceid.tar.gz -C /opt/hannah/voiceid; \
    rm /tmp/hannah-voiceid.tar.gz

RUN pip install --no-cache-dir --upgrade pip

RUN pip install --no-cache-dir \
        fastapi \
        uvicorn \
        python-multipart \
        pyyaml \
        torch \
        torchaudio \
        --index-url https://download.pytorch.org/whl/cpu

RUN pip install --no-cache-dir speechbrain

RUN useradd --system \
        --home-dir /opt/hannah/voiceid \
        --shell /usr/sbin/nologin \
        hannah \
    && mkdir -p /mnt/hannah_mem /opt/hannah/voiceid/voice_profiles \
    && chown -R hannah:hannah \
        /mnt/hannah_mem \
        /opt/hannah/voiceid

USER hannah

EXPOSE 8080

CMD ["python", "app.py", "--config", "/etc/hannah-voiceid/config.yaml"]

5. docker-compose.yml

Hier kommt alles zusammen:

services:

  hannah-core:
    build:
      context: ./core
      args:
        UPDATE_SERVER_URL: ${UPDATE_SERVER_URL:-https://hannah-update.sgessinger.de}
        UPDATE_SERVER_TOKEN: ${UPDATE_SERVER_TOKEN}
        CORE_CHANNEL: ${CORE_CHANNEL:-core-stable}

    container_name: hannah-core
    restart: unless-stopped

    volumes:
      - ./core/config/config.yaml:/etc/hannah/config.yaml:ro
      - ./data/core:/opt/hannah/core/.tts_cache

    ports:
      - "50051:50051"
      # Nur aktivieren, wenn Satelliten DIREKT mit Core sprechen:
      # - "7775:7775/udp"

    networks:
      - hannah


  hannah-proxy:
    build:
      context: ./proxy
      args:
        UPDATE_SERVER_URL: ${UPDATE_SERVER_URL:-https://hannah-update.sgessinger.de}
        UPDATE_SERVER_TOKEN: ${UPDATE_SERVER_TOKEN}
        PROXY_CHANNEL: ${PROXY_CHANNEL:-proxy-stable}

    container_name: hannah-proxy
    restart: unless-stopped

    depends_on:
      - hannah-core

    volumes:
      - ./proxy/config/config.yaml:/etc/hannah-proxy/config.yaml:ro

    ports:
      - "7775:7775/udp"

    networks:
      - hannah


  hannah-telegram:
    build:
      context: ./telegram
      args:
        UPDATE_SERVER_URL: ${UPDATE_SERVER_URL:-https://hannah-update.sgessinger.de}
        UPDATE_SERVER_TOKEN: ${UPDATE_SERVER_TOKEN}
        TELEGRAM_CHANNEL: ${TELEGRAM_CHANNEL:-telegram-stable}

    container_name: hannah-telegram
    restart: unless-stopped

    depends_on:
      - hannah-core

    volumes:
      - ./telegram/config/config.yaml:/etc/hannah-telegram/config.yaml:ro

    networks:
      - hannah


  hannah-voiceid:
    build:
      context: ./voiceid
      args:
        UPDATE_SERVER_URL: ${UPDATE_SERVER_URL:-https://hannah-update.sgessinger.de}
        UPDATE_SERVER_TOKEN: ${UPDATE_SERVER_TOKEN}
        VOICEID_CHANNEL: ${VOICEID_CHANNEL:-voiceid-stable}

    container_name: hannah-voiceid
    restart: unless-stopped

    volumes:
      - ./voiceid/config/config.yaml:/etc/hannah-voiceid/config.yaml:ro
      - ./voiceid/voice_profiles:/opt/hannah/voiceid/voice_profiles

    tmpfs:
      - /mnt/hannah_mem:size=128m,mode=1777

    expose:
      - "8080"

    networks:
      - hannah


networks:
  hannah:
    driver: bridge

Ganz wichtig: interne Hostnamen

In deinen Configs darfst du bei Docker für die Kommunikation zwischen Containern nicht mehr 127.0.0.1 verwenden.

Für proxy/config/config.yaml also beispielsweise:

proxy_id: hannah-proxy

hannah:
  address: "hannah-core:50051"

udp:
  listen_addr: ":7775"

  # Hier muss die IP des Docker-HOSTS hinein,
  # die deine Satelliten erreichen können.
  advertise_host: "192.168.8.15"

voice_id:
  enabled: true
  base_url: "http://hannah-voiceid:8080"
  timeout_sec: 3.0
  min_confidence: 0.45

Das ist besonders wichtig beim advertise_host: Hier darf nicht hannah-proxy stehen. Die Satelliten befinden sich außerhalb des Docker-Netzes und müssen deshalb die LAN-IP deines Docker-Hosts bekommen.

Für Telegram:

telegram:
  token: "DEIN_BOT_TOKEN"
  allowed_users:
    - 123456789

hannah:
  address: "hannah-core:50051"

`.env`

Im Hauptverzeichnis:

UPDATE_SERVER_URL=https://hannah-update.sgessinger.de

UPDATE_SERVER_TOKEN=DEIN_UPDATE_SERVER_TOKEN

CORE_CHANNEL=core-stable
PROXY_CHANNEL=proxy-stable
TELEGRAM_CHANNEL=telegram-stable
VOICEID_CHANNEL=voiceid-stable

Dann:

docker compose build
docker compose up -d

Logs:

docker compose logs -f hannah-core

Oder alle:

docker compose logs -f

Status:

docker compose ps

Ein Punkt, den ich noch ändern würde

Das Beispiel oben funktioniert, hat aber bei UPDATE_SERVER_TOKEN einen Docker-spezifischen Schönheitsfehler: Ein Token als ARG kann unter Umständen in Build-Metadaten landen.

Für ein dauerhaftes Produktionssetup würde ich deshalb Docker BuildKit Secrets verwenden:

RUN --mount=type=secret,id=update_token \
    UPDATE_SERVER_TOKEN="$(cat /run/secrets/update_token)" \
    ...

und dann in Compose:

build:
  secrets:
    - update_token

Das ist deutlich sauberer als ein Token über ARG.

WebUI

Die WebUI würde ich ebenfalls als eigenen Container integrieren. Da sie laut Projekt ohnehin explizit Docker unterstützt, würde ich dafür möglichst das dort vorgesehene Image/Dockerfile verwenden und sie dann einfach in dasselbe hannah-Netz hängen.

Ich würde also am Ende ungefähr diese Architektur fahren:

                         ┌───────────────────┐
Satelliten ── UDP 7775 ─▶│   hannah-proxy    │
                         └───────┬───────────┘
                                 │ gRPC
                                 ▼
                         ┌───────────────────┐
                         │    hannah-core     │
                         │       :50051       │
                         └─────┬────────┬─────┘
                               │        │
                   gRPC        │        │ MQTT / ioBroker
                               │        │
              ┌────────────────┘        └───────────▶ LAN
              │
      ┌───────▼──────────┐
      │ hannah-telegram   │
      └──────────────────┘

      ┌──────────────────┐
      │ hannah-voiceid    │◀──── HTTP ─── hannah-proxy
      │      :8080        │
      └──────────────────┘

      ┌──────────────────┐
      │ hannah-webui      │
      └──────────────────┘

Diese Variante würde ich gegenüber einem riesigen Hannah-All-in-One-Dockerfile klar bevorzugen. Sie trennt Core, Proxy, Voice-ID und Telegram, ermöglicht unabhängige Neustarts/Updates und ersetzt die bisherigen systemd-Aufgaben durch Docker Compose. Die originale Hannah-Dokumentation bestätigt auch die Rollen von Core, Proxy, Telegram und Voice-ID sowie die Ports 50051, 7775/UDP und 8080. (GitHub)

Ein weiterer Vorteil: Der Core aktiviert laut Hannah-Architektur seinen eigenen UDP-Server wieder, wenn der Proxy wegfällt. Wenn du in Docker konsequent den Proxy verwendest, würde ich deshalb nur Proxy 7775/udp nach außen publishen und beim Core den Port nicht auf den Host mappen. (GitHub)

Leonie

Klar, wenn dann eh ein Image pro Komponente. Dafür ist Docker gedacht. Ich habe auch mal eben ein Image für Core gebaut: Dockerfile

Das erwartet die Sourcefiles in src/

Starten kann man es dann so:
PS D:\hannah-test\core> docker run -it --rm -v "D:\hannah-test\core\activity_audio:/app/activity_audio" -v "D:\hannah-test\core\audio_dumps:/app/audio_dumps" -v "D:\hannah-test\core\config.yaml:/etc/hannah/config.yaml:ro" --name hannah-core hannah-core:latest
15:41:50 [INFO] hannah.main: Hannah Core dev

=======================================================
First-run: admin account created
Username : admin
Password : Q0PmWjbR4AOerEjL9cfW8g
Please change the password after first login!

Analog würde ich es für die anderen Komponeten auch machen.

Walter.O.

systemctl status hannah
Unit hannah.service could not be found.

#52

Leonie

Bei deinem Install-Befehl fehlt am Ende das "| bash", nur dann wird die Datei auch ausgeführt.

for all: Ich bin gerade an einer CI-Pipeline dran die die Images baut und dann aber auf quay.io hochlädt.

Walter.O.

@Leonie sagte:

Sorry Leonie,ich hoffe ich Nerve nicht.
So hab ich es gemacht.

$ curl -fsSL https://raw.githubusercontent.com/NurPech/hannah/master/core/deploy/install.sh | sudo bash
[sudo: authenticate] Password:
[INFO] Fetching latest core release from https://hannah-update.sgessinger.de (channel: core-stable) ...
[INFO] Latest version: v0.75.0
iob@iob:~$ systemctl status hannah
Unit hannah.service could not be found.
iob@iob:~$ curl -fsSL https://raw.githubusercontent.com/NurPech/hannah/master/proxy/deploy/install.sh | sudo bash
[INFO] Fetching latest proxy release from https://hannah-update.sgessinger.de (channel: proxy-stable-amd64) ...
[INFO] Latest version: v0.75.0 (amd64)
iob@iob:~$ curl -fsSL https://raw.githubusercontent.com/NurPech/hannah/master/telegram/deploy/install.sh | sudo bash
[INFO] Fetching latest telegram release from https://hannah-update.sgessinger.de (channel: telegram-stable) ...
[INFO] Latest version: v0.75.0
iob@iob:~$ curl -fsSL https://raw.githubusercontent.com/NurPech/hannah/master/voiceid/deploy/install.sh | sudo bash
[INFO] Fetching latest voiceid release from https://hannah-update.sgessinger.de (channel: voiceid-stable) ...
[INFO] Latest version: v0.75.0
iob@iob:~$ curl -fsSL https://raw.githubusercontent.com/NurPech/hannah/master/autodeploy/deploy/install.sh | sudo bash
[INFO] Fetching latest autodeploy release from https://hannah-update.sgessinger.de (channel: autodeploy-stable) ...
[INFO] Latest version: v0.64.1
iob@iob:~$ curl -fsSL https://raw.githubusercontent.com/NurPech/hannah-webui/refs/heads/main/deploy/install.sh | sudo bash
[INFO] Fetching latest webui release from https://hannah-update.sgessinger.de (channel: webui-stable) ...
[INFO] Latest version: v2.3.2
iob@iob:~$ systemctl status hannah
Unit hannah.service could not be found.

Leonie

@Walter.O. sagte:

ich hoffe ich Nerve nicht.

tust du nicht :D

Ich schaue es mir später an. ok?

manne01

Erstmal Danke für Eure Rückmeldungen - ihr seid echt spitze!

Nun auch von mir ein Update:
Ich habe dank der Infos von @Walter.O. und nach den nötigen Anpassungen an mein Setup nun auch fast alles mal (bis auf den Proxy) bei mir auf der Synology Container Manager ans laufen bekommen - denke ich.

Was geklappt hat:

die einzelnen Container für WebUi+Core+Telegram+voiceID laufen und die Logs sehen gut aus (bis auf 404 wegen fehlender static files)
der iobroker.hannah-Adapter und dieVerknüpfung und Kommunikation mit Hannah tut
die Verknüpfung mit meinem lokalen lemonade-ai server fürs LM uns damit das eingeben eines TextCommand an den Datenpunkt und die Rückgabe der LLM-Antwort - yayy!

Was mir noch nicht gelingt ist:

Meinen Telegram-Account zu verbinden. nachdem ich den Token in Telegram config und den WebUI Container hinterlegt habe wird im WebUI Telegram als konfiguriert angezeigt - es kommt aber im WebUI nach Click auf das Telegram-Icon eine neue Seite mit der Rückmeldung "Bot domain invalid". Zur "lokalen" Domain bei Telegram bzw. zur Domainverknüpfung mit /setdomain finde ich kaum Infos. Eine extern erreichbare Domain habe ich nicht vor. Der Telegram Chatbot antwortet also hartnäckig dass er mich nicht kennt und ich verknüpfen soll.
in der WebUI das CSS/Bilder aus dem Ordner static zu laden (sieht natürlich grausig aus, aber funktionieren tuts ja :-) )
rauszufinden wie ich die core-Datenbank so mounte, dass sie mir auf das core-Verzeichnis des Hosts gelegt wird

Aber wenn Du @Leonie jetzt eventuell bald "offizielle" Dockerfiles bereitstellt, dann teste ich auch gerne diese natürlich umgehend!

Viele Grüße und nochmal vielen vielen Dank!

Leonie

Ihr Verrückten :D

Ich habe nun die letzten Stunden damit verbracht Container Images zu bauen. Habe die Services dafür verändert, meine Pipelines überarbeitet, aber hier ist nun das Composefile mit allem drin:

services:
 hannah-core:
   image: quay.io/m1kad0/hannah-core:latest
   container_name: hannah-core
   restart: unless-stopped
   pull_policy: always
   depends_on:
     mysql-db:
       condition: service_healthy
       required: false
     mosquitto:
       condition: service_healthy
       required: false
   ports:
     - "50051:50051"
   networks:
     - hannah_network
   volumes:
     - core_activity_audio:/app/activity_audio
     - core_audio_dumps:/app/audio_dumps
     - core_data:/app/data
     - ./core-config.yaml:/etc/hannah/config.yaml:ro

 hannah-webui:
   image: quay.io/m1kad0/hannah-webui:latest
   container_name: hannah-webui
   restart: unless-stopped
   pull_policy: always
   depends_on:
     - hannah-core
   networks:
     - hannah_network
   ports:
     - "5000:5000"
   environment:
     HANNAH_WEBUI_SECRET_KEY: "SGVsbG8gV29ybGQhIFRoaXMgaXMgYSByYW5kb20gMTI4LWNoYXJhY3RlciBCYXNlNjQgc3RyaW5nIGNyZWF0ZWQgZm9yIHRlc3RpbmcgcHVycG9zZXMubmNlMXkyMw=="
     HANNAH_WEBUI_GRPC_HOST: "hannah-core"
     HANNAH_WEBUI_GRPC_PORT: "50051"

 hannah-telegram:
   image: quay.io/m1kad0/hannah-telegram:latest
   container_name: hannah-telegram
   restart: unless-stopped
   pull_policy: always
   profiles: ["full", "integrations", "telegram"]
   depends_on:
     - hannah-core
   networks:
     - hannah_network
   volumes:
     - ./telegram-config.yaml:/etc/hannah-telegram/config.yaml:ro

 hannah-proxy:
   image: quay.io/m1kad0/hannah-proxy:latest
   container_name: hannah-proxy
   restart: unless-stopped
   pull_policy: always
   profiles: ["full", "with-proxy"]
   depends_on:
     - hannah-core
   networks:
     - hannah_network
   volumes:
     - ./proxy-config.yaml:/etc/hannah-proxy/config.yaml:ro

 hannah-voiceid:
   image: quay.io/m1kad0/hannah-voiceid:latest-cpu
   container_name: hannah-voiceid
   restart: unless-stopped
   pull_policy: always
   profiles: ["full", "with-voiceid"]
   depends_on:
     - hannah-core
   networks:
     - hannah_network
   volumes:
     - ./voiceid-config.yaml:/etc/hannah-voiceid/config.yaml:ro
     - hannah_mem:/mnt/hannah_mem

 hannah-timer:
   image: quay.io/m1kad0/hannah-timer:latest
   container_name: hannah-timer
   restart: unless-stopped
   pull_policy: always
   profiles: ["full", "with-timer"]
   depends_on:
     - hannah-core
   networks:
     - hannah_network
   environment:
     HANNAH_TIMER_HANNAH_ADDRESS: "hannah-core:50051"
     HANNAH_TIMER_LOG_LEVEL: "info"
   volumes:
     - timer_data:/app/data

 mysql-db:
   image: mysql:8.0
   container_name: hannah-db
   profiles: ["full", "with-db"]
   environment:
     MYSQL_ROOT_PASSWORD: secretpassword
     MYSQL_DATABASE: hannah_db
     MYSQL_USER: hannah_user
     MYSQL_PASSWORD: hannah_pass
   networks:
     - hannah_network
   volumes:
     - mysql_data:/var/lib/mysql
   healthcheck:
     test: ["CMD", "mysqladmin", "ping", "-h", "localhost", "-u", "root", "-psecretpassword"]
     interval: 5s
     timeout: 5s
     retries: 5

 mosquitto:
   image: eclipse-mosquitto:2
   container_name: hannah-mosquitto
   profiles: ["full","with-mqtt"]
   restart: unless-stopped
   networks:
     - hannah_network
   ports:
     - "1883:1883"
     - "9001:9001"
   volumes:
     - mosquitto_data:/mosquitto/data
     - mosquitto_log:/mosquitto/log
     - ./mosquitto.conf:/mosquitto/config/mosquitto.conf:ro
   healthcheck:
     test: ["CMD-SHELL", "nc -z localhost 1883 || exit 1"]
     interval: 5s
     timeout: 3s
     retries: 5

volumes:
 core_data:
 core_activity_audio:
 core_audio_dumps:
 timer_data:
 mysql_data:
 mosquitto_data:
 mosquitto_log:
 hannah_mem:

networks:
 hannah_network:
   driver: bridge

Gestartet werden kann der ganze Stack bspw. so: docker compose --profile full up -d
Am Besten tauscht ihr dann auch entsprechende Secrets aus, alles in dem File ist von meiner Seite aus Demo, aber voll getestet.

Für VoiceID habe ich eine cpu-only Version bereitgestellt. Eine Version mit GPU-Unterstützung kann ich aktuell nicht bauen, zumindest nicht automatisiert.

Mitgestartet wird auch ein MySQL-Server, der für den Activity Log genutzt wird. Warum ein MySQL-Server? Weil Hannah bei mir komplett auf einem Raspberry Pi läuft und ich mit der Datenbank für den Activty Log, die naturgemäß eine Menge Schreiboperationen aufweisen kann, die SD-Karte nicht belasten will.
Außerdem wird ein Mosquitto, als MQTT-Broker gestartet. Ich denke der ein oder andere von euch wird bereits einen Broker einsetzen, für alle anderen, ist hier die Vorlage.

Ich habe euch auch gleich einen Service dazu gepackt, den ich noch nicht vorgestelt habe: hannah-timer. Das ist ein Timerbackend für Core. Der hält alle Timer die Core stellen mag persistent. Egal ob man Wecker stellt, ob man sich an irgendwas erinnern lassen möchte oder einfach nur einer Eieruhr stellt, dieser Service sorgt für die Integrität.
Warum ein eigener Service? In der Entwicklung hat sich gezeigt das Core bei mir öfter neustarten muss, auch bspw. aufgrund von Updates. Timer ist so stabil, das er bereits seit Monaten bei mir ohne Downtime laufen kann. Außerdem kann so die ganze Timer-Logik aus dem Core draußen bleiben. Timer informiert Core aktiv, wenn ein Timer abgelaufen ist und stellt ihm wieder die Informationen bereit, die Core braucht um Aktionen zu ergreifen.

Eventuell bekommen in Zukunft noch weitere Services Unterstützung fürs Environment. Ich verstehe schon, das es sich doof anfühlt bspw. für den Proxy eine Configdatei mit 6 Zeilen zu schreiben, während timer bspw. Environment-Variablen hat. Faktisch unterstützen die meisten Services es nicht, da sind dann Configs notwendig.

Und natürlich werden die Images jetzt nicht bei mir gehostet, das heißt, die sollten zu jeder Zeit abrufbar sein :D

Liebe Grüße
Leonie

Leonie

@manne01 sagte:

Meinen Telegram Account zu verbinden - es kommt "Bot domain invalid" und meine "lokale" Domain bei Telegram mit /setdomain zu verknüpfen macht doch irgendwie keinen Sinn? Zur Domainregistrierung finde ich kaum Infos.

Ich ziehe das nochmal nach.
Leider habe ich selbst keinen Einfluss auf das was Telegram verlangt. Hannah nutzt ein "Login with Telegram" in der WebUI für die Verknüpfung. Dafür benötigt der BotFather eine Domain, die Domain unter der die WebUI erreichbar ist.
Leider funktionieren da keine IP-Adressen und keine lokalen Domains. Telegram erfordert eine öffentliche überprüfbare Domain. Nicht falsch verstehen, die WebUI muss nur eine öffentliche Domain nutzen, nicht aus der Öffentlichkeit erreichbar sein.
Ja, ist nicht ideal, aber den Ablauf gibt leider Telegram vor.
Ich selbst habe glücklicherweise eine eigene Domain. Unter der kann ich meine WebUI aufrufen und Telegram ist glücklich. Damit ich die aber aufrufen kann, muss ich zu Hause sein. Aus dem Internet geht es nicht.
An der Stelle mag ich schonmal sagen, das eine DynDNS-Adresse bspw. von MyFritz! schon ausreichend ist, damit der BotFather zu Frieden ist.

Liebe Grüße
Leonie

manne01

Wow🤩 Freue mich riesig drauf das Compose einzurichten und melde mich wieder.
DANKE @Leonie !
Ich hoffe dass das den Anwenderkreis am Ende auch nochmal so deutlich erweitert wie ich mir das vorstelle👍

Okay, und eine Domain habe ich grundsätzlich schon auch, ich probiere es damit nochmal.

OliverIO

@Leonie sagte:

An der Stelle mag ich schonmal sagen, das eine DynDNS-Adresse bspw. von MyFritz! schon ausreichend ist, damit der BotFather zu Frieden ist.

wer einen port nach außen öffnet, sollte unbedingt einen
reverse proxy einsetzen um die Angriffsfläche zu verkleinern.
Weiterhin das noch mit fail2ban absichern, was aber ein wenig Beobachtung und Konfiguration erfordert

beides ist als dockercontainer verfügbar.
einen container mit dem reverse proxy ist sehr einfach
durch ein paar zusätzliche Anweisungen im docker compose welcher dann im internet auf anfragen horchen soll.
https://hub.docker.com/r/jwilder/nginx-proxy
https://hub.docker.com/r/linuxserver/fail2ban

kleine werbung in eigener Sache: Wer fail2ban mit einer webgui überwachen möchte kann sich diesen Container anschauen, leider ist die kommandozeile von fail2ban etwas grausam:
https://hub.docker.com/r/oweitman/fail2bancontrol
und zur Überwachung im iobroker:
https://github.com/oweitman/ioBroker.fail2bancontrol

Community Forum

NEWS

Hannah — Open Source Smart-Home-Sprachassistentin

Empfohlene Verzeichnisstruktur

1. Core

2. Proxy

3. Telegram

4. Voice-ID

5. docker-compose.yml

Ganz wichtig: interne Hostnamen

`.env`

Ein Punkt, den ich noch ändern würde

WebUI

=======================================================
First-run: admin account created
Username : admin
Password : Q0PmWjbR4AOerEjL9cfW8g
Please change the password after first login!

Support us

132

33.0k

83.7k

1.3m

Community Forum

NEWS

Hannah — Open Source Smart-Home-Sprachassistentin

Empfohlene Verzeichnisstruktur

1. Core

2. Proxy

3. Telegram

4. Voice-ID

5. docker-compose.yml

Ganz wichtig: interne Hostnamen

.env

Ein Punkt, den ich noch ändern würde

WebUI

======================================================= First-run: admin account created Username : admin Password : Q0PmWjbR4AOerEjL9cfW8g Please change the password after first login!

Support us

132

33.0k

83.7k

1.3m

`.env`

=======================================================
First-run: admin account created
Username : admin
Password : Q0PmWjbR4AOerEjL9cfW8g
Please change the password after first login!