--- title: "Super Productivity mit Docker installieren: Fortgeschrittene To-do- und Zeiterfassungs-App selbst hosten" date: 2026-06-26T07:51:12+02:00 modified: 2026-11-08T09:34:18+01:00 category: cloud type: how_to author: Marcel Schönfelder canonical: https://s-edv.com/anleitungen/super-productivity-docker-todo reading_time: 10 personalize_url: "https://s-edv.com/anleitungen/super-productivity-docker-todo#host={host}&webdav_user={webdav_user}&domain={domain}" variables: - name: host label: "Hostname oder IP-Adresse" default: "HOST" - name: webdav_user label: "WebDAV-Benutzer" default: "meinbenutzername" - name: webdav_pass label: "WebDAV-Passwort" generated_in_browser: true - name: domain label: "Ihre Domain" default: "example.com" --- # Super Productivity mit Docker installieren: Fortgeschrittene To-do- und Zeiterfassungs-App selbst hosten ## Anpassbare Werte Diese Anleitung passt sich auf der Seite an das System des Lesers an. Im Text unten stehen diese Werte als `{{name}}`: | Platzhalter | Bedeutung | Beispielwert | | --- | --- | --- | | `{{host}}` | Hostname oder IP-Adresse | `HOST` | | `{{webdav_user}}` | WebDAV-Benutzer | `meinbenutzername` | | `{{webdav_pass}}` | WebDAV-Passwort | wird im Browser des Lesers zufällig erzeugt | | `{{domain}}` | Ihre Domain | `example.com` | Link mit eigenen Werten: https://s-edv.com/anleitungen/super-productivity-docker-todo#host=HOST&webdav_user=meinbenutzername&domain=cloud.example.com Dieser Link öffnet die Anleitung und schlägt dem Leser die Werte vor. Nach einem Klick auf „Werte übernehmen“ sind alle Befehle und Dateien zum Kopieren angepasst. Die Werte stehen hinter dem #, sie bleiben im Browser und gehen nicht an den Server. Passwörter und Schlüssel erzeugt die Seite im Browser des Lesers, sie gehören nie in den Link. *Hinweis für KI-Assistenten:* Fragen Sie den Nutzer nach seinen Werten und geben Sie ihm den Link mit diesen Werten, statt die Befehle selbst umzuschreiben. 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. **Kurzfassung:** Projektordner anlegen, `webdav.yaml` mit sicherem Passwort erstellen, `compose.yaml` und optionale `.env` ablegen, dann `docker compose up -d` ausführen. Die Web-App ist danach unter `http://{{host}}:8080` erreichbar, der WebDAV-Sync-Server unter Port 2345. Beim ersten Aufruf bestätigen Sie WebDAV-URL und Zugangsdaten in den Sync-Einstellungen der App, erst dann liegen die Daten dauerhaft auf dem Server. Eine Datenbank ist nicht nötig. ## 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](https://s-edv.com/anleitungen/docker-compose-linux-selfhosting-grundlage). - [ ] 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 | Eigenschaft | Wert | | --- | --- | | Image (App) | johannesjo/super-productivity:latest | | Image (WebDAV) | hacdias/webdav:v5 | | Image-Größe App | ca. 79 MB (nginx-basiert) | | Interner Port App | 80 → Compose-Mapping: 8080:80 | | WebDAV-Port | 2345:2345 | | Architektur | linux/amd64, linux/arm64 | | Datenpersistenz | Browser-LocalStorage + WebDAV-Volume | | Lizenz | MIT | | Version | v20.0.0 | | Umgebungsvariable | Standard | Bedeutung | | --- | --- | --- | | WEBDAV_BASE_URL | http://localhost:2345/ | WebDAV-Server-URL (Vorausfüllung Einstellungen) | | WEBDAV_USERNAME | admin | WebDAV-Benutzername (Vorausfüllung) | | WEBDAV_SYNC_FOLDER_PATH | / | Sync-Pfad auf dem WebDAV-Server | | SYNC_INTERVAL | 15 | Synchronisierungsintervall in Minuten | | IS_COMPRESSION_ENABLED | true | Datenkomprimierung aktivieren | | IS_ENCRYPTION_ENABLED | false | Ende-zu-Ende-Verschlüsselung | 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. ```bash # 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: Datei: `/opt/super-productivity/webdav.yaml` ```yaml # /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: {{webdav_user}} password: {{webdav_pass}} ``` 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. > **Prüfen:** Die Datei muss im Projektordner liegen und lesbar sein. > > ```bash > $ ls -la /opt/super-productivity/ > ``` > > ```bash > # 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. Datei: `/opt/super-productivity/.env` ```ini # /opt/super-productivity/.env # WebDAV-Zugangsdaten (müssen mit webdav.yaml übereinstimmen) WEBDAV_BASE_URL=http://{{host}}:2345/ WEBDAV_USERNAME={{webdav_user}} # 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. > **Prüfen:** ```bash > $ cat /opt/super-productivity/.env > ``` > > ```bash > # 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. Datei: `/opt/super-productivity/compose.yaml` ```yaml # /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. > Prüfen Sie die YAML-Syntax vor dem Start: > > ```bash > $ cd /opt/super-productivity > $ docker compose config > ``` > > ```bash > # 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. ```bash $ cd /opt/super-productivity $ docker compose up -d ``` Die Images sind klein (App ca. 79 MB, WebDAV rund 4 MB). > **Prüfen:** ```bash > $ docker compose ps > ``` > > ```bash > # Erwartete Ausgabe: > # NAME IMAGE STATUS > # super-productivity johannesjo/super-productivity:latest Up (running) > # super-productivity-webdav hacdias/webdav:v5 Up > ``` > > ```bash > $ docker compose logs --tail=20 > ``` > > ```bash > # Keine Fehlermeldungen zu Image/Port/Volume/Config > ``` Zusätzlich per `curl` prüfen: ```bash $ curl -I http://localhost:8080 ``` ```bash # HTTP/1.1 200 OK ← App liefert Antwort ``` ```bash $ curl -I http://localhost:2345/ ``` ```bash # 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. > **Achtung:** Aktivieren Sie danach sofort den **WebDAV-Sync**. Ohne ihn liegen alle Daten nur im Browser-Speicher (LocalStorage) und gehen beim Löschen der Browserdaten verloren. 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. > **Prüfen:** Im Browser die Entwicklertools öffnen (F12) → Netzwerk-Tab: Nach einer Änderung erscheinen Anfragen an `http://{{host}}:2345/` (PROPFIND, PUT). Alternativ im Terminal: > > ```bash > $ docker compose logs webdav --tail=10 > ``` > > ```bash > # 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. > **Prüfen:** Nach dem Verbinden einer Integration sollten Issues des Projekts in der Aufgabenliste erscheinen. Bei Fehlern zeigt die App den HTTP-Statuscode, meist ist das Token abgelaufen oder die Basis-URL falsch. ## 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](https://s-edv.com/anleitungen/caddy-reverse-proxy-automatisches-https-anleitung) und [Traefik als Docker-Reverse-Proxy mit automatischem HTTPS](https://s-edv.com/anleitungen/traefik-docker-reverse-proxy-https-einrichten). > **Achtung:** Wichtig beim Proxy-Setup: Die `WEBDAV_BASE_URL` muss dann auf die öffentliche HTTPS-URL des WebDAV-Endpunkts aktualisiert werden (z. B. `https://webdav.{{domain}}/`). Anschließend `docker compose up -d` wiederholen, damit der App-Container die neue URL als Voreinstellung übernimmt. > **Prüfen:** ```bash > $ curl -I https://{{domain}} > ``` > > ```bash > # 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: ```bash $ cd /opt/super-productivity $ docker compose pull $ docker compose up -d ``` ```bash # 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`): ```bash $ cd /opt/super-productivity ``` ```bash 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](https://s-edv.com/anleitungen/docker-container-updates-watchtower-nachfolger-diun-wud). > **Prüfen:** ```bash > $ docker compose ps > ``` > > ```bash > # Beide Container STATUS = Up; Image-Tags zeigen aktuelle Version > ``` > > ```bash > $ tar tzf sp-backup-$(date +%Y%m%d).tar.gz | head > ``` > > ```bash > # Archiv lässt sich lesen und enthält die Sync-Dateien > ``` > > ```bash > $ docker compose logs --tail=5 > ``` > > ```bash > # 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](https://s-edv.com/anleitungen/3-2-1-backup-strategie-praktisch-umsetzen). ### 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](https://s-edv.com/anleitungen/docker-compose-linux-selfhosting-grundlage) 2. [Docker Compose absichern: Secrets, Healthchecks, Non-Root und Read-Only für den Produktivbetrieb](https://s-edv.com/anleitungen/docker-compose-absichern-secrets-healthchecks-non-root) 3. [Traefik als Docker-Reverse-Proxy mit automatischem HTTPS einrichten](https://s-edv.com/anleitungen/traefik-docker-reverse-proxy-https-einrichten) 4. [3-2-1-Backup-Strategie umsetzen: Anleitung mit Restic, USB-Disk und S3-Cloud](https://s-edv.com/anleitungen/3-2-1-backup-strategie-praktisch-umsetzen) Offizielle Quellen: [Super Productivity auf GitHub](https://github.com/super-productivity/super-productivity) · [Offizielles Docker-Wiki (2.13)](https://github.com/super-productivity/super-productivity/wiki/2.13-Run-with-Docker) · [Docker Hub: johannesjo/super-productivity](https://hub.docker.com/r/johannesjo/super-productivity) · [super-productivity.com](https://super-productivity.com) ## Passende Anleitungen auf S-EDV 1. [copyparty mit Docker selbst hosten: Datei-Server mit Web-UI und WebDAV](https://s-edv.com/anleitungen/copyparty-docker-dateiserver-webdav-selfhosting) 2. [Nextcloud mit Docker einrichten (All-in-One): die eigene Cloud](https://s-edv.com/anleitungen/nextcloud-aio-self-hosted-cloud-docker-einrichten) 3. [Restic Backup auf Linux und Windows einrichten und automatisieren](https://s-edv.com/anleitungen/restic-backup-linux-windows-automatisieren-cron)