Diese Seite wurde von der Cloud Translation API übersetzt.

Magento in Cloud Spanner einbinden

1. Einführung

Magento in ein Cloud Spanner-Back-End einbinden

Magento ist eine weithin beliebte PHP-basierte Open-Source-E-Commerce-Plattform, die Daten in MySQL speichert.

Dieses Codelab ist ein Proof of Concept, um Cloud Spanner anstelle von MySQL für das Catalog-Modul zu nutzen. Das ist nützlich für alle, die Magento oder andere PHP-Anwendungen in Spanner einbinden, testen und bereitstellen möchten.

Spanner ist eine vollständig verwaltete, für Unternehmen geeignete, verteilte, konsistente und konsistente Datenbank von Google Cloud, die die Vorteile des relationalen Datenbankmodells mit nicht-relationaler horizontaler Skalierbarkeit vereint. Es wurde entwickelt, um globale Bereitstellungen für die Online-Transaktionsverarbeitung, SQL-Semantik, hochverfügbare horizontale Skalierung und transaktionale Konsistenz zu unterstützen. Spanner kann große Datenmengen verarbeiten. Die Verwendung ist nicht auf Anwendungen mit großer Größe beschränkt, sondern ermöglicht die Standardisierung einer einzelnen Datenbank-Engine für alle Arbeitslasten, die ein relationales Datenbankmanagementsystem erfordern. Spanner bietet keine Ausfallzeiten für geplante Wartungsarbeiten oder Regionsausfälle mit einem Verfügbarkeits-SLA von 99, 999%. Spanner unterstützt moderne Anwendungen durch hohe Verfügbarkeit und Skalierbarkeit.

Lerninhalte

Magento in GCE installieren
Spanner-Emulator einrichten
Vorhandenes MySQL-Schema mit HarbourBridge zu Spanner migrieren
Was Sie ändern müssen, um PHP-Anwendungen wie Magento zu integrieren, die MySQL als Datenbank-Back-End verwenden, damit sie mit Spanner funktionieren

Aufgaben

In diesem Codelab geht es um die Einbindung von Magento in Spanner. Codeblöcke und Einrichtungsanleitungen werden zum Kopieren und Einfügen bereitgestellt, werden aber nicht im Detail erläutert.

In diesem Codelab beginnen Sie mit der Integration von Magento in Spanner. Sie werden Folgendes tun:

GCE-Instanz mit installiertem Magento einrichten
Spanner-Emulator installieren
Installieren Sie das HarbourBridge-Tool für die Datenmigration von MySQL zu Spanner
Magento-Sammlungen so ändern, dass der Produktkatalog aus Spanner geladen wird

Voraussetzungen

Ein Google Cloud-Projekt, das mit einem Rechnungskonto verbunden ist.
Kenntnisse der PHP-, Linux- und Apache-Konfiguration sind von Vorteil.
Magento-Vorkenntnisse sind hilfreich, aber nicht zwingend erforderlich.

2. GCE-Instanz vorbereiten

GCE-Instanz erstellen

Erstellen Sie eine Compute Engine-Instanz in der Google Cloud Platform. Folgen Sie dazu dieser Anleitung.

Ändern Sie beim Erstellen der GCE-Instanz den Instanztyp in e2-standard-2 und die Größe des Bootlaufwerks in 20 GB. Sie können alles bei den Standardeinstellungen belassen, aber achten Sie darauf, „HTTP-Traffic zulassen“ und „HTTPS-Traffic zulassen“ auszuwählen, da wir die Weboberfläche von Magento verwenden werden.

Daraus ergibt sich der Maschinentyp e2-standard-2, der keine Instanz mit gemeinsam genutztem Kern ist und 2 vCPUs, 8 GB RAM und 20 GB Festplattenspeicher hat.

Das Betriebssystem ist Debian 10. Das Erstellen der Instanz kann ein bis zwei Minuten dauern.

Nachdem er erstellt wurde, melden Sie sich an, indem Sie in der Cloud Console auf „SSH“ klicken:

Dadurch wird ein neues Browserfenster geöffnet und Sie in einem Terminal geöffnet.

Erforderliche Software installieren

Für die Ausführung von Magento muss einige Software installiert werden. Sie installieren PHP, Elastic, MySQL und Apache, wie unten beschrieben.

Installieren Sie einige erforderliche Pakete.

sudo apt update

sudo apt -y install lsb-release apt-transport-https ca-certificates wget git screen composer google-cloud-sdk-spanner-emulator gcc

Installieren Sie die für Magento erforderlichen PHP-Module.

sudo wget -O /etc/apt/trusted.gpg.d/php.gpg https://packages.sury.org/php/apt.gpg

echo "deb https://packages.sury.org/php/ $(lsb_release -sc) main" | sudo tee /etc/apt/sources.list.d/php.list

sudo apt update

sudo apt -y install php7.4-fpm php7.4-common php7.4-mysql php7.4-gmp php7.4-curl php7.4-intl php7.4-mbstring php7.4-xmlrpc php7.4-gd php7.4-xml php7.4-cli php7.4-zip php7.4-bcmath php7.4-soap php7.4-grpc

Elasticsearch installieren und Dienst starten

wget -qO - https://artifacts.elastic.co/GPG-KEY-elasticsearch | sudo apt-key add -

echo "deb https://artifacts.elastic.co/packages/7.x/apt stable main" | sudo tee /etc/apt/sources.list.d/elastic-7.x.list

sudo apt update && sudo apt -y install elasticsearch

echo "-Xms1g
-Xmx1g" | sudo tee /etc/elasticsearch/jvm.options.d/jvm.options

sudo systemctl start elasticsearch.service

MySQL installieren

Sie installieren MySQL, um das Magento-Standardschema zu installieren. Später migrieren Sie das Schema mithilfe von HarbourBridge zu Spanner.

wget https://dev.mysql.com/get/mysql-apt-config_0.8.13-1_all.deb

sudo dpkg -i mysql-apt-config*

Durch den Befehl dpkg oben wird eine interaktive Aufforderung zur Installation des MySQL 5.7-Servers angezeigt. Wählen Sie die Optionen aus:

MySQL-Server und ‑Cluster
MySQL-5.7
Ok

sudo apt update && sudo apt -y install mysql-server
# You will be prompted to enter a root password

Apache2 installieren

sudo apt -y install apache2

sudo a2enmod proxy_fcgi rewrite

Magento2 installieren und konfigurieren

Das Magento Commerce Cloud-Projekt enthält ein Datenbankschema und Dienste für den vollständigen Zugriff auf die Magento-Website und den Magento-Shop.

Folgen Sie der Anleitung für Magento zur Installation mit Composer:

Installieren Sie Magento Version 2.4.2 mit Composer. Für Magento 2 ist Composer 1.x erforderlich. Möglicherweise werden Warnungen angezeigt, dass der Support für diese Version eingestellt wird.

composer create-project --repository-url=https://repo.magento.com/ magento/project-community-edition=2.4.2 magento2

Ordnerberechtigungen festlegen

cd magento2

find var generated vendor pub/static pub/media app/etc -type f -exec chmod g+w {} +

find var generated vendor pub/static pub/media app/etc -type d -exec chmod g+ws {} +

Konfigurieren Sie den virtuellen Magento-Host, indem Sie /etc/apache2/sites-available/magento.conf mit dem unten stehenden Inhalt erstellen.

sudo nano /etc/apache2/sites-available/magento.conf

<VirtualHost *:80>
        ServerAdmin admin@local-magento.com
        DocumentRoot /var/www/html/magento/

        <Directory /var/www/html/magento/>
                Options Indexes FollowSymlinks MultiViews
                AllowOverride All
                Order allow,deny
                allow from all
        </Directory>

        <FilesMatch \.php$>
               SetHandler "proxy:unix:/run/php/php7.4-fpm.sock|fcgi://localhost"
        </FilesMatch>

        ErrorLog ${APACHE_LOG_DIR}/error.log
        CustomLog ${APACHE_LOG_DIR}/access.log combined
</VirtualHost>

Erstellen Sie die Symlinks und starten Sie apache2 neu.

cd ~/magento2
sudo ln -s $(pwd) /var/www/html/magento 
sudo ln -s /etc/apache2/sites-available/magento.conf  /etc/apache2/sites-enabled/magento.conf
sudo rm /etc/apache2/sites-enabled/000-default.conf

sudo systemctl restart apache2

Datenbank und Nutzer für Magento in MySQL erstellen

export ROOT_PASSWORD="<root password from installation>"
export GCE_INSTANCE_IP="<GCE instance IP>"
mysql -uroot -p$ROOT_PASSWORD -e "create database magento"

bin/magento sampledata:deploy

bin/magento setup:install --base-url=http://$GCE_INSTANCE_IP/ --db-host=localhost \
--db-name=magento --db-user=root --db-password=$ROOT_PASSWORD --admin-firstname=admin \
--admin-lastname=demo --admin-email=good@example.com --admin-user=admin \
--admin-password=magento123 --language=en_US --currency=USD --timezone=America/Chicago \
--use-rewrites=1

sudo chown -R :www-data ~/magento2/.

Lokalen Arbeitsbereich prüfen In diesem Beispiel können Sie mithilfe der folgenden URL-Formate auf den lokalen Magento-Shop zugreifen:

http://<GCEexternalIP>/
http://<GCEexternalIP>/<adminuri>

Die GCEexternalIP finden Sie in der Cloud Console:

Verwenden Sie den folgenden Befehl, um den URI für das Admin-Steuerfeld zu finden:

php bin/magento info:adminuri

Vollständigen Seiten-Cache deaktivieren Zu Entwicklungszwecken können Sie den gesamten Seiten-Cache von Magento2 deaktivieren. So können Sie die Daten in Spanner ändern und auf der Website anzeigen lassen, ohne dass sich das auf die im Cache gespeicherten Werte auswirkt.

php bin/magento cache:disable full_page

Spanner einrichten

Spanner-Emulator installieren

Das Cloud SDK bietet einen lokalen Emulator im Arbeitsspeicher, mit dem Sie Ihre Anwendungen kostenlos entwickeln und testen können, ohne ein GCP-Projekt oder ein Rechnungskonto erstellen zu müssen. Da der Emulator die Daten nur zwischenspeichert, geht der gesamte Status, einschließlich Daten, Schema und Konfigurationen, beim Neustart verloren. Der Emulator bietet dieselben APIs wie der Spanner-Produktionsdienst und ist für lokale Entwicklung und Tests vorgesehen, nicht für die Produktionsbereitstellung.

Über den folgenden Link erhalten Sie weitere Informationen zur Installation, Verwendung und Bereitstellung des Emulators:

Spanner-Emulator verwenden

# Set up a new configuration to use the emulator
gcloud config configurations create emulator
gcloud config set auth/disable_credentials true
gcloud config set project magento
gcloud config set api_endpoint_overrides/spanner http://localhost:9020/

# Start emulator in a screen session
screen -S magento
gcloud emulators spanner start &
gcloud spanner instances create magento-instance --config=emulator-config --description='Magento Instance' --nodes=1

# Detach from screen 
ctrl+a+d

export SPANNER_EMULATOR_HOST=localhost:9010

Magento MySQL zu Spanner migrieren

Bevor wir uns mit der Integration von Spanner befassen, verwenden wir das Tool HarbourBridge, um die MySQL-Datenbank, die im Rahmen unserer Magento-Installation oben erstellt wurde, in Spanner zu konvertieren.

Im Kern bietet HarbourBridge einen automatisierten Workflow zum Laden der Inhalte einer vorhandenen MySQL- oder PostgreSQL-Datenbank in Spanner. Sie erfordert keine Konfiguration und es müssen keine Manifeste oder Datenzuordnungen geschrieben werden. Stattdessen wird die Quelldatenbank importiert, ein Spanner-Schema erstellt, eine neue Spanner-Datenbank mit Daten aus der Quelldatenbank erstellt und ein detaillierter Bewertungsbericht generiert. HarbourBridge ist für das Laden von Datenbanken mit bis zu einigen Dutzend GB zu Bewertungszwecken gedacht, nicht für Migrationen im Vollformat.

HarbourBridge startet die Migration zu Spanner in einer frühen Phase mithilfe einer vorhandenen MySQL- oder PostgreSQL-Quelldatenbank, um einen schnellen Einstieg in Spanner zu ermöglichen. Dabei wird ein Bewertungsbericht mit einem allgemeinen Migrationsfitnesswert für Spanner, einer Tabellenanalyse von Typzuordnungen und einer Liste der in der Quelldatenbank verwendeten Features, die von Spanner nicht unterstützt werden, erstellt.

HarbourBridge kann mit dem Spanner-Emulator oder direkt mit einer Spanner-Instanz verwendet werden.

Die HarbourBridge-README enthält eine Schnellstartanleitung mit einer detaillierten Anleitung zur Verwendung des Tools mit einer Spanner-Instanz.

HarbourBridge installieren

Laden Sie das Tool auf Ihren Computer herunter und installieren Sie es. Dazu muss golang installiert sein. Es kann einige Zeit dauern, bis alle erforderlichen Module auf einer neuen Instanz installiert sind, wenn Go nicht zuvor eingerichtet wurde.

# Install golang
cd ~
wget https://golang.org/dl/go1.17.2.linux-amd64.tar.gz
sudo tar -zxvf go1.17.2.linux-amd64.tar.gz -C /usr/local
rm go1.17.2.linux-amd64.tar.gz

echo 'export GOROOT=/usr/local/go' | sudo tee -a /etc/profile
echo 'export PATH=/usr/local/go/bin:$HOME/go/bin:$PATH' | sudo tee -a /etc/profile
source /etc/profile

# Install harbourbridge
git clone https://github.com/cloudspannerecosystem/harbourbridge
cd harbourbridge
go run github.com/cloudspannerecosystem/harbourbridge help

Daten migrieren

Verwenden Sie den folgenden Befehl, um die Magento-Datenbank zu Spanner zu migrieren:

mysqldump --user='root' --password=$ROOT_PASSWORD magento | go run github.com/cloudspannerecosystem/harbourbridge -driver=mysqldump -dbname=magento

Spanner-Befehlszeilentool einrichten

go install github.com/cloudspannerecosystem/spanner-cli@latest

3. Magento konvertieren, um mit Spanner zu arbeiten

Da Magento ausgeführt wird und die mit der Magento-Datenbank erstellte Spanner-Instanz migriert wurde, werden wir Magento so anpassen, dass er mit den in Spanner gespeicherten Daten funktioniert.

Zum Konvertieren der Magento-Installation werden folgende Schritte ausgeführt:

magento-spanner-port-Projekt klonen
Verbindung zu Spanner ändern
Prüfen, ob die Katalogdetails aus Spanner stammen

Fork des Magento-Projekts klonen

Klonen Sie den PHP-Anwendungscode für Magento, der die Änderungen für die Katalog-, Wunschliste- und Einkaufswagenmodule enthält, von der unten genannten Git-URL.

cd ~
git clone https://github.com/searceinc/magento-spanner-port

Ihr Basisverzeichnis sollte in etwa so aussehen:

$ ls
go  harbourbridge  magento-spanner-port  magento2

Dabei ist magento2 die Codebasis, die wir mit Code aus magento-spanner-port ändern werden.

Verbindung zu Spanner ändern

Um zu prüfen, ob die Codeänderungen in der Benutzeroberfläche übernommen wurden, können wir die folgenden Schritte ausführen:

Eine Beispielimplementierung finden Sie unter dem GitHub-Link https://github.com/searceinc/magento-spanner-port.

PHP-Clientbibliothek „google/cloud-spanner“ verlangen
Spanner-Adapter zum Erstellen einer Verbindung zu Spanner hinzufügen
Spanner-Instanz und Serverinformationen konfigurieren
Fügen Sie SpannerInterface und Spanner in den Adapter ein, um die Verbindung zu Spanner zu implementieren.

Zuerst müssen wir die Cloud Spanner-PHP-Bibliothek mit Composer installieren. Führen Sie im magento2-Verzeichnis den folgenden Befehl aus:

cd ~/magento2
composer require google/cloud-spanner

Anschließend fügen wir der Codebasis magento2 die Spanner-Adapterdateien aus dem magento-spanner-port hinzu:

~/magento2$ cp -r ../magento-spanner-port/lib/internal/Magento/Framework/DB/Adapter/Spanner vendor/magento/framework/DB/Adapter/.
~/magento2$ ls -l vendor/magento/framework/DB/Adapter/Spanner
total 16
-rw-r--r-- 1 derekdowney derekdowney 10378 Nov  9 21:03 Spanner.php
-rw-r--r-- 1 derekdowney derekdowney  2948 Nov  9 21:03 SpannerInterface.php

Ändern Sie nun die Datei DB/Adapter/Spanner/Spanner.php, um die Spanner-Verbindungsinformationen für $project_id, $instance und $database einzugeben:

$ nano vendor/magento/framework/DB/Adapter/Spanner/Spanner.php

class Spanner implements SpannerInterface
{
    /**
     * Google cloud project id
     * @var string
     */
    private $project_id = 'magento';

    /**
     * Google cloud instance name
     * @var string
     */
    private $instance  = 'magento-instance';

    /**
     * Cloud Spanner database name
     * @var string
     */
    private $database  = 'magento';

    /**
     * Is Cloud Spanner emulator
     * @var bool
     */
    private $is_emulator = true;
...
   /**
    * Set database connection adapter
    *
    * @param \Magento\Framework\DB\Adapter\AdapterInterface $conn
    * @return $this
    * @throws \Magento\Framework\Exception\LocalizedException
    */
   public function setConnection(\Magento\Framework\DB\Adapter\AdapterInterface $conn)
   {
       $this->_conn = $conn;
       $this->_select = $this->_conn->select();
       $this->_isOrdersRendered = false;
       return $this;
   }


   /**
     * Set Cloud Spanner database connection adapter
     *
     * @return void
     * @throws \Magento\Framework\Exception\LocalizedException
     */
    private function setSpannerConnection()
    {
        $this->_spanner_conn = new Spanner();
    }

Ändern Sie die AbstractDB-Klasse in Magento, damit jetzt eine Verbindung zu Spanner über die neu erstellte Verbindungsfunktion im Spanner-Adapter hergestellt wird. Fügen Sie die grünen Zeilen nach den weißen Zeilen in der Datei hinzu. Weitere Informationen finden Sie unter vendor/magento/framework/Data/Collection/AbstractDb.php.

$ nano vendor/magento/framework/Data/Collection/AbstractDb.php
...
use Psr\Log\LoggerInterface as Logger;
use Magento\Framework\DB\Adapter\Spanner\Spanner;
...
    protected $_conn;

    /**
     * Cloud Spanner connection
     *
     * @var \Magento\Framework\DB\Adapter\Spanner\SpannerAdapterInterface
     */
    protected $_spanner_conn;
...
       if ($connection !== null) {
            $this->setConnection($connection);
        }
        $this->setSpannerConnection();
        $this->_logger = $logger;
...
   /**
     * Retrieve connection object
     *
     * @return AdapterInterface
     */
    public function getConnection()
    {
        return $this->_conn;
    }

   /**
     * Retrieve connection object
     *
     * @return SpannerAdapterInterface
     */
    public function getSpannerConnection()
    {
        return $this->_spanner_conn;
    }
...

Sobald die Verbindung hergestellt ist, müssen wir die Methode zum Abrufen von Daten vom MySQL-Adapter zum Spanner-Adapter ändern. Ändern Sie die Methode _loadAttributes in ExtractCollection, um eine Verbindung zu Spanner herzustellen und die Daten von Spanner abzurufen. Ersetzen Sie die rote Linie durch die grünen Linien.

Weitere Informationen finden Sie unter /app/code/Magento/Eav/Model/Entity/Collection/AbstractCollection.php.

$ nano ./vendor/magento/module-eav/Model/Entity/Collection/AbstractCollection.php

use Magento\Framework\Exception\LocalizedException;
use Google\Cloud\Spanner\SpannerClient;

...
               try {
                    if (is_array($selects)) {
                        $select = implode(' UNION ALL ', $selects);
                    } else {
                        $select = $selects;
                    }
                   $values = $this->getConnection()->fetchAll($select);
                   $con = $this->getSpannerConnection();

                    /**
                     * Cloud Spanner follows strict type so cast the columns in common type
                     */
                    $select = $con->addCast($select, "`t_d`.`value`", 'string');
                    $select = $con->addCast($select, "`t_s`.`value`", 'string');
                    $select = $con->addCast($select, "IF(t_s.value_id IS NULL, t_d.value, t_s.value)", 'string');
                    
                    $values = $con->fetchAll($select);

...

Prüfen, ob die Katalogdetails aus Spanner stammen

Fertig! Sie können jetzt Ihre Magento-Installation im Browser aufrufen und prüfen, ob die Daten geladen werden.

Dies sind beispielsweise die Katalogeinträge für Smartwatches:

Ändern Sie Spanner-Daten für eines der Produkte über das Terminal und fragen Sie die Daten über das Terminal ab, um die Änderung in Spanner zu bestätigen.

$ spanner-cli -pmagento -i magento-instance -d magento
spanner> SELECT * FROM catalog_product_entity_varchar WHERE value LIKE "Aim Analog%";
+----------+--------------+----------+-----------+--------------------+
| value_id | attribute_id | store_id | entity_id | value              |
+----------+--------------+----------+-----------+--------------------+
| 390      | 73           | 0        | 36        | Aim Analog Watch |
+----------+--------------+----------+-----------+--------------------+
1 rows in set (80.711542ms)

spanner> UPDATE catalog_product_entity_varchar SET value = "Aim Analog Spanner" WHERE value_id=390;
Query OK, 1 rows affected (0.19 sec)

spanner> SELECT * FROM catalog_product_entity_varchar WHERE value_id=390;
+----------+--------------+----------+-----------+--------------------+
| value_id | attribute_id | store_id | entity_id | value              |
+----------+--------------+----------+-----------+--------------------+
| 390      | 73           | 0        | 36        | Aim Analog Spanner |
+----------+--------------+----------+-----------+--------------------+
1 rows in set (80.711542ms)

Laden Sie jetzt den Bildschirm neu, um zu prüfen, ob der Name der Smartwatch jetzt zu „Aim Analog Spanner“ geändert wurde, wie über das Spanner-Terminal aktualisiert.

4. Glückwunsch

Herzlichen Glückwunsch! Sie haben das Katalogmodul von Magento so verbunden, dass es mit Spanner funktioniert. Es ist keine vollständige Integration, aber Sie wissen jetzt, welche Elemente erforderlich sind, um eine PHP-Anwendung wie Magento mit einer Spanner-Instanz zu verbinden.

Bereinigen

Wenn die POC-Einrichtung und -Validierung abgeschlossen ist, sollten Sie die während des Vorgangs erstellten GCP-Ressourcen löschen. Dazu gehören die virtuelle Compute Engine-Maschine sowie eine Cloud Spanner-Instanz, falls Sie eine anstelle des Emulators verwenden möchten.

Nächste Schritte

Dies ist nur ein Prototypmodell für ein Spanner-POC.

Wenn Sie mehr über die Arbeit mit Spanner und den in diesem Codelab verwendeten Technologien erfahren möchten, finden Sie hier einige zusätzliche Ressourcen: