Soluții

Cum se instalează Joomla cu Nginx pe serverul Ubuntu 24.04

Joomla este un sistem de management al conținutului bazat pe PHP. Pentru a-l instala, trebuie să instalați PHP pe sistemul dvs. În această secțiune, veți instala stiva LEMP (Linux, Nginx, MariaDB și PHP-FPM) ca dependențe pentru Joomla.

Mai întâi, rulați comanda de mai jos pentru a vă actualiza indexul pachetului Ubuntu.

sudo apt update

Instalați dependențele stivei LEMP cu comanda de mai jos. Introdu „ Y ” pentru a confirma instalarea.

sudo apt install nginx mariadb-server php-fpm php-curl php-common php-json php-intl php-xml php-gd php-mysql php-imagick php-mbstring php-zip

După finalizarea instalării, verificați starea serviciului Nginx cu următoarele:

sudo systemctl enable nginx 
sudo systemctl start nginx 
sudo systemctl status nginx

Puteți vedea că serviciul Nginx rulează.

Acum verificați serviciul MariaDB pentru a vă asigura că serviciul rulează și este activat cu comanda de mai jos:

sudo systemctl enable mariadb 
sudo systemctl start mariadb
sudo systemctl status mariadb

În cele din urmă, rulați următoarea comandă pentru a verifica serviciul PHP-FPM. PHP-FPM ar trebui să ruleze în mod implicit pe fișierul sock.

sudo systemctl enable php8.3-fpm 
sudo systemctl start php8.3-fpm 
sudo systemctl status php8.3-fpm

Configurarea PHP-FPM

Acum că stiva LEMP este instalată, veți configura instalarea PHP-FPM și veți modifica unele configurații implicite după cum este necesar pentru Joomla.

Deschideți configurația PHP-FPM „ /etc/php/8.3/fpm/php.ini ” cu editorul „ nano ”.

sudo nano /etc/php/8.3/fpm/php.ini

Modificați configurația implicită cu următoarele:

memory_limit=512M 
upload_max_filesize=64M 
post_max_size=64M 
max_execution_time=120 
output_buffering = Off 
extension=intl

Salvați fișierul și ieșiți din editor.

Acum reporniți serviciul PHP-FPM pentru a aplica modificările.

sudo systemctl restart php8.3-fpm

În cele din urmă, puteți verifica fișierul PHP sock pentru serviciul PHP-FPM cu comanda de mai jos.

ss -pl | grep php

Puteți vedea mai jos fișierul sock pentru PHP-FPM se află la „ /var/run/php/php8.3-fpm.sock ”.

Configurarea serverului MariaDB

În această secțiune, veți securiza instalarea serverului MariaDB, apoi veți crea o nouă bază de date și un utilizator pentru Joomla. Veți folosi „mariadb-secure-installation” pentru a securiza serverul MariaDB și apoi prin clientul „mariadb” pentru a crea o nouă bază de date și utilizator.

Pentru a securiza serverul MariaDB, rulați comanda „ mariab-secure-installation ” de mai jos.

sudo mariadb-secure-installation

Acum vi se va cere să configurați serverul MariaDB cu următoarele:

  • Pentru instalarea implicită a serverului MariaDB fără o parolă root, apăsați ENTER când sunteți întrebat despre parolă.
  • Autentificarea locală pentru utilizatorii root MariaDB este securizată în mod implicit, introduceți „n” când vi se cere să schimbați metoda de autentificare în „unix_socket”.
  • Introduceți „Y” pentru a crea o nouă parolă root MariaDB. Apoi, introduceți parola puternică pentru utilizatorul dvs. root MariaDB și repetați.
  • Când vi se cere să dezactivați autentificarea de la distanță pentru utilizatorul root MariaDB, introduceți „Y” pentru a fi de acord.
  • Instalarea implicită a serverului MariaDB vine cu baza de date „test” și permite unui utilizator anonim să o acceseze.
  • Introduceți „Y” pentru ambele setări pentru a elimina „testul” implicit al bazei de date și a elimina privilegiul anonim.
  • În cele din urmă, introduceți „Y” pentru a confirma privilegiile de reîncărcare a tabelului.

Odată ce MariaDB este securizat, veți crea o nouă bază de date și un utilizator pentru Joomla.

Conectați-vă la serverul MariaDB cu comanda „ mariadb ” de mai jos. Introduceți parola de root MariaDB când vi se solicită.

sudo mariadb -u root -p

Acum rulați următoarele interogări pentru a crea o nouă bază de date „ joomladb ” și un nou utilizator „ joomla ” cu parola „ p4ssword ”.

CREATE DATABASE joomladb;
CREATE USER joomla@localhost IDENTIFIED BY 'p4ssword';
GRANT ALL PRIVILEGES ON joomladb.* TO joomla@localhost;
FLUSH PRIVILEGES;

Apoi, executați interogarea de mai jos pentru a verifica privilegiile utilizatorului „ joomla ”. Veți vedea că utilizatorul „ joomla ” poate accesa baza de date „ joomladb ”.

SHOW GRANTS FOR joomla@localhost;

În cele din urmă, tastați „ quit ” pentru a ieși de pe serverul MariaDB.

Descărcarea codului sursă Joomla

În acest moment, ați instalat și configurat dependențe pentru Joomla. Acum veți descărca codul sursă Joomla și veți configura directorul document-root/webroot pentru instalarea Joomla. Accesați directorul „/var/www” și descărcați codul sursă Joomla cu comanda „wget” de mai jos. Verificați pagina de descărcare Joomla și luați linkul pentru cea mai recentă versiune.

cd /var/www/ 
wget https://downloads.joomla.org/cms/joomla5/5-1-4/Joomla_5-1-4-Stable-Full_Package.zip

Acum rulați comanda „unzip” de mai jos pentru a extrage codul sursă Joomla în directorul „joomla”.

unzip Joomla_5-1-4-Stable-Full_Package.zip -d joomla

În cele din urmă, rulați comanda „chmod” de mai jos pentru a schimba proprietatea directorului „/var/www/joomla” la utilizatorul „www-data”.

sudo chown -R www-data:www-data /var/www/joomla

Configurarea blocului serverului Nginx

Acum veți crea o nouă configurație de bloc de server Nginx pentru rularea Joomla. Așa că asigurați-vă că aveți numele de domeniu pregătit și că ați indicat adresa IP a serverului.

Creați un nou fișier server Nginx „ /etc/nginx/sites-available/joomla ” cu următorul editor „ nano ”.

sudo nano /etc/nginx/sites-available/joomla

Introduceți configurația de mai jos și modificați opțiunea „ server_name ” cu numele domeniului dumneavoastră.

server {
listen 80;
server_name howtoforge.local;
server_name_in_redirect off;

access_log /var/log/nginx/localhost.access_log;
error_log /var/log/nginx/localhost.error_log info;

root /var/www/joomla;
index index.php index.html index.htm default.html default.htm;

# Support API
location /api/ {
try_files $uri $uri/ /api/index.php?$args;
}

# Support Clean (aka Search Engine Friendly) URLs
location / {
try_files $uri $uri/ /index.php?$args;
}

# add global x-content-type-options header
add_header X-Content-Type-Options nosniff;

# deny running scripts inside writable directories
location ~* /(images|cache|media|logs|tmp)/.*\.(php|pl|py|jsp|asp|sh|cgi)$ {
return 403;
error_page 403 /403_error.html;
}

location ~ \.php$ {
fastcgi_pass unix:/var/run/php/php8.3-fpm.sock;
fastcgi_index index.php;
include fastcgi_params;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
include /etc/nginx/fastcgi.conf;
}

# caching of files
location ~* \.(ico|pdf|flv)$ {
expires 1y;
}

location ~* \.(js|css|png|jpg|jpeg|gif|swf|xml|txt)$ {
expires 14d;
}

}

Salvați fișierul și ieșiți din editor.

Acum rulați comanda de mai jos pentru a activa blocul de server „ joomla ” și pentru a verifica configurația dvs. Nginx. Dacă aveți setări Nginx adecvate, veți vedea o ieșire „ Sintaxa este OK ”.

sudo ln -s /etc/nginx/sites-available/joomla /etc/nginx/sites-enabled/ 
sudo nginx -t

În cele din urmă, rulați comanda „systemctl” de mai jos pentru a reporni serviciul Nginx și a aplica modificările.

sudo systemctl restart nginx

Securizarea Joomla cu HTTPS

În acest ghid, veți securiza Joomla cu HTTPS. Dacă utilizați domeniul public, puteți securiza Joomla prin certificate SSL/TLS prin Certbot și Letsencerypt.

Instalați „Certbot” și pluginul Certbot Nginx cu comanda „apt” de mai jos. Introduceți „Y” pentru a confirma instalarea.

sudo apt install certbot python3-certbot-nginx

După finalizarea instalării, rulați următoarea comandă „certbot” pentru a genera certificate SSL/TLS și a vă asigura instalarea Joomla cu HTTPS. Asigurați-vă că schimbați numele domeniului și adresa de e-mail cu informațiile dvs.

sudo certbot --nginx --agree-tos --redirect --hsts --staple-ocsp --email kyrie@howtoforge.local -d howtoforge.local

Când ați terminat, instalarea dvs. Joomla este securizată cu HTTPS prin certificate SSL/TLS de la Letsencrypt.

Instalarea Joomla

Deschideți browserul web și vizitați numele de domeniu Joomla, cum ar fi https://askit.local/ . Veți vedea asistentul de instalare Joomla.

Selectați limba implicită și introduceți numele site-ului.

Introduceți noul utilizator de administrator, adresa de e-mail și parola pentru Joomla.

Introduceți detaliile despre baza de date MariaDB și despre utilizator, apoi faceți click pe „ Instalare Joomla ” pentru a continua cu instalarea.

După finalizarea instalării, faceți clic pe „ Deschidere site ” pentru a deschide pagina de pornire implicită sau pe „ Deschidere administrator ” pentru a accesa tabloul de bord de administrare Joomla.

Pentru pagina de pornire Joomla implicită, veți vedea următoarele.

Acum introduceți utilizatorul și parola de administrator și faceți click pe „ Autentificare”.

Dacă aveți utilizatorul și parola corecte, veți vedea următorul tablou de bord de administrare Joomla.

[mai mult...]

Cum se instalează Craft CMS pe Rocky Linux 9

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.

Faceți clic pe butonul Backup pentru a descărca backupul bazei de date. De asemenea, puteți crea backup folosind terminalul. Rulați următoarea comandă pentru a crea copia de rezervă. Introduceți parola când vi se solicită.

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

De asemenea, puteți crea copia de rezervă a bazei de date folosind utilitarul de linie de comandă Craft CMS. Avantajul acestui utilitar este că nu trebuie să treceți acreditările bazei de date. Citiți mai multe despre utilitarul consolei de comandă Craft CMS aici .

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

Dacă nu specificați nicio locație în comanda de mai sus, fișierul de rezervă va fi scris în /var/www/html/craftcms/storage/backupsdirector.

Pentru a face backup la fișiere, copiați și salvați întregul /var/www/html/craftcmsfolder.

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

Pentru a-l restaura pe un nou server, extrageți fișierele în /var/www/htmlfolder.

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

Creați o bază de date cu aceleași acreditări pe noul server și restaurați baza de date folosind următoarea comandă. Introduceți parola când vi se solicită.

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

Pasul 14 – Actualizați CMS Craft

Există două moduri de a actualiza Craft CMS. Unul este din interiorul panoului de administrare. Când o actualizare este disponibilă, veți primi o notificare. Faceți clic pe notificare pentru a face upgrade. Craft CMS va face backup automat pentru baza de date înainte de a efectua o actualizare.

De asemenea, îl puteți actualiza prin terminal.

Pentru a verifica toate actualizările disponibile, executați următoarea comandă.

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

Dacă este disponibilă o actualizare, rulați următoarea comandă pentru a o aplica.

$ php craft update all
[mai mult...]

How to use Less than or Equal to in Excel

To use the less-than-or-equal-to operator, type “=C2<=200” where C2 is the cell to compare and 200 is your specified value. The formula will return TRUE if C2 has a value equal to or less than 200; else, it will return FALSE.

Using the less-than-or-equal-to

<=

operator in Microsoft Excel allows you to find out if the specified value matches your formula value or is less than that. We’ll show you how to use this operator to compare numbers and dates and how to use it with Excel’s various other functions.

When you use the less-than-or-equal-to operator, Excel retrieves a TRUE result if the cell has a value that’s less than or equal to your specified value. If the cell value is higher than your specified value, the operator will return a FALSE result.

[mai mult...]