Craft CMS unter Debian 12 installieren
Craft CMS ist ein Open-Source Content Management System für die Erstellung aller Arten 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 sicherst und wiederherstellst.
Voraussetzungen
- Ein Server mit Debian 12 und mindestens 1 GB RAM.
- Ein Nicht-Root-Benutzer mit sudo-Rechten.
- Die Uncomplicated Firewall (UFW) ist aktiviert und läuft.
- 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 apt update && sudo apt upgrade - Ein paar wichtige Pakete werden benötigt, damit das Tutorial und das Craft CMS laufen. Einige davon befinden sich bereits auf deinem Server.
$ sudo apt install curl wget nano software-properties-common dirmngr apt-transport-https ca-certificates lsb-release debian-archive-keyring gnupg2 ufw unzip -y
Schritt 1 – Firewall konfigurieren
Der erste Schritt vor der Installation der Pakete ist die Konfiguration der Firewall, um HTTP- und HTTPS-Verbindungen zuzulassen.
Überprüfe den Status der Firewall.
$ sudo ufw status
Du solltest etwas wie das Folgende sehen.
Status: active
To Action From
-- ------ ----
OpenSSH ALLOW Anywhere
OpenSSH (v6) ALLOW Anywhere (v6)
Erlaube HTTP- und HTTPs-Ports.
$ sudo ufw allow http
$ sudo ufw allow https
Überprüfe den Status zur Bestätigung noch einmal.
$ sudo ufw status
Status: active
To Action From
-- ------ ----
OpenSSH ALLOW Anywhere
80/tcp ALLOW Anywhere
443/tcp ALLOW Anywhere
OpenSSH (v6) ALLOW Anywhere (v6)
80/tcp (v6) ALLOW Anywhere (v6)
443/tcp (v6) ALLOW Anywhere (v6)
Schritt 2 – Nginx installieren
Debian 12 wird mit einer älteren Version von Nginx ausgeliefert. Du musst das offizielle Nginx-Repository herunterladen, um die neueste Version zu installieren.
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
Starten Sie den Nginx-Server.
$ 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 Fri 2023-12-01 09:46:46 UTC; 18s ago
Docs: https://nginx.org/en/docs/
Process: 39483 ExecStart=/usr/sbin/nginx -c /etc/nginx/nginx.conf (code=exited, status=0/SUCCESS)
Main PID: 39484 (nginx)
Tasks: 2 (limit: 2315)
Memory: 1.7M
CPU: 6ms
CGroup: /system.slice/nginx.service
??39484 "nginx: master process /usr/sbin/nginx -c /etc/nginx/nginx.conf"
??39485 "nginx: worker process"
Schritt 3 – PHP und Erweiterungen installieren
Debian 12 wird standardmäßig mit PHP 8.2 ausgeliefert. Du kannst es und die Erweiterungen, die für das Craft CMS benötigt werden, mit dem folgenden Befehl installieren.
$ sudo apt 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
Wenn du immer die neueste Version von PHP verwenden oder mehrere Versionen von PHP installieren möchtest, füge Ondrejs PHP-Repository hinzu.
Importiere zunächst den PHP-GPG-Schlüssel von Sury’s Repository.
$ sudo curl -sSLo /usr/share/keyrings/deb.sury.org-php.gpg https://packages.sury.org/php/apt.gpg
Füge das PHP-Repository von Ondrej Sury hinzu.
$ sudo sh -c 'echo "deb [signed-by=/usr/share/keyrings/deb.sury.org-php.gpg] https://packages.sury.org/php/ $(lsb_release -sc) main" > /etc/apt/sources.list.d/php.list'
Aktualisiere die Repository-Liste deines Systems.
$ sudo apt update
Du wirst wahrscheinlich Informationen über anstehende Upgrades erhalten. Führe sie aus.
$ sudo apt upgrade
Installiere PHP und seine Erweiterungen.
$ sudo apt install php8.2 php8.2-cli php8.2-common php8.2-gmp php8.2-fpm php8.2-xmlrpc php8.2-bcmath php8.2-imagick php8.2-curl php8.2-zip php8.2-gd php8.2-mysql php8.2-xml php8.2-mbstring php8.2-xmlrpc php8.2-intl php8.2-pgsql
Überprüfe die installierte Version von PHP.
$ php --version
PHP 8.2.13 (cli) (built: Nov 24 2023 13:10:42) (NTS)
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
Überprüfe den Status des PHP-Dienstes.
$ sudo systemctl status php8.2-fpm
? php8.2-fpm.service - The PHP 8.2 FastCGI Process Manager
Loaded: loaded (/lib/systemd/system/php8.2-fpm.service; enabled; preset: enabled)
Active: active (running) since Fri 2023-12-01 10:29:53 UTC; 34min ago
Docs: man:php-fpm8.2(8)
Process: 65825 ExecStartPost=/usr/lib/php/php-fpm-socket-helper install /run/php/php-fpm.sock /etc/php/8.2/fpm/pool.d/www.conf 82 (code=exited, status=0/SUCCESS)
Main PID: 65821 (php-fpm8.2)
Status: "Processes active: 0, idle: 3, Requests: 208, slow: 0, Traffic: 0.2req/sec"
Tasks: 4 (limit: 2315)
Memory: 83.4M
CPU: 6.456s
CGroup: /system.slice/php8.2-fpm.service
??65821 "php-fpm: master process (/etc/php/8.2/fpm/php-fpm.conf)"
??65823 "php-fpm: pool www"
??65824 "php-fpm: pool www"
??65843 "php-fpm: pool www"
Schritt 4 – PHP-FPM konfigurieren
Öffne php.ini zur Bearbeitung.
$ sudo nano /etc/php/8.2/fpm/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/8.2/fpm/php.ini
$ sudo sed -i 's/post_max_size = 8M/post_max_size = 128M/' /etc/php/8.2/fpm/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/8.2/fpm/php.ini
Öffne die Datei /etc/php/8.2/fpm/pool.d/www.conf.
$ sudo nano /etc/php/8.2/fpm/pool.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.
user = nginx
group = nginx
...
Finde auch die Zeilen listen.owner=www-data und listen.group=www-data in der Datei und ändere sie in nginx.
listen.owner = nginx
listen.group = nginx
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. Andernfalls wird er fehlschlagen, da er die Gruppe nginx nicht finden kann.
$ sudo systemctl restart php8.2-fpm
Schritt 5 – Installiere Composer
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
Debian 12 wird standardmäßig mit PostgreSQL 15 ausgeliefert. Wir werden stattdessen PostgreSQL 16 verwenden.
Führe den folgenden Befehl aus, um den PostgreSQL GPG-Schlüssel hinzuzufügen.
$ curl https://www.postgresql.org/media/keys/ACCC4CF8.asc | gpg --dearmor | sudo tee /usr/share/keyrings/postgresql-key.gpg >/dev/null
Füge das APT-Repository zu deiner Quellenliste hinzu.
$ sudo sh -c 'echo "deb [signed-by=/usr/share/keyrings/postgresql-key.gpg arch=amd64] http://apt.postgresql.org/pub/repos/apt $(lsb_release -cs)-pgdg main" > /etc/apt/sources.list.d/pgdg.list'
Aktualisiere das System-Repository.
$ sudo apt update
Jetzt kannst du PostgreSQL mit dem unten stehenden Befehl installieren.
$ sudo apt install postgresql postgresql-contrib
Das Paket postgresql-contrib enthält einige zusätzliche Hilfsprogramme.
Überprüfe die Version.
$ psql --version
psql (PostgreSQL) 16.1 (Debian 16.1-1.pgdg120+1)
Überprüfe den Status des PostgreSQL-Dienstes.
$ sudo systemctl status postgresql
? postgresql.service - PostgreSQL RDBMS
Loaded: loaded (/lib/systemd/system/postgresql.service; enabled; preset: enabled)
Active: active (exited) since Wed 2023-11-29 05:54:03 UTC; 11s ago
Main PID: 20170 (code=exited, status=0/SUCCESS)
CPU: 1ms
Nov 29 05:54:03 craftcms systemd[1]: Starting postgresql.service - PostgreSQL RDBMS...
Nov 29 05:54:03 craftcms systemd[1]: Finished postgresql.service - PostgreSQL RDBMS.
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 (Debian 16.1-1.pgdg120+1))
SSL connection (protocol: TLSv1.3, cipher: TLS_AES_256_GCM_SHA384, compression: off)
Type "help" for help.
craftcms=>
Beende die Shell, indem du \q eingibst.
Schritt 7 – Redis installieren und konfigurieren
Debian 12 wird standardmäßig mit Redis 7.0 ausgeliefert, das wir auch verwenden werden. Installiere Redis.
$ sudo apt install redis
Überprüfe die Version.
$ redis-server --version
Redis server v=7.0.11 sha=00000000:0 malloc=jemalloc-5.3.0 bits=64 build=c4e7f6bf175a885b
Wenn du jedoch die neueste Version installieren möchtest, kannst du das offizielle Repository von Redis verwenden, indem du die folgenden Befehle eingibst.
$ curl -fsSL https://packages.redis.io/gpg | sudo gpg --dearmor -o /usr/share/keyrings/redis-archive-keyring.gpg
$ echo "deb [signed-by=/usr/share/keyrings/redis-archive-keyring.gpg] https://packages.redis.io/deb $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/redis.list
$ sudo apt update
$ sudo apt install redis
Der nächste Schritt ist die Authentifizierung des Redis-Servers. 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
Setze den aktuell angemeldeten Benutzer als Eigentümer dieses Verzeichnisses.
$ 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. Du kannst Certbot entweder ü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
Führe die folgenden Befehle aus, um sicherzustellen, 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, 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
---------------------------------------------------------------------------------------------------------------------------
Fri 2023-12-01 10:39:00 UTC 12min left Fri 2023-12-01 10:09:01 UTC 17min ago phpsessionclean.timer phpsessionclean.service
Fri 2023-12-01 17:01:47 UTC 6h left Thu 2023-11-30 17:01:47 UTC 17h ago systemd-tmpfiles-clean.timer systemd-tmpfiles-clean.service
Fri 2023-12-01 18:34:00 UTC 8h 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 – 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/php8.2-fpm.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 11 – 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 12 – 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, kopierst und speicherst du einfach 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 13 – 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.