Come installare Statping su Ubuntu 22.04

Statping è un monitor di uptime open-source che tiene traccia di siti web e applicazioni ospitati su più server. Può generare una bellissima pagina di stato estraendo 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 Nginx come proxy.

Prerequisiti

• Un server che esegue Ubuntu 22.04.
• Un utente non root con privilegi sudo.
• Il Firewall semplice (UFW) è abilitato e in esecuzione.
• Un nome di dominio completamente qualificato (FQDN) che punta al server come status.example.com.
• Tutto è aggiornato. $ sudo apt update && sudo apt upgrade

Passo 1 - Configurare il Firewall

Prima di installare qualsiasi pacchetto, il primo passo è configurare il firewall per consentire 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 le 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)

Passo 2 - Installare Docker

Aggiungi la chiave GPG ufficiale di Docker.

$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker.gpg

Esegui il seguente comando per aggiungere il repository di 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 di Docker.

$ sudo apt update

Installa Docker e il plugin Docker compose.

$ sudo apt-get install docker-ce docker-ce-cli containerd.io docker-compose-plugin

Questo tutorial utilizzerà il plugin Docker Compose v2 invece del vecchio binario legacy. Pertanto, il comando per eseguirlo è cambiato da docker-compose a docker compose e questo è riflesso qui.

Docker viene eseguito con privilegi elevati, quindi dovrai usare sudo frequentemente per eseguire comandi. L’opzione migliore è aggiungere il tuo account utente Linux al gruppo docker.

$ sudo usermod -aG docker ${USER}

La variabile ${USER} prende l’account di sistema attualmente connesso. Se non sei connesso con l’utente a cui vuoi dare privilegi, sostituisci ${USER} con il nome utente.

Per applicare la nuova appartenenza al gruppo, disconnettiti dal server e riconnettiti, oppure usa il seguente comando. Ti verrà chiesto di inserire la password dell’utente.

$ su - ${USER}

Passo 3 - Installare Nginx

Ubuntu 22.04 viene fornito con una versione più vecchia di Nginx. Per installare l’ultima versione, devi scaricare il repository ufficiale di Nginx.

Importa la chiave di firma di Nginx.

$ 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 Nginx.

$ 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

Verifica l’installazione.

$ nginx -v
nginx version: nginx/1.22.0

Passo 4 - Installare SSL

Dobbiamo installare Certbot per generare il certificato SSL. Puoi installare Certbot utilizzando il repository di Ubuntu o scaricare l’ultima versione utilizzando lo strumento Snapd. Utilizzeremo 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 Certbot.

$ sudo snap install --classic certbot

Usa il seguente comando per assicurarti che il comando Certbot possa essere eseguito creando un collegamento simbolico alla directory /usr/bin.

$ sudo ln -s /snap/bin/certbot /usr/bin/certbot

Esegui il seguente comando per generare un certificato SSL.

$ sudo certbot certonly --standalone --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m [email protected] -d status.example.com

Il comando sopra scaricherà un certificato nella directory /etc/letsencrypt/live/status.example.com sul tuo server.

Genera un certificato Diffie-Hellman group.

$ 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 inserendo Y quando richiesto.

Abbiamo generato il certificato SSL utilizzando l’opzione standalone di Certbot. Esegue il proprio 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 spegnere e riavviare automaticamente il server Nginx, richiedendo quindi nessun intervento manuale.

Per controllare se il rinnovo SSL funziona correttamente, esegui un test del processo.

$ sudo certbot renew --dry-run

Se non vedi errori, sei a posto. Il tuo certificato si rinnoverà automaticamente.

Passo 5 - Configurare il file Docker Compose

Crea una directory per il file Docker compose.

$ mkdir ~/statping

Passa alla directory.

$ cd ~/statping

Crea e apri il file docker compose per la modifica.

$ nano docker-compose.yml

Incolla il seguente codice in esso.

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: 'Come creare una pagina Statping'
      DESCRIPTION: 'Pagina demo di Statping'
      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 inserendo Y quando richiesto.

Stiamo configurando le immagini Docker di Statping e Postgres. La maggior parte del file docker è facile da seguire. Stiamo utilizzando backup su disco locale per memorizzare i dati dell’app e il database Postgres. Abbiamo anche configurato diverse variabili ambientali per configurare l’applicazione e il database. Diamo un’occhiata a loro. Per ottenere un elenco completo delle variabili ambientali che puoi definire, controlla l’elenco ufficiale del repository GitHub di Statping.

• 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 che Statping configura durante l’installazione.
• La variabile ALLOW_REPORTS è impostata su false per disabilitare i rapporti di errore anonimi inviati da Statping.
• 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.

Passo 6 - Configurare Nginx

Apri il file /etc/nginx/nginx.conf per la modifica.

$ sudo nano /etc/nginx/nginx.conf

Aggiungi la seguente riga prima della riga include /etc/nginx/conf.d/*.conf;.

server_names_hash_bucket_size  64;

Salva il file premendo Ctrl + X e inserendo 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 in esso. 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; # Abilita 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;

   # Abilita le versioni TLS (TLSv1.3 è richiesto per il prossimo HTTP/3 QUIC).
   ssl_protocols TLSv1.2 TLSv1.3;

   # Abilita 0-RTT di TLSv1.3. Usa $ssl_early_data quando si fa reverse proxy per
   # prevenire attacchi di replay.
   #
   # @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 --- recupera i record OCSP dall'URL nel ssl_certificate e memorizzali nella cache
   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;
   }
}

# Questo blocco è utile per il debug di TLS v1.3. Sentiti libero di rimuovere questo
# e utilizzare direttamente la variabile `$ssl_early_data` esposta da NGINX se lo desideri.
map $ssl_early_data $tls1_3_early_data {
  "~." $ssl_early_data;
  default "";
}

Salva il file premendo Ctrl + X e inserendo Y quando richiesto.

Verifica la tua configurazione Nginx.

$ sudo nginx -t

Riavvia il server Nginx.

$ sudo systemctl restart nginx

Passo 7 - Eseguire Statping

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 usare il comando docker ps per ottenere uno stato più dettagliato. Per controllare i log del contenitore, usa il comando docker logs .

Passo 8 - Configurare Statping

Ora che il tuo contenitore è in esecuzione, lancia l’URL https://status.example.com nel tuo browser e vedrai una pagina di stato vuota. Se ometti la variabile SAMPLE_DATA nel file docker compose, vedrai una pagina completa con diversi servizi predefiniti.

Clicca sul link Dashboard in fondo per accedere alla schermata di accesso.

Compila admin sia come nome utente predefinito che come password. Assicurati di digitare il nome utente anche se sembra precompilato. Clicca sul pulsante Accedi per accedere alla dashboard di Statping.

Per aggiungere un nuovo servizio, clicca sul pulsante Crea e compila i valori richiesti.

Clicca sul pulsante Crea servizio in fondo per terminare. Per configurare email e altre notifiche, visita la pagina delle impostazioni. Puoi anche dare un nuovo nome alla tua pagina delle statistiche.

Passo 9 - Aggiornare Statping

Aggiornare Statping è un passaggio semplice. Passa alla directory Docker compose di Statping.

$ cd ~/statping

Successivamente, ferma e rimuovi il contenitore esistente. I tuoi dati verranno comunque mantenuti.

$ docker compose down --remove-orphans

Scarica l’ultima versione dell’immagine Docker di Statping.

$ docker compose pull

Avvia di nuovo i contenitori.

$ docker compose up -d

La tua installazione di Statping è aggiornata e avviata di nuovo.

Conclusione

Questo conclude il tutorial in cui hai imparato come installare Statping su un server Ubuntu 22.04. Se hai domande, postale nei commenti qui sotto.