Kimai selbst hosten mit Docker auf einem Ubuntu-Server

Keine Lust mehr, SaaS-Lösungen fürs Zeiterfassen zu nutzen oder deine Arbeitsdaten an Dritte weiterzugeben? Kimai ist ein modernes, Open-Source-Zeiterfassungstool, das für Teams und Freelancer entwickelt wurde. Es läuft im Browser und unterstützt Multi-User-Zugriffe, Projekte, Rechnungen und vieles mehr. In dieser Anleitung zeige ich dir, wie du Kimai auf einem Ubuntu-Server mit Docker, Caddy für HTTPS und einer MySQL-Datenbank selbst hostest.

Was ist Kimai?

Kimai ist eine leistungsstarke, Open-Source-Zeiterfassungslösung, die Teams und Freelancern hilft, ihre Arbeitszeiten effizient zu verwalten. Mit seiner intuitiven Oberfläche und vielen Funktionen ist Kimai eine beliebte Wahl für alle, die ihre Zeiterfassungsdaten selbst kontrollieren möchten. Was Kimai besonders macht:

• Open Source: Komplett kostenlos und Open Source, du hast volle Kontrolle über deine Daten und kannst alles anpassen
• Multi-User-Unterstützung: Ideal für Teams jeder Größe mit rollenbasiertem Zugriff
• Projektmanagement: Zeitbuchungen lassen sich nach Projekten, Kunden und Tätigkeiten organisieren
• Rechnungen: Erstelle professionelle Rechnungen basierend auf erfasster Zeit
• Berichte: Detaillierte Reports erstellen und Daten in verschiedenen Formaten exportieren
• API-Zugang: Integriere Kimai mit anderen Tools über eine stabile API
• Mobilfreundlich: Greife von jedem modernen Browser auf die Zeiterfassung zu
• Plugin-System: Funktionen lassen sich mit Community-Plugins erweitern

Ob Freelancer, der seine abrechenbaren Stunden trackt, Teamleiter, der Projektfortschritte überwacht, oder Geschäftsinhaber mit mehreren Projekten – Kimai bietet tolle Zeiterfassung ganz ohne wiederkehrende Kosten kommerzieller Lösungen. Durch die Selbst-Hosting-Option hast du volle Datenkontrolle und sparst Abo-Gebühren.

0. Dein Server

Wir nutzen einen Hetzner Cloud VPS als Grundlage. Der ist günstig, schnell und leicht automatisierbar. Hier die empfohlenen Specs:

• OS: Ubuntu 24.04
• CPU: 2 vCPU
• RAM: 4 GB
• Speicher: 40 GB SSD oder mehr
• Netzwerk: IPv4 + IPv6
• Backups: Auto-Backups aktivieren

Warum diese Specs?

• 2 vCPUs reichen für Kimai und die Datenbank locker aus
• 4 GB RAM sorgen auch bei mehreren Nutzern für flüssigen Betrieb
• 40 GB SSD bieten genug Platz für App, Datenbank & Logs
• IPv4 + IPv6 sorgt für maximale Kompatibilität
• Auto-Backups schützen deine Daten vor Hardware-Ausfällen

Das sollte für den Anfang reichen; bei Bedarf kannst du später jederzeit upgraden!

Erstelle deinen Server über das Hetzner Cloud Dashboard. Wenn du noch kein Konto hast, nutze meinen Referral-Link und schnapp dir 20 € Guthaben.

Vergiss nicht, deinen SSH-Schlüssel beim Erstellen hinzuzufügen, damit du dich sicher einloggen kannst.

Firewall konfigurieren

Sicherheit steht an erster Stelle bei einem öffentlich erreichbaren Server. Hetzner hat eine integrierte Firewall, die wir so einstellen, dass nur der nötige Traffic erlaubt wird:

1. Öffne dein Hetzner Cloud Dashboard
2. Gehe zu „Security“ → „Firewalls“
3. Erstelle eine neue Firewall mit diesen Regeln:
   • SSH (Port 22) nur von deiner IP erlauben
   • HTTP (Port 80) von überall erlauben
   • HTTPS (Port 443) von überall erlauben
   • Alle anderen eingehenden Verbindungen blockieren

So sind nur die nötigen Ports offen und dein Server vor unerwünschtem Traffic geschützt.

1. Grundinstallation

Melde dich per SSH an:

ssh root@deine-server-ip

System updaten:

sudo apt-get update
sudo apt-get upgrade -y

So hast du die neuesten Sicherheitsupdates. Regelmäßige Updates sind wichtig, um bekannte Sicherheitslücken zu schließen und die Stabilität zu verbessern.

2. Docker und Docker Compose installieren

Docker lässt uns Kimai in einem isolierten Container laufen, was Verwaltung und Updates erleichtert. Docker Compose orchestriert mehrere Container (Kimai und MySQL) zusammen.

Installiere nötige Pakete:

sudo apt-get install ca-certificates curl gnupg

Füge den Docker-GPG-Schlüssel hinzu:

sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg \
| sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg

Repository hinzufügen:

echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] \
  https://download.docker.com/linux/ubuntu $(. /etc/os-release && echo $VERSION_CODENAME) stable" \
  | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Docker & Compose installieren:

sudo apt-get update
sudo apt-get install docker-ce docker-ce-cli \
containerd.io docker-buildx-plugin docker-compose-plugin -y

Test, ob Docker läuft:

sudo docker run hello-world

Wenn du eine Erfolgsmeldung bekommst, ist alles bereit.

3. Caddy für HTTPS installieren

Ein Reverse Proxy wie Caddy hat viele Vorteile:

1. Automatische SSL/TLS-Zertifikate
2. Zusätzliche Sicherheitsschicht zwischen Internet und App
3. Verwaltung mehrerer Anwendungen auf demselben Server
4. Automatische Weiterleitung von HTTP zu HTTPS

Statt mit Certbot und Nginx rumzudoktern, nehmen wir Caddy – der erledigt die TLS-Zertifikate ganz von allein und erneuert sie automatisch.

Caddy installieren:

sudo apt install -y debian-keyring debian-archive-keyring apt-transport-https curl

curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/gpg.key' \
| sudo gpg --dearmor -o /usr/share/keyrings/caddy-stable-archive-keyring.gpg

curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/debian.deb.txt' \
| sudo tee /etc/apt/sources.list.d/caddy-stable.list

sudo apt update
sudo apt install caddy -y

Caddy läuft automatisch als Service.

Konfig anpassen:

sudo nano /etc/caddy/Caddyfile

Reverse Proxy konfigurieren:

deinedomain.com {
    reverse_proxy localhost:8001
}

Ersetze deinedomain.com mit deiner echten Domain. Achte darauf, dass die A- und AAAA-Records deiner Domain auf deine Server-IP zeigen.

Caddy neu starten:

sudo systemctl restart caddy

Jetzt wird jeder Zugriff auf https://deinedomain.com an den Kimai-Container weitergeleitet.

4. Docker Compose Setup

Mit Docker Compose verwalten wir mehrere Container zusammen. Wir brauchen:

• Eine MySQL-Datenbank für Kimais Daten
• Die Kimai-Anwendung selbst

Verzeichnis anlegen:

mkdir -p ~/kimai && cd ~/kimai
nano docker-compose.yml

Folgenden Inhalt einfügen:

services:
  mysql:
    image: mysql:8.3
    volumes:
      - mysql:/var/lib/mysql
    environment:
      - MYSQL_DATABASE=kimai
      - MYSQL_USER=kimaiuser
      - MYSQL_PASSWORD=useaverylongandsecurepassword
      - MYSQL_ROOT_PASSWORD=useaverylongandsecurepassword
    restart: unless-stopped
    healthcheck:
      test: mysqladmin -p$$MYSQL_ROOT_PASSWORD ping -h localhost
      interval: 20s
      start_period: 10s
      timeout: 10s
      retries: 3

  kimai:
    image: kimai/kimai2:apache
    volumes:
      - data:/opt/kimai/var/data
      - plugins:/opt/kimai/var/plugins
    ports:
      - 8001:8001
    environment:
      - [email protected]
      - ADMINPASS=changemeplease
      - DATABASE_URL=mysql://kimaiuser:useaverylongandsecurepassword@mysql/kimai?charset=utf8mb4&serverVersion=8.3.0
    restart: unless-stopped

volumes:
  data:
  mysql:
  plugins:

Die wichtigsten Punkte:

• Persistente Volumes für Daten und Plugins
• Datenbank-Health-Check
• Automatischer Neustart der Container
• Umgebungsvariablen für Admin-Login und Datenbankverbindung

Starte die Container:

sudo docker compose up -d

Schau, ob alles läuft:

docker ps

Du solltest zwei Container sehen: Kimai und MySQL.

5. Kimai im Browser öffnen

Besuche https://deinedomain.com

Melde dich mit der Email und dem Passwort an, die du im Compose-File eingestellt hast.

Nach dem Login landest du im Dashboard:

6. Sicherheitstipps

Ein eigener Server heißt auch: du bist für die Sicherheit verantwortlich. Hier ein paar Basics:

• 2FA aktivieren in Kimai – für eine zusätzliche Sicherheitsebene
• Starke Passwörter verwenden – die häufigste Sicherheitslücke sind schwache Passwörter
• Docker Images regelmäßig updaten – neue Versionen bringen oft Sicherheitsfixes
• Automatische OS-Updates aktivieren oder regelmäßig apt upgrade ausführen
• Fail2ban installieren, um Brute-Force-Angriffe auf SSH zu blockieren
• Logs überwachen mit docker logs und journalctl -u caddy, um Probleme früh zu erkennen

7. Kimai updaten

Updates sind wichtig für Sicherheit und neue Features. So kommt die neueste Kimai-Version:

sudo docker compose pull
sudo docker compose up -d

Das lädt neue Images und startet die Container neu. Deine Daten bleiben sicher, weil sie in Docker-Volumes liegen. Schau am besten vorher, ob’s keine Breaking Changes gibt.

8. Kostenvergleich

Wenn du bereit bist, Setup und Updates selbst zu machen, ist Selbst-Hosting günstiger und privater. Du hast volle Kontrolle über deine Daten und kannst weitere Tools auf dem Server laufen lassen.

9. Kein Bock auf Serververwaltung?

Selbst-Hosting bringt volle Kontrolle und geringere Kosten, aber du bist auch zuständig für:

• Serverpflege und Updates
• Sicherheits-Patches und Monitoring
• Backups verwalten
• Fehlerbehebung
• SSL-Zertifikate erneuern
• Performance optimieren

Wenn du dich lieber auf dein Business konzentrieren willst, schau dir Sliplane an. Wir bieten Managed Container Hosting, das Kimai (und andere Apps) super einfach macht:

• Ressourcenbasierte Preise – zahl, was du nutzt, nicht pro Nutzer (Kimai Cloud nimmt z.B. €4 pro Nutzer, bei uns ca. €10/Monat für dieselbe Leistung)
• Docker Support – laufe mit jedem Docker-Container, inklusive Kimai
• Automatische Updates – immer die neueste sichere Version
• Tägliche Backups – deine Daten sind sicher und wiederherstellbar
• 24/7 Monitoring – wir überwachen deine App permanent
• Dedizierter Support – Hilfe, wenn du sie brauchst
• Einfache Einrichtung – in Minuten startklar statt in Stunden

Mehr Infos und Preise findest du auf unserer Container Hosting Seite. Außerdem gibt’s eine Setup-Anleitung mit Video, die zeigt, wie simpel der Einstieg ist.

Ganz egal, ob du selbst hostest oder unseren Managed Service nutzt – Kimai ist eine super Wahl fürs Zeiterfassen. Wichtig ist, dass du das richtige Gleichgewicht aus Kontrolle, Kosten und Komfort für dich findest.

Viele Grüße,
Jonas
Co-Founder von Sliplane