Docker Compose

Kör en komplett, kostnadsfri Status200-instans på en enda Linux-server med Docker Compose. Den här sidan tar dig från en ny server till en körande instans och tar sedan upp HTTPS, härdning för produktion, säkerhetskopior, uppdateringar och borttagning. Vill du i stället arbeta med Status200s egen kod, se Lokal utveckling.

Så fungerar det#

Docker Compose kör varje del av Status200 som en container på din server. All trafik kommer in genom containern ingress, som skickar den vidare till app. Appen sparar sina data i PostgreSQL, ClickHouse och Valkey. En medföljande prob kör dina monitorers kontroller och rapporterar tillbaka genom ingressen.

För produktion i stor skala, eller när du behöver hög tillgänglighet, använder du i stället Helm-charten på Kubernetes: Docker Compose kör en kopia av varje tjänst på en enda server.

Krav#

Välj serverns storlek efter vad du ska köra på den. Det är telemetrin (loggar, mätvärden, traces) som avgör minne och disk; se Dimensionering och kapacitetsplanering när du känner till dina volymer.

Minimum för ett homelab passar för personligt och experimentellt bruk — en del kör Status200 på en Raspberry Pi.

Du behöver också:

• Docker med tillägget Docker Compose v2 (kommandot docker compose).
• Git, för att hämta Status200.
• Node.js och npm, som kör skripten npm start och npm run update som omsluter Docker Compose.
• Portarna 80 och 443 lediga på servern. Tabellen nedan listar varje port som Status200 använder på värden.

Det finns också en videogenomgång av installationen.

Installera Status200#

1. Klona release-grenen#

   Grenen release innehåller filerna för den senaste releasen.

   Bash

   git clone --depth 1 --single-branch --branch release https://git.wilix.dev/status200/status200.git
   cd oneuptime

2. Skapa config.env#

   Alla Status200s inställningar finns i config.env. Utgå från exemplet:

   Bash

   cp config.example.env config.env

3. Ange värdnamnet#

   Öppna config.env och sätt HOST till det domännamn eller den IP-adress som folk ska använda för att nå Status200, utan http://. Behåll localhost bara för att prova Status200 på din egen dator.

   config.envINI

   HOST=status200.example.com

4. Generera slumpmässiga hemligheter#

   Exempelfilen innehåller platshållarhemligheter som är offentliga på GitHub. Ersätt var och en med ett eget slumpmässigt värde:

   Bash

   while grep -q "please-change-this-to-random-value" config.env; do
     sed -i "0,/please-change-this-to-random-value/{s/please-change-this-to-random-value/$(openssl rand -hex 32)/}" config.env
   done
   grep -c "please-change-this" config.env

   Det sista kommandot skriver ut 0: Ingen platshållare är kvar. Loopen använder GNU sed, som alla Linux-servrar har. Det här är inställningarna den fyller i:

   Inställning	Vad den skyddar
   ONEUPTIME_SECRET	Anrop mellan Status200s egna tjänster.
   ENCRYPTION_SECRET	Hemligheterna som Status200 lagrar, som integrationstokens och SMTP-lösenord, och de inloggningstokens den utfärdar.
   DATABASE_PASSWORD, CLICKHOUSE_PASSWORD, VALKEY_PASSWORD	De tre datalagren.
   REGISTER_PROBE_KEY	Registrering av prober hos din instans.
   GLOBAL_PROBE_1_KEY, GLOBAL_PROBE_2_KEY	De globala prober som Docker Compose kan köra (probe-1 körs som standard).
   STATUS200_RUNNER_KEY	Den medföljande Runnern.
   GLOBAL_RUNNER_KEY	Den medföljande globala Runnern, som kör alla projekts JavaScript-steg.

   Viktigt

   Ange hemligheterna före första starten och behåll dem sedan. PostgreSQL tar bara sitt lösenord när den skapar sin databas, och om du ändrar ENCRYPTION_SECRET senare blir varje värde som krypterats med det gamla oläsligt. Är DATABASE_PASSWORD fortfarande platshållaren vid första starten ger npm start den ett slumpmässigt värde innan PostgreSQL skapar sin databas.

5. Starta Status200#

   npmDocker CLI

   npm

   Bash

   npm start

   Docker CLI

   Bash

   (export $(grep -v '^#' config.env | xargs) && docker compose up --remove-orphans -d)

   Första starten tar flera minuter: Docker laddar ned imagerna och Status200 skapar sina databaser. npm start väntar tills varje del svarar och avslutas med Status200 is up!

6. Skapa det första kontot#

   Öppna http:// följt av din HOST (till exempel http://localhost) och registrera dig. Det första kontot på en ny instans blir dess huvudadministratör, som kan öppna Admin Dashboard på /admin.

   Alla som kan nå sidan kan registrera sig efter dig. För att förhindra det öppnar du Admin Dashboard, går till Inställningar > Autentisering och stänger av Tillåt registrering. Personer som du bjuder in till ett projekt kan fortfarande skapa sina konton.

Konfigurera HTTPS#

Status200 levererar vanlig HTTP tills du väljer ett av två sätt att lägga till HTTPS:

Om du lägger statussidor eller dashboards på egna domäner är det enklast att låta Status200 hantera TLS: Ingressen beställer och levererar själv certifikaten för de domänerna.

Med HTTP_PROTOCOL=https bygger Status200 HTTPS-länkar, håller inloggningscookies på HTTPS och ber webbläsare att bara nå din HOST över HTTPS. En webbläsare håller sig till det i ett år, på alla portar för det namnet, så om HOST någon gång måste svara över vanlig HTTP igen sätter du HSTS_MAX_AGE_SECONDS=0 i config.env en tid innan: Webbläsare glömmer regeln vid sitt nästa besök.

Låt Status200 hämta ett certifikat#

1. Peka din domän mot servern#

   Skapa en DNS-post A (eller AAAA för IPv6) för din domän, med serverns offentliga IP-adress som värde. Med en AAAA-post slår du också på IPv6 för Status200: se Besökarnas adresser.

2. Slå på hämtning av certifikat#

   Ange de här värdena i config.env:

   config.envINI

   HOST=status200.example.com
   PROVISION_SSL=true
   HTTP_PROTOCOL=https

   HOST måste vara ett domännamn: Status200 kan inte få ett certifikat för en IP-adress eller för localhost.

3. Starta om med de nya inställningarna#

   Bash

   npm start

4. Öppna din instans över HTTPS#

   Öppna https://status200.example.com. Status200 beställer certifikatet när den startar, kontrollerar det sedan varje timme och förnyar det när det är mindre än 30 dagar kvar. Tills det första certifikatet kommer, oftast inom några minuter, levererar ingressen ett tillfälligt självsignerat certifikat och webbläsaren varnar dig.

Använd din egen omvända proxy#

De här stegen kör proxyn på samma server som Status200. Om din proxy körs på en annan maskin hoppar du över det första steget, pekar proxyn mot port 80 på den här servern och låter med molnleverantörens brandvägg bara proxyn nå portarna 80 och 443: en besökare som når Status200 förbi proxyn kan välja den adress som Status200 räknar besökaren efter.

1. Flytta ingressen från portarna 80 och 443#

   Proxyn behöver portarna 80 och 443, så flytta ingressen till andra portar, publicerade bara på serverns loopback-adress 127.0.0.1, så att besökare bara når Status200 genom din proxy. Proben och Runnern använder värdens nätverk och når Status200 via http://localhost, så de flyttar med:

   config.envINI

   ONEUPTIME_HTTP_PORT=127.0.0.1:8080
   STATUS_PAGE_HTTPS_PORT=127.0.0.1:8443
   GLOBAL_PROBE_1_STATUS200_URL=http://localhost:8080
   ONEUPTIME_RUNNER_STATUS200_URL=http://localhost:8080

2. Berätta för Status200 att den står bakom en proxy#

   config.envINI

   HOST=status200.example.com
   HTTP_PROTOCOL=https
   PROVISION_SSL=false
   TRUSTED_PROXY_HOPS=2

   HTTP_PROTOCOL=https gör att länkarna som Status200 bygger använder HTTPS. TRUSTED_PROXY_HOPS=2 räknar din proxy och Status200s ingress, så att Status200 läser besökarens riktiga adress för IP-tillåtelselistor och hastighetsbegränsningar. Lägg till en för varje ytterligare proxy som lägger till i X-Forwarded-For, som ett CDN eller en lastbalanserare.

3. Starta om Status200 på de nya portarna#

   Bash

   (export $(grep -v '^#' config.env | xargs) && docker compose up --remove-orphans -d)
   bash Tests/Scripts/status-check.sh localhost:8080

   npm start kontrollerar http://localhost på port 80, där din proxy kommer att ligga, så kontrollera den nya porten själv. Skriptet avslutas med Status200 is up!

4. Konfigurera proxyn#

   CaddyNginx

   Caddy

   Caddyfile

   status200.example.com {
       reverse_proxy localhost:8080
   }

   Caddy hämtar och förnyar certifikatet själv, omdirigerar HTTP till HTTPS och släpper igenom WebSocket-anslutningar. Läs in Caddy igen när du har ändrat filen, till exempel med sudo systemctl reload caddy.

   Nginx

   /etc/nginx/conf.d/status200.confNginx

   map $http_upgrade $status200_connection_upgrade {
       default upgrade;
       ""      close;
   }
   
   server {
       listen 80;
       server_name status200.example.com;
       return 301 https://$host$request_uri;
   }
   
   server {
       listen 443 ssl;
       server_name status200.example.com;
   
       ssl_certificate     /etc/letsencrypt/live/status200.example.com/fullchain.pem;
       ssl_certificate_key /etc/letsencrypt/live/status200.example.com/privkey.pem;
   
       # The limits Status200's own ingress uses.
       client_max_body_size 50M;
       proxy_read_timeout 300s;
       proxy_send_timeout 300s;
   
       proxy_http_version 1.1;
       proxy_set_header Host $host;
       proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
       proxy_set_header X-Forwarded-Proto $scheme;
       proxy_set_header Upgrade $http_upgrade;
       proxy_set_header Connection $status200_connection_upgrade;
   
       location / {
           proxy_pass http://127.0.0.1:8080;
       }
   
       # MCP clients keep a stream open.
       location /mcp {
           proxy_pass http://127.0.0.1:8080;
           proxy_buffering off;
           proxy_read_timeout 86400s;
           proxy_send_timeout 86400s;
       }
   }

   Certifikatsökvägarna är där Certbot lägger ett certifikat från Let's Encrypt; använd sökvägarna till ditt eget certifikat om det kommer från något annat håll. Kontrollera filen och läs in Nginx igen med sudo nginx -t && sudo systemctl reload nginx.

   Båda skickar X-Forwarded-Proto, som talar om för Status200 att en besökare kom över HTTPS. Alla andra proxyer måste också skicka den, annars hålls inte inloggningscookies för statussidor och dashboards på dina egna domäner på HTTPS.

5. Öppna din instans genom proxyn#

   Öppna https://status200.example.com. Du bör se Status200s inloggningssida, levererad med din proxys certifikat.

Besökarnas adresser#

Status200 räknar varje besökare efter adressen som besökaren ansluter från: inloggningsgränserna, de andra gränserna per adress och IP-tillåtelselistorna för statussidor och dashboards läser den alla. Två uppsättningar behöver en inställning för att den adressen ska vara besökarens egen:

Utan IPv6 på Status200s nätverk lämnar Docker vidare varje besökare som kommer över IPv6 till Status200 från en egen adress, och Status200 räknar dem alla som en besökare: en persons misslyckade inloggningar kan låsa ute de andra. Att slå på IPv6 kräver Docker Engine 27 eller senare (docker version visar din).

1. Slå på IPv6#

   Skapa docker-compose.override.yml bredvid docker-compose.yml, eller lägg till detta i den du har; npm start och npm run update läser den:

   docker-compose.override.ymlYAML

   networks:
     oneuptime:
       enable_ipv6: true

2. Starta om Status200#

   Bash

   npm stop
   npm start

   Status200 stannar och startar igen med IPv6 på sitt nätverk. Dina data behålls. Docker kan inte ta bort ett nätverk som en egen container fortfarande är ansluten till, till exempel en omvänd proxy: koppla först bort den från Status200s nätverk och anslut den igen efteråt. Stannar npm start med has active endpoints kopplar du bort den och kör npm stop och npm start igen.

3. Kontrollera nätverket#

   Bash

   docker network ls --quiet --filter name=_oneuptime | xargs docker network inspect | grep EnableIPv6

   Det skriver ut "EnableIPv6": true,.

När flera personer loggar in från samma privata nätverksadress säger sidan Status200-hälsa i Admin Dashboard det, med inställningen som ändrar det.

Checklista för produktion#

Docker Compose kör en kopia av varje tjänst på en enda server, vilket passar små team och homelabs. Gå igenom den här listan innan du förlitar dig på det.

Byt databasens lösenord#

PostgreSQL behåller lösenordet den skapades med, så om du bara ändrar DATABASE_PASSWORD i config.env stänger du ute Status200 från dess databas. För att ge en installation som startade med platshållaren ett eget lösenord ändrar du det i PostgreSQL och i config.env samtidigt och startar sedan Status200 igen:

NEW_PASSWORD=$(openssl rand -hex 32) &&
  (export $(grep -v '^#' config.env | xargs) && docker compose exec -T postgres psql -U "$DATABASE_USERNAME" -d "$DATABASE_NAME" -c "ALTER USER \"$DATABASE_USERNAME\" PASSWORD '$NEW_PASSWORD'") &&
  sed -i "s/^DATABASE_PASSWORD=.*/DATABASE_PASSWORD=$NEW_PASSWORD/" config.env
npm start

Om du har angett DATABASE_BACKUP_PASSWORD och DATABASE_RESTORE_PASSWORD, ge dem också det nya värdet.

Säkerhetskopiera och återställ#

PostgreSQL innehåller allt du konfigurerar: monitorer, incidenter, statussidor, användare. npm run backup dumpar det till en fil i mappen Backups.

1. Ge säkerhetskopieringsskriptet databaslösenordet#

   Sätt DATABASE_BACKUP_PASSWORD i config.env till värdet av DATABASE_PASSWORD. Skriptet läser config.env som ren text, så det medföljande ${DATABASE_PASSWORD} fylls aldrig i.

2. Kör säkerhetskopieringen#

   Bash

   npm run backup

   Det frågar efter ditt sudo-lösenord och skriver Backups/db-<day of the month>.backup, så att dagliga säkerhetskopior ersätter dem från en månad tidigare. Kör det minst en gång om dagen.

3. Kopiera säkerhetskopiorna från servern#

   En säkerhetskopia på samma disk som databasen överlever inte att den disken går förlorad.

Bara servern själv når PostgreSQL: den svarar på port 5400 på 127.0.0.1. För att säkerhetskopiera den från en annan maskin öppnar du en SSH-tunnel från den maskinen och ansluter sedan till dess egen port 5400:

ssh -N -L 5400:127.0.0.1:5400 you@status200.example.com

services:
  postgres:
    ports:
      - "10.0.0.5:5401:5432"

ClickHouse håller din telemetri i Docker-volymen status200_clickhouse, och inget skript säkerhetskopierar den. Om du behöver behålla den telemetrin säkerhetskopierar du volymen med ett ClickHouse-verktyg som clickhouse-backup, eller kopierar den medan Status200 är stoppat.

För att återställa PostgreSQL anger du värdena DATABASE_RESTORE_* i config.env: DATABASE_RESTORE_PASSWORD till värdet av DATABASE_PASSWORD, som för säkerhetskopior, och DATABASE_RESTORE_FILENAME till den säkerhetskopia som ska återställas, till exempel db-31.backup. Kör sedan bash restore.sh. Databasen som det återställer till måste redan finnas; i en körande installation gör den det.

Uppdatera Status200#

Säkerhetskopiera först och kör sedan:

git checkout release
git pull
npm run update

npm run update frågar efter ditt sudo-lösenord, lägger till nya inställningar från config.example.env i din config.env (dina egna värden finns kvar), hämtar de nya imagerna och startar om Status200. Precis som npm start avslutas det med Status200 is up!

Att byta till en ny huvudversion (från 13 till 14, till exempel) kan kräva mer: läs Uppgradera Status200 innan du börjar.

APP_TAG=release i config.env hämtar alltid den senaste releasen av Community Edition. För att stanna på en version sätter du APP_TAG till dess nummer, till exempel 14.0.22. För Enterprise Edition är taggarna enterprise-release och enterprise-14.0.22.

Avinstallera Status200#

Stoppa Status200 och ta bort dess containrar och nätverk:

npm run down

Dina data finns kvar i volymerna status200_postgres och status200_clickhouse, och mappen oneuptime behåller config.env och dina säkerhetskopior. För att ta bort även data:

(export $(grep -v '^#' config.env | xargs) && docker compose down --volumes --remove-orphans)

Ta sedan bort mappen oneuptime.

Felsökning#

sudo usermod -aG docker $USER

npm run ps
npm run logs

(export $(grep -v '^#' config.env | xargs) && docker compose logs app) | grep -A 5 CoreSSL

Nästa steg#