Come installare Craft CMS su Debian 12

Craft CMS è un sistema di gestione dei contenuti open-source per la creazione di ogni tipo di sito web. È un CMS sicuro e scalabile con un ampio ecosistema di plugin e plugin gratuiti e a pagamento di alta qualità. Ha un pannello di controllo intuitivo e facile da usare per la creazione di contenuti e compiti amministrativi. È costruito sul framework Yii PHP. Il motore di template Twig alimenta il suo sistema di templating. Può lavorare con database MySQL e PostgreSQL per l’archiviazione e utilizza il database Redis per la memorizzazione nella cache e la memorizzazione delle sessioni.

In questo tutorial, imparerai come installare Craft CMS su un server Debian 12. Imparerai anche come abilitare Redis per lavorare con esso e come eseguire il backup e il ripristino di un sito realizzato utilizzando Craft CMS.

Prerequisiti

Un server che esegue Debian 12 con un minimo di 1 GB di RAM.
Un utente non root con privilegi sudo.
Uncomplicated Firewall (UFW) è abilitato e in esecuzione.
Un Nome di Dominio Completo (FQDN) come craftcms.example.com che punta al tuo server.
Un account SMTP con un servizio email come Amazon SES o Mailgun.
Tutto è aggiornato. $ sudo apt update && sudo apt upgrade
Alcuni pacchetti essenziali sono richiesti per il tutorial e per il funzionamento di Craft CMS. Alcuni di questi saranno già presenti sul tuo 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

Passo 1 - Configurare il Firewall

Il primo passo prima di installare qualsiasi pacchetto è configurare il firewall per consentire connessioni HTTP e HTTPS.

Controlla lo stato del firewall.

$ sudo ufw status

Dovresti vedere qualcosa di simile a quanto segue.

Status: active

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

Consenti le porte HTTP e HTTPS.

$ sudo ufw allow http
$ sudo ufw allow https

Controlla di nuovo lo stato per confermare.

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

Passo 2 - Installare Nginx

Debian 12 viene fornito con una versione più vecchia di Nginx. Devi scaricare il repository ufficiale di Nginx per installare l’ultima versione.

Importa la chiave di firma di Nginx.

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

Aggiungi il repository per la versione stabile di 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

Aggiorna i repository di sistema.

$ sudo apt update

Installa Nginx.

$ sudo apt install nginx

Verifica l’installazione. Su sistemi Debian, il seguente comando funzionerà solo con sudo.

$ sudo nginx -v
nginx version: nginx/1.24.0

Avvia il server Nginx.

$ sudo systemctl start nginx

Controlla lo stato del servizio.

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

Passo 3 - Installare PHP e le estensioni

Debian 12 viene fornito con PHP 8.2 per impostazione predefinita. Puoi installarlo e le estensioni richieste da Craft CMS eseguendo il seguente comando.

$ 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

Per rimanere sempre sull’ultima versione di PHP o se desideri installare più versioni di PHP, aggiungi il repository PHP di Ondrej.

Prima, importa la chiave GPG del repo PHP di Sury.

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

Aggiungi il repository PHP di 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'

Aggiorna l’elenco dei repository di sistema.

$ sudo apt update

Probabilmente riceverai informazioni sugli aggiornamenti in sospeso. Eseguili.

$ sudo apt upgrade

Installa PHP e le sue estensioni.

$ 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

Controlla la versione di PHP installata.

$ 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

Controlla lo stato del servizio 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"

Passo 4 - Configurare PHP-FPM

Apri php.ini per la modifica.

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

Per impostare le dimensioni dei file caricati, modifica i valori delle variabili upload_max_filesize e post_max_size. Questo valore decide la dimensione del file che puoi caricare su Craft CMS. Per i nostri scopi, lo impostiamo a 128 MB. Puoi impostarlo come preferisci.

$ 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

Configura il limite di memoria di PHP in base alle risorse e ai requisiti del tuo server.

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

Apri il file /etc/php/8.2/fpm/pool.d/www.conf.

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

Dobbiamo impostare l’utente/gruppo Unix dei processi PHP su nginx. Trova le righe user=www-data e group=www-data nel file e cambiale 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
...

Inoltre, trova le righe listen.owner=www-data e listen.group=www-data nel file e cambiale in nginx.

listen.owner = nginx
listen.group = nginx

Salva il file premendo Ctrl + X e inserendo Y quando richiesto.

Riavvia il processo PHP-fpm. Assicurati di avere Nginx installato prima di riavviare il servizio PHP, altrimenti fallirà poiché non sarà in grado di trovare il gruppo nginx.

$ sudo systemctl restart php8.2-fpm

Passo 5 - Installare Composer

Composer funge da gestore delle dipendenze per PHP. È anche il gestore delle dipendenze del framework PHP Laravel, che alimenta Craft CMS.

Scarica lo script di installazione di Composer.

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

Verifica l’installer scaricato.

$ php -r "if (hash_file('sha384', 'composer-setup.php') === 'e21205b207c3ff031906575712edab6f13eb0b361f2085f1f1237b7126d785e826a450292b6cfd1d64d92e6563bbde02') { echo 'Installer verified'; } else { echo 'Installer corrupt'; unlink('composer-setup.php'); } echo PHP_EOL;"

Riceverai il seguente output.

Installer verified

Esegui lo script di installazione per scaricare l’ultima versione di Composer.

$ php composer-setup.php

Rimuovi lo script di installazione.

$ php -r "unlink('composer-setup.php');"

Sposta il file binario scaricato nella directory /usr/local/bin.

$ sudo mv composer.phar /usr/local/bin/composer

Conferma l’installazione.

$ composer --version
Composer version 2.6.5 2023-10-06 10:11:52

Passo 6 - Installare e Configurare PostgreSQL

Debian 12 viene fornito con PostgreSQL 15 per impostazione predefinita. Useremo PostgreSQL 16 invece.

Esegui il seguente comando per aggiungere la chiave GPG di PostgreSQL.

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

Aggiungi il repository APT alla tua lista di sorgenti.

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

Aggiorna il repository di sistema.

$ sudo apt update

Ora puoi installare PostgreSQL utilizzando il comando seguente.

$ sudo apt install postgresql postgresql-contrib

Il pacchetto postgresql-contrib contiene alcune utilità extra.

Verifica la versione.

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

Controlla lo stato del servizio 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.

Puoi vedere che il servizio è abilitato e in esecuzione per impostazione predefinita.

Avvia la shell di PostgreSQL.

$ sudo -i -u postgres psql

Crea il database Craft CMS.

postgres=# CREATE DATABASE craftcms;

Crea l’utente Craft CMS e scegli una password sicura.

postgres-# CREATE USER craftuser WITH PASSWORD 'Your_Password';

Cambia il proprietario del database in modo che sia l’utente Craft CMS.

postgres-# ALTER DATABASE craftcms OWNER TO craftuser;

Concedi tutti i privilegi sul database all’utente Craft CMS.

postgres-# GRANT ALL PRIVILEGES ON DATABASE craftcms TO craftuser;

Esci dalla shell.

postgres-# \q

Verifica che le tue credenziali funzionino.

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

Esci dalla shell digitando \q.

Passo 7 - Installare e Configurare Redis

Debian 12 viene fornito con Redis 7.0 per impostazione predefinita, che è ciò che utilizzeremo. Installa Redis.

$ sudo apt install redis

Verifica la versione.

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

Se desideri installare l’ultima versione, puoi farlo utilizzando il repository ufficiale di Redis emettendo i seguenti comandi.

$ 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

Il passo successivo è aggiungere l’autenticazione al server Redis. Dalla versione Redis v6.0, il modo migliore per aggiungere l’autenticazione è utilizzare ACL (Access Control Lists). Apri il file /etc/redis/redis.conf per la modifica.

$ sudo nano /etc/redis/redis.conf

Trova la riga # aclfile /etc/redis/users.acl e decommentala rimuovendo l’hash (#) davanti ad essa.

aclfile /etc/redis/users.acl

Salva il file premendo Ctrl + X e inserendo Y quando richiesto.

Successivamente, crea e apri il file /etc/redis/users.acl per la modifica.

$ sudo nano /etc/redis/users.acl

Aggiungi la seguente riga.

user navjot on +@all ~* >yourpassword

Salva il file premendo Ctrl + X e inserendo Y quando richiesto.

Riavvia il server Redis per implementare la modifica.

$ sudo systemctl restart redis

Apri la shell di Redis.

$ redis-cli

Usa il comando PING. Ti darà un errore di autenticazione.

127.0.0.1:6379> PING
(error) NOAUTH Authentication required.

Usa il comando AUTH per accedere.

127.0.0.1:6379> AUTH navjot yourpassword
OK

Usa di nuovo il comando PING.

127.0.0.1:6379> PING
OK

Esci dalla shell.

127.0.0.1:6379> exit

Dovrai anche installare l’estensione PHP Redis.

$ sudo apt install php-redis

Passo 8 - Installare Craft CMS

Prima di installare Craft CMS, puoi controllare se soddisfi tutti i requisiti del server per eseguirlo utilizzando il seguente comando.

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

Riceverai il seguente output.

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

Una volta che tutto è a posto, puoi procedere. Crea la directory della radice web.

$ sudo mkdir /var/www/html/craftcms -p

Imposta l’utente attualmente connesso come proprietario di questa directory.

$ sudo chown -R $USER:$USER /var/www/html/craftcms

Passa alla directory.

$ cd /var/www/html/craftcms

Scarica e installa Craft CMS utilizzando Composer. Il punto (.) alla fine del comando significa che l’installazione deve essere eseguita nella directory corrente.

$ composer create-project craftcms/craft .

Durante l’installazione, ti verranno chiesti diversi dettagli riguardanti il database, l’account amministratore, l’URL del sito e la sua lingua come mostrato di seguito.

> @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

Far funzionare Redis con Craft CMS

Installa il pacchetto yiisoft/yii2-redis.

$ composer require --prefer-dist yiisoft/yii2-redis:"~2.0.0"

Apri il file /var/www/html/craftcms/config/app.php per la modifica.

$ nano config/app.php

Vedrai il seguente contenuto in esso.

use craft\helpers\App;

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

Cambia come segue.

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);
        },
    ],
];

Salva il file premendo Ctrl + X e inserendo Y quando richiesto. Questo abilita Redis come memorizzazione nella cache per Craft CMS. Puoi anche usare Redis per memorizzare i dati delle sessioni PHP, la coda dei lavori e come driver mutex. Puoi trovare la configurazione per esso nella documentazione di Craft CMS.

Devi anche aggiungere la configurazione di Redis al file .env.

$ nano .env

Aggiungi il seguente codice alla fine del file.

REDIS_HOSTNAME=localhost
REDIS_USERNAME=navjot
REDIS_PASSWORD=yourpassword

Scegli le opzioni come mostrato sopra. Una volta terminato, cambia il gruppo della directory in nginx. In questo modo sia l’utente attualmente connesso che Nginx avranno accesso a Craft CMS.

$ sudo chgrp -R nginx /var/www/html/craftcms

Dai al gruppo nginx il permesso di scrivere nella directory.

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

Da qui in poi, non dovrai più cambiare i permessi e potrai eseguire tutte le operazioni senza utilizzare privilegi di root.

Passo 9 - Installare SSL

Dobbiamo installare Certbot per generare il certificato SSL. Puoi installare Certbot utilizzando il repository di Debian o ottenere l’ultima versione utilizzando lo strumento Snapd. Useremo la versione Snapd.

Debian 12 non viene fornito con Snapd installato. Installa il pacchetto Snapd.

$ sudo apt install snapd

Esegui i seguenti comandi per assicurarti che la tua versione di Snapd sia aggiornata.

$ sudo snap install core && sudo snap refresh core

Installa Certbot.

$ sudo snap install --classic certbot

Usa il seguente comando per assicurarti che il comando Certbot possa essere eseguito creando un collegamento simbolico alla directory /usr/bin.

$ sudo ln -s /snap/bin/certbot /usr/bin/certbot

Verifica se Certbot funziona correttamente.

$ certbot --version
certbot 2.7.4

Esegui il seguente comando per generare un certificato SSL.

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

Il comando sopra scaricherà un certificato nella directory /etc/letsencrypt/live/craftcms.example.com sul tuo server.

Genera un certificato Diffie-Hellman group.

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

Controlla il servizio di pianificazione del rinnovo di Certbot.

$ sudo systemctl list-timers

Troverai snap.certbot.renew.service come uno dei servizi programmati per l’esecuzione.

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

Fai una prova del processo per controllare se il rinnovo SSL funziona correttamente.

$ sudo certbot renew --dry-run

Se non vedi errori, sei a posto. Il tuo certificato si rinnoverà automaticamente.

Passo 10 - Configurare Nginx

Apri il file /etc/nginx/nginx.conf per la modifica.

$ sudo nano /etc/nginx/nginx.conf

Aggiungi la seguente riga prima della riga include /etc/nginx/conf.d/*.conf;.

server_names_hash_bucket_size 64;

Salva il file premendo Ctrl + X e inserendo Y quando richiesto.

Crea e apri il file /etc/nginx/conf.d/craftcms.conf per la modifica.

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

Incolla il seguente codice in esso. Sostituisci craftcms.example.com con il tuo nome di dominio. Assicurati che il valore di client_max_body_size sia impostato su 128MB, che è ciò che abbiamo impostato per Craft CMS durante la configurazione di PHP in precedenza.

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

Salva il file premendo Ctrl + X e inserendo Y quando richiesto.

Verifica la configurazione di Nginx.

$ sudo nginx -t

Riavvia il server Nginx.

$ sudo systemctl restart nginx

Passo 11 - Accedere a Craft CMS

Apri l’URL https://craftcms.example.com nel tuo browser e verrai portato alla seguente pagina.

Homepage di Craft CMS

Per accedere alla pagina di amministrazione, visita l’URL https://craftcms.example.com/admin e verrai portato alla pagina di accesso.

Pagina di accesso di Craft CMS

Inserisci le tue credenziali di amministrazione e fai clic sul tasto Accedi per effettuare il login. Verrai portato al seguente cruscotto.

Cruscotto di amministrazione di Craft CMS

Ora puoi iniziare a utilizzare Craft CMS per costruire il tuo sito web.

Passo 12 - Backup e Ripristino di Craft CMS

Puoi eseguire il backup del database di Craft CMS dall’interno del pannello di amministrazione visitando Cruscotto Amministratore >> Utilità >> Backup Database.

Backup Database di Craft CMS

Fai clic sul pulsante Backup per scaricare il backup del tuo database. Puoi anche creare il backup utilizzando il terminale. Esegui il seguente comando per creare il backup. Inserisci la tua password quando richiesto.

$ mysqldump -u craftcmsuser -p craftcms > ~/craftcms.database.sql

Puoi anche creare il backup del database utilizzando l’utilità da riga di comando di Craft CMS. Il vantaggio di questa utilità è che non è necessario fornire le credenziali del database. Leggi di più sull’utilità della console di comando di Craft CMS qui.

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

Se non specifichi alcuna posizione nel comando sopra, il file di backup verrà scritto nella directory /var/www/html/craftcms/storage/backups.

Per eseguire il backup dei file, basta copiare e salvare l’intera cartella /var/www/html/craftcms.

$ cd /var/www/html
$ tar -zcf ~/craftcms.tar.gz craftcms

Per ripristinarlo su un nuovo server, estrai i file nella cartella /var/www/html.

$ tar -xzf craftcms.tar.gz -C /var/www/html/

Crea un database con le stesse credenziali sul nuovo server e ripristina il database utilizzando il seguente comando. Inserisci la tua password quando richiesto.

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

Passo 13 - Aggiornare Craft CMS

Ci sono due modi per aggiornare Craft CMS. Uno è dall’interno del pannello di amministrazione. Quando è disponibile un aggiornamento, riceverai una notifica. Fai clic sulla notifica per eseguire l’aggiornamento. Craft CMS eseguirà automaticamente il backup del database prima di eseguire un aggiornamento.

Puoi anche aggiornarlo tramite il terminale.

Per controllare tutti gli aggiornamenti disponibili, esegui il seguente comando.

$ cd /var/www/html/craftcms/
$ php craft update

Se è disponibile un aggiornamento, esegui il seguente comando per applicarlo.

$ php craft update all

Conclusione

Questo conclude il nostro tutorial in cui hai imparato come installare il software Craft CMS su un server Debian 12. Se hai domande, postale nei commenti qui sotto.

Prerequisiti

Passo 1 - Configurare il Firewall

Passo 2 - Installare Nginx

Passo 3 - Installare PHP e le estensioni

Passo 4 - Configurare PHP-FPM

Passo 5 - Installare Composer

Passo 6 - Installare e Configurare PostgreSQL

Passo 7 - Installare e Configurare Redis

Passo 8 - Installare Craft CMS

Far funzionare Redis con Craft CMS

Passo 9 - Installare SSL

Passo 10 - Configurare Nginx

Passo 11 - Accedere a Craft CMS

Passo 12 - Backup e Ripristino di Craft CMS

Passo 13 - Aggiornare Craft CMS

Conclusione

Ricevi i nuovi post nella tua casella di posta.