So installierst du das Cachet-Statusseiten-System unter Debian 12

Cachet ist ein in PHP geschriebenes Open-Source-Statusseitensystem. Es ermöglicht es dir, Ausfallzeiten und Systemfehler in deiner Infrastruktur zu überwachen. Cachet bietet eine JSO-API, sogar Berichte, Metriken, mehrere Benachrichtigungsmethoden und eine Zwei-Faktor-Authentifizierung.

In der folgenden Anleitung zeigen wir dir, wie du die Cachet-Statusseite auf einem Debian 12-Server installierst. Du wirst Cachet als Docker-Container mit der PostgreSQL-Datenbank und dem Webserver Nginx betreiben.

Voraussetzungen

Bevor du fortfährst, solltest du sicherstellen, dass du Folgendes hast:

• Einen Debian 12 Server.
• Einen Nicht-Root-Benutzer mit sudo-Rechten.
• Eine UFW wurde installiert und konfiguriert.
• Einen Domainnamen, der auf eine Server-IP-Adresse zeigt.

Installation der Docker-Engine

In diesem Beispiel wirst du Cachet als Container über Docker installieren. Daher musst du die Docker-Engine auf deinem Debian-System installieren. In diesem Beispiel wirst du die offiziellen Docker-Engine-Pakete verwenden.

Führe zunächst den folgenden Befehl aus, um die Pakete curl und ca-certificates zu installieren.

sudo apt install ca-certificates curl -y

Füge nun den GPG-Schlüssel für das Docker-Repository hinzu, indem du den folgenden Befehl ausführst.

sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/debian/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc

Als Nächstes fügst du das Docker-Engine-Repository für das Debian-System mit folgendem Befehl hinzu.

echo \
"deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/debian \
$(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Sobald das Docker-Repository hinzugefügt ist, aktualisiere deinen Paketindex mit dem folgenden Befehl.

sudo apt update

Installiere nun die Docker Engine mit dem folgenden Befehl auf deinem System. Gib Y ein, um die Installation zu bestätigen.

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

Nachdem die Installation abgeschlossen ist, sollte der Docker-Dienst automatisch ausgeführt werden. Überprüfe den Status des Docker-Dienstes mit dem folgenden Befehl.

sudo systemctl status docker

Du wirst eine Ausgabe wie die folgende sehen:

Um sicherzustellen, dass dein Benutzer den Container ausführen kann, musst du ihn mit dem unten stehenden Befehl zur Docker-Gruppe hinzufügen.

sudo usermod -aG sudo alice

Melde dich schließlich als dein Benutzer an und führe den unten stehenden Docker-Befehl aus, um den Container hello-world zu starten.

su - alice
docker run hello-world

Wenn deine Konfiguration erfolgreich ist, solltest du die Ausgabe „Hello Docker“ wie die folgende erhalten:

Cachet mit Docker und PostgreSQL-Datenbank ausführen

Nachdem du Docker installiert hast, musst du das Cachet-Projekt herunterladen und deine Installation konfigurieren. In diesem Fall wirst du Cachet als Nicht-Root-Benutzer mit einem Docker-Container installieren und ausführen.

Lade das Cachet-Projekt in das cachet-docker-Verzeichnis herunter und gehe dorthin.

git clone https://github.com/cachethq/Docker.git cachet-docker
cd cachet-docker

Öffne die Datei docker-compose.yml mit dem folgenden Befehl des nano-Editors.

nano docker-compose.yml

Ändere den Standard-Host-Port wie folgt auf 8000. Du kannst auch die Datenbankdetails mit deinen Informationen anpassen und die Standardversion von Cachet auf 2.4 belassen.

 ports:
 - 8000:8000

Speichere die Datei und beende sie.

Führe nun die folgenden Docker-Befehle aus, um dein Cached-Image zu erstellen und Container für Cachet und PostgreSQL zu starten.

docker compose build
docker compose up

Unten siehst du den Screenshot, wenn du das Docker-Image für Cachet erstellst.

Unten siehst du den Screenshot, wenn du Container/Dienste sowohl für Cachet als auch für PostgreSQL ausführst.

In den Verbose-Logs des Cachet-Containers findest du einen Fehler bezüglich der APP_KEY-Konfiguration. Kopiere den generierten APP_KEY und drücke Strg+c, um die Container zu beenden.

Öffne die Datei docker-compose.yml erneut mit dem nano-Editor.

nano docker-compose.yml

Ändere den Standardparameter APP_KEY wie folgt. Achte darauf, dass du die base64-Zeichenkette einfügst.

APP_KEY=base64:WfKUhY0wAOyr5hkxoctZUSWPGdXbBUWFvNLCoI7kTU8=

Speichere die Datei und beende sie.

Führe nun den unten stehenden Docker-Befehl aus, um die Container für Cachet und PostgreSQL zu beenden, und starte sie dann erneut.

docker compose down
docker compose up -d

Sobald die Container gestartet sind, überprüfe die Liste der laufenden Container mit dem folgenden Befehl.

docker compose ps

Wie du unten sehen kannst, laufen sowohl der Cachet- als auch der PostgreSQL-Container. Der Cachet-Container läuft auf Port 8000.

Nginx als Reverse Proxy einrichten

Jetzt, wo Cachet als Container auf Port 8000 läuft, installierst und konfigurierst du Nginx als Reverse Proxy für Cachet.

Installiere Nginx auf deinem Debian-Server mit dem unten stehenden Befehl.

sudo apt install nginx -y

Sobald die Installation abgeschlossen ist, erstelle eine neue Nginx-Serverblockkonfiguration /etc/nginx/sites-available/cachet mit dem unten stehenden nano-Editor-Befehl.

sudo nano /etc/nginx/sites-available/cachet

Füge die unten stehende Konfiguration ein und achte darauf, dass du den Parameter server_name durch deinen Domainnamen ersetzt.

server {
 listen 80;
 server_name status.hwdomain.io;
 location / {
 proxy_pass http://127.0.0.1:8000;
 proxy_set_header Host $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;
 }
}

Speichere die Datei und beende den Editor.

Als Nächstes führst du den unten stehenden Nginx-Befehl aus, um den Cachet-Serverblock zu aktivieren und deine Nginx-Syntax zu überprüfen. Wenn du eine korrekte Syntax hast, solltest du die Ausgabe„Syntax ist ok“ erhalten.

sudo ln -s /etc/nginx/sites-available/cachet /etc/nginx/sites-enabled/
sudo nginx -t

Starte den Nginx-Webserver neu, um die Konfiguration des Cachet-Serverblocks zu übernehmen und überprüfe den Nginx-Dienst, um sicherzustellen, dass er läuft.

sudo systemctl restart nginx
sudo systemctl status nginx

Wenn Nginx läuft, solltest du die Ausgabe active(running) erhalten.

UFW (Unkomplizierte Firewall) einrichten

Bevor du auf Cachet zugreifen kannst, musst du sicherstellen, dass sowohl HTTP- als auch HTTPS-Ports zugelassen sind. Unter Ubuntu erlaubst du den Datenverkehr sowohl für HTTP als auch für HTTPS über die UFW (Uncomplicated Firewall).

Vergewissere dich, dass die UFW aktiviert ist und führe den folgenden Befehl aus, um das Profil„Nginx Full“ in der UFW zu aktivieren. Dadurch wird der Datenverkehr sowohl für HTTP- als auch für HTTPS-Protokolle zu deinem Nginx-Webserver zugelassen.

sudo ufw allow 'Nginx Full'

Überprüfe nun deine Liste der aktivierten Regeln in UFW mit dem folgenden Befehl.

sudo ufw status

Du wirst sehen, dass das Profil„Nginx Full“ in UFW aktiviert ist.

Cachet mit HTTPS absichern

Jetzt sollte dein Cachet über Nginx erreichbar sein. Um deine Installation zu sichern, aktivierst du HTTPS für Cachet über SSL von Letsencrypt.

Führe also den folgenden Befehl aus, um Certbot und das Certbot Nginx Plugin zu installieren. Gib Y ein, um die Installation zu bestätigen.

sudo apt install certbot python3-nginx-certbot

Sobald die Installation abgeschlossen ist, führe den folgenden Certbot-Befehl aus, um SSL/TLS-Zertifikate für deine Cachet-Installation zu erzeugen. Achte darauf, dass du die Angaben zum Domainnamen und zur E-Mail-Adresse mit deinen Daten abänderst.

sudo certbot --nginx --agree-tos --redirect --hsts --staple-ocsp --email alice@hwdomain.io -d status.hwdomain.io

Nachdem alles abgeschlossen ist, sollten deine SSL/TLS-Zertifikate im Verzeichnis /etc/lestencrypt/live/status.hwdomain.io gespeichert sein. Außerdem sollte dein Cachet über HTTPS gesichert sein.

Installation von Cachet

Starte deinen bevorzugten Webbrowser und besuche deine Cachet-Installation https://status.hwdomain.io/. Wenn deine Installation erfolgreich war, solltest du die folgende Seite erhalten.

Wähle den Standard Cache Driver, Queue Driver und Session Driver für die Datenbank aus. Gib dann die Daten deines Mailservers ein.

Klicke auf Weiter, um fortzufahren.

Lege nun den Namen der Statusseite, die Standardzeitzone und die Standardsprache fest. Klicke dann wieder auf Weiter.

Erstelle nun einen neuen Admin-Benutzer für Cachet, indem du deinen Benutzernamen, deine E-Mail-Adresse und dein Passwort eingibst. Klicke dann auf Einrichtung abschließen, um zu bestätigen.

Wenn du fertig bist, siehst du Folgendes: Klicke auf Zum Dashboard gehen.

Melde dich mit deinem Benutzernamen und Passwort bei Cache an und klicke dann auf Anmelden.

Wenn deine Installation erfolgreich war, solltest du das Cachet-Dashboard wie folgt sehen:

Fazit

Herzlichen Glückwunsch! Du hast jetzt die Cachet-Statusseite auf dem Debian 12-Server mit Docker installiert. Deine Cachet-Installation läuft mit einer PostgreSQL-Datenbank und einem Nginx-Webserver. Du kannst jetzt deine Websites mit Cachet überwachen.