Come installare Craft CMS su Rocky Linux 9
Su questa pagina
- Prerequisiti
- Passaggio 1 - Configurare il firewall
- Passaggio 2: installa Nginx
- Passaggio 3: installa PHP e le estensioni
- Passaggio 4 - Configurare PHP-FPM
- Passaggio 5: installa Composer
- Passaggio 6: installare e configurare PostgreSQL
- Passaggio 7 - Installare e configurare Redis
Passaggio 8: installa Craft CMS
- Fai funzionare Redis con Craft CMS
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 plug-in e plug-in gratuiti e a pagamento di alta qualità. Dispone di un pannello di controllo intuitivo e facile da usare per la creazione di contenuti e le attività amministrative. È costruito sul framework PHP Yii. Il motore di template Twig alimenta il suo sistema di modelli. Può funzionare con i database MySQL e PostgreSQL per l'archiviazione e utilizza il database Redis per la memorizzazione nella cache e l'archiviazione delle sessioni.
In questo tutorial imparerai come installare Craft CMS su un server Debian 12. Imparerai anche come abilitare Redis a funzionare 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.com
che punta al server.
Un account SMTP con un servizio di posta elettronica come Amazon SES o Mailgun.
Tutto è aggiornato.
$ sudo dnf update
Per l'esecuzione del tutorial e di Craft CMS sono necessari alcuni pacchetti essenziali. Alcuni di questi saranno già presenti sul tuo server.
$ sudo dnf install wget curl nano unzip yum-utils policycoreutils-python-utils -y
Passaggio 1 - Configurare il firewall
Il primo passo consiste nel configurare il firewall. Rocky Linux utilizza Firewalld Firewall. Controllare 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 l'output seguente.
cockpit dhcpv6-client ssh
Consenti porte HTTP e HTTPS.
$ sudo firewall-cmd --permanent --add-service=httpsudo firewall-cmd --permanent --add-service=https
Ricontrollare lo stato del firewall.
$ sudo firewall-cmd --permanent --list-services
Dovresti vedere un output simile.
cockpit dhcpv6-client http https ssh
Ricaricare il firewall per abilitare le modifiche.
$ sudo firewall-cmd --reload
Passaggio 2: installa Nginx
Rocky Linux 9 viene fornito con una versione precedente di Nginx. È necessario 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
Verificare l'installazione.
$ nginx -v
nginx version: nginx/1.24.0
Abilita e avvia il servizio server Nginx.
$ sudo systemctl enable nginx --now
Controllare 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"
Passaggio 3: installa 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 si desidera installare più versioni di PHP, è necessario utilizzare il repository REMI.
Il primo passo è quello di prendere il repository Epel.
$ sudo dnf install epel-release -y
Quindi, installa il repository Remi.
$ sudo dnf install https://rpms.remirepo.net/enterprise/remi-release-9.rpm
Verifica la disponibilità di flussi PHP.
$ 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 stesura di questo tutorial, Craft CMS è compatibile con PHP 8.2. Pertanto, abilita il repository PHP 8.2 di Remi.
$ sudo dnf module reset php -ysudo 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
Abilitare e avviare 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"
Passaggio 4 - Configurare PHP-FPM
Apri php.ini per la
modifica.
$ sudo nano /etc/php.ini
Per impostare le dimensioni di caricamento dei file, modificare i valori delle variabili upload_max_filesize
e post_max_size
. Questo valore determina la dimensione del file che puoi caricare su Craft CMS. Per i nostri scopi, lo stiamo impostando a 128 MB. Puoi impostarlo a tuo piacimento.
$ sudo sed -i 's/upload_max_filesize = 2M/upload_max_filesize = 128M/' /etc/php.inisudo 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
Aprire 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 modificale 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 aver installato Nginx 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
Passaggio 5: installa Composer
Composer funge da gestore delle dipendenze per PHP. È anche il gestore delle dipendenze del framework PHP Laravel, che è ciò che alimenta Craft CMS.
Scarica lo script di installazione di Composer.
$ php -r "copy('https://getcomposer.org/installer', 'composer-setup.php');"
Verifica il programma di installazione 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
Rimuovere 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
Confermare l'installazione.
$ composer --version
Composer version 2.6.5 2023-10-06 10:11:52
Passaggio 6: installare e configurare PostgreSQL
Rocky Linux 9 viene fornito con PostgreSQL 13 per impostazione predefinita. Utilizzeremo invece PostgreSQL 16 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 seguente.
$ sudo dnf install -y postgresql16-server postgresql16-contrib
Il pacchetto postgresql-contrib
contiene alcune utilità extra.
Verificare 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
Avviare 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.
Avvia la shell PostgreSQL.
$ sudo -i -u postgres psql
Crea il database Craft CMS.
postgres=# CREATE DATABASE craftcms;
Crea l'utente Craft CMS e scegli una password complessa.
postgres-# CREATE USER craftuser WITH PASSWORD 'Your_Password';
Cambia il proprietario del database con l'utente Craft CMS.
postgres-# ALTER DATABASE craftcms OWNER TO craftuser;
Concedi tutti i privilegi sul database all'utente di Craft CMS.
postgres-# GRANT ALL PRIVILEGES ON DATABASE craftcms TO craftuser;
Uscire dal guscio.
postgres-# \q
Verifica che le tue credenziali funzionino.
$ psql --username craftuser --password --host localhost craftcms
Password:
psql (16.1)
Type "help" for help.
craftcms=>
Uscire dalla shell digitando \q
.
Passaggio 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.
Dal momento che 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 l'ultimo modulo Redis 7.2.
$ sudo dnf module enable -y redis:remi-7.2
Installare Redis.
$ sudo dnf install redis
Verificare la versione.
$ redis-server --version
Redis server v=7.2.3 sha=00000000:0 malloc=jemalloc-5.3.0 bits=64 build=7bd3173e4e30c3e4
Abilitare il servizio Redis.
$ sudo systemctl enable redis
Avviare 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 passaggio successivo consiste nell'aggiungere l'autenticazione al server Redis. A partire da Redis v6.0, il modo migliore per aggiungere l'autenticazione consiste nell'utilizzare ACL (Access Control Lists). Apri il file /etc/redis/redis.conf
per la modifica.
$ sudo nano /etc/redis/redis.conf
Trova la voce # 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.
Quindi, 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
Aprire la shell Redis.
$ redis-cli
Utilizzare il comando PING
. Darà un errore di autenticazione.
127.0.0.1:6379> PING
(error) NOAUTH Authentication required.
Utilizzare il comando AUTH
per accedere.
127.0.0.1:6379> AUTH navjot yourpassword
OK
Utilizzare nuovamente il comando PING
.
127.0.0.1:6379> PING
OK
Uscire dal guscio.
127.0.0.1:6379> exit
Dovrai anche installare l'estensione PHP Redis.
$ sudo apt install php-redis
Passaggio 8: installa Craft CMS
Prima di installare Craft CMS, puoi verificare 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
Otterrai 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. Creare la directory principale del Web.
$ sudo mkdir /var/www/html/craftcms -p
Impostare l'utente attualmente connesso come proprietario di questa directory.
$ sudo chown -R $USER:$USER /var/www/html/craftcms
Passare 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 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
Password:
Confirm:
Site name: Howtoforge Tutorials
Site URL: https://craftcms.example.com
Site language: [en-US]
*** installing Craft
Fai funzionare Redis con Craft CMS
Installare 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',
];
Modificarlo 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. Ciò abilita Redis come archiviazione cache per Craft CMS. È inoltre possibile utilizzare Redis per archiviare i dati della sessione PHP, la coda dei processi e come driver mutex. Puoi trovare la configurazione nella documentazione di Craft CMS.
È inoltre necessario aggiungere la configurazione Redis al file con estensione env
.
$ nano .env
Aggiungere il codice seguente 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
Concedi a nginx
group l'autorizzazione a scrivere nella directory.
$ sudo chmod -R g+w /var/www/html/craftcms
Da qui in poi, non sarà più necessario modificare le autorizzazioni e sarà possibile eseguire tutte le operazioni senza utilizzare i privilegi di root.
Passaggio 9: installare SSL
Dobbiamo installare Certbot per generare il certificato SSL. A tale scopo utilizzeremo il programma di installazione del pacchetto Snapd. Poiché Rocky Linux non viene fornito con esso, installa il programma di installazione di Snapd. Richiede il repository EPEL (Extra Packages for Enterprise Linux) per funzionare. Ma poiché l'abbiamo già installato nel passaggio 3, possiamo andare avanti direttamente.
Installa Snapd.
$ sudo dnf install -y snapd
Abilita e avvia il servizio Snap.
$ sudo systemctl enable snapd --now
Installa il pacchetto base di Snap e assicurati che la tua versione di Snapd sia aggiornata.
$ sudo snap install core && sudo snap refresh core
Crea i collegamenti necessari per il funzionamento di Snapd.
$ sudo ln -s /var/lib/snapd/snap /snapecho 'export PATH=$PATH:/var/lib/snapd/snap/bin' | sudo tee -a /etc/profile.d/snapd.sh
Installa Certbot.
$ sudo snap install --classic certbot
Utilizzare il comando seguente per assicurarsi 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 -d craftcms.example.com
Il comando precedente scaricherà un certificato nella directory /etc/letsencrypt/live/craftcms.example.com
sul tuo server.
Generare un certificato di gruppo Diffie-Hellman.
$ 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
Esegui una prova del processo per verificare se il rinnovo SSL funziona correttamente.
$ sudo certbot renew --dry-run
Se non vedi errori, sei pronto. Il tuo certificato si rinnoverà automaticamente.
Passaggio 10 - Configurare SELinux
Modifica il contesto di sicurezza dei file per Craft CMS.
$ sudo semanage fcontext -a -t httpd_sys_rw_content_t "/var/www/html/craftcms(/.*)?"
Applicare il criterio.
$ sudo restorecon -Rv /var/www/html/craftcms/
Applica la policy per consentire a Nginx di concedere l'accesso a PostgreSQL.
$ sudo setsebool -P httpd_can_network_connect_db 1
Applicare il criterio per consentire la connessione a host esterni.
$ sudo setsebool -P httpd_can_network_connect 1
Con MariaDB 10.11, dovrai affrontare un altro problema che è che SELinux impedisce a PHP-FPM di connettersi a MariaDB. Questo problema può essere risolto installando un modulo SELinux. Il primo passaggio consiste nel creare un file di imposizione dei tipi
.
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 passaggio successivo consiste nel convertirlo in un modulo di criteri utilizzando il comando seguente. 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 delle politiche per creare un pacchetto di politiche.
$ sudo semodule_package -o my-phpfpm.pp -m my-phpfpm.mod
Il passaggio finale consiste nel caricare il pacchetto di criteri utilizzando il comando semodule
che installa il criterio da utilizzare.
$ sudo semodule -i my-phpfpm.pp
Passaggio 11: configurare Nginx
Apri il file /etc/nginx/nginx.conf
per la modifica.
$ sudo nano /etc/nginx/nginx.conf
Aggiungere 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 del client_max_body_size sia impostato su 128 MB,
che è quello 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 tua configurazione Nginx.
$ sudo nginx -t
Riavvia il server Nginx.
$ sudo systemctl restart nginx
Passaggio 12 - Accedi a Craft CMS
Apri il https://craftcms.example.com
URL nel tuo browser e verrai indirizzato alla pagina seguente.
Per accedere alla pagina di amministrazione, visita l'URL https://craftcms.example.com/admin
e verrai indirizzato alla pagina di accesso.
Inserisci le tue credenziali di amministrazione e fai clic sul tasto Accedi per accedere. Verrai indirizzato alla seguente dashboard.
Ora puoi iniziare a utilizzare Craft CMS per creare il tuo sito web.
Passaggio 13: backup e ripristino di Craft CMS
Puoi eseguire il backup del database di Craft CMS dall'interno del pannello di amministrazione visitando Dashboard di amministrazione >> Utility >> Backup del database.
Fare clic sul pulsante Backup per scaricare il backup del database. È inoltre possibile creare il backup utilizzando il terminale. Eseguire il comando seguente per creare il backup. Inserisci la tua password quando richiesto.
$ mysqldump -u craftcmsuser -p craftcms > ~/craftcms.database.sql
È inoltre possibile creare il backup del database utilizzando l'utilità della riga di comando Craft CMS. Il vantaggio di questa utility è che non è necessario passare le credenziali del database. Per saperne di più sull'utilità della console dei comandi di Craft CMS, clicca qui.
$ cd /var/www/html/craftcmsphp 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 si specifica alcuna posizione nel comando precedente, 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/htmltar -zcf ~/craftcms.tar.gz craftcms
Per ripristinarlo su un nuovo server, estrarre i file nella cartella /var/www/html
.
$ tar -xzf craftcms.tar.gz -C /var/www/html/
Creare un database con le stesse credenziali sul nuovo server e ripristinare il database utilizzando il comando seguente. Inserisci la tua password quando richiesto.
$ mysqlimport -u craftcmsuser -p craftcms craftcms.database.sql
Passaggio 14: aggiorna Craft CMS
Ci sono due modi per aggiornare Craft CMS. Uno è dall'interno del pannello di amministrazione. Quando è disponibile un aggiornamento, riceverai un avviso. Fare clic sull'avviso 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, eseguire il comando seguente.
$ cd /var/www/html/craftcms/php craft update
Se è disponibile un aggiornamento, eseguire il comando seguente 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, pubblicale nei commenti qui sotto.