Docker Compose

Esegui un'istanza Status200 completa e gratuita su un unico server Linux con Docker Compose. Questa pagina ti porta da un server appena creato a un'istanza funzionante, poi tratta HTTPS, l'hardening per la produzione, i backup, gli aggiornamenti e la rimozione. Per lavorare invece sul codice di Status200, vedi Sviluppo locale.

Come funziona#

Docker Compose esegue ogni parte di Status200 come container sul tuo server. Tutto il traffico entra dal container ingress, che lo instrada verso l'app. L'app conserva i suoi dati in PostgreSQL, ClickHouse e Valkey. Una sonda inclusa esegue i controlli dei tuoi monitor e riporta i risultati tramite l'ingress.

Per la produzione su larga scala, o quando ti serve l'alta disponibilità, usa invece il chart Helm su Kubernetes: Docker Compose esegue una sola copia di ogni servizio su un unico server.

Requisiti#

Scegli la dimensione del server in base a ciò che ci farai girare. È la telemetria (log, metriche, trace) a determinare memoria e disco; consulta Dimensionamento e pianificazione della capacità quando conosci i tuoi volumi.

Il minimo per un homelab va bene per un uso personale e sperimentale: c'è chi fa girare Status200 su un Raspberry Pi.

Ti servono anche:

• Docker con il plugin Docker Compose v2 (il comando docker compose).
• Git, per scaricare Status200.
• Node.js e npm, che eseguono gli script npm start e npm run update che avvolgono Docker Compose.
• Porte 80 e 443 libere sul server. La tabella qui sotto elenca ogni porta che Status200 usa sull'host.

C'è anche una guida video dell'installazione.

Installare Status200#

1. Clona il branch release#

   Il branch release contiene i file dell'ultima release.

   Bash

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

2. Crea config.env#

   Tutte le impostazioni di Status200 si trovano in config.env. Parti dall'esempio:

   Bash

   cp config.example.env config.env

3. Imposta il nome host#

   Apri config.env e imposta HOST sul nome di dominio o sull'indirizzo IP che verrà usato per raggiungere Status200, senza http://. Lascia localhost solo per provare Status200 sul tuo computer.

   config.envINI

   HOST=status200.example.com

4. Genera secret casuali#

   Il file di esempio contiene secret segnaposto che sono pubblici su GitHub. Sostituisci ciascuno con un valore casuale proprio:

   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

   L'ultimo comando stampa 0: non è rimasto alcun segnaposto. Il ciclo usa GNU sed, presente su ogni server Linux. Queste sono le impostazioni che compila:

   Impostazione	Cosa protegge
   ONEUPTIME_SECRET	Le chiamate tra i servizi di Status200.
   ENCRYPTION_SECRET	I secret che Status200 conserva, come i token delle integrazioni e le password SMTP, e i token di accesso che emette.
   DATABASE_PASSWORD, CLICKHOUSE_PASSWORD, VALKEY_PASSWORD	I tre datastore.
   REGISTER_PROBE_KEY	La registrazione delle sonde presso la tua istanza.
   GLOBAL_PROBE_1_KEY, GLOBAL_PROBE_2_KEY	Le sonde globali che Docker Compose può eseguire (probe-1 è attiva per impostazione predefinita).
   STATUS200_RUNNER_KEY	Il Runner incluso.
   GLOBAL_RUNNER_KEY	Il Runner globale incluso, che esegue i passaggi JavaScript di tutti i progetti.

   Importante

   Imposta i secret prima del primo avvio e poi non cambiarli. PostgreSQL prende la sua password solo quando crea il database, e cambiare ENCRYPTION_SECRET in seguito rende illeggibile ogni valore cifrato con quello vecchio. Se al primo avvio DATABASE_PASSWORD è ancora il segnaposto, npm start le dà un valore casuale prima che PostgreSQL crei il suo database.

5. Avvia Status200#

   npmDocker CLI

   npm

   Bash

   npm start

   Docker CLI

   Bash

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

   Il primo avvio richiede diversi minuti: Docker scarica le immagini e Status200 crea i suoi database. npm start attende che ogni parte risponda e termina con Status200 is up!

6. Crea il primo account#

   Apri http:// seguito dal tuo HOST (per esempio http://localhost) e registrati. Il primo account di una nuova istanza ne diventa l'amministratore principale, che può aprire l'Admin Dashboard su /admin.

   Chiunque possa raggiungere la pagina può registrarsi dopo di te. Per impedirlo, apri l'Admin Dashboard, vai in Impostazioni > Autenticazione e disattiva Consenti la registrazione. Le persone che inviti in un progetto possono comunque creare il proprio account.

Configurare HTTPS#

Status200 serve HTTP semplice finché non scegli uno dei due modi per aggiungere HTTPS:

Se metti pagine di stato o dashboard su domini personalizzati, lasciare che Status200 gestisca TLS è la configurazione più semplice: l'ingress ordina e serve da solo i certificati di quei domini.

Con HTTP_PROTOCOL=https, Status200 costruisce link HTTPS, mantiene i cookie di accesso su HTTPS e chiede ai browser di raggiungere il tuo HOST solo in HTTPS. Un browser vi si attiene per un anno, su ogni porta di quel nome, quindi se un giorno HOST dovrà di nuovo rispondere in HTTP semplice, imposta HSTS_MAX_AGE_SECONDS=0 in config.env un po' di tempo prima: i browser dimenticano la regola alla visita successiva.

Lasciare che Status200 ottenga un certificato#

1. Punta il tuo dominio al server#

   Crea un record DNS A (o AAAA per IPv6) per il tuo dominio, con l'indirizzo IP pubblico del server come valore. Con un record AAAA, attiva anche IPv6 per Status200: vedi Indirizzi dei visitatori.

2. Attiva l'ottenimento dei certificati#

   Imposta questi valori in config.env:

   config.envINI

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

   HOST deve essere un nome di dominio: Status200 non può ottenere un certificato per un indirizzo IP o per localhost.

3. Riavvia con le nuove impostazioni#

   Bash

   npm start

4. Apri la tua istanza in HTTPS#

   Apri https://status200.example.com. Status200 ordina il certificato all'avvio e poi lo controlla ogni ora, rinnovandolo quando mancano meno di 30 giorni. Finché non arriva il primo certificato, di solito entro pochi minuti, l'ingress serve un certificato autofirmato temporaneo e il browser ti avvisa.

Usare il tuo reverse proxy#

Questi passi eseguono il proxy sullo stesso server di Status200. Se il tuo proxy gira su un'altra macchina, salta il primo passo, punta il proxy alla porta 80 di questo server e, con il firewall del tuo provider cloud, lascia che solo il proxy raggiunga le porte 80 e 443: un visitatore che raggiunge Status200 aggirando il proxy può scegliere l'indirizzo con cui Status200 lo conta.

1. Sposta l'ingress dalle porte 80 e 443#

   Il proxy ha bisogno delle porte 80 e 443, quindi sposta l'ingress su altre porte, pubblicate solo sull'indirizzo di loopback 127.0.0.1 di questo server, così i visitatori raggiungono Status200 soltanto attraverso il tuo proxy. La sonda e il Runner usano la rete dell'host e raggiungono Status200 tramite http://localhost, quindi si spostano con lui:

   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. Indica a Status200 che è dietro un proxy#

   config.envINI

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

   HTTP_PROTOCOL=https fa usare HTTPS ai link che Status200 costruisce. TRUSTED_PROXY_HOPS=2 conta il tuo proxy e l'ingress di Status200, così Status200 legge l'indirizzo reale del visitatore per le allowlist IP e i limiti di frequenza. Aggiungine uno per ogni altro proxy che aggiunge voci a X-Forwarded-For, come una CDN o un load balancer.

3. Riavvia Status200 sulle nuove porte#

   Bash

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

   npm start controlla http://localhost sulla porta 80, dove ci sarà il tuo proxy, quindi controlla tu la nuova porta. Lo script termina con Status200 is up!

4. Configura il proxy#

   CaddyNginx

   Caddy

   Caddyfile

   status200.example.com {
       reverse_proxy localhost:8080
   }

   Caddy ottiene e rinnova il certificato da solo, reindirizza HTTP su HTTPS e fa passare le connessioni WebSocket. Ricarica Caddy dopo aver modificato il file, per esempio con 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;
       }
   }

   I percorsi dei certificati sono quelli in cui Certbot mette un certificato Let's Encrypt; usa i percorsi del tuo certificato se viene da altrove. Controlla il file e ricarica Nginx con sudo nginx -t && sudo systemctl reload nginx.

   Entrambi inviano X-Forwarded-Proto, che dice a Status200 che un visitatore è arrivato in HTTPS. Anche qualsiasi altro proxy deve inviarlo, altrimenti i cookie di accesso delle pagine di stato e delle dashboard sui tuoi domini personalizzati non restano su HTTPS.

5. Apri la tua istanza tramite il proxy#

   Apri https://status200.example.com. Dovresti vedere la pagina di accesso di Status200, servita con il certificato del tuo proxy.

Indirizzi dei visitatori#

Status200 conta ogni visitatore in base all'indirizzo da cui si collega: i limiti di accesso, gli altri limiti per indirizzo e le allowlist IP delle pagine di stato e delle dashboard lo leggono tutti. Due configurazioni richiedono un'impostazione perché quell'indirizzo sia proprio quello del visitatore:

Senza IPv6 sulla rete di Status200, Docker passa a Status200 ogni visitatore che arriva via IPv6 da un indirizzo proprio, e Status200 li conta tutti come un solo visitatore: gli accessi non riusciti di una persona possono bloccare le altre. Attivare IPv6 richiede Docker Engine 27 o successivo (docker version mostra la tua).

1. Attiva IPv6#

   Crea docker-compose.override.yml accanto a docker-compose.yml, oppure aggiungi questo a quello che hai già; npm start e npm run update lo leggono:

   docker-compose.override.ymlYAML

   networks:
     oneuptime:
       enable_ipv6: true

2. Riavvia Status200#

   Bash

   npm stop
   npm start

   Status200 si ferma e riparte con IPv6 sulla sua rete. I tuoi dati restano. Docker non può rimuovere una rete a cui è ancora collegato un tuo container, come un reverse proxy: scollegalo prima dalla rete di Status200 e ricollegalo dopo. Se npm start si ferma con has active endpoints, scollegalo ed esegui di nuovo npm stop e npm start.

3. Controlla la rete#

   Bash

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

   Stampa "EnableIPv6": true,.

Quando più persone accedono da uno stesso indirizzo di rete privata, la pagina Integrità di Status200 dell'Admin Dashboard lo segnala, con l'impostazione che lo cambia.

Checklist per la produzione#

Docker Compose esegue una sola copia di ogni servizio su un unico server, il che si adatta a team piccoli e homelab. Prima di affidartici, ripassa questa lista.

Cambia la password del database#

PostgreSQL mantiene la password con cui è stato creato, quindi cambiare solo DATABASE_PASSWORD in config.env lascia Status200 fuori dal suo database. Per dare una password propria a un'installazione avviata con il segnaposto, cambiala in PostgreSQL e in config.env insieme, poi avvia di nuovo Status200:

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

Se hai impostato DATABASE_BACKUP_PASSWORD e DATABASE_RESTORE_PASSWORD, dai anche a loro il nuovo valore.

Backup e ripristino#

PostgreSQL contiene tutto ciò che configuri: monitor, incidenti, pagine di stato, utenti. npm run backup ne fa il dump in un file nella cartella Backups.

1. Dai allo script di backup la password del database#

   In config.env, imposta DATABASE_BACKUP_PASSWORD sul valore di DATABASE_PASSWORD. Lo script legge config.env come testo semplice, quindi il ${DATABASE_PASSWORD} fornito non viene mai sostituito.

2. Esegui il backup#

   Bash

   npm run backup

   Chiede la tua password di sudo e scrive Backups/db-<day of the month>.backup, così i backup giornalieri sostituiscono quelli di un mese prima. Eseguilo almeno una volta al giorno.

3. Copia i backup fuori dal server#

   Un backup sullo stesso disco del database non sopravvive alla perdita di quel disco.

Solo il server stesso raggiunge PostgreSQL: risponde sulla porta 5400 di 127.0.0.1. Per farne il backup da un'altra macchina, apri un tunnel SSH da quella macchina, poi connettiti alla sua porta 5400:

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

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

ClickHouse conserva la tua telemetria nel volume Docker status200_clickhouse, e nessuno script ne fa il backup. Se devi conservare quella telemetria, fai il backup del volume con uno strumento per ClickHouse come clickhouse-backup, oppure copialo mentre Status200 è fermo.

Per ripristinare PostgreSQL, imposta i valori DATABASE_RESTORE_* in config.env: DATABASE_RESTORE_PASSWORD sul valore di DATABASE_PASSWORD, come per i backup, e DATABASE_RESTORE_FILENAME sul backup da ripristinare, per esempio db-31.backup. Poi esegui bash restore.sh. Il database in cui ripristina deve già esistere; in un'installazione in funzione esiste.

Aggiornare Status200#

Fai prima un backup, poi esegui:

git checkout release
git pull
npm run update

npm run update chiede la tua password di sudo, aggiunge al tuo config.env le nuove impostazioni di config.example.env (i tuoi valori restano), scarica le nuove immagini e riavvia Status200. Come npm start, termina con Status200 is up!

Passare a una nuova versione major (dalla 13 alla 14, per esempio) può richiedere di più: leggi Aggiornamento di Status200 prima di iniziare.

APP_TAG=release in config.env scarica sempre l'ultima release della Community Edition. Per restare su una versione, imposta APP_TAG sul suo numero, per esempio 14.0.22. Per la Enterprise Edition, i tag sono enterprise-release e enterprise-14.0.22.

Disinstallare Status200#

Ferma Status200 e rimuovi i suoi container e la sua rete:

npm run down

I tuoi dati restano nei volumi status200_postgres e status200_clickhouse, e la cartella oneuptime conserva config.env e i tuoi backup. Per eliminare anche i dati:

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

Poi elimina la cartella oneuptime.

Risoluzione dei problemi#

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

Passi successivi#