Super Productivity mit Docker installieren: Fortgeschrittene To-do- und Zeiterfassungs-App selbst hosten

Super Productivity vereint Aufgabenverwaltung, Zeiterfassung und Timeboxing in einer App, ohne Abo und ohne Arbeitsdaten in einer fremden Cloud. Die MIT-lizenzierte Software bietet Kanban-Board, Pomodoro-Timer und Integrationen für Jira, GitHub, GitLab, Gitea, OpenProject, CalDAV und weitere Dienste. Sie läuft im Browser, ohne Benutzerkonto und ohne Telemetrie. Hier betreiben Sie die Web-App mit einem WebDAV-Server für die Synchronisation per Docker Compose.

Voraussetzungen

• Docker Engine ab 20.10 mit Docker Compose Plugin v2 (docker compose, kein altes docker-compose). Grundlagen: Docker und Docker Compose auf Linux installieren.
• Linux-Host, VM, NAS mit Docker-Unterstützung oder Raspberry Pi 4/5 mit 64-Bit-System (die aktuellen Images gibt es für linux/amd64 und linux/arm64).
• 1 CPU-Kern und mindestens 256 MB freier RAM für beide Container (zusammen belegen sie rund 21 MB).
• Rund 200 MB Speicherplatz für Images und Daten.
• Optional: Reverse Proxy (Traefik, Caddy, Nginx Proxy Manager) für HTTPS-Termination bei öffentlichem Zugriff (siehe Schritt 7).

Eckdaten auf einen Blick

Alle Variablen sind optional. Sie füllen nur die Sync-Einstellungen im Browser vor, die App startet auch ohne sie.

Schritt 1: Projektordner und WebDAV-Konfiguration anlegen

Legen Sie einen Projektordner an und erstellen Sie dort die webdav.yaml. Fehlt sie, legt Docker an ihrer Stelle ein leeres Verzeichnis an und der WebDAV-Container startet nicht.

# mkdir -p /opt/super-productivity
# cd /opt/super-productivity

Die Vorlage im offiziellen Repo nutzt Benutzer admin mit Passwort admin. Ändern Sie das vor dem ersten Start. Die Datei verwendet die Schlüssel von hacdias/webdav v5 (directory, permissions). Die älteren v4-Schlüssel scope, modify und auth ignoriert v5: Der Server erlaubt dann nur Lesezugriff, Schreibversuche enden mit HTTP 403. Der Block cors ist nötig, weil die App im Browser von Port 8080 aus auf Port 2345 zugreift:

# /opt/super-productivity/webdav.yaml
address: 0.0.0.0
port: 2345
prefix: /
directory: /data
permissions: CRUD
cors:
  enabled: true
  credentials: true
  allowed_headers:
    - '*'
  allowed_hosts:
    - '*'
  allowed_methods:
    - GET
    - HEAD
    - POST
    - PUT
    - DELETE
    - OPTIONS
    - PROPFIND
    - PROPPATCH
    - MKCOL
    - COPY
    - MOVE
    - LOCK
    - UNLOCK
  exposed_headers:
    - '*'
users:
  - username: meinbenutzername
    password: IHR_WEBDAV_PASSWORT

Passen Sie username und password an und notieren Sie beide Werte. Sie benötigen sie in der .env und später in den App-Einstellungen.

$ ls -la /opt/super-productivity/

# Erwartete Ausgabe: webdav.yaml mit korrekten Rechten sichtbar

Schritt 2: .env-Datei mit Zugangsdaten erstellen

Die .env-Datei hält die projektspezifischen Werte außerhalb der compose.yaml. Die App läuft im Browser: WEBDAV_BASE_URL muss deshalb eine Adresse sein, die der Browser erreicht. localhost passt nur, wenn Browser und Docker auf demselben Rechner laufen, sonst tragen Sie http://HOST:2345/ ein.

# /opt/super-productivity/.env

# WebDAV-Zugangsdaten (müssen mit webdav.yaml übereinstimmen)
WEBDAV_BASE_URL=http://HOST:2345/
WEBDAV_USERNAME=meinbenutzername

# Sync-Einstellungen (Intervall in Minuten)
WEBDAV_SYNC_FOLDER_PATH=/
SYNC_INTERVAL=15

# Datenkomprimierung und Verschlüsselung
IS_COMPRESSION_ENABLED=true
IS_ENCRYPTION_ENABLED=false

Ist der WebDAV-Endpunkt öffentlich erreichbar, setzen Sie IS_ENCRYPTION_ENABLED=true und betreiben ihn nur hinter einem HTTPS-Reverse-Proxy.

$ cat /opt/super-productivity/.env

# Alle Variablen korrekt gesetzt, kein Tippfehler in der URL

Schritt 3: compose.yaml erstellen

Die compose.yaml enthält die App und den WebDAV-Server. PostgreSQL und SuperSync aus dem GitHub-Repo fehlen bewusst, sie dienen dort E2E-Tests. Den Healthcheck aus der Repo-Vorlage enthält diese Datei nicht: Das Image hacdias/webdav basiert auf scratch und enthält kein wget, der Container bleibt damit dauerhaft „unhealthy“ und die App startet nie.

# /opt/super-productivity/compose.yaml
services:
  app:
    image: johannesjo/super-productivity:latest
    container_name: super-productivity
    restart: unless-stopped
    ports:
      - "8080:80"
    environment:
      WEBDAV_BASE_URL: ${WEBDAV_BASE_URL:-http://localhost:2345/}
      WEBDAV_USERNAME: ${WEBDAV_USERNAME:-admin}
      WEBDAV_SYNC_FOLDER_PATH: ${WEBDAV_SYNC_FOLDER_PATH:-/}
      SYNC_INTERVAL: ${SYNC_INTERVAL:-15}
      IS_COMPRESSION_ENABLED: ${IS_COMPRESSION_ENABLED:-true}
      IS_ENCRYPTION_ENABLED: ${IS_ENCRYPTION_ENABLED:-false}
    depends_on:
      - webdav

  webdav:
    image: hacdias/webdav:v5
    container_name: super-productivity-webdav
    restart: unless-stopped
    ports:
      - "2345:2345"
    volumes:
      - ./webdav.yaml:/etc/webdav/config.yaml:ro
      - webdav_data:/data

volumes:
  webdav_data:

Der App-Container braucht kein Volume: Die Daten liegen im Browser und werden per WebDAV in das Volume webdav_data synchronisiert, das Neustarts und Updates übersteht.

$ cd /opt/super-productivity
$ docker compose config

# Keine Fehler, beide Services und das Volume werden ausgegeben

Schritt 4: Container starten

Starten Sie den Stack. Docker Compose lädt beide Images von Docker Hub und startet den WebDAV-Container vor dem App-Container.

$ cd /opt/super-productivity
$ docker compose up -d

Die Images sind klein (App ca. 79 MB, WebDAV rund 4 MB).

$ docker compose ps

# Erwartete Ausgabe:
# NAME                          IMAGE                                    STATUS
# super-productivity            johannesjo/super-productivity:latest     Up (running)
# super-productivity-webdav     hacdias/webdav:v5                        Up

$ docker compose logs --tail=20

# Keine Fehlermeldungen zu Image/Port/Volume/Config

Zusätzlich per curl prüfen:

$ curl -I http://localhost:8080

# HTTP/1.1 200 OK  ← App liefert Antwort

$ curl -I http://localhost:2345/

# HTTP/1.1 401 Unauthorized  ← WebDAV erreichbar, Authentifizierung erwartet

Schritt 5: Erste Einrichtung im Browser und WebDAV-Sync aktivieren

Öffnen Sie http://HOST:8080 im Browser (HOST ist die IP-Adresse oder der Hostname Ihres Servers). Super Productivity startet direkt ohne Login-Maske: kein Benutzerkonto, keine Registrierung.

1. Öffnen Sie die Einstellungen (Zahnrad-Symbol unten links).
2. Wechseln Sie zum Bereich Sync / WebDAV.
3. Die Felder „WebDAV-URL“, „Benutzername“ und „Sync-Pfad“ sind durch die Umgebungsvariablen vorausgefüllt. Prüfen Sie die Werte und ergänzen Sie das Passwort aus Ihrer webdav.yaml.
4. Klicken Sie auf Verbindung testen. Bei Erfolg erscheint eine grüne Bestätigung.
5. Aktivieren Sie den Sync und klicken Sie auf Speichern.

Ab jetzt werden alle Aufgaben, Zeiterfassungs-Einträge und Einstellungen im eingestellten Intervall (Standard 15 Minuten) und bei Änderungen mit dem WebDAV-Container synchronisiert.

$ docker compose logs webdav --tail=10

# Erwartete Ausgabe: Zeilen "user authorized" mit Ihrem Benutzernamen

Schritt 6: Jira, GitHub oder GitLab verbinden (optional)

Integrationen richten Sie unter Einstellungen → Projekte → Neues Projekt → Integration ein.

Für Jira benötigen Sie die Basis-URL Ihrer Jira-Instanz, Ihren Benutzernamen und ein API-Token (über id.atlassian.com/manage-profile/security/api-tokens abrufbar).

Für GitHub und GitLab reicht ein Personal Access Token mit read:project-Berechtigung. Issues erscheinen dann als Aufgaben.

Die Zugangsdaten speichert die App nur im Browser.

Schritt 7: Reverse Proxy und HTTPS einrichten (empfohlen)

Im LAN reicht HTTP auf Port 8080. Ist die App aus dem Internet erreichbar, gehört ein Reverse Proxy mit HTTPS davor, sonst gehen WebDAV-Zugangsdaten und Aufgaben unverschlüsselt über das Netz. Anleitungen dazu finden Sie unter Caddy als Reverse Proxy einrichten: Anfänger-Anleitung mit automatischem HTTPS und Traefik als Docker-Reverse-Proxy mit automatischem HTTPS.

$ curl -I https://example.com

# HTTP/2 200  ← TLS aktiv, App erreichbar

Schritt 8: Updates und Backup

Da der App-Container selbst keine persistenten Daten hält, ist ein Update unkompliziert:

$ cd /opt/super-productivity
$ docker compose pull
$ docker compose up -d

# Kein Migrations-Schritt erforderlich; webdav_data bleibt unberührt

Wer eine bestimmte Version festhalten will, ersetzt latest durch einen Versions-Tag; auf Docker Hub tragen die Tags ein vorangestelltes v, etwa johannesjo/super-productivity:v20.0.0 (ein Tag 20.0.0 ohne v existiert nicht). Nach einem Update mit dieser Compose-Datei bleiben per WebDAV abgelegte Dateien abrufbar, WebDAV weist Zugriffe ohne oder mit falschem Passwort weiter mit 401 ab. Das gilt auch für den Wechsel von v19.3.0 auf v20.0.0: Dockerfile und Beispiel-Compose im Repository sind gegenüber 19.3.0 unverändert, und im Test lief nach docker compose pull und docker compose up -d die neue Version, die zuvor per WebDAV abgelegte Datei war unverändert abrufbar.

Für das Backup des WebDAV-Volumes starten Sie einen kurzlebigen Alpine-Container, denn das WebDAV-Image enthält kein tar. Compose benennt das Volume nach dem Projektordner, hier super-productivity_webdav_data (prüfen mit docker volume ls):

$ cd /opt/super-productivity

docker run --rm -v super-productivity_webdav_data:/data:ro -v "$PWD":/backup alpine \
  tar czf /backup/sp-backup-$(date +%Y%m%d).tar.gz -C /data .

Zusätzlich können Sie jederzeit aus der App heraus einen Export als JSON oder CSV erstellen (Einstellungen → Daten → Exportieren).

Werkzeuge für automatische Container-Updates vergleicht die Anleitung Docker-Container automatisch aktualisieren nach dem Watchtower-Aus: Diun, WUD und Renovate im Vergleich.

$ docker compose ps

# Beide Container STATUS = Up; Image-Tags zeigen aktuelle Version

$ tar tzf sp-backup-$(date +%Y%m%d).tar.gz | head

# Archiv lässt sich lesen und enthält die Sync-Dateien

$ docker compose logs --tail=5

# Keine Fehler nach dem Update

Troubleshooting / Typische Fehler

WebDAV-Container startet nicht, Fehler „not a directory“ oder „no such file or directory“

Die webdav.yaml fehlt im Projektordner. Datei anlegen, ein eventuell von Docker erzeugtes Verzeichnis gleichen Namens vorher löschen.

App-Container bleibt im Status „Created“, Meldung „dependency failed to start … is unhealthy“

Die compose.yaml enthält den wget-Healthcheck aus der Repo-Vorlage, den das WebDAV-Image nicht ausführen kann. Healthcheck und condition: service_healthy entfernen. Startet der WebDAV-Container selbst nicht, zeigt docker compose logs webdav die Ursache (YAML-Fehler, Port 2345 belegt: ss -tlnp | grep 2345).

Port 8080 belegt

Host-Port in der compose.yaml ändern, z. B. "9080:80".

Verbindungstest klappt, Speichern scheitert mit 403

Die webdav.yaml nutzt noch v4-Schlüssel (scope, modify). Auf directory: /data und permissions: CRUD umstellen und docker compose restart webdav ausführen.

WebDAV-Verbindungstest schlägt im Browser fehl

URL oder Zugangsdaten passen nicht zur webdav.yaml, die URL ist vom Browser aus nicht erreichbar (localhost auf einem anderen Rechner) oder der cors-Block fehlt.

Daten weg nach Browser-Wechsel

Der WebDAV-Sync war nicht aktiv. Richten Sie ihn direkt nach dem ersten Start ein.

Container startet nicht auf dem Raspberry Pi

Die aktuellen Images gibt es nur für linux/amd64 und linux/arm64. Ein 32-Bit-System (armv7) wird nicht bedient, installieren Sie ein 64-Bit-Raspberry-Pi-OS. docker inspect johannesjo/super-productivity:latest | grep Architecture zeigt die geladene Architektur.

PostgreSQL und SuperSync starten mit

Die compose.yaml stammt unverändert aus dem GitHub-Repo. Nur app und webdav wie in dieser Anleitung verwenden.

Integrations-Issues erscheinen nicht

Bei Jira das API-Token auf Ablauf prüfen; bei GitHub/GitLab die Token-Berechtigungen (read:project bzw. read_api) kontrollieren.

Häufige Fragen

Brauche ich PostgreSQL für den Betrieb?

Nein. PostgreSQL gehört zum E2E-Test-Setup im GitHub-Repo. Super Productivity speichert die Daten im Browser und synchronisiert sie per WebDAV.

Funktioniert der Container auf einem Raspberry Pi?

Ja, mit 64-Bit-System. Die aktuellen Tags enthalten Images für linux/amd64 und linux/arm64, Docker wählt die passende Architektur automatisch. Für 32-Bit-Systeme (armv7) gibt es keine aktuellen Images.

Wie sichere ich meine Daten regelmäßig?

Manuell über den Export der App (Einstellungen → Daten → Exportieren) oder automatisiert mit dem Volume-Backup aus Schritt 8. Für eine Strategie mit Offsite-Kopie siehe die Anleitung 3-2-1-Backup-Strategie umsetzen: Anleitung mit Restic, USB-Disk und S3-Cloud.

Kann ich Super Productivity auf mehreren Geräten nutzen?

Ja, über den WebDAV-Container (alternativ Dropbox oder Nextcloud). Alle Geräte zeigen auf dieselbe WebDAV-URL mit denselben Zugangsdaten. Super Productivity ist eine Einzelbenutzer-App: Für mehrere Personen legen Sie je Person einen eigenen WebDAV-Benutzer mit eigenem directory an.

Wie aktualisiere ich den Stack?

Mit docker compose pull && docker compose up -d, wie in Schritt 8 beschrieben. Die Daten im Volume webdav_data bleiben erhalten.

Kann ich Jira-Zeit direkt auf Tickets buchen?

Ja. Nach der Verbindung eines Jira-Projekts in den Einstellungen kann die laufende Zeiterfassung direkt einem Jira-Issue zugeordnet werden. Beim Stoppen des Timers bietet Super Productivity an, die Zeit als Jira-Worklog zu übermitteln.

Fazit

Das Setup besteht aus zwei kleinen Containern ohne Datenbank. Entscheidend ist der WebDAV-Sync, denn ohne ihn liegen die Daten nur im Browser. Achten Sie auf die v5-Syntax der webdav.yaml, den CORS-Block und eine vom Browser erreichbare WEBDAV_BASE_URL.

Weiterführende Anleitungen und Quellen

1. Docker und Docker Compose auf Linux installieren (Ubuntu/Debian): die Self-Hosting-Grundlage
2. Docker Compose absichern: Secrets, Healthchecks, Non-Root und Read-Only für den Produktivbetrieb
3. Traefik als Docker-Reverse-Proxy mit automatischem HTTPS einrichten
4. 3-2-1-Backup-Strategie umsetzen: Anleitung mit Restic, USB-Disk und S3-Cloud

Offizielle Quellen: Super Productivity auf GitHub · Offizielles Docker-Wiki (2.13) · Docker Hub: johannesjo/super-productivity · super-productivity.com

Passende Anleitungen auf S-EDV

1. copyparty mit Docker selbst hosten: Datei-Server mit Web-UI und WebDAV
2. Nextcloud mit Docker einrichten (All-in-One): die eigene Cloud
3. Restic Backup auf Linux und Windows einrichten und automatisieren