Installation Craft CMS · 22 min read · Sep 11, 2025
Comment installer Craft CMS sur Rocky Linux 9
Craft CMS est un système de gestion de contenu open-source pour la création de sites web. C’est un CMS sécurisé et évolutif avec un vaste écosystème de plugins et des plugins gratuits et payants de haute qualité. Il dispose d’un panneau de contrôle intuitif et convivial pour la création de contenu et les tâches administratives. Il est construit sur le framework PHP Yii. Le moteur de template Twig alimente son système de templating. Il peut fonctionner avec des bases de données MySQL et PostgreSQL pour le stockage et utilise la base de données Redis pour la mise en cache et le stockage des sessions.
Dans ce tutoriel, vous apprendrez comment installer Craft CMS sur un serveur Debian 12. Vous apprendrez également comment activer Redis pour travailler avec lui et comment sauvegarder et restaurer un site créé avec Craft CMS.
Prérequis
- Un serveur exécutant Rocky Linux 9 avec un minimum de 1 Go de RAM.
- Un utilisateur non-root avec des privilèges sudo.
- Un nom de domaine entièrement qualifié (FQDN) comme
craftcms.example.compointant vers votre serveur. - Un compte SMTP avec un service de messagerie comme Amazon SES ou Mailgun.
- Tout est à jour.
$ sudo dnf update - Quelques packages essentiels sont nécessaires pour le tutoriel et le fonctionnement de Craft CMS. Certains d’entre eux seront déjà sur votre serveur.
$ sudo dnf install wget curl nano unzip yum-utils policycoreutils-python-utils -y
Étape 1 - Configurer le pare-feu
La première étape consiste à configurer le pare-feu. Rocky Linux utilise le pare-feu Firewalld. Vérifiez l’état du pare-feu.
$ sudo firewall-cmd --state
running
Le pare-feu fonctionne avec différentes zones, et la zone publique est celle par défaut que nous allons utiliser. Listez tous les services et ports actifs sur le pare-feu.
$ sudo firewall-cmd --permanent --list-services
Il devrait afficher la sortie suivante.
cockpit dhcpv6-client ssh
Autorisez les ports HTTP et HTTPS.
$ sudo firewall-cmd --permanent --add-service=http
$ sudo firewall-cmd --permanent --add-service=https
Vérifiez à nouveau l’état du pare-feu.
$ sudo firewall-cmd --permanent --list-services
Vous devriez voir une sortie similaire.
cockpit dhcpv6-client http https ssh
Rechargez le pare-feu pour activer les changements.
$ sudo firewall-cmd --reload
Étape 2 - Installer Nginx
Rocky Linux 9 est livré avec une version plus ancienne de Nginx. Vous devez utiliser le dépôt officiel de Nginx pour installer la dernière version.
Créez et ouvrez le fichier /etc/yum.repos.d/nginx.repo pour l’éditer.
$ sudo nano /etc/yum.repos.d/nginx.repo
Collez le code suivant dedans.
[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
Une fois que vous avez terminé, enregistrez le fichier en appuyant sur Ctrl + X et en entrant Y lorsque vous y êtes invité.
Installez Nginx.
$ sudo dnf install nginx -y
Vérifiez l’installation.
$ nginx -v
nginx version: nginx/1.24.0
Activez et démarrez le service du serveur Nginx.
$ sudo systemctl enable nginx --now
Vérifiez l’état du service.
$ sudo systemctl status nginx
? nginx.service - nginx - serveur web haute performance
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"
Étape 3 - Installer PHP et ses extensions
Rocky Linux 9 est livré avec PHP 8.1 par défaut. Pour rester toujours sur la dernière version de PHP ou si vous souhaitez installer plusieurs versions de PHP, nous devons utiliser le dépôt REMI.
La première étape consiste à récupérer le dépôt Epel.
$ sudo dnf install epel-release -y
Ensuite, installez le dépôt Remi.
$ sudo dnf install https://rpms.remirepo.net/enterprise/remi-release-9.rpm
Vérifiez les flux PHP disponibles.
$ 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
La version par défaut est 8.1. Au moment de la rédaction de ce tutoriel, Craft CMS est compatible avec PHP 8.2. Par conséquent, activez le dépôt PHP 8.2 de Remi.
$ sudo dnf module reset php -y
$ sudo dnf module enable php:remi-8.2
Installez PHP et ses extensions requises par Craft CMS.
$ 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
Vérifiez la version de PHP installée.
$ 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
Activez et démarrez le service PHP-FPM.
$ sudo systemctl enable php-fpm --now
Vérifiez l’état du service PHP.
$ 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"
Étape 4 - Configurer PHP-FPM
Ouvrez php.ini pour l’éditer.
$ sudo nano /etc/php.ini
Pour définir les tailles de téléchargement de fichiers, changez les valeurs des variables upload_max_filesize et post_max_size. Cette valeur détermine la taille de fichier que vous pouvez télécharger sur Craft CMS. Pour nos besoins, nous la définissons à 128 Mo. Vous pouvez la définir selon vos préférences.
$ 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
Configurez la limite de mémoire de PHP en fonction des ressources et des besoins de votre serveur.
$ sudo sed -i 's/memory_limit = 128M/memory_limit = 256M/' /etc/php.ini
Ouvrez le fichier /etc/php-fpm.d/www.conf.
$ sudo nano /etc/php-fpm.d/www.conf
Nous devons définir l’utilisateur/groupe Unix des processus PHP sur nginx. Trouvez les lignes user=www-data et group=www-data dans le fichier et changez-les en 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
...
Trouvez les lignes listen.owner = nobody, listen.group = nobody, listen.mode = 0660 dans le fichier et changez-les comme suit après les avoir décommentées.
; 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
Enregistrez le fichier en appuyant sur Ctrl + X et en entrant Y lorsque vous y êtes invité.
Redémarrez le processus PHP-fpm. Assurez-vous d’avoir Nginx installé avant de redémarrer le service PHP, sinon, il échouera car il ne pourra pas trouver le groupe nginx.
$ sudo systemctl restart php-fpm
Changez le groupe du répertoire des sessions PHP en Nginx.
$ sudo chgrp -R nginx /var/lib/php/session
Étape 5 - Installer Composer
Composer agit comme un gestionnaire de dépendances pour PHP. C’est également le gestionnaire de dépendances du framework PHP Laravel, qui est ce qui alimente Craft CMS.
Téléchargez le script d’installation de Composer.
$ php -r "copy('https://getcomposer.org/installer', 'composer-setup.php');"
Vérifiez l’installateur téléchargé.
$ php -r "if (hash_file('sha384', 'composer-setup.php') === 'e21205b207c3ff031906575712edab6f13eb0b361f2085f1f1237b7126d785e826a450292b6cfd1d64d92e6563bbde02') { echo 'Installer verified'; } else { echo 'Installer corrupt'; unlink('composer-setup.php'); } echo PHP_EOL;"
Vous recevrez la sortie suivante.
Installer verified
Exécutez le script d’installation pour télécharger la dernière version de Composer.
$ php composer-setup.php
Supprimez le script d’installation.
$ php -r "unlink('composer-setup.php');"
Déplacez le fichier binaire téléchargé vers le répertoire /usr/local/bin.
$ sudo mv composer.phar /usr/local/bin/composer
Confirmez l’installation.
$ composer --version
Composer version 2.6.5 2023-10-06 10:11:52
Étape 6 - Installer et configurer PostgreSQL
Rocky Linux 9 est livré avec PostgreSQL 13 par défaut. Nous allons utiliser PostgreSQL 16 à la place depuis son dépôt officiel.
Installez le dépôt RPM de PostgreSQL.
$ sudo dnf install -y https://download.postgresql.org/pub/repos/yum/reporpms/EL-9-x86_64/pgdg-redhat-repo-latest.noarch.rpm
Désactivez le module PostgreSQL intégré.
$ sudo dnf -qy module disable postgresql
Maintenant, vous pouvez installer PostgreSQL en utilisant la commande ci-dessous.
$ sudo dnf install -y postgresql16-server postgresql16-contrib
Le package postgresql-contrib contient quelques utilitaires supplémentaires.
Vérifiez la version.
$ psql --version
psql (PostgreSQL) 16.1
Initialisez la base de données PostgreSQL.
$ sudo /usr/pgsql-16/bin/postgresql-16-setup initdb
Initializing database ... OK
Activez le service PostgreSQL.
$ sudo systemctl enable postgresql-16
Démarrez le service PostgreSQL.
$ sudo systemctl start postgresql-16
Vérifiez l’état du service PostgreSQL.
$ 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.
Vous pouvez voir que le service est activé et en cours d’exécution par défaut.
Lancez le shell PostgreSQL.
$ sudo -i -u postgres psql
Créez la base de données Craft CMS.
postgres=# CREATE DATABASE craftcms;
Créez l’utilisateur Craft CMS et choisissez un mot de passe fort.
postgres-# CREATE USER craftuser WITH PASSWORD 'Your_Password';
Changez le propriétaire de la base de données à l’utilisateur Craft CMS.
postgres-# ALTER DATABASE craftcms OWNER TO craftuser;
Accordez tous les privilèges sur la base de données à l’utilisateur Craft CMS.
postgres-# GRANT ALL PRIVILEGES ON DATABASE craftcms TO craftuser;
Quittez le shell.
postgres-# \q
Vérifiez que vos identifiants fonctionnent.
$ psql --username craftuser --password --host localhost craftcms
Password:
psql (16.1)
Type "help" for help.
craftcms=>
Quittez le shell en tapant \q.
Étape 7 - Installer et configurer Redis
Rocky Linux 9 est livré avec Redis 6.2 par défaut. Cependant, nous allons utiliser Redis 7.0 que nous allons installer en utilisant le dépôt Remi.
Puisque nous avons installé le dépôt Remi lors de l’installation de PHP, nous pouvons sauter cette partie. Listez tous les modules Redis disponibles.
$ 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
Activez le dernier module Redis 7.2.
$ sudo dnf module enable -y redis:remi-7.2
Installez Redis.
$ sudo dnf install redis
Vérifiez la version.
$ redis-server --version
Redis server v=7.2.3 sha=00000000:0 malloc=jemalloc-5.3.0 bits=64 build=7bd3173e4e30c3e4
Activez le service Redis.
$ sudo systemctl enable redis
Démarrez le service Redis.
$ sudo systemctl start redis
Vérifiez l’état du service.
$ 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.
La prochaine étape consiste à ajouter une authentification au serveur Redis. Depuis Redis v6.0, la meilleure façon d’ajouter une authentification est d’utiliser les ACL (Listes de Contrôle d’Accès). Ouvrez le fichier /etc/redis/redis.conf pour l’éditer.
$ sudo nano /etc/redis/redis.conf
Trouvez la ligne # aclfile /etc/redis/users.acl et décommentez-la en supprimant le hash (#) devant.
aclfile /etc/redis/users.acl
Enregistrez le fichier en appuyant sur Ctrl + X et en entrant Y lorsque vous y êtes invité.
Ensuite, créez et ouvrez le fichier /etc/redis/users.acl pour l’éditer.
$ sudo nano /etc/redis/users.acl
Ajoutez la ligne suivante.
user navjot on +@all ~* >yourpassword
Enregistrez le fichier en appuyant sur Ctrl + X et en entrant Y lorsque vous y êtes invité.
Redémarrez le serveur Redis pour appliquer le changement.
$ sudo systemctl restart redis
Ouvrez le shell Redis.
$ redis-cli
Utilisez la commande PING. Cela donnera une erreur d’authentification.
127.0.0.1:6379> PING
(error) NOAUTH Authentication required.
Utilisez la commande AUTH pour vous connecter.
127.0.0.1:6379> AUTH navjot yourpassword
OK
Utilisez à nouveau la commande PING.
127.0.0.1:6379> PING
OK
Quittez le shell.
127.0.0.1:6379> exit
Vous devrez également installer l’extension PHP Redis.
$ sudo apt install php-redis
Étape 8 - Installer Craft CMS
Avant d’installer Craft CMS, vous pouvez vérifier si vous remplissez toutes les exigences du serveur pour le faire en utilisant la commande suivante.
$ curl -Lsf https://raw.githubusercontent.com/craftcms/server-check/HEAD/check.sh | bash
Vous obtiendrez la sortie suivante.
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
Une fois que tout est en ordre, vous pouvez procéder. Créez le répertoire racine du web.
$ sudo mkdir /var/www/html/craftcms -p
Définissez l’utilisateur actuellement connecté comme propriétaire de ce répertoire.
$ sudo chown -R $USER:$USER /var/www/html/craftcms
Passez au répertoire.
$ cd /var/www/html/craftcms
Téléchargez et installez Craft CMS en utilisant Composer. Le point (.) à la fin de la commande signifie que l’installation doit être effectuée dans le répertoire actuel.
$ composer create-project craftcms/craft .
Lors de l’installation, vous serez invité à fournir plusieurs détails concernant la base de données, le compte administrateur, l’URL du site et sa langue comme indiqué ci-dessous.
> @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: [email protected]
Password:
Confirm:
Site name: Howtoforge Tutorials
Site URL: https://craftcms.example.com
Site language: [en-US]
*** installing Craft
Faire fonctionner Redis avec Craft CMS
Installez le package yiisoft/yii2-redis.
$ composer require --prefer-dist yiisoft/yii2-redis:"~2.0.0"
Ouvrez le fichier /var/www/html/craftcms/config/app.php pour l’éditer.
$ nano config/app.php
Vous verrez le contenu suivant.
use craft\helpers\App;
return [
'id' => App::env('CRAFT_APP_ID') ?: 'CraftCMS',
];
Changez-le comme suit.
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);
},
],
];
Enregistrez le fichier en appuyant sur Ctrl + X et en entrant Y lorsque vous y êtes invité. Cela active Redis comme stockage de cache pour Craft CMS. Vous pouvez également utiliser Redis pour stocker des données de session PHP, une file d’attente de tâches et comme pilote mutex. Vous pouvez trouver la configuration pour cela dans la documentation de Craft CMS.
Vous devez également ajouter la configuration Redis au fichier .env.
$ nano .env
Ajoutez le code suivant à la fin du fichier.
REDIS_HOSTNAME=localhost
REDIS_USERNAME=navjot
REDIS_PASSWORD=yourpassword
Choisissez les options comme indiqué ci-dessus. Une fois terminé, changez le groupe du répertoire en nginx. De cette façon, l’utilisateur actuellement connecté et Nginx auront accès à Craft CMS.
$ sudo chgrp -R nginx /var/www/html/craftcms
Donnez au groupe nginx la permission d’écrire dans le répertoire.
$ sudo chmod -R g+w /var/www/html/craftcms
À partir de maintenant, vous n’aurez plus besoin de changer les permissions et pourrez effectuer toutes les opérations sans utiliser de privilèges root.
Étape 9 - Installer SSL
Nous devons installer Certbot pour générer le certificat SSL. Nous utiliserons le gestionnaire de paquets Snapd pour cela. Comme Rocky Linux ne l’inclut pas, installez le gestionnaire Snapd. Il nécessite le dépôt EPEL (Extra Packages for Enterprise Linux) pour fonctionner. Mais comme nous l’avons déjà installé à l’étape 3, nous pouvons directement avancer.
Installez Snapd.
$ sudo dnf install -y snapd
Activez et démarrez le service Snap.
$ sudo systemctl enable snapd --now
Installez le package de base Snap, et assurez-vous que votre version de Snapd est à jour.
$ sudo snap install core && sudo snap refresh core
Créez les liens nécessaires pour que Snapd fonctionne.
$ 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
Installez Certbot.
$ sudo snap install --classic certbot
Utilisez la commande suivante pour vous assurer que la commande Certbot peut être exécutée en créant un lien symbolique vers le répertoire /usr/bin.
$ sudo ln -s /snap/bin/certbot /usr/bin/certbot
Vérifiez si Certbot fonctionne correctement.
$ certbot --version
certbot 2.7.4
Exécutez la commande suivante pour générer un certificat SSL.
$ sudo certbot certonly --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m [email protected] -d craftcms.example.com
La commande ci-dessus téléchargera un certificat dans le répertoire /etc/letsencrypt/live/craftcms.example.com sur votre serveur.
Générez un certificat de groupe Diffie-Hellman.
$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096
Vérifiez le service de planification de renouvellement de Certbot.
$ sudo systemctl list-timers
Vous trouverez snap.certbot.renew.service comme l’un des services programmés pour s’exécuter.
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
Faites un essai de la procédure pour vérifier si le renouvellement SSL fonctionne correctement.
$ sudo certbot renew --dry-run
Si vous ne voyez pas d’erreurs, vous êtes prêt. Votre certificat se renouvellera automatiquement.
Étape 10 - Configurer SELinux
Changez le contexte de sécurité des fichiers pour Craft CMS.
$ sudo semanage fcontext -a -t httpd_sys_rw_content_t "/var/www/html/craftcms(/.*)?"
Appliquez la politique.
$ sudo restorecon -Rv /var/www/html/craftcms/
Appliquez la politique pour permettre à Nginx d’accéder à PostgreSQL.
$ sudo setsebool -P httpd_can_network_connect_db 1
Appliquez la politique pour permettre des connexions vers des hôtes externes.
$ sudo setsebool -P httpd_can_network_connect 1
Avec MariaDB 10.11, vous rencontrerez un autre problème qui est que SELinux empêche PHP-FPM de se connecter à MariaDB. Cela peut être résolu en installant un module SELinux. La première étape consiste à créer un fichier type enforcement.
Créez le fichier my-phpfpm.te dans votre répertoire personnel et ouvrez-le pour l’éditer.
$ cd ~
$ nano my-phpfpm.te
Collez le code suivant dedans.
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;
Enregistrez le fichier en appuyant sur Ctrl + X et en entrant Y lorsque vous y êtes invité.
La prochaine étape consiste à le convertir en module de politique en utilisant la commande suivante. Ne modifiez pas le nom du fichier dans la commande sinon cela ne fonctionnera pas. Le module s’appelle my-phpfpm et le nom du fichier doit être le même que le nom du module.
$ sudo checkmodule -M -m -o my-phpfpm.mod my-phpfpm.te
Ensuite, nous devons compiler le module de politique pour créer un package de politique.
$ sudo semodule_package -o my-phpfpm.pp -m my-phpfpm.mod
La dernière étape consiste à charger le package de politique en utilisant la commande semodule qui installe la politique à utiliser.
$ sudo semodule -i my-phpfpm.pp
Étape 11 - Configurer Nginx
Ouvrez le fichier /etc/nginx/nginx.conf pour l’éditer.
$ sudo nano /etc/nginx/nginx.conf
Ajoutez la ligne suivante avant la ligne include /etc/nginx/conf.d/*.conf;.
server_names_hash_bucket_size 64;
Enregistrez le fichier en appuyant sur Ctrl + X et en entrant Y lorsque vous y êtes invité.
Créez et ouvrez le fichier /etc/nginx/conf.d/craftcms.conf pour l’éditer.
$ sudo nano /etc/nginx/conf.d/craftcms.conf
Collez le code suivant dedans. Remplacez craftcms.example.com par votre nom de domaine. Assurez-vous que la valeur de client_max_body_size est définie sur 128 Mo, ce qui est ce que nous avons défini pour Craft CMS lors de la configuration de PHP précédemment.
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;
}
Enregistrez le fichier en appuyant sur Ctrl + X et en entrant Y lorsque vous y êtes invité.
Vérifiez votre configuration Nginx.
$ sudo nginx -t
Redémarrez le serveur Nginx.
$ sudo systemctl restart nginx
Étape 12 - Accéder à Craft CMS
Ouvrez l’URL https://craftcms.example.com dans votre navigateur et vous serez dirigé vers la page suivante.
Pour accéder à la page d’administration, visitez l’URL https://craftcms.example.com/admin et vous serez dirigé vers la page de connexion.
Entrez vos identifiants d’administration et cliquez sur la touche Se connecter pour vous connecter. Vous serez dirigé vers le tableau de bord suivant.
Vous pouvez maintenant commencer à utiliser Craft CMS pour construire votre site web.
Étape 13 - Sauvegarder et restaurer Craft CMS
Vous pouvez sauvegarder la base de données de Craft CMS depuis le panneau d’administration en visitant Tableau de bord Admin >> Utilitaires >> Sauvegarde de la base de données.
Cliquez sur le bouton Sauvegarder pour télécharger votre sauvegarde de base de données. Vous pouvez également créer la sauvegarde en utilisant le terminal. Exécutez la commande suivante pour créer la sauvegarde. Entrez votre mot de passe lorsque vous y êtes invité.
$ mysqldump -u craftcmsuser -p craftcms > ~/craftcms.database.sql
Vous pouvez également créer la sauvegarde de la base de données en utilisant l’utilitaire en ligne de commande de Craft CMS. L’avantage de cet utilitaire est que vous n’avez pas besoin de passer vos identifiants de base de données. Lisez-en plus sur l’utilitaire de console de commande de Craft CMS ici.
$ 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)
Si vous ne spécifiez aucun emplacement dans la commande ci-dessus, le fichier de sauvegarde sera écrit dans le répertoire /var/www/html/craftcms/storage/backups.
Pour sauvegarder les fichiers, copiez et enregistrez l’ensemble du dossier /var/www/html/craftcms.
$ cd /var/www/html
$ tar -zcf ~/craftcms.tar.gz craftcms
Pour le restaurer sur un nouveau serveur, extrayez les fichiers dans le dossier /var/www/html.
$ tar -xzf craftcms.tar.gz -C /var/www/html/
Créez une base de données avec les mêmes identifiants sur le nouveau serveur et restaurez la base de données en utilisant la commande suivante. Entrez votre mot de passe lorsque vous y êtes invité.
$ mysqlimport -u craftcmsuser -p craftcms craftcms.database.sql
Étape 14 - Mettre à jour Craft CMS
Il existe deux façons de mettre à jour Craft CMS. L’une est depuis le panneau d’administration. Lorsqu’une mise à jour est disponible, vous recevrez un avis. Cliquez sur l’avis pour mettre à niveau. Craft CMS sauvegardera automatiquement la base de données avant d’effectuer une mise à jour.
Vous pouvez également le mettre à jour via le terminal.
Pour vérifier toutes les mises à jour disponibles, exécutez la commande suivante.
$ cd /var/www/html/craftcms/
$ php craft update
Si une mise à jour est disponible, exécutez la commande suivante pour l’appliquer.
$ php craft update all
Conclusion
Cela conclut notre tutoriel où vous avez appris comment installer le logiciel Craft CMS sur un serveur Debian 12. Si vous avez des questions, postez-les dans les commentaires ci-dessous.
Recevez de nouveaux articles dans votre boîte de réception.
Aucun spam. Désabonnez-vous à tout moment.