So installierst du Plausible Analytics unter Debian 12
Plausible ist eine datenschutzfreundliche Open-Source-Analysesoftware, mit der du die Besucherzahlen deiner Website verfolgen kannst. Es ist eine leichtgewichtige Alternative zu Google Analytics, mit der du Besucher/innen verfolgen kannst, ohne Kompromisse beim Datenschutz einzugehen. Sie unterstützt GDPR und verwendet keine Cookies. Du kannst die Statistiken in einem modern gestalteten Dashboard einsehen, und das Tracking-Skript ist minimal und verlangsamt deine Website nicht. Du kannst Plausible entweder selbst hosten oder ein Abonnement abschließen.
In dieser Anleitung werden wir Plausible Analytics mit Docker auf einem Debian 12 Server installieren.
Voraussetzungen
- Ein Server, auf dem Debian 12 läuft.
- Ein Nicht-Root-Benutzer mit sudo-Rechten.
- Ein vollständig qualifizierter Domainname (FQDN) wie
plausible.example.com, der auf den Server zeigt. - Die Uncomplicated Firewall (UFW) ist aktiviert und läuft.
- Aktualisiere alles.
$ sudo apt update && sudo apt upgrade
- Installiere wichtige Pakete, die dein System braucht. Einige dieser Pakete sind vielleicht schon auf deinem System installiert.
$ sudo apt install wget curl nano ufw software-properties-common dirmngr apt-transport-https gnupg2 ca-certificates lsb-release debian-archive-keyring unzip -y
Schritt 1 – Firewall konfigurieren
Der erste Schritt besteht darin, die Firewall zu konfigurieren. Ubuntu wird standardmäßig mit ufw (Uncomplicated Firewall) ausgeliefert.
Überprüfe, ob die Firewall läuft.
$ sudo ufw status
Du solltest die folgende Ausgabe erhalten.
Status: inactive
Erlaube den SSH-Port, damit die Firewall die aktuelle Verbindung nicht unterbricht, wenn du sie aktivierst.
$ sudo ufw allow OpenSSH
Lasse auch HTTP- und HTTPS-Ports zu.
$ sudo ufw allow http $ sudo ufw allow https
Aktiviere die Firewall
$ sudo ufw enable Command may disrupt existing ssh connections. Proceed with operation (y|n)? y Firewall is active and enabled on system startup
Überprüfe den Status der Firewall erneut.
$ sudo ufw status
Du solltest eine ähnliche Ausgabe sehen.
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 – Git installieren
Git wird benötigt, um das offizielle Repository von Plausible zu klonen. Installiere Git.
$ sudo apt install git
Überprüfe die Installation.
$ git --version git version 2.39.2
Setze die ersten Konfigurationsvariablen.
$ git config --global user.name "Your Name" $ git config --global user.email "email@example.com"
Schritt 3 – Installiere Docker und Docker Compose
Wir müssen Docker über das offizielle Repository installieren. Füge den offiziellen GPG-Schlüssel von Docker hinzu.
$ curl -fsSL https://download.docker.com/linux/debian/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker.gpg
Füge das Docker-Repository zum System hinzu.
$ echo \ "deb [arch="$(dpkg --print-architecture)" signed-by=/usr/share/keyrings/docker.gpg] https://download.docker.com/linux/debian \ "$(. /etc/os-release && echo "$VERSION_CODENAME")" stable" | \ sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
Aktualisiere die APT-Repository-Liste und installiere Docker.
$ sudo apt update $ sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
Überprüfe, ob die Docker-Engine korrekt installiert ist.
$ docker --version Docker version 24.0.6, build ed223bc
Führe die folgenden Befehle aus, damit du nicht sudo verwenden musst, um Docker-Befehle auszuführen.
$ sudo usermod -aG docker ${USER}
$ su - ${USER}
Damit ist der Abschnitt über die Installation von Docker und Docker compose abgeschlossen.
Schritt 4 – Nginx installieren
Debian 12 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] \
http://nginx.org/packages/debian `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. Auf Debian-Systemen funktioniert der folgende Befehl nur mit sudo.
$ sudo nginx -v nginx version: nginx/1.24.0
Starte Nginx.
$ sudo systemctl start nginx
Überprüfe den Status des Dienstes.
$ sudo systemctl status nginx
? nginx.service - nginx - high performance web server
Loaded: loaded (/lib/systemd/system/nginx.service; enabled; preset: enabled)
Active: active (running) since Wed 2023-10-11 01:35:15 UTC; 3s ago
Docs: https://nginx.org/en/docs/
Process: 3598 ExecStart=/usr/sbin/nginx -c /etc/nginx/nginx.conf (code=exited, status=0/SUCCESS)
Main PID: 3599 (nginx)
Tasks: 3 (limit: 4652)
Memory: 2.4M
CPU: 8ms
CGroup: /system.slice/nginx.service
??3599 "nginx: master process /usr/sbin/nginx -c /etc/nginx/nginx.conf"
??3600 "nginx: worker process"
??3601 "nginx: worker process"
Oct 11 01:35:15 plausible systemd[1]: Starting nginx.service - nginx - high performance web server...
Oct 11 01:35:15 plausible systemd[1]: Started nginx.service - nginx - high performance web server.
Schritt 5 – Plausible herunterladen
Klone das Plausible Self-Hosting GitHub Repository.
$ git clone https://github.com/plausible/hosting
Wechsle in das heruntergeladene Verzeichnis.
$ cd hosting
Schritt 6 – Plausible konfigurieren
In dem heruntergeladenen Verzeichnis findest du die folgenden Dateien.
docker-compose.yml– Sie enthalten die Einstellungen für das Docker Compose Tool, um den Plausible Server und alles, was er braucht, zu installieren. Plausible braucht den PostgreSQL-Server für die Datenbank und die Clickhouse-Datenbank für die Statistiken. Außerdem kann ein SMTP-Server installiert werden, um Benachrichtigungen, Passwortrücksetzungen und wöchentliche Statistiken per E-Mail zu versenden.plausible-conf.env– Diese Datei enthält die Umgebungsvariablen, mit denen du deine Installation anpassen kannst.
Der erste Schritt besteht darin, einen geheimen Schlüssel zu generieren, der für die Sicherheit der Plausible-App benötigt wird. Führe den folgenden Befehl aus, um den Schlüssel zu erzeugen.
$ openssl rand -base64 64 | tr -d '\n' ; echo vPkrzp59qQIYtMcyTCKGuyvpkbQ8PYf+Go2ju+DPV/fZUk2eTGNiwV3CoKEueXzypMVLbSkJNGS7xfq96/wepg==
Kopiere den Schlüssel, der auf dem Terminal angezeigt wird. Öffne die Datei plausible-conf.env, um sie zu bearbeiten.
$ nano plausible-conf.env
Füge den folgenden Schlüssel vor der Variable BASE_URL ein.
Füge den Wert für BASE_URL als https://plausible.example.com oder die Domain ein, auf der du Plausible installieren möchtest. Da wir später SSL konfigurieren werden, musst du sicherstellen, dass du die Basis-URL mit HTTPS eingibst. Du kannst auch die Portnummer ändern, auf der Plausible lauscht. Standardmäßig verwendet es Port 8000.
BASE_URL=https://plausible.example.com SECRET_KEY_BASE=yQVWmKfhvr/etwTSN/pSUmhAwExBX7eCKXKAMKV4mrtqzFCA5dgrAnTMx2dS2OIZ9KulVwa+vl7iGRbJpycYaA== PORT=8000
Wenn du die Benutzerregistrierung nach der Installation deaktivieren möchtest, füge die folgende Zeile hinzu.
DISABLE_REGISTRATION=true
Wenn du die Registrierung für andere Benutzer/innen öffnen willst und möchtest, dass sie ihre E-Mail-Adressen verifizieren, füge die folgende Zeile hinzu. Damit dies funktioniert, musst du die SMTP-Details konfigurieren, die wir im Folgenden besprechen.
ENABLE_EMAIL_VERIFICATION=true
Du kannst deine SMTP-Details auch mit den folgenden Daten konfigurieren. In unserem Beispiel verwenden wir den Amazon SES Service.
MAILER_EMAIL=navjot@example.com MAILER_NAME=Howtforge SMTP_HOST_ADDR=email-smtp.us-west-2.amazonaws.com SMTP_HOST_PORT=587 SMTP_USER_NAME=<username> SMTP_USER_PWD=<password> SMTP_HOST_SSL_ENABLED=1 SMTP_RETRIES=2
Google Search Console konfigurieren
Du kannst Plausible auch so konfigurieren, dass es sich mit der Google Search Console verbindet und so die Suchbegriffe auflistet, mit denen Besucher auf deine Website kommen. Die Konfiguration dieses Teils kann ein wenig kompliziert sein.
Besuche die Google API-Konsole und melde dich an. Wenn du in der API-Konsole bist, erstelle ein neues Projekt. Gib deinem Projekt einen Namen. Wenn du ein Google Apps-Konto verwendest, siehst du vielleicht das Feld Organisation. Auf dem Screenshot haben wir ein persönliches Google-Konto verwendet. Klicke auf Erstellen, um fortzufahren.
Klicke auf dem folgenden Bildschirm auf APIs und Dienste aktivieren.
Suche und klicke auf die Google Search Console API.
Klicke auf dem folgenden Bildschirm auf Aktivieren.
Als Nächstes brauchst du Anmeldedaten, um auf die API zuzugreifen. Aber zuerst musst du den Zustimmungsbildschirm konfigurieren. Gehe dazu auf die Option Anmeldeinformationen auf der linken Seite und klicke auf die Schaltfläche Zustimmungsbildschirm konfigurieren.
Wähle als Nutzertyp Intern, da wir nur über den Code darauf zugreifen werden, und klicke auf Erstellen, um fortzufahren. Wenn du ein Google Apps-Konto verwendest, kannst du beide Optionen als Nutzertyp wählen.
Gib deinen Produktnamen an und füge die Support-E-Mail und die Entwickler-Kontakt-E-Mail hinzu, die mit deinem Google Search Console-Konto verknüpft sind. Füge deinen Domainnamen als autorisierte Domains hinzu. Wenn du Plausible unter der Domain https://plausible.example.com installierst, füge https://example.com als autorisierte Domain hinzu. Wenn du Plausible als Top-Level-Domain hostest, verwende diese. Klicke auf die Schaltfläche Speichern und weiter, um zum nächsten Bildschirm zu gelangen.
Überspringe die nächsten paar Bildschirme und gehe zurück zum Dashboard. Im Dashboard gehst du auf die Registerkarte Credentials auf der linken Seite und klickst auf Credential erstellen. Wähle OAuth Client ID.
Auf dem nächsten Bildschirm wählst du Webanwendung als Projekttyp. Gib ihr einen Namen und klicke auf Erstellen.
Du musst deine Client ID und Client Secret Schlüssel speichern. Kopiere diese Werte und füge sie in die Datei plausible-conf.env ein. Du kannst auch die JSON-Datei herunterladen, um die Anmeldedaten für eine spätere Verwendung zu speichern.
GOOGLE_CLIENT_ID=<ID>.apps.googleusercontent.com GOOGLE_CLIENT_SECRET=<secret>
Wenn du fertig bist, speicherst du die plausible-conf.env Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Die App, die du erstellt hast, hat den Status Testing. Die erste Möglichkeit ist, deine App bei Google zu verifizieren, was 3-5 Tage dauern kann. Um die Verifizierung bei Google zu vermeiden, kannst du dein Google-Konto als Testnutzer eingeben. Gehe zum OAuth-Zustimmungsbildschirm, scrolle runter zum Abschnitt Testnutzer und klicke auf die Schaltfläche Nutzer hinzufügen, um dein Google-Konto hinzuzufügen.
Google Analytics konfigurieren
Plausible unterstützt auch den Import deiner Google Analytics-Daten. Dazu müssen wir die folgenden APIs aktivieren.
Gehe zurück zur Seite APIs und Dienste und klicke auf die Schaltfläche APIS und Dienste aktivieren, um die beiden oben genannten APIs zu finden und zu aktivieren.
Schritt 7 – Plausible installieren
Um Plausible zu installieren, führe den folgenden Docker-Befehl aus.
$ docker compose up -d
Dieser Befehl erstellt eine PostgreSQL-Datenbank für die Daten, eine Clickhouse-Datenbank für die Statistiken, Migrationen für beide Datenbanken, um das Schema vorzubereiten, erstellt ein Administratorkonto mit den Angaben aus der env-Datei und startet den Server auf Port 8000.
Überprüfe den Status der Container. Du kannst dafür auch den Befehl docker compose ps verwenden.
$ docker ps CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES d9d2806a978e plausible/analytics:v2.0 "/entrypoint.sh sh -…" 56 seconds ago Up 54 seconds 0.0.0.0:8000->8000/tcp, :::8000->8000/tcp hosting-plausible-1 99c9a1afff34 clickhouse/clickhouse-server:23.3.7.5-alpine "/entrypoint.sh" 56 seconds ago Up 55 seconds 8123/tcp, 9000/tcp, 9009/tcp hosting-plausible_events_db-1 cf408ae32fc3 postgres:14-alpine "docker-entrypoint.s…" 56 seconds ago Up 55 seconds 5432/tcp hosting-plausible_db-1 a5bae1a9f163 bytemark/smtp "docker-entrypoint.s…" 56 seconds ago Up 55 seconds 25/tcp hosting-mail-1
Du solltest in der Lage sein, auf http://<yourserverip>:8000 auf Plausible zuzugreifen (dazu musst du den Port 8000 über die Firewall öffnen).
Schritt 8 – SSL installieren
Bevor wir Nginx als Reverse Proxy konfigurieren, um die Plausible-Domain zu hosten, müssen wir zunächst das SSL-Zertifikat einrichten.
Wir müssen Certbot installieren, um kostenlose SSL-Zertifikate zu generieren, die von Let’s Encrypt angeboten werden. Du kannst Certbot über das Repository von Debian installieren oder die neueste Version mit dem Snapd-Tool herunterladen. Wir werden die Snapd-Version verwenden.
Bei Debian 12 ist Snapd noch nicht installiert. Installiere das Snapd-Paket.
$ sudo apt install snapd
Vergewissere dich, dass deine Version von Snapd auf dem neuesten Stand ist.
$ sudo snap install core $ sudo snap refresh core
Installiere Certbot.
$ sudo snap install --classic certbot
Stelle mit folgendem Befehl sicher, dass der Certbot-Befehl ausgeführt werden kann, indem du einen symbolischen Link auf das Verzeichnis /usr/bin erstellst.
$ sudo ln -s /snap/bin/certbot /usr/bin/certbot
Überprüfe die Installation.
$ certbot --version certbot 2.7.1
Erstelle ein SSL-Zertifikat.
$ sudo certbot certonly --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m name@example.com -d plausible.example.com
Mit dem obigen Befehl wird ein Zertifikat in das Verzeichnis /etc/letsencrypt/live/plausible.example.com auf deinem Server heruntergeladen.
Erstelle ein Diffie-Hellman-Gruppenzertifikat.
$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096
Überprüfe den Certbot-Erneuerungsplanerdienst.
$ sudo systemctl list-timers
Du findest snap.certbot.renew.service als einen der Dienste, die für die Ausführung vorgesehen sind.
NEXT LEFT LAST PASSED UNIT ACTIVATES ..... Wed 2023-10-11 06:43:59 UTC 2h 57min left Wed 2023-10-11 00:51:05 UTC 2h 55min ago apt-daily.timer apt-daily.service Wed 2023-10-11 06:56:46 UTC 3h 10min left Wed 2023-10-11 00:51:05 UTC 2h 55min ago apt-daily-upgrade.timer apt-daily-upgrade.service Wed 2023-10-11 07:32:00 UTC 3h 45min left - - snap.certbot.renew.timer snap.certbot.renew.servic
Führe einen Probelauf des Prozesses durch, um zu prüfen, ob die SSL-Erneuerung einwandfrei funktioniert.
$ sudo certbot renew --dry-run
Wenn du keine Fehler siehst, bist du bereit. Dein Zertifikat wird automatisch erneuert.
Schritt 9 – Nginx als Reverse Proxy konfigurieren
Bis jetzt läuft Plausible auf dem lokalen System über Port 8000. Um auf seiner Domäne zu laufen, werden wir Nginx als Reverse Proxy verwenden.
Erstelle eine Konfigurationsdatei für Plausible im Verzeichnis /etc/nginx/conf.d/.
$ sudo nano /etc/nginx/conf.d/plausible.conf
Füge den folgenden Code in die Datei ein.
server {
listen 80; listen [::]:80;
server_name plausible.example.com;
return 301 https://$host$request_uri;
}
server {
server_name plausible.example.com;
listen 443 ssl http2;
listen [::]:443 ssl http2;
access_log /var/log/nginx/plausible.access.log;
error_log /var/log/nginx/plausible.error.log;
ssl_certificate /etc/letsencrypt/live/plausible.example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/plausible.example.com/privkey.pem;
ssl_trusted_certificate /etc/letsencrypt/live/plausible.example.com/chain.pem;
ssl_session_timeout 1d;
ssl_session_cache shared:MozSSL:10m;
ssl_session_tickets off;
ssl_protocols TLSv1.2 TLSv1.3;
ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384:DHE-RSA-CHACHA20-POLY1305;
ssl_prefer_server_ciphers off;
ssl_ecdh_curve X25519:prime256v1:secp384r1:secp521r1;
ssl_stapling on;
ssl_stapling_verify on;
resolver 8.8.8.8;
ssl_dhparam /etc/ssl/certs/dhparam.pem;
location / {
proxy_pass http://127.0.0.1:8000;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
}
}
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Ö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.
Überprüfe die Syntax der Nginx-Konfigurationsdatei.
$ sudo nginx -t nginx: the configuration file /etc/nginx/nginx.conf syntax is ok nginx: configuration file /etc/nginx/nginx.conf test is successful
Starte den Nginx-Dienst neu, um die neue Konfiguration zu aktivieren.
$ sudo systemctl restart nginx
Schritt 10 – Website und Star Tracking hinzufügen
Rufe die Domain https://plausible.example.com in deinem Browser auf, und du solltest den folgenden Bildschirm zur Registrierung von Plausible sehen.
Klicke auf die Schaltfläche Mein Konto erstellen, um fortzufahren.
Wenn du die Variable ENABLE_EMAIL_VERIFICATION=true eingestellt hast, wirst du aufgefordert, einen Verifizierungscode einzugeben, der an deine E-Mail-ID gesendet wird. Wenn du den SMTP-Server konfiguriert hast, solltest du eine E-Mail mit dem Code erhalten. Falls nicht, oder falls du den Code aus irgendeinem Grund nicht erhältst, führe den folgenden Befehl aus, um alle Benutzer in der Datenbank zu überprüfen.
$ docker compose exec plausible_db psql -U postgres -d plausible_db -c "UPDATE users SET email_verified = true;"
Als nächstes wirst du aufgefordert, eine Website hinzuzufügen. Gib die Domain ein, die du verfolgen möchtest, und wähle die Zeitzone für die Statistikberichterstattung aus.
Auf der nächsten Seite erhältst du den JavaScript-Code für das Tracking deiner Website. Kopiere den Code und füge ihn zwischen die <head>....</head> deiner Website ein und klicke auf die Schaltfläche Datenerfassung starten, um fortzufahren.
Abhängig von den Besucherzahlen deiner Website sollte das Dashboard bald die Statistiken für deine Website anzeigen.
Du kannst deine Google Analytics-Daten importieren oder dich mit der Google Search Console verbinden, indem du die Einstellungen deiner Website aufrufst.
Fazit
Damit ist unsere Anleitung zur Installation und Konfiguration von Plausible Analytics auf einem Debian 12-Server abgeschlossen. Wenn du noch Fragen hast, schreibe sie in die Kommentare unten.