Installazione CMS · 21 min read · Sep 11, 2025
Come installare Craft CMS su Rocky Linux 9
Craft CMS è un sistema di gestione dei contenuti open-source per la creazione di siti 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 lo storage e utilizza il database Redis per la memorizzazione nella cache e lo storage 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 Rocky Linux 9 con un minimo di 1 GB di RAM.
- Un utente non root con privilegi sudo.
- Un Nome di Dominio Completo (FQDN) come
craftcms.example.comche punta al tuo server. - Un account SMTP con un servizio email come Amazon SES o Mailgun.
- Tutto è aggiornato.
$ sudo dnf update - 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 dnf install wget curl nano unzip yum-utils policycoreutils-python-utils -y
Passo 1 - Configurare il Firewall
Il primo passo è configurare il firewall. Rocky Linux utilizza Firewalld Firewall. Controlla lo stato del firewall.
$ sudo firewall-cmd --state
running
Il firewall funziona con diverse zone, e la zona pubblica è quella predefinita che utilizzeremo. Elenca tutti i servizi e le porte attive sul firewall.
$ sudo firewall-cmd --permanent --list-services
Dovrebbe mostrare il seguente output.
cockpit dhcpv6-client ssh
Consenti le porte HTTP e HTTPS.
$ sudo firewall-cmd --permanent --add-service=http
$ sudo firewall-cmd --permanent --add-service=https
Controlla di nuovo lo stato del firewall.
$ sudo firewall-cmd --permanent --list-services
Dovresti vedere un output simile.
cockpit dhcpv6-client http https ssh
Ricarica il firewall per abilitare le modifiche.
$ sudo firewall-cmd --reload
Passo 2 - Installare Nginx
Rocky Linux 9 viene fornito con una versione più vecchia di Nginx. Devi utilizzare il repository ufficiale di Nginx per installare l’ultima versione.
Crea e apri il file /etc/yum.repos.d/nginx.repo per la modifica.
$ sudo nano /etc/yum.repos.d/nginx.repo
Incolla il seguente codice al suo interno.
[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
Una volta terminato, salva il file premendo Ctrl + X e inserendo Y quando richiesto.
Installa Nginx.
$ sudo dnf install nginx -y
Verifica l’installazione.
$ nginx -v
nginx version: nginx/1.24.0
Abilita e avvia il servizio del server Nginx.
$ sudo systemctl enable nginx --now
Controlla lo stato del servizio.
$ sudo systemctl status nginx
? nginx.service - nginx - high performance web server
Loaded: loaded (/usr/lib/systemd/system/nginx.service; enabled; preset: disabled)
Active: active (running) since Mon 2023-12-04 14:01:19 UTC; 3s ago
Docs: http://nginx.org/en/docs/
Process: 59396 ExecStart=/usr/sbin/nginx -c /etc/nginx/nginx.conf (code=exited, status=0/SUCCESS)
Main PID: 59397 (nginx)
Tasks: 2 (limit: 10866)
Memory: 1.9M
CPU: 10ms
CGroup: /system.slice/nginx.service
??59397 "nginx: master process /usr/sbin/nginx -c /etc/nginx/nginx.conf"
??59398 "nginx: worker process"
Passo 3 - Installare PHP e le estensioni
Rocky Linux 9 viene fornito con PHP 8.1 per impostazione predefinita. Per rimanere sempre sull’ultima versione di PHP o se desideri installare più versioni di PHP, dobbiamo utilizzare il repository REMI.
Il primo passo è acquisire il repository Epel.
$ sudo dnf install epel-release -y
Successivamente, installa il repository Remi.
$ sudo dnf install https://rpms.remirepo.net/enterprise/remi-release-9.rpm
Controlla gli stream PHP disponibili.
$ 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 versione predefinita è 8.1. Al momento della scrittura di questo tutorial, Craft CMS è compatibile con PHP 8.2. Pertanto, abilita il repository PHP 8.2 di Remi.
$ sudo dnf module reset php -y
$ sudo dnf module enable php:remi-8.2
Installa PHP e le sue estensioni richieste da 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
Controlla la versione di PHP installata.
$ 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
Abilita e avvia il servizio PHP-FPM.
$ sudo systemctl enable php-fpm --now
Controlla lo stato del servizio 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"
Passo 4 - Configurare PHP-FPM
Apri php.ini per la modifica.
$ sudo nano /etc/php.ini
Per impostare le dimensioni dei file di upload, 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.ini
$ sudo sed -i 's/post_max_size = 8M/post_max_size = 128M/' /etc/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.ini
Apri il file /etc/php-fpm.d/www.conf.
$ sudo nano /etc/php-fpm.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.
; 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
...
Trova le righe listen.owner = nobody, listen.group = nobody, listen.mode = 0660 nel file e cambiale come segue dopo averle decommentate.
; 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
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 php-fpm
Cambia il gruppo della directory delle sessioni PHP in Nginx.
$ sudo chgrp -R nginx /var/lib/php/session
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
Rocky Linux 9 viene fornito con PostgreSQL 13 per impostazione predefinita. Utilizzeremo PostgreSQL 16 invece dal suo repository ufficiale.
Installa il repository RPM di PostgreSQL.
$ sudo dnf install -y https://download.postgresql.org/pub/repos/yum/reporpms/EL-9-x86_64/pgdg-redhat-repo-latest.noarch.rpm
Disabilita il modulo PostgreSQL integrato.
$ sudo dnf -qy module disable postgresql
Ora puoi installare PostgreSQL utilizzando il comando qui sotto.
$ sudo dnf install -y postgresql16-server postgresql16-contrib
Il pacchetto postgresql-contrib contiene alcune utilità extra.
Verifica la versione.
$ psql --version
psql (PostgreSQL) 16.1
Inizializza il database PostgreSQL.
$ sudo /usr/pgsql-16/bin/postgresql-16-setup initdb
Initializing database ... OK
Abilita il servizio PostgreSQL.
$ sudo systemctl enable postgresql-16
Avvia il servizio PostgreSQL.
$ sudo systemctl start postgresql-16
Controlla lo stato del servizio 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.
Puoi vedere che il servizio è abilitato e in esecuzione per impostazione predefinita.
Lancia 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 forte.
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)
Type "help" for help.
craftcms=>
Esci dalla shell digitando \q.
Passo 7 - Installare e Configurare Redis
Rocky Linux 9 viene fornito con Redis 6.2 per impostazione predefinita. Tuttavia, utilizzeremo Redis 7.0 che installeremo utilizzando il Repository Remi.
Poiché abbiamo installato il repository Remi durante l’installazione di PHP, possiamo saltare quella parte. Elenca tutti i moduli Redis disponibili.
$ 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
Abilita il modulo Redis 7.2 più recente.
$ sudo dnf module enable -y redis:remi-7.2
Installa Redis.
$ sudo dnf install redis
Verifica la versione.
$ redis-server --version
Redis server v=7.2.3 sha=00000000:0 malloc=jemalloc-5.3.0 bits=64 build=7bd3173e4e30c3e4
Abilita il servizio Redis.
$ sudo systemctl enable redis
Avvia il servizio Redis.
$ sudo systemctl start redis
Controlla lo stato del servizio.
$ 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.
Il passo successivo è aggiungere l’autenticazione al server Redis. Dalla versione 6.0 di Redis, il modo migliore per aggiungere 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 al suo interno.
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 verrà chiesto di fornire diversi dettagli riguardanti il database, e l’account amministratore. 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 al suo interno.
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 storage della cache per Craft CMS. Puoi anche utilizzare Redis per memorizzare i dati delle sessioni PHP, la coda dei lavori e come driver mutex. Puoi trovare la configurazione per questo 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 puoi eseguire tutte le operazioni senza utilizzare i privilegi di root.
Passo 9 - Installare SSL
Dobbiamo installare Certbot per generare il certificato SSL. Utilizzeremo il gestore pacchetti Snapd per questo. Poiché Rocky Linux non viene fornito con esso, installa il gestore Snapd. Richiede il repository EPEL (Extra Packages for Enterprise Linux) per funzionare. Ma poiché lo abbiamo già installato nel passo 3, possiamo procedere direttamente.
Installa Snapd.
$ sudo dnf install -y snapd
Abilita e avvia il servizio Snap.
$ sudo systemctl enable snapd --now
Installa il pacchetto core di Snap e assicurati che la tua versione di Snapd sia aggiornata.
$ sudo snap install core && sudo snap refresh core
Crea i collegamenti necessari affinché Snapd funzioni.
$ 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
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
---------------------------------------------------------------------------------------------------------------------------
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
Fai un dry run 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 SELinux
Cambia il contesto di sicurezza del file per Craft CMS.
$ sudo semanage fcontext -a -t httpd_sys_rw_content_t "/var/www/html/craftcms(/.*)?"
Applica la policy.
$ sudo restorecon -Rv /var/www/html/craftcms/
Applica la policy per consentire a Nginx di accedere a PostgreSQL.
$ sudo setsebool -P httpd_can_network_connect_db 1
Applica la policy per consentire le connessioni verso host esterni.
$ sudo setsebool -P httpd_can_network_connect 1
Con MariaDB 10.11, affronterai un altro problema, ovvero che SELinux impedisce a PHP-FPM di connettersi a MariaDB. Questo può essere risolto installando un modulo SELinux. Il primo passo è creare un file di type enforcement.
Crea il file my-phpfpm.te nella tua home directory e aprilo per la modifica.
$ cd ~
$ nano my-phpfpm.te
Incolla il seguente codice al suo interno.
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;
Salva il file premendo Ctrl + X e inserendo Y quando richiesto.
Il passo successivo è convertirlo in un modulo di policy utilizzando il seguente comando. Non modificare il nome del file nel comando altrimenti non funzionerà. Il modulo si chiama my-phpfpm e il nome del file deve essere lo stesso del nome del modulo.
$ sudo checkmodule -M -m -o my-phpfpm.mod my-phpfpm.te
Successivamente, dobbiamo compilare il modulo di policy per creare un pacchetto di policy.
$ sudo semodule_package -o my-phpfpm.pp -m my-phpfpm.mod
L’ultimo passo è caricare il pacchetto di policy utilizzando il comando semodule che installa la policy da utilizzare.
$ sudo semodule -i my-phpfpm.pp
Passo 11 - 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 al suo interno. 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-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;
}
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 12 - Accedere a Craft CMS
Apri l’URL https://craftcms.example.com nel tuo browser e verrai portato alla seguente pagina.
Per accedere alla pagina di amministrazione, visita l’URL https://craftcms.example.com/admin e verrai portato alla pagina di accesso.
Inserisci le tue credenziali di amministrazione e fai clic sul pulsante Accedi per accedere. Verrai portato al seguente cruscotto.
Ora puoi iniziare a utilizzare Craft CMS per costruire il tuo sito web.
Passo 13 - 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.
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 utility è che non devi passare le tue 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, copia e salva 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 14 - 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.
Ricevi i nuovi post nella tua casella di posta.
Nessuno spam. Disiscriviti in qualsiasi momento.