SERVER

Dawarich: Installationsanleitung für eigene Standortdaten

Dawarich installieren für volle Kontrolle über die eigenen Standortdaten! Schritt-für-Schritt-Anleitung zum Selbsthosten mit Docker, Docker Compose und Reverse Proxy (Caddy) für maximale Privatsphäre und Datenhoheit.

Auf YouTube ansehen
Dawarich: Installationsanleitung für eigene Standortdaten hero image

Inhaltsverzeichnis

In einer zunehmend digitalisierten Welt, in der Dienste wie Google Location History allgegenwärtig sind, um persönliche Bewegungen und besuchte Orte nachzuverfolgen, wächst das Bedürfnis nach umfassender Kontrolle über diese sensiblen Daten. Dawarich positioniert sich hier als eine leistungsstarke Open-Source-Alternative, die es Nutzern ermöglicht, ihre Standortverläufe eigenverantwortlich auf einem eigenen Server zu hosten und zu verwalten. Im Folgendem findet sich eine Anleitung zur Installation, Konfiguration und Inbetriebnahme von Dawarich, um die Souveränität über die eigenen Standortdaten zu gewährleisten.

1. Konzeptioneller Rahmen und Notwendigkeit

Dawarich dient als private und sichere Datenbank für geografische Bewegungsdaten. Es ermöglicht eine retrospektive Analyse von Reisen und besuchten Orten, vergleichbar mit kommerziellen Angeboten, jedoch mit dem entscheidenden Vorteil der vollständigen Datenhoheit. Die Motivation hinter Dawarich ist es, Nutzern die Kontrolle darüber zurückzugeben, wo und wie ihre sehr persönlichen Standortinformationen gespeichert und verarbeitet werden.

2. Voraussetzungen für die Installation

Vor Beginn der Installation sind folgende Komponenten und Kenntnisse erforderlich:

  • Server-Infrastruktur: Ein physischer oder virtueller Server. Dies kann ein Heimserver (z.B. Raspberry Pi, Synology NAS) oder ein Virtual Private Server (VPS) bei einem Hoster sein.
  • Software: Docker und Docker Compose müssen auf dem Server installiert und funktionsfähig sein.
  • Domain: Eine registrierte Domain, die für den Zugriff auf die Dawarich-Instanz verwendet wird.
  • Grundlegende Linux-Kenntnisse: Vertrautheit mit der Kommandozeile ist für die Serveradministration und Docker-Verwaltung notwendig.

3. Installationsschritte auf einem Linux-Server (Ubuntu)

Die folgende Anleitung beschreibt die Installation von Dawarich unter Verwendung von Docker und Docker Compose auf einem Ubuntu-Server.

3.1. Server-Bereitstellung und initiale Konfiguration

  • Server-Beschaffung: Ein VPS (Affiliate) wird gemietet.
  • Betriebssystem-Installation: Als Betriebssystem wird Ubuntu 24.04 gewählt. Es wird ein dedizierter Benutzer mit einem sicheren Passwort erstellt.
  • DNS-Konfiguration:
    • Die IP-Adresse des neu bereitgestellten Servers wird ermittelt.
    • In der DNS-Verwaltung der zu verwendenden Domain werden A-Records für die Hauptdomain (@) und Wildcard-Subdomains (*) oder eine spezifische Subdomain (z.B. dawarich.domain.de) auf die IP-Adresse des Servers gesetzt.
    • Wichtig: Die Propagierung von DNS-Änderungen kann einige Zeit in Anspruch nehmen (Minuten bis Stunden). Der Befehl ping dawarich.domain.de kann zur Überprüfung der korrekten Auflösung verwendet werden.

3.2. Installation der Docker Engine und Docker Compose

  • Docker Engine:

    • Aufrufen der offiziellen Installationsanleitung. Es ist wichtig, die Docker Engine zu installieren, nicht Docker Desktop.

    • Spezifischen Anweisungen für Ubuntu befolgen. Dies beinhaltet typischerweise das Hinzufügen des Docker-Repositories und die Installation über apt. Beispielhafte Befehle:

      sudo apt-get update
sudo apt-get install ca-certificates curl
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc

# Add the repository to Apt sources:
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu \
  $(. /etc/os-release && echo "${UBUNTU_CODENAME:-$VERSION_CODENAME}") stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt-get update
      sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
  • Überprüfung der Installation: 
    docker --version
docker compose version
    Diese Befehle sollten die installierten Versionen anzeigen und bestätigen, dass Docker und Docker Compose einsatzbereit sind.

3.3. Vorbereitung und Konfiguration der Dawarich-Anwendung

  • Verzeichniserstellung:
    • Verbindung zum Server herstellen (z.B. über SSH oder Visual Studio Code mit der “Remote - SSH” Erweiterung: benutzername@IP-ADRESSE-DES-SERVERS).
    • Dediziertes Verzeichnis für die Dawarich-Konfiguration erstellen: 
      mkdir dawarich
cd dawarich
  • Docker Compose YAML-Datei:
    • compose.yaml-Datei in diesem Verzeichnis erstellen: touch compose.yaml.
    • Datei mit einem Texteditor öffnen.
    • Inhalt der docker-compose.production.yaml aus dem offiziellen Dawarich-Repository kopieren und in diecompose.yaml einfügen.

3.4. Anpassung der compose.yaml

Die compose.yaml definiert die verschiedenen Dienste (Redis, Datenbank, App, Sidekiq) und deren Interaktion.

  • Netzwerke (networks):
    • Das interne Netzwerk dawarich verbindet die Dawarich-Dienste.
    • Für die spätere Reverse-Proxy-Integration wird ein externes Netzwerk (z.B. proxy) hinzugefügt.
  • Datenbank-Dienst (dawarich_db):
    • Image: postgis/postgis:17-3.5-alpine (PostgreSQL mit PostGIS-Erweiterungen).
    • Volume-Management: Analog zu Redis nutze ich ein Bind-Mount für die Datenbankdaten. dawarich_db_data:/var/lib/postgresql/data zu ./db_data:/var/lib/postgresql/data ändern..
    • Host-Ordner erstellen: mkdir db_data.
    • Umgebungsvariablen (environment):
      • POSTGRES_USER: z.B. postgres (Standard).
      • POSTGRES_PASSWORD: z.B. password (Standard).
      • POSTGRES_DB: z.B. dawarich_production (Standard).
      • Wichtig: Wenn POSTGRES_USER oder POSTGRES_PASSWORD geändert werden, müssen diese Änderungen auch in den Health-Check-Konfigurationen dieses Dienstes sowie in den Datenbankverbindungseinstellungen der dawarich-app und dawarich-sidekiq Dienste konsistent angepasst werden.
  • Dawarich App-Dienst (dawarich_app):
    • Image: Spezifischen Version-Tag verwenden, z.B. freika/da-war-ich:0.27.3. latest vermeiden, da sich Dawarich in aktiver Entwicklung befindet und latest zu unerwarteten Fehlern oder Inkompatibilitäten führen kann.
    • Volumes: Bind-Mounts für persistente Daten konfigurieren:
      • ./public:/var/app/public
      • ./watched:/var/app/tmp/imports/watched
      • ./storage:/var/app/storage
      • Entsprechende Host-Ordner erstellen: mkdir public watched storage. Diese sollten vor dem ersten Start leer sein.
    • Ports: Die Port-Weiterleitung (z.B. 3000:3000) wird später entfernt, wenn der Reverse Proxy konfiguriert wird.
    • Umgebungsvariablen:
      • TIME_ZONE: Setzen der Zeitzone, z.B. Europe/Berlin.
      • APPLICATION_HOSTS: Initial auf localhost und die IP-Adresse des Servers setzen (z.B. localhost,::1,127.0.0.1,123.45.67.89). Später wird hier die Domain eingetragen.
      • Die Datenbank-Verbindungsvariablen (DATABASE_URL oder einzelne Parameter) müssen mit den bei dawarich_db festgelegten Werten übereinstimmen.
    • deploy-Block (Ressourcenlimits): Dieser Block definiert CPU- und RAM-Limits. Falls beim Starten der Container Fehler wie “unsupported deploy” auftreten, den gesamten deploy-Block entfernen, da er nicht von allen Docker-Installationen unterstützt wird.
  • Entfernen nicht benötigter Named Volumes: Wenn durchgehend Bind-Mounts verwendet werden, sollten die Definitionen der Named Volumes am Ende der compose.yaml-Datei entfernt werden.

´´´yml networks: dawarich: external: false

proxy

external: true

services: dawarich_db: image: postgis/postgis:17-3.5-alpine shm_size: 1G container_name: dawarich_db volumes:

  • ./db_data:/var/lib/postgresql/data networks:
  • dawarich environment: POSTGRES_USER: postgres POSTGRES_PASSWORD: password POSTGRES_DB: dawarich_production restart: always healthcheck: test: [ “CMD”, “pg_isready”, “-U”, “postgres” ] interval: 10s retries: 5 start_period: 30s timeout: 10s dawarich_app: image: freika/dawarich:0.27.3 container_name: dawarich_app volumes:
  • ./public:/var/app/public
  • ./watched:/var/app/tmp/imports/watched
  • ./storage:/var/app/storage networks:
  • dawarich

- proxy

ports:

  • 3000:3000

- 9394:9394 # Prometheus exporter, uncomment if needed

stdin_open: true tty: true entrypoint: web-entrypoint.sh command: [‘bin/rails’, ‘server’, ‘-p’, ‘3000’, ‘-b’, ’::’] restart: on-failure environment: RAILS_ENV: production DATABASE_HOST: dawarich_db DATABASE_PORT: 5432 DATABASE_USERNAME: postgres DATABASE_PASSWORD: password DATABASE_NAME: dawarich_production MIN_MINUTES_SPENT_IN_CITY: 60 APPLICATION_HOSTS: localhost,::1,127.0.0.1,123.45.67.89,dawarich.domain.de TIME_ZONE: Europe/Berlin APPLICATION_PROTOCOL: http PROMETHEUS_EXPORTER_ENABLED: false PROMETHEUS_EXPORTER_HOST: 0.0.0.0 PROMETHEUS_EXPORTER_PORT: 9394 SECRET_KEY_BASE: 12345678901234567890 RAILS_LOG_TO_STDOUT: “true” STORE_GEODATA: “true” logging: driver: “json-file” options: max-size: “100m” 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 deploy: resources: limits: cpus: ‘0.50’ # Limit CPU usage to 50% of one core memory: ‘4G’ # Limit memory usage to 4GB ´´´

3.5. Starten der Dawarich-Container

sudo docker-compose up -d

Dieser Befehl lädt die Docker-Images herunter (falls noch nicht vorhanden) und startet alle definierten Dienste im Hintergrund (-d). Logs bei Problemen überprüfen:

sudo docker-compose logs -f
sudo docker-compose ps # Zeigt den Status der Container
sudo docker-compose stats # Zeigt Ressourcenverbrauch

Ein häufiger Fehler beim ersten Start ist ein falscher oder nicht existierender Image-Tag.

3.6. Erster Zugriff und Benutzer-Einrichtung

  • Nachdem alle Container erfolgreich gestartet sind (Health Checks müssen positiv sein), ist Dawarich initial über http://IP-ADRESSE-DES-SERVERS:3000 erreichbar (falls Port 3000 freigegeben wurde).
  • Problem “Blocked Host”: Wenn der Zugriff blockiert wird, liegt es oft an der APPLICATION_HOSTS-Einstellung. IP-Adresse des Servers zu dieser Variable in der compose.yaml hinzufügen, Container stoppen (sudo docker-compose down) und neustarten.
  • Standard-Login: demo@dawarich.app mit dem Passwort password.
  • Passwort ändern: Umgehend Passwort ändern.

4. Konfiguration eines Reverse Proxy (Caddy) für HTTPS und Domain-Zugriff

Für den produktiven Einsatz ist der Zugriff über eine Domain mit HTTPS unerlässlich.

  • Netzwerk-Vorbereitung:

    • Externes Docker-Netzwerk für den Proxy erstellen:

      sudo docker network create proxy

    • Dawarich-Container stoppen: sudo docker-compose down.

    • compose.yaml von Dawarich anpassen:

      • proxy-Netzwerk zur networks-Sektion hinzufügen:

        networks:
  dawarich:
    external: false
  proxy:
    external: true

      • ports-Sektion aus dem dawarich_app-Dienst entfernen.

      • proxy-Netzwerk zum dawarich_app-Dienst hinzufügen:

        services:
  da-war-ich-app:
    # ... andere Konfigurationen ...
    networks:
      - dawarich # internes Netzwerk
      - proxy    # externes Proxy-Netzwerk

      • APPLICATION_HOSTS-Variable in der dawarich_app Konfiguration aktualisieren, um die Domain aufzunehmen.

  • Caddy-Konfiguration:
    • Verzeichnis für Caddy und eine compose.yaml sowie eine Caddyfile darin erstellen: 
      cd ~
mkdir caddy
cd caddy
touch compose.yaml Caddyfile
mkdir data config
    • Caddy compose.yaml (im caddy-Verzeichnis): 
      services:
  caddy:
    image: caddy:2
    container_name: caddy
    restart: unless-stopped
    ports:
      - "80:80"
      - "443:443"
      - "443:443/udp"
    volumes:
      - ./Caddyfile:/etc/caddy/Caddyfile
      - ./data:/data
      - ./config:/config
    networks:
      - proxy
networks:
  proxy:
    external: true
    • Caddyfile (im caddy-Verzeichnis): 
      dawarich.ihredomain.de {
    reverse_proxy da-war-ich-app:3000 # Name des Dawarich-App-Containers und dessen interner Port
    header_up X-Real-IP {remote_host}
    header_up X-Forwarded-For {remote_host}
    header_up X-Forwarded-Proto {scheme}
    # Optional: Komprimierung etc.
    # encode zstd gzip
}
      Caddy kümmert sich automatisch um HTTPS-Zertifikate via Let’s Encrypt.
  • Starten der Dienste:
    1. Caddy (im caddy-Verzeichnis) starten: sudo docker compose up -d.
    2. Dawarich (im dawarich-Verzeichnis) starten: sudo docker compose up -d.
  • Fehlerbehebung:
    • Wenn der Zugriff über die Domain nicht sofort funktioniert, Caddy-Logs überprüfen (cd ~/caddy && sudo docker compose logs -f).
    • Sicherstellen, dass die DNS-Einträge korrekt propagiert sind.
    • Lokalen DNS-Cache leeren (z.B. unter Windows mit ipconfig /flushdns).
    • In einem privaten Browserfenster testen, um Caching-Probleme auszuschließen.
    • Überprüfen, ob die Container in denselben Docker-Netzwerken (proxy) sind und sich gegenseitig erreichen können.

5. Kernfunktionalitäten und Betrieb

  • Datenimport:
    • Immich-Integration: Metadaten aus Bildern in Immich können zur Extraktion von Standortdaten genutzt werden.
    • Google: Daten aus Google Takeout importieren.
  • Kartenansicht und Trip-Management: Importierte Daten visualisieren.
  • Benutzerverwaltung: Weitere Benutzer hinzufügen.
  • Datensicherung und -export:
    • Datenbank-Dump: 
      cd ~/dawarich # Navigieren zum Dawarich-Verzeichnis
mkdir db_backup
sudo docker compose exec dawarich_db pg_dumpall --clean --if-exists --username=postgres | gzip > ./db_backup/backup_dump_$(date +%Y%m%d).sql.gz
    • Dateisystem-Backup: Regelmäßig die gesamte dawarich-Verzeichnisstruktur (inklusive compose.yaml, der Bind-Mount-Ordner public, storage, watched und des Ordners db_backup) sichern. Tools wie Duplicati können hierfür verwendet werden.

6. Fazit und Ausblick

Dawarich stellt eine technisch ausgereifte und flexible Lösung für das selbstgehostete Management von Standortdaten dar. Die Installation mittels Docker und Docker Compose, obwohl detailreich, ermöglicht eine kontrollierte und reproduzierbare Bereitstellung. Die Konfiguration eines Reverse Proxy wie Caddy gewährleistet einen sicheren und benutzerfreundlichen Zugriff über eine eigene Domain mit HTTPS.

Die Möglichkeit, die Hoheit über die eigenen, sehr persönlichen Bewegungsdaten zu behalten, ist in der heutigen Zeit von unschätzbarem Wert. Dawarich bietet die Werkzeuge, um diese Kontrolle effektiv auszuüben. Die sorgfältige Konfiguration der Persistenzmechanismen (Bind-Mounts) und eine durchdachte Backup-Strategie sind für den langfristig zuverlässigen Betrieb unerlässlich. Für datenschutzbewusste Anwender, die eine Alternative zu kommerziellen Standortdiensten suchen, ist Dawarich eine klare Empfehlung. Die Investition in die Einarbeitung und Konfiguration wird durch ein Höchstmaß an Privatsphäre und Datenkontrolle belohnt.

#dawarich #installation #anleitung #docker #self hosting #standortdaten #privatsphäre #datenkontrolle #caddy #linux #tutorial

Diesen Beitrag teilen:

Zurück zu allen Beiträgen
Diese Website verwendet Cookies. Diese sind notwendig, um die Funktionalität der Website zu gewährleisten. Weitere Informationen finden Sie in der Datenschutzerklärung