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

# TREK Docker Compose: Reiseplaner mit Karte selbst hosten
- URL: https://sakis.tech/trek-docker-compose/
- Published: 2026-10-26T09:50:45.000Z
- Updated: 2026-10-26T09:50:45.000Z
- Description: TREK plant deine Reise Tag für Tag auf der Karte, mit Buchungen, Budget und Packliste für alle, die mitfahren. Was hinter 15.000 GitHub-Sternen und Version 5.0 steckt und wie TREK per Docker Compose sicher bei dir läuft.
- Author: Sakis
- Tags: homelab, docker

Wer diese Woche die bestbewerteten Beiträge auf r/selfhosted durchgeht, findet eine Notfallwarnung zu PHP, einen Bilderrahmen, der Vogelarten erkennt, und dazwischen einen Reiseplaner. Er heißt TREK, und sein Beitrag kündigt ihn als die einzige Reise-App an, die man je selbst hosten muss.

Superlative lese ich grundsätzlich mit Abstand. Die Zahlen dahinter lohnen trotzdem einen Blick: Das Projekt wurde am 19-03-2026 auf GitHub angelegt, steht heute bei 15.092 Sternen, und am 25-10-2026 ist Version 5.0.0 erschienen. TREK ist eine Web-App, in der du eine Reise Tag für Tag auf der Karte planst, mit Buchungen, Budget und Packliste, gemeinsam mit allen, die mitfahren. Am Ende dieser Anleitung läuft sie auf deinem Server, mit eigenem Schlüssel, geschlossener Registrierung und einem Backup, das jede Nacht entsteht.

**Kurz gesagt:** TREK ist ein selbst gehosteter Reiseplaner: Tagespläne auf der Karte, Ortssuche, Buchungen, geteilte Kosten, Packlisten, gemeinsames Bearbeiten in Echtzeit. Nach rund 30 Minuten läuft TREK 5.0 per Docker Compose auf Port 3000, mit dem Verschlüsselungsschlüssel in einer eigenen Datei, einem Admin-Konto mit 2FA, Einladungen statt offener Registrierung und täglichem Auto-Backup. Stufe Standard: Docker und Terminal solltest du grob kennen. Stand: TREK 5.0.0, geprüft am 26-10-2026.

![TREK in vier Schritten: Ordner und Verschlüsselungsschlüssel anlegen, Container mit trek:5.0 starten, erstes Login mit Passwortwechsel, dann Registrierung schließen, 2FA und Auto-Backup einschalten](https://sakis.tech/content/images/2026/10/grafik-23.png)

Vier Schritte bis zum fertigen Reiseplaner. Der letzte besteht nur aus Klicks und schützt am meisten.

## Was in TREK steckt

TREK läuft im Browser, am Rechner wie am Handy. Eine Reise besteht aus Tagen, jeder Tag aus Orten, und alle Orte liegen auf einer Karte. Du suchst ein Museum, ziehst es auf den Dienstag, und TREK zeichnet auf Wunsch die Route zwischen den Stopps samt Fahrzeit. Drumherum sammelt die App, was sonst über Mails, Tabellen und Chatgruppen verstreut ist: Flüge, Züge und Unterkünfte, ein Budget, das die Kosten unter den Mitreisenden aufteilt, Packlisten, To-dos, Dokumente und ein Reisetagebuch. Ändert jemand etwas, sehen es die anderen sofort, ohne neu zu laden.

Version 5.0 bringt zwei große Neuheiten. Das Add-on Tours plant Wanderungen, Radtouren, Läufe, Paddel- und Skitouren mit Höhenprofil und liest GPX-, KML- und KMZ-Dateien ein, die Formate, in denen Navis und Sport-Apps ihre Strecken speichern. TREK Studio macht aus den Fotos einer Reise ein Fotobuch, mit 34 Schriftarten, 17 Themen und 160 Stickern.

Neu ist auch ein eingebauter KI-Assistent, der Pläne bearbeitet und jede Änderung zeigt, bevor er sie übernimmt. Er braucht einen eigenen API-Schlüssel von Anthropic, OpenAI, Google Gemini oder OpenRouter, alternativ eine ChatGPT-Anmeldung, die noch als Beta läuft. Ich würde ohne ihn anfangen. Die App trägt auch so, und was du dem Assistenten gibst, landet beim jeweiligen KI-Anbieter.

Browser oder Handy→ Port 3000 →TREK→ nur der Suchbegriff →TREK Places API und OpenStreetMap

Selbst gehostet heißt bei TREK nicht: ohne jeden Kontakt nach draußen. Reisen, Dokumente und Uploads liegen auf deinem Server. Die Ortssuche aber fragt laut Wiki zwei Dienste im Internet, die TREK Places API, einen Ortsindex des Projekts mit 73,6 Millionen Einträgen, und OpenStreetMap. Mit geht der Suchbegriff und ein Hinweis auf die Gegend, etwa der Ort des gerade geöffneten Reisetags. Einen Google-Schlüssel brauchst du nicht. Trägst du einen ein, springt Google erst ein, wenn die beiden anderen nichts finden. Damit kann ich gut leben: „Trattoria Bologna“ verrät weniger über dich als ein kompletter Plan mit Flugnummern und Hoteladresse, und der bleibt zu Hause.

## TREK 5.0 und das Tempo dahinter

Zu den 15.092 Sternen kommen 1.302 Forks, also Kopien, an denen andere weiterbauen. TREK steht unter der AGPL-3.0: Zu Hause darfst du es frei betreiben, und wer eine veränderte Fassung als Dienst für andere anbietet, muss seine Änderungen offenlegen. Die Oberfläche gibt es in 27 Sprachen, Deutsch inklusive.

Auffälliger ist das Tempo. Zwischen dem 27-08-2026 und dem 25-10-2026 sind elf stabile Versionen erschienen, darunter die Hauptversionen 4.0.0 und 5.0.0\. Drei davon brachten Sicherheitskorrekturen, zuletzt 4.3.4 am 21-10-2026\. Ein Detail aus den Release Notes von 5.0.0 hat mir gefallen: Dort steht, ab welcher Altversion der Sprung auf 5.0 durch Tests abgedeckt ist, nämlich ab der 2.9-Reihe. Wer so etwas aufschreibt, rechnet mit Leuten, die lange nicht aktualisiert haben, und lässt sie nicht im Regen stehen.

Dieselben Release Notes zeigen auch die Kehrseite. Mit 5.0 baut TREK beim ersten Start seine Datenbank um und legt vorher selbst eine Kopie an; passt die nicht mehr auf die Platte, startet TREK gar nicht. Und ein Verschlüsselungsschlüssel, der nicht zu den Daten passt, blockiert jetzt den Start, wo ältere Versionen ihn stillschweigend ersetzt haben. Für dich folgt daraus dreierlei: Version festnageln, vor jedem Update sichern, den Schlüssel getrennt aufbewahren. Die Anleitung unten baut alle drei von Anfang an ein.

## Was du brauchst

- **Einen Linux-Server mit Docker und Docker Compose.** Prüfen mit `docker compose version`; die Antwort nennt eine Versionsnummer. Kommt stattdessen eine Fehlermeldung, fehlt Compose noch, und die [Docker-Compose-Anleitung für Einsteiger](https://sakis.tech/docker-compose-grundlagen-fuer-einsteiger/) hilft weiter. Das TREK-Image gibt es für amd64 und arm64, ein Raspberry Pi mit 64-Bit-System reicht also als Unterbau.
- **Docker aus dem offiziellen Paket, nicht als Snap.** Prüfen mit `command -v docker`. Steht dort `/usr/bin/docker`, passt es. Steht dort `/snap/bin/docker`, startet TREK mit der Schutzoption `no-new-privileges` aus der Compose-Datei nicht; was dann hilft, steht unten bei den Stolpersteinen.
- **Port 3000 frei.** Prüfen mit `ss -tlnp | grep ':3000 ' || echo "Port frei"`.

- IP des Servers, auf dem TREK läuft: `192.168.178.50`
- Ordner für Compose-Datei, Schlüssel und Daten: `~/trek`
- Adresse im Browser: `http://192.168.178.50:3000`
- Anmeldung des ersten Admin-Kontos: `admin@trek.local`
- Zeitzone des Servers: `Europe/Berlin`
- Ziel der Testreise: `Bologna`

**So liest du diese Anleitung:** Alles, was du selbst tun sollst, steht in einem farbigen Kasten. **\[ per klick \]** heißt: Das erledigst du mit der Maus in einer Web-Oberfläche, hier die TREK-Oberfläche im Browser. **\[ über die shell \]** heißt: Den Befehl kopieren, ins Terminal einfügen, Enter. Stehen beide Kästen direkt untereinander, führen sie zum selben Ergebnis. Du gehst EINEN davon, nicht beide.

## Schritt 1: Ordner und Schlüssel anlegen

TREK braucht zwei Ordner und einen Schlüssel. In `data` liegt die Datenbank, eine einzelne SQLite-Datei namens `travel.db`, in `uploads` landen Titelbilder, Anhänge und Avatare. Der Schlüssel heißt `ENCRYPTION_KEY`. Mit ihm verschlüsselt TREK, was in der Datenbank geheim bleiben soll, etwa den Zugangsschlüssel, mit dem es später deine Immich-Fotos abruft. Stell ihn dir als Schlüssel zu einem Schließfach vor, in dem TREK die Zugangsdaten zu anderen Diensten aufbewahrt: Ohne ihn bleibt das Fach zu, auch für TREK selbst.

Setzt du keinen Schlüssel, erzeugt TREK beim ersten Start selbst einen und legt ihn in den Datenordner. Das Wiki empfiehlt trotzdem, ihn selbst zu setzen, damit du ihn getrennt von den Daten sichern kannst. Dem schließe ich mich an, aus einem Grund, der beim Backup weiter unten wichtig wird.

```bash
mkdir -p ~/trek/data ~/trek/uploads
cd ~/trek
echo "ENCRYPTION_KEY=$(openssl rand -hex 32)" > .env
chmod 600 .env
```

`openssl rand -hex 32` würfelt 32 zufällige Bytes und schreibt sie als 64 Zeichen aus Ziffern und den Buchstaben a bis f; genau diesen Befehl nennt die TREK-Doku. Das `echo` davor schreibt das Ergebnis samt Namen in die Datei `.env`, die Docker Compose beim Start von selbst liest. `chmod 600` sorgt dafür, dass nur dein Benutzer die Datei lesen darf. Meldet die Shell `openssl: command not found`, holt `sudo apt install openssl` das Werkzeug nach. Ob die Datei stimmt, zeigt dieser Befehl:

```bash
grep -cE '^ENCRYPTION_KEY=[0-9a-f]{64}$' .env
```

```text
1
```

Die `1` heißt: genau eine Zeile in der richtigen Form. Bei einer `0` ging beim Erzeugen etwas schief; dann führst du die `echo`\-Zeile von oben noch einmal aus, sie überschreibt die Datei.

## Schritt 2: Die Compose-Datei schreiben

```bash
cd ~/trek
nano docker-compose.yml
```

Den folgenden Inhalt einfügen, im Terminal klappt das meist mit Strg+Umschalt+V oder einem Rechtsklick. Speichern mit Strg+O und Enter, schließen mit Strg+X. Die Datei folgt der offiziellen `docker-compose.yml` aus dem TREK-Repository. Weggelassen habe ich die auskommentierten Optionen und `ALLOWED_ORIGINS`, das in der Vorlage ohnehin leer bleibt. Inhaltlich geändert sind drei Stellen: Image, Zeitzone und Cookie.

```yaml
services:
  app:
    image: mauriceboe/trek:5.0
    container_name: trek
    read_only: true
    security_opt:
      - no-new-privileges:true
    cap_drop:
      - ALL
    cap_add:
      - CHOWN
      - SETUID
      - SETGID
    tmpfs:
      - /tmp:noexec,nosuid,size=128m
    ports:
      - "3000:3000"
    environment:
      - NODE_ENV=production
      - PORT=3000
      - ENCRYPTION_KEY=${ENCRYPTION_KEY:-}
      - TZ=Europe/Berlin
      - LOG_LEVEL=info
      - COOKIE_SECURE=false
    volumes:
      - ./data:/app/data
      - ./uploads:/app/uploads
    restart: unless-stopped
    logging:
      driver: json-file
      options:
        max-size: "10m"
        max-file: "3"
    healthcheck:
      test: ["CMD-SHELL", "wget -qO- http://localhost:$${PORT:-3000}/api/health || exit 1"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 15s
```

Was die wichtigen Zeilen tun:

- `**image: mauriceboe/trek:5.0**`: Die Vorlage nimmt `latest`. Wer damit seit dem 25-10-2026 ein Update zieht, springt ohne Rückfrage von 4.3 auf 5.0, samt Datenbank-Umbau. Das Tag `5.0` bekommt alle Korrekturen der 5.0-Reihe und wechselt nie von selbst auf 5.1.
- **`read_only`**, **`cap_drop`**, **`cap_add`**, **`security_opt`**, `**tmpfs**`: Härtung aus der offiziellen Datei, und die lasse ich gern stehen. Das Dateisystem des Containers ist schreibgeschützt, beschreibbar sind nur `data`, `uploads` und ein kleines `/tmp` im Arbeitsspeicher. Von den Sonderrechten, die ein Container haben kann, bleiben drei übrig: Dateibesitzer ändern sowie Benutzer- und Gruppenkennung wechseln. Die braucht das Startskript, damit TREK danach als einfacher Benutzer `node` läuft statt als root.
- `**ENCRYPTION_KEY=${ENCRYPTION_KEY:-}**`: holt den Schlüssel aus der `.env` von Schritt 1\. In der Compose-Datei selbst steht er nie.
- **`TZ=Europe/Berlin`**: Die Vorlage nimmt UTC. Das Auto-Backup läuft aber nach Serverzeit, Erinnerungen auch. Mit UTC liefe ein Backup, das du auf 2 Uhr stellst, bei dir im Winter um 3 Uhr und im Sommer um 4.
- `**healthcheck**`: Docker fragt alle 30 Sekunden die Adresse `/api/health` im Container ab und merkt sich, ob TREK antwortet. Darauf baut die Erfolgskontrolle in Schritt 3.
- `**COOKIE_SECURE=false**`: Ohne diese Zeile kommst du über `http://` nicht hinein. Sie braucht eine längere Erklärung.

Nach der Anmeldung gibt TREK deinem Browser ein Sitzungs-Cookie mit, eine Art Garderobenmarke, an der es dich bei jedem Klick wiedererkennt. Im Produktivbetrieb markiert TREK diese Marke als „secure“, und der Browser zeigt sie dann nur über verschlüsseltes HTTPS vor. Über `http://192.168.178.50:3000` bleibt die Marke in der Tasche, und die Anmeldung hält nicht; das Troubleshooting im TREK-Wiki führt genau das als ersten Punkt. `COOKIE_SECURE=false` schaltet die Markierung ab. Das Wiki nennt das ausdrücklich eine Lösung fürs Heimnetz ohne HTTPS, und so behandle ich sie auch: als Übergang, bis ein Reverse Proxy mit Zertifikat davorsteht.

Ob die Datei formal in Ordnung ist, prüft Compose selbst:

```bash
docker compose config --quiet && echo "Compose-Datei in Ordnung"
```

```text
Compose-Datei in Ordnung
```

Kommt stattdessen eine Meldung mit Zeilennummer, ist beim Einfügen meist die Einrückung verrutscht. YAML zählt Leerzeichen, Tabulatoren mag es gar nicht.

## Schritt 3: TREK starten und das Startpasswort holen

```bash
cd ~/trek
docker compose up -d
docker inspect --format '{{.State.Health.Status}}' trek
```

Beim ersten Mal lädt Docker das Image herunter, das dauert je nach Leitung eine Weile. Der letzte Befehl fragt den Zustand ab, den der Healthcheck pflegt. Direkt nach dem Start steht dort `starting`. Nach einer halben Minute rufst du ihn noch einmal auf, und dann sollte es so aussehen:

```text
healthy
```

Bleibt es nach zwei Minuten bei `starting` oder steht dort `unhealthy`, nennt `docker compose logs` den Grund; die häufigsten Gründe stehen unten bei den Stolpersteinen.

Beim allerersten Start legt TREK ein Admin-Konto an und schreibt ein zufälliges Passwort ins Protokoll. Den passenden Suchbefehl liefert das Troubleshooting im Wiki:

```bash
docker compose logs | grep -A6 "First Run"
```

In dem Block, der erscheint, steht das Startpasswort. Kopier es dir, du brauchst es genau einmal. Angemeldet wird mit der E-Mail-Adresse `admin@trek.local`.

## Schritt 4: Anmelden und das Passwort tauschen

Im Browser `http://192.168.178.50:3000` öffnen. Als E-Mail `admin@trek.local` eintragen, dazu das Startpasswort, dann **Anmelden**. TREK meldet: „Sie müssen Ihr Passwort ändern, bevor Sie fortfahren können.“ Unter **Neues Passwort** und **Neues Passwort bestätigen** ein neues, langes Passwort aus deinem Passwort-Manager eintragen und bestätigen. Den Wechsel schließt der Knopf **Passwort aktualisieren** ab; TREK verlangt dafür mindestens 8 Zeichen mit Groß- und Kleinbuchstaben, einer Zahl und einem Sonderzeichen. Das Fenster „Update installiert 5.0.0“, das TREK danach über das Dashboard legt, schließt du mit dem X oben rechts. (Stand TREK 5.0, deutsche Oberfläche)

Geklappt hat es, wenn du auf einer fast leeren Seite landest: „Noch keine Reisen“, darunter der Knopf **Neue Reise**. Die Menünamen in dieser Anleitung stammen aus der deutschen Oberfläche. TREK richtet sich nach der Sprache deines Browsers; steht der auf Englisch, stellst du TREK unter Einstellungen, Allgemein auf Deutsch um.

## Schritt 5: Probelauf mit einer Testreise

Ob Datenbank, Karte und Ortssuche zusammenspielen, zeigt eine Testreise in zwei Minuten.

**Neue Reise** anklicken. Als **Titel** „Bologna“ eintragen, **Startdatum** und **Enddatum** wählen und mit **Neue Reise erstellen** abschließen. Die neue Reise im Dashboard anklicken, der Planer öffnet sich. Auf die Kopfzeile des ersten Tages klicken, dann in der rechten Spalte auf **Zum Tag**. Ins Feld **Suchen** „Piazza Maggiore“ tippen, den Vorschlag anklicken und mit **Hinzufügen** speichern. Zur Wahl stehen mehrere Plätze dieses Namens, ganz oben etwa einer in Pulheim, Deutschland; der richtige trägt den Zusatz Bologna, Italien. Dasselbe mit „Torre degli Asinelli“. Einen Eintrag mit genau diesem Namen gibt es nicht; passend ist „Sommità della Torre degli Asinelli“ in Bologna, den TREK als „Top of Asinelli Tower“ übernimmt. Zum Schluss unten am Tag den Schalter **Route** einschalten. (Stand TREK 5.0)

Beide Orte sitzen jetzt als Markierung auf der Karte, und zwischen ihnen zeichnet TREK den Weg; die Zeit dafür steht im Tagesplan. Wenn die Linie erscheint, funktioniert alles bis hinaus zur Ortssuche. Dein Server hat gerade seinen ersten Stadtbummel geplant, das darf man kurz würdigen.

## Fünf Einstellungen, bevor jemand mitplant

TREK läuft. Bevor Familie oder Freunde dazukommen, gehören fünf Dinge eingestellt.

### 1\. Registrierung schließen, Einladungen verschicken

Ab Werk ist die Passwort-Registrierung eingeschaltet: Wer die Anmeldeseite erreicht, darf sich ein Konto anlegen. In einem Heimnetz voller Gäste-Handys ist das eine Tür, die niemand braucht. Deine Leute kommen stattdessen über Einladungslinks.

Oben in der Leiste auf deinen Avatar klicken, dann **Admin**. In der Seitenleiste unter **Konfiguration** den Tab **Einstellungen** öffnen und in der Karte **Anmeldemethoden** den Schalter **Passwort-Registrierung** ausschalten. Dann unter **Benutzer** den Tab **Benutzer** öffnen, in der Karte **Einladungslinks** auf **Link erstellen** klicken, **Max. Nutzungen** auf 1× und **Gültig für** auf 7d lassen und mit **Erstellen & kopieren** abschließen. (Stand TREK 5.0)

Der Link liegt jetzt in der Zwischenablage und kann per Messenger raus. Vorher ein kurzer Blick darauf: Laut Wiki baut TREK Links aus seiner eingestellten Adresse, und die lautet ohne weitere Angabe `http://localhost:3000`. Beginnt dein Link so, tausch diesen Teil gegen `http://192.168.178.50:3000` und lass den Rest stehen. Die Gegenprobe machst du in einem privaten Browserfenster: Die Anmeldeseite bietet kein Formular zum Registrieren mehr an, wer deinen Einladungslink öffnet, bekommt es trotzdem.

### 2\. 2FA für das Admin-Konto

Das Admin-Konto darf alles, auch ein Backup einspielen, das sämtliche Daten ersetzt. Es bekommt deshalb einen zweiten Faktor: einen Code aus einer Authenticator-App, ohne den das Passwort allein nicht mehr reicht.

Avatar, dann **Einstellungen**, Tab **Konto**. In der Karte **Zwei-Faktor-Authentifizierung (2FA)** auf **Authenticator einrichten** klicken und den QR-Code innerhalb von 15 Minuten mit einer TOTP-App scannen, etwa Google Authenticator, Authy oder 1Password. Den sechsstelligen Code eintragen und **2FA aktivieren** klicken. Danach zeigt TREK zehn **Backup-Codes**, und zwar nur dieses eine Mal: herunterladen oder ausdrucken. (Stand TREK 5.0)

Die Gegenprobe: abmelden und neu anmelden, nach dem Passwort fragt TREK jetzt nach dem Code. Die Backup-Codes sind dabei kein Beiwerk. Ein Admin kann die 2FA anderer Konten zurücksetzen, die eigene aber nicht, und für den Fall, dass Handy und Codes zugleich weg sind, beschreibt das Wiki keinen bequemen Rückweg. Wer mag, verlangt 2FA unter Admin, Einstellungen mit dem Schalter **Zwei-Faktor-Authentifizierung (2FA) für alle verlangen** gleich von allen Konten.

### 3\. Auto-Backup einschalten

TREK bringt ein eigenes Backup mit, und bei einer frischen Installation ist es aus. Eingeschaltet packt es Datenbank und Uploads in ein ZIP-Archiv, nach Zeitplan und mit Aufbewahrungsfrist.

Avatar, **Admin**, in der Seitenleiste unter **Wartung** den Tab **Backup**. In der Karte **Auto-Backup** den Schalter **Auto-Backup aktivieren** einschalten, **Intervall** auf **Täglich**, **Ausführung um** auf 2 Uhr und **Alte Backups löschen nach** auf **7 Tage** stellen, dann speichern. Gleich danach in der Karte **Datensicherung** einmal **Backup erstellen** klicken, damit du nicht bis zur Nacht auf das erste wartest. Den Zeitstempel im Dateinamen schreibt TREK in UTC, die Liste daneben zeigt die Ortszeit. (Stand TREK 5.0)

Nach dem Speichern bestätigt TREK mit „Auto-Backup Einstellungen gespeichert“, und das erste Backup steht in der Liste der Karte; sein Name beginnt mit `backup-`. Liegen tut es laut Wiki im Ordner `data/backups`, bei dir also in `~/trek/data/backups`.

Jetzt kommt der Grund aus Schritt 1\. Ein TREK-Backup enthält den Verschlüsselungsschlüssel nur, wenn TREK ihn selbst erzeugt hat. Kommt er wie hier aus der `.env`, fehlt er im ZIP. Das ist gut so, denn wer das Archiv in die Finger bekommt, kann die darin gespeicherten Zugangsdaten nicht entschlüsseln. Es heißt aber auch, dass die `.env` getrennt gesichert gehört. Am einfachsten wandert ihre einzige Zeile in deinen Passwort-Manager:

```bash
cat ~/trek/.env
```

Und weil ein Backup, das auf derselben Platte liegt, mit ihr stirbt: `~/trek/data/backups` gehört zusätzlich auf ein zweites Gerät, verschlüsselt und regelmäßig, zum Beispiel mit [Kopia](https://sakis.tech/kopia-docker-compose/). Ich weiß, wie das klingt. Aber die Reise, deren Buchungen du hier ablegst, findet in ein paar Wochen statt, und dann will niemand aus dem Hotel-WLAN eine Datenbank retten.

### 4\. Updates mit Plan

Mit dem Tag `5.0` holen zwei Befehle alle Korrekturen der 5.0-Reihe, auch die Sicherheitskorrekturen, von denen es in den letzten zwei Monaten drei gab:

```bash
cd ~/trek
docker compose pull
docker compose up -d
```

Danach meldet der `docker inspect`\-Befehl aus Schritt 3 wieder `healthy`. Für den Sprung auf 5.1 änderst du in der Compose-Datei `5.0` in `5.1`, aber erst, nachdem du die Release Notes gelesen und ein frisches Backup gezogen hast. Vor jedem Datenbank-Umbau legt TREK eine Kopie namens `pre-migrate-…db` in den Datenordner, die drei neuesten bleiben liegen. Mit ihr kommst du auf die alte Version zurück, denn ein Umbau läuft nur vorwärts. Die Kopie braucht so viel Platz wie die Datenbank selbst, und wie viel frei ist, zeigt `df -h ~/trek`. Und Updates spielst du nicht in der Woche vor der Abreise ein.

### 5\. Im Heimnetz lassen, HTTPS vormerken

Port 3000 spricht unverschlüsseltes HTTP, und mit `COOKIE_SECURE=false` reist auch die Garderobenmarke unverschlüsselt durchs Netz. Im eigenen WLAN ist das vertretbar, im Internet nicht: keine Portfreigabe im Router auf Port 3000\. Für unterwegs gehört ein VPN ins Heimnetz davor.

HTTPS hat bei TREK noch einen Vorteil. Erst damit lässt sich TREK auf dem Handy als App auf den Startbildschirm legen, und erst damit gibt es Push-Benachrichtigungen; über `http://` bietet der Browser beides gar nicht an. Der Weg dahin führt über einen Reverse Proxy wie den [Nginx Proxy Manager](https://sakis.tech/nginx-proxy-manager-installieren/). Läuft TREK dahinter, fliegt `COOKIE_SECURE=false` aus der Compose-Datei, dafür kommen laut Wiki `FORCE_HTTPS=true` und `TRUST_PROXY=1` hinein. Zwei Dinge muss der Proxy dann können: WebSockets auf `/ws` durchreichen, sonst steht die gemeinsame Bearbeitung still, und Uploads bis 500 MB annehmen, sonst scheitert das Einspielen größerer Backups. Das ist Stoff für einen eigenen Beitrag.

## Stolpersteine aus dem TREK-Wiki

Das TREK-Wiki hat eine eigene Seite für Probleme im Betrieb. Für diesen Aufbau zählen fünf davon.

**Die Anmeldung über http:// hält nicht.** Das ist das Cookie aus Schritt 2\. Es trifft vor allem, wer später die Vorlage aus dem Repository übernimmt, in der `COOKIE_SECURE=false` nur als Kommentar steht. Die Zeile gehört aktiv in den `environment`\-Block, danach einmal `docker compose up -d`.

**`exec /usr/bin/dumb-init: operation not permitted`.** Docker läuft als Snap, und der verträgt sich laut Wiki nicht mit `no-new-privileges`. Empfohlen wird Docker aus dem offiziellen Repository. Ein Umzug von Snap-Docker auf das offizielle Paket betrifft alle Container auf dem Server, also vorher sichern. Wer jetzt nicht umziehen will, kann laut Wiki die zwei Zeilen `security_opt` aus der Compose-Datei nehmen; dann fehlt eben eine Schutzschicht.

**`EACCES` im Log.** TREK darf in `data` oder `uploads` nicht schreiben. Die Lösung aus dem Wiki gibt beide Ordner der Benutzerkennung 1000:

```bash
cd ~/trek
sudo chown -R 1000:1000 ./data ./uploads
docker compose up -d
```

**Immich-Fotos kommen nicht an.** TREK holt auf Wunsch Fotos aus Immich oder Synology Photos ins Reisetagebuch, verbindet sich ab Werk aber mit keiner privaten Adresse wie `192.168.178.x`. Das ist ein Schutz: So kann niemand TREK dazu bringen, Geräte in deinem Heimnetz abzufragen. Läuft dein Immich im Heimnetz, öffnest du die Compose-Datei:

```bash
cd ~/trek
nano docker-compose.yml
```

In `~/trek/docker-compose.yml` im Abschnitt `environment` des Dienstes `app` unter `COOKIE_SECURE=false` diese Zeile ergänzen, gleich eingerückt:

```yaml
      - ALLOW_INTERNAL_NETWORK=true
```

Speichern, schließen, Container neu aufbauen:

```bash
docker compose up -d
```

Der Schalter öffnet die privaten Adressbereiche für alle Integrationen zugleich, deshalb setzt du ihn nur, wenn du ihn brauchst. Gesperrt bleibt auch dann `localhost`: In TREK trägst du Immich mit der IP im Heimnetz ein, nicht mit `localhost`.

**Admin-Passwort vergessen.** Dafür hat TREK ein Skript im Container. Laut Wiki setzt es das Admin-Konto zurück, die Reisen bleiben erhalten:

```bash
docker exec -it trek node server/reset-admin.js
```

## Wann sich TREK lohnt

Sobald mehr als eine Person an einer Reise plant. Dann ist eine gemeinsame Karte mit Tagesplan, geteilten Kosten und einer Packliste, auf der jeder sieht, wer das Ladekabel einpackt, ein echter Fortschritt gegenüber der Chatgruppe. Wer allein einmal im Jahr verreist, ist mit einer Notiz-App schneller fertig; für ihn ist TREK ein Dienst mehr, den er pflegen muss.

Zum Reifegrad: sieben Monate alt, elf Versionen in gut acht Wochen, und mit 5.0 ein Umbau der Datenbank. Ich würde TREK mit festem Tag und nächtlichem Backup trotzdem für die nächste Reise nehmen, die Buchungsbestätigungen aber zusätzlich im Mail-Postfach lassen. Ein Update, das in der Nacht vor dem Abflug hakt, ist ärgerlich. Ohne Bordkarte am Gate zu stehen, wäre schlimmer.

Wo liegt eure letzte Urlaubsplanung: in einer geteilten Google-Maps-Liste, in einer Tabelle, im Familien-Chat oder auf dem Zettel am Kühlschrank? Schreib's in die Kommentare, gern auch, was TREK für euch noch fehlt.

Und falls die Urlaubsfotos am Ende neben der Route im Reisetagebuch stehen sollen: TREK holt sie aus Immich, wenn eins in deinem Heimnetz läuft. Wie du das aufsetzt, steht in [Immich installieren: eigene Foto-Cloud per Docker Compose](https://sakis.tech/immich-installieren-docker-compose/).

sakis@homelab:\~$ echo "bleib neugierig — und mach backups" 

## Quellen

- [TREK auf GitHub (README, Funktionen, Lizenz, Sterne)](https://github.com/liketrek/TREK?ref=sakis.tech)
- [GitHub-API: Repository-Daten von TREK (angelegt, Sterne, Forks, Lizenz)](https://api.github.com/repos/liketrek/TREK?ref=sakis.tech)
- [TREK: offizielle docker-compose.yml](https://raw.githubusercontent.com/mauriceboe/TREK/main/docker-compose.yml?ref=sakis.tech)
- [TREK 5.0.0 Release Notes](https://github.com/liketrek/TREK/releases/tag/v5.0.0?ref=sakis.tech)
- [TREK: alle Releases](https://github.com/mauriceboe/TREK/releases?ref=sakis.tech)
- [Docker Hub: Image-Tags von mauriceboe/trek](https://hub.docker.com/v2/repositories/mauriceboe/trek/tags?page%5Fsize=25&ref=sakis.tech)
- [TREK-Wiki: Quick Start](https://github.com/liketrek/TREK/wiki/Quick-Start?ref=sakis.tech)
- [TREK-Wiki: Install Docker Compose](https://github.com/liketrek/TREK/wiki/Install-Docker-Compose?ref=sakis.tech)
- [TREK-Wiki: Environment Variables](https://github.com/liketrek/TREK/wiki/Environment-Variables?ref=sakis.tech)
- [TREK-Wiki: Updating](https://github.com/liketrek/TREK/wiki/Updating?ref=sakis.tech)
- [TREK-Wiki: Troubleshooting](https://github.com/liketrek/TREK/wiki/Troubleshooting?ref=sakis.tech)
- [TREK-Wiki: Login and Registration](https://github.com/liketrek/TREK/wiki/Login-and-Registration?ref=sakis.tech)
- [TREK-Wiki: Admin Settings](https://github.com/liketrek/TREK/wiki/Admin-Settings?ref=sakis.tech)
- [TREK-Wiki: Users and Invites](https://github.com/liketrek/TREK/wiki/Admin-Users-and-Invites?ref=sakis.tech)
- [TREK-Wiki: Two-Factor Authentication](https://github.com/liketrek/TREK/wiki/Two-Factor-Authentication?ref=sakis.tech)
- [TREK-Wiki: Backups](https://github.com/liketrek/TREK/wiki/Backups?ref=sakis.tech)
- [TREK-Wiki: Storage](https://github.com/liketrek/TREK/wiki/Admin-Storage?ref=sakis.tech)
- [TREK-Wiki: Places and Search](https://github.com/liketrek/TREK/wiki/Places-and-Search?ref=sakis.tech)
- [TREK-Wiki: Day Plans and Notes](https://github.com/liketrek/TREK/wiki/Day-Plans-and-Notes?ref=sakis.tech)
- [TREK-Wiki: Creating a Trip](https://github.com/liketrek/TREK/wiki/Creating-a-Trip?ref=sakis.tech)
- [TREK-Wiki: Photo Providers](https://github.com/liketrek/TREK/wiki/Photo-Providers?ref=sakis.tech)
- [TREK-Wiki: Internal Network Access](https://github.com/liketrek/TREK/wiki/Internal-Network-Access?ref=sakis.tech)
- [TREK-Wiki: Offline Mode and PWA](https://github.com/liketrek/TREK/wiki/Offline-Mode-and-PWA?ref=sakis.tech)
- [TREK-Wiki: Reverse Proxy](https://github.com/liketrek/TREK/wiki/Reverse-Proxy?ref=sakis.tech)
- [TREK-Wiki: Languages](https://github.com/liketrek/TREK/wiki/Languages?ref=sakis.tech)