> ## Content Index
> Fetch the complete content index at: https://cubem.de/llms.txt
> Use this file to discover other available public pages before exploring further.

# 06. Komodo: Docker-Container auf der NAS im Browser verwalten
- URL: https://cubem.de/06-komodo-docker-container-auf-der-nas-im-browser-verwalten/
- Published: 2026-11-20T15:52:51.000Z
- Updated: 2026-11-20T20:12:29.000Z
- Description: Stacks anlegen, ausrollen und aktualisieren, ohne für jede Änderung ins Terminal zu wechseln. Erreichbar nur über das private Netz – mit zwei Variablen, die später jede Konfigurationsdatei plattformunabhängig machen.
- Author: martin
- Tags: NAS Edition, Self-Hosting 2027, Infrastruktur, Komodo, Docker

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

[ Neu in der Reihe? Hier geht's los ](https://cubem.de/self-hosting/)  
[ Welche Hardware brauche ich? ](https://cubem.de/hardware) 

## 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_ROOT` und `DATA_ROOT` angelegt
- 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 `docker` angelegt, `homelab_net` und `homelab_intern` existieren
- 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/docker` heiß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:

```bash
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:

```bash
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:

```bash
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**

```bash
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.

```bash
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 -hex` erzeugt nur Ziffern und die Buchstaben a bis f. Damit kann keiner der Werte etwas kaputtmachen: Das Datenbank-Passwort landet in einer Verbindungsadresse der Form `mongodb://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

```bash
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:

```bash
chmod 600 /volume2/docker/komodo/.env

```

**Check**

```bash
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=false` erlaubt gleich das Anlegen des ersten Kontos. Sobald das steht, drehen wir den Wert um.
> 
> `PERIPHERY_STACK_DIR=/volume2/docker` ist 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

```bash
nano /volume2/docker/komodo/compose.yaml

```

```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

```bash
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**

```bash
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:

```bash
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 refused` direkt 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 `periphery` unter `/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.

1. Benutzernamen eintragen
2. Passwort vergeben, mindestens zwölf Zeichen, am besten aus dem Passwort-Manager
3. Auf **Sign Up** klicken

Das erste Konto bekommt automatisch alle Rechte. Du bist danach angemeldet.

![](https://cubem.de/content/images/2026/11/01-komodo-log-on-1.webp)

### Registrierung schließen

🗄️ **Auf der NAS**, sofort danach, damit niemand sonst ein Konto anlegen kann:

```bash
nano /volume2/docker/komodo/.env

```

Diese Zeile ändern:

```
KOMODO_DISABLE_USER_REGISTRATION=true

```

Speichern, dann:

```bash
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.

![](https://cubem.de/content/images/2026/11/02-komodo-server-1.webp)

> **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_AS` in 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.

1. Unten links auf **Settings**, dann auf den Reiter **Variables**
2. **\+ 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_ROOT` ist der Freigabeordner aus Artikel 04; bei dir kann er `/volume1/docker` heißen. `DATA_ROOT` ist die Ebene, auf der deine Freigabeordner für Nutzdaten liegen – ein App-Artikel schreibt dann `${DATA_ROOT}/dokumente` und meint damit den Freigabeordner `dokumente`.

**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:

```yaml
    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:**

1. Links auf **Stacks**, oben rechts **\+ New Stack**
2. **Name:** `test-whoami`
3. **Server:** `nas`
4. **Stack Type:** `UI Defined`
5. Im Bereich **Compose File** einfügen:

```yaml
name: test-whoami

services:
  whoami:
    image: traefik/whoami
    container_name: test-whoami
    restart: unless-stopped
    networks:
      - homelab_intern

networks:
  homelab_intern:
    external: true

```

1. **Save** – damit ist die Definition gespeichert, gestartet ist noch nichts
2. **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:**

```bash
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:

1. 💻 In der Ansicht des Stacks auf **Destroy** – stoppt und entfernt den Container
2. Links auf **Stacks** zurück in die Übersicht. Dort den Stack `test-whoami` auswä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:

```bash
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:

```bash
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**

```bash
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 `2` auf `3` – 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 von `2` passiert 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**

```bash
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](https://cubem.de/07-caddy-auf-der-nas-https-fur-alle-apps-uber-eine-einzige-adresse/)