So installierst du die Magento eCommerce Suite auf Debian 12 mit Nginx und Elasticsearch

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 für die Suche im Produktkatalog, Redis für den Sitzungs- und Dateicache und nutzen den Nginx-Server.

Voraussetzungen

  • Ein Server mit Debian 12 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 apt update
    $ sudo apt upgrade
    
  • Einige wenige Pakete, die dein System benötigt.
    $ sudo apt install wget curl nano ufw software-properties-common dirmngr apt-transport-https gnupg2 ca-certificates lsb-release debian-archive-keyring unzip -y
    

    Einige dieser Pakete sind vielleicht schon auf deinem System installiert.

Schritt 1 – Firewall konfigurieren

Der erste Schritt besteht darin, die Firewall zu konfigurieren. Debian wird standardmäßig mit ufw (Uncomplicated Firewall) ausgeliefert.

Überprüfe, ob die Firewall aktiv ist.

$ sudo ufw status

Du solltest etwas wie das Folgende sehen.

Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere
OpenSSH (v6)               ALLOW       Anywhere (v6)

Lasse auch HTTP- und HTTPS-Ports zu.

$ sudo ufw allow http
$ sudo ufw allow https

Überprüfe den Status der Firewall erneut.

$ sudo ufw status

Du solltest eine ähnliche Ausgabe sehen.

Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere
80/tcp                     ALLOW       Anywhere
443                        ALLOW       Anywhere
OpenSSH (v6)               ALLOW       Anywhere (v6)
80/tcp (v6)                ALLOW       Anywhere (v6)
443 (v6)                   ALLOW       Anywhere (v6)

Schritt 2 – Installiere PHP und seine Erweiterungen

Debian 12 wird standardmäßig mit der Version PHP 8.2 ausgeliefert. Du kannst es und die von Magento benötigten Erweiterungen installieren, indem du den folgenden Befehl ausführst.

$ sudo apt 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-xsl libsodium-dev libsodium23 libssl-dev libcurl4-openssl-dev

Wenn du immer die neueste Version von PHP verwenden oder mehrere PHP-Versionen installieren möchtest, füge Ondrejs PHP-Repository hinzu.

Importiere zunächst den PHP-GPG-Schlüssel von Sury’s Repository.

$ sudo curl -sSLo /usr/share/keyrings/deb.sury.org-php.gpg https://packages.sury.org/php/apt.gpg

Füge das PHP-Repository von Ondrej Sury hinzu.

$ sudo sh -c 'echo "deb [signed-by=/usr/share/keyrings/deb.sury.org-php.gpg] https://packages.sury.org/php/ $(lsb_release -sc) main" > /etc/apt/sources.list.d/php.list'

Aktualisiere die Liste der System-Repositorys.

$ sudo apt update	

Als Nächstes installierst du PHP und die von Magento benötigten Erweiterungen.

$ sudo apt install php8.2-fpm php8.2-mysql php8.2-bcmath php8.2-xml php8.2-zip php8.2-curl php8.2-mbstring php8.2-gd php8.2-tidy php8.2-intl php8.2-cli php8.2-soap php8.2-xsl libsodium-dev libsodium23 libssl-dev libcurl4-openssl-dev

Überprüfe die Installation.

$ php --version
PHP 8.2.8 (cli) (built: Jul 16 2023 11:00:43) (NTS)
Copyright (c) The PHP Group
Zend Engine v4.2.8, Copyright (c) Zend Technologies
    with Zend OPcache v8.2.8, Copyright (c), by Zend Technologies

Schritt 3 – Installiere Composer

Composer ist ein Tool zur Verwaltung von Abhängigkeiten für PHP und wird für die Installation von Magento benötigt.

Führe die folgenden Befehle aus, um das Composer-Binary 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.21 2023-02-15 13:07:40

Schritt 4 – MariaDB installieren

Debian 12 wird standardmäßig nicht mit MySQL ausgeliefert und es wurde noch kein offizielles Paket dafür veröffentlicht. Deshalb werden wir MariaDB dafür verwenden. Auch für MariaDB gibt es kein offizielles Paket für Debian 12, aber es wird mit Debian ausgeliefert. Deshalb installierst du es mit dem folgenden Befehl.

$ sudo apt install mariadb-server

Überprüfe die Version von MySQL.

$ mysql --version
mysql  Ver 15.1 Distrib 10.11.3-MariaDB, for debian-linux-gnu (x86_64) using  EditLine wrapper

Diese Version von MariaDB wird von Magento nicht unterstützt und das offizielle MariaDB-Paket für Debian 12 ist derzeit nicht verfügbar. Wir werden also mit der Installation fortfahren und später einen Workaround verwenden, um die Beschränkung zu umgehen.

Führe das Skript für die sichere Installation von MariaDB aus.

$ sudo mysql_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 willst. 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. Unter Debian 12 ist das Root-Passwort eng mit der automatischen Systemwartung verknüpft, daher solltest du es nicht ändern. Gib n ein, um fortzufahren.

 ... skipping.

You already have your root account protected, so you can safely answer 'n'.

Change the root password? [Y/n] n

Als nächstes werden dir einige Fragen gestellt, um die Sicherheit von MariaDB zu verbessern. Gib Y ein, um anonyme Benutzer zu entfernen, Remote-Root-Logins zu verbieten, die Testdatenbank zu entfernen und die Berechtigungstabellen neu zu laden.

 ... skipping.

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 mysql

Erstelle eine Datenbank für Magento.

mysql> CREATE DATABASE magento;

Erstelle ein SQL-Benutzerkonto.

mysql> CREATE USER 'magentouser'@'localhost' IDENTIFIED BY 'Your_password2';

Erteile dem Benutzer alle Rechte für die Datenbank.

mysql> GRANT ALL PRIVILEGES ON magento.* TO 'magentouser'@'localhost';

Da wir den Root-Benutzer nicht ändern, solltest du einen weiteren SQL-Benutzer für die Durchführung von Verwaltungsaufgaben anlegen, die eine Passwortauthentifizierung erfordern. Wähle ein sicheres Passwort für diesen Benutzer.

MariaDB> GRANT ALL ON *.* TO 'navjot'@'localhost' IDENTIFIED BY 'Yourpassword32!' WITH GRANT OPTION;

Lösche die Benutzerrechte.

mysql> FLUSH PRIVILEGES;

Beende die Shell.

mysql> exit

Schritt 6 – Nginx installieren

Debian 12 wird mit einer älteren Version von Nginx ausgeliefert. Um die neueste Version zu installieren, musst du das offizielle Nginx-Repository herunterladen.

Importiere den Signierschlüssel von Nginx.

$ curl https://nginx.org/keys/nginx_signing.key | gpg --dearmor \
    | sudo tee /usr/share/keyrings/nginx-archive-keyring.gpg >/dev/null

Füge das Repository für die stabile Version von Nginx hinzu.

$ echo "deb [signed-by=/usr/share/keyrings/nginx-archive-keyring.gpg] \
http://nginx.org/packages/debian `lsb_release -cs` nginx" \
    | sudo tee /etc/apt/sources.list.d/nginx.list

Aktualisiere die System-Repositories.

$ sudo apt update

Installiere Nginx.

$ sudo apt install nginx

Überprüfe die Installation. Auf Debian-Systemen funktioniert der folgende Befehl nur mit sudo.

$ sudo nginx -v
nginx version: nginx/1.24.0

Starten Sie den Nginx-Server.

$ sudo systemctl start nginx

Überprüfe den Status des Dienstes.

? nginx.service - nginx - high performance web server
     Loaded: loaded (/lib/systemd/system/nginx.service; enabled; preset: enabled)
     Active: active (running) since Wed 2023-08-02 06:45:52 UTC; 14s ago
       Docs: https://nginx.org/en/docs/
    Process: 18326 ExecStart=/usr/sbin/nginx -c /etc/nginx/nginx.conf (code=exited, status=0/SUCCESS)
   Main PID: 18327 (nginx)
      Tasks: 2 (limit: 2315)
     Memory: 1.8M
        CPU: 11ms
     CGroup: /system.slice/nginx.service
             ??18327 "nginx: master process /usr/sbin/nginx -c /etc/nginx/nginx.conf"
             ??18328 "nginx: worker process"

Schritt 7 – SSL installieren

Wir müssen Certbot installieren, um das SSL-Zertifikat zu erstellen. Du kannst Certbot entweder über das Repository von Debian installieren oder die neueste Version mit dem Snapd-Tool herunterladen. Wir werden die Snapd-Version verwenden.

Bei Debian 12 ist Snapd noch nicht installiert. Installiere das Snapd-Paket.

$ sudo apt install snapd

Führe die folgenden Befehle aus, um sicherzustellen, dass deine Version von Snapd auf dem neuesten Stand ist.

$ sudo snap install core && sudo snap refresh core

Installiere Certbot.

$ sudo snap install --classic certbot

Verwende den folgenden Befehl, um sicherzustellen, dass der Certbot-Befehl ausgeführt werden kann, indem du einen symbolischen Link zum Verzeichnis /usr/bin erstellst.

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

Überprüfe, ob Certbot richtig funktioniert.

$ certbot --version
certbot 2.6.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
.....
Wed 2023-08-02 08:09:00 UTC 9h left       Wed 2023-08-02 07:39:06 UTC 2h 59min ago  snap.certbot.renew.timer  snap.certbot.renew.service
Thu 2023-08-03 06:41:11 UTC 9h left       Wed 2023-08-02 06:24:33 UTC 10h ago       apt-daily-upgrade.timer   apt-daily-upgrade.service
Wed 2023-08-02 14:06:00 UTC 11h left      Sun 2021-11-14 02:03:02 UTC 5min ago      apt-daily.timer           apt-daily.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 über das offizielle Repository installieren, da diese Version mit Magento kompatibel ist.

Importiere den GPG-Schlüssel von Elasticsearch.

$ wget -qO - https://artifacts.elastic.co/GPG-KEY-elasticsearch | sudo gpg --dearmor -o /usr/share/keyrings/elasticsearch-keyring.gpg

Füge das Elasticsearch-Repository hinzu.

$ echo "deb [signed-by=/usr/share/keyrings/elasticsearch-keyring.gpg] https://artifacts.elastic.co/packages/7.x/apt stable main" | sudo tee /etc/apt/sources.list.d/elastic-7.x.list

Aktualisiere die Repository-Liste des Systems.

$ sudo apt update

Installiere Elasticsearch.

$ sudo apt install elasticsearch

Elasticsearch verbraucht viel Speicher. Du musst seine Nutzung je nach Größe deines Servers begrenzen. 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. Du kannst bei Bedarf jeden beliebigen Wert verwenden.

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",
  "cluster_name" : "elasticsearch",
  "cluster_uuid" : "LNFRevgvQIOGeWCdtvc7bA",
  "version" : {
    "number" : "7.17.12",
    "build_flavor" : "default",
    "build_type" : "deb",
    "build_hash" : "e3b0c3d3c5c130e1dc6d567d6baef1c73eeb2059",
    "build_date" : "2023-07-20T05:33:33.690180787Z",
    "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 – Redis-Server installieren

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 funktioniert mit Redis 7.0. Debian wird mit Redis 6.0 ausgeliefert, also werden wir das Redis-Repository für die Installation verwenden.

Importiere den offiziellen Redis GPG-Schlüssel.

$ curl -fsSL https://packages.redis.io/gpg | sudo gpg --dearmor -o /usr/share/keyrings/redis-archive-keyring.gpg

Füge das APT-Repository zu deiner Quellenliste hinzu.

$ echo "deb [signed-by=/usr/share/keyrings/redis-archive-keyring.gpg] https://packages.redis.io/deb $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/redis.list

Aktualisiere die Liste der System-Repositorys.

$ sudo apt update

Gib den folgenden Befehl ein, um den Redis-Server zu installieren.

$ sudo apt install redis

Bestätige die Redis-Version.

$ redis-server -v
Redis server v=7.0.12 sha=00000000:0 malloc=jemalloc-5.2.1 bits=64 build=d706905cc5f560c1

Überprüfe die Verbindung zum Dienst 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/magento -p

Gib dem aktuellen Benutzer die Rechte für das Magento-Verzeichnis.

$ sudo chown $USER:$USER /var/www/magento/ -R

Bevor wir weitermachen, brauchst du die Authentifizierungsschlüssel, die für das Magento-Repository erforderlich sind. Besuche die Website https://account.magento.com/ und du wirst auf der folgenden Seite aufgefordert, dich mit deiner Adobe ID anzumelden.

Adobe ID Anmeldeseite

Klicke auf die Schaltfläche Mit Adobe ID anmelden, um auf die folgende Seite zu gelangen.

Magento Adobe Login Seite

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://marketplace.magento.com/customer/accessKeys/. Du kannst diese Seite auch aufrufen, indem du dein Profil aufrufst und auf den Link Zugangsschlüssel klickst.

Adobe Magento Profilseite

Klicke auf die Schaltfläche Einen neuen Zugangsschlüssel erstellen, um deinen Authentifizierungsschlüssel zu erstellen. Gib deinem Schlüssel einen Namen zur Identifizierung.

Magento Access Keys

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/magento.

$ cd /var/www/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-p1)
  - Downloading magento/project-community-edition (2.4.6-p1)
  - Installing magento/project-community-edition (2.4.6-p1): Extracting archive
Created project in /var/www/magento/.
Loading composer repositories with package information
Info from https://repo.packagist.org: #StandWithUkraine
Updating dependencies
Lock file operations: 565 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)
...............................................

Es gibt ein Problem mit der Nginx-Beispielkonfigurationsdatei, die von Adobe bereitgestellt wird. Führe den folgenden Befehl aus, um es zu beheben.

$ sed -i 's/php-fpm:9000/fastcgi_backend/g' /var/www/magento/nginx.conf.sample

Führe die folgenden Befehle aus, um die Dateiberechtigungen zu setzen und die Magento-Binärdatei 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

Bevor wir mit der Installation fortfahren, müssen wir das Installationsprogramm so ändern, dass wir MariaDB 10.11.3 verwenden können, das derzeit von Magento nicht unterstützt wird. Magento unterstützt bisher die Versionen MariaDB 10.2-10.6.

Öffne die Datei /var/www/magento/app/etc/di.xml zum Bearbeiten.

$ sudo nano /var/www/magento/app/etc/di.xml

Suche nach der folgenden Zeile.

<item name="MariaDB-(10.2-10.6)" xsi:type="string">^10\.[2-6]\.</item>

Ersetze sie durch den folgenden Code.

<item name="MariaDB-(10.2-10.11)" xsi:type="string">^10\.([2-9]|10|11)\.</item>

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Stelle sicher, dass du dich im Magento-Verzeichnis befindest.

$ cd /var/www/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=localhost \
--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_11xb2x
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 d1957f62aa710cc367525c9ec68dd7456d4311756b5aa37d2143c4a98b25318c
* * * * * /usr/bin/php8.2 /var/www/magento/bin/magento cron:run 2>&1 | grep -v "Ran jobs by schedule" >> /var/www/magento/var/log/magento.cron.log
#~ MAGENTO END d1957f62aa710cc367525c9ec68dd7456d4311756b5aa37d2143c4a98b25318c

Schritt 12 – PHP-FPM konfigurieren

Öffne die Datei /etc/php/8.2/fpm/pool.d/www.conf.

$ sudo nano /etc/php/8.2/fpm/pool.d/www.conf

Wir müssen den Unix-Benutzer/die Unix-Gruppe der PHP-Prozesse auf nginx setzen. Finde die Zeilen user=www-data und group=www-data in der Datei und ändere sie in nginx.

...
; Unix user/group of the child processes. This can be used only if the master
; process running user is root. It is set after the child process is created.
; The user and group can be specified either by their name or by their numeric
; IDs.
; Note: If the user is root, the executable needs to be started with
;       --allow-to-run-as-root option to work.
; Default Values: The user is set to master process running user by default.
;                 If the group is not set, the user's group is used.
user = nginx
group = nginx
...

Finde die Zeilen listen.owner = www-data und listen.group = www-data in der Datei und ändere sie in nginx.

; 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. Many
; BSD-derived systems allow connections regardless of permissions. The owner
; and group can be specified either by name or by their numeric IDs.
; Default Values: user and group are set as the running user
;                 mode is set to 0660
listen.owner = nginx
listen.group = nginx

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Erhöhe die Ausführungszeit für PHP-FPM und PHP-CLI auf 180 Sekunden.

$ sudo sed -i 's/max_execution_time = 30/max_execution_time = 180/' /etc/php/8.2/fpm/php.ini
$ sudo sed -i 's/max_execution_time = 30/max_execution_time = 180/' /etc/php/8.2/cli/php.ini

Erhöhe das Speicherlimit für PHP-FPM von 128 MB auf 256 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 = 256M/' /etc/php/8.2/fpm/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/8.2/fpm/php.ini
$ sudo sed -i 's/post_max_size = 8M/post_max_size = 25M/g' /etc/php/8.2/fpm/php.ini

Schalte die Zlib-Komprimierung ein.

$ sudo sed -i 's/zlib.output_compression = Off/zlib.output_compression = On/g' /etc/php/8.2/fpm/php.ini

Starte den PHP-FPM-Dienst neu.

$ sudo systemctl restart php8.2-fpm

Ändere die Gruppe des PHP-Sessions-Verzeichnisses auf Nginx.

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

Schritt 13 – 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/php8.2-fpm.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/magento;
  include /var/www/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.

Magento Homepage

Wenn das CSS und JS nicht geladen wird, führe die folgenden Befehle aus.

$ cd /var/www/magento
$ php bin/magento setup:static-content:deploy -f
$ php bin/magento indexer:reindex

Schritt 14 – Deaktivieren der Zwei-Faktor-Authentifizierung

Bevor wir auf das Administrationspanel zugreifen, müssen wir die Zwei-Faktor-Authentifizierung deaktivieren, die standardmäßig aktiviert ist. 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. Um die Zwei-Faktor-Authentifizierung zu deaktivieren, müssen wir zwei Module von Magento mit den folgenden Befehlen deaktivieren.

$ php /var/www/magento/bin/magento module:disable Magento_AdminAdobeImsTwoFactorAuth
$ php /var/www/magento/bin/magento module:disable Magento_TwoFactorAuth

Führe den folgenden Befehl aus, um die Klassen zu erstellen.

$ php /var/www/magento/bin/magento setup:di:compile

Lösche auch den Cache.

$ php /var/www/magento/bin/magento c:c

Schritt 15 – Zugriff auf das Administrationsportal

Du musst das Administrationsportal mit der URI öffnen, die dir das Magento-Installationsskript mitgeteilt hat. Wenn du vergessen hast, sie zu notieren oder sie verloren hast, kannst du die URI mit folgendem Befehl wiederherstellen.

$ php /var/www/magento/bin/magento info:adminuri
Admin URI: /admin_11xb2x

Öffne die URL https://magento.example.com/admin_11xb2x in deinem Browser und du wirst den folgenden Bildschirm sehen.

Magento Admin Login Seite

Gib deine Administrator-Anmeldedaten ein, die du während der Installation erhalten hast, und klicke auf die Schaltfläche Anmelden, um fortzufahren. Du wirst mit dem folgenden Bildschirm begrüßt.

Magento Admin Dashboard

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.

Magento Stores &gt; Config Menü

Erweitere das Menü Erweitert auf der linken Seite und klicke auf die Option Systeme, um die Seite E-Mail-Einstellungen zu öffnen.

Magento Einstellungen für den E-Mail-Versand

Deaktiviere die Option Systemwert verwenden vor den Optionen Transport, Host und Port. Klicke auf das Dropdown-Menü für Transport und wähle SMTP aus. Für unser Tutorial verwenden wir Amazon SES als Mailer.

Magento Amazon SES Mail Einstellungen

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 Filial-E-Mail-Adressen.

Magento Store E-Mail-Adressen Seite

Deaktiviere die Standardfelder für Absender-E-Mails und gib die E-Mail-Adressen 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.

Magento Kontakt E-Mail Einstellungen

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.

$ php /var/www/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.

Magento E-Mail Test

Schritt 16 – 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.

$ php /var/www/magento/bin/magento module:enable Magento_AdminAdobeImsTwoFactorAuth
$ php /var/www/magento/bin/magento module:enable Magento_TwoFactorAuth

Aktualisiere das Setup für die Module.

$ php /var/www/magento/bin/magento setup:upgrade

Führe den folgenden Befehl aus, um die Klassen zu erstellen.

$ php /var/www/magento/bin/magento setup:di:compile

Lösche auch den Cache.

$ php /var/www/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.

$ php /var/www/magento/bin/magento setup:static-content:Deploy -f

Lege die Dateiberechtigungen fest.

$ cd /var/www/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.

Magento 2FA konfigurieren

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.

Magento Google 2FA konfigurieren

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 Tutorium zur Installation von Magento eCommerce Site auf einem Debian 12 Server mit einem Nginx Server und Elasticsearch abgeschlossen. Wenn du noch Fragen hast, schreibe sie in die Kommentare unten.

Das könnte dich auch interessieren …