Docker Compose

Draai een volledige, gratis Status200-instantie op één Linux-server met Docker Compose. Deze pagina brengt u van een nieuwe server naar een draaiende instantie en behandelt daarna HTTPS, het beveiligen voor productie, back-ups, updates en verwijderen. Wilt u in plaats daarvan aan de code van Status200 zelf werken, zie dan Lokale ontwikkeling.

Hoe het werkt#

Docker Compose draait elk onderdeel van Status200 als container op uw server. Al het verkeer komt binnen via de container ingress, die het naar de app doorstuurt. De app bewaart zijn gegevens in PostgreSQL, ClickHouse en Valkey. Een meegeleverde probe voert de controles van uw monitors uit en meldt de resultaten terug via de ingress.

Gebruik voor productie op grote schaal, of als u hoge beschikbaarheid nodig hebt, in plaats daarvan de Helm-chart op Kubernetes: Docker Compose draait van elke service één exemplaar op één server.

Vereisten#

Kies de grootte van de server op basis van wat u erop gaat draaien. Telemetrie (logs, metrics, traces) bepaalt het geheugen en de schijf; zie Sizing en capaciteitsplanning zodra u uw volumes kent.

Het minimum voor een homelab is geschikt voor persoonlijk en experimenteel gebruik — sommigen draaien Status200 op een Raspberry Pi.

U hebt ook nodig:

• Docker met de plugin Docker Compose v2 (het commando docker compose).
• Git, om Status200 op te halen.
• Node.js en npm, die de scripts npm start en npm run update uitvoeren die om Docker Compose heen zijn gebouwd.
• Poorten 80 en 443 vrij op de server. De tabel hieronder toont elke poort die Status200 op de host gebruikt.

Er is ook een video-uitleg van de installatie.

Status200 installeren#

1. Kloon de release-branch#

   De branch release bevat de bestanden van de nieuwste release.

   Bash

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

2. Maak config.env aan#

   Alle instellingen van Status200 staan in config.env. Begin met het voorbeeld:

   Bash

   cp config.example.env config.env

3. Stel de hostnaam in#

   Open config.env en stel HOST in op de domeinnaam of het IP-adres waarmee mensen Status200 bereiken, zonder http://. Houd localhost alleen aan om Status200 op uw eigen computer uit te proberen.

   config.envINI

   HOST=status200.example.com

4. Genereer willekeurige geheimen#

   Het voorbeeldbestand bevat tijdelijke geheimen die openbaar op GitHub staan. Vervang elk ervan door een eigen willekeurige waarde:

   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

   Het laatste commando geeft 0: er is geen tijdelijke waarde meer over. De lus gebruikt GNU sed, dat elke Linux-server heeft. Dit zijn de instellingen die hij invult:

   Instelling	Wat ze beschermt
   ONEUPTIME_SECRET	Aanroepen tussen de eigen services van Status200.
   ENCRYPTION_SECRET	De geheimen die Status200 opslaat, zoals integratietokens en SMTP-wachtwoorden, en de aanmeldtokens die het uitgeeft.
   DATABASE_PASSWORD, CLICKHOUSE_PASSWORD, VALKEY_PASSWORD	De drie gegevensopslagen.
   REGISTER_PROBE_KEY	Het registreren van probes bij uw instantie.
   GLOBAL_PROBE_1_KEY, GLOBAL_PROBE_2_KEY	De globale probes die Docker Compose kan draaien (probe-1 draait standaard).
   STATUS200_RUNNER_KEY	De meegeleverde Runner.
   GLOBAL_RUNNER_KEY	De meegeleverde globale Runner, die de JavaScript-stappen van alle projecten uitvoert.

   Belangrijk

   Stel de geheimen in vóór de eerste start en houd ze daarna aan. PostgreSQL neemt zijn wachtwoord alleen over bij het aanmaken van zijn database, en ENCRYPTION_SECRET later wijzigen maakt elke waarde die met de oude is versleuteld onleesbaar. Is DATABASE_PASSWORD bij de eerste start nog de tijdelijke waarde, dan geeft npm start het een willekeurige waarde voordat PostgreSQL zijn database aanmaakt.

5. Start Status200#

   npmDocker CLI

   npm

   Bash

   npm start

   Docker CLI

   Bash

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

   De eerste start duurt enkele minuten: Docker downloadt de images en Status200 maakt zijn databases aan. npm start wacht tot elk onderdeel antwoordt en eindigt met Status200 is up!

6. Maak het eerste account aan#

   Open http:// gevolgd door uw HOST (bijvoorbeeld http://localhost) en registreer u. Het eerste account van een nieuwe instantie wordt de hoofdbeheerder ervan, die het Admin Dashboard op /admin kan openen.

   Iedereen die de pagina kan bereiken, kan zich na u registreren. Om dat te voorkomen, opent u het Admin Dashboard, gaat u naar Instellingen > Authenticatie en schakelt u Registratie toestaan uit. Mensen die u voor een project uitnodigt, kunnen nog steeds hun account aanmaken.

HTTPS instellen#

Status200 levert gewoon HTTP totdat u een van twee manieren kiest om HTTPS toe te voegen:

Als u statuspagina's of dashboards op eigen domeinen zet, is Status200 TLS laten afhandelen de eenvoudigste opzet: de ingress bestelt de certificaten van die domeinen zelf en levert ze uit.

Met HTTP_PROTOCOL=https bouwt Status200 HTTPS-links, houdt het aanmeldcookies op HTTPS en vraagt het browsers om uw HOST alleen via HTTPS te bereiken. Een browser houdt zich daar een jaar aan, op elke poort van die naam. Moet HOST ooit weer via gewoon HTTP antwoorden, zet dan een tijd van tevoren HSTS_MAX_AGE_SECONDS=0 in config.env: browsers vergeten de regel bij hun volgende bezoek.

Status200 een certificaat laten halen#

1. Wijs uw domein naar de server#

   Maak voor uw domein een DNS-record A (of AAAA voor IPv6) aan, met het openbare IP-adres van de server als waarde. Met een AAAA-record zet u ook IPv6 aan voor Status200: zie Adressen van bezoekers.

2. Schakel het aanvragen van certificaten in#

   Stel deze waarden in config.env in:

   config.envINI

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

   HOST moet een domeinnaam zijn: Status200 kan geen certificaat krijgen voor een IP-adres of voor localhost.

3. Herstart met de nieuwe instellingen#

   Bash

   npm start

4. Open uw instantie via HTTPS#

   Open https://status200.example.com. Status200 bestelt het certificaat bij het starten, controleert het daarna elk uur en vernieuwt het als er minder dan 30 dagen over zijn. Totdat het eerste certificaat binnen is, meestal binnen enkele minuten, levert de ingress een tijdelijk zelfondertekend certificaat en waarschuwt uw browser u.

Uw eigen reverse proxy gebruiken#

Deze stappen draaien de proxy op dezelfde server als Status200. Draait uw proxy op een andere machine, sla dan de eerste stap over, wijs de proxy naar poort 80 van deze server en laat met de firewall van uw cloudprovider alleen de proxy poort 80 en 443 bereiken: een bezoeker die Status200 buiten de proxy om bereikt, kan het adres kiezen waarop Status200 hem telt.

1. Haal de ingress van poort 80 en 443 af#

   De proxy heeft poort 80 en 443 nodig, dus verplaats de ingress naar andere poorten, alleen gepubliceerd op het loopbackadres 127.0.0.1 van deze server, zodat bezoekers Status200 alleen via uw proxy bereiken. De probe en de Runner gebruiken het netwerk van de host en bereiken Status200 via http://localhost, dus ze verhuizen mee:

   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. Vertel Status200 dat het achter een proxy staat#

   config.envINI

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

   HTTP_PROTOCOL=https laat de links die Status200 bouwt HTTPS gebruiken. TRUSTED_PROXY_HOPS=2 telt uw proxy en de ingress van Status200, zodat Status200 voor IP-allowlists en rate limits het echte adres van de bezoeker leest. Tel er een bij voor elke volgende proxy die iets toevoegt aan X-Forwarded-For, zoals een CDN of een load balancer.

3. Herstart Status200 op de nieuwe poorten#

   Bash

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

   npm start controleert http://localhost op poort 80, waar uw proxy komt, dus controleer de nieuwe poort zelf. Het script eindigt met Status200 is up!

4. Configureer de proxy#

   CaddyNginx

   Caddy

   Caddyfile

   status200.example.com {
       reverse_proxy localhost:8080
   }

   Caddy haalt en vernieuwt het certificaat zelf, stuurt HTTP door naar HTTPS en laat WebSocket-verbindingen door. Laad Caddy opnieuw nadat u het bestand hebt gewijzigd, bijvoorbeeld met 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;
       }
   }

   De certificaatpaden zijn de plekken waar Certbot een Let's Encrypt-certificaat neerzet; gebruik de paden van uw eigen certificaat als het ergens anders vandaan komt. Controleer het bestand en laad Nginx opnieuw met sudo nginx -t && sudo systemctl reload nginx.

   Beide sturen X-Forwarded-Proto mee, dat Status200 vertelt dat een bezoeker via HTTPS kwam. Elke andere proxy moet het ook sturen, anders blijven de aanmeldcookies van statuspagina's en dashboards op uw eigen domeinen niet op HTTPS.

5. Open uw instantie via de proxy#

   Open https://status200.example.com. U zou de aanmeldpagina van Status200 moeten zien, geleverd met het certificaat van uw proxy.

Adressen van bezoekers#

Status200 telt elke bezoeker op het adres waarvandaan hij verbinding maakt: de aanmeldlimieten, de andere limieten per adres en de IP-allowlists van statuspagina's en dashboards lezen het allemaal. Twee opstellingen hebben een instelling nodig om dat adres het eigen adres van de bezoeker te laten zijn:

Zonder IPv6 op het netwerk van Status200 geeft Docker elke bezoeker die via IPv6 komt vanaf een eigen adres door aan Status200, en Status200 telt hen allemaal als één bezoeker: de mislukte aanmeldingen van één persoon kunnen de anderen buitensluiten. IPv6 aanzetten vraagt Docker Engine 27 of nieuwer (docker version toont de uwe).

1. Zet IPv6 aan#

   Maak docker-compose.override.yml aan naast docker-compose.yml, of voeg dit toe aan het bestand dat u al hebt; npm start en npm run update lezen het:

   docker-compose.override.ymlYAML

   networks:
     oneuptime:
       enable_ipv6: true

2. Herstart Status200#

   Bash

   npm stop
   npm start

   Status200 stopt en start opnieuw, met IPv6 op zijn netwerk. Uw gegevens blijven bewaard. Docker kan geen netwerk verwijderen waaraan nog een eigen container gekoppeld is, zoals een reverse proxy: ontkoppel die eerst van het netwerk van Status200 en koppel hem daarna weer. Stopt npm start met has active endpoints, ontkoppel hem dan en voer npm stop en npm start opnieuw uit.

3. Controleer het netwerk#

   Bash

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

   Het toont "EnableIPv6": true,.

Als meerdere mensen zich aanmelden vanaf één privénetwerkadres, meldt de pagina Status200-gezondheid van het Admin Dashboard dat, met de instelling die het verandert.

Checklist voor productie#

Docker Compose draait van elke service één exemplaar op één server, wat past bij kleine teams en homelabs. Loop deze lijst door voordat u erop gaat vertrouwen.

Wijzig het databasewachtwoord#

PostgreSQL houdt het wachtwoord waarmee het is aangemaakt, dus als u alleen DATABASE_PASSWORD in config.env wijzigt, sluit u Status200 buiten zijn database. Om een installatie die startte met de tijdelijke waarde een eigen wachtwoord te geven, wijzigt u het tegelijk in PostgreSQL en in config.env en start u Status200 daarna opnieuw:

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

Hebt u DATABASE_BACKUP_PASSWORD en DATABASE_RESTORE_PASSWORD ingesteld, geef ze dan ook de nieuwe waarde.

Back-up en herstel#

PostgreSQL bevat alles wat u configureert: monitors, incidenten, statuspagina's, gebruikers. npm run backup dumpt het naar een bestand in de map Backups.

1. Geef het back-upscript het databasewachtwoord#

   Stel in config.env DATABASE_BACKUP_PASSWORD in op de waarde van DATABASE_PASSWORD. Het script leest config.env als platte tekst, dus de meegeleverde ${DATABASE_PASSWORD} wordt nooit ingevuld.

2. Voer de back-up uit#

   Bash

   npm run backup

   Het vraagt om uw sudo-wachtwoord en schrijft Backups/db-<day of the month>.backup, zodat dagelijkse back-ups die van een maand eerder vervangen. Voer het minstens één keer per dag uit.

3. Kopieer de back-ups van de server af#

   Een back-up op dezelfde schijf als de database overleeft het verlies van die schijf niet.

Alleen de server zelf bereikt PostgreSQL: het antwoordt op poort 5400 van 127.0.0.1. Om er vanaf een andere machine een back-up van te maken, opent u vanaf die machine een SSH-tunnel en maakt u daarna verbinding met de eigen poort 5400 van die machine:

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

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

ClickHouse bewaart uw telemetrie in het Docker-volume status200_clickhouse, en geen enkel script maakt daar een back-up van. Moet u die telemetrie bewaren, maak dan een back-up van het volume met een ClickHouse-tool zoals clickhouse-backup, of kopieer het terwijl Status200 is gestopt.

Om PostgreSQL te herstellen, stelt u de waarden DATABASE_RESTORE_* in config.env in: DATABASE_RESTORE_PASSWORD op de waarde van DATABASE_PASSWORD, net als voor back-ups, en DATABASE_RESTORE_FILENAME op de te herstellen back-up, zoals db-31.backup. Voer daarna bash restore.sh uit. De database waarin het herstelt, moet al bestaan; bij een draaiende installatie is dat zo.

Status200 bijwerken#

Maak eerst een back-up en voer daarna uit:

git checkout release
git pull
npm run update

npm run update vraagt om uw sudo-wachtwoord, voegt nieuwe instellingen uit config.example.env toe aan uw config.env (uw eigen waarden blijven staan), haalt de nieuwe images op en herstart Status200. Net als npm start eindigt het met Status200 is up!

Overstappen op een nieuwe hoofdversie (van 13 naar 14, bijvoorbeeld) kan meer vergen: lees Status200 upgraden voordat u begint.

APP_TAG=release in config.env haalt altijd de nieuwste release van de Community Edition op. Om op één versie te blijven, stelt u APP_TAG in op het nummer ervan, zoals 14.0.22. Voor de Enterprise Edition zijn de tags enterprise-release en enterprise-14.0.22.

Status200 verwijderen#

Stop Status200 en verwijder de containers en het netwerk:

npm run down

Uw gegevens blijven in de volumes status200_postgres en status200_clickhouse, en de map oneuptime houdt config.env en uw back-ups. Om ook de gegevens te verwijderen:

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

Verwijder daarna de map oneuptime.

Probleemoplossing#

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

Volgende stappen#