So installierst du Statping unter Ubuntu 22.04

Statping ist ein Open-Source-Uptime-Monitor, der die Verfügbarkeit von Websites und Anwendungen auf mehreren Servern überwacht. Es kann eine schöne Statusseite erstellen, indem es Echtzeitdaten aus verschiedenen Quellen abruft. Es kann mit verschiedenen Datenbanksystemen arbeiten, darunter SQLite, MySQL und Postgres. Für unseren Lehrgang verwenden wir den Fork von Statping, genannt Statping-ng, da die ursprüngliche Anwendung nicht mehr weiterentwickelt wird.

In diesem Tutorium lernst du, wie du Statping auf einem Ubuntu 22.04 Server mit Docker und Nginx Server als Proxy installierst.

Voraussetzungen

  • Ein Server mit Ubuntu 22.04.
  • Ein Nicht-Root-Benutzer mit sudo-Rechten.
  • Die Unkomplizierte Firewall (UFW) ist aktiviert und läuft.
  • Ein Fully Qualified Domain Name (FQDN), der auf den Server zeigt, z. B. status.example.com.
  • Alles ist auf dem neuesten Stand.
    $ sudo apt update && sudo apt upgrade
    

Schritt 1 – Firewall konfigurieren

Bevor du die Pakete installierst, musst du zunächst die Firewall so konfigurieren, dass HTTP- und HTTPS-Verbindungen zugelassen werden.

Überprüfe den Status der Firewall.

$ sudo ufw status

Du solltest etwas wie das Folgende sehen.

Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere
OpenSSH (v6)               ALLOW       Anywhere (v6)

Erlaube HTTP- und HTTPs-Ports.

$ sudo ufw allow http
$ sudo ufw allow https

Überprüfe den Status zur Bestätigung noch einmal.

$ 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)

Schritt 2 – Installiere Docker

Füge 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ühre 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

Aktualisiere das System, um das Docker-Repository aufzunehmen.

$ sudo apt update

Installiere Docker und das Docker Compose Plugin.

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

In diesem Lehrgang wird das Docker Compose v2 Plugin anstelle des älteren Legacy Binary verwendet. Daher hat sich der Befehl zum Ausführen des Plugins von docker-compose auf docker compose geändert, was sich hier widerspiegelt.

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

$ sudo usermod -aG docker ${USER}

Die Variable ${USER} nimmt das aktuell eingeloggte Systemkonto auf. Wenn du nicht mit dem Benutzer eingeloggt bist, dem du Privilegien geben willst, ersetze ${USER} durch den Benutzernamen.

Um die neue Gruppenmitgliedschaft zu beantragen, melde dich vom Server ab und wieder an oder verwende den folgenden Befehl. Du wirst aufgefordert, das Passwort des Benutzers einzugeben.

$ su - ${USER}

Schritt 3 – Nginx installieren

Ubuntu 22.04 wird mit einer älteren Version von Nginx ausgeliefert. Um die neueste Version zu installieren, musst du das offizielle Nginx-Repository herunterladen.

Importiere den Signierschlü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üge 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

Aktualisiere die System-Repositories.

$ sudo apt update

Installiere Nginx.

$ sudo apt install nginx

Überprüfe die Installation.

$ nginx -v
nginx version: nginx/1.22.0

Schritt 4 – SSL installieren

Wir müssen Certbot installieren, um das SSL-Zertifikat zu erzeugen. Du kannst Certbot entweder über das Repository von Ubuntu installieren oder die neueste Version mit dem Snapd-Tool herunterladen. Wir werden die Snapd-Version verwenden.

Bei Ubuntu 22.04 ist Snapd standardmäßig installiert. Führe die folgenden Befehle aus, um sicherzustellen, dass deine Version von Snapd auf dem neuesten Stand ist.

$ sudo snap install core

Installiere Certbot.

$ sudo snap install --classic certbot

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

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

Führe den folgenden Befehl aus, um ein SSL-Zertifikat zu erzeugen.

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

Mit dem obigen Befehl wird ein Zertifikat in das Verzeichnis /etc/letsencrypt/live/status.example.com auf deinem Server heruntergeladen.

Erstelle ein Diffie-Hellman-Gruppenzertifikat.

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

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

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

Füge den folgenden Code am Ende der Datei ein.

pre_hook = systemctl stop nginx
post_hook = systemctl start nginx

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Wir haben das SSL-Zertifikat mit der Standalone-Option von Certbot erstellt. Es lässt seinen Webserver laufen, um das Zertifikat zu erstellen, was bedeutet, dass Nginx während der Erneuerung abgeschaltet sein sollte. Die Befehle pre_hook und post_hook werden vor und nach der Erneuerung ausgeführt, um den Nginx-Server automatisch abzuschalten und neu zu starten, sodass kein manuelles Eingreifen erforderlich ist.

Um zu überprüfen, ob die SSL-Erneuerung einwandfrei funktioniert, führe einen Probelauf des Prozesses durch.

$ sudo certbot renew --dry-run

Wenn du keine Fehler siehst, ist alles in Ordnung. Dein Zertifikat wird automatisch erneuert.

Schritt 5 – Docker Compose-Datei konfigurieren

Erstelle ein Verzeichnis für die Docker-Kompositionsdatei.

$ mkdir ~/statping

Wechsle in das Verzeichnis.

$ cd ~/statping

Erstelle und öffne die Docker Compose Datei zur Bearbeitung.

$ nano docker-compose.yml

Füge den folgenden Code in die Datei 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

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Wir richten Statping- und Postgres-Docker-Images ein. Der größte Teil der Docker-Datei ist einfach zu befolgen. Wir verwenden lokale Festplatten-Backups, um die App-Daten und die Postgres-Datenbank zu speichern. Außerdem haben wir mehrere Umgebungsvariablen konfiguriert, um die Anwendung und die Datenbank zu konfigurieren. Lass uns einen Blick darauf werfen. Eine vollständige Liste der Umgebungsvariablen, die du definieren kannst, findest du in der offiziellen Liste im Statping GitHub Repository.

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

Schritt 6 – NGinx konfigurieren

Öffne die Datei /etc/nginx/nginx.conf zum Bearbeiten.

$ sudo nano /etc/nginx/nginx.conf

Füge die folgende Zeile vor der Zeile include /etc/nginx/conf.d/*.conf; ein.

server_names_hash_bucket_size  64;

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Erstelle und öffne die Datei /etc/nginx/conf.d/statusping.conf zum Bearbeiten.

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

Füge den folgenden Code in die Datei ein. Ersetze status.example.com durch deinen 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; # 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 "";
}

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Überprüfe deine Nginx-Konfiguration.

$ sudo nginx -t

Starte den Nginx-Server neu.

$ sudo systemctl restart nginx

Schritt 7 – Statping ausführen

Wechsle in das Verzeichnis Statping.

$ cd ~/statping

Erstelle und starte den Docker-Container.

$ docker compose up -d

Überprüfe den Status des Containers.

$ docker compose ps

Du wirst 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

Du kannst auch den Befehl docker ps verwenden, um einen detaillierteren Status zu erhalten. Um die Container-Logs zu überprüfen, verwende den Befehl docker logs <container name>.

Schritt 8 – Statping konfigurieren

Wenn dein Container jetzt läuft, rufe die URL https://status.example.com in deinem Browser auf und du siehst eine leere Statusseite. Wenn du die Variable SAMPLE_DATA in der Docker-Compose-Datei weglässt, siehst du eine vollständige Seite mit verschiedenen vordefinierten Diensten.

Statping Status Seite

Klicke unten auf den Dashboard-Link, um die Anmeldeseite aufzurufen.

Statping Anmeldebildschirm

Gib admin als Standardbenutzernamen und als Passwort ein. Achte darauf, dass du auch den Benutzernamen eingibst, auch wenn es so aussieht, als sei er bereits ausgefüllt. Klicke auf die Schaltfläche Anmelden, um das Statping-Dashboard aufzurufen.

Statping Dashboard

Um einen neuen Dienst hinzuzufügen, klickst du auf die Schaltfläche Erstellen und gibst die erforderlichen Werte ein.

Statping Dienst erstellen

Klicke unten auf die Schaltfläche Dienst erstellen, um den Vorgang abzuschließen. Um E-Mail- und andere Benachrichtigungen zu konfigurieren, besuche die Seite mit den Einstellungen. Du kannst deiner Statistikseite auch einen neuen Namen geben.

Stating-Statusseite mit Live-Service

Schritt 9 – Statping aktualisieren

Die Aktualisierung von Statping ist ein einfacher Schritt. Wechsle in das Docker-Compose-Verzeichnis von Statping.

$ cd ~/statping

Als Nächstes stoppst du den bestehenden Container und entfernst ihn. Deine Daten bleiben jedoch erhalten.

$ docker compose down --remove-orphans

Ziehe die neueste Version des Statping-Docker-Images.

$ docker compose pull

Starte die Container erneut.

$ docker compose up -d

Deine Statping-Installation wird aktualisiert und neu gestartet.

Fazit

Damit ist das Tutorial abgeschlossen, in dem du gelernt hast, wie du Statping auf einem Ubuntu 22.04 Server installierst. Wenn du Fragen hast, schreibe sie unten in die Kommentare.

Das könnte dich auch interessieren …