Docker Compose

Betreiben Sie mit Docker Compose eine vollständige, kostenlose Status200-Instanz auf einem einzigen Linux-Server. Diese Seite führt Sie von einem frischen Server zu einer laufenden Instanz und behandelt danach HTTPS, die Absicherung für den Produktivbetrieb, Backups, Updates und das Entfernen. Um stattdessen am Code von Status200 selbst zu arbeiten, siehe Lokale Entwicklung.

So funktioniert es#

Docker Compose betreibt jeden Teil von Status200 als Container auf Ihrem Server. Der gesamte Verkehr kommt über den Container ingress herein, der ihn an die app weiterleitet. Die App speichert ihre Daten in PostgreSQL, ClickHouse und Valkey. Eine mitgelieferte Probe führt die Prüfungen Ihrer Monitore aus und meldet die Ergebnisse über den Ingress zurück.

Für den Produktivbetrieb im großen Maßstab oder wenn Sie Hochverfügbarkeit brauchen, verwenden Sie stattdessen das Helm-Chart auf Kubernetes: Docker Compose betreibt jeden Dienst einmal auf einem einzigen Server.

Anforderungen#

Wählen Sie die Servergröße danach, was Sie darauf betreiben werden. Telemetrie (Logs, Metriken, Traces) bestimmt Arbeitsspeicher und Festplatte; siehe Dimensionierung & Kapazitätsplanung, sobald Sie Ihre Datenmengen kennen.

Das Minimum für das Homelab eignet sich für die private und experimentelle Nutzung — manche betreiben Status200 auf einem Raspberry Pi.

Außerdem brauchen Sie:

• Docker mit dem Plugin Docker Compose v2 (der Befehl docker compose).
• Git, um Status200 abzurufen.
• Node.js und npm, die die Skripte npm start und npm run update ausführen, die Docker Compose umschließen.
• Ports 80 und 443 frei auf dem Server. Die Tabelle unten listet jeden Port, den Status200 auf dem Host belegt.

Es gibt auch eine Video-Anleitung zur Installation.

Status200 installieren#

1. Den Release-Branch klonen#

   Der Branch release enthält die Dateien des neuesten Releases.

   Bash

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

2. config.env anlegen#

   Alle Einstellungen von Status200 stehen in config.env. Beginnen Sie mit dem Beispiel:

   Bash

   cp config.example.env config.env

3. Den Hostnamen festlegen#

   Öffnen Sie config.env und setzen Sie HOST auf den Domainnamen oder die IP-Adresse, über die Status200 erreicht werden soll, ohne http://. Behalten Sie localhost nur, um Status200 auf Ihrem eigenen Rechner auszuprobieren.

   config.envINI

   HOST=status200.example.com

4. Zufällige Geheimnisse erzeugen#

   Die Beispieldatei enthält Platzhalter-Geheimnisse, die auf GitHub öffentlich sind. Ersetzen Sie jedes durch einen eigenen Zufallswert:

   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

   Der letzte Befehl gibt 0 aus: Es ist kein Platzhalter mehr übrig. Die Schleife verwendet GNU sed, das jeder Linux-Server hat. Diese Einstellungen füllt sie aus:

   Einstellung	Was sie schützt
   ONEUPTIME_SECRET	Aufrufe zwischen den eigenen Diensten von Status200.
   ENCRYPTION_SECRET	Die Geheimnisse, die Status200 speichert, etwa Integrations-Tokens und SMTP-Passwörter, und die Anmelde-Tokens, die es ausstellt.
   DATABASE_PASSWORD, CLICKHOUSE_PASSWORD, VALKEY_PASSWORD	Die drei Datenspeicher.
   REGISTER_PROBE_KEY	Das Registrieren von Probes bei Ihrer Instanz.
   GLOBAL_PROBE_1_KEY, GLOBAL_PROBE_2_KEY	Die globalen Probes, die Docker Compose betreiben kann (probe-1 läuft standardmäßig).
   STATUS200_RUNNER_KEY	Den mitgelieferten Runner.
   GLOBAL_RUNNER_KEY	Den mitgelieferten globalen Runner, der die JavaScript-Schritte aller Projekte ausführt.

   Wichtig

   Setzen Sie die Geheimnisse vor dem ersten Start und behalten Sie sie danach bei. PostgreSQL übernimmt sein Passwort nur beim Anlegen seiner Datenbank, und eine spätere Änderung von ENCRYPTION_SECRET macht jeden mit dem alten Wert verschlüsselten Wert unlesbar. Ist DATABASE_PASSWORD beim ersten Start noch der Platzhalter, gibt npm start ihm einen zufälligen Wert, bevor PostgreSQL seine Datenbank anlegt.

5. Status200 starten#

   npmDocker CLI

   npm

   Bash

   npm start

   Docker CLI

   Bash

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

   Der erste Start dauert einige Minuten: Docker lädt die Images herunter, und Status200 legt seine Datenbanken an. npm start wartet, bis jeder Teil antwortet, und endet mit Status200 is up!

6. Das erste Konto anlegen#

   Öffnen Sie http:// gefolgt von Ihrem HOST (zum Beispiel http://localhost) und registrieren Sie sich. Das erste Konto einer neuen Instanz wird ihr Master-Admin, der das Admin Dashboard unter /admin öffnen kann.

   Jeder, der die Seite erreicht, kann sich nach Ihnen registrieren. Um das zu verhindern, öffnen Sie das Admin Dashboard, gehen zu Einstellungen > Authentifizierung und schalten Registrierung erlauben aus. Personen, die Sie in ein Projekt einladen, können ihr Konto weiterhin anlegen.

HTTPS einrichten#

Status200 liefert reines HTTP aus, bis Sie einen von zwei Wegen zu HTTPS wählen:

Wenn Sie Statusseiten oder Dashboards auf eigene Domains legen, ist es einfacher, Status200 TLS übernehmen zu lassen: Der Ingress bestellt die Zertifikate dieser Domains selbst und liefert sie aus.

Mit HTTP_PROTOCOL=https erzeugt Status200 HTTPS-Links, hält Anmelde-Cookies auf HTTPS und weist Browser an, Ihren HOST nur noch über HTTPS aufzurufen. Ein Browser hält sich ein Jahr lang daran, auf jedem Port dieses Namens. Soll HOST also irgendwann wieder über reines HTTP antworten, setzen Sie HSTS_MAX_AGE_SECONDS=0 in config.env eine Weile vorher: Browser vergessen die Regel bei ihrem nächsten Besuch.

Status200 ein Zertifikat holen lassen#

1. Ihre Domain auf den Server zeigen lassen#

   Legen Sie für Ihre Domain einen DNS-Eintrag A (oder AAAA für IPv6) an, mit der öffentlichen IP-Adresse des Servers als Wert. Mit einem AAAA-Eintrag schalten Sie außerdem IPv6 für Status200 ein: siehe Besucheradressen.

2. Die Zertifikatsbereitstellung einschalten#

   Setzen Sie diese Werte in config.env:

   config.envINI

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

   HOST muss ein Domainname sein: Status200 kann kein Zertifikat für eine IP-Adresse oder für localhost bekommen.

3. Mit den neuen Einstellungen neu starten#

   Bash

   npm start

4. Ihre Instanz über HTTPS öffnen#

   Öffnen Sie https://status200.example.com. Status200 bestellt das Zertifikat beim Start und prüft es danach stündlich; es erneuert es, wenn weniger als 30 Tage übrig sind. Bis das erste Zertifikat eintrifft, meist innerhalb weniger Minuten, liefert der Ingress ein vorläufiges selbstsigniertes aus, und Ihr Browser warnt Sie.

Einen eigenen Reverse Proxy verwenden#

Diese Schritte betreiben den Proxy auf demselben Server wie Status200. Läuft Ihr Proxy auf einem anderen Rechner, überspringen Sie den ersten Schritt, richten den Proxy auf Port 80 dieses Servers und lassen mit der Firewall Ihres Cloud-Anbieters nur den Proxy die Ports 80 und 443 erreichen: Ein Besucher, der Status200 am Proxy vorbei erreicht, kann die Adresse wählen, nach der Status200 ihn zählt.

1. Den Ingress von den Ports 80 und 443 wegverlegen#

   Der Proxy braucht die Ports 80 und 443, also verlegen Sie den Ingress auf andere Ports, veröffentlicht nur auf der Loopback-Adresse 127.0.0.1 dieses Servers, damit Besucher Status200 nur über Ihren Proxy erreichen. Die Probe und der Runner nutzen das Netzwerk des Hosts und erreichen Status200 über http://localhost, daher ziehen sie mit um:

   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. Status200 mitteilen, dass es hinter einem Proxy steht#

   config.envINI

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

   HTTP_PROTOCOL=https lässt die Links, die Status200 erzeugt, HTTPS verwenden. TRUSTED_PROXY_HOPS=2 zählt Ihren Proxy und den Ingress von Status200, sodass Status200 für IP-Allowlists und Ratenbegrenzungen die echte Adresse des Besuchers liest. Zählen Sie für jeden weiteren Proxy, der etwas an X-Forwarded-For anhängt, etwa ein CDN oder einen Load Balancer, einen hinzu.

3. Status200 auf den neuen Ports neu starten#

   Bash

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

   npm start prüft http://localhost auf Port 80, wo Ihr Proxy liegen wird, also prüfen Sie den neuen Port selbst. Das Skript endet mit Status200 is up!

4. Den Proxy konfigurieren#

   CaddyNginx

   Caddy

   Caddyfile

   status200.example.com {
       reverse_proxy localhost:8080
   }

   Caddy holt und erneuert das Zertifikat selbst, leitet HTTP auf HTTPS um und reicht WebSocket-Verbindungen durch. Laden Sie Caddy nach einer Änderung der Datei neu, zum Beispiel mit 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;
       }
   }

   Die Zertifikatspfade sind die, unter denen Certbot ein Let's-Encrypt-Zertifikat ablegt; verwenden Sie die Pfade Ihres eigenen Zertifikats, wenn es von woanders stammt. Prüfen Sie die Datei und laden Sie Nginx neu mit sudo nginx -t && sudo systemctl reload nginx.

   Beide senden X-Forwarded-Proto, das Status200 mitteilt, dass ein Besucher über HTTPS kam. Jeder andere Proxy muss es ebenfalls senden, sonst werden die Anmelde-Cookies von Statusseiten und Dashboards auf Ihren eigenen Domains nicht auf HTTPS gehalten.

5. Ihre Instanz über den Proxy öffnen#

   Öffnen Sie https://status200.example.com. Sie sollten die Anmeldeseite von Status200 sehen, ausgeliefert mit dem Zertifikat Ihres Proxys.

Besucheradressen#

Status200 zählt jeden Besucher nach der Adresse, von der aus er sich verbindet: Die Anmeldelimits, die übrigen Limits pro Adresse und die IP-Allowlists von Statusseiten und Dashboards lesen sie alle. Zwei Setups brauchen eine Einstellung, damit diese Adresse die eigene des Besuchers ist:

Ohne IPv6 im Netzwerk von Status200 reicht Docker jeden Besucher, der über IPv6 kommt, von einer eigenen Adresse aus an Status200 weiter, und Status200 zählt sie alle als einen Besucher: Die fehlgeschlagenen Anmeldungen einer Person können die anderen aussperren. Um IPv6 einzuschalten, brauchen Sie Docker Engine 27 oder neuer (docker version zeigt Ihre).

1. IPv6 einschalten#

   Legen Sie docker-compose.override.yml neben docker-compose.yml an, oder ergänzen Sie Ihre vorhandene Datei; npm start und npm run update lesen sie:

   docker-compose.override.ymlYAML

   networks:
     oneuptime:
       enable_ipv6: true

2. Status200 neu starten#

   Bash

   npm stop
   npm start

   Status200 hält an und startet wieder, mit IPv6 in seinem Netzwerk. Ihre Daten bleiben erhalten. Docker kann kein Netzwerk entfernen, mit dem ein eigener Container noch verbunden ist, etwa ein Reverse Proxy: Trennen Sie ihn vorher vom Netzwerk von Status200 und verbinden Sie ihn danach wieder. Bricht npm start mit has active endpoints ab, trennen Sie ihn und führen dann npm stop und npm start erneut aus.

3. Das Netzwerk prüfen#

   Bash

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

   Es gibt "EnableIPv6": true, aus.

Wenn sich mehrere Personen von einer privaten Netzwerkadresse aus anmelden, sagt das die Seite Status200-Zustand im Admin Dashboard, mit der Einstellung, die das ändert.

Checkliste für den Produktivbetrieb#

Docker Compose betreibt jeden Dienst einmal auf einem einzigen Server, was zu kleinen Teams und Homelabs passt. Bevor Sie sich darauf verlassen, gehen Sie diese Liste durch.

Das Datenbankpasswort ändern#

PostgreSQL behält das Passwort, mit dem es angelegt wurde: Ändern Sie nur DATABASE_PASSWORD in config.env, sperren Sie Status200 aus seiner Datenbank aus. Um einer Installation, die mit dem Platzhalter gestartet ist, ein eigenes Passwort zu geben, ändern Sie es in PostgreSQL und in config.env zugleich und starten Status200 dann neu:

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

Wenn Sie DATABASE_BACKUP_PASSWORD und DATABASE_RESTORE_PASSWORD gesetzt haben, geben Sie ihnen ebenfalls den neuen Wert.

Sichern und wiederherstellen#

PostgreSQL enthält alles, was Sie konfigurieren: Monitore, Vorfälle, Statusseiten, Benutzer. npm run backup schreibt einen Dump davon in eine Datei im Ordner Backups.

1. Dem Backup-Skript das Datenbankpasswort geben#

   Setzen Sie in config.env den Wert DATABASE_BACKUP_PASSWORD auf den Wert von DATABASE_PASSWORD. Das Skript liest config.env als reinen Text, daher wird das mitgelieferte ${DATABASE_PASSWORD} nie ausgefüllt.

2. Das Backup ausführen#

   Bash

   npm run backup

   Es fragt nach Ihrem sudo-Passwort und schreibt Backups/db-<day of the month>.backup, sodass tägliche Backups die eines Monats zuvor ersetzen. Führen Sie es mindestens einmal am Tag aus.

3. Die Backups vom Server kopieren#

   Ein Backup auf derselben Festplatte wie die Datenbank übersteht den Verlust dieser Festplatte nicht.

Nur der Server selbst erreicht PostgreSQL: Es antwortet auf Port 5400 von 127.0.0.1. Um es von einem anderen Rechner aus zu sichern, öffnen Sie von diesem Rechner einen SSH-Tunnel und verbinden sich dann mit dessen eigenem 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 bewahrt Ihre Telemetrie im Docker-Volume status200_clickhouse auf, und kein Skript sichert es. Wenn Sie diese Telemetrie behalten müssen, sichern Sie das Volume mit einem ClickHouse-Werkzeug wie clickhouse-backup, oder kopieren Sie es, während Status200 gestoppt ist.

Um PostgreSQL wiederherzustellen, setzen Sie die Werte DATABASE_RESTORE_* in config.env: DATABASE_RESTORE_PASSWORD auf den Wert von DATABASE_PASSWORD, wie bei Backups, und DATABASE_RESTORE_FILENAME auf das wiederherzustellende Backup, etwa db-31.backup. Führen Sie dann bash restore.sh aus. Die Datenbank, in die es wiederherstellt, muss bereits existieren; in einer laufenden Installation tut sie das.

Status200 aktualisieren#

Sichern Sie zuerst, dann führen Sie aus:

git checkout release
git pull
npm run update

npm run update fragt nach Ihrem sudo-Passwort, übernimmt neue Einstellungen aus config.example.env in Ihre config.env (Ihre eigenen Werte bleiben), lädt die neuen Images und startet Status200 neu. Wie npm start endet es mit Status200 is up!

Der Wechsel auf eine neue Hauptversion (von 13 auf 14, zum Beispiel) kann mehr erfordern: Lesen Sie Status200 upgraden, bevor Sie beginnen.

APP_TAG=release in config.env lädt immer das neueste Release der Community Edition. Um auf einer Version zu bleiben, setzen Sie APP_TAG auf ihre Nummer, etwa 14.0.22. Für die Enterprise Edition lauten die Tags enterprise-release und enterprise-14.0.22.

Status200 deinstallieren#

Stoppen Sie Status200 und entfernen Sie seine Container und sein Netzwerk:

npm run down

Ihre Daten bleiben in den Volumes status200_postgres und status200_clickhouse, und der Ordner oneuptime behält config.env und Ihre Backups. Um auch die Daten zu löschen:

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

Löschen Sie anschließend den Ordner oneuptime.

Fehlerbehebung#

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ächste Schritte#