Comment installer Craft CMS sur Debian 12

Ce tutoriel existe pour ces versions d'OS

Debian 12 (Bookworm)
Debian 11 (Bullseye)
Debian 9 (étirement)

Sur cette page

Conditions préalables
Étape 1 - Configurer le pare-feu
Étape 2 - Installer Nginx
Étape 3 - Installez PHP et les extensions
Étape 4 - Configurer PHP-FPM
Étape 5 - Installer Composer
Étape 6 - Installer et configurer PostgreSQL
Étape 7 - Installer et configurer Redis
Étape 8 - Installer Craft CMS
1. Faire fonctionner Redis avec Craft CMS
Étape 9 - Installer SSL
Étape 10 - Configurer Nginx
Étape 11 - Accéder à Craft CMS
Étape 12 - Sauvegarde et restauration de Craft CMS
Étape 13 - Mettre à jour Craft CMS
Conclusion

Craft CMS est un système de gestion de contenu open source permettant de créer toutes sortes de sites Web. Il s'agit d'un CMS sécurisé et évolutif doté d'un vaste écosystème de plugins et de 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 modèles Twig alimente son système de modèles. Il peut fonctionner avec les 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 de session.

Dans ce tutoriel, vous apprendrez comment installer Craft CMS sur un serveur Debian 12. Vous apprendrez également comment permettre à Redis de fonctionner avec et comment sauvegarder et restaurer un site créé à l'aide de Craft CMS.

Conditions préalables

Un serveur exécutant Debian 12 avec un minimum de 1 Go de RAM.

Un utilisateur non root avec les privilèges sudo.

Le pare-feu simple (UFW) est activé et en cours d'exécution.

Un nom de domaine complet (FQDN) tel que craftcms.example.com pointant vers votre serveur.

Un compte SMTP avec un service de messagerie comme Amazon SES ou Mailgun.

Tout est mis à jour.

$ sudo apt update && sudo apt upgrade

Quelques packages essentiels sont requis pour que le didacticiel et Craft CMS fonctionnent. Certains d'entre eux seront déjà sur votre serveur.

$ sudo apt install curl wget nano software-properties-common dirmngr apt-transport-https ca-certificates lsb-release debian-archive-keyring gnupg2 ufw unzip -y

Étape 1 - Configurer le pare-feu

La première étape avant d'installer un package consiste à configurer le pare-feu pour autoriser les connexions HTTP et HTTPS.

Vérifiez l'état du pare-feu.

$ sudo ufw status

Vous devriez voir quelque chose comme ce qui suit.

Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere
OpenSSH (v6)               ALLOW       Anywhere (v6)

Autoriser les ports HTTP et HTTPs.

$ sudo ufw allow http
$ sudo ufw allow https

Vérifiez à nouveau l'état pour confirmer.

$ 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)

Étape 2 - Installer Nginx

Debian 12 est livré avec une ancienne version de Nginx. Vous devez télécharger le référentiel officiel Nginx pour installer la dernière version.

Importez la clé de signature de Nginx.

$ curl https://nginx.org/keys/nginx_signing.key | gpg --dearmor \
    | sudo tee /usr/share/keyrings/nginx-archive-keyring.gpg >/dev/null

Ajoutez le référentiel pour la version stable de Nginx.

$ 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

Mettez à jour les référentiels système.

$ sudo apt update

Installez Nginx.

$ sudo apt install nginx

Vérifiez l'installation. Sur les systèmes Debian, la commande suivante ne fonctionnera qu'avec sudo.

$ sudo nginx -v
nginx version: nginx/1.24.0

Démarrez le serveur Nginx.

$ sudo systemctl start nginx

Vérifiez l'état du service.

$ 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"

Étape 3 - Installez PHP et les extensions

Debian 12 est livré avec PHP 8.2 par défaut. Vous pouvez l'installer ainsi que les extensions requises par Craft CMS en exécutant la commande suivante.

$ 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

Pour toujours rester sur la dernière version de PHP ou si vous souhaitez installer plusieurs versions de PHP, ajoutez le dépôt PHP d'Ondrej.

Tout d’abord, importez la clé PHP GPG du dépôt de Sury.

$ sudo curl -sSLo /usr/share/keyrings/deb.sury.org-php.gpg https://packages.sury.org/php/apt.gpg

Ajoutez le référentiel PHP d'Ondrej Sury.

$ 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'

Mettez à jour la liste de vos référentiels système.

$ sudo apt update

Vous recevrez probablement des informations sur les mises à niveau en attente. Exécutez-les.

$ sudo apt upgrade

Installez PHP et ses extensions.

$ 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

Vérifiez la version de PHP installée.

$ 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

Vérifiez l'état du service PHP.

$ 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"

Étape 4 - Configurer PHP-FPM

Ouvrez php.ini pour le modifier.

$ sudo nano /etc/php/8.2/fpm/php.ini

Pour définir les tailles de téléchargement de fichiers, modifiez les valeurs des variables upload_max_filesize et post_max_size. Cette valeur détermine la taille du fichier que vous pouvez télécharger sur Craft CMS. Pour nos besoins, nous le fixons à 128 Mo. Vous pouvez le régler à votre guise.

$ 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

Configurez la limite de mémoire de PHP en fonction des ressources et des exigences de votre serveur.

$ sudo sed -i 's/memory_limit = 128M/memory_limit = 256M/' /etc/php/8.2/fpm/php.ini

Ouvrez le fichier /etc/php/8.2/fpm/pool.d/www.conf.

$ sudo nano /etc/php/8.2/fpm/pool.d/www.conf

Nous devons définir l'utilisateur/groupe Unix de processus PHP sur nginx. Recherchez les lignes user=www-data et group=www-data dans le fichier et remplacez-les par 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
...

Recherchez également les lignes listen.owner=www-data et listen.group=www-data dans le fichier et remplacez-les par nginx.

listen.owner = nginx
listen.group = nginx

Enregistrez le fichier en appuyant sur Ctrl + X et en saisissant Y lorsque vous y êtes invité.

Redémarrez le processus PHP-fpm. Assurez-vous que Nginx est installé avant de redémarrer le service PHP, sinon il échouera car il ne pourra pas trouver le groupe nginx.

$ sudo systemctl restart php8.2-fpm

É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 alimente Craft CMS.

Téléchargez le script d'installation de Composer.

$ php -r "copy('https://getcomposer.org/installer', 'composer-setup.php');"

Vérifiez le programme d'installation 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 le résultat suivant.

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

Debian 12 est livré avec PostgreSQL 15 par défaut. Nous utiliserons plutôt PostgreSQL 16.

Exécutez la commande suivante pour ajouter la clé GPG PostgreSQL.

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

Ajoutez le référentiel APT à votre liste de sources.

$ 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'

Mettez à jour le référentiel système.

$ sudo apt update

Maintenant, vous pouvez installer PostgreSQL à l'aide de la commande ci-dessous.

$ sudo apt install postgresql postgresql-contrib

Le package postgresql-contrib contient des utilitaires supplémentaires.

Vérifiez la version.

$ psql --version
psql (PostgreSQL) 16.1 (Debian 16.1-1.pgdg120+1)

Vérifiez l'état du service PostgreSQL.

$ 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.

Vous pouvez voir que le service est activé et exécuté 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';

Remplacez le propriétaire de la base de données par 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 informations d'identification fonctionnent.

$ 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=>

Quittez le shell en tapant \q.

Étape 7 - Installer et configurer Redis

Debian 12 est livré par défaut avec Redis 7.0, ce que nous utiliserons. Installez Redis.

$ sudo apt install redis

Vérifiez la version.

$ redis-server --version
Redis server v=7.0.11 sha=00000000:0 malloc=jemalloc-5.3.0 bits=64 build=c4e7f6bf175a885b

Si toutefois vous souhaitez installer la dernière version, vous pouvez le faire en utilisant le référentiel officiel de Redis en exécutant les commandes suivantes.

$ 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

L'étape suivante consiste à ajouter l'authentification au serveur Redis. Depuis Redis v6.0, la meilleure façon d'ajouter une authentification est d'utiliser des ACL (Access Control Lists). Ouvrez le fichier /etc/redis/redis.conf pour le modifier.

$ sudo nano /etc/redis/redis.conf

Recherchez l'entrée de la ligne # aclfile /etc/redis/users.acl et décommentez-la en supprimant le hachage (#) devant elle.

aclfile /etc/redis/users.acl

Enregistrez le fichier en appuyant sur Ctrl + X et en saisissant Y lorsque vous y êtes invité.

Ensuite, créez et ouvrez le fichier /etc/redis/users.acl pour le modifier.

$ sudo nano /etc/redis/users.acl

Ajoutez-y la ligne suivante.

user navjot on +@all ~* >yourpassword

Enregistrez le fichier en appuyant sur Ctrl + X et en saisissant Y lorsque vous y êtes invité.

Redémarrez le serveur Redis pour implémenter la modification.

$ 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 répondez à toutes les exigences du serveur pour l'exécuter à l'aide de la commande suivante.

$ curl -Lsf https://raw.githubusercontent.com/craftcms/server-check/HEAD/check.sh | bash

Vous obtiendrez le résultat suivant.

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 va bien, vous pouvez continuer. Créez le répertoire racine 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

Basculez vers le répertoire.

$ cd /var/www/html/craftcms

Téléchargez et installez Craft CMS à l’aide de Composer. Le point (.) à la fin de la commande signifie que l'installation doit être effectuée dans le répertoire courant.

$ composer create-project craftcms/craft .

Lors de l'installation, il vous sera demandé plusieurs détails concernant la base de données et le compte administrateur. 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 
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 le modifier.

$ nano config/app.php

Vous y verrez le contenu suivant.

use craft\helpers\App;

return [
    'id' => App::env('CRAFT_APP_ID') ?: 'CraftCMS',
];

Modifiez-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 saisissant Y lorsque vous y êtes invité. Cela active Redis comme stockage de cache pour Craft CMS. Vous pouvez également utiliser Redis pour stocker les données de session PHP, la file d'attente des tâches et comme pilote mutex. Vous pouvez trouver la configuration correspondante 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 l'autorisation d'écrire dans le répertoire.

$ sudo chmod -R g+w /var/www/html/craftcms

À partir de maintenant, vous n’aurez plus besoin de modifier les autorisations et pourrez effectuer toutes les opérations sans utiliser les privilèges root.

Étape 9 - Installer SSL

Nous devons installer Certbot pour générer le certificat SSL. Vous pouvez soit installer Certbot à l'aide du référentiel Debian, soit récupérer la dernière version à l'aide de l'outil Snapd. Nous utiliserons la version Snapd.

Debian 12 n'est pas fourni avec Snapd installé. Installez le package Snapd.

$ sudo apt install snapd

Exécutez les commandes suivantes pour vous assurer que votre version de Snapd est à jour.

$ sudo snap install core && sudo snap refresh core

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  -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 Certbot.

$ sudo systemctl list-timers

Vous trouverez snap.certbot.renew.service comme l'un des services dont l'exécution est planifiée.

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

Effectuez un essai à sec du processus pour vérifier si le renouvellement SSL fonctionne correctement.

$ sudo certbot renew --dry-run

Si vous ne voyez aucune erreur, vous êtes prêt. Votre certificat se renouvellera automatiquement.

Étape 10 - Configurer Nginx

Ouvrez le fichier /etc/nginx/nginx.conf pour le modifier.

$ 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 saisissant Y lorsque vous y êtes invité.

Créez et ouvrez le fichier /etc/nginx/conf.d/craftcms.conf pour le modifier.

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

Collez-y le code suivant. 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 que nous avons défini pour Craft CMS lors de la configuration de PHP plus tôt.

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;
}

Enregistrez le fichier en appuyant sur Ctrl + X et en saisissant Y lorsque vous y êtes invité.

Vérifiez votre configuration Nginx.

$ sudo nginx -t

Redémarrez le serveur Nginx.

$ sudo systemctl restart nginx

Étape 11 - Accéder à Craft CMS

Ouvrez l'URL https://craftcms.example.com dans votre navigateur et vous serez redirigé vers la page suivante.

Pour accéder à la page d'administration, visitez l'URL https://craftcms.example.com/admin et vous serez redirigé vers la page de connexion.

Entrez vos informations d'identification d'administration et cliquez sur la touche Connexion pour vous connecter. Vous serez redirigé vers le tableau de bord suivant.

Vous pouvez maintenant commencer à utiliser Craft CMS pour créer votre site Web.

Étape 12 - Sauvegarde et restauration de Craft CMS

Vous pouvez sauvegarder la base de données de Craft CMS depuis le panneau d'administration en visitant Tableau de bord d'administration >> Utilitaires >> Sauvegarde de base de données.

Cliquez sur le bouton Sauvegarde pour télécharger la sauvegarde de votre base de données. Vous pouvez également créer la sauvegarde à l'aide du 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 à l'aide de l'utilitaire de ligne de commande Craft CMS. L'avantage de cet utilitaire est que vous n'avez pas besoin de transmettre les informations d'identification de votre base de données. En savoir plus sur l'utilitaire de console de commande 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 simplement l'intégralité 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 informations d'identification sur le nouveau serveur et restaurez la base de données à l'aide de la commande suivante. Entrez votre mot de passe lorsque vous y êtes invité.

$ mysqlimport -u craftcmsuser -p craftcms craftcms.database.sql

Étape 13 - Mettre à jour Craft CMS

Il existe deux façons de mettre à jour Craft CMS. L’un vient de l’intérieur du 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

Ceci conclut notre tutoriel dans lequel vous avez appris à installer le logiciel Craft CMS sur un serveur Debian 12. Si vous avez des questions, postez-les dans les commentaires ci-dessous.

Comment installer Craft CMS sur Debian 12

Ce tutoriel existe pour ces versions d'OS

Sur cette page

Conditions préalables

Étape 1 - Configurer le pare-feu

Étape 2 - Installer Nginx

Étape 3 - Installez PHP et les extensions

Étape 4 - Configurer PHP-FPM

Étape 5 - Installer Composer

Étape 6 - Installer et configurer PostgreSQL

Étape 7 - Installer et configurer Redis

Étape 8 - Installer Craft CMS

Faire fonctionner Redis avec Craft CMS

Étape 9 - Installer SSL

Étape 10 - Configurer Nginx

Étape 11 - Accéder à Craft CMS

Étape 12 - Sauvegarde et restauration de Craft CMS

Étape 13 - Mettre à jour Craft CMS

Conclusion

Articles connexes: