Wie man die Magento eCommerce Suite auf Rocky Linux 9 mit Elasticsearch installiert
Magento ist eine Open-Source-E-Commerce-Plattform, die in PHP geschrieben wurde. Sie wurde 2018 von Adobe übernommen. Sie wird auch als kommerzielles und cloudbasiertes Produkt angeboten. Mit Magento kannst du professionelle Shopping-Websites mit hoher Kapazität erstellen. Es bietet sowohl einen Single-Store- als auch einen Multiple-Store-Modus. Es wird mit vielen Modulen geliefert, mit denen du seine Funktionen erweitern kannst.
In diesem Lernprogramm werden wir die Open-Source-Community-Edition von Magento installieren. Sie bietet alle Funktionen, die du für die Einrichtung eines professionellen Online-Shops brauchst. Außerdem installieren wir Elasticsearch, um den Produktkatalog zu durchsuchen, Redis für den Sitzungs- und Dateicache und nutzen den Nginx-Server.
Voraussetzungen
- Ein Server mit Rocky Linux 9 und mindestens 2 GB RAM. Je nach deinen Anforderungen benötigst du eventuell mehr RAM.
- Ein Nicht-Root-Benutzer mit sudo-Rechten.
- Ein vollständig qualifizierter Domainname (FQDN) für den Server,
magento.example.com - Stelle sicher, dass alles auf dem neuesten Stand ist.
$ sudo dnf update
- Einige wenige Pakete, die dein System benötigt.
$ sudo dnf install wget curl nano unzip yum-utils policycoreutils-python-utils -y
Einige dieser Pakete sind vielleicht schon auf deinem System installiert.
Schritt 1 – Firewall konfigurieren
Der erste Schritt besteht darin, die Firewall zu konfigurieren. Rocky Linux verwendet die Firewalld Firewall. Überprüfe den Status der Firewall.
$ sudo firewall-cmd --state running
Die Firewall arbeitet mit verschiedenen Zonen, wobei die öffentliche Zone die Standardzone ist, die wir verwenden werden. Liste alle Dienste und Ports auf, die auf der Firewall aktiv sind.
$ sudo firewall-cmd --permanent --list-services
Es sollte die folgende Ausgabe angezeigt werden.
cockpit dhcpv6-client ssh
Lasse HTTP- und HTTPS-Ports zu.
$ sudo firewall-cmd --permanent --add-service=http $ sudo firewall-cmd --permanent --add-service=https
Überprüfe erneut den Status der Firewall.
$ sudo firewall-cmd --permanent --list-services
Du solltest eine ähnliche Ausgabe sehen.
cockpit dhcpv6-client http https ssh
Lade die Firewall neu, um die Änderungen zu aktivieren.
$ sudo firewall-cmd --reload
Schritt 2 – Installiere PHP und seine Erweiterungen
Rocky Linux 9 wird standardmäßig mit PHP 8.1 ausgeliefert. Um immer die neueste Version von PHP zu haben oder wenn du mehrere PHP-Versionen installieren möchtest, müssen wir das REMI-Repository verwenden.
Der erste Schritt besteht darin, das Epel-Repository zu holen.
$ sudo dnf install epel-release -y
Als nächstes installierst du das Remi-Repository.
$ sudo dnf install https://rpms.remirepo.net/enterprise/remi-release-9.rpm
Prüfe, ob PHP-Streams verfügbar sind.
$ 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
Die Standardversion ist 8.1. Zum Zeitpunkt der Erstellung dieses Tutorials ist Magento mit PHP 8.2 kompatibel. Aktiviere daher das PHP 8.2 Repository von Remi.
$ sudo dnf module reset php -y $ sudo dnf module enable php:remi-8.2
Du kannst es und die von Magento benötigten Erweiterungen installieren, indem du den folgenden Befehl ausführst.
$ 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
Überprüfe die Installation.
$ 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
Schritt 3 – Installiere Composer
Composer ist ein Abhängigkeitsmanagement-Tool für PHP und wird für die Installation von Magento benötigt.
Führe die folgenden Befehle aus, um die Composer-Binärdatei herunterzuladen. Magento benötigt Composer 2.2 LTS, daher haben wir den Befehl entsprechend angepasst.
$ php -r "copy('https://getcomposer.org/installer', 'composer-setup.php');"
$ php composer-setup.php --2.2
$ php -r "unlink('composer-setup.php');"
Installiere Composer, indem du das Binary in das Verzeichnis /usr/local/bin verschiebst.
$ sudo mv composer.phar /usr/local/bin/composer
Überprüfe die Installation, indem du die Version überprüfst.
$ composer --version Composer version 2.2.22 2023-09-29 10:53:45
Schritt 4 – MariaDB installieren
Rocky Linux 9 wird mit einer älteren Version von MariaDB ausgeliefert. Daher werden wir für die Installation das MariaDB-Repository verwenden. Zum Zeitpunkt der Erstellung dieses Tutorials unterstützt Magento MariaDB 10.6, das wir installieren werden.
Importiere den GPG-Schlüssel von MariaDB.
$ sudo rpm --import https://supplychain.mariadb.com/MariaDB-Server-GPG-KEY
Erstelle und öffne die Datei /etc/yum.repos.d/mariadb.repo zum Bearbeiten.
$ sudo nano /etc/yum.repos.d/mariadb.repo
Füge den folgenden Code in die Datei ein.
[mariadb] name = MariaDB baseurl = https://rpm.mariadb.org/10.6/rhel/$releasever/$basearch gpgkey= https://rpm.mariadb.org/RPM-GPG-KEY-MariaDB gpgcheck=1
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
$ sudo dnf install MariaDB-server
Überprüfe die Version von MySQL.
$ mysql --version mysql Ver 15.1 Distrib 10.6.16-MariaDB, for Linux (x86_64) using EditLine wrapper
Aktiviere und starte den MariaDB-Dienst.
$ sudo systemctl enable mariadb --now
Führe das Skript zur sicheren Installation von MariaDB aus.
$ sudo mariadb-secure-installation
Du wirst nach dem Root-Passwort gefragt. Drücke die Eingabetaste, denn wir haben kein Passwort dafür festgelegt.
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):
Als Nächstes wirst du gefragt, ob du zur Unix-Socket-Authentifizierungsmethode wechseln möchtest. Mit dem unix_socket Plugin kannst du deine Betriebssystem-Zugangsdaten verwenden, um dich mit dem MariaDB-Server zu verbinden. Da du bereits ein geschütztes Root-Konto hast, gibst du n ein, um fortzufahren.
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
Als nächstes wirst du gefragt, ob du dein Root-Passwort ändern möchtest. Gib Y ein, um fortzufahren und dein Root-Passwort in ein starkes und sicheres Passwort zu ändern.
... 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!
Als Nächstes werden dir einige Fragen gestellt, um die Sicherheit von MariaDB zu erhöhen. Gib Y ein, um anonyme Benutzer zu entfernen, Remote-Root-Logins zu verbieten, die Testdatenbank zu entfernen und die Berechtigungstabellen neu zu laden.
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!
Du kannst die MariaDB-Shell aufrufen, indem du sudo mysql oder sudo mariadb in die Befehlszeile eingibst.
Schritt 5 – MariaDB konfigurieren
Melde dich in der MariaDB-Shell an.
$ sudo mariadb
Erstelle eine Datenbank für Magento.
MariaDB > CREATE DATABASE magento;
Erstelle ein SQL-Benutzerkonto.
MariaDB > CREATE USER 'magentouser'@'localhost' IDENTIFIED BY 'Your_password2';
Erteile dem Benutzer alle Rechte für die Datenbank.
MariaDB > GRANT ALL PRIVILEGES ON magento.* TO 'magentouser'@'localhost';
Lösche die Benutzerrechte.
MariaDB > FLUSH PRIVILEGES;
Beende die Shell.
MariaDB > exit
Schritt 6 – Nginx installieren
Rocky Linux 9 wird mit einer älteren Version von Nginx ausgeliefert. Du musst das offizielle Nginx-Repository verwenden, um die neueste Version zu installieren.
Erstelle und öffne die Datei /etc/yum.repos.d/nginx.repo zum Bearbeiten.
$ sudo nano /etc/yum.repos.d/nginx.repo
Füge den folgenden Code in die Datei ein.
[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
Wenn du fertig bist, speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Wir werden Nginx Mainline installieren, also aktiviere das Paket für Nginx.
$ sudo dnf config-manager --enable nginx-mainline
Installiere Nginx.
$ sudo dnf install nginx -y
Überprüfe die Installation.
$ nginx -v nginx version: nginx/1.25.3
Aktiviere und starte den Nginx-Serverdienst.
$ sudo systemctl enable nginx --now
Überprüfe den Status des Dienstes.
? 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"
Schritt 7 – SSL installieren
Wir müssen Certbot installieren, um das SSL-Zertifikat zu erstellen. Dazu verwenden wir den Snapd-Paketinstaller. Da Rocky Linux nicht mit diesem Paket ausgeliefert wird, installierst du den Snapd-Installer. Er benötigt das EPEL (Extra Packages for Enterprise Linux) Repository, um zu funktionieren. Da wir es aber bereits in Schritt 3 installiert haben, können wir direkt fortfahren.
Installiere das Snapd-Paket.
$ sudo dnf install -y snapd
Aktiviere und starte den Snap-Dienst.
$ sudo systemctl enable snapd --now
Installiere das Snap-Kernpaket und vergewissere dich, dass deine Version von Snapd auf dem neuesten Stand ist.
$ sudo snap install core && sudo snap refresh core
Erstelle die notwendigen Links, damit Snapd funktioniert.
$ 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
Installiere Certbot.
$ sudo snap install --classic certbot
Stelle mit dem folgenden Befehl sicher, dass der Certbot-Befehl ausgeführt werden kann, indem du einen symbolischen Link auf das Verzeichnis /usr/bin erstellst.
$ sudo ln -s /snap/bin/certbot /usr/bin/certbot
Überprüfe, ob Certbot richtig funktioniert.
$ certbot --version certbot 2.8.0
Führe den folgenden Befehl aus, um ein SSL-Zertifikat zu erzeugen.
$ sudo certbot certonly --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m name@example.com -d magento.example.com
Mit dem obigen Befehl wird ein Zertifikat in das Verzeichnis /etc/letsencrypt/live/magento.example.com auf deinem Server heruntergeladen.
Erstelle ein Diffie-Hellman-Gruppenzertifikat.
$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096
Überprüfe den Certbot-Erneuerungszeitplanungsdienst.
$ sudo systemctl list-timers
Du findest snap.certbot.renew.service als einen der Dienste, die für die Ausführung vorgesehen sind.
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
Führe einen Probelauf des Prozesses durch, um zu prüfen, ob die SSL-Erneuerung einwandfrei funktioniert.
$ sudo certbot renew --dry-run
Wenn du keine Fehler siehst, bist du bereit. Dein Zertifikat wird automatisch erneuert.
Schritt 8 – Installiere Elasticsearch
Elasticsearch wird von Magento für die Produktsuche verwendet. Wir werden Elasticsearch 7.x aus dem offiziellen Repository installieren, da diese Version mit Magento 2.4.6, der neuesten Version, kompatibel ist. Auf der Anforderungsseite wird auch Elasticsearch 8.5 erwähnt, aber es funktioniert nicht richtig mit Magento.
Importiere den GPG-Schlüssel von Elasticsearch.
$ sudo rpm --import https://artifacts.elastic.co/GPG-KEY-elasticsearch
Erstelle eine Datei namens elasticsearch.repo im Verzeichnis /etc/yum.repos.d/ und öffne sie zur Bearbeitung.
$ sudo nano /etc/yum.repos.d/elasticsearch.repo
Füge den folgenden Code in die Datei ein.
[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
Wenn du fertig bist, speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Installiere Elasticsearch.
$ sudo dnf install --enablerepo=elasticsearch elasticsearch
Elasticsearch verbraucht viel Speicherplatz. Du musst seine Nutzung je nach Größe deines Servers einschränken. Erstelle die Datei /etc/elasticsearch/jvm.options.d/memory.options und öffne sie zur Bearbeitung.
$ sudo nano /etc/elasticsearch/jvm.options.d/memory.options
Füge den folgenden Code darin ein. Ändere die Werte entsprechend der Größe deines Servers. Der erste Wert bezieht sich auf den Anfangsspeicher und der zweite auf den maximal verfügbaren Speicher. Für 1 GB und mehr, verwende das Format -Xms1g.
-Xms512m -Xmx784m
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst. Dadurch wird Elasticsearch so konfiguriert, dass es 1 GB RAM verwendet. Ändere sie entsprechend deinen Anforderungen und Serverspezifikationen ab.
Starte und aktiviere den Dienst.
$ sudo systemctl enable elasticsearch --now
Überprüfe, ob Elasticsearch funktioniert.
$ curl http://localhost:9200
Du solltest die folgende Ausgabe sehen.
{
"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"
}
Schritt 9 – Installiere den Redis-Server
Magento verwendet Redis für die Sitzungs- und Cache-Speicherung. Es ist völlig optional und du kannst auch die Datenbank für die Sitzungsspeicherung verwenden. Aber Redis macht einen besseren Job. Die neueste Version von Magento arbeitet mit Redis 7.0. Rocky Linux wird mit Redis 6.0 ausgeliefert, also werden wir das Remi-Repository für die Installation verwenden.
Wir haben das Remi-Repository bereits installiert, als wir in Schritt 2 PHP installiert haben. Liste alle verfügbaren Redis-Module auf.
$ 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
Aktiviere Redis 7.0.
$ sudo dnf module enable -y redis:remi-7.0
Gib den folgenden Befehl ein, um den Redis-Server zu installieren.
$ sudo dnf install redis
Bestätige die Redis-Version.
$ redis-server -v Redis server v=7.0.15 sha=00000000:0 malloc=jemalloc-5.2.1 bits=64 build=77c9855172eb54e9
Aktiviere und starte den Redis-Dienst.
$ sudo systemctl enable redis --now
Überprüfe die Verbindung des Dienstes mit dem folgenden Befehl.
$ redis-cli
Du wirst auf die Redis-Shell umgeschaltet.
Der erste Schritt besteht darin, das Passwort für den Redis-Standardbenutzer festzulegen. Ersetze Your_Redis_Password durch ein sicheres Passwort deiner Wahl. Achte darauf, dass du dem Passwort das Zeichen > voranstellst.
127.0.0.1:6379> acl setuser default >Your_Redis_Password
Teste die Redis-Authentifizierung.
127.0.0.1:6379> AUTH Your_Redis_Password OK
Pinge den Dienst an.
127.0.0.1:6379> ping PONG
Beende den Dienst, indem du exit eingibst.
Schritt 10 – Magento herunterladen
Erstelle ein Web-Root-Verzeichnis für Magento.
$ sudo mkdir /var/www/html/magento -p
Gib dem aktuellen Benutzer die Rechte für das Magento-Verzeichnis.
$ sudo chown $USER:$USER /var/www/html/magento/ -R
Bevor wir weitermachen, brauchst du die Authentifizierungsschlüssel, die für das Magento-Repository erforderlich sind. Besuche die Website https://commercemarketplace.adobe.com/, klicke oben rechts auf den Link Anmelden und du wirst auf der folgenden Seite aufgefordert, dich mit deiner Adobe ID anzumelden.
Klicke auf die Schaltfläche Mit Adobe ID anmelden, um auf die folgende Seite zu gelangen.
Wenn du eine Adobe ID hast, gib deine Anmeldedaten ein, um fortzufahren, oder du kannst hier ein Konto erstellen. Sobald du dein Konto erstellt und dich eingeloggt hast, öffne die URL https://commercemarketplace.adobe.com/customer/accessKeys/. Du kannst diese Seite auch aufrufen, indem du dein Profil ( https://commercemarketplace.adobe.com/customer/account/) aufrufst und auf den Link Zugangsschlüssel klickst.
Klicke auf die Schaltfläche Einen neuen Zugangsschlüssel erstellen, um deinen Authentifizierungsschlüssel zu erstellen. Gib deinem Schlüssel einen Namen zur Identifizierung.
Notiere dir sowohl den öffentlichen als auch den privaten Schlüssel für den nächsten Schritt.
Erstelle die Datei ~/.config/composer/auth.json und öffne sie zur Bearbeitung.
$ nano ~/.config/composer/auth.json
Füge den folgenden Code in die Datei ein. Verwende den öffentlichen Schlüssel für den Benutzernamen und den privaten Schlüssel für das Passwort.
{
"http-basic": {
"repo.magento.com": {
"username": "<public_key>",
"password": "<private_key>"
}
}
}
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Wechsle in das Verzeichnis /var/www/html/magento.
$ cd /var/www/html/magento
Erstelle das Magento-Projekt. Beachte das period am Ende des Befehls. Es verweist auf das aktuelle Verzeichnis, in dem der Befehl ausgeführt wird.
$ composer create-project --repository-url=https://repo.magento.com/ magento/project-community-edition .
Du solltest eine ähnliche Ausgabe sehen.
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) ...............................................
Führe die folgenden Befehle aus, um die Dateiberechtigungen zu setzen und Magento binär ausführbar zu machen. Setze außerdem den Besitzer des Magento-Verzeichnisses auf den Nginx-Benutzer, damit dieser auf die Website zugreifen kann.
$ 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
Schritt 11 – Magento installieren
Vergewissere dich, dass du dich im Magento-Verzeichnis befindest.
$ cd /var/www/html/magento
Führe den folgenden Befehl aus, um Magento zu installieren.
$ 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 \ --admin-email=navjot@example.com \ --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
Sobald der Vorgang abgeschlossen ist, erhältst du eine ähnliche Ausgabe.
....... [SUCCESS]: Magento installation complete. [SUCCESS]: Magento Admin URI: /admin_l5pv1h Nothing to import.
Notiere dir die Admin URI, die du später für den Zugriff auf das Administrationspanel benötigst.
Erstelle Magento Cron-Jobs.
$ php bin/magento cron:install
Überprüfe den Cron-Job.
$ crontab -l
Du solltest die folgende Ausgabe sehen.
#~ 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
Schritt 12 – PHP-FPM konfigurieren
Öffne die Datei /etc/php-fpm.d/www.conf.
$ sudo nano /etc/php-fpm.d/www.conf
Wir müssen den Unix-Benutzer/die Unix-Gruppe der PHP-Prozesse auf nginx setzen. Finde die Zeilen user = apache und group = apache in der Datei und ändere sie 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 ...
Finde die Zeilen listen.owner = nobody, listen.group = nobody, listen.mode = 0660 in der Datei und ändere sie wie folgt, nachdem du sie auskommentiert hast.
; 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
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Erhöhe die Ausführungszeit auf 180 Sekunden.
$ sudo sed -i 's/max_execution_time = 30/max_execution_time = 180/' /etc/php.ini
Erhöhe das Speicherlimit für PHP-FPM von 128 MB auf 512 MB. Du kannst das Limit je nach Größe deines Servers und deinen Anforderungen erhöhen.
$ sudo sed -i 's/memory_limit = 128M/memory_limit = 512M/' /etc/php.ini
Magento setzt das Dateigrößenlimit für die Medienbibliothek standardmäßig auf 2 MB. Führe die folgenden Befehle aus, um die Dateigrößenbegrenzung auf 25 MB zu erhöhen.
$ 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
Schalte die Zlib-Komprimierung ein.
$ sudo sed -i 's/zlib.output_compression = Off/zlib.output_compression = On/g' /etc/php.ini
Erhöhe die Konfiguration von realpath_cache wie gezeigt.
$ 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
Öffne die Datei /etc/php.d/10-opcache.ini zum Bearbeiten.
$ sudo nano /etc/php.d/10-opcache.ini
Finde die Zeile ;opcache.save_comments=1 und entkommentiere sie wie abgebildet.
opcache.save_comments=1
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Starte den PHP-FPM-Dienst neu.
$ sudo systemctl restart php-fpm
Ändere die Gruppe des PHP-Sessions-Verzeichnisses auf Nginx.
$ sudo chgrp -R nginx /var/lib/php/session
Schritt 13 – SELinux konfigurieren
Führe die folgenden Befehle aus, um den Sicherheitskontext für das Magento-Verzeichnis zu ändern.
$ 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/'
Wende die Richtlinie an, um Verbindungen zu externen Hosts zuzulassen.
$ sudo setsebool -P httpd_can_network_connect 1
Wende die Richtlinie an, um Nginx den Zugriff auf PostgreSQL zu erlauben.
$ sudo setsebool -P httpd_can_network_connect_db 1
Schritt 14 – Nginx konfigurieren
Öffne die Datei /etc/nginx/nginx.conf zum Bearbeiten.
$ sudo nano /etc/nginx/nginx.conf
Füge die folgende Zeile vor der Zeile include /etc/nginx/conf.d/*.conf; ein.
server_names_hash_bucket_size 64;
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Erstelle und öffne die Datei /etc/nginx/conf.d/magento.conf zum Bearbeiten.
$ sudo nano /etc/nginx/conf.d/magento.conf
Füge den folgenden Code in die Datei ein.
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;
}
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Magento wird mit einer Nginx-Konfigurationsvorlage unter /var/www/magento/nginx.conf.sample geliefert, die wir in unsere Konfiguration aufgenommen haben. Die Variable $MAGE_ROOT verweist auf das Magento-Web-Root-Verzeichnis, das wir in unserer Datei festgelegt haben und das in der Beispielkonfigurationsdatei verwendet wird.
Überprüfe die Syntax der Nginx-Konfigurationsdatei.
$ sudo nginx -t nginx: the configuration file /etc/nginx/nginx.conf syntax is ok nginx: configuration file /etc/nginx/nginx.conf test is successful
Starte den Nginx-Dienst neu.
$ sudo systemctl restart nginx
Öffne die Magento-Website über die URL https://magento.example.com. Du solltest die folgende Seite sehen.
Wenn CSS und JS nicht geladen werden, führe die folgenden Befehle aus.
$ cd /var/www/html/magento $ sudo php bin/magento setup:static-content:deploy -f $ sudo php bin/magento indexer:reindex
Schritt 15 – Deaktiviere die Zwei-Faktor-Authentifizierung
Bevor wir auf das Administrationspanel zugreifen, müssen wir die standardmäßig aktivierte Zwei-Faktor-Authentifizierung deaktivieren. Magento versucht, während der Installation eine E-Mail an sendmail zu senden, um die Zwei-Faktor-Authentifizierung zu aktivieren, aber da wir das nicht konfiguriert haben, ist die einzige Möglichkeit, auf das Dashboard zuzugreifen, die Deaktivierung dieser Funktion.
Wenn du sendmail auf deinem Server für den Versand von E-Mails konfiguriert hast, kannst du diesen Schritt überspringen. Wir müssen zwei Module von Magento mit den folgenden Befehlen deaktivieren, um die Zwei-Faktor-Authentifizierung zu deaktivieren.
$ sudo php /var/www/html/magento/bin/magento module:disable Magento_AdminAdobeImsTwoFactorAuth $ sudo php /var/www/html/magento/bin/magento module:disable Magento_TwoFactorAuth
Führe den folgenden Befehl aus, um die Klassen zu erstellen.
$ sudo php /var/www/html/magento/bin/magento setup:di:compile
Lösche auch den Cache.
$ sudo php /var/www/html/magento/bin/magento c:c
Schritt 16 – Zugriff auf das Administrationsportal
Du musst das Administrationsportal mit der URI öffnen, die dir das Magento-Installationsskript mitgeteilt hat. Wenn du sie vergessen oder verloren hast, kannst du die URI mit folgendem Befehl wiederherstellen.
$ php /var/www/magento/bin/magento info:adminuri Admin URI: /admin_l5pv1h
Öffne die URL https://magento.example.com/admin_l5pv1h in deinem Browser und du bekommst den folgenden Bildschirm.
Gib die Administrator-Anmeldedaten ein, die du bei der Installation angegeben hast, und klicke auf die Schaltfläche Anmelden, um fortzufahren. Du wirst mit dem folgenden Bildschirm begrüßt.
Du wirst in einem Pop-up-Fenster gefragt, ob Adobe Nutzungsdaten sammeln darf. Klicke auf die Schaltfläche Nicht zulassen, um fortzufahren.
Im nächsten Schritt musst du SMTP für E-Mails konfigurieren, damit wir die Zwei-Faktor-Authentifizierung wieder aktivieren können. Rufe das Menü Stores >> Konfiguration auf.
Erweitere das Menü Erweitert auf der linken Seite und klicke auf die Option Systeme, um die Seite E-Mail-Einstellungen zu öffnen.
Deaktiviere das Kontrollkästchen Systemwert verwenden vor den Optionen Transport, Host und, Port. Klicke auf das Dropdown-Menü für Transport und wähle SMTP. Für unser Tutorial verwenden wir Amazon SES als Mailer.
Gib deinen SMTP-Host, 587 als Port, deinen Benutzernamen und dein Kennwort ein, setze Auth auf LOGIN und SSL auf TLS in den entsprechenden Feldern. Klicke auf die Schaltfläche Save Config, wenn du fertig bist. Nachdem wir nun die E-Mail-Einstellungen konfiguriert haben, müssen wir als Nächstes die E-Mail-IDs der Filialen konfigurieren, damit wir sie testen können.
Scrolle nach oben, erweitere das Menü Allgemein auf derselben Seite und wähle die Option E-Mail-Adressen der Filiale.
Deaktiviere die Standardfelder für Absender-E-Mails und gib die E-Mail-IDs deines Geschäfts ein. Klicke auf die Schaltfläche Konfiguration speichern, wenn du fertig bist. Öffne auf ähnliche Weise den Bildschirm Kontakte, nimm die gleichen Änderungen vor und klicke zum Abschluss auf die Schaltfläche Konfiguration speichern.
Wenn du die Administratoroptionen änderst, kann sich das auf den Cache auswirken und du bekommst eine Warnung. Führe den folgenden Befehl aus, um den Cache manuell zu löschen.
$ sudo php /var/www/html/magento/bin/magento c:c
Um die E-Mails zu testen, rufe die Storefront-Seite auf und öffne die Seite Contact Us. Du kannst die URL https://magento.example.com/contact/ direkt verwenden, um sie aufzurufen. Sende eine Testnachricht und klicke auf die Schaltfläche Senden. Du solltest eine ähnliche E-Mail erhalten.
Schritt 17 – Aktiviere und konfiguriere die Zwei-Faktor-Authentifizierung
Nachdem wir nun den SMTP-Mailer aktiviert haben, ist es an der Zeit, die Zwei-Faktor-Authentifizierung wieder zu aktivieren. Führe die folgenden Befehle aus, um die Zwei-Faktor-Authentifizierung zu aktivieren.
$ sudo php /var/www/html/magento/bin/magento module:enable Magento_AdminAdobeImsTwoFactorAuth $ sudo php /var/www/html/magento/bin/magento module:enable Magento_TwoFactorAuth
Aktualisiere das Setup für die Module.
$ sudo php /var/www/html/magento/bin/magento setup:upgrade
Führe den folgenden Befehl aus, um die Klassen zu erstellen.
$ sudo php /var/www/html/magento/bin/magento setup:di:compile
Lösche auch den Cache.
$ sudo php /var/www/html/magento/bin/magento c:c
Wenn du nicht auf den Admin-Bereich zugreifen kannst, führe auch die folgenden Befehle aus.
Erzwinge die Bereitstellung der statischen Inhalte.
$ sudo php /var/www/html/magento/bin/magento setup:static-content:Deploy -f
Lege die Dateiberechtigungen fest.
$ 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 .
Besuche das Admin-Portal und du wirst den folgenden Bildschirm sehen.
Wir werden die Google Authenticator-Methode verwenden. Du kannst auch einen Hardware-Schlüssel verwenden, wenn du einen hast. Die Google Authenticator-Methode funktioniert mit jeder TOTP-App, einschließlich Authy, 1Password, Bitwarden, Microsoft Authenticator, usw. Klicke auf die Schaltfläche Übernehmen, um fortzufahren.
Auf der nächsten Seite erhältst du den QR-Code, den du mit deiner 2FA-App scannen musst. Gib die Daten in deine App ein und kopiere den generierten Code in das Feld Authenticator-Code. Klicke auf die Schaltfläche Bestätigen, um zum Admin-Dashboard zu gelangen.
Fazit
Damit ist unser Tutorial zur Installation einer Magento eCommerce Site auf einem Rocky Linux 9 Server mit einem Nginx Server und Elasticsearch abgeschlossen. Wenn du Fragen hast, schreibe sie unten in die Kommentare.