Dawarich 1.19 mit Docker Compose: Google-Zeitachse selbst hosten

Dawarich bildet die Zeitachse von Google Maps selbst gehostet nach. Das Projekt Freika/dawarich nimmt Standortpunkte von Apps wie OwnTracks, Overland oder der eigenen Dawarich-App sowie aus Importen (Google Takeout, GPX, GeoJSON) an und zeigt sie auf Karte und Statistik. Version 1.19.0 vom 27. Oktober 2026 bringt archivierbare Orte, Geofencing beim Anlegen eines Ortes und eine überarbeitete Tag-Verwaltung. Die Release Notes verlangen vor dem Upgrade ein Datenbank-Backup, weil eine Migration nicht rückgängig zu machen ist.

Sie installieren Dawarich mit Docker Compose, ersetzen den Standardzugang, spielen Punkte per API ein, sichern vollständig, stellen nach Totalverlust wieder her und heben eine Instanz von 1.18.1 auf 1.19.0. Alle Ausgaben stammen aus einem Testlauf.

Voraussetzungen

Dawarich ist sparsam. Die Projektdokumentation nennt 1 CPU-Kern, 2 GB RAM und mindestens 10 GB Speicher, auf AMD64 oder ARM64. Im Test belegte die App rund 370 MiB, PostGIS 170 MiB und Redis 10 MiB RAM.

• Linux-Server oder VM mit 2 Kernen und 4 GB RAM, x86 oder ARM, 20 GB freiem Speicher
• Docker Engine mit Docker Compose Plugin, eingerichtet wie in der Grundlagen-Anleitung zu Docker Compose unter Linux
• Shell-Zugriff per SSH und openssl zum Erzeugen von Geheimnissen
• Für den Zugriff aus dem Internet: eine Domain und ein Reverse Proxy mit HTTPS, etwa Caddy, Nginx oder Traefik
• Ein Smartphone mit OwnTracks, Overland oder der Dawarich-App, wenn Sie live aufzeichnen möchten

Schritt 1: Projektordner und Compose-Datei anlegen

Grundlage ist die offizielle docker/docker-compose.yml des Repositorys mit zwei Änderungen: Das Image ist auf freikin/dawarich:1.19.0 gepinnt, damit kein pull ungeplant migriert, und die festen container_name-Einträge fehlen; alle Befehle nutzen docker compose exec mit dem Dienstnamen.

Eckdaten	Wert
Image	freikin/dawarich:1.19.0, postgis/postgis:17-3.5-alpine, redis:8-alpine
Port	3000 (Weboberfläche und API)
Volumes	dawarich_db_data, dawarich_storage, dawarich_public, dawarich_watched, dawarich_shared
Wichtige Env	SECRET_KEY_BASE, DATABASE_PASSWORD, APPLICATION_HOSTS, APPLICATION_PROTOCOL, TIME_ZONE

sudo mkdir -p /opt/dawarich && cd /opt/dawarich
sudo nano compose.yaml

networks:
  dawarich:

services:
  dawarich_redis:
    image: redis:8-alpine
    command: >
      redis-server
      --save 900 1
      --save 300 10
      --appendonly no
    networks:
      - dawarich
    volumes:
      - dawarich_shared:/data
    restart: always
    healthcheck:
      test: [ "CMD", "redis-cli", "--raw", "incr", "ping" ]
      interval: 10s
      retries: 5
      start_period: 30s
      timeout: 10s

  dawarich_db:
    image: postgis/postgis:17-3.5-alpine
    shm_size: 1G
    volumes:
      - dawarich_db_data:/var/lib/postgresql/data
      - dawarich_shared:/var/shared
    networks:
      - dawarich
    environment:
      POSTGRES_USER: ${POSTGRES_USER:-postgres}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-password}
      POSTGRES_DB: ${POSTGRES_DB:-dawarich_development}
    restart: always
    healthcheck:
      test: [ "CMD-SHELL", "pg_isready -U ${POSTGRES_USER:-postgres} -d ${POSTGRES_DB:-dawarich_development}" ]
      interval: 10s
      retries: 5
      start_period: 30s
      timeout: 10s

  dawarich_app:
    image: freikin/dawarich:1.19.0
    volumes:
      - dawarich_public:/var/app/public
      - dawarich_watched:/var/app/tmp/imports/watched
      - dawarich_storage:/var/app/storage
      - dawarich_db_data:/dawarich_db_data
    networks:
      - dawarich
    ports:
      - "${DAWARICH_APP_PORT:-3000}:3000"
    stdin_open: true
    tty: true
    entrypoint: web-entrypoint.sh
    command: ['bin/rails', 'server', '-p', '3000', '-b', '::']
    restart: unless-stopped
    stop_grace_period: 60s
    environment:
      RAILS_ENV: ${RAILS_ENV:-production}
      REDIS_URL: ${REDIS_URL:-redis://dawarich_redis:6379}
      DATABASE_HOST: ${DATABASE_HOST:-dawarich_db}
      DATABASE_PORT: ${DATABASE_PORT:-5432}
      DATABASE_USERNAME: ${DATABASE_USERNAME:-postgres}
      DATABASE_PASSWORD: ${DATABASE_PASSWORD:-password}
      DATABASE_NAME: ${DATABASE_NAME:-dawarich_development}
      APPLICATION_HOSTS: ${APPLICATION_HOSTS:-localhost,::1,127.0.0.1}
      TIME_ZONE: ${TIME_ZONE:-Europe/London}
      APPLICATION_PROTOCOL: ${APPLICATION_PROTOCOL:-http}
      PROMETHEUS_EXPORTER_ENABLED: ${PROMETHEUS_EXPORTER_ENABLED:-false}
      SECRET_KEY_BASE: ${SECRET_KEY_BASE:-"CHANGE_ME"}
      RAILS_LOG_TO_STDOUT: ${RAILS_LOG_TO_STDOUT:-true}
      SELF_HOSTED: ${SELF_HOSTED:-true}
      STORE_GEODATA: ${STORE_GEODATA:-true}
      SIDEKIQ_EMBEDDED: 'true'
      WEB_CONCURRENCY: '0'
      BACKGROUND_PROCESSING_CONCURRENCY: ${BACKGROUND_PROCESSING_CONCURRENCY:-2}
    logging:
      driver: "json-file"
      options:
        max-size: ${LOG_MAX_SIZE:-100m}
        max-file: ${LOG_MAX_FILE:-5}
    healthcheck:
      test: [ "CMD-SHELL", "wget -qO - http://127.0.0.1:3000/api/v1/health | grep -q '\"status\"\\s*:\\s*\"ok\"'" ]
      interval: 10s
      retries: 30
      start_period: 30s
      timeout: 10s
    depends_on:
      dawarich_db:
        condition: service_healthy
        restart: true
      dawarich_redis:
        condition: service_healthy
        restart: true
    deploy:
      resources:
        limits:
          cpus: ${APP_CPU_LIMIT:-1.00}
          memory: ${APP_MEMORY_LIMIT:-4G}


volumes:
  dawarich_db_data:
  dawarich_shared:
  dawarich_public:
  dawarich_watched:
  dawarich_storage:

Healthchecks sorgen dafür, dass die App erst nach Datenbank und Redis startet. Weitere Härtung mit Secrets und Non-Root-Betrieb beschreibt Docker Compose absichern. Auf ARM nennt die Vorlage imresamu/postgis:17-3.5-alpine.

Verifizieren: docker compose config --quiet endet ohne Ausgabe und mit Exit-Code 0.

Schritt 2: Geheimnisse in der .env festlegen

Die Vorgaben der Compose-Datei taugen nicht für den Betrieb: Datenbankpasswort password, SECRET_KEY_BASE gleich CHANGE_ME. Der Schlüssel signiert Sitzungen und leitet Verschlüsselungsschlüssel ab; eine spätere Änderung meldet alle ab und kann verschlüsselte Daten unlesbar machen. Erzeugen Sie beide Werte einmalig:

openssl rand -hex 24   # Datenbankpasswort
openssl rand -hex 64   # SECRET_KEY_BASE

# .env im Ordner /opt/dawarich (nur für root lesbar: chmod 600 .env)
POSTGRES_PASSWORD=HIER_LANGES_ZUFALLSPASSWORT
DATABASE_PASSWORD=HIER_DASSELBE_PASSWORT
SECRET_KEY_BASE=HIER_AUSGABE_VON_openssl_rand_-hex_64
TIME_ZONE=Europe/Berlin
APPLICATION_HOSTS=localhost,127.0.0.1,::1,dawarich.example.de
APPLICATION_PROTOCOL=http

Beide Passwörter müssen identisch sein. APPLICATION_HOSTS listet alle Hostnamen und IPs ohne Protokoll, unter denen Browser und Apps Dawarich erreichen. Hinter einem HTTPS-Proxy gilt APPLICATION_PROTOCOL=https; die App erzwingt dann SSL und sichere Cookies.

Verifizieren: docker compose config | grep SECRET_KEY_BASE zeigt Ihren Wert und nicht mehr CHANGE_ME.

Schritt 3: Stack starten und Version prüfen

docker compose up -d
docker compose ps
curl -s http://localhost:3000/api/v1/health
docker compose exec dawarich_app cat .app_version

Die App führt beim Start Migrationen und Seeds aus; nach rund einer Minute waren alle Container healthy.

dawarich_app freikin/dawarich:1.19.0 Up (healthy)
dawarich_db postgis/postgis:17-3.5-alpine Up (healthy)
dawarich_redis redis:8-alpine Up (healthy)
{"status":"ok"}
1.19.0

Verifizieren: Der Health-Endpunkt antwortet mit {"status":"ok"}, und .app_version sowie das Image-Label org.opencontainers.image.version zeigen 1.19.0.

Schritt 4: Standardzugang sofort ersetzen

Die Seeds legen das Administratorkonto demo@dawarich.app mit safepassword an, öffentlich dokumentiert. Melden Sie sich unter http://SERVER:3000 an, öffnen Sie im Benutzermenü das Profil und setzen Sie eigene E-Mail-Adresse und ein Passwort mit mindestens 12 Zeichen. Die Administratorrechte bleiben erhalten.

Im Test lieferte der alte Zugang danach HTTP 422. Geben Sie die Instanz erst jetzt im Netz frei.

Verifizieren: Abmelden und mit demo@dawarich.app und safepassword anmelden: Die Anmeldung muss scheitern. Mit den neuen Zugangsdaten öffnet sich die Karte.

Schritt 5: API-Schlüssel holen und Standortpunkte einspielen

Den API-Schlüssel (64 Zeichen) finden Sie im Profil unter API-Zugriff, samt QR-Code für die App. Wer ihn kennt, liest Ihren gesamten Verlauf: Behandeln Sie ihn wie ein Passwort.

Ohne Smartphone senden Sie Punkte im OwnTracks-Format, tst ist ein Unix-Zeitstempel. Wir haben zwölf fiktive Punkte in der Leipziger Innenstadt eingespielt:

KEY='IHR_API_SCHLUESSEL'
curl -s -w ' HTTP %{http_code}\n' -H 'Content-Type: application/json' \
  -d '{"_type":"location","lat":51.3455,"lon":12.3810,"tst":1793091600,"acc":8,"tid":"t1"}' \
  "http://localhost:3000/api/v1/owntracks/points?api_key=$KEY"
curl -s "http://localhost:3000/api/v1/points?api_key=$KEY&start_at=2026-10-27T00:00:00Z&per_page=100" | jq length

Alle Aufrufe ergaben HTTP 200, die Kontrolle 12; ein falscher Schlüssel ergab HTTP 401. OwnTracks nutzt dieselbe URL im HTTP-Modus, Overland /api/v1/overland/batches.

Verifizieren: Die Punkte-API gibt die Anzahl der gesendeten Punkte zurück, ein Aufruf mit falschem api_key endet mit HTTP 401.

Schritt 6: Karte, Statistik und Datenschutz

Unter Karte wählen Sie den Zeitraum und klicken auf Suchen; der jüngste Punkt erscheint rot. Ebenen blenden Heatmap, Orte oder Fog of War ein. Eine deutsche Oberfläche wird beim ersten Aufruf angeboten.

Einblicke entstehen per Hintergrundjob, nach wenigen Minuten standen Strecke und aktive Tage bereit. Länder und Städte bleiben ohne umgekehrte Geokodierung bei 0.

Standortdaten sind personenbezogene Daten, Art. 4 Nr. 1 der DSGVO nennt sie ausdrücklich als Merkmal zur Identifizierung. Ein Verlauf verrät Wohnort und Gewohnheiten; Zugriffsschutz, Backup-Verschlüsselung und Löschfristen liegen bei Ihnen. Für Firmenfahrzeuge oder Mitarbeitende brauchen Sie eine Rechtsgrundlage und transparente Information, mit Betriebsrat greift das Mitbestimmungsrecht nach § 87 Abs. 1 Nr. 6 BetrVG. Beachten Sie außerdem den Datenfluss der Oberfläche: Die Kartenkacheln lädt der Browser in Version 1.19.0 standardmäßig vom externen Kachelserver tyles.dwri.xyz, der damit IP-Adresse und Kartenausschnitt sieht.

Verifizieren: Die Karte zeigt für den gewählten Tag die eingespielte Route, Einblicke zeigt für den Monat eine Strecke größer 0.

Schritt 7: Vollständiges Backup erstellen

Die Datenbank enthält Konten, Punkte und Einstellungen, aber keine Import- und Exportdateien; die liegen in dawarich_storage. Ein vollständiges Backup nach Dokumentation umfasst Dump, Storage, Public, Watched, Redis sowie compose.yaml und .env. App und Redis werden vorher gestoppt.

set -o pipefail; umask 077
B=/srv/backup/dawarich-$(date +%F); mkdir -p "$B"
docker compose stop --timeout 60 dawarich_app
docker compose stop dawarich_redis
docker compose exec -T dawarich_db pg_dumpall --clean --if-exists --username=postgres | gzip > "$B/dump.sql.gz"
docker compose cp dawarich_app:/var/app/storage/. - | gzip > "$B/storage.tar.gz"
docker compose cp dawarich_app:/var/app/public/. - | gzip > "$B/public.tar.gz"
docker compose cp dawarich_app:/var/app/tmp/imports/watched/. - | gzip > "$B/watched.tar.gz"
docker compose cp dawarich_redis:/data/. - | gzip > "$B/redis.tar.gz"
cp compose.yaml .env "$B/"
docker compose start dawarich_redis dawarich_app

Der Dump war im Test schon mit zwölf Punkten 8 MB groß, weil die Länderdaten in der Datenbank liegen. Verschlüsseln Sie das Backup vor der Ablage außer Haus.

Verifizieren: zcat dump.sql.gz | grep -c '^COPY public.points' liefert einen Treffer größer 0, und alle fünf Archive liegen im Backup-Ordner.

Schritt 8: Restore nach Totalverlust

Im Test kam nach dem Backup ein dreizehnter Punkt hinzu, dann löschte docker compose down -v alle Volumes. Diesen Befehl nie produktiv als Routine nutzen. Der Restore folgt der Dokumentation: Container anlegen, Dateien zurückkopieren, Datenbank starten, Dump einspielen.

B=/srv/backup/dawarich-2026-10-28
docker compose create
gunzip -c "$B/storage.tar.gz" | docker compose cp -a - dawarich_app:/var/app/storage/
gunzip -c "$B/public.tar.gz"  | docker compose cp -a - dawarich_app:/var/app/public/
gunzip -c "$B/watched.tar.gz" | docker compose cp -a - dawarich_app:/var/app/tmp/imports/watched/
gunzip -c "$B/redis.tar.gz"   | docker compose cp -a - dawarich_redis:/data/
docker compose start dawarich_db
# warten, bis die Erstinitialisierung von PostGIS abgeschlossen ist
until docker compose logs dawarich_db | grep -q 'PostgreSQL init process complete'; do sleep 2; done
until docker compose exec -T dawarich_db pg_isready -U postgres; do sleep 2; done
gunzip -c "$B/dump.sql.gz" \
 | sed "s/SELECT pg_catalog.set_config('search_path', '', false);/SELECT pg_catalog.set_config('search_path', 'public, pg_catalog', true);/g" \
 | docker compose exec -T dawarich_db psql --username=postgres
docker compose up -d

Diese Meldungen sind erwartbar, weil die frische PostGIS-Instanz Rolle und Schemata schon besitzt:

ERROR:  role "postgres" already exists
ERROR:  current user cannot be dropped
ERROR:  cannot drop a template database
ERROR:  database "template_postgis" already exists
ERROR:  schema "tiger" already exists
ERROR:  schema "topology" already exists

Andere Fehler nicht ignorieren. Danach enthielt points wieder genau zwölf Punkte, der dreizehnte fehlte erwartungsgemäß. Neues Passwort und API-Schlüssel funktionierten, der Standardzugang blieb gesperrt.

Verifizieren: docker compose exec dawarich_db psql -U postgres -d dawarich_development -tAc 'select count(*) from points' zeigt den Stand des Backups, die Anmeldung und die Punkte-API funktionieren mit den alten Zugangsdaten.

Schritt 9: Update von 1.18 auf 1.19

Getestet mit einer Instanz unter 1.18.1: Punkte, neues Passwort, Backup nach Schritt 7, dann Tag anheben. Zurück auf 1.18 geht nur per Restore dieses Backups mit altem Tag.

sed -i 's#freikin/dawarich:1.18.1#freikin/dawarich:1.19.0#' compose.yaml
docker compose pull dawarich_app
docker compose up -d
docker compose logs dawarich_app | grep -E '== 2026'

== 20261027120000 PreserveGeofenceEventsWithoutPlaces: migrated (0.0323s) =====
== 20261027130000 AddArchivedAtToPlaces: migrated (0.0073s) ===================

Die App war nach Sekunden healthy, Punkte und Anmeldung blieben erhalten. Danach laufen Datenmigrationen als Hintergrundjobs; warten Sie, bis /sidekiq leer ist. Automatische Updates per Watchtower sind wegen der Migrationen keine gute Idee, siehe Container-Updates mit Diun und WUD.

Verifizieren: docker compose exec dawarich_app cat .app_version zeigt 1.19.0, die Punkte-API liefert dieselbe Anzahl wie vor dem Update.

Troubleshooting

Fehlerbild	Ursache	Lösung
HTTP 403, im Log Blocked hosts: dawarich.example.de	Der aufgerufene Hostname fehlt in APPLICATION_HOSTS.	Hostnamen ohne Protokoll ergänzen, docker compose up -d.
FATAL: the database system is shutting down beim Restore	Der Dump lief, während PostGIS noch die Erstinitialisierung abschloss und den Server neu startete.	Auf PostgreSQL init process complete im Log warten, Volumes leeren und den Restore wiederholen.
API antwortet mit HTTP 401	Falscher oder neu generierter API-Schlüssel.	Schlüssel im Profil prüfen und in allen Apps aktualisieren.
Anmeldung nach Restore scheitert, Sitzungen ungültig	SECRET_KEY_BASE weicht vom gesicherten Wert ab.	Originale .env aus dem Backup verwenden.
Statistik leer, obwohl Punkte da sind	Statistiken entstehen per Hintergrundjob.	Einige Minuten warten oder unter Einblicke Statistiken aktualisieren.

Bleibt die Karte trotz Daten leer, blockiert oft ein Proxy die externen Kacheln. Serverschutz: Linux-Server mit UFW und Fail2ban absichern.

Häufige Fragen

Kann ich meine alte Google-Zeitachse übernehmen?

Ja, laut Dokumentation per Google-Takeout-Import, ebenso GPX, KML und GeoJSON.

Brauche ich einen separaten Sidekiq-Container?

Nein, seit 1.17.0 laufen Jobs im App-Container. Ältere Setups entfernen dawarich_sidekiq vor dem Dateiwechsel.

Reicht ein Dump der Datenbank als Backup?

Nein. Importe und Exporte liegen im Storage-Volume, und ohne originalen SECRET_KEY_BASE gehen verschlüsselte Werte verloren.

Wie unterscheidet sich Dawarich von Traccar?

Traccar zielt auf Flotten und GPS-Tracker, Dawarich auf den persönlichen Verlauf. Für Flotten: Traccar mit Docker Compose.

Fazit

Dawarich 1.19.0 ist schnell installiert und ersetzt die Google-Zeitachse solide. Der Aufwand liegt im Betrieb: Standardzugang ersetzen, Geheimnisse und Storage sichern, Updates mit gepinntem Tag und getestetem Restore einspielen. Bei fremden Standortdaten vorher Rechtsgrundlage und Mitbestimmung klären.

Weiterführende Anleitungen und Quellen

• Docker Compose unter Linux: Grundlage für Selfhosting
• Docker Compose absichern: Secrets, Healthchecks, Non-Root
• Traccar mit Docker Compose als GPS-Tracking-Server
• Irische DPC: Bußgeld gegen Google wegen Standortdaten
• Dawarich 1.19.0 Release Notes auf GitHub
• Dawarich-Dokumentation: Self-Hosting
• Dawarich-Dokumentation: Backup und Restore
• Dawarich-Dokumentation: Updating
• Image freikin/dawarich auf Docker Hub