Wie man Ghost Blog mit Nginx unter Debian 12 einsetzt
Ghost ist eine Open-Source-Blogging-Plattform, mit der du einen professionell aussehenden Blog erstellen kannst. Sie wurde 2013 als Alternative zu WordPress eingeführt. Es ist in JavaScript geschrieben und wird von der Node.js-Bibliothek unterstützt.
In diesem Tutorial zeigen wir dir, wie du Ghost CMS mit Nginx und MySQL auf einem Server mit Debian 12 installierst. Wir werden das SSL-Zertifikat von Let’s Encrypt verwenden, um unsere Installation zu sichern.
Voraussetzungen
- Ein Server mit Debian 12 und mindestens 2 GB RAM.
- Ein Nicht-Root-Benutzer mit sudo-Rechten.
- Ein Fully Qualified Domain Name (FQDN) wie
example.com, der auf deinen Server zeigt. - Stelle sicher, dass alles auf dem neuesten Stand ist.
$ sudo apt update $ sudo apt upgrade
- Einige wenige Pakete, die dein System benötigt.
$ sudo apt install wget curl nano ufw software-properties-common dirmngr apt-transport-https gnupg2 ca-certificates lsb-release debian-archive-keyring unzip -y
Einige dieser Pakete sind vielleicht schon auf deinem System installiert.
Schritt 1 – UFW-Firewall konfigurieren
Der erste Schritt besteht darin, die Firewall zu konfigurieren. Debian 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 – 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 arch=amd64] \ 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. Die sudo wird benötigt, um den Befehl unter Debian auszuführen.
$ sudo nginx -v nginx version: nginx/1.24.0
Starte den Nginx-Server.
$ sudo systemctl start nginx
Schritt 3 – Node.js installieren
Ghost Installer braucht Nodejs, um zu funktionieren. Der erste Schritt besteht darin, den Nodesource GPG-Schlüssel zu importieren.
$ curl -fsSL https://deb.nodesource.com/gpgkey/nodesource-repo.gpg.key | sudo gpg --dearmor -o /usr/share/keyrings/nodesource.gpg
Als Nächstes erstellst du die Nodesource-Repository-Datei. Wir werden Node 18x installieren, die aktuelle LTS (Long Term Support) Version, die von Ghost empfohlen wird.
$ NODE_MAJOR=18 $ echo "deb [signed-by=/usr/share/keyrings/nodesource.gpg] https://deb.nodesource.com/node_$NODE_MAJOR.x nodistro main" | sudo tee /etc/apt/sources.list.d/nodesource.list
Aktualisiere die Repository-Liste des Systems.
$ sudo apt update
Installiere Node.
$ sudo apt install nodejs -y
Bestätige die Node-Installation.
$ node --version v18.18.2
Schritt 4 – MySQL mit Docker installieren
Debian wird nicht mehr mit MySQL ausgeliefert. Stattdessen wird es mit MariaDB ausgeliefert. Ghost unterstützt nur MySQL. Du kannst Ghost so anpassen, dass es mit MariaDB funktioniert, aber das ist nicht empfehlenswert. Da die offiziellen MySQL-Repositories zum Zeitpunkt der Erstellung dieses Tutorials noch nicht für Debian 12 aktualisiert wurden, werden wir es mit Docker installieren.
Importiere den Docker-GPG-Schlüssel.
$ curl -fsSL https://download.docker.com/linux/debian/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker.gpg
Erstelle eine Docker-Repository-Datei.
$ 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 Liste der System-Repositorys.
$ sudo apt update
Installiere Docker und Docker Compose.
$ sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
Docker erfordert standardmäßig Root-Rechte. Wenn du vermeiden willst, dass du jedes Mal sudo verwendest, wenn du den Befehl docker ausführst, füge deinen Benutzernamen der Gruppe docker hinzu.
$ sudo usermod -aG docker $(whoami)
Um diese Änderung zu aktivieren, musst du dich vom Server abmelden und als derselbe Benutzer wieder anmelden oder den folgenden Befehl verwenden.
$ su - ${USER}
Bestätige, dass dein Benutzer der Docker-Gruppe hinzugefügt wurde.
$ groups navjot wheel docker
Jetzt, da Docker installiert ist, müssen wir eine Docker-Compose-Datei für MySQL erstellen. Erstelle ein Verzeichnis für MySQL Docker.
$ mkdir ~/mysql
Erstelle und öffne die Datei docker-compose.yml zum Bearbeiten.
$ nano docker-compose.yml
Füge den folgenden Code in die Datei ein.
services:
database:
image: container-registry.oracle.com/mysql/community-server:latest
container_name: mysql
restart: always
environment:
MYSQL_ROOT_PASSWORD: rootpassword
MYSQL_USER: ghost
MYSQL_PASSWORD: ghostpassword
MYSQL_DATABASE: ghostdb
ports:
- "3306:3306"
volumes:
- ./mysql:/var/lib/mysql
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Hier haben wir das Root-Passwort und die MySQL-Anmeldedaten für die Ghost-Datenbank festgelegt. Diese werden erstellt, wenn der Container gestartet wird.
Starte den MySQL-Container.
$ docker compose up -d
Überprüfe den Status des Docker-Containers.
$ docker ps CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES ec42fb205f1e container-registry.oracle.com/mysql/community-server:latest "/entrypoint.sh mysq…" 4 seconds ago Up 2 seconds 0.0.0.0:3306->3306/tcp, :::3306->3306/tcp, 33060-33061/tcp mysql
Ghost kann sich über Port 3306 mit dem MySQL-Container verbinden und Operationen durchführen.
Schritt 5 – Ghost installieren
Wir können Ghost auch mit Docker installieren, was die Sache vereinfacht, aber das werden wir hier nicht tun.
Die Ghost-Installation besteht aus drei Komponenten – dem Kommandozeilen-Tool Ghost-CLI, das die Updates für den Ghost-Blog installiert und verwaltet, und dem Blog-Paket selbst.
Ghost-CLI installieren
Führe den folgenden Befehl aus, um das Ghost-CLI-Tool zu installieren.
$ sudo npm install ghost-cli@latest -g
Ghost-Verzeichnis vorbereiten
Erstelle das Ghost-Stammverzeichnis.
$ sudo mkdir -p /var/www/html/ghost
Setze den Eigentümer des Verzeichnisses auf den aktuellen Benutzer.
$ sudo chown $USER:$USER /var/www/html/ghost
Setze die richtigen Verzeichnisberechtigungen.
$ sudo chmod 755 /var/www/html/ghost
Wechsle in das Ghost-Verzeichnis.
$ cd /var/www/html/ghost
Ghost installieren
Die Installation von Ghost ist ein einziger Befehlsvorgang.
$ ghost install
Während der Installation stellt das CLI-Tool mehrere Fragen zur Konfiguration des Blogs.
- Blog-URL: Gib deine vollständige Blog-URL zusammen mit dem https-Protokoll ein. (
https://example.com) - MySQL Hostname: Drücke die Eingabetaste, um den Standardwert
localhostzu verwenden, da unsere Ghost-Installation und MySQL auf demselben Server liegen. - MySQL-Benutzername: Gib
ghostals deinen MySQL-Benutzernamen ein. - MySQL-Passwort: Gib dein Root-Passwort ein, das du zuvor in der Docker-Datei erstellt hast.
- Ghost-Datenbankname: Gib den Namen der Datenbank (
ghostdb) ein, die in der Docker-Datei konfiguriert wurde. - Sudo-Passwort: Es wird nach deinem sudo-Passwort gefragt, um administrative Aufgaben durchzuführen.
- Nginx einrichten? Normalerweise erkennt Ghost-CLI deine Nginx-Installation und konfiguriert sie automatisch für deinen Blog. Das funktioniert aber nur für Nginx, das mit dem OS-Paket installiert wurde. Da wir es über das Nginx-Repository installiert haben, kann Ghost es nicht erkennen und überspringt es automatisch.
- SSL einrichten?: Da es die Nginx-Konfiguration übersprungen hat, überspringt das CLI-Tool auch die Einrichtung von SSL.
- systemd einrichten?: Ghost wird dich fragen, ob du einen Systemdienst für Ghost einrichten willst. Drücke Y, um fortzufahren.
- Ghost starten? Drücke Y, um deine Ghost-Installation zu starten. Es wird jedoch nicht funktionieren, weil Nginx und SSL noch nicht konfiguriert sind.
Schritt 6 – SSL installieren
Bevor wir fortfahren, müssen wir das Tool Certbot installieren und ein SSL-Zertifikat für unsere Domain einrichten.
Um Certbot zu installieren, verwenden wir den Snapd-Paketinstaller. Snapd enthält immer die neueste stabile Version von Certbot. Bei Debian ist Snapd allerdings noch nicht installiert. Installiere es zuerst.
$ 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
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
Ü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 example.com
Mit dem obigen Befehl wird ein Zertifikat in das Verzeichnis /etc/letsencrypt/live/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 Tue 2023-10-17 00:00:00 UTC 14h left Mon 2023-10-16 00:00:18 UTC 9h ago dpkg-db-backup.timer dpkg-db-backup.service Mon 2023-10-16 19:12:00 UTC 9h left Mon 2023-10-16 07:27:11 UTC 2h 17min ago snap.certbot.renew.timer snap.certbot.renew.service Mon 2023-10-16 20:49:14 UTC 11h left Mon 2023-10-16 07:48:12 UTC 1h 56min ago apt-daily.timer apt-daily.service
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 7 – Nginx konfigurieren
Erstelle und öffne die Datei /etc/nginx/conf.d/ghost.conf zum Bearbeiten.
$ sudo nano /etc/nginx/conf.d/ghost.conf
Füge den folgenden Code in die Datei ghost.conf ein. Ersetze alle Instanzen von example.com durch deine Domain.
server {
listen 80;
listen [::]:80;
server_name example.com;
location / {
return 301 https://$server_name$request_uri;
}
}
server {
listen 443 ssl http2;
listen [::]:443 ssl http2;
server_name example.com;
access_log /var/log/nginx/ghost.access.log;
error_log /var/log/nginx/ghost.error.log;
client_max_body_size 20m;
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_session_timeout 1d;
ssl_session_cache shared:SSL:10m;
ssl_dhparam /etc/ssl/certs/dhparam.pem;
ssl_stapling on;
ssl_stapling_verify on;
resolver 1.1.1.1 1.0.0.1 [2606:4700:4700::1111] [2606:4700:4700::1001] 8.8.8.8 8.8.4.4 [2001:4860:4860::8888] [2001:4860:4860::8844] valid=60s;
resolver_timeout 2s;
ssl_certificate /etc/letsencrypt/live/example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/example.com/privkey.pem;
ssl_trusted_certificate /etc/letsencrypt/live/example.com/chain.pem;
location / {
proxy_set_header Host $http_host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-Proto https;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_pass http://localhost:2368;
}
}
Die obige Konfiguration leitet alle HTTP-Anfragen auf HTTPS um und dient als Proxy für den Ghost-Dienst, um ihn über deine Domain zu bedienen.
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 deine Nginx-Konfiguration.
$ sudo nginx -t
Wenn du keine Fehler siehst, bist du startklar. Starte den Nginx-Server neu, um die Konfiguration zu übernehmen.
$ sudo systemctl restart nginx
Schritt 9 – Ausführen der Website
Jetzt kannst du deine Installation überprüfen, indem du https://example.com in deinem Webbrowser öffnest. Du erhältst die folgende Seite, die eine erfolgreiche Installation anzeigt.
Schritt 10 – Einrichtung abschließen
Um die Einrichtung deines Ghost-Blogs abzuschließen, rufe https://example.com/ghost in deinem Browser auf. Das zusätzliche /ghost am Ende der Domain deines Blogs leitet dich zum Ghost Admin Panel oder in diesem Fall zum Setup weiter, da du es zum ersten Mal aufrufst.
Hier musst du dein Administratorkonto erstellen und einen Blogtitel auswählen.
Gib deine Daten ein und klicke auf die Schaltfläche Konto erstellen & Veröffentlichung starten, um fortzufahren.
Als Nächstes wirst du zum folgenden Bildschirm weitergeleitet, auf dem du Optionen wie das Schreiben deines ersten Beitrags, das Anpassen deiner Seite und das Importieren von Mitgliedern findest.
Wir wählen die Option Explore Ghost admin und gehen direkt zum Dashboard. Am Ende der Einrichtung wirst du mit dem Ghost-Administrationsbereich begrüßt.
Wenn du in den dunklen Modus wechseln möchtest, kannst du das tun, indem du unten auf der Einstellungsseite auf den Kippschalter neben dem Zahnrad-Button klickst.
Du wirst einen Standardbeitrag sehen. Du kannst ihn aufheben oder löschen und mit dem Posten beginnen.
Schritt 11 – Mailer konfigurieren
Ghost fungiert nicht nur als Blogging-Plattform, sondern auch als Newsletter-Manager. Für den täglichen Betrieb kannst du jeden Transaktionsmaildienst nutzen, der mit Ghost zusammenarbeitet, um Mails zu versenden. Wenn du aber Newsletter über Ghost verschicken willst, wird nur Mailgun als offizieller Massenversender unterstützt. Du kannst auch einen anderen Newsletter-Dienst verwenden, aber dafür musst du die Zapier-Integrationsfunktion von Ghost nutzen.
Konfigurieren wir zunächst einen SMTP-Dienst für Transaktions-E-Mails. Öffne dazu die Datei /var/www/html/ghost/config.production.json zur Bearbeitung.
$ nano /var/www/html/ghost/config.production.json
Finde die folgenden Zeilen.
"mail": {
"transport": "Direct"
},
Ersetze sie durch den folgenden Code.
"mail": {
"from": "'HowtoForge Support' name@example.com",
"transport": "SMTP",
"options": {
"host": "YOUR-SES-SERVER-NAME",
"port": 465,
"service": "SES",
"auth": {
"user": "YOUR-SES-SMTP-ACCESS-KEY-ID",
"pass": "YOUR-SES-SMTP-SECRET-ACCESS-KEY"
}
}
},
Hier verwenden wir den Amazon SES Mail-Dienst, da er günstig ist und keine monatlichen Gebühren verlangt.
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst. Wenn du fertig bist, starte die Ghost-Anwendung neu, damit die Änderungen wirksam werden.
$ ghost restart
Um die Newsletter-Einstellungen zu konfigurieren, besuche den Bereich Einstellungen >> E-Mail-Newsletter.
Klicke auf den Link Mailgun-Konfiguration, um ihn zu erweitern.
Gib deine Mailgun-Region, deine Domain und deinen API-Schlüssel ein.
Klicke oben rechts auf die Schaltfläche Speichern, um die Einstellungen zu speichern.
Um den Versand des Newsletters zu testen, erstelle einen neuen Testpost, klicke auf Veröffentlichen und wähle die Option Nur E-Mail. Wenn du den Beitrag auch veröffentlichen möchtest, wähle die Option Veröffentlichen und E-Mail.
Klicke auf die Schaltfläche Weiter, letzte Überprüfung, um fortzufahren. Auf der nächsten Seite wirst du erneut um eine endgültige Bestätigung gebeten.
Klicke auf die Schaltfläche E-Mail senden, jetzt, um den Newsletter zu versenden. Sobald die Mail versendet wurde, erhältst du die folgende Nachricht.
Schau in deiner E-Mail nach, ob die Post angekommen ist.
Schritt 12 – Ghost aktualisieren
Es gibt zwei Arten von Ghost Updates – Minor Updates und Major Updates.
Wenn du ein kleines Update durchführen willst, musst du zunächst ein vollständiges Backup erstellen. Dabei wird ein Backup aller Beiträge, Mitglieder, Themen, Bilder, Dateien und Weiterleitungsdateien erstellt.
$ cd /var/www/html/ghost $ ghost backup
Führe den Befehl update aus, um das kleinere Update durchzuführen.
$ ghost update
Um ein größeres Update durchzuführen, solltest du die offizielle, detaillierte Update-Anleitung bei Ghost befolgen. Je nachdem, auf welcher Version du dich gerade befindest und auf welche Hauptversion du aktualisieren möchtest, variieren die Schritte.
Fazit
Damit ist unsere Anleitung zur Einrichtung von Ghost CMS auf deinem Debian 12 Server mit Nginx abgeschlossen. Wenn du Fragen oder Anregungen hast, schreibe sie in die Kommentare unten.