Hosta Umami på en Managed VPS: din webbanalys på din egen server

Det Umami gör

Umami är en plattform med öppen källkod för webb- och produktanalys. Dess dokumentation beskriver ett verktyg som samlar trafik, kampanjer, besökarnas beteende, konverteringar, återkommande besökare och intäkter, från det första besöket till de resultat som betyder något för din verksamhet. Det är skrivet i TypeScript på Next.js, och dess Docker-avbild körs under ett konto utan särskilda rättigheter.

• Förvärvet: sidvisningar, besökare, hänvisande sidor, länder, enheter och aktivitet i realtid, med UTM-kampanjer, korta länkar och spårningspixlar.
• Beteendet: egna händelser, besöksvägar, uppspelning av sessioner, värmekartor, segment, kohorter och återkommande besökare.
• Konverteringen: mål, trattar, attribution och uppföljning av intäkter per sida och per kampanj.
• Delningen: tavlor, team, en publik delningsadress, ett API och en MCP-server med enbart läsåtkomst för din AI-assistent.
• Moderna webbplatser: FAQ:n anger att Umami följer sidnavigeringen i enkelsidesapplikationer av sig själv, utan någon extra inställning.

En instans följer flera webbplatser: var och en får sitt eget ID och sitt eget spårningsskript, och dina kolleger hittar rätt genom konton och team.

Det som MIT-licensen tillåter

Umami publiceras under MIT-licensen, i namnet Umami Software, Inc. Den ger, kostnadsfritt, rätt att använda, kopiera, ändra, slå samman, publicera, distribuera, underlicensiera och sälja kopior av programvaran. Du kan alltså köra den för ditt företag och för dina kunders webbplatser, utan att köpa någon licens.

Dess enda villkor: upphovsrättsmeddelandet och tillståndsmeddelandet följer med alla kopior eller väsentliga delar av programvaran. Som varje MIT-licens tillhandahåller den programvaran ”i befintligt skick”, utan garanti.

Kakor och personuppgifter: det projektet säger

Dokumentationen presenterar Umami som en analys utan kakor, utan spårning mellan webbplatser och utan automatisk insamling av personuppgifter. Självhostad håller den din statistik på din egen server: du bestämmer var den finns och hur länge den sparas.

Tre inställningar i spårningsskriptet går längre, om du vill: data-exclude-search tar bort sökparametrarna från de registrerade adresserna, data-exclude-hash tar bort ankaret, och data-do-not-track stänger av spårningen för webbläsare som anger inställningen Do Not Track. Dokumentationen påpekar att den sista inställningen inte på egen hand är en komplett lösning för hantering av samtycke.

Om du identifierar inloggade besökare med data-distinct-id eller umami.identify() rekommenderar dokumentationen ett internt användar-ID eller en hash i stället för en e-postadress: värdet går att läsa i sidans HTML.

Installationen med Docker Compose och PostgreSQL

Förrådet levererar en docker-compose.yml som startar Umami och dess PostgreSQL-databas. Sedan version 3 är PostgreSQL den enda databas som stöds, minst version 12.14, och dokumentationen rekommenderar att ställa in den på tidszonen UTC. På en server där Docker är installerat skapar du en mapp och börjar med dess hemligheter, slumpmässigt genererade med openssl, som dokumentationen föreslår:

cat > .env <<EOF
POSTGRES_PASSWORD=$(openssl rand -hex 24)
APP_SECRET=$(openssl rand -hex 32)
TWO_FACTOR_ENCRYPTION_KEY=$(openssl rand -hex 32)
EOF
chmod 600 .env

Lägg sedan denna compose.yaml bredvid. Den följer projektets fil i version 3.4.1, med två ändringar: hemligheterna kommer från filen .env, och porten publiceras bara på 127.0.0.1.

services:
  umami:
    image: ghcr.io/umami-software/umami:latest
    ports:
      - "127.0.0.1:3000:3000"
    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
    init: true
    restart: always
    healthcheck:
      test: ["CMD-SHELL", "curl http://localhost:3000/api/heartbeat"]
      interval: 5s
      timeout: 5s
      retries: 5
  db:
    image: postgres:15-alpine
    environment:
      POSTGRES_DB: umami
      POSTGRES_USER: umami
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
    volumes:
      - umami-db-data:/var/lib/postgresql/data
    restart: always
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U $${POSTGRES_USER} -d $${POSTGRES_DB}"]
      interval: 5s
      timeout: 5s
      retries: 5
volumes:
  umami-db-data:

docker compose up -d
curl -s http://127.0.0.1:3000/api/heartbeat

• DATABASE_URL: den enda obligatoriska variabeln, anslutningssträngen till databasen. Det hexadecimala lösenordet skrivs in som det är; ett lösenord med specialtecken skulle kräva procentkodning.
• APP_SECRET: en slumpmässig sträng som skyddar autentiseringstoken, unik för varje installation. I koden för version 3.4.1 ingår den också i beräkningen av sessions-ID: håll den oförändrad.
• TWO_FACTOR_ENCRYPTION_KEY: 64 hexadecimala tecken som krypterar hemligheterna för tvåfaktorsautentisering. Utan den kan ingen aktivera tvåfaktorsautentisering.
• Vid start kontrollerar containern anslutningen till databasen och dess version, och tillämpar sedan själv schemamigreringarna. Vid den första körningen skapar den tabellerna och kontot admin. Sonden /api/heartbeat svarar {"ok":true} när Umami är redo.
• Taggen latest följer den senast publicerade versionen. Projektets register publicerar också versionstaggar, som 3.4.1, för att låsa den du kör.

Installationsdokumentationen anger ingen siffra för minne eller processor. Storleken beror på trafiken till de följda webbplatserna och på volymen av data du sparar. På en Managed VPS beskriver du hur du tänker använda den, så rekommenderar vi lämplig storlek.

HTTPS: den omvända proxyn

Umami lyssnar med HTTP på port 3000, och dokumentationen föreslår att servera den bakom din webbserver, via en omvänd proxy. Ge den en egen underdomän, som stats.example.com, som pekar mot servern med A- och AAAA-poster. Att servera Umami under en sökväg går via BASE_PATH, en variabel som läses när applikationen byggs: med den publicerade avbilden är underdomänen den direkta vägen.

Proxyn måste också skicka vidare besökarens adress. Umami läser den i huvudena den tar emot, bland andra X-Real-IP och X-Forwarded-For: den använder den för att skilja besökarna åt och avgöra deras land. Om din proxy använder ett annat huvud anger CLIENT_IP_HEADER dess namn.

Med Caddy

Caddy hämtar certifikatet från Let’s Encrypt och aktiverar HTTPS på egen hand. Dess direktiv reverse_proxy sätter X-Forwarded-For som standard: de här tre raderna räcker.

stats.example.com {
  reverse_proxy 127.0.0.1:3000
}

Med Nginx och Certbot

Det här blocket följer Nginx-exemplet i Umamis dokumentation, och lyssnar på port 80 så att Certbot kan installera HTTPS:

server {
  listen 80;
  listen [::]:80;
  server_name stats.example.com;

  location / {
    proxy_pass http://127.0.0.1:3000;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header Host $host;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
  }
}

Certbot installerar sedan certifikatet och sköter förnyelsen:

sudo certbot --nginx

Den första inloggningen: administratörskontot och tvåfaktorsautentisering

När Umami skapar sin databas öppnar den ett administratörskonto: användarnamnet admin, lösenordet umami. Dokumentationen ber dig att byta lösenordet vid din första inloggning.

1. Öppna din HTTPS-adress och logga in med admin och umami.
2. Öppna Settings från profilknappen i sidofältet, sedan Profile, och klicka på Change password.
3. På fliken Security aktiverar du tvåfaktorsautentisering: skanna QR-koden med din autentiseringsapp, ange den sexsiffriga koden och förvara sedan de tio reservkoderna på ett säkert ställe, eftersom de bara visas en gång.

• Kräva tvåfaktorsautentisering: en administratör kan kräva den för hela instansen, för en användare eller för ett team, från administrationssidorna.
• Försöken: fem felaktiga koder spärrar nya försök i 15 minuter.
• Ditt teams konton: administrationssidorna hanterar användare, webbplatser och team för hela instansen.

Förvara TWO_FACTOR_ENCRYPTION_KEY tillsammans med dina säkerhetskopior: dokumentationen varnar för att om nyckeln går förlorad eller ändras blir de lagrade hemligheterna oläsliga, och varje användare måste då registrera sin tvåfaktorsautentisering på nytt.

Lägga till en webbplats och dess spårningsskript

1. I Websites klickar du på Add website.
2. Ge webbplatsen ett namn och sedan dess domän: Umami använder den för att filtrera bort dina egna sidor ur listan över hänvisande sidor.
3. Öppna Edit på den webbplatsen och kopiera koden i avsnittet Tracking code.
4. Klistra in den i <head> på dina sidor och besök sedan din webbplats: data visas i instrumentpanelen direkt.

<script defer src="https://stats.example.com/script.js" data-website-id="your-website-id"></script>

• Syns ingenting? Dokumentationen föreslår fliken nätverk i webbläsarens utvecklarverktyg: förfrågningarna till din instans ska gå iväg utan fel.
• Next.js: lägg till koden med komponenten next/script i stället för en vanlig tagg <script>.
• data-domains begränsar spårningen till dina produktionsdomäner, vilket håller dina testmiljöer utanför statistiken.
• Dina egna besök undantas webbplats för webbplats, från webbläsarens konsol, med localStorage.setItem('umami.disabled', 1).

Ett eget namn på skriptet

Vissa annonsblockerare blockerar allt som liknar statistik. Självhostad serveras Umami redan från din egen domän, och två variabler går längre: TRACKER_SCRIPT_NAME ger skriptet ett annat namn än script.js, och COLLECT_API_ENDPOINT byter namn på insamlingens slutpunkt, i stället för /api/send. Skriptet anropar då den nya slutpunkten av sig självt; bara källan i spårningskoden ändras på dina sidor.

TRACKER_SCRIPT_NAME: "stats.js"
COLLECT_API_ENDPOINT: "/api/collect"

Användbara inställningar

Dessa miljövariabler läggs i tjänsten umami i compose.yaml, och sedan skapar docker compose up -d om containern så att de börjar gälla:

Säkerhetskopiorna

Allt som Umami sparar finns i dess PostgreSQL-databas: konton, webbplatser, team och statistik. Exportera den varje dag och strax före varje uppdatering: självhostade sparas dessa data utan tidsgräns. Bredvid databasen innehåller filen .env de hemligheter som gör den användbar:

Exportera databasen medan den körs

pg_dump gör en konsekvent export medan databasen används. Det anpassade formatet, -Fc, är komprimerat och återställs med pg_restore:

docker compose exec -T db pg_dump -U umami -d umami -Fc > umami-$(date +%F).dump

Schemalägg kommandot på servern minst en gång om dagen, gallra bland exporterna, som hopar sig, och skicka en kopia till annat håll. Lagda på serverns disk ingår de här exporterna också i dess nattliga säkerhetskopior.

Återställa

1. Stoppa Umami och låt databasen vara igång: docker compose stop umami.
2. Återställ exporten i databasen och ersätt de befintliga objekten.
3. Starta Umami igen och kontrollera sedan att dina webbplatser och deras statistik finns kvar.

docker compose stop umami
docker compose exec -T db pg_restore -U umami -d umami --clean --if-exists < umami-YYYY-MM-DD.dump
docker compose start umami

Upprepa övningen då och då, på en kopia: så kontrollerar du att en säkerhetskopia fungerar.

Uppdateringarna

Dokumentationen anger två kommandon, från mappen med compose.yaml. Databasen ligger kvar i sin volym:

docker compose pull
docker compose up --force-recreate -d

Vid omstarten tillämpar containern själv schemamigreringarna. Version 3.4.0, från den 17 september 2026, innehöll två, för anteckningar och API-nycklar; version 3.4.1, från den 23 oktober 2026, innehåller ingen. Efter en större uppgradering, som övergången till version 3, föreslår dokumentationen att köra ANALYZE i PostgreSQL så att instrumentpanelerna får tillbaka sin hastighet:

docker compose exec db psql -U umami -d umami -c "ANALYZE;"

• Versionsanteckningarna anger vad varje version ändrar. Version 3.4.1 är en brådskande säkerhetsrättelse som uppdaterar Next.js och basavbilden för Node.js; dess anteckningar ber varje självhostad instans att uppgradera genom att hämta avbilden på nytt.
• Från en version 2 på MySQL: version 3 stöder inte längre MySQL. Projektets migreringsguide flyttar data till PostgreSQL i version 2.19.0, före uppgraderingen till version 3.
• PostgreSQL självt: behåll filens tagg postgres:15-alpine. Att byta till en ny huvudversion av PostgreSQL kräver en export och en återställning, eller pg_upgrade.

Vem gör vad på en Managed VPS

Att självhosta innebär att sköta servern utöver applikationen. På en Managed VPS tar våra team hand om servern och följer din instans proaktivt; Umami förblir din programvara, med sina inställningar och sina data.

Om du föredrar att våra team ingriper i själva applikationen faktureras den tjänsten per timme eller som fast pris, med en offert som lämnas före ingreppet.