So installierst du Craft CMS auf Rocky Linux 9
Craft CMS ist ein Open-Source Content Management System für die Erstellung von Websites. Es ist ein sicheres und skalierbares CMS mit einem umfangreichen Plugin-Ökosystem und hochwertigen kostenlosen und kostenpflichtigen Plugins. Es verfügt über ein intuitives, benutzerfreundliches Bedienfeld für die Erstellung von Inhalten und administrative Aufgaben. Es basiert auf dem PHP-Framework Yii. Das Templating-System wird von der Twig Template Engine angetrieben. Es kann sowohl mit MySQL- als auch mit PostgreSQL-Datenbanken arbeiten und nutzt die Redis-Datenbank für das Caching und die Sitzungsspeicherung.
In diesem Tutorium lernst du, wie du Craft CMS auf einem Debian 12 Server installierst. Außerdem erfährst du, wie du Redis für die Arbeit mit Craft CMS aktivierst und wie du eine mit Craft CMS erstellte Website sichern und wiederherstellen kannst.
Voraussetzungen
- Ein Server mit Rocky Linux 9 und mindestens 1 GB RAM.
- Ein Nicht-Root-Benutzer mit sudo-Rechten.
- Ein Fully Qualified Domain Name (FQDN) wie
craftcms.example.com, der auf deinen Server zeigt. - Ein SMTP-Konto bei einem E-Mail-Dienst wie Amazon SES oder Mailgun.
- Alles ist auf dem neuesten Stand.
$ sudo dnf update
- Ein paar wichtige Pakete werden benötigt, damit das Tutorial und das Craft CMS laufen. Einige davon befinden sich bereits auf deinem Server.
$ sudo dnf install wget curl nano unzip yum-utils policycoreutils-python-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 9 wird mit einer älteren Version von Nginx ausgeliefert. Du musst das offizielle Nginx-Repository verwenden, um die neueste Version zu installieren.
Erstelle und öffne die Datei /etc/yum.repos.d/nginx.repo zum Bearbeiten.
$ 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
Wenn du fertig bist, speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Installiere Nginx.
$ sudo dnf install nginx -y
Überprüfe die Installation.
$ nginx -v nginx version: nginx/1.24.0
Aktiviere und starte den Nginx Serverdienst.
$ sudo systemctl enable nginx --now
Überprüfe den Status des Dienstes.
$ sudo systemctl status nginx
? nginx.service - nginx - high performance web server
Loaded: loaded (/usr/lib/systemd/system/nginx.service; enabled; preset: disabled)
Active: active (running) since Mon 2023-12-04 14:01:19 UTC; 3s ago
Docs: http://nginx.org/en/docs/
Process: 59396 ExecStart=/usr/sbin/nginx -c /etc/nginx/nginx.conf (code=exited, status=0/SUCCESS)
Main PID: 59397 (nginx)
Tasks: 2 (limit: 10866)
Memory: 1.9M
CPU: 10ms
CGroup: /system.slice/nginx.service
??59397 "nginx: master process /usr/sbin/nginx -c /etc/nginx/nginx.conf"
??59398 "nginx: worker process"
Schritt 3 – PHP und Erweiterungen installieren
Rocky Linux 9 wird standardmäßig mit PHP 8.1 ausgeliefert. Um immer auf der neuesten PHP-Version zu bleiben oder wenn du mehrere PHP-Versionen installieren möchtest, müssen wir das REMI-Repository verwenden.
Der erste Schritt besteht darin, das Epel-Repository zu holen.
$ sudo dnf install epel-release -y
Als nächstes installierst du das Remi-Repository.
$ sudo dnf install https://rpms.remirepo.net/enterprise/remi-release-9.rpm
Prüfe, ob PHP-Streams verfügbar sind.
$ dnf module list php -y Name Stream Profiles Summary php 8.1 common [d], devel, minimal PHP scripting language Remi's Modular repository for Enterprise Linux 9 - x86_64 Name Stream Profiles Summary 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 php remi-8.2 common [d], devel, minimal PHP scripting language php remi-8.3 common [d], devel, minimal PHP scripting language Hint: [d]efault, [e]nabled, [x]disabled, [i]nstalled
Die Standardversion ist 8.1. Zum Zeitpunkt der Erstellung dieses Tutorials ist Craft CMS mit PHP 8.2 kompatibel. Aktiviere daher das PHP 8.2 Repository von Remi.
$ sudo dnf module reset php -y $ sudo dnf module enable php:remi-8.2
Installiere PHP und die für Craft CMS benötigten Erweiterungen.
$ sudo dnf install php php-cli php-common php-json php-gmp php-fpm php-xmlrpc php-bcmath php-imagick php-curl php-zip php-gd php-mysql php-xml php-mbstring php-xmlrpc php-intl php-pgsql
Überprüfe die installierte Version von PHP.
$ php --version
PHP 8.2.13 (cli) (built: Nov 21 2023 09:55:59) (NTS gcc x86_64)
Copyright (c) The PHP Group
Zend Engine v4.2.13, Copyright (c) Zend Technologies
with Zend OPcache v8.2.13, Copyright (c), by Zend Technologies
Aktiviere und starte den PHP-FPM-Dienst.
$ sudo systemctl enable php-fpm --now
Überprüfe den Status des PHP-Dienstes.
$ sudo systemctl status php-fpm
? php-fpm.service - The PHP FastCGI Process Manager
Loaded: loaded (/usr/lib/systemd/system/php-fpm.service; enabled; preset: disabled)
Active: active (running) since Mon 2023-12-04 14:05:58 UTC; 6s ago
Main PID: 61410 (php-fpm)
Status: "Ready to handle connections"
Tasks: 6 (limit: 10866)
Memory: 16.6M
CPU: 96ms
CGroup: /system.slice/php-fpm.service
??61410 "php-fpm: master process (/etc/php-fpm.conf)"
??61411 "php-fpm: pool www"
??61412 "php-fpm: pool www"
??61413 "php-fpm: pool www"
??61414 "php-fpm: pool www"
??61415 "php-fpm: pool www"
Schritt 4 – PHP-FPM konfigurieren
Öffne php.ini zur Bearbeitung.
$ sudo nano /etc/php.ini
Um die Datei-Upload-Größen festzulegen, ändere die Werte der Variablen upload_max_filesize und post_max_size. Dieser Wert bestimmt die Dateigröße, die du in das Craft CMS hochladen kannst. Für unsere Zwecke setzen wir ihn auf 128 MB. Du kannst ihn nach deinem Geschmack einstellen.
$ sudo sed -i 's/upload_max_filesize = 2M/upload_max_filesize = 128M/' /etc/php.ini $ sudo sed -i 's/post_max_size = 8M/post_max_size = 128M/' /etc/php.ini
Konfiguriere das Speicherlimit von PHP je nach den Ressourcen und Anforderungen deines Servers.
$ sudo sed -i 's/memory_limit = 128M/memory_limit = 256M/' /etc/php.ini
Ö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. Finde 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 ...
Finde die Zeilen listen.owner = nobody, listen.group = nobody, listen.mode = 0660 in der Datei und ändere sie wie folgt, nachdem du sie auskommentiert hast.
; Set permissions for unix socket, if one is used. In Linux, read/write ; permissions must be set in order to allow connections from a web server. Many ; BSD-derived systems allow connections regardless of permissions. The owner ; and group can be specified either by name or by their numeric IDs. ; Default Values: user and group are set as the running user ; mode is set to 0660 listen.owner = nginx listen.group = nginx listen.mode = 0660
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Starte den PHP-fpm-Prozess neu. Vergewissere dich, dass Nginx installiert ist, bevor du den PHP-Dienst neu startest, sonst schlägt er fehl, da er die Gruppe nginx nicht finden kann.
$ sudo systemctl restart php-fpm
Ändere die Gruppe des PHP-Sessions-Verzeichnisses auf Nginx.
$ sudo chgrp -R nginx /var/lib/php/session
Schritt 5 – Composer installieren
Composer fungiert als Abhängigkeitsmanager für PHP. Er ist auch der Abhängigkeitsmanager des Laravel-PHP-Frameworks, das Craft CMS betreibt.
Lade das Composer-Installationsskript herunter.
$ php -r "copy('https://getcomposer.org/installer', 'composer-setup.php');"
Überprüfe das heruntergeladene Installationsprogramm.
$ php -r "if (hash_file('sha384', 'composer-setup.php') === 'e21205b207c3ff031906575712edab6f13eb0b361f2085f1f1237b7126d785e826a450292b6cfd1d64d92e6563bbde02') { echo 'Installer verified'; } else { echo 'Installer corrupt'; unlink('composer-setup.php'); } echo PHP_EOL;"
Du wirst die folgende Ausgabe erhalten.
Installer verified
Führe das Installationsskript aus, um die neueste Version von Composer herunterzuladen.
$ php composer-setup.php
Entferne das Installationsskript.
$ php -r "unlink('composer-setup.php');"
Verschiebe die heruntergeladene Binärdatei in das Verzeichnis /usr/local/bin.
$ sudo mv composer.phar /usr/local/bin/composer
Bestätige die Installation.
$ composer --version Composer version 2.6.5 2023-10-06 10:11:52
Schritt 6 – PostgreSQL installieren und konfigurieren
Rocky Linux 9 wird standardmäßig mit PostgreSQL 13 ausgeliefert. Wir werden stattdessen PostgreSQL 16 aus dem offiziellen Repository verwenden.
Installiere das PostgreSQL RPM-Repository.
$ sudo dnf install -y https://download.postgresql.org/pub/repos/yum/reporpms/EL-9-x86_64/pgdg-redhat-repo-latest.noarch.rpm
Deaktiviere das integrierte PostgreSQL-Modul.
$ sudo dnf -qy module disable postgresql
Jetzt kannst du PostgreSQL mit dem unten stehenden Befehl installieren.
$ sudo dnf install -y postgresql16-server postgresql16-contrib
Das Paket postgresql-contrib enthält einige zusätzliche Hilfsprogramme.
Überprüfe die Version.
$ psql --version psql (PostgreSQL) 16.1
Initialisiere die PostgreSQL-Datenbank.
$ sudo /usr/pgsql-16/bin/postgresql-16-setup initdb Initializing database ... OK
Aktiviere den PostgreSQL-Dienst.
$ sudo systemctl enable postgresql-16
Starte den PostgreSQL-Dienst.
$ sudo systemctl start postgresql-16
Überprüfe den Status des PostgreSQL-Dienstes.
$ sudo systemctl status postgresql-16
? postgresql-16.service - PostgreSQL 16 database server
Loaded: loaded (/usr/lib/systemd/system/postgresql-16.service; enabled; preset: disabled)
Active: active (running) since Mon 2023-12-04 22:28:34 UTC; 2s ago
Docs: https://www.postgresql.org/docs/16/static/
Process: 72143 ExecStartPre=/usr/pgsql-16/bin/postgresql-16-check-db-dir ${PGDATA} (code=exited, status=0/SUCCESS)
Main PID: 72148 (postgres)
Tasks: 7 (limit: 10866)
Memory: 17.4M
CPU: 45ms
CGroup: /system.slice/postgresql-16.service
??72148 /usr/pgsql-16/bin/postgres -D /var/lib/pgsql/16/data/
??72149 "postgres: logger "
??72150 "postgres: checkpointer "
??72151 "postgres: background writer "
??72153 "postgres: walwriter "
??72154 "postgres: autovacuum launcher "
??72155 "postgres: logical replication launcher "
Dec 04 22:28:33 craftcms.nspeaks.com systemd[1]: Starting PostgreSQL 16 database server...
Dec 04 22:28:33 craftcms.nspeaks.com postgres[72148]: 2023-12-04 22:28:33.999 UTC [72148] LOG: redirecting log output to logging collector process
Dec 04 22:28:33 craftcms.nspeaks.com postgres[72148]: 2023-12-04 22:28:33.999 UTC [72148] HINT: Future log output will appear in directory "log".
Dec 04 22:28:34 craftcms.nspeaks.com systemd[1]: Started PostgreSQL 16 database server.
Du kannst sehen, dass der Dienst aktiviert ist und standardmäßig läuft.
Starte die PostgreSQL-Shell.
$ sudo -i -u postgres psql
Erstelle die Craft CMS-Datenbank.
postgres=# CREATE DATABASE craftcms;
Erstelle den Craft CMS-Benutzer und wähle ein sicheres Passwort.
postgres-# CREATE USER craftuser WITH PASSWORD 'Your_Password';
Ändere den Eigentümer der Datenbank auf den Craft CMS-Benutzer.
postgres-# ALTER DATABASE craftcms OWNER TO craftuser;
Erteile dem Craft CMS-Benutzer alle Rechte für die Datenbank.
postgres-# GRANT ALL PRIVILEGES ON DATABASE craftcms TO craftuser;
Beende die Shell.
postgres-# \q
Überprüfe, ob deine Anmeldedaten funktionieren.
$ psql --username craftuser --password --host localhost craftcms Password: psql (16.1) Type "help" for help. craftcms=>
Beende die Shell, indem du \q eingibst.
Schritt 7 – Redis installieren und konfigurieren
Rocky Linux 9 wird standardmäßig mit Redis 6.2 ausgeliefert. Wir werden jedoch Redis 7.0 verwenden, das wir mit Hilfe des Remi-Repositorys installieren werden.
Da wir das Remi Repository bereits bei der Installation von PHP installiert haben, können wir diesen Teil überspringen. Liste alle verfügbaren Redis-Module auf.
$ sudo dnf module list redis Rocky Linux 9 - AppStream Name Stream Profiles Summary redis 7 common [d] Redis persistent key-value database Remi's Modular repository for Enterprise Linux 9 - x86_64 Name Stream Profiles Summary redis remi-5.0 common [d] Redis persistent key-value database redis remi-6.0 common [d] Redis persistent key-value database redis remi-6.2 common [d] Redis persistent key-value database redis remi-7.0 common [d] Redis persistent key-value database redis remi-7.2 common [d] Redis persistent key-value database Hint: [d]efault, [e]nabled, [x]disabled, [i]nstalled
Aktiviere das neueste Redis 7.2 Modul.
$ sudo dnf module enable -y redis:remi-7.2
Installiere Redis.
$ sudo dnf install redis
Überprüfe die Version.
$ redis-server --version Redis server v=7.2.3 sha=00000000:0 malloc=jemalloc-5.3.0 bits=64 build=7bd3173e4e30c3e4
Aktiviere den Redis-Dienst.
$ sudo systemctl enable redis
Starte den Redis-Dienst.
$ sudo systemctl start redis
Überprüfe den Status des Dienstes.
$ sudo systemctl status redis
? redis.service - Redis persistent key-value database
Loaded: loaded (/usr/lib/systemd/system/redis.service; enabled; preset: disabled)
Drop-In: /etc/systemd/system/redis.service.d
??limit.conf
Active: active (running) since Mon 2023-12-04 22:36:25 UTC; 1min 32s ago
Main PID: 72877 (redis-server)
Status: "Ready to accept connections"
Tasks: 5 (limit: 10866)
Memory: 7.5M
CPU: 176ms
CGroup: /system.slice/redis.service
??72877 "/usr/bin/redis-server 127.0.0.1:6379"
Dec 04 22:36:25 craftcms.nspeaks.com systemd[1]: Starting Redis persistent key-value database...
Dec 04 22:36:25 craftcms.nspeaks.com systemd[1]: Started Redis persistent key-value database.
Der nächste Schritt ist das Hinzufügen der Authentifizierung zum Redis-Server. Seit Redis v6.0 ist es am besten, die Authentifizierung über ACL (Access Control Lists) vorzunehmen. Öffne die Datei /etc/redis/redis.conf zum Bearbeiten.
$ sudo nano /etc/redis/redis.conf
Suche die Zeile # aclfile /etc/redis/users.acl und entferne die Kommentare, indem du die Raute (#) vor der Zeile entfernst.
aclfile /etc/redis/users.acl
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Als Nächstes erstellst du die Datei /etc/redis/users.acl und öffnest sie zur Bearbeitung.
$ sudo nano /etc/redis/users.acl
Füge die folgende Zeile hinzu.
user navjot on +@all ~* >yourpassword
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Starte den Redis-Server neu, um die Änderung umzusetzen.
$ sudo systemctl restart redis
Öffne die Redis-Shell.
$ redis-cli
Verwende den Befehl PING. Es wird ein Authentifizierungsfehler angezeigt.
127.0.0.1:6379> PING (error) NOAUTH Authentication required.
Verwende den Befehl AUTH, um dich anzumelden.
127.0.0.1:6379> AUTH navjot yourpassword OK
Verwende erneut den Befehl PING.
127.0.0.1:6379> PING OK
Beende die Shell.
127.0.0.1:6379> exit
Du musst auch die PHP Redis-Erweiterung installieren.
$ sudo apt install php-redis
Schritt 8 – Craft CMS installieren
Bevor du Craft CMS installierst, kannst du mit folgendem Befehl überprüfen, ob du alle Servervoraussetzungen erfüllst, um es zu betreiben.
$ curl -Lsf https://raw.githubusercontent.com/craftcms/server-check/HEAD/check.sh | bash
Du wirst die folgende Ausgabe erhalten.
Running Craft Server Check… Craft CMS Requirement Checker This script checks if your web server configuration meets the requirements for running a Craft CMS installation. It checks if the server is running the right version of PHP, if appropriate PHP extensions have been loaded, and if php.ini file settings are correct. Results: -------- PHP 8.2+: OK BCMath extension: OK ctype extension: OK cURL extension: OK DOM extension: OK Fileinfo extension: OK GD extension or ImageMagick extension: OK iconv extension: OK Intl extension: OK JSON extension: OK Multibyte String extension (with Function Overloading disabled): OK OPcache extension (with save_comments): OK OpenSSL extension: OK PCRE extension (with UTF-8 support): OK PDO extension: OK Reflection extension: OK SPL extension: OK Zip extension: OK ignore_user_abort(): OK password_hash(): OK proc_close(): OK proc_get_status(): OK proc_open(): OK proc_terminate(): OK allow_url_fopen: OK ini_set calls: OK Memory Limit: OK ------------------------------------------ Errors: 0 Warnings: 0 Total checks: 27
Wenn alles in Ordnung ist, kannst du fortfahren. Erstelle das Web-Root-Verzeichnis.
$ sudo mkdir /var/www/html/craftcms -p
Lege den aktuell angemeldeten Benutzer als Eigentümer dieses Verzeichnisses fest.
$ sudo chown -R $USER:$USER /var/www/html/craftcms
Wechsle in das Verzeichnis.
$ cd /var/www/html/craftcms
Lade Craft CMS herunter und installiere es mit Composer. Der Punkt (.) am Ende des Befehls bedeutet, dass die Installation im aktuellen Verzeichnis durchgeführt werden soll.
$ composer create-project craftcms/craft .
Während der Installation wirst du nach einigen Details zur Datenbank und zum Administratorkonto gefragt. Die URL der Website und ihre Sprache werden wie unten gezeigt.
> @php craft setup/welcome
______ .______ ___ _______ .___________.
/ || _ \ / \ | ____|| |
| ,----'| |_) | / ^ \ | |__ `---| |----`
| | | / / /_\ \ | __| | |
| `----.| |\ \----./ _____ \ | | | |
\______|| _| `._____/__/ \__\ |__| |__|
A N E W I N S T A L L
______ .___ ___. _______.
/ || \/ | / |
| ,----'| \ / | | (----`
| | | |\/| | \ \
| `----.| | | | .----) |
\______||__| |__| |_______/
Generating an application ID ... done (CraftCMS--923f03f1-9bea-4c3d-a7ca-1466645ce75d)
Generating a security key ... done (iMdcUi6wQyf9MshEda__vZcCwILbclxz)
Welcome to Craft CMS!
Are you ready to begin the setup? (yes|no) [no]:yes
Which database driver are you using? (mysql or pgsql) [mysql] pgsql
Database server name or IP address: [127.0.0.1]
Database port: [5432]
Database username: [root] craftuser
Database password:
Database name: craftcms
Database table prefix:
Testing database credentials ... success!
Using default schema "public".
Saving database credentials to your .env file ... done
Install Craft now? (yes|no) [yes]:yes
Username: [admin] navjot
Email: navjot@example.com
Password:
Confirm:
Site name: Howtoforge Tutorials
Site URL: https://craftcms.example.com
Site language: [en-US]
*** installing Craft
Redis mit dem Craft CMS zusammenarbeiten lassen
Installiere das Paket yiisoft/yii2-redis.
$ composer require --prefer-dist yiisoft/yii2-redis:"~2.0.0"
Öffne die Datei /var/www/html/craftcms/config/app.php zum Bearbeiten.
$ nano config/app.php
Du wirst den folgenden Inhalt darin sehen.
use craft\helpers\App;
return [
'id' => App::env('CRAFT_APP_ID') ?: 'CraftCMS',
];
Ändere ihn wie folgt.
use craft\helpers\App;
return [
'id' => App::env('CRAFT_APP_ID') ?: 'CraftCMS',
'components' => [
'cache' => function() {
$config = [
'class' => yii\redis\Cache::class,
'keyPrefix' => Craft::$app->id,
'defaultDuration' => Craft::$app->config->general->cacheDuration,
// Full Redis connection details:
'redis' => [
'hostname' => App::env('REDIS_HOSTNAME') ?: 'localhost',
'port' => 6379,
'username' => App::env('REDIS_USERNAME') ?: null,
'password' => App::env('REDIS_PASSWORD') ?: null,
],
];
return Craft::createObject($config);
},
],
];
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst. Damit wird Redis als Cache-Speicher für Craft CMS aktiviert. Du kannst Redis auch für die Speicherung von PHP-Sitzungsdaten, die Jobwarteschlange und als Mutex-Treiber verwenden. Die Konfiguration dafür findest du in der Dokumentation von Craft CMS.
Außerdem musst du die Redis-Konfiguration in die Datei .env einfügen.
$ nano .env
Füge den folgenden Code am Ende der Datei ein.
REDIS_HOSTNAME=localhost REDIS_USERNAME=navjot REDIS_PASSWORD=yourpassword
Wähle die Optionen wie oben gezeigt. Wenn du fertig bist, ändere die Gruppe des Verzeichnisses in nginx. Auf diese Weise haben sowohl der aktuell eingeloggte Benutzer als auch Nginx Zugriff auf Craft CMS.
$ sudo chgrp -R nginx /var/www/html/craftcms
Gib der Gruppe nginx die Berechtigung, in das Verzeichnis zu schreiben.
$ sudo chmod -R g+w /var/www/html/craftcms
Von nun an brauchst du die Berechtigungen nicht mehr zu ändern und kannst alle Operationen durchführen, ohne Root-Rechte zu verwenden.
Schritt 9 – SSL installieren
Wir müssen Certbot installieren, um das SSL-Zertifikat zu erstellen. Dazu verwenden wir den Snapd-Paketinstaller. Da Rocky Linux nicht mit diesem Paket ausgeliefert wird, installierst du den Snapd-Installer. Er benötigt das EPEL (Extra Packages for Enterprise Linux) Repository, um zu funktionieren. Da wir es aber bereits in Schritt 3 installiert haben, können wir direkt fortfahren.
Installiere Snapd.
$ sudo dnf install -y snapd
Aktiviere und starte den Snap-Dienst.
$ sudo systemctl enable snapd --now
Installiere das Snap-Kernpaket und vergewissere dich, dass deine Version von Snapd auf dem neuesten Stand ist.
$ sudo snap install core && sudo snap refresh core
Erstelle die notwendigen Links, damit Snapd funktioniert.
$ 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
Installiere Certbot.
$ sudo snap install --classic certbot
Stelle mit dem folgenden 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, ob Certbot richtig funktioniert.
$ certbot --version certbot 2.7.4
Führe den folgenden Befehl aus, um ein SSL-Zertifikat zu erzeugen.
$ sudo certbot certonly --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m name@example.com -d craftcms.example.com
Mit dem obigen Befehl wird ein Zertifikat in das Verzeichnis /etc/letsencrypt/live/craftcms.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-Erneuerungszeitplanungsdienst.
$ 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 --------------------------------------------------------------------------------------------------------------------------- Mon 2023-12-04 23:38:47 UTC 18min left Mon 2023-12-04 22:19:02 UTC 1h 0min ago dnf-makecache.timer dnf-makecache.service Tue 2023-12-05 00:00:00 UTC 40min left - - logrotate.timer logrotate.service Tue 2023-12-05 09:36:00 UTC 10h left - - snap.certbot.renew.timer snap.certbot.renew.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 10 – SELinux konfigurieren
Ändere den Dateisicherheitskontext für Craft CMS.
$ sudo semanage fcontext -a -t httpd_sys_rw_content_t "/var/www/html/craftcms(/.*)?"
Wende die Richtlinie an.
$ sudo restorecon -Rv /var/www/html/craftcms/
Wende die Richtlinie an, um Nginx den Zugriff auf PostgreSQL zu ermöglichen.
$ sudo setsebool -P httpd_can_network_connect_db 1
Wende die Richtlinie an, um Verbindungen zu externen Hosts zu erlauben.
$ sudo setsebool -P httpd_can_network_connect 1
Mit MariaDB 10.11 wirst du mit einem weiteren Problem konfrontiert: SELinux verhindert, dass sich PHP-FPM mit MariaDB verbindet. Das kann durch die Installation eines SELinux-Moduls gelöst werden. Der erste Schritt besteht darin, eine Datei type enforcement zu erstellen.
Erstelle die Datei my-phpfpm.te in deinem Home-Verzeichnis und öffne sie zum Bearbeiten.
$ cd ~ $ nano my-phpfpm.te
Füge den folgenden Code in die Datei ein.
module my-phpfpm 1.0;
require {
type unconfined_service_t;
type httpd_t;
type httpd_sys_content_t;
class dir write;
class unix_stream_socket connectto;
}
#============= httpd_t ==============
#!!!! This avc is allowed in the current policy
allow httpd_t httpd_sys_content_t:dir write;
#!!!! This avc is allowed in the current policy
allow httpd_t unconfined_service_t:unix_stream_socket connectto;
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Im nächsten Schritt wandelst du sie mit dem folgenden Befehl in ein Richtlinienmodul um. Ändere den Dateinamen in dem Befehl nicht, sonst funktioniert er nicht. Das Modul heißt my-phpfpm und der Dateiname sollte mit dem Namen des Moduls übereinstimmen.
$ sudo checkmodule -M -m -o my-phpfpm.mod my-phpfpm.te
Als Nächstes müssen wir das Richtlinienmodul kompilieren, um ein Richtlinienpaket zu erstellen.
$ sudo semodule_package -o my-phpfpm.pp -m my-phpfpm.mod
Der letzte Schritt besteht darin, das Richtlinienpaket mit dem Befehl semodule zu laden, der die zu verwendende Richtlinie installiert.
$ sudo semodule -i my-phpfpm.pp
Schritt 11 – Nginx konfigurieren
Ö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.
Erstelle und öffne die Datei /etc/nginx/conf.d/craftcms.conf zum Bearbeiten.
$ sudo nano /etc/nginx/conf.d/craftcms.conf
Füge den folgenden Code in die Datei ein. Ersetze craftcms.example.com durch deinen Domainnamen. Vergewissere dich, dass der Wert von client_max_body_size auf 128 MB gesetzt ist, wie wir es bei der Konfiguration von PHP für Craft CMS festgelegt haben.
server {
listen 443 ssl http2;
listen [::]:443 ssl http2;
server_name craftcms.example.com;
root /var/www/html/craftcms/web;
index index.php;
client_max_body_size 128M;
access_log /var/log/nginx/craftcms.access.log;
error_log /var/log/nginx/craftcms.error.log;
ssl_certificate /etc/letsencrypt/live/craftcms.example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/craftcms.example.com/privkey.pem;
ssl_trusted_certificate /etc/letsencrypt/live/craftcms.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;
location / {
try_files $uri/index.html $uri $uri/ /index.php?$query_string;
}
location ~ [^/]\.php(/|$) {
try_files $uri $uri/ /index.php?$query_string;
fastcgi_index index.php;
fastcgi_split_path_info ^(.+\.php)(/.+)$;
fastcgi_keep_conn on;
include fastcgi_params;
fastcgi_pass unix:/run/php-fpm/www.sock;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
fastcgi_param PATH_INFO $fastcgi_path_info;
fastcgi_param HTTP_PROXY "";
}
}
# enforce HTTPS
server {
listen 80;
listen [::]:80;
server_name craftcms.example.com;
return 301 https://$host$request_uri;
}
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
Starte den Nginx-Server neu.
$ sudo systemctl restart nginx
Schritt 12 – Zugriff auf Craft CMS
Öffne die URL https://craftcms.example.com in deinem Browser und du wirst auf die folgende Seite weitergeleitet.
Um auf die Verwaltungsseite zuzugreifen, rufe die URL https://craftcms.example.com/admin auf und du wirst zur Anmeldeseite weitergeleitet.
Gib deine Zugangsdaten für die Verwaltung ein und klicke auf die Taste Anmelden, um dich einzuloggen. Du gelangst dann zum folgenden Dashboard.
Jetzt kannst du Craft CMS für die Erstellung deiner Website verwenden.
Schritt 13 – Craft CMS sichern und wiederherstellen
Du kannst die Datenbank von Craft CMS im Admin-Panel sichern, indem du Admin Dashboard >> Utilities >> Database Backup aufrufst.
Klicke auf die Schaltfläche Backup, um deine Datenbanksicherung herunterzuladen. Du kannst das Backup auch über das Terminal erstellen. Führe den folgenden Befehl aus, um das Backup zu erstellen. Gib dein Passwort ein, wenn du dazu aufgefordert wirst.
$ mysqldump -u craftcmsuser -p craftcms > ~/craftcms.database.sql
Du kannst die Datenbanksicherung auch mit dem Craft CMS Kommandozeilenprogramm erstellen. Der Vorteil dieses Dienstprogramms ist, dass du deine Zugangsdaten für die Datenbank nicht angeben musst. Mehr über das Craft CMS Kommandozeilendienstprogramm erfährst du hier.
$ cd /var/www/html/craftcms $ php craft db/backup ~/ Backing up the database ... done Backup file: /home/navjot/howtoforge-tutorials--2023-12-03-065138--v4.5.11.1.sql (200.019 KB)
Wenn du im obigen Befehl keinen Speicherort angibst, wird die Sicherungsdatei in das Verzeichnis /var/www/html/craftcms/storage/backups geschrieben.
Um die Dateien zu sichern, kopiere und speichere den gesamten Ordner /var/www/html/craftcms.
$ cd /var/www/html $ tar -zcf ~/craftcms.tar.gz craftcms
Um sie auf einem neuen Server wiederherzustellen, entpackst du die Dateien in den Ordner /var/www/html.
$ tar -xzf craftcms.tar.gz -C /var/www/html/
Erstelle eine Datenbank mit denselben Zugangsdaten auf dem neuen Server und stelle die Datenbank mit dem folgenden Befehl wieder her. Gib dein Passwort ein, wenn du dazu aufgefordert wirst.
$ mysqlimport -u craftcmsuser -p craftcms craftcms.database.sql
Schritt 14 – Craft CMS aktualisieren
Es gibt zwei Möglichkeiten, Craft CMS zu aktualisieren. Die eine ist über das Administrationspanel. Wenn ein Update verfügbar ist, erhältst du eine Benachrichtigung. Klicke auf den Hinweis, um zu aktualisieren. Craft CMS erstellt automatisch eine Sicherungskopie der Datenbank, bevor es ein Update durchführt.
Du kannst sie auch über das Terminal aktualisieren.
Um alle verfügbaren Updates zu prüfen, führe den folgenden Befehl aus.
$ cd /var/www/html/craftcms/ $ php craft update
Wenn ein Update verfügbar ist, führe den folgenden Befehl aus, um es anzuwenden.
$ php craft update all
Fazit
Dies ist der Abschluss unseres Tutorials, in dem du gelernt hast, wie du die Craft CMS Software auf einem Debian 12 Server installierst. Wenn du noch Fragen hast, schreibe sie in die Kommentare unten.