Stand: November 2026
Komodo ist eine Weboberfläche für Docker. Du legst darin Anwendungen an, bearbeitest ihre Konfiguration im Browser, startest sie neu und liest ihre Protokolle mit. Komodo ersetzt Docker nicht, es steuert es – auf einem Gerät oder auf mehreren aus derselben Oberfläche.
In dieser Reihe ist Komodo ab jetzt der Weg, auf dem jede weitere Anwendung auf die NAS kommt. Docker läuft seit Artikel 04 – bisher hast du damit nur die beiden gemeinsamen Netze angelegt.
Den Container Manager aus Artikel 04 lässt du dabei links liegen. Er bleibt installiert, weil er Docker mitbringt, aber angelegt und geändert wird ab jetzt nur noch in Komodo – warum, steht in Artikel 04.
Komodo ist ausschließlich über das private Netzwerk aus Artikel 05 erreichbar. Kein offener Port, keine Domain, kein Anmeldeformular, das irgendwer von außen findet.
Am Ende hast du
- Komodo auf der NAS installiert, mit Datenbank und Agent
- Die Oberfläche erreichbar unter
http://nas:9120, nur über das private Netz - Ein Administratorkonto angelegt und die Registrierung wieder geschlossen
- Die NAS als verwalteten Server in der Oberfläche, mit Live-Daten
- Die Variablen
DOCKER_ROOTundDATA_ROOTangelegt - Einen Probelauf gemacht: eine Anwendung über die Oberfläche angelegt, gestartet und wieder entfernt
- Komodos tägliche Sicherung der eigenen Datenbank in einem Verzeichnis, das mitgesichert wird
- Verstanden, warum genau dieser eine Stack von Hand entsteht und alle folgenden nicht
Voraussetzungen
- Artikel 04 abgeschlossen: Freigabeordner
dockerangelegt,homelab_netundhomelab_internexistieren - Artikel 05 abgeschlossen: Tailscale läuft auf der NAS, dem Laptop und dem Handy
- Zugang zur NAS über SSH
- Die private Adresse deiner NAS (
100.x.x.x) – wir holen sie gleich noch einmal
In diesem Artikel steht durchgängig
/volume2/docker. Setz dort den Pfad ein, den du in Artikel 04 notiert hast – bei dir kann er/volume1/dockerheißen.
Docker-Befehle laufen mit
sudo, wie in Artikel 04 begründet. Verzeichnisse und Dateien legst du dagegen ohne an – sonst gehören sie root, und du kannst sie später nicht mehr selbst bearbeiten.
Getestet mit: UGOS Pro 1.21.1.0016 · Docker Engine 29.6.2 · Komodo 2.3.4 · FerretDB 2.7.0
Zuletzt durchgespielt: November 2026 auf einer DXP2800
1. Was Komodo macht
Im Einzelnen:
- Alle Container auf einen Blick, mit Status, Prozessorlast und Speicherverbrauch
- Protokolle in Echtzeit im Browser, ohne Terminal
- Konfigurationsdateien direkt in der Oberfläche bearbeiten
- Starten, stoppen, neu ausrollen per Klick
- Erkennen, wenn es neue Versionen der verwendeten Container-Abbilder gibt
- Benachrichtigen, wenn etwas ausfällt
Zwei Teile: Core und Periphery
| Teil | Aufgabe |
|---|---|
| Core | Die Oberfläche, die du im Browser aufrufst. Speichert deine Anwendungsdefinitionen, Anmeldedaten und die Historie. |
| Periphery | Ein Agent, der auf dem verwalteten Gerät läuft und dort die eigentlichen Docker-Befehle ausführt. |
Auf einem einzelnen Gerät laufen beide nebeneinander. Die Trennung wirkt an dieser Stelle überflüssig und zahlt sich später aus: Kommt irgendwann ein zweites Gerät dazu, installierst du dort nur Periphery – die Oberfläche bleibt eine einzige.
Im fertigen Aufbau laufen vier Container: Core, Periphery, eine PostgreSQL-Datenbank und FerretDB als Übersetzer dazwischen. Komodo spricht MongoDB, FerretDB übersetzt das nach PostgreSQL. Du musst mit keinem der beiden je direkt arbeiten.
Wie sich Core und Periphery erkennen
Beide erzeugen beim ersten Start je ein Schlüsselpaar und legen es in einem Speicher ab, auf den beide zugreifen. Am Ende liegen dort vier Dateien: core.key, core.pub, periphery.key und periphery.pub. In der Konfiguration steht jeweils, wo der öffentliche Schlüssel des anderen liegt – ab da authentifizieren sie sich gegenseitig darüber. Du musst kein Geheimnis erzeugen, kopieren oder synchron halten.
⚠️ Was du Komodo damit gibst
Periphery bekommt Zugriff auf den Docker-Steuerkanal der NAS. Ein Container mit diesem Zugriff kann faktisch alles auf dem Gerät tun – Container starten, Verzeichnisse einbinden, Rechte ausweiten. Das ist bei jeder Docker-Verwaltungsoberfläche so, egal welche.
Genau deshalb steht Komodo hinter dem privaten Netz und nicht hinter einem Anmeldeformular im Internet. Halt dich an diese Regel, auch wenn dir später eine bequemere Variante begegnet.
2. Erreichbar nur über das private Netz
Docker kann einen Port entweder auf allen Netzwerkadressen des Geräts veröffentlichen oder gezielt auf einer einzigen. Wir wählen die zweite Variante und binden Komodos Port 9120 ausschließlich an die Adresse aus dem privaten Netz. Auf der Heimnetz-Adresse der NAS ist dann nichts zu erreichen.
🗄️ Auf der NAS, Adresse ermitteln:
tailscale ip -4
Check
Ausgabe: Eine Adresse aus dem Bereich 100.x.x.x. Schreib sie auf, du trägst sie gleich zweimal ein.
Und einmal gegenprüfen, dass die NAS diese Adresse tatsächlich auf einer Netzwerkschnittstelle trägt:
ip -4 addr show tailscale0
Check
Ausgabe: Eine Zeile mit inet 100.x.x.x.
Genau diese Adresse muss existieren, bevor Komodo startet – Docker kann einen Port nur auf einer Adresse veröffentlichen, die es beim Start vorfindet. Nach einem Neustart der NAS kann es deshalb einen Moment dauern, bis die Oberfläche erreichbar ist. Komodo versucht es von selbst erneut. Der Weg zurück, falls etwas klemmt, ist immer SSH aus dem Heimnetz.
3. Die eine Ausnahme
Ab dem nächsten Artikel legst du jede Anwendung über die Komodo-Oberfläche an. Für Komodo selbst geht das nicht – es kann sich nicht selbst ausrollen. Dieser eine Stack entsteht daher von Hand über SSH – so, wie du in Artikel 05 auch Tailscale von Hand installiert hast.
Danach ist Schluss damit. Wenn du irgendwann Komodos eigene Konfiguration änderst oder Komodo aktualisierst, machst du das wieder auf diesem Weg.
Wo die Anwendungen später liegen: direkt im Freigabeordner aus Artikel 04, also /volume2/docker/<name>/. Komodo legt diese Unterordner selbst an – du musst nie wieder ein Verzeichnis vorbereiten. Damit das funktioniert, bekommt Periphery den Freigabeordner eingebunden und die Angabe, dass die Anwendungen genau dort hingehören. Ohne diese Angabe legt Komodo sie in einem eigenen Verzeichnis irgendwo im System ab, und du suchst sie beim ersten Backup vergeblich.
4. Das Verzeichnis anlegen
Ein Verzeichnis brauchst du, und zwar für die beiden Dateien, die du gleich schreibst:
mkdir -p /volume2/docker/komodo
Den Freigabeordner docker darüber hast du in Artikel 04 über die NAS-Oberfläche angelegt – das war dort Pflicht, weil nur so entstandene oberste Ebenen im Dateimanager auftauchen. Für alles darunter gilt das nicht: Unterordner sind gewöhnliche Verzeichnisse und dürfen über die Kommandozeile entstehen. Genau das macht Komodo ab dem nächsten Artikel auch selbst.
Check
ls -ld /volume2/docker/komodo
Ausgabe: Eine Zeile mit dem Verzeichnis.
Schau kurz auch im Dateimanager der NAS-Oberfläche nach – der Ordner sollte unter docker sichtbar sein.
Für die Datenbank legst du nichts an. Postgres, FerretDB und die Schlüssel bekommen Speicher, den Docker selbst verwaltet und beim ersten Start anlegt. Das ist die Ausnahme von der Regel „alles in den Freigabeordner", und sie hat einen Grund: Eine Datenbankdatei, die von einem Container laufend beschrieben wird, gehört nicht in eine Netzwerkfreigabe. Sicherbar ist sie trotzdem: Komodos eigene Datenbank schreibt jede Nacht einen Abzug in den Freigabeordner (Abschnitt 13), bei den Anwendungen übernimmt das das Backup in Phase 4. Ein kopiertes Datenverzeichnis im laufenden Betrieb wäre ohnehin kein verlässliches Backup.
Für alles, was du selbst bearbeitest – Konfigurationsdateien, Nutzdaten, hochgeladene Fotos – bleibt es beim Freigabeordner. In den Stacks dieser Einrichtung steht der Pfad ausgeschrieben, wie hier; die App-Artikel setzen stattdessen die Variable aus Abschnitt 11 ein.
5. Zufallswerte erzeugen
Komodo braucht drei Geheimnisse: ein Datenbank-Passwort und zwei Schlüssel für interne Zwecke.
echo "DB-Passwort: $(openssl rand -hex 24)"
echo "JWT-Schlüssel: $(openssl rand -hex 32)"
echo "Webhook-Schlüssel: $(openssl rand -hex 24)"
Lass die Ausgabe im Terminal stehen – im nächsten Abschnitt kopierst du die drei Werte von dort in die Konfigurationsdatei. Extra aufheben musst du sie nicht: Danach stehen sie in dieser Datei.
Warum hexadezimal?
openssl rand -hexerzeugt nur Ziffern und die Buchstaben a bis f. Damit kann keiner der Werte etwas kaputtmachen: Das Datenbank-Passwort landet in einer Verbindungsadresse der Formmongodb://benutzer:passwort@host, in der+,/und=eine eigene Bedeutung haben, und ab Artikel 07 stehen Geheimnisse in Konfigurationswerten, in denen$eine eigene Bedeutung hat. Ein Zeichensatz für alle Werte erspart dir die Frage, welcher wo hingehört.
⚠️ Übernimm niemals Beispielwerte aus Anleitungen – auch nicht aus dieser. Ein Geheimnis, das öffentlich in einem Artikel steht, ist keines mehr.
6. Die Konfigurationsdatei
nano /volume2/docker/komodo/.env
Inhalt – die Platzhalter in spitzen Klammern durch deine Werte ersetzen:
####################################
# Komodo – Konfiguration
####################################
# Version der Komodo-Abbilder
COMPOSE_KOMODO_IMAGE_TAG=2
# Unter welcher Adresse Komodo erreichbar ist
KOMODO_HOST=http://<PRIVATE-ADRESSE>:9120
KOMODO_TITLE=Komodo
# Auf welcher Adresse der Port veröffentlicht wird
TAILSCALE_IP=<PRIVATE-ADRESSE>
# Datenbank
KOMODO_DATABASE_USERNAME=komodo
KOMODO_DATABASE_PASSWORD=<DB-PASSWORT>
# Geheimnisse
KOMODO_JWT_SECRET=<JWT-SCHLUESSEL>
KOMODO_WEBHOOK_SECRET=<WEBHOOK-SCHLUESSEL>
# Anmeldung
KOMODO_LOCAL_AUTH=true
KOMODO_DISABLE_USER_REGISTRATION=false
KOMODO_DISABLE_NON_ADMIN_CREATE=false
KOMODO_TRANSPARENT_MODE=false
KOMODO_JWT_TTL="1-day"
# Wie oft Komodo nachsieht
KOMODO_MONITORING_INTERVAL="15-sec"
KOMODO_RESOURCE_POLL_INTERVAL="5-min"
# Anmeldung über fremde Dienste aus
KOMODO_OIDC_ENABLED=false
KOMODO_GITHUB_OAUTH_ENABLED=false
KOMODO_GOOGLE_OAUTH_ENABLED=false
# Name, unter dem die NAS in der Oberfläche erscheint
KOMODO_FIRST_SERVER_NAME=nas
# Schlüsseltausch zwischen Core und Periphery
KOMODO_PERIPHERY_PUBLIC_KEY=file:/config/keys/periphery.pub
# Der Agent
PERIPHERY_CORE_ADDRESS=ws://core:9120
PERIPHERY_CONNECT_AS=${KOMODO_FIRST_SERVER_NAME}
PERIPHERY_CORE_PUBLIC_KEYS=file:/config/keys/core.pub
PERIPHERY_ROOT_DIRECTORY=/volume2/docker/komodo/periphery
PERIPHERY_STACK_DIR=/volume2/docker
# Zeitzone
TZ=Europe/Berlin
Speichern mit Strg + X, Y, Enter.
Rechte einschränken – in der Datei stehen jetzt Passwörter im Klartext:
chmod 600 /volume2/docker/komodo/.env
Check
grep -n "<" /volume2/docker/komodo/.env
Ausgabe: keine. Kommt eine Zeile zurück, ist dort ein Platzhalter stehen geblieben – spitze Klammern gibt es in keinem der echten Werte. Diese Prüfung ist nicht Formsache: Bei KOMODO_DATABASE_PASSWORD fällt ein Platzhalter sofort auf, weil der Stack nicht startet. Bei KOMODO_HOST startet er, und die Zeile fällt erst später auf.
Zu zwei Zeilen kurz die Begründung:
KOMODO_DISABLE_USER_REGISTRATION=falseerlaubt gleich das Anlegen des ersten Kontos. Sobald das steht, drehen wir den Wert um.
PERIPHERY_STACK_DIR=/volume2/dockerist die Zeile aus Abschnitt 3: Sie legt fest, dass alle künftigen Anwendungen im Freigabeordner landen und nicht irgendwo im System.
7. Die Compose-Datei
nano /volume2/docker/komodo/compose.yaml
name: komodo
services:
postgres:
image: ghcr.io/ferretdb/postgres-documentdb:17-0.107.0-ferretdb-2.7.0
container_name: komodo-postgres
restart: unless-stopped
labels:
komodo.skip: ""
environment:
POSTGRES_USER: ${KOMODO_DATABASE_USERNAME}
POSTGRES_PASSWORD: ${KOMODO_DATABASE_PASSWORD}
POSTGRES_DB: postgres
volumes:
- postgres-data:/var/lib/postgresql/data
networks:
- komodo_internal
ferretdb:
image: ghcr.io/ferretdb/ferretdb:2.7.0
container_name: komodo-ferretdb
restart: unless-stopped
labels:
komodo.skip: ""
environment:
FERRETDB_POSTGRESQL_URL: postgres://${KOMODO_DATABASE_USERNAME}:${KOMODO_DATABASE_PASSWORD}@postgres:5432/postgres
FERRETDB_TELEMETRY: disable
depends_on:
- postgres
volumes:
- ferretdb-state:/state
networks:
- komodo_internal
core:
image: ghcr.io/moghtech/komodo-core:${COMPOSE_KOMODO_IMAGE_TAG}
container_name: komodo-core
init: true
restart: unless-stopped
labels:
komodo.skip: ""
env_file: .env
environment:
KOMODO_DATABASE_ADDRESS: ferretdb:27017
ports:
- "${TAILSCALE_IP}:9120:9120"
volumes:
- keys:/config/keys
- /volume2/docker/komodo/backups:/backups
depends_on:
- ferretdb
networks:
- komodo_internal
- homelab_net
periphery:
image: ghcr.io/moghtech/komodo-periphery:${COMPOSE_KOMODO_IMAGE_TAG}
container_name: komodo-periphery
init: true
restart: unless-stopped
labels:
komodo.skip: ""
env_file: .env
volumes:
- keys:/config/keys
- /var/run/docker.sock:/var/run/docker.sock
- /proc:/proc
- /volume2/docker:/volume2/docker
depends_on:
- core
networks:
- komodo_internal
volumes:
postgres-data:
ferretdb-state:
keys:
networks:
komodo_internal:
name: komodo_internal
homelab_net:
external: true
Speichern und schließen.
Was hier passiert
| Zeile | Bedeutung |
|---|---|
name: komodo |
Fester Projektname, damit Docker nicht den Verzeichnisnamen rät. |
komodo.skip: "" |
Markiert diese Container als „nicht anfassen". Komodo lässt seinen eigenen Stack dadurch in Ruhe. |
init: true |
Sorgt für sauberes Aufräumen beendeter Prozesse im Container. |
postgres mit DocumentDB-Abbild |
PostgreSQL mit einer Erweiterung, die FerretDB voraussetzt. |
postgres und ferretdb mit fester Version |
Die beiden gehören zusammen: Die Marke von postgres-documentdb nennt die FerretDB-Version, zu der sie passt (…-ferretdb-2.7.0). Ohne feste Marke holte das Update in Abschnitt 13 ungesehen eine neue Fassung – der Komodo-Stack ist von Poll for Updates ausgenommen. |
FERRETDB_TELEMETRY: disable |
FerretDB schickt sonst regelmäßig einen Nutzungsbericht an den Hersteller und fragt dabei nach neuen Versionen. Die Versionsprüfung brauchst du nicht – die Version steht fest und wird nur bewusst angehoben. |
volumes: unten |
Drei von Docker verwaltete Speicherbereiche: Datenbank, FerretDB-Zustand und die Schlüssel. Docker legt sie beim ersten Start an. |
keys in Core und Periphery |
Derselbe Speicher in beiden Containern – nur so finden sie die Schlüsselpaare aus Abschnitt 1. Er muss erhalten bleiben, sonst müssen sich beide bei jedem Neustart neu bekannt machen. |
ports: "${TAILSCALE_IP}:9120:9120" |
Der Port wird ausschließlich auf der privaten Adresse veröffentlicht. |
core mit /backups |
Hierhin schreibt Komodo jede Nacht eine Sicherung seiner eigenen Datenbank. Ohne diese Zeile landen die Abzüge nur im Container und sind beim nächsten Update weg. Das Verzeichnis legt Docker beim ersten Start an. |
core in beiden Netzen |
Im internen Netz für die Datenbank, in homelab_net für alles Weitere. |
periphery ohne ports |
Der Agent ist von außen nicht erreichbar; Core spricht ihn über seinen Namen an. |
/var/run/docker.sock |
Der Steuerkanal zu Docker. Ohne ihn kann Periphery nichts ausführen. |
/proc |
Damit Periphery Prozessorlast und Speicher des Geräts auslesen kann. |
/volume2/docker:/volume2/docker |
Der Freigabeordner, innen unter demselben Pfad wie außen. Diese Gleichheit ist wichtig: Periphery gibt Pfade an Docker weiter, und Docker liest sie als Pfade des Geräts. Über diesen einen Eintrag erreicht Periphery beides – die Verzeichnisse der Anwendungen und sein eigenes Arbeitsverzeichnis. |
Eine bewusste Abweichung von Artikel 04: Das interne Netz bekommt hier kein
internal: true. Komodo sieht regelmäßig nach, ob es neue Versionen der verwendeten Abbilder gibt, und verschickt später Benachrichtigungen – beides braucht einen Weg nach draußen. Bei den Anwendungen der App-Artikel ist das anders: Dort wird die Datenbank abgeriegelt, weil sie mit der Außenwelt nichts zu tun hat.
8. Starten
cd /volume2/docker/komodo
sudo docker compose up -d
Beim ersten Start passiert einiges: PostgreSQL richtet sich ein (das kann eine Minute dauern), FerretDB verbindet sich, Core kommt hoch und legt sein Schlüsselpaar an, Periphery ebenso.
Check
sudo docker compose ps
Ausgabe: Vier Container mit Status Up:
NAME STATUS PORTS
komodo-core Up 30 seconds 100.x.x.x:9120->9120/tcp
komodo-ferretdb Up 35 seconds
komodo-periphery Up 30 seconds
komodo-postgres Up 1 minute
Achte auf die Portspalte bei komodo-core: Dort muss deine private Adresse stehen, nicht 0.0.0.0.
Dass sich die beiden Teile gefunden haben, steht im Protokoll:
sudo docker compose logs periphery | grep -i "logged in"
Ausgabe: Eine Zeile in der Art Logged in to Komodo Core core:9120 websocket as Server nas.
Zwei Meldungen im Protokoll, die harmlos sind.
Failed to connect to websocket … Connection refuseddirekt beim Start: Periphery ist schneller oben als Core. Es versucht es alle paar Sekunden erneut, und die Erfolgsmeldung von oben steht kurz darauf darunter.
Failed to resolve host public ip: Periphery versucht, die öffentliche Adresse des Anschlusses über einen fremden DNS-Dienst zu ermitteln. Auf einer NAS im Heimnetz scheitert das oft – etwa weil kein IPv6 anliegt oder ein Werbefilter dazwischensteht. Gebraucht wird der Wert nicht; er füllt nur ein Anzeigefeld.Ein Verzeichnis
peripheryunter/volume2/docker/komodo/suchst du an dieser Stelle übrigens vergeblich. Periphery legt seine Arbeitsverzeichnisse erst an, wenn es sie braucht – beim ersten ausgerollten Stack.
9. Erster Aufruf
💻 Im Browser, auf einem Gerät, das im privaten Netz angemeldet ist:
http://nas:9120
Der Name kommt aus Artikel 05. Über die private Adresse, http://100.x.x.x:9120, kommst du ebenso hin.
Die Warnung „Nicht sicher" ist hier in Ordnung. Du rufst die Seite über
http://auf, also ohne Zertifikat – deshalb meckert der Browser. Die Verbindung läuft aber durch den verschlüsselten Tunnel des privaten Netzes. Zertifikate richten wir im nächsten Artikel ein, und zwar für die Anwendungen, nicht für die Verwaltungsoberfläche.
Konto anlegen
Beim ersten Aufruf erscheint ein Formular, das gleichzeitig Anmeldung und Registrierung ist – ein getrennter Registrieren-Knopf fehlt.
- Benutzernamen eintragen
- Passwort vergeben, mindestens zwölf Zeichen, am besten aus dem Passwort-Manager
- Auf Sign Up klicken
Das erste Konto bekommt automatisch alle Rechte. Du bist danach angemeldet.

Registrierung schließen
🗄️ Auf der NAS, sofort danach, damit niemand sonst ein Konto anlegen kann:
nano /volume2/docker/komodo/.env
Diese Zeile ändern:
KOMODO_DISABLE_USER_REGISTRATION=true
Speichern, dann:
cd /volume2/docker/komodo
sudo docker compose up -d
Docker erneuert nur die Container, die es betrifft. Datenbank und FerretDB laufen unverändert weiter.
Check
Im privaten Browserfenster die Oberfläche aufrufen: Jetzt erscheint nur noch die Anmeldung.
10. Die NAS in der Oberfläche
Du musst nichts verbinden – das ist beim ersten Start bereits passiert. Core und Periphery haben ihre Schlüssel ausgetauscht, und KOMODO_FIRST_SERVER_NAME hat den Eintrag für die NAS angelegt.
💻 Im Browser, links im Menü unter Servers sollte stehen:
- Name:
nas - Status: grün
Klick ihn an. Im Hauptbereich erscheinen Prozessorlast, Speicher, Plattenbelegung und die laufenden Container. Wenn das angezeigt wird, funktioniert die Verbindung zwischen beiden Teilen.

Den Namen lässt du so. Core ordnet die Anmeldung des Agenten über den Namen zu: Der Eintrag in der Oberfläche muss Zeichen für Zeichen so heißen wie
PERIPHERY_CONNECT_ASin der Konfigurationsdatei. Benennst du ihn später in der Oberfläche um, musst du die Zeile mitziehen – sonst meldet sich Periphery an, findet keinen passenden Eintrag, und der Server steht auf „is not connected".
11. Zwei Variablen anlegen
Bevor die erste Anwendung dazukommt, legst du zwei Werte an, die Komodo später in jede Compose-Datei einsetzt. Das ist der Grund, warum die App-Artikel dieser Reihe eine Compose-Datei zeigen, die auf der NAS und auf einem Mietserver gleichermaßen funktioniert: Die Pfade stehen nicht in der Datei, sondern hier.
- Unten links auf Settings, dann auf den Reiter Variables
- + New Variable, zweimal:
| Name | Wert |
|---|---|
DOCKER_ROOT |
/volume2/docker |
DATA_ROOT |
/volume1 |
Die Option Secret bleibt bei beiden aus – es sind Pfade, keine Geheimnisse.
Setz hier deine eigenen Pfade ein.
DOCKER_ROOTist der Freigabeordner aus Artikel 04; bei dir kann er/volume1/dockerheißen.DATA_ROOTist die Ebene, auf der deine Freigabeordner für Nutzdaten liegen – ein App-Artikel schreibt dann${DATA_ROOT}/dokumenteund meint damit den Freigabeordnerdokumente.
So werden die Werte später benutzt. In jedem App-Stack stehen im Abschnitt Environment zwei Zeilen:
DOCKER_ROOT=[[DOCKER_ROOT]]
DATA_ROOT=[[DATA_ROOT]]
Die doppelten eckigen Klammern sind Komodos Schreibweise: Beim Ausrollen ersetzt Komodo sie durch die Werte von oben und schreibt das Ergebnis in die .env neben der Compose-Datei. Die Compose-Datei selbst nutzt danach die gewohnte Docker-Schreibweise:
volumes:
- ${DOCKER_ROOT}/beispiel/config:/config
- ${DATA_ROOT}/dokumente:/data
Warum dieser Umweg? Weil dadurch kein einziger App-Artikel mehr einen Pfad nennen muss. Ziehst du später auf ein anderes Volume um, änderst du die Variable an dieser einen Stelle statt in zwanzig Stacks.
Der Freigabeordner bleibt trotzdem deine Aufgabe. ${DATA_ROOT} zeigt nur auf die Ebene darüber. Das Verzeichnis für die Nutzdaten einer Anwendung legst du weiterhin vorher über Systemsteuerung → Freigabeordner an – sonst entsteht dort ein gewöhnliches Verzeichnis, das im Dateimanager unsichtbar ist.
12. Probelauf
Bevor im nächsten Artikel der erste echte Dienst entsteht, einmal trocken durchspielen. Der Testcontainer tut nichts weiter, als seinen eigenen Namen zu melden.
💻 Im Browser:
- Links auf Stacks, oben rechts + New Stack
- Name:
test-whoami - Server:
nas - Stack Type:
UI Defined - Im Bereich Compose File einfügen:
name: test-whoami
services:
whoami:
image: traefik/whoami
container_name: test-whoami
restart: unless-stopped
networks:
- homelab_intern
networks:
homelab_intern:
external: true
- Save – damit ist die Definition gespeichert, gestartet ist noch nichts
- Deploy, dann im Dialog Confirm
Was jetzt passiert: Komodo schreibt die Datei auf die NAS, Periphery startet den Container, und in der Übersicht erscheint er als laufend.
Check
🗄️ Auf der NAS:
ls -l /volume2/docker/test-whoami
Ausgabe: Ein Verzeichnis mit der compose.yaml darin. Das ist der Beweis, dass PERIPHERY_STACK_DIR sitzt – deine Anwendungen landen im Freigabeordner, nicht irgendwo im System.
Schau auch einmal im Dateimanager der NAS-Oberfläche nach. Der Ordner sollte dort auftauchen.
Wieder aufräumen – in zwei Schritten, und der zweite geht nur über die Übersicht:
- 💻 In der Ansicht des Stacks auf Destroy – stoppt und entfernt den Container
- Links auf Stacks zurück in die Übersicht. Dort den Stack
test-whoamiauswählen und auf Execute, dann Delete – das entfernt die Definition aus Komodo
Den zweiten Schritt suchst du in der Ansicht des Stacks vergeblich: Gelöscht wird eine Definition nur über die Auswahl in der Übersicht.
Das Verzeichnis auf der NAS bleibt dabei liegen. Komodo räumt es nicht mit weg – aus gutem Grund, denn bei einer echten Anwendung stünden dort deine Daten drin. Beim Testcontainer ist nichts drin, also weg damit:
sudo rm -rf /volume2/docker/test-whoami
Merk dir das für später. Eine gelöschte Anwendung hinterlässt ihr Verzeichnis. Wer über Monate ausprobiert und wieder verwirft, sammelt Ordner an, die zu nichts mehr gehören – und sichert sie beim Backup treu mit. Der Wartungsartikel in Phase 4 hat dafür einen eigenen Abschnitt.
Du hast damit den kompletten Ablauf einmal gesehen: anlegen, bearbeiten, ausrollen, kontrollieren, entfernen. Genau so entsteht ab jetzt jede Anwendung dieser Reihe.
13. Komodo im Alltag
Der Installationsteil ist durch. Ein paar Dinge lohnt sich zu kennen, bevor du sie das erste Mal brauchst.
Wie eine Anwendung definiert wird
Komodo bietet drei Wege an. Für diese Reihe gilt durchgängig der erste:
UI Defined – du tippst Compose-Datei und Konfiguration im Browser, Komodo legt beides beim Ausrollen auf der NAS ab. Kein SSH, alles an einer Stelle.
Files on Host – Komodo liest eine Datei, die schon auf dem Gerät liegt. Praktisch, wenn du etwas Bestehendes übernehmen willst.
Git Repo – Komodo holt sich die Datei aus einem Git-Verwaltungssystem. Das ist die Ausbaustufe für später und braucht ein paar Anpassungen an unserem Aufbau.
Compose File und Environment: zwei Bereiche pro Stack
In der Konfiguration einer Anwendung liegen zwei Eingabebereiche untereinander. Oben Compose File, darunter Environment – und was du in Environment schreibst, legt Komodo beim Ausrollen als .env neben der Compose-Datei ab. Daher der Name.
Passwörter, Adressen und Versionsnummern gehören deshalb in Environment, in der Compose-Datei stehen nur Verweise darauf. In dieser Reihe heißt der Inhalt von Environment im Fließtext „die Konfigurationswerte".
Merk dir das für Phase 4: Diese Werte liegen in Komodos eigener Datenbank. Gesichert werden sie über Komodos eigene Sicherung weiter unten – sie liegt im Freigabeordner und geht mit dem Backup aus Phase 4 nach draußen.
Neue Versionen
Komodo sieht regelmäßig nach, ob es zu den verwendeten Abbildern neuere Fassungen gibt, und markiert das in der Übersicht. Pro Anwendung gibt es zwei Schalter:
- Poll for Updates – Komodo sieht nach und sagt Bescheid, du entscheidest
- Auto Update – Komodo zieht die neue Version und rollt selbst aus
Für jede Anwendung dieser Reihe gilt: Poll for Updates an, Auto Update aus. Größere Sprünge können Datenbanken umbauen oder Konfigurationen ändern. Wenn das nachts von allein passiert und am Morgen läuft etwas nicht mehr, fehlt dir der Zusammenhang. Bei einer Foto- oder Passwortanwendung willst du dabei sein.
Beide Schalter stehen in derselben Konfiguration wie Compose File und Environment, und Save sichert alles zusammen.
Komodo selbst aktualisieren
Der Weg von oben gilt für alle Anwendungen außer einer. Komodos eigener Stack trägt das komodo.skip-Label und bleibt davon ausgenommen – er wird über SSH aktualisiert, wie jede Änderung an diesem Stack:
cd /volume2/docker/komodo
sudo docker compose pull
sudo docker compose up -d
pull holt die neuesten Abbilder zur Marke 2 aus der Konfigurationsdatei, up -d tauscht nur die Container, deren Abbild sich geändert hat. Die Speicherbereiche bleiben unberührt: Anwendungsdefinitionen, Konten und Historie überleben das. Postgres und FerretDB holt pull dagegen nicht neu: Sie stehen auf einer festen Version, weil ein Wechsel dort die Datenbank umbauen kann. Die hebst du nur bewusst an, nach den Release Notes von FerretDB – erst postgres-documentdb, dann ferretdb, beide auf dieselbe FerretDB-Version.
Check
sudo docker compose ps
sudo docker compose logs periphery | grep -i "logged in"
Ausgabe: Vier Container Up, und eine neue logged in-Zeile mit aktuellem Zeitstempel. Der zweite Befehl ist der wichtigere: Wird Core neu erstellt, muss Periphery ihn wiederfinden.
Die abgelösten Abbilder bleiben auf der Platte liegen. sudo docker image prune -f entfernt die, die kein Container mehr nutzt.
Ein Sprung auf eine neue Hauptversion – von
2auf3– folgt anderen Regeln. Zwischen 1.x und 2.x wechselten das Postgres-Abbild, die Authentifizierung und die Pflichtangaben in der Konfigurationsdatei. Dafür liest man zuerst die Release Notes des Projekts und sichert die Datenbank – wie, steht im nächsten Unterabschnitt. Innerhalb von2passiert das nicht.
Komodos eigene Sicherung
Komodo legt bei einer neuen Installation von selbst eine Prozedur namens Backup Core Database an. Sie läuft jede Nacht um 01:00 und schreibt einen Ordner mit Datum in das Verzeichnis, das du in Abschnitt 7 bei core als /backups eingehängt hast – darin je eine gepackte Datei für Stacks, Server, Variablen, Empfänger, Konten und den Rest von Komodos Konfiguration.
Zu finden ist sie links unter Procedures. Dort startest du sie auch von Hand, etwa vor einem Sprung auf eine neue Hauptversion – und jetzt gleich einmal, damit du nicht bis zur ersten Nacht auf den Check warten musst.
Check
ls -l /volume2/docker/komodo/backups
Ausgabe: ein Ordner mit Datum und Uhrzeit im Namen, daneben eine Datei Stats.gz mit den gesammelten Messwerten:
drwxr-xr-x 1 root root 488 Nov 20 11:27 2026-11-20_11-27-54
-rw-r--r-- 1 root root 8550580 Nov 20 11:27 Stats.gz
Beides gehört root, weil Docker das Verzeichnis anlegt und Komodo darin schreibt. Lesen kann es jeder, und mehr braucht das Backup in Phase 4 nicht.
Gesichert ist damit Komodos eigene Datenbank, nicht die Daten deiner Anwendungen – die liegen in deren Verzeichnissen. Weil das Sicherungsverzeichnis im Freigabeordner liegt, nimmt der Backup-Artikel in Phase 4 es ohne weiteren Handgriff mit.
Benachrichtigungen
Unter Alerters lässt sich einstellen, dass Komodo aktiv meldet: Container ausgefallen, Gerät nicht erreichbar, Speicher knapp, Aktualisierung verfügbar.
Als Empfänger kommt hier keine Mailadresse in Frage. Komodo verschickt keine Mail – ein SMTP-Versand ist nicht vorgesehen, auch nicht mit der Weiterleitung aus Artikel 08. Es meldet an Push- und Chatdienste: Slack, Discord, Pushover und ntfy sind eingebaut, alles andere braucht einen Zwischenbaustein.
Deshalb bleibt dieser Punkt vorerst offen. In Artikel 10 – 10. ntfy: Meldungen von VPS und NAS direkt aufs Handy – richtest du ntfy ein und trägst es hier als Empfänger nach. Für jetzt reicht zu wissen, wo die Einstellung sitzt.
Zwei-Faktor-Anmeldung
Komodo kann die Anmeldung mit einer Zwei-Faktor-Anmeldung (2FA) absichern, in zwei Varianten – über einen Passkey oder über eine Authenticator-App mit Zahlencode. Du findest beides oben rechts im Profil unter Account.
Der Passkey funktioniert hier nicht, und das liegt nicht an Komodo: Browser geben die dafür nötige Schnittstelle nur auf Seiten mit gültigem HTTPS frei. Komodo rufst du über http:// auf, also meldet die Oberfläche, es sei kein Anbieter verfügbar. Das ist erwartet.
Die Authenticator-App funktioniert, weil der Zahlencode auf dem Server geprüft wird und der Browser damit nichts zu tun hat. Nimm dieselbe App, mit der du in Artikel 05 dein Tailscale-Konto abgesichert hast.
Pflicht ist 2FA hier nicht – wer die Oberfläche erreichen will, muss ohnehin erst im privaten Netz sein. Aber es kostet zwei Minuten.
Was Komodo nicht ist
Damit keine falschen Erwartungen entstehen: Komodo verwaltet Container. Es ist kein Reverse Proxy, kein Backup-Werkzeug für deine Anwendungen und keine Benutzerverwaltung. Adressen und Zertifikate macht Caddy im nächsten Artikel, Sicherungen kommen in Phase 4.
Wenn es nicht klappt
| Was du siehst | Ursache | Weiter |
|---|---|---|
komodo-core hängt auf Restarting, im Protokoll password must be URL encoded |
Datenbank-Passwort mit Sonderzeichen erzeugt | Neues mit openssl rand -hex 24 eintragen, dann sudo docker compose down -v und up -d – nur solange Komodo noch nie lief, -v löscht alle Speicherbereiche des Stacks → Abschnitt 5 |
komodo-core steigt mit Exited (128) aus |
In der Konfigurationsdatei ist ein Platzhalter stehen geblieben, etwa bei KOMODO_HOST |
grep -n "<" → Abschnitt 6 |
Failed to connect to websocket … Connection refused oder Failed to resolve host public ip direkt nach dem Start |
Harmlos – Periphery ist schneller oben als Core bzw. die öffentliche Adresse füllt nur ein Anzeigefeld | → Abschnitt 8 |
Die Seite unter http://nas:9120 lädt nicht |
Gerät nicht im privaten Netz, Core gestoppt oder falsche Adresse in TAILSCALE_IP |
Tailscale-App, sudo docker compose ps, Vergleich mit tailscale ip -4 → Abschnitte 2 und 8 |
| Nach Sign Up steht nur „Komodo Log in" ohne Felder | Zwischenspeicher des Browsers | Strg + Shift + R oder ein privates Fenster |
| Der Server steht auf „is not connected" | Name in der Oberfläche passt nicht zu PERIPHERY_CONNECT_AS |
→ Abschnitt 10, Kasten |
/volume2/docker/komodo/backups fehlt, obwohl die Prozedur unter Procedures läuft |
Zeile /backups bei core fehlt – die Abzüge landen nur im Container |
Zeile ergänzen, sudo docker compose up -d, Prozedur von Hand starten → Abschnitt 7 und 13 |
In einer .env steht [[DOCKER_ROOT]] wörtlich |
Variable fehlt oder ist vertippt – Komodo setzt unbekannte Namen nicht ein | Schreibweise unter Settings → Variables prüfen → Abschnitt 11 |
Und jetzt?
Du verwaltest Docker ab hier im Browser. SSH brauchst du künftig fast nur noch für drei Dinge: Änderungen an Komodo selbst, gelegentliche Fehlersuche und die Dateien, die außerhalb von Komodo gepflegt werden.
Eine davon kommt sofort. Im nächsten Artikel richtest du Caddy ein: den einen Eingang für alle Anwendungen, mit gültigen Zertifikaten über die DNS-Schnittstelle, für die du in Artikel 05 die Zugangsdaten geholt hast. Dort bindest du auch den Freigabeordner docker als Netzlaufwerk ein und bearbeitest die Dateien in einem normalen Editor – dann ist nano Vergangenheit.
👉 Nächster Artikel: 07. Caddy auf der NAS: HTTPS für alle Apps über eine einzige Adresse
Discussion