Umami mit Docker Compose: Eigene Webanalyse lokal in 20 Minuten starten

Wer eine schlanke Webanalyse ohne Werbeoekosystem, Third-Party-Skripte und Datenabfluss will, landet schnell bei Umami. Das Projekt beschreibt sich in der aktuellen v3-Doku als privacy-focused Analytics-Plattform ohne Cookies und ohne persoenliche Datensammlung. Fuer ein lokales Self-Hosting-Setup ist gerade das spannend: wenig bewegliche Teile, klares Docker-Compose-Setup und ein Ergebnis, das sofort sichtbar ist.

Wichtig fuer den Stand 10. Mai 2026: Die offizielle Dokumentation verweist weiter auf Umami v3, das Repository liefert ein aktuelles docker-compose.yml mit ghcr.io/umami-software/umami:latest und postgres:15-alpine, und der gezeigte Stack liess sich lokal mit HTTP 200 auf 127.0.0.1:3000 und 127.0.0.1:8081 verifizieren.

Selbstgehostete Webanalyse mit Umami, Laptop und kleinem Homeserver

Was du am Ende hast

Umami lokal unter http://127.0.0.1:3000
PostgreSQL als eigene Datenbank im selben Compose-Stack
Eine kleine Demo-Seite unter http://127.0.0.1:8081
Sichtbare Pageviews und ein klickbares Test-Event im Umami-Dashboard

Voraussetzungen

Docker Engine und docker compose sind installiert
Die Ports 3000 und 8081 sind frei
Du startest in einem neuen Projektordner

1. Arbeitsordner anlegen

Nicht in ein altes Compose-Verzeichnis hineinpfuschen. Erstelle zuerst einen sauberen Ordner:

mkdir umami-lab && cd umami-lab
mkdir -p site

2. Compose-Datei schreiben

Das Grundgeruest orientiert sich eng an der offiziellen Compose-Datei des Projekts. Ich binde die Ports hier bewusst nur an 127.0.0.1, damit der Stack zunaechst lokal bleibt.

umami-lab/compose.yaml:

services:
  umami:
    image: ghcr.io/umami-software/umami:latest
    ports:
      - "127.0.0.1:3000:3000"
    environment:
      DATABASE_URL: postgresql://umami:umami@db:5432/umami
      APP_SECRET: CHANGE_ME_TO_A_LONG_RANDOM_SECRET
    depends_on:
      db:
        condition: service_healthy
    init: true
    restart: unless-stopped
    healthcheck:
      test: ["CMD-SHELL", "curl -fsS http://localhost:3000/api/heartbeat || exit 1"]
      interval: 5s
      timeout: 5s
      retries: 10

  db:
    image: postgres:15-alpine
    environment:
      POSTGRES_DB: umami
      POSTGRES_USER: umami
      POSTGRES_PASSWORD: umami
    volumes:
      - umami-db-data:/var/lib/postgresql/data
    restart: unless-stopped
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U $${POSTGRES_USER} -d $${POSTGRES_DB}"]
      interval: 5s
      timeout: 5s
      retries: 10

  demo-site:
    image: nginx:alpine
    ports:
      - "127.0.0.1:8081:80"
    volumes:
      - ./site:/usr/share/nginx/html:ro
    restart: unless-stopped

volumes:
  umami-db-data:

3. Zufalls-Secret setzen

APP_SECRET darf kein Platzhalter bleiben. Ein schneller Weg:

openssl rand -hex 32

Kopiere den erzeugten Wert in compose.yaml an die Stelle von CHANGE_ME_TO_A_LONG_RANDOM_SECRET.

4. Eine lokale Demo-Seite anlegen

Damit du nicht nur das Dashboard siehst, sondern direkt echte Daten erzeugst, legen wir eine kleine Testseite an.

umami-lab/site/index.html:

<!doctype html>
<html lang="de">
  <head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>Umami Demo</title>
  </head>
  <body>
    <h1>Umami Demo</h1>
    <p>Lokale Testseite fuer Pageviews und ein Klick-Event.</p>
    <button data-umami-event="demo-button-click">Demo-Klick</button>
  </body>
</html>

Das Event-Attribut data-umami-event ist direkt aus der Umami-Doku ableitbar: Beim Klick wird ein Event mit genau diesem Namen gespeichert.

5. Stack starten

Jetzt den gesamten Stack hochfahren:

docker compose up -d

Der erste Start zieht mehrere Images und initialisiert die PostgreSQL-Datenbank. Das kann beim ersten Mal kurz dauern.

6. Technisch pruefen, bevor du klickst

Warte nicht blind auf den Browser, sondern pruefe den Stack einmal sauber:

docker compose ps
docker compose logs --tail=100 umami
curl -fsS http://127.0.0.1:3000/api/heartbeat
curl -I http://127.0.0.1:3000
curl -I http://127.0.0.1:8081

Wenn alles stimmt, siehst du einen laufenden PostgreSQL-Container, einen laufenden Umami-Container und erfolgreiche HTTP-Antworten. Genau so liess sich das Setup fuer diesen Artikel lokal verifizieren.

Oeffne jetzt http://127.0.0.1:3000.

Laut offizieller Installationsdoku sind die Standard-Zugangsdaten beim ersten Start:

Benutzername: admin
Passwort: umami

Wichtig: Aendere das Standardpasswort sofort nach dem ersten Login.

8. Website in Umami anlegen und Tracking-Code holen

Damit die Demo-Seite Daten an Umami schickt, brauchst du eine Website-ID aus dem Dashboard.

Lege in Umami eine neue Website an, zum Beispiel Local Demo.
Oeffne bei dieser Website Edit.
Kopiere die dort angezeigte Tracking code-Sektion bzw. die Website ID.

Die Doku sagt hier klar: Der Tracking-Code gehoert in den <head> deiner Website.

9. Tracking-Skript in die Demo-Seite einbauen

Ergaenze den <head> in umami-lab/site/index.html um dieses Skript und ersetze DEINE-WEBSITE-ID:

<script
  defer
  src="http://127.0.0.1:3000/script.js"
  data-website-id="DEINE-WEBSITE-ID"
></script>

Die Datei sieht dann im Kern so aus:

<!doctype html>
<html lang="de">
  <head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>Umami Demo</title>
    <script
      defer
      src="http://127.0.0.1:3000/script.js"
      data-website-id="DEINE-WEBSITE-ID"
    ></script>
  </head>
  <body>
    <h1>Umami Demo</h1>
    <p>Lokale Testseite fuer Pageviews und ein Klick-Event.</p>
    <button data-umami-event="demo-button-click">Demo-Klick</button>
  </body>
</html>

Danach die Demo-Seite im Browser neu laden:

http://127.0.0.1:8081

10. Sichtbares Ergebnis erzeugen

Jetzt kommt der eigentliche Nutzwert:

Besuche http://127.0.0.1:8081
Aktualisiere die Seite ein paar Mal
Klicke auf den Button Demo-Klick
Wechsle zurueck ins Umami-Dashboard

Laut Umami-Doku sollten die Daten unmittelbar im Dashboard auftauchen. Du bekommst damit nicht nur Pageviews, sondern auch das Event demo-button-click.

11. Sinnvolle Alltagsbefehle

Fuer Betrieb und Updates reichen am Anfang diese Kommandos:

docker compose logs -f umami
docker compose pull
docker compose up -d
docker compose down

Die Datenbank bleibt erhalten, weil PostgreSQL auf dem Volume umami-db-data liegt.

12. Was du spaeter verbessern solltest

Fuer den lokalen Test ist 127.0.0.1 genau richtig. Wenn du Umami spaeter im Heimnetz oder oeffentlich bereitstellen willst, brauchst du mindestens:

einen Reverse Proxy mit HTTPS
ein eigenes starkes Datenbank-Passwort statt umami
eine sichere Domain statt direkter IP- oder Port-Freigabe

Erst dann wird aus dem lokalen Demo-Stack ein sauberes Dauer-Setup.

Fazit

Umami ist als Self-Hosting-Projekt gerade deshalb stark, weil es nicht in Infrastruktur-Overkill abrutscht. Ein Compose-Stack, eine PostgreSQL-Datenbank, eine kleine Demo-Seite und sofort sichtbare Ergebnisse reichen aus, um in kurzer Zeit eine brauchbare Webanalyse unter eigener Kontrolle zu bekommen.

Wenn du heute ein Docker-Compose-Projekt mit sichtbarem Resultat suchst, ist das deutlich besser als noch ein abstrakter Container-Artikel ohne echten Browser-Effekt.

User Dashboard