Die Google Maps-Zeitachse ist ein nützliches Tool, um persönliche Bewegungsdaten aufzuzeichnen und zu visualisieren. Doch was, wenn man seine Daten nicht einem großen Konzern überlassen möchte? Hier kommt Dawarich ins Spiel: eine Open-Source-Software, die dir ähnliche Funktionen bietet – direkt auf deinem eigenen Server.

Dawarich ist ein vielseitiges Tool, das für viele Anwendungsfälle nützlich sein kann. Es ermöglicht dir, deine täglichen Bewegungen zu analysieren, Reisen zu dokumentieren oder Routinen zu optimieren. Egal, ob du deine Joggingstrecken nachvollziehen, Geschäftsreisen auswerten oder einfach Erinnerungen an besuchte Orte festhalten möchtest – Dawarich gibt dir die Kontrolle über deine Standortdaten. Darüber hinaus kann es für Unternehmen oder Teams interessant sein, die Bewegungsdaten von Außendienstmitarbeitern oder Logistikfahrzeugen effizient und datenschutzkonform zu verwalten. Mit Funktionen wie Reverse-Geocoding und individuell einstellbaren Parametern bietet Dawarich eine flexible Plattform für alle, die ihre Standortdaten sinnvoll nutzen möchten, ohne sie Dritten preiszugeben.

In diesem Beitrag zeige ich dir, wie du Dawarich unter Debian mit Docker installierst und konfigurierst. Als App zum Tracken des Standorts wird OwnTracks verwendet. Verwendest du bereits die Google Maps Zeitachse, kannst du deine Daten später einfach importieren. Für die Einrichtung von Dawarich benötigst du eine eigene Domain, da diese für die Kommunikation mit der App und die Absicherung über HTTPS unverzichtbar ist.

Docker installieren

Dawarich ist als Docker-Container vorhanden und lässt sich somit recht einfach installieren. Falls noch nicht geschehen, musst du also zunächst Docker und Docker Compose installieren.

Verbinde dich per PuTTY auf deinen Server. Suche zunächst nach Updates, um den Server auf den aktuellsten Stand zu bringen:

apt update

Installiere die erforderlichen Abhängigkeiten, die von Docker benötigt werden:

apt install apt-transport-https ca-certificates curl software-properties-common

Füge den offiziellen Docker-GPG-Schlüssel hinzu, um die Paketsignaturen zu überprüfen:

curl -fsSL https://download.docker.com/linux/debian/gpg | gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

Füge die Docker-Repository hinzu:

echo "deb [arch=amd64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/debian $(lsb_release -cs) stable" | tee /etc/apt/sources.list.d/docker.list > /dev/null

Aktualisiere erneut dein Paketverzeichnis, um die Informationen aus dem Docker-Repository zu erhalten:

apt update

Installiere Docker nun mit dem folgenden Befehl:

apt install docker-ce docker-ce-cli containerd.io

Starte den Docker-Dienst und aktiviere ihn, damit er bei jedem Systemstart gestartet wird:

systemctl start docker

systemctl enable docker

Führe den folgenden Befehl aus, um Docker Compose herunterzuladen und in das Verzeichnis /usr/local/bin zu verschieben. Dieser Befehl installiert die neueste Version von Docker Compose:

curl -L "https://github.com/docker/compose/releases/latest/download/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

Gib ausführbare Berechtigungen für Docker Compose:

chmod +x /usr/local/bin/docker-compose

Docker wurde nun installiert. Jetzt kann Dawarich installiert werden.

Reverse Proxy mit Apache einrichten

Im folgenden habe ich einmal eine Virtual Host Datei für Apache2 zusammengestellt, die dafür sorgt, dass der Dienst über deine Domain und ohne Port erreichbar ist.

<VirtualHost *:443>
	ServerName sub.domain.tld

	ProxyPass / http://127.0.0.1:3000/
	ProxyPassReverse / http://127.0.0.1:3000/

	SSLEngine On
	SSLCertificateFile /Pfad/zur/cert.pem
	SSLCertificateKeyFile /Pfad/zur/private.pem
	SSLCertificateChainFile /Pfad/zur/fullchain.pem

	RequestHeader set X-Forwarded-Proto https
	RequestHeader set X-Forwarded-Ssl on
	RequestHeader set X-Forwarded-Port 443
</VirtualHost>

Diese für deine Domain angepasste Config erstellst du hier:

nano /etc/apache2/sites-available/dawarich.conf

Aktiviere nun die eben erstelle Konfiguration:

a2ensite dawarich.conf

Und starte Apache2 einmal neu:

systemctl restart apache2

Dawarich ist nun über deine hinterlegte Domain im Browser aufrufbar.

Dawarich installieren

Die Installation von Dawarich sollte aus Sicherheitsgründen nur als nicht-Root Benutzer erfolgen. Falls noch kein anderer Benutzer existiert, erstellst du einen:

adduser dawarich

Befolge die weiteren Schritte, um den Benutzer anzulegen.

Vergib dem neuen Benutzer die Berechtigung, Docker zu verwenden:

usermod -aG docker dawarich

Wechsel jetzt die Sitzung in den neuen Benutzer:

su dawarich

Erstelle nun ein neues Verzeichnis, in welchem die Dawarich-Dateien gespeichert werden sollen, beispielsweise namens Dawarich, und begib dich dort hinein:

cd /Pfad/zum/Ordner/Dawarich

In diesem musst du die docker-compose.yml anlegen. Bei GitHub findest du eine Vorlage, bei welcher aber noch einige Änderungen vorgenommen werden müssen: github.com/Freika/dawarich/blob/master/docker/docker-compose.yml

• "password": Das Wort kommt insgesamt dreimal vor und muss durch ein sicheres, immer gleiches Passwort ersetzt werden.
• "TIME_ZONE": Hier muss die Zeitzone von Deutschland angegeben werden: Europe/Berlin
• "DISTANCE_UNIT": hier sollte km festgelegt sein.
• "APPLICATION_HOSTS" im Bereich "dawarich_app": Hier muss zusätzlich deine Domain angegeben werden, unter welcher Dawarich erreichbar ist: 'sub.domain.tld,localhost'
• "cpus" und "memory": Insgesamt zweimal kannst du hier festlegen, wie viele Kerne und wie viel Arbeitsspeicher Dawarich maximal verwenden darf.

Hast du die Konfigurationsdatei für deine Bedürfnisse angepasst und abgespeichert, kannst du die Docker-Container starten:

docker compose up -d

Wenn alle Container hochgefahren sind, kannst du Dawarich über die festgelegte Domain in deinem Browser erreichen. Der Standard-User lautet demo@dawarich.app mit dem Kennwort password.

Über den Benutzer rechts oben Settings Users kannst du dir zunächst einen eigenen Benutzter anlegen und dich anschließend mit diesem einloggen.

Über den Benutzer rechts oben Account kannst du deinen API-Link auslesen, dieser wird später für OwnTracks benötigt.

Ich empfehle, bei der Karte auf das Zahnrad-Symbol zu klicken und den Wert für Minutes between routes anzupassen. Dieser Wert bestimmt, nach wie vielen Minuten ohne Standortänderung eine aktuelle Tour als beendet gilt und eine neue beginnt. Der Standardwert liegt bei 60, aber ich würde empfehlen, ihn auf 15 Minuten zu reduzieren, damit kürzere Besuche ebenfalls als eigene Tour zählen.

Dein Benutzer wird jetzt noch zum Administrator hochgestuft und der Default-User wird aus Sicherheitsgründen gelöscht. Dawarich läuft über Ruby on Rails und daher muss die Rails-Konsole im Docker-Container selbst dafür verwendet werden. Schalte dich dazu zunächst in den Container und die Rails-Konsole:

docker exec -it dawarich_app /bin/sh

bin/rails console

Setze hier folgenden Befehl ab:

User.find_by(email: 'user@example.com').update(admin: true)

Lösche den Default-User:

User.find_by(email: 'demo@dawarich.app').destroy

Verlasse die Konsole und den Container wieder:

exit

exit

Zurück zur Weboberfläche von Dawarich. Die Grundeinrichtung von Dawarich ist nun abgeschlossen. Über die Map kannst du dir ansehen, wo du zu welchem Zeitpunkt warst. Die Daten laufen über deinen eigenen Server und liegen somit in deiner eigenen Hand. Du kannst auch filtern und nur einen bestimmten Zeitraum festlegen, welcher dargestellt werden soll. Außerdem kannst du dir Statistiken ansehen, wie viele Kilometer du in welchem Jahr unterwegs warst.

Über Trips kannst du dir eine Übersicht deiner aufgezeichneten Touren erstellen und anzeigen lassen. Hier werden die einzelnen Strecken in einem festgelegten Zeitraum übersichtlich dargestellt, inklusive Start- und Endzeit sowie der jeweiligen Distanz. Dies ist ein nützliches Feature, um deine getätigten Ausflüge und Reisen einfach nachzuvollziehen.

Visis & Places dient für einen detaillierten Überblick über die Orte, die du besucht hast, und die Dauer deiner Aufenthalte. Dawarich analysiert deine Standortdaten und zeigt dir, wie lange du an bestimmten Orten verweilt hast. Diese Funktion nutzt Reverse Geocoding, um aus deinen Standortkoordinaten aussagekräftige Ortsnamen oder Adressen zu ermitteln. Visits & Places befindet sich derzeit jedoch noch in der Beta-Phase ist und ist noch nicht voll funktionsfähig.

Dawarich befindet sich aktuell in einer frühen Entwicklungsversion. Es kann daher zu Fehlern kommen und es wird davon abgeraten, Dawarich ohne vorher ein Backup erstellt zu haben zu aktualisieren. Sichere dir also stets deine Daten und lies dir zunächst die Release-Notes auf GitHub durch.

OwnTracks konfigurieren

Nun musst du OwnTracks auf deinem Smartphone installieren und konfigurieren, damit diese Apps deinen Standort stets an deinen Dawarich-Server sendet.

Startest du die App, siehst du direkt eine Landkarte. Oben rechts stellst du den Monitoring-Modus ein. Wesentliche Änderungen ist völlig ausrechend für eine genaue Standort-Verfolgung.

Über das Burger-Menü-Icon Einstellungen stellst du nun die Verbindung zu Dawarich her.
Als Verbindung wählst du HTTPS aus. In URL trägst du den vorhin kopierten API-Link ein. Für die Identifikation kannst du noch eine Geräte ID und eine Tracker-ID festlegen. Außerdem loggst du dich im Bereich Zugangsdaten mit deinem Dawarich-User ein. Tippe oben rechts auf das Reload-Symbol, um die Verbindung herzustellen.

Über das Burger-Menü-Icon Einstellungen Erweitert empfehle ich für Ungenaue Positionen den Wert 10, für Minimale Standortänderung den Wert 50 und für Standort Intervall den Wert 30. Das ist ein guter Mittelwert, um den Akku nicht zu stark zu belasten, aber immer noch eine genaue Aufzeichnung des Standortverlaufs zu garantieren. Wenn das Tracking noch genauer sein soll, werden die letzten beiden genannten Werte einfach entsprechend verringert.

Über das Burger-Menü-Icon Status solltest du jetzt noch die Batterieoptimierung für diese App anpassen, damit die Aufzeichnung korrekt funktioniert.

OwnTracks sendet nun deinen Standort an deine Dawarich-Instanz.

Zeitachse von Google Maps importieren

Verwendest du bereits die Zeitachse von Google Maps, kannst du deinen gesamten Verlauf in Dawarich importieren.
Dazu musst du zunächst deine aktuelle Zeitachse exportieren. Begib dich dazu auf deinem Android-Smartphone zu den Systemeinstellungen Standort Zeitachse und klicke auf Zeitachse exportieren. Speichere die Datei Zeitachse.json lokal ab.

Die exportiere Zeitachse.json wird nun in Dawarich importiert. Klicke dazu oben auf den Reiter Imports und wähle New import aus.

Scrolle nach unten und wähle als Quelle Google Phone Takeout aus. Darunter wählst du die exportierte Zeitachse.json Datei aus und klickst auf Create Import, um den Import zu starten.

Je nach Datenmenge kann dieser Import mehrere Stunden dauern. Im Reiter Imports siehst du jederzeit die Anzahl der importierten Standorte.

Ist der Import abgeschlossen, klickst du noch auf den Reiter Stats und dann auf Update stats, um die gesamten Statistiken mit den importierten Daten neu zu laden. Außerdem empfehle ich über den Benutzer rechts oben Settings Background Jobs den Job Start Reverse Geocoding zu starten.

Dawarich aktualisieren

Um Dawarich zu aktualisieren, gehst du wie folgt vor.

Dawarich erhält regelmäßig Aktualisierungen mit Fehlerbehebungen, weiteren Features und Behebungen von Sicherheitslücken. Die Software befindet sich in einer frühen Entwicklungsversion und manuelle Updates sollten nur vorgenommen werden, wenn du vorher deine Daten gesichert hast. Die Konfigurationen können sich jederzeit per Update ändern, sodass hier selbst Hand angelegt werden muss. Außerdem solltest du dir vorher die Release-Notes auf GitHub durchlesen oder im Blog vorbeischauen.

Fahre den Container zunächst herunter. Begib dich dazu in das Verzeichnis von Dawarich und verwende diesen Befehl:

docker-compose down

Lade dir jetzt per pull das neueste Docker-Image von Dawarich herunter:

docker-compose pull

Anschließend kann der Container wieder gestartet werden. Er fährt jetzt mit der neuesten Version hoch.

docker-compose up -d

Backup erstellen

Regelmäßige Backups sind eine wichtige Maßnahme, um vor Datenverlust geschützt zu sein, insbesondere bei selbst gehosteten Anwendungen wie Dawarich. Regelmäßige Backups sind wichtig, um Datenverluste durch Systemausfälle, fehlerhafte Updates oder versehentliches Löschen von Daten zu vermeiden.

Für ein vollständiges Backup von Dawarich ist es nicht erforderlich, alle Docker-Volumes zu sichern. Stattdessen reicht es, ein Export der Dawarich-Datenbank zu erstellen. Die Datenbank enthält alle wichtigen Informationen wie deine Standortdaten, Routen und Konfigurationen.

Um ein Backup der Datenbank durchzuführen, führe einfach den folgenden Befehl in der Shell aus, während die Dawarich-Container laufen. Dieser Befehl exportiert die gesamte Datenbank in eine Datei, die du für eine Wiederherstellung nutzen kannst. Achte darauf, dass du während des Exports sicherstellst, dass keine anderen Prozesse auf die Datenbank zugreifen, um Konsistenzprobleme zu vermeiden:

docker exec -t dawarich_db pg_dumpall --clean --if-exists --username=postgres | gzip > "/Pfad/zum/Backup/dump.sql.gz"

Du kannst den Befehl auch regelmäßig durch ein Cronjob automatisieren, um sicherzustellen, dass du immer ein aktuelles Backup zur Hand hast.

Backup wiederherstellen

Beim Wiederherstellen eines erstellten Backups müssen die Docker-Dateien von Dawarich zunächst komplett gelöscht werden. Anschließend werden die Container neu erzeugt und die Datenbank wird importiert. Die genauen Schritte für einen Restore sind hier in der Dokumentation erklärt: dawarich.app/docs/tutorials/backup-and-restore