So installieren Sie Statping auf Ubuntu 22.04

Statping ist ein Open-Source-Uptime-Monitor, der Websites und Anwendungen verfolgt, die auf mehreren Servern gehostet werden. Es kann eine schöne Statusseite generieren, indem es Echtzeitdaten aus verschiedenen Quellen abruft. Es kann mit mehreren Datenbanksystemen wie SQLite, MySQL und Postgres arbeiten. Für unser Tutorial verwenden wir den Fork von Statping, genannt Statping-ng, da die ursprüngliche Anwendung nicht mehr entwickelt wird.

In diesem Tutorial lernen Sie, wie Sie Statping auf einem Ubuntu 22.04-Server mit Docker und Nginx-Server als Proxy installieren.

Voraussetzungen

• Ein Server, der Ubuntu 22.04 ausführt.
• Ein Nicht-Root-Benutzer mit Sudo-Rechten.
• Die unkomplizierte Firewall (UFW) ist aktiviert und läuft.
• Ein vollständig qualifizierter Domainname (FQDN), der auf den Server zeigt, wie status.example.com.
• Alles ist aktualisiert. $ sudo apt update && sudo apt upgrade

Schritt 1 - Firewall konfigurieren

Bevor Sie Pakete installieren, besteht der erste Schritt darin, die Firewall so zu konfigurieren, dass HTTP- und HTTPS-Verbindungen erlaubt sind.

Überprüfen Sie den Status der Firewall.

$ sudo ufw status

Sie sollten etwas sehen, das wie folgt aussieht.

Status: aktiv

Zu                         Aktion      Von
--                         ------      ----
OpenSSH                    ERLAUBEN    Überall
OpenSSH (v6)               ERLAUBEN    Überall (v6)

Erlauben Sie HTTP- und HTTPS-Ports.

$ sudo ufw allow http
$ sudo ufw allow https

Überprüfen Sie den Status erneut, um zu bestätigen.

$ sudo ufw status
Status: aktiv

Zu                         Aktion      Von
--                         ------      ----
OpenSSH                    ERLAUBEN    Überall
80/tcp                     ERLAUBEN    Überall
443                        ERLAUBEN    Überall
OpenSSH (v6)               ERLAUBEN    Überall (v6)
80/tcp (v6)                ERLAUBEN    Überall (v6)
443 (v6)                   ERLAUBEN    Überall (v6)

Schritt 2 - Docker installieren

Fügen Sie den offiziellen GPG-Schlüssel von Docker hinzu.

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

Führen Sie den folgenden Befehl aus, um das Docker-Repository hinzuzufügen.

$ 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

Aktualisieren Sie das System, um das Docker-Repository einzuschließen.

$ sudo apt update

Installieren Sie Docker und das Docker-Compose-Plugin.

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

Dieses Tutorial verwendet das Docker Compose v2-Plugin anstelle des älteren Legacy-Binaries. Daher hat sich der Befehl zum Ausführen von docker-compose in docker compose geändert, und dies wird hier reflektiert.

Docker läuft mit erhöhten Rechten, daher müssen Sie häufig sudo verwenden, um Befehle auszuführen. Die bessere Option ist, Ihr Linux-Benutzerkonto zur docker-Benutzergruppe hinzuzufügen.

$ sudo usermod -aG docker ${USER}

Die ${USER}-Variable erfasst das aktuell angemeldete Systemkonto. Wenn Sie nicht mit dem Benutzer angemeldet sind, dem Sie Berechtigungen erteilen möchten, ersetzen Sie ${USER} durch den Benutzernamen.

Um die neue Gruppenmitgliedschaft anzuwenden, melden Sie sich vom Server ab und wieder an oder verwenden Sie den folgenden Befehl. Sie werden nach dem Passwort des Benutzers gefragt.

$ su - ${USER}

Schritt 3 - Nginx installieren

Ubuntu 22.04 wird mit einer älteren Version von Nginx ausgeliefert. Um die neueste Version zu installieren, müssen Sie das offizielle Nginx-Repository herunterladen.

Importieren Sie den Signaturschlüssel von Nginx.

$ curl https://nginx.org/keys/nginx_signing.key | gpg --dearmor \
| sudo tee /usr/share/keyrings/nginx-archive-keyring.gpg >/dev/null

Fügen Sie das Repository für die stabile Version von Nginx hinzu.

$ 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

Aktualisieren Sie die System-Repositorys.

$ sudo apt update

Installieren Sie Nginx.

$ sudo apt install nginx

Überprüfen Sie die Installation.

$ nginx -v
nginx version: nginx/1.22.0

Schritt 4 - SSL installieren

Wir müssen Certbot installieren, um das SSL-Zertifikat zu generieren. Sie können Certbot entweder über das Ubuntu-Repository installieren oder die neueste Version mit dem Snapd-Tool herunterladen. Wir werden die Snapd-Version verwenden.

Ubuntu 22.04 wird standardmäßig mit Snapd ausgeliefert. Führen Sie die folgenden Befehle aus, um sicherzustellen, dass Ihre Version von Snapd auf dem neuesten Stand ist.

$ sudo snap install core

Installieren Sie Certbot.

$ sudo snap install --classic certbot

Verwenden Sie den folgenden Befehl, um sicherzustellen, dass der Certbot-Befehl ausgeführt werden kann, indem Sie einen symbolischen Link zum Verzeichnis /usr/bin erstellen.

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

Führen Sie den folgenden Befehl aus, um ein SSL-Zertifikat zu generieren.

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

Der obige Befehl lädt ein Zertifikat in das Verzeichnis /etc/letsencrypt/live/status.example.com auf Ihrem Server herunter.

Generieren Sie ein Diffie-Hellman-Gruppe-Zertifikat.

$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096

Öffnen Sie die Datei /etc/letsencrypt/renewal/status.example.com.conf zur Bearbeitung.

$ sudo nano /etc/letsencrypt/renewal/status.example.com.conf

Fügen Sie den folgenden Code am Ende ein.

pre_hook = systemctl stop nginx
post_hook = systemctl start nginx

Speichern Sie die Datei, indem Sie Ctrl + X drücken und bei Aufforderung Y eingeben.

Wir haben das SSL-Zertifikat mit der Standalone-Option von Certbot generiert. Es betreibt seinen eigenen Webserver, um das Zertifikat zu erstellen, was bedeutet, dass Nginx während der Erneuerung abgeschaltet werden sollte. Die pre_hook- und post_hook-Befehle werden vor und nach der Erneuerung ausgeführt, um den Nginx-Server automatisch zu stoppen und neu zu starten, sodass keine manuelle Intervention erforderlich ist.

Um zu überprüfen, ob die SSL-Erneuerung einwandfrei funktioniert, führen Sie einen Testlauf des Prozesses durch.

$ sudo certbot renew --dry-run

Wenn Sie keine Fehler sehen, sind Sie bereit. Ihr Zertifikat wird automatisch erneuert.

Schritt 5 - Docker-Compose-Datei konfigurieren

Erstellen Sie ein Verzeichnis für die Docker-Compose-Datei.

$ mkdir ~/statping

Wechseln Sie in das Verzeichnis.

$ cd ~/statping

Erstellen und öffnen Sie die Docker-Compose-Datei zur Bearbeitung.

$ nano docker-compose.yml

Fügen Sie den folgenden Code ein.

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

Speichern Sie die Datei, indem Sie Ctrl + X drücken und bei Aufforderung Y eingeben.

Wir richten die Statping- und Postgres-Docker-Images ein. Der Großteil der Docker-Datei ist leicht zu befolgen. Wir verwenden lokale Datensicherungen, um die Anwendungsdaten und die Postgres-Datenbank zu speichern. Wir haben auch mehrere Umgebungsvariablen konfiguriert, um die Anwendung und die Datenbank zu konfigurieren. Lassen Sie uns einen Blick darauf werfen. Um eine vollständige Liste der Umgebungsvariablen zu erhalten, die Sie definieren können, überprüfen Sie die offizielle Liste im Statping-GitHub-Repository.

• Die USE_ASSETS-Variable ermöglicht es der App, die Assets aus dem assets-Ordner zu verwenden.
• Die SAMPLE_DATA-Variable ist auf false gesetzt, um die Standardmonitore zu deaktivieren, die Statping während der Installation konfiguriert.
• Die ALLOW_REPORTS-Variable ist auf false gesetzt, um die anonymen Fehlermeldungen, die Statping sendet, zu deaktivieren.
• Die ADMIN_USER- und ADMIN_PASSWORD-Variablen werden verwendet, um die Anmeldeinformationen für den Standardbenutzer festzulegen.
• Die DB_-Variablen werden verwendet, um die Datenbankanmeldeinformationen festzulegen, die mit den Variablen übereinstimmen sollten, die für den Postgres-Container definiert sind.

Schritt 6 - Nginx konfigurieren

Öffnen Sie die Datei /etc/nginx/nginx.conf zur Bearbeitung.

$ sudo nano /etc/nginx/nginx.conf

Fügen Sie die folgende Zeile vor der Zeile include /etc/nginx/conf.d/*.conf; hinzu.

server_names_hash_bucket_size  64;

Speichern Sie die Datei, indem Sie Ctrl + X drücken und bei Aufforderung Y eingeben.

Erstellen und öffnen Sie die Datei /etc/nginx/conf.d/statusping.conf zur Bearbeitung.

$ sudo nano /etc/nginx/conf.d/statusping.conf

Fügen Sie den folgenden Code ein. Ersetzen Sie status.example.com durch Ihren Domainnamen.

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; # HTTP/2 Server Push aktivieren

   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;

   # TLS-Versionen aktivieren (TLSv1.3 ist für das kommende HTTP/3 QUIC erforderlich).
   ssl_protocols TLSv1.2 TLSv1.3;

   # Aktivieren Sie TLSv1.3's 0-RTT. Verwenden Sie $ssl_early_data, wenn Sie einen Reverse-Proxy verwenden,
   # um Wiederholungsangriffe zu verhindern.
   #
   # @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 --- OCSP-Datensätze von der URL im ssl_certificate abrufen und cachen
   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;
   }
}

# Dieser Block ist nützlich zur Fehlersuche bei TLS v1.3. Bitte entfernen Sie dies
# und verwenden Sie die von NGINX direkt bereitgestellte `$ssl_early_data`-Variable, wenn Sie
# dies wünschen.
map $ssl_early_data $tls1_3_early_data {
  "~." $ssl_early_data;
  default "";
}

Speichern Sie die Datei, indem Sie Ctrl + X drücken und bei Aufforderung Y eingeben.

Überprüfen Sie Ihre Nginx-Konfiguration.

$ sudo nginx -t

Starten Sie den Nginx-Server neu.

$ sudo systemctl restart nginx

Schritt 7 - Statping ausführen

Wechseln Sie in das Statping-Verzeichnis.

$ cd ~/statping

Erstellen und starten Sie den Docker-Container.

$ docker compose up -d

Überprüfen Sie den Status des Containers.

$ docker compose ps

Sie werden die folgende Ausgabe sehen.

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

Sie können auch den Befehl docker ps verwenden, um einen detaillierteren Status zu erhalten. Um die Containerprotokolle zu überprüfen, verwenden Sie den Befehl docker logs .

Schritt 8 - Statping konfigurieren

Jetzt, da Ihr Container läuft, öffnen Sie die URL https://status.example.com in Ihrem Browser und Sie sehen eine leere Statusseite. Wenn Sie die Variable SAMPLE_DATA in der Docker-Compose-Datei weglassen, sehen Sie eine vollständige Seite mit verschiedenen vordefinierten Diensten.

Klicken Sie auf den Dashboard-Link am Ende, um zum Anmeldebildschirm zu gelangen.

Geben Sie admin sowohl als Standardbenutzernamen als auch als Passwort ein. Stellen Sie sicher, dass Sie den Benutzernamen eingeben, auch wenn er vorab ausgefüllt aussieht. Klicken Sie auf die Schaltfläche Anmelden, um auf das Statping-Dashboard zuzugreifen.

Um einen neuen Dienst hinzuzufügen, klicken Sie auf die Schaltfläche Erstellen und füllen Sie die erforderlichen Werte aus.

Klicken Sie auf die Schaltfläche Dienst erstellen am Ende, um abzuschließen. Um E-Mail- und andere Benachrichtigungen zu konfigurieren, besuchen Sie die Einstellungsseite. Sie können Ihrer Statusseite auch einen neuen Namen geben.

Schritt 9 - Statping aktualisieren

Das Upgrade von Statping ist ein einfacher Schritt. Wechseln Sie in das Docker-Compose-Verzeichnis von Statping.

$ cd ~/statping

Stoppen und entfernen Sie dann den vorhandenen Container. Ihre Daten bleiben jedoch erhalten.

$ docker compose down --remove-orphans

Holen Sie sich die neueste Version des Statping-Docker-Images.

$ docker compose pull

Starten Sie die Container erneut.

$ docker compose up -d

Ihre Statping-Installation ist aktualisiert und wurde erneut gestartet.

Fazit

Damit endet das Tutorial, in dem Sie gelernt haben, wie Sie Statping auf einem Ubuntu 22.04-Server installieren. Wenn Sie Fragen haben, posten Sie diese in den Kommentaren unten.