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 mit curl 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 name@example.com -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
assetszu 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.
Klicke unten auf den Dashboard-Link, um die Anmeldeseite aufzurufen.
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.
Um einen neuen Dienst hinzuzufügen, klickst du auf die Schaltfläche Erstellen und gibst die erforderlichen Werte ein.
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.
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.