So installierst du NEOS CMS mit Nginx und Let’s Encrypt SSL auf Rocky Linux 8

Neos ist ein kostenloses und quelloffenes Content Management System (CMS), mit dem du ganz einfach komplexe Websites erstellen kannst, ohne programmieren zu müssen. Du kannst damit einen Blog, eine News-Website, eine Portfolioseite oder eine Unternehmenswebsite erstellen. Es bietet eine Vielzahl von Funktionen wie Inline-Editing, Unterstützung mehrerer Websites in einer einzigen Installation, integrierte SEO-Tools, menschenlesbare URLs, Plugin-Manager, Gerätevorschau und Unterstützung für mehrere Vorlagen. Es unterstützt moderne Technologien wie REST API, JSON, GraphQL und oEmbed.

In diesem Lernprogramm erfährst du, wie du Neos CMS auf einem Server mit dem Betriebssystem Rocky Linux 8 installierst.

Voraussetzungen

  • Ein Server, auf dem Rocky Linux 8 läuft.
  • Ein sudo-Benutzer ohne Root-Rechte.
  • Stelle sicher, dass alles auf dem neuesten Stand ist.
    $ sudo dnf update
    
  • Installiere grundlegende Hilfspakete. Einige von ihnen sind vielleicht schon installiert.
    $ sudo dnf install wget curl nano unzip yum-utils -y
    

Schritt 1 – Firewall konfigurieren

Der erste Schritt besteht darin, die Firewall zu konfigurieren. Rocky Linux verwendet die Firewalld Firewall. Überprüfe den Status der Firewall.

$ sudo firewall-cmd --state
running

Die Firewall arbeitet mit verschiedenen Zonen, wobei die öffentliche Zone die Standardzone ist, die wir verwenden werden. Liste alle Dienste und Ports auf, die auf der Firewall aktiv sind.

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

Es sollte die folgende Ausgabe angezeigt werden.

cockpit dhcpv6-client ssh

Lasse HTTP- und HTTPS-Ports zu.

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

Überprüfe erneut den Status der Firewall.

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

Du solltest eine ähnliche Ausgabe sehen.

cockpit dhcpv6-client http https ssh

Lade die Firewall neu, um die Änderungen zu aktivieren.

$ sudo firewall-cmd --reload

Schritt 2 – Nginx installieren

Rocky Linux wird mit einer älteren Version von Nginx ausgeliefert. Um die neueste Version zu installieren, musst du das offizielle Nginx-Repository herunterladen.

Erstelle und öffne die Datei /etc/yum.repos.d/nginx.repo zur Erstellung des offiziellen Nginx-Repositorys.

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

Füge den folgenden Code in die Datei 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

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Installiere Nginx.

$ sudo dnf install nginx

Überprüfe die Installation.

$ nginx -v
nginx version: nginx/1.20.2

Aktiviere und starte den Nginx-Dienst.

$ sudo systemctl enable nginx --now

Schritt 3 – PHP und Erweiterungen installieren

Für unser Tutorial müssen wir die neueste Version von PHP aus dem Repository von Remi installieren. Der erste Schritt besteht darin, das Epel-Repository zu holen.

$ sudo dnf install epel-release

Als nächstes installierst du das Remi-Repository.

$ sudo dnf install https://rpms.remirepo.net/enterprise/remi-release-8.rpm

Überprüfe, ob PHP Streams verfügbar sind.

$ dnf module list php -y
Last metadata expiration check: 0:00:12 ago on Fri 03 Dec 2021 09:39:32 AM UTC.
Rocky Linux 8 - AppStream
Name                Stream                 Profiles                                 Summary
php                 7.2 [d]                common [d], devel, minimal               PHP scripting language
php                 7.3                    common [d], devel, minimal               PHP scripting language
php                 7.4                    common [d], devel, minimal               PHP scripting language

Remi's Modular repository for Enterprise Linux 8 - x86_64
Name                Stream                 Profiles                                 Summary
php                 remi-7.2               common [d], devel, minimal               PHP scripting language
php                 remi-7.3               common [d], devel, minimal               PHP scripting language
php                 remi-7.4               common [d], devel, minimal               PHP scripting language
php                 remi-8.0               common [d], devel, minimal               PHP scripting language
php                 remi-8.1               common [d], devel, minimal               PHP scripting language

Hint: [d]efault, [e]nabled, [x]disabled, [i]nstalled

Die Standardversion ist 7.2. Aktiviere das PHP 8.0 Repository von Remi.

$ sudo dnf module reset php
$ sudo dnf module enable php:remi-8.0

Als Nächstes installierst du PHP und die von Neos benötigten Erweiterungen sowie ImageMagick.

$ sudo dnf install php-fpm php-mbstring php-xml php-curl php-mysqlnd php-zip php-cli php-imagick ImageMagick php-intl

Überprüfe die Installation.

$ php --version
PHP 8.0.14 (cli) (built: Dec 16 2021 03:01:07) ( NTS gcc x86_64 )
Copyright (c) The PHP Group
Zend Engine v4.0.14, Copyright (c) Zend Technologies

Schritt 4 – Installiere und konfiguriere den MySQL-Server

Wir werden eine MySQL-Datenbank verwenden, um die Daten zu speichern. Das Appstream-Repository von Rocky Linux wird mit der neuesten Version von MySQL ausgeliefert.

Installiere MySQL.

$ sudo dnf install mysql-server

Aktiviere und starte den MySQL-Dienst.

$ sudo systemctl enable mysqld --now

Sichere die MySQL-Installation.

$ sudo mysql_secure_installation

Im ersten Schritt wirst du gefragt, ob du das Validate Password Plugin einrichten möchtest, mit dem du die Stärke deines MySQL-Passworts testen kannst. Wähle Y, um fortzufahren. Im nächsten Schritt wirst du aufgefordert, die Stufe der Passwortüberprüfung zu wählen. Wähle 2. Das ist die stärkste Stufe und verlangt, dass dein Passwort mindestens acht Zeichen lang ist und eine Mischung aus Groß- und Kleinbuchstaben, Zahlen und Sonderzeichen enthält.

Securing the MySQL server deployment.

Connecting to MySQL using a blank password.

VALIDATE PASSWORD COMPONENT can be used to test passwords
and improve security. It checks the strength of password
and allows the users to set only those passwords which are
secure enough. Would you like to setup VALIDATE PASSWORD component?

Press y|Y for Yes, any other key for No: Y

There are three levels of password validation policy:

LOW    Length >= 8
MEDIUM Length >= 8, numeric, mixed case, and special characters
STRONG Length >= 8, numeric, mixed case, special characters and dictionary                  file

Please enter 0 = LOW, 1 = MEDIUM and 2 = STRONG: 2

Im nächsten Schritt wirst du aufgefordert, ein Root-Passwort zu wählen. Wähle ein sicheres Passwort, das die Anforderungen des Plugins zur Passwortvalidierung erfüllt. Im nächsten Schritt wirst du gefragt, ob du mit dem gewählten Passwort fortfahren möchtest. Drücke y, um fortzufahren.

Please set the password for root here.

New password:

Re-enter new password:

Estimated strength of the password: 100
Do you wish to continue with the password provided?(Press y|Y for Yes, any other key for No) : Y

Drücke Y und dann ENTER für alle folgenden Aufforderungen, um anonyme Benutzer und die Testdatenbank zu entfernen, Root-Logins zu deaktivieren und die neu festgelegten Regeln zu laden.

...
Remove anonymous users? (Press y|Y for Yes, any other key for No) : Y
Success.
...
Disallow root login remotely? (Press y|Y for Yes, any other key for No) : Y
Success.
...
Remove test database and access to it? (Press y|Y for Yes, any other key for No) : Y
 - Dropping test database...
Success.
 - Removing privileges on test database...
Success.
Reloading the privilege tables will ensure that all changes
made so far will take effect immediately.
...
Reload privilege tables now? (Press y|Y for Yes, any other key for No) : Y
Success.
All done!

Gib die MySQL-Shell ein. Gib dein Root-Passwort ein, um fortzufahren.

$ mysql -u root -p

Erstelle den Benutzer neos. Vergewissere dich, dass das Passwort den zuvor festgelegten Anforderungen entspricht.

mysql> CREATE USER 'neos'@'localhost' IDENTIFIED BY 'Your_password2';

Erstelle die Datenbank neosdb.

mysql> CREATE DATABASE neosdb CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;

Erteile dem Benutzer die Rechte für die Datenbank neosdb.

mysql> GRANT ALL PRIVILEGES ON neosdb.* TO 'neos'@'localhost';

Beende die Shell.

mysql> exit

Schritt 5 – Composer installieren

Composer ist ein Tool zur Verwaltung von Abhängigkeiten in PHP und wird von Neos CMS benötigt, um zu funktionieren.

Lade das Composer-Installationsskript herunter.

$ curl -sS https://getcomposer.org/installer -o composer-setup.php

Führe die folgenden Befehle aus, um den Installer zu überprüfen.

$ HASH=`curl -sS https://composer.github.io/installer.sig`
$ echo $HASH
$ php -r "if (hash_file('SHA384', 'composer-setup.php') === '$HASH') { echo 'Installer verified'; } else { echo 'Installer corrupt'; unlink('composer-setup.php'); } echo PHP_EOL;"

Die obigen Befehle erfassen den Hash-Wert des Installers und gleichen ihn mit deinem heruntergeladenen Skript ab. Wenn das Installationsprogramm sicher ausgeführt werden kann, solltest du die folgende Ausgabe sehen.

Installer verified

Installiere Composer.

$ sudo php composer-setup.php --install-dir=/usr/local/bin --filename=composer

Überprüfe die Installation, indem du die Version überprüfst.

$ composer --version
Composer version 2.2.3 2021-12-31 12:18:53

Schritt 6 – Neos CMS installieren

Erstelle ein Stammverzeichnis für die Installation von Neos.

$ sudo mkdir -p /var/www/neos

Ändere die Eigentümerschaft des Stammverzeichnisses auf den aktuell angemeldeten Benutzer.

$ sudo chown -R $USER:$USER /var/www/neos

Wechsle in das Root-Verzeichnis.

$ cd /var/www/neos

Verwende den Composer, um Neos und seine Abhängigkeiten zu installieren.

$ composer create-project --no-dev neos/neos-base-distribution .

Vergiss nicht den Punkt am Ende des Befehls, der Composer anweist, das Programm im aktuellen Verzeichnis zu installieren. Möglicherweise erhältst du während der Installation die folgenden Warnungen. Gib y ein, um fortzufahren. Die Installation wird dadurch nicht behindert.

 - Installing neos/composer-plugin (2.1.3): Extracting archive
neos/composer-plugin contains a Composer plugin which is currently not in your allow-plugins config. See https://getcomposer.org/allow-plugins
Do you trust "neos/composer-plugin" to execute code and wish to enable it now? (writes "allow-plugins" to composer.json) [y,n,d,?] y

  - Installing composer/package-versions-deprecated (1.11.99.4): Extracting archive
composer/package-versions-deprecated contains a Composer plugin which is currently not in your allow-plugins config. See https://getcomposer.org/allow-plugins
Do you trust "composer/package-versions-deprecated" to execute code and wish to enable it now? (writes "allow-plugins" to composer.json) [y,n,d,?] y

Ändere die Eigentümerschaft des Stammverzeichnisses auf nginx.

$ sudo ./flow core:setfilepermissions $USER nginx nginx

Füge den aktuell angemeldeten Benutzer zur Gruppe nginx hinzu.

$ sudo usermod -a -G nginx $USER

Das war’s für den Moment. Wir werden die restlichen Konfigurationen später vornehmen.

Schritt 7 – SELinux-Berechtigungen konfigurieren

Verwende den SELinux-Befehl chcon, um den Dateisicherheitskontext für die Webinhalte zu ändern, die im Verzeichnis /var/www/neos bereitgestellt werden.

$ sudo chcon -t httpd_sys_content_t /var/www/neos -R
$ sudo chcon -t httpd_sys_rw_content_t /var/www/neos -R

Konfiguriere SELinux, um Netzwerkverbindungen für das Neos CMS zuzulassen.

$ sudo setsebool -P httpd_can_network_connect on

Schritt 8 – SSL installieren und konfigurieren

Um ein SSL-Zertifikat mit Let’s Encrypt zu installieren, müssen wir das Tool Certbot herunterladen. Für die Installation von Certbot benötigen wir das Epel-Repository, aber wir können diesen Schritt überspringen, da wir es bereits früher im Lehrgang installiert haben.

Installiere Certbot.

$ sudo dnf install certbot

Beende den Nginx-Server, da er das Certbot-Tool behindert.

$ sudo systemctl stop nginx

Erstelle ein SSL-Zertifikat.

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

Mit dem obigen Befehl wird ein Zertifikat in das Verzeichnis /etc/letsencrypt/live/neos.example.com auf deinem Server heruntergeladen.

Erstelle ein Diffie-Hellman-Gruppenzertifikat.

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

Erstelle ein Challenge-Web-Root-Verzeichnis für die automatische Erneuerung von Let’s Encrypt.

$ sudo mkdir -p /var/lib/letsencrypt

Erstelle einen Cron Job zur Erneuerung des SSL-Zertifikats. Er wird jeden Tag ausgeführt, um das Zertifikat zu überprüfen und bei Bedarf zu erneuern. Erstelle dazu zunächst die Datei /etc/cron.daily/certbot-renew und öffne sie zur Bearbeitung.

$ sudo nano /etc/cron.daily/certbot-renew

Füge den folgenden Code ein.

#!/bin/sh
certbot renew --cert-name neos.example.com --webroot -w /var/lib/letsencrypt/ --post-hook "systemctl reload nginx"

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Ändere die Berechtigungen für die Aufgabendatei, um sie ausführbar zu machen.

$ sudo chmod +x /etc/cron.daily/certbot-renew

Schritt 9 – Nginx und PHP konfigurieren

PHP-FPM konfigurieren

Öffne die Datei /etc/php-fpm.d/www.conf.

$ sudo nano /etc/php-fpm.d/www.conf

Wir müssen den Unix-Benutzer/die Unix-Gruppe der PHP-Prozesse auf nginx setzen. Suche die Zeilen user=www-data und group=www-data in der Datei und ändere sie in nginx.

...
; Unix user/group of processes
; Note: The user is mandatory. If the group is not set, the default user's group
;       will be used.
; RPM: apache user chosen to provide access to the same directories as httpd
user = nginx
; RPM: Keep a group allowed to write in log dir.
group = nginx
...

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Starten Sie den PHP-Dienst.

$ sudo systemctl start php-fpm

Nginx konfigurieren

Erstelle und öffne die Datei /etc/nginx/conf.d/neos.conf zur Bearbeitung.

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

Füge den folgenden Code in die Datei ein.

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

    access_log  /var/log/nginx/neos.access.log;
    error_log   /var/log/nginx/neos.error.log;
    
    # SSL
    ssl_certificate      /etc/letsencrypt/live/neos.example.com/fullchain.pem;
    ssl_certificate_key  /etc/letsencrypt/live/neos.example.com/privkey.pem;
    ssl_trusted_certificate /etc/letsencrypt/live/neos.example.com/chain.pem;
    ssl_session_timeout  5m;
    ssl_session_cache shared:MozSSL:10m;
    ssl_session_tickets off;
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_prefer_server_ciphers on;
    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;
    ssl_ecdh_curve X25519:prime256v1:secp384r1:secp521r1;
    ssl_stapling on;
    ssl_stapling_verify on;
    ssl_dhparam /etc/ssl/certs/dhparam.pem;
    resolver 8.8.8.8;

    root /var/www/neos/Web/;
    index index.php;
    
    location / {
        try_files $uri $uri/ /index.php?$args;
    }

    # Pass PHP Scripts To FastCGI Server
    location ~ \.php$ {
        fastcgi_split_path_info ^(.+\.php)(.*)$;
        fastcgi_pass unix:/run/php-fpm/www.sock; # Depends On The PHP Version
        fastcgi_index index.php;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        fastcgi_param PATH_INFO $fastcgi_path_info;
        fastcgi_param FLOW_REWRITEURLS  1;
	fastcgi_param FLOW_CONTEXT  Production;
    	fastcgi_param X-Forwarded-For $proxy_add_x_forwarded_for;
	fastcgi_param X-Forwarded-Port $proxy_port;
    	fastcgi_param REMOTE_ADDR $remote_addr;
	fastcgi_param REMOTE_PORT $remote_port;
    	fastcgi_param SERVER_ADDR $server_addr;
	fastcgi_param SERVER_NAME $http_host;
        fastcgi_read_timeout 300;
	fastcgi_buffer_size  128k;
    	fastcgi_buffers  256 16k;
	fastcgi_busy_buffers_size 256k;
    	fastcgi_temp_file_write_size 256k;
        include fastcgi_params;
        try_files $uri =404;
    }

    location ~ /_Resources/ {
   	access_log off;
	log_not_found off;
	expires max;

    	if (!-f $request_filename) {
    		rewrite "/_Resources/Persistent/([a-z0-9]{40})/.+\.(.+)" /_Resources/Persistent/$1.$2 break;
     		rewrite "/_Resources/Persistent(?>/[a-z0-9]{5}){8}/([a-f0-9]{40})/.+\.(.+)" /_Resources/Persistent/$1.$2 break;
    	}
    }
}

# enforce HTTPS
server {
    listen       80;
    listen       [::]:80;
    server_name  neos.example.com;
    return 301   https://$host$request_uri;
}

Beachte, dass das Stammverzeichnis, das in der Nginx-Konfiguration verwendet werden soll, /var/www/neos/Web/ und nicht /var/www/neos/ ist.

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 – Neos-Installation abschließen

Rufe die URL https://neos.example.com in deinem Browser auf und du erhältst den folgenden Einrichtungsbildschirm.

Neos Setup Bildschirm

Klicke auf die Schaltfläche Go to setup, um fortzufahren. Du wirst zum Anmeldebildschirm weitergeleitet.

Neos Login Screen

Führe den folgenden Befehl im Terminal aus, um dein Passwort zu erhalten.

$ cat /var/www/neos/Data/SetupPassword.txt
The setup password is:

SCPUYmmQ

After you successfully logged in, this file is automatically deleted for security reasons.
Make sure to save the setup password for later use.

Gib das Passwort ein und klicke auf Anmelden, um fortzufahren. Neos prüft nun, ob PHP-Bibliotheken vorhanden sind.

Neos PHP Check

Klicke auf Weiter, um fortzufahren. Du wirst aufgefordert, deine Datenbank-Anmeldedaten einzugeben. Gib die in Schritt 4 erstellten Anmeldedaten ein. Sobald die Zugangsdaten verifiziert sind, wird die MeldungVerbindung hergestellt angezeigt.

Neos Datenbank konfigurieren

Klicke auf Weiter, um fortzufahren. Du wirst aufgefordert, ein Administratorkonto einzurichten. Gib deine Daten ein.

Neos Administrator Konto

Klicke auf Weiter, um fortzufahren. Als Nächstes wirst du gefragt, ob du eine Demo-Site importieren oder eine neue Site erstellen möchtest. Wenn du eine neue Website von Grund auf erstellen willst, musst du beide Felder ausfüllen. Wenn du zum Beispiel eine Nachrichtenseite erstellen willst, füllst du die Felder wie angegeben aus. Vergiss nicht, dass die Seite kein CSS enthält, wenn du sie von Grund auf neu erstellst, und dass du es selbst machen musst.

Package Name: Neos.HowtoForgeNews
Site Name: HowtoForgeNews

Für unser Tutorial werden wir uns an die Demo-Site halten. Um eine Demoseite zu importieren, lass alle Felder leer.

Neos Website erstellen

Klicke auf Weiter, um fortzufahren. Du erhältst den Bildschirm zum Abschluss der Einrichtung.

Neos erfolgreiche Einrichtung

Klicke auf die Schaltfläche Zum Backend gehen, um den Anmeldebildschirm für das Control Panel zu öffnen. Gib deinen Benutzernamen und dein Passwort ein und klicke auf Anmelden, um das Administrationspanel zu öffnen.

Neos Control Panel

Da wir die Demoseite importiert haben, müssen wir im ersten Schritt die Try me-Seite löschen, damit jeder ein Backend-Konto mit Rechten zur Bearbeitung der Website einrichten kann.

Wechsle zur Try me-Seite in der linken Seitenleiste und klicke auf die Schaltfläche Löschen, die im Screenshot unten hervorgehoben ist.

Neos Try Me Seite Löschen

Klicke auf den orangefarbenen Pfeil rechts neben der SchaltflächeVeröffentlicht – Live, um das Dropdown-Menü zu öffnen, und klicke auf Alle veröffentlichen, um die Änderungen zu speichern.

Neos Änderungen veröffentlichen

Deine Neos CMS-Installation ist jetzt einsatzbereit.

Fazit

In diesem Tutorial hast du Neos CMS mit einem LEMP-Stack auf einem Rocky Linux 8 basierten Server installiert und konfiguriert. Wenn du Fragen hast, kannst du sie unten in den Kommentaren stellen.

Das könnte dich auch interessieren …