# Umami mit Docker installieren: Schritt-für-Schritt-Anleitung

Mit Umami betreiben Sie eine datenschutzorientierte Webanalyse auf Ihrem eigenen Server und behalten die Kontrolle über die erhobenen Analysedaten. Diese Anleitung zeigt Schritt für Schritt, wie Sie Umami mithilfe von Docker, PostgreSQL und einer verschlüsselten HTTPS-Verbindung auf einem VPS installieren.

## Schritt 1: Passenden Server für Umami auswählen

Für die selbst gehostete Version von [Umami](https://www.ionos.de/digitalguide/server/knowhow/umami/) benötigen Sie einen virtuellen privaten Server, kurz [VPS](https://www.ionos.de/digitalguide/server/knowhow/was-ist-ein-virtual-private-server-vps/). Dabei handelt es sich um einen dauerhaft mit dem Internet verbundenen Computer, den Sie über eine Kommandozeile verwalten. Für Umami selbst müssen Sie **keine kostenpflichtige Softwarelizenz** abschließen. Das Projekt steht unter der MIT-Lizenz. Kosten entstehen daher vor allem für den VPS, eine optionale Domain und gegebenenfalls zusätzliche Backups.

Die benötigte Serverleistung hängt davon ab, wie viele Websites Sie erfassen, wie stark diese besucht werden und wie lange Sie die Analysedaten speichern möchten. Die folgende Übersicht orientiert sich an aktuell verfügbaren VPS-Leistungsstufen. Die Angaben sind als leicht verständliche Ausgangspunkte und nicht als feste Kapazitätsgrenzen zu verstehen.

<table>
  <thead>
    <tr>
      <th><strong>Anwendungsfall</strong></th>
      <th><strong>Geeignete Serverleistung</strong></th>
      <th><strong>Einordnung</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Kleine private Website, Portfolio oder einzelner Blog</td>
      <td>2 vCores, 2 GB RAM, 90 GB NVMe-Speicher</td>
      <td>Ausreichend für eine einfache Umami-Installation mit überschaubarem Datenaufkommen</td>
    </tr>
    <tr>
      <td>Kleine Unternehmenswebsite oder mehrere kleinere Projekte</td>
      <td>4 vCores, 4 GB RAM, 120 GB NVMe-Speicher</td>
      <td>Empfehlenswerter Einstieg, wenn Umami dauerhaft produktiv eingesetzt werden soll</td>
    </tr>
    <tr>
      <td>Gut besuchter Onlineshop, Nachrichtenportal oder mehrere Kundenwebsites</td>
      <td>6 vCores, 8 GB RAM, 240 GB NVMe-Speicher</td>
      <td>Mehr Reserven für viele gleichzeitige Zugriffe, längere Datenspeicherung und umfangreichere Auswertungen</td>
    </tr>
    <tr>
      <td>Agentur, umfangreiche Ereignisdaten und viele Websites</td>
      <td>8 vCores, 16 GB RAM, 480 GB NVMe-Speicher</td>
      <td>Geeignet für größere Datenbestände und zusätzliche Analysefunktionen</td>
    </tr>
  </tbody>
</table>

Für die meisten kleinen Unternehmen ist die Variante mit 4 vCores, 4 GB [RAM](https://www.ionos.de/digitalguide/server/knowhow/was-ist-ein-arbeitsspeicher/) und 120 GB NVMe-Speicher ein **sinnvoller Ausgangspunkt**. Ein Upgrade auf eine größere Serverstufe ist später möglich, falls Speicherverbrauch oder Auslastung deutlich ansteigen.

Zusätzlich benötigen Sie:

- ein 64-Bit-Linux-System,
- einen User mit Administratorrechten,
- eine öffentliche [IPv4-Adresse](https://www.ionos.de/digitalguide/server/knowhow/was-ist-eine-ip-adresse/),
- eine Domain oder Subdomain wie analytics.example.de,
- einen Computer mit Terminal beziehungsweise SSH-Programm,
- Zugriff auf die [DNS](https://www.ionos.de/digitalguide/server/knowhow/domain-name-system/)-Einstellungen Ihrer Domain.

## Schritt 2: VPS mit Ubuntu bereitstellen und Netzwerkzugänge festlegen

Erstellen Sie im Verwaltungsbereich Ihres Hosting-Anbieters einen neuen VPS. Wählen Sie als Betriebssystem [Ubuntu](https://www.ionos.de/digitalguide/server/knowhow/ubuntu-das-linux-system-fuer-jedermann/) 24.04 LTS oder 26.04 LTS in der 64-Bit-Version. Diese Versionen werden offiziell von [Docker](https://www.ionos.de/digitalguide/server/knowhow/was-ist-docker/) unterstützt und sind für eine produktive Installation gut geeignet.

Wenn der Anbieter die Anmeldung mit einem [SSH](https://www.ionos.de/digitalguide/server/tools/secure-shell-ssh/)-Schlüssel ermöglicht, sollten Sie diese Variante einem reinen Passwortzugang vorziehen. Der öffentliche Teil des Schlüssels wird beim Server hinterlegt. Der private Schlüssel bleibt ausschließlich auf Ihrem Computer und darf nicht weitergegeben werden.

Öffnen Sie in der [Firewall](https://www.ionos.de/digitalguide/server/sicherheit/was-ist-eine-firewall/) des Hosting-Anbieters nur die tatsächlich benötigten eingehenden Verbindungen:

<table>
  <thead>
    <tr>
      <th><strong>Port</strong></th>
      <th><strong>Protokoll</strong></th>
      <th><strong>Zweck</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>22</td>
      <td>TCP</td>
      <td>Anmeldung am Server über SSH</td>
    </tr>
    <tr>
      <td>80</td>
      <td>TCP</td>
      <td>Unverschlüsselte HTTP-Verbindung und Ausstellung des TLS-Zertifikats</td>
    </tr>
    <tr>
      <td>443</td>
      <td>TCP</td>
      <td>Verschlüsselte HTTPS-Verbindung</td>
    </tr>
    <tr>
      <td>443</td>
      <td>UDP</td>
      <td>Optionales HTTP/3 über den eingesetzten Webserver</td>
    </tr>
  </tbody>
</table>

[![Bild: Firewall im IONOS Cloud Center](https://www.ionos.de/digitalguide/fileadmin/_processed_/2/9/csm_umami-docker-firewall-konfig_c034393a7e.webp "Firewall im IONOS Cloud Center")](https://www.ionos.de/digitalguide/fileadmin/DigitalGuide/Screenshots_2026/umami-docker-firewall-konfig.jpg) Firewall-Konfiguration mit den freigegebenen Ports 22, 80 und 443. Die später intern verwendeten Ports 3000 für Umami und 5432 für PostgreSQL dürfen **nicht öffentlich freigegeben werden**. Beide Dienste kommunizieren ausschließlich innerhalb des Docker-Netzwerks. Notieren Sie nach der Bereitstellung die öffentliche IP-Adresse und den Namen des administrativen Users.

## Schritt 3: Über SSH mit dem Server verbinden

Öffnen Sie auf Ihrem Computer ein Terminal. Unter macOS und Linux ist bereits ein SSH-Programm vorhanden. Unter aktuellen Windows-Versionen können Sie SSH in der PowerShell oder im Windows Terminal verwenden.

Geben Sie folgenden Befehl ein und ersetzen Sie die beiden Platzhalter:

```bash
ssh SERVERBENUTZER@SERVER_IP
```

Bei der ersten Verbindung erscheint eine Rückfrage zum Fingerabdruck des Servers. Kontrollieren Sie nach Möglichkeit, ob der angezeigte Fingerabdruck mit der Angabe Ihres Hosting-Anbieters übereinstimmt. Bestätigen Sie die Verbindung anschließend mit `yes`.

Aktualisieren Sie nach der Anmeldung zunächst die Paketlisten und die bereits installierte Software:

```bash
sudo apt update
sudo apt upgrade -y
```

Der erste Befehl lädt Informationen zu verfügbaren Paketen. Der zweite Befehl installiert die Aktualisierungen. Falls während der Aktualisierung ein neuer Systemkern installiert wurde, starten Sie den Server neu:

```bash
sudo reboot
```

Die SSH-Verbindung wird dadurch getrennt. Warten Sie kurz, bis der Server wieder erreichbar ist, und melden Sie sich danach erneut mit dem SSH-Befehl an.

## Schritt 4: Docker und Docker Compose installieren

Docker führt Anwendungen in voneinander getrennten [Containern](https://www.ionos.de/digitalguide/server/knowhow/docker-container/) aus. Für diese Installation werden **drei Container** verwendet:

- Umami stellt die Weboberfläche und die Analysefunktionen bereit.
- [PostgreSQL](https://www.ionos.de/digitalguide/server/knowhow/postgresql/) speichert die erfassten Daten.
- Caddy nimmt Webanfragen entgegen und stellt die verschlüsselte [HTTPS](https://www.ionos.de/digitalguide/hosting/hosting-technik/was-ist-https/)-Verbindung her.

[Docker Compose](https://www.ionos.de/digitalguide/server/konfiguration/docker-compose-tutorial/) beschreibt alle drei Container in einer gemeinsamen Konfigurationsdatei. Dadurch lässt sich die vollständige Installation später mit wenigen Befehlen starten, stoppen und aktualisieren.

Installieren Sie zunächst die benötigten Hilfsprogramme:

```bash
sudo apt update
sudo apt install -y ca-certificates curl
```

Legen Sie anschließend den Speicherort für den offiziellen Docker-Schlüssel an:

```bash
sudo install -m 0755 -d /etc/apt/keyrings
```

Laden Sie den Signaturschlüssel des offiziellen Docker-Paketarchivs herunter:

```bash
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg \
    -o /etc/apt/keyrings/docker.asc
```

Erlauben Sie dem Paketmanager, den Schlüssel zu lesen:

```bash
sudo chmod a+r /etc/apt/keyrings/docker.asc
```

Fügen Sie danach das offizielle Docker-Paketarchiv hinzu:

```bash
sudo tee /etc/apt/sources.list.d/docker.sources > /dev/null <<EOF
Types: deb
URIs: https://download.docker.com/linux/ubuntu
Suites: $(. /etc/os-release && echo "${UBUNTU_CODENAME:-$VERSION_CODENAME}")
Components: stable
Architectures: $(dpkg --print-architecture)
Signed-By: /etc/apt/keyrings/docker.asc
EOF
```

Aktualisieren Sie die Paketlisten erneut:

```bash
sudo apt update
```

Installieren Sie nun Docker Engine, die Kommandozeilenwerkzeuge und das Docker-Compose-Plug-in:

```bash
sudo apt install -y \
    docker-ce \
    docker-ce-cli \
    containerd.io \
    docker-buildx-plugin \
    docker-compose-plugin
```

Aktivieren und starten Sie Docker:

```bash
sudo systemctl enable --now docker
```

Überprüfen Sie die Installation mit einem Testcontainer:

```bash
sudo docker run hello-world
```

Erscheint eine Erfolgsmeldung, funktioniert Docker.

[![Bild: Hello-World Docker-Container](https://www.ionos.de/digitalguide/fileadmin/_processed_/0/9/csm_umami-docker-hello-world_72261fd859.webp "Hello-World Docker-Container")](https://www.ionos.de/digitalguide/fileadmin/DigitalGuide/Screenshots_2026/umami-docker-hello-world.jpg) Der erfolgreiche Start des Hello World Containers bestätigt die Installation von Docker. Kontrollieren Sie zusätzlich Docker Compose:

```bash
sudo docker compose version
```

[![Bild: Docker Compose Versionsanzeige](https://www.ionos.de/digitalguide/fileadmin/_processed_/e/e/csm_umami-docker-compose-version_49bbdd2b9e.webp "Docker Compose Versionsanzeige")](https://www.ionos.de/digitalguide/fileadmin/DigitalGuide/Screenshots_2026/umami-docker-compose-version.jpg) Nachdem Sie Docker Compose erfolgreich installiert haben, wird Ihnen die Versionsnummer im Terminal angezeigt. ## Schritt 5: Domain oder Subdomain mit dem Server verbinden

Um Umami später über eine leicht merkbare und verschlüsselte Adresse aufzurufen, sollten Sie eine Subdomain verwenden. Öffnen Sie die DNS-Verwaltung der betreffenden Domain. Erstellen Sie dort einen [A-Record](https://www.ionos.de/digitalguide/hosting/hosting-technik/a-record/) mit folgenden Angaben:

<table>
  <thead>
    <tr>
      <th><strong>Einstellung</strong></th>
      <th><strong>Beispiel</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Typ</td>
      <td>A</td>
    </tr>
    <tr>
      <td>Hostname</td>
      <td>analytics</td>
    </tr>
    <tr>
      <td>Ziel beziehungsweise Wert</td>
      <td>Öffentliche IPv4-Adresse des VPS</td>
    </tr>
    <tr>
      <td>TTL</td>
      <td>Standardwert oder beispielsweise 3600 Sekunden</td>
    </tr>
  </tbody>
</table>

Verfügt Ihr Server zusätzlich über eine korrekt konfigurierte öffentliche IPv6-Adresse, können Sie ergänzend einen AAAA-Record anlegen. Die Änderung kann abhängig vom bisherigen [TTL](https://www.ionos.de/digitalguide/server/konfiguration/dns-ttl-verstehen-und-anwenden/)-Wert **einige Zeit benötigen**. Prüfen Sie auf dem Server, ob die Domain bereits auf die richtige IP-Adresse verweist:

```bash
getent hosts analytics.example.de
```

Ersetzen Sie `analytics.example.de` durch Ihre tatsächliche Subdomain. Die Ausgabe sollte die IP-Adresse Ihres Servers enthalten.

Caddy kann ein öffentlich anerkanntes [TLS](https://www.ionos.de/digitalguide/server/sicherheit/tls-transport-layer-security/)-Zertifikat automatisch ausstellen, wenn der DNS-Eintrag auf den Server zeigt und die Ports 80 sowie 443 von außen erreichbar sind. Caddy erneuert das Zertifikat später ebenfalls automatisch und leitet unverschlüsselte HTTP-Aufrufe auf HTTPS um.

## Schritt 6: Verzeichnis und sichere Zugangsdaten für Umami erstellen

Legen Sie ein eigenes Verzeichnis für die Installation an:

```bash
sudo mkdir -p /opt/umami
sudo chown "$USER":"$USER" /opt/umami
cd /opt/umami
```

In diesem Verzeichnis werden die Docker-Konfiguration, die HTTPS-Konfiguration und die geheimen Zugangsdaten gespeichert. Installieren Sie das Werkzeug OpenSSL, falls es noch nicht vorhanden ist:

```bash
sudo apt install -y openssl
```

Erzeugen Sie anschließend ein zufälliges sicheres Datenbankpasswort, einen geheimen Anwendungsschlüssel sowie einen separaten Schlüssel für die optionale Zwei-Faktor-Authentifizierung:

```bash
DB_PASSWORD=$(openssl rand -hex 24)
UMAMI_SECRET=$(openssl rand -hex 32)
TWO_FACTOR_KEY=$(openssl rand -hex 32)
```

Speichern Sie diese drei Werte in einer Datei namens `.env`:

```bash
printf "POSTGRES_PASSWORD=%s\nAPP_SECRET=%s\nTWO_FACTOR_ENCRYPTION_KEY=%s\n" \
"$DB_PASSWORD" "$UMAMI_SECRET" "$TWO_FACTOR_KEY" > .env
```

Entfernen Sie die temporären Variablen danach aus der aktuellen Terminalsitzung:

```bash
unset DB_PASSWORD UMAMI_SECRET TWO_FACTOR_KEY
```

Beschränken Sie den Zugriff auf die Datei:

```bash
chmod 600 .env
```

Veröffentlichen Sie die `.env`-Datei niemals. Das `APP_SECRET` schützt unter anderem die von Umami verwendeten Anmeldetoken.

## Schritt 7: Docker-Compose-Datei für Umami erstellen

Erstellen Sie im Verzeichnis `/opt/umami` eine neue Datei:

```bash
nano compose.yml
```

Fügen Sie den folgenden Inhalt ein:

```yaml
services:
    db:
        image: postgres:15-alpine
        restart: unless-stopped
        environment:
            POSTGRES_DB: umami
            POSTGRES_USER: umami
            POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
        volumes:
            - umami_db_data:/var/lib/postgresql/data
        healthcheck:
            test:
                - CMD-SHELL
                - pg_isready -U $${POSTGRES_USER} -d $${POSTGRES_DB}
            interval: 5s
            timeout: 5s
            retries: 10
    umami:
        image: ghcr.io/umami-software/umami:latest
        restart: unless-stopped
        init: true
        environment:
            DATABASE_URL: postgresql://umami:${POSTGRES_PASSWORD}@db:5432/umami
            APP_SECRET: ${APP_SECRET}
            TWO_FACTOR_ENCRYPTION_KEY: ${TWO_FACTOR_ENCRYPTION_KEY}
        depends_on:
            db:
                condition: service_healthy
        expose:
            - "3000"
        healthcheck:
            test:
                - CMD-SHELL
                - curl -f http://localhost:3000/api/heartbeat || exit 1
            interval: 10s
            timeout: 5s
            retries: 10
    caddy:
        image: caddy:2-alpine
        restart: unless-stopped
        ports:
            - "80:80"
            - "443:443"
            - "443:443/udp"
        volumes:
            - ./Caddyfile:/etc/caddy/Caddyfile:ro
            - caddy_data:/data
            - caddy_config:/config
        depends_on:
            umami:
                condition: service_healthy
volumes:
    umami_db_data:
    caddy_data:
    caddy_config:
```

[![Bild: Ansicht der compose.yml-Datei](https://www.ionos.de/digitalguide/fileadmin/_processed_/5/8/csm_umami-docker-compose-yml_a2a1f4ad63.webp "Ansicht der compose.yml-Datei")](https://www.ionos.de/digitalguide/fileadmin/DigitalGuide/Screenshots_2026/umami-docker-compose-yml.jpg) Docker Compose konfigurieren Sie in der Datei compose.yml wie im Code gezeigt. Der Abschnitt `volumes` sorgt dafür, dass die Datenbank **nicht** zusammen mit dem Container gelöscht wird. Ein Container kann dadurch aktualisiert oder neu erstellt werden, ohne dass die gespeicherten Analysedaten verloren gehen.

Die Einträge unter `expose` machen Port 3000 **nur innerhalb des Docker-Netzes erreichbar**. Die Datenbank besitzt überhaupt keine öffentliche Portfreigabe. Entscheidend ist, dass der Umami-Dienst keinen Eintrag unter `ports` besitzt. Port 3000 kann daher nicht direkt über die öffentliche IP-Adresse des VPS aufgerufen werden. Von außen sind lediglich die für Caddy vorgesehenen Ports 80 und 443 erreichbar.

## Schritt 8: HTTPS-Proxy mit Caddy konfigurieren

Erstellen Sie die Caddy-Konfiguration:

```bash
nano Caddyfile
```

Fügen Sie folgenden Inhalt ein und ersetzen Sie die Beispieldomain:

```txt
analytics.example.de {
    encode zstd gzip
    reverse_proxy umami:3000
}
```

[![Bild: Ansicht des Caddyfiles](https://www.ionos.de/digitalguide/fileadmin/_processed_/e/1/csm_umami-docker-caddyfile_d00c8e336a.webp "Ansicht des Caddyfiles")](https://www.ionos.de/digitalguide/fileadmin/DigitalGuide/Screenshots_2026/umami-docker-caddyfile.jpg) Die Caddy-Konfiguration erstellen Sie in einem eigenen Caddyfile. Speichern und schließen Sie die Datei wieder. Der Eintrag `reverse_proxy umami:3000` bedeutet, dass Caddy eingehende Anfragen an den Umami-Container weiterleitet. Die Bezeichnung `umami` entspricht dem Servicenamen aus der Compose-Datei. Docker löst diesen Namen automatisch innerhalb des gemeinsamen Netzwerks auf.

Sobald Caddy mit einer öffentlichen Domain gestartet wird, versucht es automatisch, **ein gültiges TLS-Zertifikat auszustellen**. Dafür müssen der DNS-Eintrag stimmen und die Ports 80 sowie 443 erreichbar sein.

Kontrollieren Sie, ob alle benötigten Dateien vorhanden sind:

```bash
ls -la
```

Die Ausgabe sollte mindestens folgende Dateien enthalten:

- `.env`
- `Caddyfile`
- `compose.yml`

[![Bild: Terminalausgabe mit den erforderlichen Dateien](https://www.ionos.de/digitalguide/fileadmin/_processed_/d/1/csm_umami-docker-files_6bfa2a6427.webp "Terminalausgabe mit den erforderlichen Dateien")](https://www.ionos.de/digitalguide/fileadmin/DigitalGuide/Screenshots_2026/umami-docker-files.jpg) Die erforderlichen Dateien sollten nun in Ihrem Ordner sichtbar sein. ## Schritt 9: Umami-Container starten und Installation prüfen

Lassen Sie Docker Compose zunächst überprüfen, ob die Konfiguration gültig ist:

```bash
sudo docker compose config -q
```

Der Befehl prüft die Compose-Konfiguration auf Fehler, ohne die aufgelösten Konfigurationswerte im Terminal auszugeben. Laden Sie anschließend die benötigten Container-Images herunter:

```bash
sudo docker compose pull
```

Starten Sie die vollständige Installation im Hintergrund:

```bash
sudo docker compose up -d
```

Docker erstellt nun das gemeinsame Netzwerk, das PostgreSQL-Volume und die drei Container. Prüfen Sie anschließend den Status:

```bash
sudo docker compose ps
```

Nach der Startphase sollten der Datenbank- und der Umami-Container als `healthy` angezeigt werden. Der Caddy-Container sollte den Status `Up` besitzen.

Öffnen Sie danach Ihre Umami-Adresse im Browser:

```bash
https://analytics.example.de
```

Beim ersten Start kann die Ausstellung des Zertifikats **einen kurzen Moment dauern**. Danach sollte die Umami-Anmeldeseite über eine verschlüsselte HTTPS-Verbindung erscheinen.

[![Bild: Terminalausgabe Docker Compose](https://www.ionos.de/digitalguide/fileadmin/_processed_/9/9/csm_umami-docker-container_86aa711fc5.webp "Terminalausgabe Docker Compose")](https://www.ionos.de/digitalguide/fileadmin/DigitalGuide/Screenshots_2026/umami-docker-container.jpg) Sie sollten drei laufende Container in der Terminalausgabe sehen. ## Schritt 10: Zum ersten Mal bei Umami anmelden

Die offizielle Docker-Installation erstellt standardmäßig folgendes Administratorkonto:

- Benutzername: admin
- Passwort: umami

[![Bild: Umami: Standard-Login](https://www.ionos.de/digitalguide/fileadmin/_processed_/2/4/csm_umami-docker-login_d8f70c987d.webp "Umami: Standard-Login")](https://www.ionos.de/digitalguide/fileadmin/DigitalGuide/Screenshots_2026/umami-docker-login.jpg) Der Login bei Umami funktioniert zunächst mit den Standard-Zugangsdaten. Diese Standardzugangsdaten sind öffentlich bekannt und müssen daher **unmittelbar geändert werden**. Melden Sie sich an und öffnen Sie anschließend über das Benutzermenü die Einstellungen beziehungsweise das Profil. Ändern Sie dort das Kennwort des Administratorkontos und verwenden Sie dazu ein langes, sicheres Passwort, das Sie nicht für andere Dienste einsetzen.

[![Bild: Umami: Passwort ändern](https://www.ionos.de/digitalguide/fileadmin/_processed_/f/d/csm_umami-docker-passwort_a04919a181.webp "Umami: Passwort ändern")](https://www.ionos.de/digitalguide/fileadmin/DigitalGuide/Screenshots_2026/umami-docker-passwort.jpg) Ändern Sie in den Umami-Einstellungen Ihr Passwort. Optional können Sie zusätzlich die Zwei-Faktor-Authentifizierung aktivieren. Öffnen Sie dazu die Einstellungen und wechseln Sie zu „Security“. Dort lässt sich 2FA mit einer Authenticator-App einrichten. Bewahren Sie die anschließend erzeugten Backup-Codes sicher auf.

Kontrollieren Sie außerdem, ob die in Umami angezeigte Zeitzone zu Ihrem Standort passt. Eine korrekte Zeitzone ist wichtig, damit Tageswerte und zeitliche Auswertungen richtig dargestellt werden.

## Schritt 11: Erste Website in Umami hinzufügen

Öffnen Sie in Umami den Bereich **Websites** und wählen Sie die Funktion zum Hinzufügen einer neuen Website. Tragen Sie einen verständlichen Namen und die Domain der zu analysierenden Website ein. Geben Sie die Domain **ohne Pfad** ein. Nutzen Sie die Schreibweise, unter der die Website tatsächlich erreichbar ist.

[![Bild: Neu angelegte Website in Umami](https://www.ionos.de/digitalguide/fileadmin/_processed_/b/d/csm_umami-docker-website_e20a254d01.webp "Neu angelegte Website in Umami")](https://www.ionos.de/digitalguide/fileadmin/DigitalGuide/Screenshots_2026/umami-docker-website.jpg) Fügen Sie Ihre Website in Umami einfach im Menü hinzu. Speichern Sie die Website. Öffnen Sie danach die Bearbeitungsansicht und suchen Sie den Abschnitt **Tracking code**. Umami erzeugt dort automatisch einen individuellen Code mit einer Website-ID, den Sie einfach kopieren können.

[![Bild: Tracking Code im Umami](https://www.ionos.de/digitalguide/fileadmin/_processed_/8/7/csm_umami-docker-tracking-code_210aa2d6ab.webp "Tracking Code im Umami")](https://www.ionos.de/digitalguide/fileadmin/DigitalGuide/Screenshots_2026/umami-docker-tracking-code.jpg) Den Tracking Code für Ihre Website können Sie direkt aus Umami kopieren. Seit Umami 3.1 lassen sich zusätzlich [Core Web Vitals](https://www.ionos.de/digitalguide/online-marketing/suchmaschinenmarketing/google-core-web-vitals/) erfassen. Dafür ergänzen Sie im Code `data-performance="true"`:

```html
<script
    defer
    src="https://analytics.example.de/script.js"
    data-website-id="IHRE-WEBSITE-ID"
    data-domains="example.de,www.example.de"
    data-performance="true"
></script>
```

Damit kann Umami unter anderem LCP, INP, CLS, FCP und TTFB auswerten.

Hinweis Bei WordPress können Sie den Code über ein geeignetes Header-Plug-in oder über die Theme-Konfiguration einfügen. Bei statischen Websites gehört er direkt in den &lt;head&gt;-Abschnitt der HTML-Datei. In Frameworks mit clientseitigem Routing wie React, Vue oder Angular kann der Tracking-Code direkt eingebunden werden. Bei Next.js empfiehlt sich die Einbindung über die integrierte `next/script`-Komponente, damit das Script korrekt in die Anwendung integriert wird.

Damit ist die Umami-Installation vollständig eingerichtet. Die Anwendung läuft in getrennten Docker-Containern, die PostgreSQL-Datenbank ist nicht öffentlich erreichbar und Caddy stellt automatisch eine verschlüsselte HTTPS-Verbindung bereit.

## Schritt 12: Backup und Wiederherstellung

Ein Docker-Volume ersetzt kein Backup. Sichern Sie die PostgreSQL-Datenbank daher regelmäßig und bewahren Sie die Sicherung außerhalb des VPS auf:

```bash
sudo docker compose exec -T db \
    pg_dump -U umami -d umami -Fc > umami-backup.dump
```

Dieser Befehl sichert nur die Datenbank. Bewahren Sie zusätzlich `compose.yml`, `Caddyfile` und die geheimen Werte aus `.env` sicher auf. Diese Dateien werden für eine vollständige Wiederherstellung der Installation benötigt.

Prüfen Sie die Wiederherstellung zunächst in einer Testinstallation. Wenn Sie eine bestehende Installation wiederherstellen, halten Sie Umami vorher an:

```bash
sudo docker compose stop umami
```

Der folgende Befehl löscht die im Backup enthaltenen Datenbankobjekte in der Zieldatenbank und stellt sie aus der Sicherung wieder her. Daten, die seit dem Backup hinzugekommen sind, gehen dabei verloren:

```bash
sudo docker compose exec -T db \
    pg_restore -U umami -d umami --clean --if-exists --no-owner \
    < umami-backup.dump
```

Starten Sie Umami anschließend erneut:

```bash
sudo docker compose start umami
```

Die Sicherungsdatei `umami-backup.dump` liegt bei diesen Befehlen im aktuellen Verzeichnis. Denken Sie daher daran, die genannten Befehle im Installationsverzeichnis `/opt/umami` auszuführen.


This is a markdown version of: [https://www.ionos.de/digitalguide/server/konfiguration/umami-docker/](https://www.ionos.de/digitalguide/server/konfiguration/umami-docker/) for AI/LLM consumption.