Come installare Magento eCommerce Suite su Rocky Linux 9 con Elasticsearch
In questa pagina
- Prerequisiti
- Passaggio 1: configurare il firewall
- Passaggio 2: installa PHP e le sue estensioni
- Passaggio 3: installare Composer
- Passaggio 4: installare MariaDB
- Passaggio 5: configurare MariaDB
- Passaggio 6: installare Nginx
- Passaggio 7: installare SSL
- Passaggio 8: installare Elasticsearch
- Passaggio 9: installare il server Redis
- Passaggio 10: scarica Magento
- Passaggio 11: installare Magento
- Passaggio 12: configurare PHP-FPM
- Passaggio 13: configurare SELinux
- Passaggio 14: configurare Nginx
- Passaggio 15: disattivare l'autenticazione a due fattori
- Passaggio 16: accedere al portale di amministrazione
- Passaggio 17: abilitare e configurare l'autenticazione a due fattori
- Conclusione
Magento è una piattaforma di e-commerce open source scritta in PHP. È stato acquisito da Adobe nel 2018. Viene offerto anche come prodotto commerciale e basato su cloud. Puoi utilizzare Magento per creare siti Web di shopping professionali ad alta capacità. Offre entrambe le modalità: negozio singolo e modalità negozio multiplo. Viene fornito con molti moduli per estendere le sue funzionalità.
In questo tutorial installeremo l'edizione della community open source Magento. Offre tutte le funzionalità necessarie per creare un negozio online professionale. Installeremo anche Elasticsearch per effettuare ricerche nel catalogo prodotti, Redis per la sessione e la cache dei file e lo serviremo utilizzando il server Nginx.
Prerequisiti
Un server che esegue Rocky Linux 9 con un minimo di 2 GB di RAM. Potrebbe essere necessaria più RAM, a seconda delle tue esigenze.
Un utente non root con privilegi sudo.
Un nome di dominio completo (FQDN) per il server, magento.example.com
Assicurati che tutto sia aggiornato.
$ sudo dnf update
Pochi pacchetti di cui il tuo sistema ha bisogno.
$ sudo dnf install wget curl nano unzip yum-utils policycoreutils-python-utils -y
Alcuni di questi pacchetti potrebbero essere già installati sul tuo sistema.
Passaggio 1: configurare il firewall
Il primo passo è configurare il firewall. Rocky Linux utilizza Firewalld Firewall. Controlla lo stato del firewall.
$ sudo firewall-cmd --state
running
Il firewall funziona con zone diverse e la zona pubblica è quella predefinita che utilizzeremo. Elenca tutti i servizi e le porte attive sul firewall.
$ sudo firewall-cmd --permanent --list-services
Dovrebbe mostrare il seguente output.
cockpit dhcpv6-client ssh
Consenti porte HTTP e HTTPS.
$ sudo firewall-cmd --permanent --add-service=http
$ sudo firewall-cmd --permanent --add-service=https
Ricontrolla lo stato del firewall.
$ sudo firewall-cmd --permanent --list-services
Dovresti vedere un output simile.
cockpit dhcpv6-client http https ssh
Ricaricare il firewall per abilitare le modifiche.
$ sudo firewall-cmd --reload
Passaggio 2: installa PHP e le sue estensioni
Rocky Linux 9 viene fornito con PHP 8.1 per impostazione predefinita. Per rimanere sempre sull'ultima versione di PHP o se desideri installare più versioni di PHP, dobbiamo utilizzare il repository REMI.
Il primo passo è prendere il repository Epel.
$ sudo dnf install epel-release -y
Successivamente, installa il repository Remi.
$ sudo dnf install https://rpms.remirepo.net/enterprise/remi-release-9.rpm
Controlla i flussi PHP disponibili.
$ dnf module list php -y
Name Stream Profiles Summary
php 8.1 common [d], devel, minimal PHP scripting language
Remi's Modular repository for Enterprise Linux 9 - x86_64
Name Stream Profiles Summary
php remi-7.4 common [d], devel, minimal PHP scripting language
php remi-8.0 common [d], devel, minimal PHP scripting language
php remi-8.1 common [d], devel, minimal PHP scripting language
php remi-8.2 common [d], devel, minimal PHP scripting language
php remi-8.3 common [d], devel, minimal PHP scripting language
Hint: [d]efault, [e]nabled, [x]disabled, [i]nstalled
La versione predefinita è 8.1. Al momento della stesura di questo tutorial, Magento è compatibile con PHP 8.2. Pertanto, abilita il repository PHP 8.2 di Remi.
$ sudo dnf module reset php -y
$ sudo dnf module enable php:remi-8.2
Puoi installarlo e le estensioni richieste da Magento eseguendo il seguente comando.
$ sudo dnf install php-fpm php-cli php-mysql php-mbstring php-xml php-gd php-bcmath php-zip php-curl php-tidy php-intl php-soap php-opcache php-xsl php-sodium
Verificare l'installazione.
$ php --version
PHP 8.2.15 (cli) (built: Jan 16 2024 12:19:32) (NTS gcc x86_64)
Copyright (c) The PHP Group
Zend Engine v4.2.15, Copyright (c) Zend Technologies
with Zend OPcache v8.2.15, Copyright (c), by Zend Technologies
Passaggio 3: installare Composer
Composer è uno strumento di gestione delle dipendenze per PHP ed è richiesto per l'installazione di Magento.
Esegui i seguenti comandi per scaricare il file binario Composer. Magento richiede Composer 2.2 LTS quindi abbiamo modificato il comando di conseguenza.
$ php -r "copy('https://getcomposer.org/installer', 'composer-setup.php');"
$ php composer-setup.php --2.2
$ php -r "unlink('composer-setup.php');"
Installa Composer spostando il file binario nella directory /usr/local/bin
.
$ sudo mv composer.phar /usr/local/bin/composer
Verificare l'installazione controllandone la versione.
$ composer --version
Composer version 2.2.22 2023-09-29 10:53:45
Passaggio 4: installare MariaDB
Rocky Linux 9 viene fornito con una versione precedente di MariaDB. Pertanto, utilizzeremo il repository di MariaDB per l'installazione. Al momento della stesura di questo tutorial, Magento supporta MariaDB 10.6 che è ciò che installeremo.
Importa la chiave GPG di MariaDB.
$ sudo rpm --import https://supplychain.mariadb.com/MariaDB-Server-GPG-KEY
Crea e apri il file /etc/yum.repos.d/mariadb.repo
per la modifica.
$ sudo nano /etc/yum.repos.d/mariadb.repo
Incolla il seguente codice al suo interno.
[mariadb]
name = MariaDB
baseurl = https://rpm.mariadb.org/10.6/rhel/$releasever/$basearch
gpgkey= https://rpm.mariadb.org/RPM-GPG-KEY-MariaDB
gpgcheck=1
Salva il file premendo Ctrl + X e inserendo Y quando richiesto.
$ sudo dnf install MariaDB-server
Controlla la versione di MySQL.
$ mysql --version
mysql Ver 15.1 Distrib 10.6.16-MariaDB, for Linux (x86_64) using EditLine wrapper
Abilita e avvia il servizio MariaDB.
$ sudo systemctl enable mariadb --now
Esegui lo script di installazione sicura di MariaDB.
$ sudo mariadb-secure-installation
Ti verrà richiesta la password di root. Premi Invio perché non abbiamo impostato alcuna password per questo.
NOTE: RUNNING ALL PARTS OF THIS SCRIPT IS RECOMMENDED FOR ALL MariaDB
SERVERS IN PRODUCTION USE! PLEASE READ EACH STEP CAREFULLY!
In order to log into MariaDB to secure it, we'll need the current
password for the root user. If you've just installed MariaDB, and
haven't set the root password yet, you should just press enter here.
Enter current password for root (enter for none):
Successivamente, ti verrà chiesto se desideri passare al metodo di autenticazione del socket Unix. Il plugin unix_socket
ti consente di utilizzare le credenziali del tuo sistema operativo per connetterti al server MariaDB. Poiché hai già un account root protetto, inserisci n
per procedere.
OK, successfully used password, moving on...
Setting the root password or using the unix_socket ensures that nobody
can log into the MariaDB root user without the proper authorisation.
You already have your root account protected, so you can safely answer 'n'.
Switch to unix_socket authentication [Y/n] n
Successivamente, ti verrà chiesto se desideri modificare la password di root. Digita Y
per procedere oltre e cambiare la password di root con qualcosa di sicuro e sicuro.
... skipping.
You already have your root account protected, so you can safely answer 'n'.
Change the root password? [Y/n] Y
New password:
Re-enter new password:
Password updated successfully!
Reloading privilege tables..
... Success!
Successivamente ti verranno poste alcune domande per migliorare la sicurezza di MariaDB. Digita Y per rimuovere utenti anonimi, impedire accessi root remoti, rimuovere il database di test e ricaricare le tabelle dei privilegi.
By default, a MariaDB installation has an anonymous user, allowing anyone
to log into MariaDB without having to have a user account created for
them. This is intended only for testing, and to make the installation
go a bit smoother. You should remove them before moving into a
production environment.
Remove anonymous users? [Y/n] y
... Success!
Normally, root should only be allowed to connect from 'localhost'. This
ensures that someone cannot guess at the root password from the network.
Disallow root login remotely? [Y/n] y
... Success!
By default, MariaDB comes with a database named 'test' that anyone can
access. This is also intended only for testing, and should be removed
before moving into a production environment.
Remove test database and access to it? [Y/n] y
- Dropping test database...
... Success!
- Removing privileges on test database...
... Success!
Reloading the privilege tables will ensure that all changes made so far
will take effect immediately.
Reload privilege tables now? [Y/n] y
... Success!
Cleaning up...
All done! If you've completed all of the above steps, your MariaDB
installation should now be secure.
Thanks for using MariaDB!
Puoi accedere alla shell MariaDB digitando sudo mysql
o sudo mariadb
sulla riga di comando.
Passaggio 5: configurare MariaDB
Accedi alla shell MariaDB.
$ sudo mariadb
Creare un database per Magento.
MariaDB > CREATE DATABASE magento;
Crea un account utente SQL.
MariaDB > CREATE USER 'magentouser'@'localhost' IDENTIFIED BY 'Your_password2';
Concedere all'utente tutti i privilegi sul database.
MariaDB > GRANT ALL PRIVILEGES ON magento.* TO 'magentouser'@'localhost';
Svuota i privilegi dell'utente.
MariaDB > FLUSH PRIVILEGES;
Esci dalla conchiglia.
MariaDB > exit
Passaggio 6: installare Nginx
Rocky Linux 9 viene fornito con una versione precedente di Nginx. È necessario utilizzare il repository ufficiale Nginx per installare la versione più recente.
Crea e apri il file /etc/yum.repos.d/nginx.repo
per la modifica.
$ sudo nano /etc/yum.repos.d/nginx.repo
Incolla il seguente codice al suo interno.
[nginx-stable]
name=nginx stable repo
baseurl=http://nginx.org/packages/centos/$releasever/$basearch/
gpgcheck=1
enabled=1
gpgkey=https://nginx.org/keys/nginx_signing.key
module_hotfixes=true
[nginx-mainline]
name=nginx mainline repo
baseurl=http://nginx.org/packages/mainline/centos/$releasever/$basearch/
gpgcheck=1
enabled=0
gpgkey=https://nginx.org/keys/nginx_signing.key
module_hotfixes=true
Una volta terminato, salva il file premendo Ctrl + X e inserendo Y quando richiesto.
Installeremo la linea principale Nginx, quindi abilita il pacchetto per questo.
$ sudo dnf config-manager --enable nginx-mainline
Installa Nginx.
$ sudo dnf install nginx -y
Verificare l'installazione.
$ nginx -v
nginx version: nginx/1.25.3
Abilita e avvia il servizio server Nginx.
$ sudo systemctl enable nginx --now
Controlla lo stato del servizio.
? nginx.service - nginx - high performance web server
Loaded: loaded (/usr/lib/systemd/system/nginx.service; enabled; preset: disabled)
Drop-In: /etc/systemd/system/nginx.service.d
??php-fpm.conf
Active: active (running) since Fri 2024-01-26 06:46:17 UTC; 1s ago
Docs: http://nginx.org/en/docs/
Process: 19765 ExecStart=/usr/sbin/nginx -c /etc/nginx/nginx.conf (code=exited, status=0/SUCCESS)
Main PID: 19767 (nginx)
Tasks: 3 (limit: 12225)
Memory: 3.1M
CPU: 16ms
CGroup: /system.slice/nginx.service
??19767 "nginx: master process /usr/sbin/nginx -c /etc/nginx/nginx.conf"
??19768 "nginx: worker process"
??19769 "nginx: worker process"
Passaggio 7: installare SSL
Dobbiamo installare Certbot per generare il certificato SSL. Per questo utilizzeremo il programma di installazione del pacchetto Snapd. Poiché Rocky Linux non viene fornito con esso, installa il programma di installazione Snapd. Per funzionare richiede il repository EPEL (Extra Packages for Enterprise Linux). Ma poiché l'abbiamo già installato nel passaggio 3, possiamo andare direttamente avanti.
Installa il pacchetto Snapd.
$ sudo dnf install -y snapd
Abilita e avvia il servizio Snap.
$ sudo systemctl enable snapd --now
Installa il pacchetto Snap core e assicurati che la tua versione di Snapd sia aggiornata.
$ sudo snap install core && sudo snap refresh core
Crea i collegamenti necessari affinché Snapd funzioni.
$ 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
Installa Certbot.
$ sudo snap install --classic certbot
Utilizzare il comando seguente per garantire che il comando Certbot possa essere eseguito creando un collegamento simbolico alla directory /usr/bin
.
$ sudo ln -s /snap/bin/certbot /usr/bin/certbot
Verifica se Certbot funziona correttamente.
$ certbot --version
certbot 2.8.0
Esegui il comando seguente per generare un certificato SSL.
$ sudo certbot certonly --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m [email -d magento.example.com
Il comando precedente scaricherà un certificato nella directory /etc/letsencrypt/live/magento.example.com
sul tuo server.
Genera un certificato gruppo Diffie-Hellman.
$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096
Controlla il servizio di pianificazione del rinnovo di Certbot.
$ sudo systemctl list-timers
Troverai snap.certbot.renew.service
come uno dei servizi pianificati per l'esecuzione.
NEXT LEFT LAST PASSED UNIT ACTIVATES
-------------------------------------------------------------------------------------------------------------------------------
Fri 2024-01-26 08:05:24 UTC 1h 1min left Fri 2024-01-26 06:35:00 UTC 29min ago dnf-makecache.timer dnf-makecache.service
Fri 2024-01-26 14:20:42 UTC 7h left Thu 2024-01-25 14:20:42 UTC 16h ago systemd-tmpfiles-clean.timer systemd-tmpfiles-clean.service
Fri 2024-01-26 22:37:00 UTC 15h left - - snap.certbot.renew.timer snap.certbot.renew.service
Esegui un test del processo per verificare se il rinnovo SSL funziona correttamente.
$ sudo certbot renew --dry-run
Se non vedi errori, è tutto a posto. Il tuo certificato si rinnoverà automaticamente.
Passaggio 8: installare Elasticsearch
Elasticsearch viene utilizzato da Magento per le ricerche di prodotti. Installeremo Elasticsearch 7.x utilizzando il suo repository ufficiale poiché è la versione compatibile con Magento 2.4.6 che è l'ultima versione disponibile. La pagina dei requisiti menziona anche Elasticsearch 8.5 ma non funziona correttamente con Magento.
Importa la chiave GPG di Elasticsearch.
$ sudo rpm --import https://artifacts.elastic.co/GPG-KEY-elasticsearch
Crea un file chiamato elasticsearch.repo
nella directory /etc/yum.repos.d/
e aprilo per la modifica.
$ sudo nano /etc/yum.repos.d/elasticsearch.repo
Incolla il seguente codice al suo interno.
[elasticsearch]
name=Elasticsearch repository for 7.x packages
baseurl=https://artifacts.elastic.co/packages/7.x/yum
gpgcheck=1
gpgkey=https://artifacts.elastic.co/GPG-KEY-elasticsearch
enabled=0
autorefresh=1
type=rpm-md
Una volta terminato, salva il file premendo Ctrl + X e inserendo Y quando richiesto.
Installa Elasticsearch.
$ sudo dnf install --enablerepo=elasticsearch elasticsearch
Elasticsearch utilizza molta memoria. È necessario limitarne l'utilizzo in base alle dimensioni del server. Crea il file /etc/elasticsearch/jvm.options.d/memory.options
e aprilo per la modifica.
$ sudo nano /etc/elasticsearch/jvm.options.d/memory.options
Incolla il seguente codice al suo interno. Modifica i valori in base alle dimensioni del tuo server. Il primo valore si riferisce alla memoria iniziale e il secondo si riferisce alla memoria massima disponibile. Per 1 GB e oltre, utilizza il formato -Xms1g
.
-Xms512m
-Xmx784m
Salva il file premendo Ctrl + X e inserendo Y quando richiesto. Ciò configura Elasticsearch per utilizzare 1 GB di RAM. Modificalo in base ai tuoi requisiti e alle specifiche del server.
Avvia e abilita il servizio.
$ sudo systemctl enable elasticsearch --now
Controlla se Elasticsearch funziona.
$ curl http://localhost:9200
Dovresti vedere il seguente output.
{
"name" : "magento.example.com",
"cluster_name" : "elasticsearch",
"cluster_uuid" : "saBfw0F_Tam6ayGjXr6pEA",
"version" : {
"number" : "7.17.17",
"build_flavor" : "default",
"build_type" : "rpm",
"build_hash" : "aba4da413a368e296dfc64fb20897334d0340aa1",
"build_date" : "2024-01-18T10:05:03.821431920Z",
"build_snapshot" : false,
"lucene_version" : "8.11.1",
"minimum_wire_compatibility_version" : "6.8.0",
"minimum_index_compatibility_version" : "6.0.0-beta1"
},
"tagline" : "You Know, for Search"
}
Passaggio 9: installare il server Redis
Magento utilizza Redis per l'archiviazione di sessioni e cache. È del tutto facoltativo ed è possibile utilizzare il database per l'archiviazione delle sessioni. Ma Redis fa un lavoro migliore. L'ultima versione di Magento funziona con Redis 7.0. Rocky Linux viene fornito con Redis 6.0, quindi utilizzeremo il repository Remi per l'installazione.
Abbiamo già installato il repository Remi quando abbiamo installato PHP nel passaggio 2. Elenca tutti i moduli Redis disponibili.
$ dnf module list redis
Name Stream Profiles Summary
redis 7 common [d] Redis persistent key-value database
Remi's Modular repository for Enterprise Linux 9 - x86_64
Name Stream Profiles Summary
redis remi-5.0 common [d] Redis persistent key-value database
redis remi-6.0 common [d] Redis persistent key-value database
redis remi-6.2 common [d] Redis persistent key-value database
redis remi-7.0 common [d] Redis persistent key-value database
redis remi-7.2 common [d] Redis persistent key-value database
Hint: [d]efault, [e]nabled, [x]disabled, [i]nstalled
Abilita Redis 7.0.
$ sudo dnf module enable -y redis:remi-7.0
Emettere il comando seguente per installare il server Redis.
$ sudo dnf install redis
Conferma la versione Redis.
$ redis-server -v
Redis server v=7.0.15 sha=00000000:0 malloc=jemalloc-5.2.1 bits=64 build=77c9855172eb54e9
Abilita e avvia il servizio Redis.
$ sudo systemctl enable redis --now
Verifichiamo la connessione al servizio utilizzando il comando seguente.
$ redis-cli
Verrai trasferito alla shell Redis.
Il primo passaggio è impostare la password per l'utente predefinito di Redis. Sostituisci Your_Redis_Password
con una password complessa a tua scelta. Assicurati di anteporre alla password il carattere >
.
127.0.0.1:6379> acl setuser default >Your_Redis_Password
Testare l'autenticazione Redis.
127.0.0.1:6379> AUTH Your_Redis_Password
OK
Effettua il ping del servizio.
127.0.0.1:6379> ping
PONG
Esci dal servizio digitando exit
.
Passaggio 10: scarica Magento
Crea una directory root web per Magento.
$ sudo mkdir /var/www/html/magento -p
Concedere i diritti sulla directory Magento all'utente corrente.
$ sudo chown $USER:$USER /var/www/html/magento/ -R
Prima di procedere oltre, è necessario autenticare le chiavi richieste dal repository Magento. Visita il sito web https://commercemarketplace.adobe.com/
, fai clic sul collegamento Accedi in alto a destra e otterrai la seguente pagina che ti chiede di accedere utilizzando il tuo ID Adobe.
Fai clic sul pulsante Accedi con Adobe ID per accedere alla pagina seguente.
Se disponi di un Adobe ID, inserisci le tue credenziali per continua oppure puoi creare un account qui. Dopo aver creato il tuo account ed effettuato l'accesso, apri l'URL https://commercemarketplace.adobe.com/customer/accessKeys/
. Puoi anche accedere a questa pagina visitando il tuo profilo (https://commercemarketplace.adobe.com/customer/account/
) e facendo clic sul collegamento Chiavi di accesso.
Fai clic sul pulsante Crea una nuova chiave di accesso per creare la tua chiave di autenticazione. Dai un nome alla tua chiave per l'identificazione.
Annotare sia la chiave pubblica che quella privata per il passaggio successivo.
Crea il file ~/.config/composer/auth.json
e aprilo per la modifica.
$ nano ~/.config/composer/auth.json
Incolla il seguente codice al suo interno. Utilizzare la chiave pubblica per il nome utente e la chiave privata per la password.
{
"http-basic": {
"repo.magento.com": {
"username": "<public_key>",
"password": "<private_key>"
}
}
}
Salva il file premendo Ctrl + X e inserendo Y quando richiesto.
Passa alla directory /var/www/html/magento
.
$ cd /var/www/html/magento
Crea il progetto Magento. Nota il punto
alla fine del comando. Si riferisce alla directory corrente in cui viene eseguito il comando.
$ composer create-project --repository-url=https://repo.magento.com/ magento/project-community-edition .
Dovresti vedere un output simile.
Creating a "magento/project-community-edition" project at "./"
Installing magento/project-community-edition (2.4.6-p3)
- Downloading magento/project-community-edition (2.4.6-p3)
- Installing magento/project-community-edition (2.4.6-p3): Extracting archive
Created project in /var/www/html/magento/.
Loading composer repositories with package information
Info from https://repo.packagist.org: #StandWithUkraine
Updating dependencies
Lock file operations: 566 installs, 0 updates, 0 removals
- Locking 2tvenom/cborencode (1.0.2)
- Locking adobe-commerce/adobe-ims-metapackage (2.2.0)
- Locking allure-framework/allure-codeception (v2.3.0)
- Locking allure-framework/allure-php-commons (v2.3.1)
- Locking allure-framework/allure-phpunit (v2.1.0)
...............................................
Esegui i seguenti comandi per impostare i permessi del file e rendere eseguibile il binario Magento. Inoltre, imposta il proprietario della directory Magento sull'utente Nginx in modo che possa accedere al sito web.
$ sudo find var generated vendor pub/static pub/media app/etc -type f -exec chmod g+w {} +
$ sudo find var generated vendor pub/static pub/media app/etc -type d -exec chmod g+ws {} +
$ sudo chown -R :nginx .
$ sudo chmod u+x bin/magento
Passaggio 11: installare Magento
Assicurati di essere nella directory Magento.
$ cd /var/www/html/magento
Esegui il comando seguente per installare Magento.
$ bin/magento setup:install \
--base-url=http://magento.example.com \
--use-secure=1 \
--base-url-secure=https://magento.example.com \
--use-secure-admin=1 \
--db-host=127.0.0.1 \
--db-name=magento \
--db-user=magentouser \
--db-password=Your_password2 \
--admin-firstname=Navjot \
--admin-lastname=Singh \
[email \
--admin-user=navjot \
--admin-password=admin_password \
--language=en_US \
--currency=USD \
--timezone=America/Chicago \
--use-rewrites=1 \
--elasticsearch-host=http://127.0.0.1 \
--elasticsearch-port=9200 \
--session-save=redis \
--session-save-redis-db=0 \
--session-save-redis-password=redis_password \
--cache-backend=redis \
--cache-backend-redis-db=2 \
--cache-backend-redis-password=redis_password \
--page-cache=redis \
--page-cache-redis-db=4 \
--page-cache-redis-password=redis_password
Una volta completato il processo, otterrai un output simile.
.......
[SUCCESS]: Magento installation complete.
[SUCCESS]: Magento Admin URI: /admin_l5pv1h
Nothing to import.
Annota l'URI di amministrazione di cui avrai bisogno in seguito per accedere al pannello di amministrazione.
Crea lavori cron Magento.
$ php bin/magento cron:install
Verifica il lavoro cron.
$ crontab -l
Dovresti vedere il seguente output.
#~ MAGENTO START f37deed947b2ea951ad6f939b8ab752bc79587e3d77f40d06f20f0657c98e94d
* * * * * /usr/bin/php /var/www/html/magento/bin/magento cron:run 2>&1 | grep -v "Ran jobs by schedule" >> /var/www/html/magento/var/log/magento.cron.log
#~ MAGENTO END f37deed947b2ea951ad6f939b8ab752bc79587e3d77f40d06f20f0657c98e94d
Passaggio 12: configurare PHP-FPM
Apri il file /etc/php-fpm.d/www.conf
.
$ sudo nano /etc/php-fpm.d/www.conf
Dobbiamo impostare l'utente/gruppo Unix dei processi PHP su nginx. Trova le righe user=apache
e group=apache
nel file e modificale in nginx
.
...
; Unix user/group of processes
; Note: The user is mandatory. If the group is not set, the default user's group
; will be used.
; RPM: apache user chosen to provide access to the same directories as httpd
user = nginx
; RPM: Keep a group allowed to write in log dir.
group = nginx
...
Trova le righe listen.owner=nessuno
, listen.group=nessuno
, listen.mode=0660
nel file e modificale come segue dopo decommentandoli.
; Set permissions for unix socket, if one is used. In Linux, read/write
; permissions must be set in order to allow connections from a web server.
; Default Values: user and group are set as the running user
; mode is set to 0660
listen.owner = nginx
listen.group = nginx
listen.mode = 0660
Salva il file premendo Ctrl + X e inserendo Y quando richiesto.
Aumentare il tempo di esecuzione a 180 secondi.
$ sudo sed -i 's/max_execution_time = 30/max_execution_time = 180/' /etc/php.ini
Aumenta il limite di memoria per PHP-FPM da 128 MB a 512 MB. Puoi aumentare il limite in base alle dimensioni e ai requisiti del tuo server.
$ sudo sed -i 's/memory_limit = 128M/memory_limit = 512M/' /etc/php.ini
Magento per impostazione predefinita imposta il limite della dimensione del file per il catalogo multimediale su 2 MB. Esegui i seguenti comandi per aumentare il limite della dimensione del file a 25 MB.
$ sudo sed -i 's/upload_max_filesize = 2M/upload_max_filesize = 25M/g' /etc/php.ini
$ sudo sed -i 's/post_max_size = 8M/post_max_size = 25M/g' /etc/php.ini
Attiva la compressione Zlib.
$ sudo sed -i 's/zlib.output_compression = Off/zlib.output_compression = On/g' /etc/php.ini
Aumenta la configurazione realpath_cache
come mostrato.
$ sudo sed -i 's/;realpath_cache_size = 4096k/realpath_cache_size = 10M/g' /etc/php.ini
$ sudo sed -i 's/;realpath_cache_ttl = 120/realpath_cache_ttl = 7200/g' /etc/php.ini
Apri il file /etc/php.d/10-opcache.ini
per modificarlo.
$ sudo nano /etc/php.d/10-opcache.ini
Trova la riga ;opcache.save_comments=1
e decommentala come mostrato.
opcache.save_comments=1
Salva il file premendo Ctrl + X e inserendo Y quando richiesto.
Riavviare il servizio PHP-FPM.
$ sudo systemctl restart php-fpm
Cambia il gruppo della directory delle sessioni PHP in Nginx.
$ sudo chgrp -R nginx /var/lib/php/session
Passaggio 13: configurare SELinux
Esegui i seguenti comandi per modificare il contesto di sicurezza per la directory Magento.
$ sudo semanage fcontext -a -t httpd_sys_rw_content_t '/var/www/html/magento/app/etc(/.*)?'
$ sudo semanage fcontext -a -t httpd_sys_rw_content_t '/var/www/html/magento/var(/.*)?'
$ sudo semanage fcontext -a -t httpd_sys_rw_content_t '/var/www/html/magento/pub/media(/.*)?'
$ sudo semanage fcontext -a -t httpd_sys_rw_content_t '/var/www/html/magento/pub/static(/.*)?'
$ sudo semanage fcontext -a -t httpd_sys_rw_content_t '/var/www/html/magento/generated(/.*)?'
$ sudo restorecon -Rv '/var/www/html/magento/'
Applicare la policy per consentire l'esecuzione di connessioni a host esterni.
$ sudo setsebool -P httpd_can_network_connect 1
Applica la policy per consentire a Nginx di concedere l'accesso a PostgreSQL.
$ sudo setsebool -P httpd_can_network_connect_db 1
Passaggio 14: configurare Nginx
Apri il file /etc/nginx/nginx.conf
per la modifica.
$ sudo nano /etc/nginx/nginx.conf
Aggiungi la seguente riga prima della riga include /etc/nginx/conf.d/*.conf;
.
server_names_hash_bucket_size 64;
Salva il file premendo Ctrl + X e inserendo Y quando richiesto.
Crea e apri il file /etc/nginx/conf.d/magento.conf
per la modifica.
$ sudo nano /etc/nginx/conf.d/magento.conf
Incolla il seguente codice al suo interno.
upstream fastcgi_backend {
server unix:/run/php-fpm/www.sock;
}
server {
# Redirect any http requests to https
listen 80;
listen [::]:80;
server_name magento.example.com;
return 301 https://$host$request_uri;
}
server {
listen 443 ssl http2;
listen [::]:443 ssl http2;
server_name magento.example.com;
set $MAGE_ROOT /var/www/html/magento;
include /var/www/html/magento/nginx.conf.sample;
client_max_body_size 25m;
access_log /var/log/nginx/magento.access.log;
error_log /var/log/nginx/magento.error.log;
# TLS configuration
ssl_certificate /etc/letsencrypt/live/magento.example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/magento.example.com/privkey.pem;
ssl_trusted_certificate /etc/letsencrypt/live/magento.example.com/chain.pem;
ssl_protocols TLSv1.2 TLSv1.3;
ssl_ciphers 'ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES256-SHA384:ECDHE-RSA-AES256-SHA384';
ssl_prefer_server_ciphers on;
ssl_session_cache shared:SSL:50m;
ssl_session_timeout 1d;
# OCSP Stapling ---
# fetch OCSP records from URL in ssl_certificate and cache them
ssl_stapling on;
ssl_stapling_verify on;
ssl_dhparam /etc/ssl/certs/dhparam.pem;
}
Salva il file premendo Ctrl + X e inserendo Y quando richiesto una volta terminato.
Magento viene fornito con un modello di configurazione Nginx su /var/www/magento/nginx.conf.sample
che abbiamo incluso nella nostra configurazione. La variabile $MAGE_ROOT
punta alla directory web root di Magento che abbiamo impostato nel nostro file e viene utilizzata nel file di configurazione di esempio.
Verifica la sintassi del file di configurazione Nginx.
$ sudo nginx -t
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful
Riavvia il servizio Nginx.
$ sudo systemctl restart nginx
Apri il sito web Magento tramite l'URL https://magento.example.com
. Dovresti vedere la pagina seguente.
Se CSS e JS non vengono caricati, esegui i seguenti comandi.
$ cd /var/www/html/magento
$ sudo php bin/magento setup:static-content:deploy -f
$ sudo php bin/magento indexer:reindex
Passaggio 15: disattivare l'autenticazione a due fattori
Prima di accedere al pannello di amministrazione dobbiamo disattivare l'autenticazione a due fattori abilitata di default. Magento tenta di inviare posta tramite sendmail
per abilitare l'autenticazione a due fattori durante l'installazione ma poiché non l'abbiamo configurato, l'unico modo per accedere alla dashboard è prima disabilitare la funzionalità.
Se hai sendmail
configurato sul tuo server per inviare email, puoi saltare questo passaggio. Dobbiamo disabilitare due dei moduli di Magento utilizzando i seguenti comandi per disabilitare l'autenticazione a due fattori.
$ sudo php /var/www/html/magento/bin/magento module:disable Magento_AdminAdobeImsTwoFactorAuth
$ sudo php /var/www/html/magento/bin/magento module:disable Magento_TwoFactorAuth
Eseguire il comando seguente per creare le classi.
$ sudo php /var/www/html/magento/bin/magento setup:di:compile
Pulisci anche la cache.
$ sudo php /var/www/html/magento/bin/magento c:c
Passaggio 16: accedere al portale di amministrazione
Devi aprire il portale di amministrazione utilizzando l'URI fornito dallo script di installazione di Magento. Se in qualche modo hai dimenticato di annotarlo o lo hai perso, puoi recuperare nuovamente l'URI utilizzando il seguente comando.
$ php /var/www/magento/bin/magento info:adminuri
Admin URI: /admin_l5pv1h
Apri l'URL https://magento.example.com/admin_l5pv1h
nel tuo browser e otterrai la seguente schermata.
Inserisci le credenziali di amministratore fornite durante l'installazione e fai clic sul pulsante Accedi per procedere. Verrai accolto con la seguente schermata.
Verrà visualizzato un popup che richiede l'autorizzazione ad Adobe per raccogliere i dati di utilizzo. Fai clic sul pulsante Non consentire per procedere.
Il passaggio successivo è configurare SMTP per le e-mail in modo da poter riattivare l'autenticazione a due fattori. Visita il menu Negozi >> Configurazione.
Espandi il Menu Avanzato dal lato sinistro e fai clic sull'opzione Sistemi per aprire la pagina delle impostazioni email.
Deseleziona Utilizza valore di sistema prima delle opzioni Trasporto, Host e Porta. Fai clic sul menu a discesa Trasporto e seleziona SMTP. Per il nostro tutorial, utilizziamo Amazon SES come mailer.
Inserisci il tuo host SMTP, 587 come porta, nome utente e password, imposta Auth su LOGIN e imposta SSL su TLS< nei campi indicati. Al termine, fai clic sul pulsante Salva configurazione. Ora che abbiamo configurato le impostazioni e-mail, il passaggio successivo è configurare gli ID e-mail del negozio in modo da poterli testare.
Scorri verso l'alto, espandi il menu Generale nella stessa pagina e seleziona l'opzione Memorizza indirizzi email.
Deseleziona i campi Email mittente predefiniti e inserisci gli ID email del tuo negozio. Al termine, fai clic sul pulsante Salva configurazione. Allo stesso modo, apri la schermata Contatti, apporta le stesse modifiche e fai clic sul pulsante Salva configurazione per terminare.
La modifica delle opzioni dell'amministratore può influire sulla cache e riceverai un avviso. Eseguire il comando seguente per svuotare manualmente la cache.
$ sudo php /var/www/html/magento/bin/magento c:c
Per testare le email, visita la pagina del negozio e apri la pagina Contattaci
. Puoi utilizzare direttamente l'URL https://magento.example.com/contact/
per accedervi. Invia un messaggio di prova e fai clic sul pulsante Invia. Dovresti ricevere una mail simile.
Passaggio 17: abilitare e configurare l'autenticazione a due fattori
Ora che abbiamo abilitato il mailer SMTP, è il momento di riabilitare l'autenticazione a due fattori. Esegui i seguenti comandi per abilitare l'autenticazione a due fattori.
$ sudo php /var/www/html/magento/bin/magento module:enable Magento_AdminAdobeImsTwoFactorAuth
$ sudo php /var/www/html/magento/bin/magento module:enable Magento_TwoFactorAuth
Aggiorna la configurazione dei moduli.
$ sudo php /var/www/html/magento/bin/magento setup:upgrade
Eseguire il comando seguente per creare le classi.
$ sudo php /var/www/html/magento/bin/magento setup:di:compile
Pulisci anche la cache.
$ sudo php /var/www/html/magento/bin/magento c:c
Se non riesci ad accedere all'area di amministrazione, esegui anche i seguenti comandi.
Forza la distribuzione del contenuto statico.
$ sudo php /var/www/html/magento/bin/magento setup:static-content:Deploy -f
Imposta i permessi del file.
$ cd /var/www/html/magento
$ sudo find var generated vendor pub/static pub/media app/etc -type f -exec chmod g+w {} +
$ sudo find var generated vendor pub/static pub/media app/etc -type d -exec chmod g+ws {} +
$ sudo chown -R :nginx .
Visita il portale di amministrazione e otterrai la seguente schermata.
Utilizzeremo il metodo Google Authenticator. Puoi utilizzare una chiave hardware se ne hai una. Il metodo Google Authenticator funziona con qualsiasi app TOTP tra cui Authy, 1Password, Bitwarden, Microsoft Authenticator, ecc. Fai clic sul pulsante Applica per procedere.
Nella pagina successiva riceverai il codice QR da scansionare con la tua app 2FA. Inserisci i dettagli nella tua app e copia il codice generato nel campo Codice autenticatore. Fai clic sul pulsante Conferma per procedere alla dashboard di amministrazione.
Conclusione
Questo conclude il nostro tutorial sull'installazione di un sito di eCommerce Magento su un server Rocky Linux 9 con un server Nginx ed Elasticsearch. Se avete domande, pubblicatele nei commenti qui sotto.