Zeiterfassung leicht gemacht: Timetagger mit Docker Compose installieren

Einleitung

In der heutigen Arbeitswelt, egal ob im Büro oder Remote, ist das Erfassen von Arbeitszeiten oft unerlässlich – sei es für die Projektabrechnung, zur Selbstorganisation oder einfach, um einen Überblick über den eigenen Tag zu behalten. Während es viele Cloud-Dienste gibt, bevorzugen manche die volle Kontrolle über ihre Daten. Hier kommt Timetagger ins Spiel: Ein Open-Source-Tool zur Zeiterfassung mit einer einfachen, interaktiven Weboberfläche, das du auf deinem eigenen Server hosten kannst.

Dieser Beitrag führt dich Schritt für Schritt durch die Installation von Timetagger mithilfe von Docker Compose. Docker vereinfacht die Bereitstellung von Anwendungen, indem es sie samt ihren Abhängigkeiten in Container verpackt. Docker Compose erweitert dies, indem es die Konfiguration und das Starten von Multi-Container-Anwendungen (auch wenn Timetagger hier nur ein Container ist) in einer einzigen Datei ermöglicht. Diese Anleitung richtet sich an Anfänger, erklärt aber die Hintergründe, damit du nicht nur klickst, sondern auch verstehst.

Was du brauchst (Voraussetzungen)

Bevor wir starten, stelle sicher, dass du Folgendes zur Verfügung hast:

Einen Server: Das kann ein kleiner Raspberry Pi in deinem Heimnetzwerk sein, ein virtueller Server bei einem Hoster oder ein anderer Linux-Rechner, der dauerhaft läuft.
SSH-Zugang: Du benötigst eine Möglichkeit, dich per Kommandozeile mit deinem Server zu verbinden (z.B. über Terminal/Konsole oder ein Tool wie PuTTY).
Docker und Docker Compose: Diese müssen auf deinem Server installiert sein.
- Wenn Docker noch nicht installiert ist, folge der offiziellen Anleitung für dein Betriebssystem: Install Docker Engine
- Docker Compose ist oft als Plugin für Docker enthalten oder kann separat installiert werden: Install Docker Compose
- Stelle sicher, dass dein Benutzer Docker-Befehle ausführen darf (beispielsweise durch sudo).

Schritt 1: Mit dem Server verbinden und Verzeichnisstruktur anlegen

Öffne dein Terminal oder deine SSH-Konsole und verbinde dich mit deinem Server:

ssh dein_benutzername@deine_server_ip

Ersetze dein_benutzername und deine_server_ip entsprechend.

Nach erfolgreicher Anmeldung erstellen wir ein Verzeichnis für unser Timetagger-Projekt und wechseln direkt hinein:

mkdir timetagger && cd timetagger

Innerhalb dieses timetagger-Verzeichnisses werden wir gleich die Konfigurationsdatei und ein Unterverzeichnis für die persistenten Daten anlegen.

Schritt 2: Die `compose.yml`-Datei erstellen und konfigurieren

Docker Compose verwendet eine YAML-Datei (standardmäßig compose.yml oder docker-compose.yml), um die Dienste, Netzwerke und Volumes für eine Anwendung zu definieren. Erstelle diese Datei mit einem Texteditor deiner Wahl (z.B. nano):

nano compose.yml

Nun fügen wir den Inhalt ein. Wir orientieren uns an der Vorlage aus dem Timetagger-Repository (almarklein/timetagger), passen sie aber leicht an:

services:
    timetagger:
        image: ghcr.io/almarklein/timetagger:latest # Das offizielle Docker-Image für Timetagger
        container_name: timetagger # Ein eindeutiger Name für den laufenden Container
        restart: unless-stopped # Startet den Container automatisch neu, außer er wurde manuell gestoppt
        ports:
            - "1234:80" # Mappt den Port 1234 deines Servers auf den Port 80 im Container
        volumes:
            - ./data:/data # Speichert die Timetagger-Daten persistent im Unterordner "data" auf deinem Server
        environment:
            - TIMETAGGER_LOG_LEVEL=warn # Setzt das Log-Level (z.B. debug, info, warn, error)
            - TIMETAGGER_CREDENTIALS=dein_benutzer:DEIN_BCRYPT_HASH # Deine Anmeldedaten (wird gleich generiert)
            - TZ=Europe/Berlin # Setzt die Zeitzone

Erläuterung der Konfiguration:

services: Definiert die einzelnen Anwendungen (hier nur eine: timetagger).
image: Gibt an, welches Docker-Image verwendet werden soll. ghcr.io/almarklein/timetagger:latest holt die aktuellste Version aus der GitHub Container Registry.
container_name: Gibt dem Container einen festen Namen, was die Verwaltung erleichtert.
restart: unless-stopped: Eine wichtige Einstellung für Dienste, die immer laufen sollen. Der Container startet z.B. nach einem Server-Neustart automatisch wieder.
ports: Hier wird festgelegt, wie du Timetagger erreichst. Das Format ist "HOST_PORT:CONTAINER_PORT". Wir leiten Anfragen an Port 1234 deines Servers an den Port 80 weiter, auf dem der Webserver innerhalb des Timetagger-Containers lauscht. Du kannst den Host-Port (1234) frei wählen, stelle nur sicher, dass er auf deinem Server noch nicht verwendet wird. Wenn du einen Reverse Proxy (wie Nginx Proxy Manager oder Traefik) verwendest, um Timetagger z.B. unter einer Subdomain mit HTTPS zu erreichen, kannst du diesen ports-Abschnitt eventuell ganz weglassen und stattdessen Netzwerkeinstellungen für den Proxy hinzufügen.
volumes: Damit deine erfassten Zeiten und Einstellungen auch nach einem Neustart oder Update des Containers erhalten bleiben, müssen die Daten außerhalb des Containers gespeichert werden. Das Format ist HOST_PFAD:CONTAINER_PFAD. Wir mappen den Ordner /data innerhalb des Containers auf einen Unterordner namens data auf deinem Server (relativ zur compose.yml-Datei).
environment: Hier werden Umgebungsvariablen gesetzt, die das Verhalten des Containers beeinflussen.
- TIMETAGGER_LOG_LEVEL: Steuert, wie gesprächig Timetagger in den Logs ist. warn ist ein guter Mittelweg – es zeigt Warnungen und Fehler, aber keine reinen Informationsmeldungen.
- TIMETAGGER_CREDENTIALS: Hier kommen deine Anmeldedaten hinein. Das Format ist benutzername:passworthash. Wichtig: Speichere hier niemals dein Passwort im Klartext! Wir generieren gleich einen sicheren Hash.
- TZ (optional): Setzt die Zeitzone für den Container, was für korrekte Zeitstempel wichtig ist.

Schritt 3: Datenverzeichnis erstellen

Gemäß unserer compose.yml erwartet Timetagger die Daten im Unterordner data. Erstellen wir diesen nun im Hauptverzeichnis timetagger (wo auch die compose.yml liegt):

mkdir data

Deine Verzeichnisstruktur sollte jetzt so aussehen:

timetagger/
├── compose.yml
└── data/

Schritt 4: Anmeldedaten (Credentials) generieren

Timetagger verwendet bcrypt zum Hashen von Passwörtern. Das ist ein sicheres Verfahren, bei dem das Originalpasswort nicht wiederhergestellt werden kann.

Öffne die Hilfeseite von Timetagger in deinem Browser: timetagger.app/cred
Gib deinen gewünschten Benutzernamen ein (z.B. admin oder deinen Namen).
Gib ein sicheres Passwort ein.
Klicke auf “Generate”.
Kopiere die Zeile unter “For Docker Compose (environment variable):“. Sie sollte mit deinem Benutzernamen beginnen, gefolgt von einem Doppelpunkt und einem Hash, der mit $$ beginnt (z.B. admin:$$2b$$...).

Alternativ: Wenn du die Webseite nicht nutzen möchtest, kannst du bcrypt-Hashes auch auf der Kommandozeile mit Tools wie htpasswd (aus dem apache2-utils-Paket) oder über Python-Bibliotheken erzeugen. Stelle sicher, dass der Hash im bcrypt-Format vorliegt und escape die Dollarzeichen ($) korrekt.

Schritt 5: Anmeldedaten einfügen

Öffne die compose.yml erneut mit deinem Editor:

nano compose.yml

Ersetze die Zeile dein_benutzer:DEIN_BCRYPT_HASH unter environment durch die eben kopierte Zeichenfolge. Achte darauf, dass die Einrückung korrekt bleibt.

# ... (andere Teile der Datei) ...
environment:
    - TIMETAGGER_LOG_LEVEL=warn
    - TIMETAGGER_CREDENTIALS=admin:$$2b$$12$$xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx # <-- Ersetzt durch deine generierten Credentials
    - TZ=Europe/Berlin
# ... (Rest der Datei) ...

Speichere die Datei und schließe den Editor (in nano: Strg+X, dann Y und Enter).

Schritt 6: Timetagger starten

Jetzt sind wir bereit, den Timetagger-Container zu starten. Führe im Verzeichnis timetagger (wo deine compose.yml liegt) folgenden Befehl aus:

sudo docker compose up -d

sudo: Notwendig, falls dein Benutzer nicht in der docker-Gruppe ist.
docker compose up: Startet die in der compose.yml definierten Dienste.
-d: Startet die Container im “detached” Modus, also im Hintergrund. Du bekommst die Kommandozeile zurück.

Docker wird nun das Timetagger-Image herunterladen (falls es noch nicht lokal vorhanden ist) und den Container gemäß deiner Konfiguration starten.

Du kannst den Status des Containers überprüfen mit:

sudo docker compose ps

Und die Logs live verfolgen (nützlich bei Problemen) mit:

sudo docker compose logs -f

(Beenden mit Strg+C)

Schritt 7: Auf Timetagger zugreifen und testen

Öffne einen Webbrowser auf deinem Computer und gib die IP-Adresse deines Servers gefolgt von dem Port ein, den du in der compose.yml festgelegt hast (in unserem Beispiel 1234):

http://deine_server_ip:1234

Du solltest die Startseite von Timetagger sehen.

Klicke auf “App” und dann auf “Login”.
Melde dich mit dem Benutzernamen und dem Passwort an, das du in Schritt 4 verwendet hast.

Wenn der Login klappt – Herzlichen Glückwunsch! Du hast Timetagger erfolgreich auf deinem eigenen Server installiert.

Erste Schritte mit Timetagger

Jetzt kannst du beginnen, deine Zeiten zu erfassen:

Aufnahme starten: Klicke auf “Record”. Gib eine Beschreibung dessen ein, was du tust. Nutze Hashtags (z.B. #projektA, #meeting), um Einträge zu kategorisieren. Die Zeit beginnt zu laufen.
Aufnahme stoppen/neue starten: Klicke auf den laufenden Eintrag unten, um ihn zu stoppen. Du kannst direkt einen neuen Eintrag starten, der nahtlos anschließt.
Nachtragen: Klicke auf den Zeitstrahl oben, um Zeiträume in der Vergangenheit auszuwählen und Einträge manuell hinzuzufügen.
Auswertungen: Nutze die “Report”-Funktion, um deine erfassten Zeiten nach verschiedenen Kriterien zu gruppieren und zu exportieren (z.B. als PDF).
Ansichten: Wechsle zwischen Tages-, Wochen- und Monatsansicht, um einen Überblick zu bekommen.

Timetagger schlägt dir bereits verwendete Tags vor, was hilft, Konsistenz zu wahren.

Fazit

Die Installation von Timetagger mit Docker Compose ist ein überschaubarer Prozess, der dir die volle Kontrolle über deine Zeiterfassungsdaten gibt. Dank Docker ist die Einrichtung isoliert und leicht zu verwalten. Du hast nun ein mächtiges, aber einfach zu bedienendes Werkzeug an der Hand, um deine Zeit effektiv zu managen.

Weitere Informationen und fortgeschrittene Konfigurationen findest du in der offiziellen Timetagger-Dokumentation oder im GitHub-Repository. Ein guter nächster Schritt könnte sein, einen Reverse Proxy einzurichten, um Timetagger sicher über HTTPS und eine eigene Subdomain zu erreichen.

Viel Erfolg beim Tracken deiner Zeit!

Inhaltsverzeichnis