Ricerca nel sito web

Come installare Craft CMS su Rocky Linux 9


Su questa pagina

  1. Prerequisiti
  2. Passaggio 1 - Configurare il firewall
  3. Passaggio 2: installa Nginx
  4. Passaggio 3: installa PHP e le estensioni
  5. Passaggio 4 - Configurare PHP-FPM
  6. Passaggio 5: installa Composer
  7. Passaggio 6: installare e configurare PostgreSQL
  8. Passaggio 7 - Installare e configurare Redis
  9. Passaggio 8: installa Craft CMS

    1. Fai funzionare Redis con Craft CMS
  10. Passaggio 9: installare SSL
  11. Passaggio 10 - Configurare SELinux
  12. Passaggio 11: configurare Nginx
  13. Passaggio 12 - Accedi a Craft CMS
  14. Passaggio 13: backup e ripristino di Craft CMS
  15. Passaggio 14: aggiorna Craft CMS
  16. Conclusione

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.