Stații de lucru

Cum se instalează Craft CMS pe Rocky Linux 9

• Data 05/04/2025
• Autor Adrian Imbrea
• 0
• 16

Cerințe preliminare

• Un server care rulează Rocky Linux 9 cu minim 1 GB RAM.
• Un utilizator non-root cu privilegii sudo.
• Un nume de domeniu complet calificat (FQDN) ca craftcms.example.comindicarea către serverul dvs.
• Un cont SMTP cu un serviciu de e-mail precum Amazon SES sau Mailgun.
• Totul este actualizat.

  $ sudo dnf update
  

• Sunt necesare câteva pachete esențiale pentru ca tutorialul și Craft CMS să ruleze. Unele dintre acestea vor fi deja pe serverul dvs.

  $ sudo dnf install wget curl nano unzip yum-utils policycoreutils-python-utils -y
  

Pasul 1 – Configurați firewall

Primul pas este configurarea firewall-ului. Rocky Linux folosește Firewalld Firewall. Verificați starea firewall-ului.

$ sudo firewall-cmd --state
funcţionare

Firewall-ul funcționează cu diferite zone, iar zona publică este cea implicită pe care o vom folosi. Listați toate serviciile și porturile active pe firewall.

$ sudo firewall-cmd --permanent --list-services

Ar trebui să arate următoarea ieșire.

cockpit dhcpv6-client ssh

Permiteți porturile HTTP și HTTPS.

$ sudo firewall-cmd --permanent --add-service=http
$ sudo firewall-cmd --permanent --add-service=https

Verificați din nou starea paravanului de protecție.

$ sudo firewall-cmd --permanent --list-services

Ar trebui să vedeți o ieșire similară.

cockpit dhcpv6-client http https ssh

Reîncărcați paravanul de protecție pentru a activa modificările.

$ sudo firewall-cmd --reload

Pasul 2 – Instalați Nginx

Rocky Linux 9 este livrat cu o versiune mai veche de Nginx. Trebuie să utilizați depozitul oficial Nginx pentru a instala cea mai recentă versiune.

Creați și deschideți fișierul /etc/yum.repos.d/nginx.repopentru editare.

$ sudo nano /etc/yum.repos.d/nginx.repo

Lipiți următorul cod în el.

[nginx-stable]
nume=nginx stable repo
baseurl=http://nginx.org/packages/centos/$releasever/$basearch/
gpgcheck=1
activat=1
gpgkey=https://nginx.org/keys/nginx_signing.key
module_hotfixes=adevărat

[nginx-mainline]
nume=nginx repository principal
baseurl=http://nginx.org/packages/mainline/centos/$releasever/$basearch/
gpgcheck=1
activat=0
gpgkey=https://nginx.org/keys/nginx_signing.key
module_hotfixes=adevărat

După ce ați terminat, salvați fișierul apăsând Ctrl + X și introducând Y când vi se solicită.

Instalați Nginx.

$ sudo dnf install nginx -y

Verificați instalarea.

$ nginx -v
Versiunea nginx: nginx/1.24.0

Activați și porniți serviciul server Nginx.

$ sudo systemctl enable nginx --now

Verificați starea serviciului.

$ sudo systemctl status nginx
? nginx.service - nginx - server web de înaltă performanță
     Încărcat: încărcat (/usr/lib/systemd/system/nginx.service; activat; presetat: dezactivat)
     Activ: activ (în rulare) din Luni 2023-12-04 14:01:19 UTC; acum 3s
       Documente: http://nginx.org/en/docs/
    Proces: 59396 ExecStart=/usr/sbin/nginx -c /etc/nginx/nginx.conf (code=exit, status=0/SUCCESS)
   PID principal: 59397 (nginx)
      Sarcini: 2 (limită: 10866)
     Memorie: 1,9 M
        CPU: 10 ms
     CGroup: /system.slice/nginx.service
             ??59397 „nginx: proces principal /usr/sbin/nginx -c /etc/nginx/nginx.conf”
             ??59398 „nginx: proces de lucru”

Pasul 3 – Instalați PHP și extensii

Rocky Linux 9 este livrat implicit cu PHP 8.1. Pentru a rămâne mereu pe cea mai recentă versiune de PHP sau dacă doriți să instalați mai multe versiuni de PHP, trebuie să folosim depozitul REMI.

Primul pas este să luați depozitul Epel.

$ sudo dnf install epel-release -y

Apoi, instalați depozitul Remi.

$ sudo dnf install https://rpms.remirepo.net/enterprise/remi-release-9.rpm

Verificați fluxurile PHP disponibile.

$ dnf module list php -y

 Rezumatul profilurilor fluxului de nume php 8.1 comun [d], devel, limbaj de scripting PHP minim  Depozitul modular al lui Remi pentru Enterprise Linux 9 - x86_64 Rezumatul profilurilor fluxului de nume php remi-7.4 comun [d], devel, limbaj de scripting PHP minim php remi-8.0 comun [d], devel, limbaj de scripting PHP minim php remi-8.1 comun [d], devel, limbaj de scripting PHP minim php remi-8.2 comun [d], devel, limbaj de scripting PHP minim php remi-8.3 comun [d], devel, limbaj de scripting PHP minim  Sugestie: [d]efectuat, [activat], [x]dezactivat, [instalat]

Versiunea implicită este 8.1. La momentul scrierii acestui tutorial, Craft CMS este compatibil cu PHP 8.2. Prin urmare, activați depozitul PHP 8.2 al lui Remi.

$ sudo dnf module reset php -y
$ sudo dnf module enable php:remi-8.2

Instalați PHP și extensiile sale solicitate de 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-pintlql

Verificați versiunea de PHP instalată.

$ php --version
PHP 8.2.13 (cli) (construit: 21 noiembrie 2023 09:55:59) (NTS gcc x86_64)
Drepturi de autor (c) Grupul PHP
Zend Engine v4.2.13, Copyright (c) Zend Technologies
    cu Zend OPcache v8.2.13, Copyright (c), de Zend Technologies

Activați și porniți serviciul PHP-FPM.

$ sudo systemctl enable php-fpm --now

Verificați starea serviciului PHP.

$ sudo systemctl status php-fpm
? php-fpm.service - Managerul de procese PHP FastCGI
     Încărcat: încărcat (/usr/lib/systemd/system/php-fpm.service; activat; presetat: dezactivat)
     Activ: activ (în rulare) din Luni 2023-12-04 14:05:58 UTC; acum 6 secunde
   PID principal: 61410 (php-fpm)
     Stare: „Pregătit pentru a gestiona conexiunile”
      Sarcini: 6 (limită: 10866)
     Memorie: 16,6 M
        CPU: 96 ms
     CGroup: /system.slice/php-fpm.service
             ??61410 „php-fpm: proces principal (/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"

Pasul 4 – Configurați PHP-FPM

Deschis php.inipentru editare.

$ sudo nano /etc/php.ini

Pentru a seta dimensiunile de încărcare a fișierelor, modificați valorile variabilelor upload_max_filesizeși post_max_size. Această valoare decide dimensiunea fișierului pe care îl puteți încărca în Craft CMS. Pentru scopurile noastre, îl setăm la 128 MB. Îl poți seta după bunul plac.

$ 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ți limita de memorie PHP în funcție de resursele și cerințele serverului dvs.

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

Deschideți fișierul /etc/php-fpm.d/www.conf.

$ sudo nano /etc/php-fpm.d/www.conf

Trebuie să setăm utilizatorul/grupul de procese PHP Unix la nginx . Găsiți liniile user=www-datași group=www-dataîn fișier și schimbați-le în nginx.

...
; Utilizator Unix/grup de procese
; Notă: Utilizatorul este obligatoriu. Dacă grupul nu este setat, grupul implicit al utilizatorului
; va fi folosit.
; RPM: utilizator apache ales să ofere acces la aceleași directoare ca httpd
utilizator = nginx
; RPM: Păstrați un grup permis să scrie în directorul jurnalului.
grup = nginx
...

Găsiți liniile listen.owner = nobody, listen.group = nobody, listen.mode = 0660din fișier și modificați-le după cum urmează după ce le-ați decomentat.

; Setați permisiunile pentru socket Unix, dacă este folosit unul. În Linux, citiți/scrieți
; permisiunile trebuie setate pentru a permite conexiuni de la un server web. Multe
; Sistemele derivate din BSD permit conexiuni indiferent de permisiuni. Proprietarul
; și grupul poate fi specificat fie prin nume, fie prin ID-urile lor numerice.
; Valori implicite: utilizatorul și grupul sunt setate ca utilizator care rulează
; modul este setat la 0660
listen.owner = nginx
ascultă.grup = nginx
listen.mode = 0660

Salvați fișierul apăsând Ctrl + X și introducând Y când vi se solicită.

Reporniți procesul PHP-fpm. Asigurați-vă că aveți instalat Nginx înainte de a reporni serviciul PHP, altfel acesta va eșua, deoarece nu va putea găsi nginxgrupul.

$ sudo systemctl restart php-fpm

Schimbați grupul directorului de sesiuni PHP în Nginx.

$ sudo chgrp -R nginx /var/lib/php/session

Pasul 5 – Instalați Composer

Composer acționează ca un manager de dependență pentru PHP. Este, de asemenea, managerul de dependență al cadrului PHP Laravel, care este ceea ce alimentează Craft CMS.

Descărcați scriptul de instalare Composer.

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

Verificați programul de instalare descărcat.

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

Veți primi următorul rezultat.

Installer verified

Rulați scriptul de instalare pentru a descărca cea mai recentă versiune de Composer.

$ php composer-setup.php

Eliminați scriptul de instalare.

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

Mutați fișierul binar descărcat în /usr/local/bindirector.

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

Confirmați instalarea.

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

Pasul 6 – Instalați și configurați PostgreSQL

Rocky Linux 9 este livrat implicit cu PostgreSQL 13. Vom folosi PostgreSQL 16 în schimb din depozitul său oficial.

Instalați depozitul RPM PostgreSQL.

$ sudo dnf install -y https://download.postgresql.org/pub/repos/yum/reporpms/EL-9-x86_64/pgdg-redhat-repo-latest.noarch.rpm

Dezactivați modulul PostgreSQL încorporat.

$ sudo dnf -qy module disable postgresql

Acum, puteți instala PostgreSQL folosind comanda de mai jos.

$ sudo dnf install -y postgresql16-server postgresql16-contrib

Pachetul postgresql-contribconține câteva utilități suplimentare.

Verificați versiunea.

$ psql --version
psql (PostgreSQL) 16.1

Inițializați baza de date PostgreSQL.

$ sudo /usr/pgsql-16/bin/postgresql-16-setup initdb
Se inițializează baza de date... OK

Activați serviciul PostgreSQL.

$ sudo systemctl enable postgresql-16

Porniți serviciul PostgreSQL.

$ sudo systemctl start postgresql-16

Verificați starea serviciului PostgreSQL.

$ sudo systemctl status postgresql-16
? postgresql-16.service - Server de baze de date PostgreSQL 16
     Încărcat: încărcat (/usr/lib/systemd/system/postgresql-16.service; activat; prestabilit: dezactivat)
     Activ: activ (în rulare) din Luni 2023-12-04 22:28:34 UTC; acum 2 secunde
       Documente: https://www.postgresql.org/docs/16/static/
    Proces: 72143 ExecStartPre=/usr/pgsql-16/bin/postgresql-16-check-db-dir ${PGDATA} (code=exit, status=0/SUCCESS)
   PID principal: 72148 (postgres)
      Sarcini: 7 (limită: 10866)
     Memorie: 17,4 M
        CPU: 45 ms
     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: scriitor de fundal"
             ??72153 "postgres: walwriter"
             ??72154 "postgres: lansatorul de autovacuum"
             ??72155 „postgres: lansatorul de replicare logică”

04 decembrie 22:28:33 craftcms.nspeaks.com systemd[1]: Se pornește serverul de baze de date PostgreSQL 16...
Dec 04 22:28:33 craftcms.nspeaks.com postgres[72148]: 2023-12-04 22:28:33.999 UTC [72148] LOG: redirecționarea ieșirii jurnalului către procesul de colectare a jurnalului
Dec 04 22:28:33 craftcms.nspeaks.com postgres[72148]: 2023-12-04 22:28:33.999 UTC [72148] SFAT: Ieșirea viitoare a jurnalului va apărea în directorul „jurnal”.
04 decembrie 22:28:34 craftcms.nspeaks.com systemd[1]: A pornit serverul de baze de date PostgreSQL 16.

Puteți vedea că serviciul este activat și rulează implicit.

Lansați shell-ul PostgreSQL.

$ sudo -i -u postgres psql

Creați baza de date Craft CMS.

postgres=# CREAȚI BAZĂ DE DATE craftcms;

Creați utilizatorul Craft CMS și alegeți o parolă puternică.

postgres-# CREAȚI UTILIZATOR craftuser CU PAROLA 'Parola_dvs';

Schimbați proprietarul bazei de date în utilizatorul Craft CMS.

postgres-# ALTER DATABASE craftcms OWNER TO craftuser;

Acordați toate privilegiile din baza de date utilizatorului Craft CMS.

postgres-# ACORDĂ TOATE PRIVILEGIILE PE BAZĂ DE DATE craftcms CĂTRE craftuser;

Ieși din shell.

postgres-# \q

Verificați dacă acreditările dvs. funcționează.

$ psql --username craftuser --parola --host localhost craftcms
Password:
psql (16.1)
Tastați „help” pentru ajutor.

craftcms =>

Ieșiți din shell tastând \q.

Pasul 7 – Instalați și configurați Redis

Rocky Linux 9 este livrat implicit cu Redis 6.2. Cu toate acestea, vom folosi Redis 7.0 pe care îl vom instala folosind Remi Repository.

Deoarece am instalat depozitul Remi în timpul instalării PHP, putem sări peste acea parte. Listați toate modulele Redis disponibile.

$ sudo dnf module list redis
Rocky Linux 9 - AppStream
Rezumatul profilurilor fluxului de nume
redis 7 comun [d] baza de date persistentă cheie-valoare Redis

Depozitul modular al lui Remi pentru Enterprise Linux 9 - x86_64
Rezumatul profilurilor fluxului de nume
redis remi-5.0 common [d] baza de date persistentă cheie-valoare Redis
redis remi-6.0 common [d] baza de date persistentă cheie-valoare Redis
redis remi-6.2 common [d] baza de date persistentă cheie-valoare Redis
redis remi-7.0 common [d] baza de date persistentă cheie-valoare Redis
redis remi-7.2 common [d] baza de date persistentă cheie-valoare Redis

Sugestie: [d]efectuat, [activat], [x]dezactivat, [instalat]

Activați cel mai recent modul Redis 7.2.

$ sudo dnf module enable -y redis:remi-7.2

Instalați Redis.

$ sudo dnf install redis

Verificați versiunea.

$ redis-server --version
Server Redis v=7.2.3 sha=00000000:0 malloc=jemalloc-5.3.0 biți=64 build=7bd3173e4e30c3e4

Activați serviciul Redis.

$ sudo systemctl enable redis

Porniți serviciul Redis.

$ sudo systemctl start redis

Verificați starea serviciului.

$ sudo systemctl status redis
? redis.service - baza de date persistentă cheie-valoare Redis
     Încărcat: încărcat (/usr/lib/systemd/system/redis.service; activat; presetat: dezactivat)
    Drop-in: /etc/systemd/system/redis.service.d
             ??limit.conf
     Activ: activ (în rulare) din Luni 2023-12-04 22:36:25 UTC; acum 1 min 32s
   PID principal: 72877 (server redis)
     Stare: „Pregătit să accepte conexiuni”
      Sarcini: 5 (limită: 10866)
     Memorie: 7,5 M
        CPU: 176 ms
     CGroup: /system.slice/redis.service
             ??72877 „/usr/bin/redis-server 127.0.0.1:6379”

04 decembrie 22:36:25 craftcms.nspeaks.com systemd[1]: Se pornește baza de date persistentă cheie-valoare Redis...
04 decembrie 22:36:25 craftcms.nspeaks.com systemd[1]: a început baza de date persistentă cheie-valoare Redis.

Următorul pas este să adăugați autentificare la serverul Redis. Începând cu Redis v6.0, cea mai bună modalitate de a adăuga autentificare este utilizarea ACL (liste de control acces). Deschideți /etc/redis/redis.conffișierul pentru editare.

$ sudo nano /etc/redis/redis.conf

Găsiți # aclfile /etc/redis/users.aclintrarea de linie și decomentați-o eliminând simbolul hash ( #) din fața ei.

aclfile /etc/redis/users.acl

Salvați fișierul apăsând Ctrl + X și introducând Y când vi se solicită.

Apoi, creați și deschideți /etc/redis/users.aclfișierul pentru editare.

$ sudo nano /etc/redis/users.acl

Adăugați următoarea linie la acesta.

user navjot pe +@all ~* >parola ta

Salvați fișierul apăsând Ctrl + X și introducând Y când vi se solicită.

Reporniți serverul Redis pentru a implementa modificarea.

$ sudo systemctl restart redis

Deschideți shell-ul Redis.

$ redis-cli

Utilizați PINGcomanda. Va da o eroare de autentificare.

127.0.0.1:6379> PING
(eroare) NOAUTH Este necesară autentificarea.

Utilizați AUTHcomanda pentru a vă autentifica.

127.0.0.1:6379> AUTH navjot parola ta
Bine

Folosiți PINGcomanda din nou.

127.0.0.1:6379> PING
Bine

Ieși din shell.

127.0.0.1:6379> ieșire

De asemenea, va trebui să instalați extensia PHP Redis.

$ sudo apt install php-redis

Pasul 8 – Instalați Craft CMS

Înainte de a instala Craft CMS, puteți verifica dacă îndepliniți toate cerințele de server pentru a-l rula folosind următoarea comandă.

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

Veți obține următoarea ieșire.

Se execută verificarea serverului Craft...

Craft CMS Verificator de cerințe

Acest script verifică dacă configurația serverului dvs. web îndeplinește cerințele pentru rularea unei instalări Craft CMS.
Verifică dacă serverul rulează versiunea corectă de PHP, dacă au fost încărcate extensii PHP adecvate,
și dacă setările fișierului php.ini sunt corecte.

Rezultate:
--------

PHP 8.2+: OK

Extensia BCMath: OK

extensia ctype: OK

Extensia cURL: OK

Extensia DOM: OK

Extensia informațiilor fișierului: OK

Extensia GD sau extensia ImageMagick: OK

extensia iconv: OK

Extensie interna: OK

Extensie JSON: OK

Extensie șir multiocteți (cu supraîncărcarea funcției dezactivată): OK

Extensia OPcache (cu save_comments): OK

Extensia OpenSSL: OK

Extensie PCRE (cu suport UTF-8): OK

Extensie PDO: OK

Extensie de reflecție: OK

Extensie SPL: OK

Extensie zip: 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

apeluri ini_set: OK

Limită memorie: OK

-------------------------------------------
Erori: 0 Avertismente: 0 Total verificări: 27

Odată ce totul este în regulă, puteți continua. Creați directorul rădăcină web.

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

Setați utilizatorul conectat în prezent ca proprietar al acestui director.

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

Comutați la director.

$ cd /var/www/html/craftcms

Descărcați și instalați Craft CMS folosind Composer. Punctul ( .) de la sfârșitul comenzii înseamnă că instalarea trebuie efectuată în directorul curent.

$ compozitor create-project craftcms/craft .

În timpul instalării, vi se vor cere mai multe detalii privind baza de date și contul de administrator. URL-ul site-ului și limba acestuia, după cum se arată mai jos.

> @php craft Configurare/bine ai venit

   ______ .______ ___ _______ .___________.
  / || _ \ / \ | ____|| |
 | ,----'| |_) | / ^ \ | |__ `---| |----`
 | | | / / /_\ \ | __| | |
 | `----.| |\ \----./ _____ \ | | | |
  \______|| _| `._____/__/ \__\ |__| |__|

     ANEWINSTALL
               ______ .___ ___. _______.
              / || \/ | / |
             | ,----'| \ / | | (----`
             | | | |\/| | \ \
             | `----.| | | | .----) |
              \______||__| |__| |_______/


Generarea unui ID de aplicație... gata (CraftCMS--923f03f1-9bea-4c3d-a7ca-1466645ce75d)
Generarea unei chei de securitate... gata (iMdcUi6wQyf9MshEda__vZcCwILbclxz)

Bun venit la Craft CMS!

Ești gata să începi configurarea? (da|nu) [nu]:da
Ce driver de bază de date folosești? (mysql sau pgsql) [mysql] pgsql
Numele serverului bazei de date sau adresa IP: [127.0.0.1]
Port baza de date: [5432]
Nume utilizator baza de date: [root] craftuser
Parola bazei de date:
Numele bazei de date: craftcms
Prefixul tabelului bazei de date:
Testarea acreditărilor bazei de date... succes!
Folosind schema implicită „publică”.
Salvarea acreditărilor bazei de date în fișierul .env... gata

Instalați Craft acum? (da|nu) [da]:da

Nume de utilizator: [admin] navjot
E-mail: navjot@example.com
Parolă:
Confirma:
Numele site-ului: tutoriale Howtoforge
Adresa URL a site-ului: https://craftcms.example.com
Limba site-ului: [en-US]
*** instalarea Craft

Faceți Redis să funcționeze cu Craft CMS

Instalați yiisoft/yii2-redispachetul.

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

Deschideți /var/www/html/craftcms/config/app.phpfișierul pentru editare.

$ nano config/app.php

Veți vedea următorul conținut în el.

use craft\helpers\App;

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

Schimbați-l după cum urmează.

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ți fișierul apăsând Ctrl + X și introducând Y când vi se solicită. Acest lucru permite Redis ca stocare cache pentru Craft CMS. De asemenea, puteți utiliza Redis pentru stocarea datelor de sesiune PHP, coada de joburi și ca driver mutex. Puteți găsi configurația pentru aceasta în documentația Craft CMS .

De asemenea, trebuie să adăugați configurația Redis la .envfișier.

$ nano .env

Adăugați următorul cod la sfârșitul fișierului.

REDIS_HOSTNAME=localhost
REDIS_USERNAME=navjot
REDIS_PASSWORD=parola ta

Alegeți opțiunile așa cum se arată mai sus. După ce ați terminat, schimbați grupul directorului în nginx. În acest fel, atât utilizatorul conectat în prezent, cât și Nginx vor avea acces la Craft CMS.

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

Acordați nginxpermisiunea grupului de a scrie în director.

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

De aici încolo, nu va trebui să schimbați din nou permisiunile și puteți face toate operațiunile fără a utiliza privilegiile root.

Pasul 9 – Instalați SSL

Trebuie să instalăm Certbot pentru a genera certificatul SSL. Vom folosi programul de instalare a pachetului Snapd pentru asta. Deoarece Rocky Linux nu este livrat cu acesta, instalați programul de instalare Snapd. Este necesar ca depozitul EPEL (Extra Packages for Enterprise Linux) să funcționeze. Dar, din moment ce l-am instalat deja la pasul 3, putem merge direct înainte.

Instalați Snapd.

$ sudo dnf install -y snapd

Activați și porniți serviciul Snap.

$ sudo systemctl enable snapd --now

Instalați pachetul de bază Snap și asigurați-vă că versiunea dvs. de Snapd este actualizată.

$ sudo snap install core && sudo snap refresh core

Creați linkurile necesare pentru ca Snapd să funcționeze.

$ 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

Instalați Certbot.

$ sudo snap install --classic certbot

Utilizați următoarea comandă pentru a vă asigura că comanda Certbot poate fi rulată prin crearea unei legături simbolice către /usr/bindirector.

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

Verificați dacă Certbot funcționează corect.

$ certbot --versiune
certbot 2.7.4

Rulați următoarea comandă pentru a genera un certificat SSL.

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

Comanda de mai sus va descărca un certificat în /etc/letsencrypt/live/craftcms.example.comdirectorul de pe serverul dvs.

Generați un certificat de grup Diffie-Hellman .

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

Verificați serviciul de planificare a reînnoirii Certbot.

$ sudo systemctl list-timers

Veți găsi snap.certbot.renew.serviceunul dintre serviciile programate să ruleze.

URMĂTOAREA STÂNGA ULTIMA UNITATE A TRUCĂ SE ACTIVĂ     
------------------------------------------------------------ -------------------------------------------------------------               
Luni 2023-12-04 23:38:47 UTC 18min rămas Luni 2023-12-04 22:19:02 UTC Acum 1h 0min dnf-makecache.timer dnf-makecache.service
Mar 2023-12-05 00:00:00 UTC 40 min rămase - - logrotate.timer logrotate.service
Mar 2023-12-05 09:36:00 UTC Mai sunt 10 ore - - snap.certbot.renew.timer snap.certbot.renew.service

Faceți o rulare uscată a procesului pentru a verifica dacă reînnoirea SSL funcționează bine.

$ sudo certbot renew --dry-run

Dacă nu vedeți nicio eroare, sunteți gata. Certificatul dumneavoastră se va reînnoi automat.

Pasul 10 – Configurați SELinux

Schimbați contextul de securitate al fișierului pentru Craft CMS.

$ sudo semanage fcontext -a -t httpd_sys_rw_content_t "/var/www/html/craftcms(/.*)?"

Aplicați politica.

$ sudo restorecon -Rv /var/www/html/craftcms/

Aplicați politica pentru a permite Nginx să acorde acces la PostgreSQL.

$ sudo setsebool -P httpd_can_network_connect_db 1

Aplicați politica pentru a permite conexiunile cu gazde externe.

$ sudo setsebool -P httpd_can_network_connect 1

Cu MariaDB 10.11, te vei confrunta cu o altă problemă și anume că SELinux împiedică PHP-FPM să se conecteze la MariaDB. Acest lucru poate fi rezolvat prin instalarea unui modul SELinux. Primul pas este crearea unui type enforcementfișier.

Creați fișierul my-phpfpm.teîn directorul dvs. de acasă și deschideți-l pentru editare.

$ cd ~
$ nano my-phpfpm.te

Lipiți următorul cod în el.

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ți fișierul apăsând Ctrl + X și introducând Y când vi se solicită.

Următorul pas este să îl convertiți într-un modul de politică folosind următoarea comandă. Nu modificați numele fișierului în comandă, altfel nu va funcționa. Modulul este numit my-phpfpmși numele fișierului ar trebui să fie același cu numele modulului.

$ sudo checkmodule -M -m -o my-phpfpm.mod my-phpfpm.te

Apoi, trebuie să compilam modulul de politici pentru a crea un pachet de politici.

$ sudo semodule_package -o my-phpfpm.pp -m my-phpfpm.mod

Pasul final este să încărcați pachetul de politici utilizând semodulecomanda care instalează politica de utilizat.

$ sudo semodule -i my-phpfpm.pp

Pasul 11 ​​- Configurați Nginx

Deschideți fișierul /etc/nginx/nginx.confpentru editare.

$ sudo nano /etc/nginx/nginx.conf

Adăugați următoarea linie înainte de linie include /etc/nginx/conf.d/*.conf;.

server_names_hash_bucket_size 64;

Salvați fișierul apăsând Ctrl + X și introducând Y când vi se solicită.

Creați și deschideți fișierul /etc/nginx/conf.d/craftcms.confpentru editare.

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

Lipiți următorul cod în el. Înlocuiește-l craftcms.example.comcu numele tău de domeniu. Asigurați-vă că valoarea client_max_body_sizeeste setată la 128MB, ceea ce am setat pentru Craft CMS în timp ce configurați PHP mai devreme.

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ți fișierul apăsând Ctrl + X și introducând Y când vi se solicită.

Verificați configurația dvs. Nginx.

$ sudo nginx -t

Reporniți serverul Nginx.

$ sudo systemctl reporniți nginx

Pasul 12 – Accesați Craft CMS

Deschideți adresa URL https://craftcms.example.comîn browser și veți fi direcționat la următoarea pagină.

Pentru a accesa pagina de administrare, vizitați adresa URL https://craftcms.example.com/adminși veți fi direcționat către pagina de autentificare.

Introduceți acreditările dvs. de administrare și faceți click pe tasta Conectare pentru a vă conecta. Veți fi direcționat la următorul tablou de bord.

Acum puteți începe să utilizați Craft CMS pentru a vă construi site-ul web.

Pasul 13 – Backup și restaurare Craft CMS

Puteți face copii de rezervă ale bazei de date Craft CMS din interiorul panoului de administrare, vizitând Tabloul de bord de administrare >> Utilități >> Backup baze de date.

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

$ cd /var/www/html/craftcms
$ php craft db/backup ~/
Copierea de rezervă a bazei de date... gata
Fișier de rezervă: /home/navjot/craftcms.database.sql (200.019 KB)

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

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

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

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

$ php craft update all