Soluții pentru problemele tale IT
Pentru a marca începutul noului an fiscal, echipa de comunicare internă a companiei organizează un eveniment fizic cu angajații. Pentru a coordona eficient organizarea evenimentului, de la gestionarea invitațiilor, până la comunicarea detaliilor logistice, a fost aleasă platforma Enjoee.
În cele ce urmează, vom parcurge pas cu pas procesul de creare a evenimentului în Enjoee.
[mai mult...]Daca avem nevoie de setarea unei rezolutii cu anumiti parametri (sau frecvente foarte specifice) si vrem sa ne asiguram ca acestea sunt aplicate, nu ne putem baza intotdeauna pe valorile raportate de windows sau de driverul video. De asemenea, acestea de obicei nu furnizeaza detalii precise despre parametrii rezolutiei actuale.
[mai mult...]Twitch Drops are a way for viewers to earn in-game rewards by watching participating Twitch streams.
[mai mult...]Adding emotes to Twitch is primarily a feature for Twitch Partners and Affiliates
Key Requirements:
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:
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.
Cerințe preliminare
craftcms.example.comindicarea către serverul dvs.$ sudo dnf update
$ 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
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