Come installare Statping su Ubuntu 22.04
Su questa pagina
- Prerequisiti
- Passaggio 1: configurazione del firewall
- Passaggio 2 - Installa Docker
- Passaggio 3 - Installa Nginx
- Passaggio 4 - Installa SSL
- Passaggio 5: configurazione del file di composizione Docker
- Passaggio 6 - Configura NGinx
- Passaggio 7 - Esegui Statping
- Passaggio 8 - Configura Statping
- Passaggio 9 - Aggiorna stapping
- Conclusione
Statping è un monitor del tempo di attività open source che tiene traccia dei siti Web e delle applicazioni ospitati su più server. Può generare una bellissima pagina di stato recuperando dati in tempo reale da varie fonti. Può funzionare con più sistemi di database tra cui SQLite, MySQL e Postgres. Per il nostro tutorial, utilizzeremo il fork di Statping, chiamato Statping-ng poiché l'applicazione originale non è più in fase di sviluppo.
In questo tutorial imparerai come installare Statping su un server Ubuntu 22.04 utilizzando Docker e il server Nginx come proxy.
Prerequisiti
-
A server running Ubuntu 22.04.
-
A non-root user with sudo privileges.
-
The uncomplicated Firewall(UFW) is enabled and running.
-
A Fully Qualified domain name (FQDN) pointing to the server like,
status.example.com. -
Everything is updated.
$ sudo apt update && sudo apt upgrade
Passaggio 1: configurare il firewall
Prima di installare qualsiasi pacchetto, il primo passo è configurare il firewall per consentire le connessioni HTTP e HTTPS.
Controlla lo stato del firewall.
$ sudo ufw status
Dovresti vedere qualcosa di simile al seguente.
Status: active To Action From -- ------ ---- OpenSSH ALLOW Anywhere OpenSSH (v6) ALLOW Anywhere (v6)
Consenti porte HTTP e HTTPs.
$ sudo ufw allow http $ sudo ufw allow https
Controlla di nuovo lo stato per confermare.
$ sudo ufw status Status: active To Action From -- ------ ---- OpenSSH ALLOW Anywhere 80/tcp ALLOW Anywhere 443 ALLOW Anywhere OpenSSH (v6) ALLOW Anywhere (v6) 80/tcp (v6) ALLOW Anywhere (v6) 443 (v6) ALLOW Anywhere (v6)
Passaggio 2: installa Docker
Aggiungi la chiave GPG ufficiale di Dockers.
$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker.gpg
Eseguire il comando seguente per aggiungere il repository Docker.
$ echo \ "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \ $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
Aggiorna il sistema per includere il repository Docker.
$ sudo apt update
Installa Docker e il plug-in di composizione Docker.
$ sudo apt-get install docker-ce docker-ce-cli containerd.io docker-compose-plugin
Questo tutorial utilizzerà il plug-in Docker Compose v2 invece del vecchio binario legacy. Pertanto, il comando per eseguirlo è cambiato da docker-compose a docker compose e questo si riflette qui.
Docker viene eseguito con privilegi elevati, quindi dovrai utilizzare sudo frequentemente per eseguire i comandi. L'opzione migliore è aggiungere il tuo account utente Linux al gruppo utenti docker.
$ sudo usermod -aG docker ${USER}
La variabile $ {USER} preleva l'account di sistema attualmente connesso. Se non hai effettuato l'accesso con l'utente a cui desideri concedere i privilegi, sostituisci $ {USER} con il nome utente.
Per richiedere la nuova appartenenza al gruppo, disconnettersi dal server e riconnettersi oppure utilizzare il seguente comando. Verrà richiesta la password dell'utente.
$ su - ${USER}
Passaggio 3: installa Nginx
Ubuntu 22.04 viene fornito con una versione precedente di Nginx. Per installare l'ultima versione, devi scaricare il repository Nginx ufficiale.
Importa la chiave di firma Nginxs.
$ curl https://nginx.org/keys/nginx_signing.key | gpg --dearmor \ | sudo tee /usr/share/keyrings/nginx-archive-keyring.gpg >/dev/null
Aggiungi il repository per la versione stabile di Nginxs.
$ echo "deb [signed-by=/usr/share/keyrings/nginx-archive-keyring.gpg arch=amd64] \ http://nginx.org/packages/ubuntu `lsb_release -cs` nginx" \ | sudo tee /etc/apt/sources.list.d/nginx.list
Aggiorna i repository di sistema.
$ sudo apt update
Installa Nginx.
$ sudo apt install nginx
Verificare l'installazione.
$ nginx -v nginx version: nginx/1.22.0
Passaggio 4: installa SSL
Dobbiamo installare Certbot per generare il certificato SSL. Puoi installare Certbot usando il repository Ubuntus o prendere l'ultima versione usando lo strumento Snapd. Useremo la versione Snapd.
Ubuntu 22.04 viene fornito con Snapd installato per impostazione predefinita. Esegui i seguenti comandi per assicurarti che la tua versione di Snapd sia aggiornata.
$ sudo snap install core
Installa Cerbot.
$ sudo snap install --classic certbot
Utilizzare il seguente comando per assicurarsi che il comando Certbot possa essere eseguito creando un collegamento simbolico alla directory /usr/bin.
$ sudo ln -s /snap/bin/certbot /usr/bin/certbot
Eseguire il seguente comando per generare un certificato SSL.
$ sudo certbot certonly --standalone --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m -d status.example.com
Il comando precedente scaricherà un certificato nella directory /etc/letsencrypt/live/status.example.com sul tuo server.
Genera un certificato di gruppo Diffie-Hellman.
$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096
Apri il file /etc/letsencrypt/renewal/status.example.com.conf per la modifica.
$ sudo nano /etc/letsencrypt/renewal/status.example.com.conf
Incolla il seguente codice in fondo.
pre_hook = systemctl stop nginx post_hook = systemctl start nginx
Salva il file premendo Ctrl + X e immettendo Y quando richiesto.
Abbiamo generato il certificato SSL utilizzando l'opzione standalone di Certbot. Esegue il suo server Web per creare il certificato, il che significa che Nginx dovrebbe essere spento durante il rinnovo. I comandi pre_hook e post_hook vengono eseguiti prima e dopo il rinnovo per arrestare e riavviare automaticamente il server Nginx, quindi non richiedono alcun intervento manuale.
Per verificare se il rinnovo SSL funziona correttamente, eseguire un'esecuzione a secco del processo.
$ sudo certbot renew --dry-run
Se non vedi errori, sei a posto. Il tuo certificato si rinnoverà automaticamente.
Passaggio 5: configurare Docker Compose File
Crea una directory per il file di composizione Docker.
$ mkdir ~/statping
Passa alla rubrica.
$ cd ~/statping
Crea e apri il file di composizione docker per la modifica.
$ nano docker-compose.yml
Incolla il seguente codice al suo interno.
services:
statping:
container_name: statping
image: adamboutcher/statping-ng
restart: always
ports:
- 8080:8080
volumes:
- ./statping_data:/app
links:
- postgres
depends_on:
- postgres
environment:
DB_CONN: postgres
DB_HOST: postgres
DB_PORT: 5432
DB_DATABASE: statping
DB_USER: root
DB_PASS: password123
NAME: 'Howtoforge Statping page'
DESCRIPTION: 'Statping Demo page'
USE_ASSETS: 'true'
SAMPLE_DATA: 'false'
ALLOW_REPORTS: 'false'
ADMIN_USER: navjot
ADMIN_PASSWORD: yourpassword
postgres:
container_name: postgres
image: postgres:14-alpine
ports:
- 5432:5432
volumes:
- ./pg_data:/var/lib/postgresql/data/pg_data
environment:
POSTGRES_PASSWORD: password123
POSTGRES_DB: statping
POSTGRES_USER: root
POSTGRES_PORT: 5432
PGDATA: /var/lib/postgresql/data/pg_data
Salva il file premendo Ctrl + X e immettendo Y quando richiesto.
Stiamo configurando le immagini docker di Statping e Postgres. La maggior parte del file docker è facile da seguire. Stiamo utilizzando i backup del disco locale per archiviare i dati dell'app e il database Postgres. Abbiamo anche configurato diverse variabili d'ambiente per configurare l'applicazione e il database. Diamo un'occhiata a loro. Per ottenere un elenco completo delle variabili di ambiente che puoi definire, controlla l'elenco ufficiale dal repository Statping GitHub.
- La variabile USE_ASSETS consente all'app di utilizzare le risorse dalla cartella
assets. - La variabile SAMPLE_DATA è impostata su false per disabilitare i monitor predefiniti configurati da Statping durante l'installazione.
- La variabile ALLOW_REPORTS è impostata su false per disabilitare i rapporti di errore anonimi che Statping invia.
- Le variabili ADMIN_USER e ADMIN_PASSWORD vengono utilizzate per impostare le informazioni di accesso per l'utente predefinito.
- Le variabili DB_ vengono utilizzate per impostare le credenziali del database che dovrebbero corrispondere alle variabili definite per il contenitore Postgres.
Passaggio 6: configurare NGinx
Apri il file /etc/nginx/nginx.conf per la modifica.
$ sudo nano /etc/nginx/nginx.conf
Aggiungere la riga seguente prima della riga include /etc/nginx/conf.d/*.conf;.
server_names_hash_bucket_size 64;
Salva il file premendo Ctrl + X e immettendo Y quando richiesto.
Crea e apri il file /etc/nginx/conf.d/statusping.conf per la modifica.
$ sudo nano /etc/nginx/conf.d/statusping.conf
Incolla il seguente codice al suo interno. Sostituisci status.example.com con il tuo nome di dominio.
upstream backend {
server 127.0.0.1:8080;
keepalive 32;
}
server {
listen 80 default_server;
server_name status.example.com;
return 301 https://$server_name$request_uri;
}
server {
listen 443 ssl http2;
server_name status.example.com;
http2_push_preload on; # Enable HTTP/2 Server Push
ssl_certificate /etc/letsencrypt/live/status.example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/status.example.com/privkey.pem;
ssl_trusted_certificate /etc/letsencrypt/live/status.example.com/chain.pem;
ssl_session_timeout 1d;
# Enable TLS versions (TLSv1.3 is required upcoming HTTP/3 QUIC).
ssl_protocols TLSv1.2 TLSv1.3;
# Enable TLSv1.3's 0-RTT. Use $ssl_early_data when reverse proxying to
# prevent replay attacks.
#
# @see: https://nginx.org/en/docs/http/ngx_http_ssl_module.html#ssl_early_data
ssl_early_data on;
ssl_ciphers 'ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA384';
ssl_prefer_server_ciphers on;
ssl_session_cache shared:SSL:50m;
# OCSP Stapling --- fetch OCSP records from URL in ssl_certificate and cache them
ssl_stapling on;
ssl_stapling_verify on;
ssl_dhparam /etc/ssl/certs/dhparam.pem;
add_header X-Early-Data $tls1_3_early_data;
access_log /var/log/nginx/statusping.access.log main;
error_log /var/log/nginx/statusping.error.log;
location / {
client_max_body_size 50M;
proxy_set_header Connection "";
proxy_set_header Host $http_host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
proxy_set_header X-Frame-Options SAMEORIGIN;
proxy_set_header X-Client-Verify SUCCESS;
proxy_set_header X-Client-DN $ssl_client_s_dn;
proxy_set_header X-SSL-Subject $ssl_client_s_dn;
proxy_set_header X-SSL-Issuer $ssl_client_i_dn;
proxy_buffers 256 16k;
proxy_buffer_size 16k;
proxy_read_timeout 1800s;
proxy_connect_timeout 1800s;
proxy_http_version 1.1;
proxy_pass http://backend;
}
}
# This block is useful for debugging TLS v1.3. Please feel free to remove this
# and use the `$ssl_early_data` variable exposed by NGINX directly should you
# wish to do so.
map $ssl_early_data $tls1_3_early_data {
"~." $ssl_early_data;
default "";
}
Salva il file premendo Ctrl + X e immettendo Y quando richiesto.
Verifica la configurazione di Nginx.
$ sudo nginx -t
Riavvia il server Nginx.
$ sudo systemctl restart nginx
Passaggio 7: eseguire Stapping
Passa alla directory Statping.
$ cd ~/statping
Crea e avvia il contenitore Docker.
$ docker compose up -d
Controlla lo stato del contenitore.
$ docker compose ps
Vedrai il seguente output.
NAME COMMAND SERVICE STATUS PORTS postgres "docker-entrypoint.s…" postgres running 0.0.0.0:5432->5432/tcp statping "/bin/sh -c 'statpin…" statping running (healthy) 0.0.0.0:8080->8080/tcp
Puoi anche utilizzare il comando docker ps per ottenere uno stato più dettagliato. Per controllare i log del contenitore, utilizzare il comando docker logs .
Passaggio 8: configurare lo stapping
Ora che il tuo contenitore è in esecuzione, avvia l'URL https://status.example.com nel tuo browser e vedrai una pagina di stato vuota. Se ometti la variabile SAMPLE_DATA nel file di composizione docker, vedrai una pagina intera con diversi servizi predefiniti.
Fare clic sul collegamento Dashboard in basso per accedere alla schermata di accesso.
Inserisci admin sia come nome utente predefinito che come password. Assicurati di digitare anche il nome utente, anche se sembra precompilato. Fai clic sul pulsante Accedi per accedere alla dashboard di Stapping.
Per aggiungere un nuovo servizio, fai clic sul pulsante Crea e inserisci i valori richiesti.
Fare clic sul pulsante Crea servizio in basso per terminare. Per configurare le email e altre notifiche, visita la pagina delle impostazioni. Puoi anche assegnare un nuovo nome alla tua pagina delle statistiche.
Passaggio 9: aggiornamento dello stato
L'aggiornamento di Statping è un passaggio semplice. Passa alla directory di composizione di Statpings Docker.
$ cd ~/statping
Successivamente, arresta e rimuovi il contenitore esistente. I tuoi dati verranno comunque conservati.
$ docker compose down --remove-orphans
Estrai l'ultima versione dell'immagine Docker Statping.
$ docker compose pull
Riavvia i contenitori.
$ docker compose up -d
L'installazione di Statping viene aggiornata e riavviata.
Conclusione
Questo conclude il tutorial in cui hai imparato come installare Statping su un server Ubuntu 22.04. Se hai domande, pubblicale nei commenti qui sotto.