Magento in Cloud Spanner einbinden

1. Einführung

Magento in ein Cloud Spanner-Back-End einbinden

Magento ist eine weit verbreitete Open-Source-E-Commerce-Plattform, die auf PHP basiert und Daten in MySQL speichert.

Dieses Codelab ist ein Proof of Concept, um Cloud Spanner anstelle von MySQL für das Katalogmodul zu verwenden. 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 und konsistente Datenbank von Google Cloud, die die Vorteile des relationalen Datenbankmodells mit nicht relationaler horizontaler Skalierbarkeit vereint. Er wurde für globale OLTP-Bereitstellungen (Online Transactional Processing), SQL-Semantik, hochverfügbare horizontale Skalierung und Transaktionskonsistenz entwickelt. Spanner kann große Datenmengen verarbeiten. Die Verwendung ist nicht auf große Anwendungen beschränkt, sondern ermöglicht die Standardisierung einer einzelnen Datenbank-Engine für alle Arbeitslasten, die ein relationales Datenbankverwaltungssystem (RDBMS) erfordern. Spanner vermeidet Ausfallzeiten bei geplanten Wartungsarbeiten oder Regionalfehlern und bietet ein 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, damit PHP-Anwendungen wie Magento, die MySQL für das Datenbank-Backend verwenden, mit Spanner funktionieren

Aufgaben

In diesem Codelab geht es um die Integration von Magento in Spanner. Codeblöcke und Einrichtungsanleitungen können Sie einfach kopieren und einfügen. Sie werden jedoch 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
Installieren Sie den Spanner-Emulator .
HarbourBridge-Tool für die Datenmigration von MySQL zu Spanner installieren
Magento-Sammlungen ändern, um den Produktkatalog aus Spanner zu laden

Voraussetzungen

Ein Google Cloud-Projekt, das mit einem Rechnungskonto verknüpft ist.
Kenntnisse in PHP, Linux und Apache-Konfiguration sind von Vorteil.
Erfahrung mit Magento ist hilfreich, aber nicht zwingend erforderlich.

2. GCE-Instanz vorbereiten

GCE-Instanz erstellen

Erstellen Sie eine Compute Engine-Instanz in Google Cloud, indem Sie die hier beschriebenen Schritte ausführen.

Ä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 auf den Standardeinstellungen belassen, sollten aber „HTTP-Traffic zulassen“ und „HTTPS-Traffic zulassen“ auswählen, da wir die Weboberfläche von Magento nutzen werden.

Das Ergebnis ist der Maschinentyp e2-standard-2, der keine Instanz mit gemeinsam genutztem Kern ist und 2 vCPUs, 8 GB RAM und 20 GB Speicherplatz hat.

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

Nachdem die Instanz erstellt wurde, können Sie sich anmelden, indem Sie in der Cloud Console auf „SSH“ klicken:

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

Erforderliche Software installieren

Für Magento muss einige erforderliche Software installiert werden, bevor wir Magento ausführen können. 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 den 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 standardmäßige Magento-Schema zu installieren. Später migrieren Sie das Schema mit HarbourBridge zu Spanner.

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

sudo dpkg -i mysql-apt-config*

Mit dem Befehl dpkg oben wird eine interaktive Eingabeaufforderung zur Installation des MySQL 5.7-Servers angezeigt. Wählen Sie die gewünschten 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

Magento 2 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.

Am einfachsten ist es, wenn Sie die Magento-Anleitung zur Installation mit Composer befolgen:

Installieren Sie Magento 2.4.2 mit Composer. Für Magento 2 ist die Composer-Version 1.x erforderlich. Möglicherweise werden einige 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 folgenden 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 Apache 2 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 bestätigen: Rufen Sie den Store über die Basis-URL auf, die Sie im Installationsbefehl übergeben haben, um zu bestätigen, dass der Server in der lokalen Umgebung gehostet wird. In diesem Beispiel können Sie über die folgenden URL-Formate auf den lokalen Magento-Shop zugreifen:

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

Die GCEexternalIP finden Sie in der Cloud Console:

Wenn Sie den URI für das Admin-Panel ändern möchten, verwenden Sie diesen Befehl, um ihn zu finden:

php bin/magento info:adminuri

Vollständigen Seitencache deaktivieren Für Entwicklungszwecke können Sie den vollständigen Seitencache von Magento 2 deaktivieren. So können Sie die Daten in Spanner ändern und sie werden auf der Website angezeigt, ohne dass sie durch zwischengespeicherte Werte beeinflusst werden.

php bin/magento cache:disable full_page

Cloud Spanner einrichten

Spanner-Emulator installieren

Das Cloud SDK bietet einen lokalen Emulator im Speicher, 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 Cloud Spanner-Produktionsdienst und ist für lokale Entwicklung und Tests vorgesehen, nicht für die Produktionsbereitstellung.

Weitere Informationen zur Installation, Verwendung und Bereitstellung des Emulators finden Sie unter dem folgenden Link:

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 der oben beschriebenen Magento-Installation erstellt wurde, in Spanner zu konvertieren.

Im Grunde bietet HarbourBridge einen automatisierten Workflow zum Laden der Inhalte einer vorhandenen MySQL- oder PostgreSQL-Datenbank in Spanner. Es ist keine Konfiguration erforderlich – Sie müssen keine Manifeste oder Datenzuordnungen schreiben. 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 einer Größe von bis zu einigen Dutzend Gigabyte zu Evaluierungszwecken vorgesehen, nicht für Migrationen im großen Maßstab.

HarbourBridge unterstützt die Migration zu Spanner in der Anfangsphase, indem eine vorhandene MySQL- oder PostgreSQL-Quelldatenbank verwendet wird, damit Sie schnell mit Spanner loslegen können. Es wird ein Bewertungsbericht mit einer allgemeinen Migrationsbereitschaftsbewertung für Spanner, einer tabellenweisen Analyse von Typzuordnungen und einer Liste der in der Quelldatenbank verwendeten Funktionen generiert, die von Spanner nicht unterstützt werden.

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

Die HarbourBridge-README-Datei enthält eine detaillierte Kurzanleitung für die Verwendung des Tools mit einer Spanner-Instanz.

HarbourBridge installieren

Laden Sie das Tool auf Ihren Computer herunter und installieren Sie es. Für die Ausführung ist die Installation von Go erforderlich. Es kann eine Weile dauern, bis alle erforderlichen Module auf einer neuen Instanz installiert sind, auf der Go noch nicht eingerichtet ist.

# 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-cli-Tool einrichten

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

3. Magento für die Verwendung mit Spanner konvertieren

Nachdem Magento ausgeführt wird und die Spanner-Instanz mit der migrierten Magento-Datenbank erstellt wurde, werden wir Magento so ändern, dass es mit den in Spanner gespeicherten Daten funktioniert.

Die Magento-Installation wird so konvertiert:

Klonen Sie das Projekt magento-spanner-port.
Verbindung zu Cloud 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 Module „Katalog“, „Wunschliste“ und „Warenkorb“ enthält, von der unten angegebenen Git-URL.

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

Ihr Home-Verzeichnis 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.

Verbindung zu Cloud Spanner ändern

So prüfen Sie, ob sich die Codeänderungen in der Benutzeroberfläche widerspiegeln:

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

PHP-Clientbibliothek „google/cloud-spanner“ anfordern
Fügen Sie den Spanner-Adapter hinzu, um eine Verbindung zu Spanner herzustellen.
Konfigurieren Sie die Spanner-Instanz und die Serverinformationen.
Fügen Sie dem Adapter SpannerInterface und Spanner hinzu, um die Verbindung zu Cloud Spanner zu implementieren.

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

cd ~/magento2
composer require google/cloud-spanner

Anschließend fügen wir die Spanner-Adapterdateien aus magento-spanner-port in unseren magento2-Code ein:

~/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 Klasse „AbstractDB“ in Magento, um jetzt mit der neu erstellten Connection-Funktion im Spanner-Adapter eine Verbindung zu Spanner herzustellen. Fügen Sie die grünen Zeilen nach den weißen Zeilen in der Datei hinzu. Siehe 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 AbstractCollection, um eine Verbindung zu Spanner herzustellen und die Daten aus Spanner abzurufen. Ersetzen Sie die rote Zeile durch die grünen Zeilen.

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

Geschafft! Sie können jetzt in Ihrem Browser auf Ihre Magento-Installation zugreifen und prüfen, ob die Daten geladen werden.

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

Ändern Sie Spanner-Daten über das Terminal für eines der Produkte 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 den Bildschirm neu, um zu bestätigen, dass der Name der Smartwatch jetzt „Aim Analog Spanner“ lautet, wie über das Spanner-Terminal aktualisiert.

4. Glückwunsch

Glückwunsch, Sie haben das Katalogmodul von Magento erfolgreich mit Spanner verbunden. Es handelt sich nicht um eine vollständige Integration, aber Sie kennen jetzt die Elemente, um eine PHP-Anwendung wie Magento mit einer Spanner-Instanz zu verbinden.

Bereinigen

Wenn die Einrichtung und Validierung des Proof of Concept abgeschlossen ist, können Sie die während des Vorgangs erstellten GCP-Ressourcen löschen. Dazu gehören die Compute Engine-VM sowie eine Cloud Spanner-Instanz, falls Sie sich für die Verwendung einer solchen anstelle des Emulators entschieden haben.

Nächste Schritte

Dies ist nur ein Prototypmodell für einen Spanner-Konzeptnachweis.

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