Strapi auf Rocky Linux 9 mit Nginx & PM2

In dieser Anleitung installieren und konfigurieren Sie die Community-Version von Strapi auf einem Rocky Linux 9 Server mit PostgreSQL als Datenbank, PM2 als Prozessmanager und Nginx als Reverse-Proxy inklusive Let’s Encrypt SSL. Schritt-für-Schritt-Befehle, Sicherheits-Hinweise, Upgrade- und Wartungs-Checks sind enthalten.

Einleitung

Rocky Linux Server Übersicht

Strapi ist ein quelloffenes, headless Content-Management-System (CMS) in JavaScript. Als “headless” CMS liefert Strapi Inhalte über eine API und bringt kein Frontend mit; Sie binden Frontends wie React oder Next.js per API ein. Strapi ist modular über Plugins erweiterbar, das Admin-Panel und die API sind anpassbar und bieten ein integriertes Benutzersystem zur Feingranularen Zugriffssteuerung.

Diese Anleitung erklärt die Installation der Community-Edition von Strapi auf Rocky Linux 9, inklusive Firewall-Konfiguration, PostgreSQL, Node.js, PM2-Prozessmanagement, Nginx-Reverse-Proxy und Let’s Encrypt SSL.

Wozu diese Anleitung geeignet ist: Produktionsnahe Setups kleiner bis mittlerer Projekte, bei denen Sie Kontrolle über Server, Prozesse und TLS wünschen.

Wichtige Begriffe in einer Zeile

Headless CMS: Backend für Inhalte ohne Frontend-Rendering.
Reverse-Proxy: Weiterleitet HTTPS-Anfragen an den internen HTTP-Port der App.
PM2: Prozessmanager für Node.js-Anwendungen.

Voraussetzungen

Rocky Linux 9 Server mit mindestens 2 GB RAM und 1 CPU-Kern.
Ein Nicht-Root-Benutzer mit sudo-Rechten.
Voll qualifizierter Domainname (FQDN), z. B. strapi.example.com.
Systemaktualisierungen und Basiswerkzeuge installiert.

Aktualisieren Sie das System:

$ sudo dnf update

Installieren Sie Basis-Pakete (einige könnten bereits installiert sein):

$ sudo dnf install wget curl nano unzip yum-utils -y

Wichtig: Stellen Sie sicher, dass DNS für Ihren FQDN korrekt auf Ihren Server verweist, bevor Sie SSL-Zertifikate anfordern.

Architekturüberblick

Kurze Skizze der Zielarchitektur:

PostgreSQL (lokal) speichert Inhalte.
Strapi läuft als Node.js-App, verwaltet von PM2.
Nginx akzeptiert HTTPS-Verbindungen, leitet an Strapi weiter.
Certbot (Let’s Encrypt) stellt TLS-Zertifikate bereit und erneuert sie automatisch.

Vorteile dieses Aufbaus: klare Trennung von App, DB und TLS; einfache Verwaltung mit PM2; Nginx kann Caching, Logging und Rate-Limiting übernehmen.

Schritt 1 - Firewall konfigurieren

Rocky Linux verwendet firewalld. Prüfen Sie den Status:

$ sudo firewall-cmd --state
running

Zeigen Sie aktive Dienste in der default Zone an:

$ sudo firewall-cmd --permanent --list-services

Öffnen Sie HTTP und HTTPS:

$ sudo firewall-cmd --permanent --add-service=http
$ sudo firewall-cmd --permanent --add-service=https
$ sudo firewall-cmd --reload

Wenn Sie temporär den Strapi-Entwicklungsport 1337 testen, öffnen Sie ihn nur vorübergehend und entfernen danach die Regel wieder (siehe Schritt “Strapi starten und testen”).

Hinweis: Wenn Sie zusätzliche Sicherheitsrichtlinien wie fail2ban einsetzen, fügen Sie ggf. Regeln für Admin-Ports hinzu.

Schritt 2 - PostgreSQL installieren und konfigurieren

Strapi unterstützt PostgreSQL 11+. Rocky Linux 9 liefert PostgreSQL 13, in dieser Anleitung verwenden wir PostgreSQL 15.

GPG-Schlüssel hinzufügen:

$ curl https://www.postgresql.org/media/keys/ACCC4CF8.asc | gpg --dearmor | sudo tee /usr/share/keyrings/postgresql-key.gpg >/dev/null

Repository installieren:

$ sudo dnf install -y https://download.postgresql.org/pub/repos/yum/reporpms/EL-9-x86_64/pgdg-redhat-repo-latest.noarch.rpm

Deaktivieren Sie das eingebaute Modul und installieren Sie PostgreSQL 15:

$ sudo dnf -qy module disable postgresql
$ sudo dnf install -y postgresql15-server

Datenbank initialisieren und Dienst aktivieren:

$ sudo /usr/pgsql-15/bin/postgresql-15-setup initdb
$ sudo systemctl enable postgresql-15
$ sudo systemctl start postgresql-15
$ sudo systemctl status postgresql-15

Starten Sie die PostgreSQL-Shell und erstellen Sie DB und Benutzer:

$ sudo -i -u postgres psql
postgres=# CREATE DATABASE strapidb;
postgres-# CREATE USER strapiuser WITH PASSWORD 'Your_Password';
postgres-# ALTER DATABASE strapidb OWNER TO strapiuser;
postgres-# \q

Testen Sie die Verbindung mit dem Benutzer:

$ psql --username strapiuser --password --host localhost strapidb
Password:
psql (15.1)
Type "help" for help.
strapidb=>

Wichtig: Verwenden Sie ein starkes Passwort, speichern Sie es sicher (z. B. Vault oder Passwortmanager). Falls Ihre Datenbank extern erreichbar sein muss, beschränken Sie den Zugriff per Firewall und pg_hba.conf.

Sicherheits-Hinweis: Für Produktionsumgebungen sollten Sie regelmäßige Backups (pg_dump/pg_basebackup) und WAL-Strategien planen.

Schritt 3 - Node.js installieren

Rocky Linux 9 kann ältere Node-Versionen liefern. Installieren Sie die aktuelle LTS (im Textzeitpunkt v18):

$ curl -fsSL https://rpm.nodesource.com/setup_18.x | sudo bash -
$ sudo dnf install nodejs -y
$ node -v
v18.13.0

Hinweis: Bei Updates auf spätere LTS-Versionen testen Sie die Strapi-Kompatibilität vor dem Produktionsupgrade.

Schritt 4 - Strapi installieren

Erstellen Sie ein neues Projekt mit dem offiziellen Scaffolding-Werkzeug:

$ npx create-strapi-app@latest howtoforge-project
Need to install the following packages:
  [email protected]
Ok to proceed? (y) y

Wählen Sie “Custom” und geben Sie die PostgreSQL-Zugangsdaten an:

? Choose your installation type Custom (manual settings)
? Choose your preferred language JavaScript
? Choose your default database client postgres
? Database name: strapidb
? Host: 127.0.0.1
? Port: 5432
? Username: strapiuser
? Password: Your_Password
? Enable SSL connection: No

Wechseln Sie in das Projektverzeichnis und bauen Sie das Admin-Panel für Produktion:

$ cd howtoforge-project
$ NODE_ENV=production npm run build

Starten Sie Strapi manuell (nur zum Test):

$ node ~/howtoforge-project/node_modules/.bin/strapi start

Öffnen Sie temporär den Port 1337, wenn Sie die Seite testen möchten, und entfernen Sie die Regel danach:

$ sudo firewall-cmd --permanent --add-port=1337/tcp
$ sudo firewall-cmd --reload

Besuchen Sie dann: http://:1337

Strapi CMS Home

Drücken Sie Strg+C, um den Testserver zu stoppen, und entfernen Sie die temporäre Firewall-Regel:

$ sudo firewall-cmd --permanent --remove-port=1337/tcp
$ sudo firewall-cmd --reload

Wichtiger Hinweis: Der manuelle Start ist nur für Tests geeignet. Für Produktion verwenden Sie PM2 (nächster Schritt).

Schritt 5 - PM2 als Prozessmanager installieren und konfigurieren

PM2 ermöglicht das Daemonisieren Ihrer Node-App, automatischen Neustart und systemd-Integration.

Wechseln Sie ins Home-Verzeichnis und installieren Sie PM2 global:

$ cd ~
$ sudo npm install pm2@latest -g

Erstellen Sie eine ecosystem.config.js im Home-Verzeichnis oder einem geeigneten Ort. Öffnen Sie die Datei:

$ sudo nano ecosystem.config.js

Beispielinhalt (passen Sie cwd und Passwörter an):

module.exports = {
  apps: [
    {
      name: 'strapi',
      cwd: '/home/navjot/howtoforge-project',
      script: 'npm',
      args: 'start',
      env: {
        NODE_ENV: 'production',
        DATABASE_HOST: 'localhost',
        DATABASE_PORT: '5432',
        DATABASE_NAME: 'strapidb',
        DATABASE_USERNAME: 'strapiuser',
        DATABASE_PASSWORD: 'Your_Password',
      },
    },
  ],
};

Starten Sie die App mit PM2:

$ pm2 start ecosystem.config.js

Initialisieren Sie PM2 als systemd-Dienst (ersetzen Sie den Benutzer durch Ihren eigenen):

$ pm2 startup
# Kopieren Sie den vorgeschlagenen sudo-Befehl aus der Ausgabe, z. B.:
$ sudo env PATH=$PATH:/usr/bin /usr/lib/node_modules/pm2/bin/pm2 startup systemd -u navjot --hp /home/navjot

Speichern Sie die Prozessliste, damit sie nach einem Neustart wiederhergestellt wird:

$ pm2 save
[PM2] Saving current process list...
[PM2] Successfully saved in /home/navjot/.pm2/dump.pm2

PM2 bietet weitere nützliche Kommandos:

pm2 logs — Log-Streaming
pm2 monit — Monitoring-Ansicht
pm2 restart strapi — Neustart
pm2 stop strapi — stoppen

Berechtigungen: Achten Sie darauf, dass PM2 unter dem richtigen Systembenutzer läuft und Zugriff auf Projektverzeichnis und Umgebungsvariablen hat.

Schritt 6 - Nginx installieren

Für aktuelle Nginx-Versionen fügen wir das offizielle Repository hinzu:

$ sudo nano /etc/yum.repos.d/nginx.repo

Fügen Sie folgendes ein:

[nginx-stable]
name=nginx stable repo
baseurl=http://nginx.org/packages/centos/$releasever/$basearch/
gpgcheck=1
enabled=1
gpgkey=https://nginx.org/keys/nginx_signing.key
module_hotfixes=true

[nginx-mainline]
name=nginx mainline repo
baseurl=http://nginx.org/packages/mainline/centos/$releasever/$basearch/
gpgcheck=1
enabled=0
gpgkey=https://nginx.org/keys/nginx_signing.key
module_hotfixes=true

Installieren und aktivieren Sie Nginx:

$ sudo dnf install -y nginx
$ nginx -v
nginx version: nginx/1.22.1
$ sudo systemctl enable nginx --now
$ sudo systemctl status nginx

Schritt 7 - SSL mit Certbot (Let’s Encrypt)

Installieren Sie Snapd und Certbot, um automatisierte TLS-Zertifikate zu erhalten.

$ sudo dnf install -y epel-release
$ sudo dnf install -y snapd
$ sudo systemctl enable snapd --now
$ sudo snap install core && sudo snap refresh core
$ sudo ln -s /var/lib/snapd/snap /snap
$ echo 'export PATH=$PATH:/var/lib/snapd/snap/bin' | sudo tee -a /etc/profile.d/snapd.sh
$ sudo snap install --classic certbot
$ sudo ln -s /snap/bin/certbot /usr/bin/certbot
$ certbot --version
certbot 2.2.0

Fordern Sie ein Zertifikat für Ihre Domain an (ersetzen Sie E-Mail und Domain):

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

Das Zertifikat landet unter /etc/letsencrypt/live/strapi.example.com.

Erzeugen Sie einen starken Diffie-Hellman-Parameter:

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

Testen Sie eine Erneuerung im Dry-Run:

$ sudo certbot renew --dry-run

Wichtig: Stellen Sie sicher, dass Port 80 für die HTTP-Verifikation offen ist, bevor Sie Certbot ausführen.

Schritt 8 - Nginx als Reverse-Proxy konfigurieren

Fügen Sie vor den server-Blocks in /etc/nginx/nginx.conf folgende Direktive hinzu:

server_names_hash_bucket_size  64;

Erstellen Sie die virtuelle Host-Konfiguration:

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

Inhalt:

server {
  # Redirect any http requests to https
  listen         80;
  listen         [::]:80;
  server_name    strapi.example.com;
  return 301     https://$host$request_uri;
}

server {
  listen                    443 ssl http2;
  listen                    [::]:443 ssl http2;
  server_name               strapi.example.com;

  access_log                /var/log/nginx/strapi.access.log;
  error_log                 /var/log/nginx/strapi.error.log;

  # TLS configuration
  ssl_certificate           /etc/letsencrypt/live/strapi.example.com/fullchain.pem;
  ssl_certificate_key       /etc/letsencrypt/live/strapi.example.com/privkey.pem;
  ssl_trusted_certificate   /etc/letsencrypt/live/strapi.example.com/chain.pem;
  ssl_protocols             TLSv1.2 TLSv1.3;

  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;
  ssl_session_timeout       1d;

  # OCSP Stapling ---
  ssl_stapling on;
  ssl_stapling_verify on;
  ssl_dhparam /etc/ssl/certs/dhparam.pem;

  location / {
    proxy_set_header        X-Real-IP $remote_addr;
    proxy_set_header        X-Forwarded-Proto $scheme;
    proxy_set_header        X-Forwarded-Host $http_host;
    proxy_set_header        X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_pass              http://127.0.0.1:1337;
  }
}

Prüfen und neu starten:

$ sudo nginx -t
$ sudo systemctl restart nginx

Zugriff:

https://strapi.example.com

Strapi Production Home

Admin-Interface:

Besuchen Sie https://strapi.example.com/admin um den ersten Administrator anzulegen.

Strapi Admin User Create Page

Nachdem Sie die Admin-Daten eingeben und auf “Let’s start” klicken, sehen Sie das Dashboard:

Strapi Admin Dashboard

Schritt 9 - Strapi upgraden

Standardablauf zum Aktualisieren einer Strapi-Installation:

Server stoppen:

$ cd ~
$ pm2 stop ecosystem.config.js

package.json im Projekt öffnen und Strapi-Pakete auf die gewünschte Version aktualisieren.

$ cd howtoforge-project
$ nano package.json

Beispielabhängigkeiten (nur Versionen als Platzhalter):

"dependencies": {
  "@strapi/strapi": "4.5.5",
  "@strapi/plugin-users-permissions": "4.5.5",
  "@strapi/plugin-i18n": "4.5.5",
  "pg": "8.6.0"
},

Pakete installieren, Admin neu bauen und App neu starten:

$ npm install
$ NODE_ENV=production npm run build
$ cd ~
$ pm2 start ecosystem.config.js

Hinweis: Testen Sie Upgrades zuerst in einer Staging-Umgebung. Lesen Sie die Strapi-Release-Notes auf GitHub, um Breaking Changes zu erkennen.

Sicherheit und Hardening

Empfehlungen für Produktion:

Verwenden Sie starke Passwörter und rollenbasierte Zugänge.
Deaktivieren Sie unbenutzte Plugins und Endpunkte.
Aktivieren Sie Rate-Limiting in Nginx oder per Middleware.
Hosten Sie die Datenbank nicht öffentlich; verwenden Sie Firewall-Restriktionen.
Sichern Sie Backups automatisiert (z. B. täglicher pg_dump mit Rotation).
Beschränken Sie Dateirechte im Projektordner (nur benötigte Benutzer dürfen schreiben).
Nutzen Sie ein WAF (z. B. mod_security) bei Bedarf.

Spezifische Nginx-Hardening-Schritte (kurz):

HTTP Security Headers setzen (Content-Security-Policy, X-Frame-Options, X-Content-Type-Options).
SSL/TLS-Protokolle auf TLSv1.2/TLSv1.3 beschränken (siehe Konfigurationsblock).
OCSP Stapling aktivieren (in Konfiguration enthalten).

Datenschutz / DSGVO Hinweise

Strapi speichert Inhalte und ggf. personenbezogene Daten. Dokumentieren Sie Verarbeitungszwecke und Fristen.
Implementieren Sie Datensubjekt-Rechte (Löschung, Zugriff) in Ihren Content-Prozessen.
Verschlüsseln Sie Backups und begrenzen Sie Zugriff auf sensible Datenbank-Backups.
Verwenden Sie lokale Serverstandorte und prüfen Sie Drittanbieter-Integrationen auf Auftragsverarbeitungsverträge.

Fehlerbehebung - häufige Probleme und Lösungen

Postgres-Verbindungsfehler: Prüfen Sie host/port/username/password und pg_hba.conf.
PM2 startet nicht: Prüfen Sie Benutzerrechte und PATH in systemd-Startup-Befehl.
Nginx 502/504: Prüfen Sie, ob Strapi auf 127.0.0.1:1337 erreichbar ist (curl http://127.0.0.1:1337).
SSL-Probleme bei Certbot: Stellen Sie sicher, dass Port 80 offen ist und Nginx keine Konfiguration blockiert.

Minimaler Testfall nach Installation

Admin-Login erreichbar unter /admin und neues Inhaltsmodell anlegen.
API-Endpunkt gibt JSON zurück: GET https://strapi.example.com/api/.
TLS-Zertifikat gültig und automatische Erneuerung per certbot renew funktioniert im Dry-Run.

Rollenbasierte Checkliste

Administrator:

Domain und DNS gesetzt
Let’s Encrypt Zertifikat geprüft
Firewall-Regeln gesetzt (80, 443)

DevOps:

PM2-Prozess überwacht und auto-start konfiguriert
Backups der DB eingerichtet
Logrotation für Nginx und Strapi-Logs aktiviert

Developer:

Lokales Frontend (z. B. Next.js) gegen Strapi-API getestet
CORS-Einstellungen überprüft

Upgrade-Playbook kurz

Snapshot/Sicherung der VM oder Backup der DB.
Stoppen der App (pm2 stop).
Aktualisieren der Abhängigkeiten in package.json.
npm install und build ausführen.
Tests in Staging durchführen.
Produktion neu starten und Logs prüfen.

Kriterien für erfolgreichen Betrieb

HTTPS erreichbar ohne Zertifikatsfehler.
Admin-Panel erreichbar und in “production” Mode.
Regelmäßige Backups erfolgreich und wiederherstellbar.
PM2 hält App nach Crashs online.

Kurze Entscheidungshilfe: Wann Strapi nicht geeignet ist

Wenn Sie ein stark datenbankorientiertes CMS mit komplexen Transaktionen benötigen: Evaluieren Sie relationale monolithische CMS.
Für extrem hohe Skalierung ohne Node-Expertise: Betrachten Sie verwaltete Headless-Services (SaaS).

Mini-Glossar (ein Satz pro Begriff)

Strapi: Headless CMS in Node.js für strukturierte Inhalte.
PM2: Prozessmanager für Node.js, der Daemonisierung und Restart-Strategien liefert.
Nginx: Hochperformanter Reverse-Proxy und Webserver.
Certbot: Tool zum Anfordern und Erneuern von Let’s Encrypt Zertifikaten.

Social Preview und Kurz-Ankündigung

Social-Preview-Vorschlag (OG):

OG Titel: Strapi auf Rocky Linux 9 — Komplettes Setup mit Nginx & SSL
OG Beschreibung: Schnellstart: Strapi mit PostgreSQL, PM2 und Nginx samt Let’s Encrypt auf Rocky Linux 9 einrichten.

Kurz-Ankündigung (100–200 Wörter):

Diese Anleitung zeigt Schritt für Schritt, wie Sie Strapi Community auf einem Rocky Linux 9 Server produktionsreif einrichten. Sie umfasst die Datenbankkonfiguration mit PostgreSQL 15, das Aufsetzen von Node.js v18, Prozessmanagement mit PM2, Reverse-Proxy und TLS per Nginx/Let’s Encrypt sowie Security- und Upgrade-Empfehlungen. Ideal für Entwickler und DevOps, die ein flexibles Headless-CMS selbst hosten möchten.

Zusammenfassung

Sie haben Strapi mit PostgreSQL, PM2 und Nginx installiert.
TLS ist per Certbot/Let’s Encrypt konfiguriert und erweiterbar.
PM2 sorgt für Prozessstabilität und systemd-Integration.
Backup-, Upgrade- und Sicherheitsprozesse sollten Teil Ihrer Betriebsroutine sein.

Wichtige Takeaways

Testen Sie Upgrades zuerst in Staging.
Schützen Sie die Datenbank per Firewall und starke Passwörter.
Automatisieren Sie Backups und Zertifikats-Erneuerung.

Wenn Sie Fragen zu einem der Schritte haben oder ein Kapitel vertieft brauchen (z. B. automatische Backups, CI/CD-Integration oder Cloud-Migration), schreiben Sie mir, dann liefere ich eine spezialisierte Erweiterung.

Strapi auf Rocky Linux 9 mit Nginx, PostgreSQL und PM2 installieren