Docker Compose

Kør en komplet, gratis Status200-instans på én Linux-server med Docker Compose. Denne side fører dig fra en ny server til en kørende instans og dækker derefter HTTPS, sikring til produktion, backups, opdateringer og fjernelse. Vil du i stedet arbejde på Status200s egen kode, så se Lokal udvikling.

Sådan fungerer det#

Docker Compose kører hver del af Status200 som en container på din server. Al trafik kommer ind gennem containeren ingress, som sender den videre til app. Appen gemmer sine data i PostgreSQL, ClickHouse og Valkey. En medfølgende probe kører dine monitorers tjek og melder tilbage gennem ingressen.

Til produktion i stor skala, eller når du har brug for høj tilgængelighed, så brug i stedet Helm-chartet på Kubernetes: Docker Compose kører én kopi af hver tjeneste på én server.

Krav#

Vælg serverens størrelse ud fra, hvad du vil køre på den. Det er telemetri (logs, metrikker, traces), der bestemmer hukommelse og disk; se Dimensionering og kapacitetsplanlægning, når du kender dine mængder.

Minimum til et homelab passer til personlig og eksperimentel brug — nogle kører Status200 på en Raspberry Pi.

Du har også brug for:

• Docker med pluginet Docker Compose v2 (kommandoen docker compose).
• Git, til at hente Status200.
• Node.js og npm, som kører scriptene npm start og npm run update, der pakker Docker Compose ind.
• Port 80 og 443 ledige på serveren. Tabellen nedenfor viser hver port, Status200 bruger på værten.

Der findes også en videogennemgang af installationen.

Installér Status200#

1. Klon release-branchen#

   Branchen release indeholder filerne til den nyeste release.

   Bash

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

2. Opret config.env#

   Alle Status200s indstillinger ligger i config.env. Start ud fra eksemplet:

   Bash

   cp config.example.env config.env

3. Angiv værtsnavnet#

   Åbn config.env, og sæt HOST til det domænenavn eller den IP-adresse, folk skal bruge for at nå Status200, uden http://. Behold kun localhost for at prøve Status200 på din egen computer.

   config.envINI

   HOST=status200.example.com

4. Generér tilfældige hemmeligheder#

   Eksempelfilen indeholder pladsholderhemmeligheder, der er offentlige på GitHub. Erstat hver af dem med sin egen tilfældige værdi:

   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

   Den sidste kommando udskriver 0: Der er ingen pladsholder tilbage. Løkken bruger GNU sed, som alle Linux-servere har. Det er disse indstillinger, den udfylder:

   Indstilling	Hvad den beskytter
   ONEUPTIME_SECRET	Kald mellem Status200s egne tjenester.
   ENCRYPTION_SECRET	De hemmeligheder, Status200 gemmer, som integrationstokens og SMTP-adgangskoder, og de login-tokens, den udsteder.
   DATABASE_PASSWORD, CLICKHOUSE_PASSWORD, VALKEY_PASSWORD	De tre datalagre.
   REGISTER_PROBE_KEY	Registrering af prober hos din instans.
   GLOBAL_PROBE_1_KEY, GLOBAL_PROBE_2_KEY	De globale prober, Docker Compose kan køre (probe-1 kører som standard).
   STATUS200_RUNNER_KEY	Den medfølgende Runner.
   GLOBAL_RUNNER_KEY	Den medfølgende globale Runner, der kører alle projekters JavaScript-trin.

   Vigtigt

   Angiv hemmelighederne før første start, og behold dem derefter. PostgreSQL tager kun sin adgangskode, når den opretter sin database, og ændrer du ENCRYPTION_SECRET senere, bliver hver værdi, der er krypteret med den gamle, ulæselig. Er DATABASE_PASSWORD stadig pladsholderen ved første start, giver npm start den en tilfældig værdi, før PostgreSQL opretter sin database.

5. Start Status200#

   npmDocker CLI

   npm

   Bash

   npm start

   Docker CLI

   Bash

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

   Første start tager flere minutter: Docker henter imagesne, og Status200 opretter sine databaser. npm start venter, til hver del svarer, og slutter med Status200 is up!

6. Opret den første konto#

   Åbn http:// efterfulgt af din HOST (for eksempel http://localhost), og tilmeld dig. Den første konto på en ny instans bliver dens masteradministrator, som kan åbne Admin Dashboard på /admin.

   Alle, der kan nå siden, kan tilmelde sig efter dig. For at forhindre det åbner du Admin Dashboard, går til Indstillinger > Godkendelse og slår Tillad tilmelding fra. Personer, du inviterer til et projekt, kan stadig oprette deres konto.

Opsæt HTTPS#

Status200 leverer almindelig HTTP, indtil du vælger en af to måder at tilføje HTTPS på:

Hvis du lægger statussider eller dashboards på egne domæner, er det enklest at lade Status200 håndtere TLS: Ingressen bestiller og leverer selv certifikaterne til de domæner.

Med HTTP_PROTOCOL=https bygger Status200 HTTPS-links, holder login-cookies på HTTPS og beder browsere om kun at nå din HOST over HTTPS. En browser holder sig til det i et år, på alle porte under det navn, så hvis HOST en dag skal svare over almindelig HTTP igen, så sæt HSTS_MAX_AGE_SECONDS=0 i config.env et stykke tid før: Browsere glemmer reglen ved deres næste besøg.

Lad Status200 hente et certifikat#

1. Peg dit domæne på serveren#

   Opret en DNS-post A (eller AAAA til IPv6) for dit domæne med serverens offentlige IP-adresse som værdi. Med en AAAA-post skal du også slå IPv6 til for Status200: se Besøgendes adresser.

2. Slå hentning af certifikater til#

   Angiv disse værdier i config.env:

   config.envINI

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

   HOST skal være et domænenavn: Status200 kan ikke få et certifikat til en IP-adresse eller til localhost.

3. Genstart med de nye indstillinger#

   Bash

   npm start

4. Åbn din instans over HTTPS#

   Åbn https://status200.example.com. Status200 bestiller certifikatet ved start og tjekker det derefter hver time og fornyer det, når der er mindre end 30 dage tilbage. Indtil det første certifikat kommer, som regel inden for få minutter, leverer ingressen et midlertidigt selvsigneret certifikat, og din browser advarer dig.

Brug din egen reverse proxy#

Disse trin kører proxyen på samme server som Status200. Kører din proxy på en anden maskine, så spring det første trin over, peg proxyen på port 80 på denne server, og lad med din cloududbyders firewall kun proxyen nå port 80 og 443: en besøgende, der når Status200 uden om proxyen, kan vælge den adresse, Status200 tæller vedkommende efter.

1. Flyt ingressen væk fra port 80 og 443#

   Proxyen skal bruge port 80 og 443, så flyt ingressen til andre porte, kun udgivet på serverens loopback-adresse 127.0.0.1, så besøgende kun når Status200 gennem din proxy. Proben og Runneren bruger værtens netværk og når Status200 gennem http://localhost, så de flytter 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. Fortæl Status200, at den står bag en proxy#

   config.envINI

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

   HTTP_PROTOCOL=https får de links, Status200 bygger, til at bruge HTTPS. TRUSTED_PROXY_HOPS=2 tæller din proxy og Status200s ingress, så Status200 læser den besøgendes rigtige adresse til IP-tilladelseslister og hastighedsbegrænsninger. Læg én til for hver yderligere proxy, der tilføjer til X-Forwarded-For, som et CDN eller en load balancer.

3. Genstart Status200 på de nye porte#

   Bash

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

   npm start tjekker http://localhost på port 80, hvor din proxy kommer til at ligge, så tjek selv den nye port. Scriptet slutter med Status200 is up!

4. Konfigurér proxyen#

   CaddyNginx

   Caddy

   Caddyfile

   status200.example.com {
       reverse_proxy localhost:8080
   }

   Caddy henter og fornyer selv certifikatet, omdirigerer HTTP til HTTPS og sender WebSocket-forbindelser igennem. Genindlæs Caddy, når du har ændret filen, for eksempel 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;
       }
   }

   Certifikatstierne er der, hvor Certbot lægger et certifikat fra Let's Encrypt; brug stierne til dit eget certifikat, hvis det kommer et andet sted fra. Kontrollér filen, og genindlæs Nginx med sudo nginx -t && sudo systemctl reload nginx.

   Begge sender X-Forwarded-Proto, som fortæller Status200, at en besøgende kom over HTTPS. Enhver anden proxy skal også sende den, ellers holdes login-cookies for statussider og dashboards på dine egne domæner ikke på HTTPS.

5. Åbn din instans gennem proxyen#

   Åbn https://status200.example.com. Du bør se Status200s loginside, leveret med din proxys certifikat.

Besøgendes adresser#

Status200 tæller hver besøgende efter den adresse, vedkommende forbinder fra: login-grænserne, de andre grænser pr. adresse og IP-tilladelseslisterne for statussider og dashboards læser den alle. To opsætninger kræver en indstilling, for at den adresse er den besøgendes egen:

Uden IPv6 på Status200s netværk giver Docker hver besøgende, der kommer via IPv6, videre til Status200 fra én adresse af sin egen, og Status200 tæller dem alle som én besøgende: én persons mislykkede logins kan låse de andre ude. At slå IPv6 til kræver Docker Engine 27 eller nyere (docker version viser din).

1. Slå IPv6 til#

   Opret docker-compose.override.yml ved siden af docker-compose.yml, eller føj dette til den, du har; npm start og npm run update læser den:

   docker-compose.override.ymlYAML

   networks:
     oneuptime:
       enable_ipv6: true

2. Genstart Status200#

   Bash

   npm stop
   npm start

   Status200 stopper og starter igen med IPv6 på sit netværk. Dine data bevares. Docker kan ikke fjerne et netværk, som en container af din egen stadig er forbundet til, for eksempel en reverse proxy: frakobl den først fra Status200s netværk, og forbind den igen bagefter. Stopper npm start med has active endpoints, så frakobl den og kør npm stop og npm start igen.

3. Tjek netværket#

   Bash

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

   Den skriver "EnableIPv6": true,.

Når flere personer logger ind fra den samme private netværksadresse, siger siden Status200-tilstand i Admin Dashboard det, med den indstilling, der ændrer det.

Tjekliste til produktion#

Docker Compose kører én kopi af hver tjeneste på én server, hvilket passer til små teams og homelabs. Gå denne liste igennem, før du stoler på den.

Skift databasens adgangskode#

PostgreSQL beholder den adgangskode, den blev oprettet med, så ændrer du kun DATABASE_PASSWORD i config.env, låser du Status200 ude af sin database. For at give en installation, der startede med pladsholderen, sin egen adgangskode skal du ændre den i PostgreSQL og i config.env samtidig og derefter starte 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

Har du angivet DATABASE_BACKUP_PASSWORD og DATABASE_RESTORE_PASSWORD, så giv dem også den nye værdi.

Backup og gendannelse#

PostgreSQL indeholder alt, hvad du konfigurerer: monitorer, hændelser, statussider, brugere. npm run backup dumper det til en fil i mappen Backups.

1. Giv backupscriptet databasens adgangskode#

   Sæt i config.env værdien DATABASE_BACKUP_PASSWORD til værdien af DATABASE_PASSWORD. Scriptet læser config.env som ren tekst, så det medfølgende ${DATABASE_PASSWORD} bliver aldrig udfyldt.

2. Kør backuppen#

   Bash

   npm run backup

   Det beder om din sudo-adgangskode og skriver Backups/db-<day of the month>.backup, så daglige backups erstatter dem fra en måned tidligere. Kør det mindst én gang om dagen.

3. Kopiér backupperne væk fra serveren#

   En backup på samme disk som databasen overlever ikke, at den disk går tabt.

Kun selve serveren når PostgreSQL: Den svarer på port 5400 på 127.0.0.1. For at tage backup af den fra en anden maskine skal du åbne en SSH-tunnel fra den maskine og derefter forbinde til dens 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 gemmer din telemetri i Docker-volumet status200_clickhouse, og intet script tager backup af det. Hvis du skal beholde den telemetri, så tag backup af volumet med et ClickHouse-værktøj som clickhouse-backup, eller kopiér det, mens Status200 er stoppet.

For at gendanne PostgreSQL angiver du værdierne DATABASE_RESTORE_* i config.env: DATABASE_RESTORE_PASSWORD til værdien af DATABASE_PASSWORD, som ved backups, og DATABASE_RESTORE_FILENAME til den backup, der skal gendannes, for eksempel db-31.backup. Kør derefter bash restore.sh. Den database, der gendannes til, skal allerede findes; på en kørende installation gør den det.

Opdatér Status200#

Tag backup først, og kør derefter:

git checkout release
git pull
npm run update

npm run update beder om din sudo-adgangskode, tilføjer nye indstillinger fra config.example.env til din config.env (dine egne værdier bliver), henter de nye images og genstarter Status200. Ligesom npm start slutter det med Status200 is up!

At skifte til en ny hovedversion (fra 13 til 14, for eksempel) kan kræve mere: Læs Opgradering af Status200, før du går i gang.

APP_TAG=release i config.env henter altid den nyeste release af Community Edition. For at blive på én version sætter du APP_TAG til dens nummer, for eksempel 14.0.22. Til Enterprise Edition er taggene enterprise-release og enterprise-14.0.22.

Afinstallér Status200#

Stop Status200, og fjern dens containere og netværk:

npm run down

Dine data bliver i volumerne status200_postgres og status200_clickhouse, og mappen oneuptime beholder config.env og dine backups. For også at slette dataene:

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

Slet derefter mappen oneuptime.

Fejlfinding#

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æste trin#