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. Dies ist nützlich für alle, die Magento oder andere PHP-Anwendungen in Spanner integrieren, testen und bereitstellen möchten.

Spanner ist eine vollständig verwaltete, verteilte und konsistente Datenbank für Unternehmen von Google Cloud, die die Vorteile eines relationalen Datenbankmodells mit nicht relationaler horizontaler Skalierbarkeit kombiniert. 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. Seine Verwendung ist nicht auf Anwendungen mit großer Größe beschränkt, sondern ermöglicht die Standardisierung eines einzigen Datenbankmoduls für alle Arbeitslasten, die RDBMS erfordern. Spanner bietet keine Ausfallzeiten für geplante Wartungsarbeiten oder Regionsausfälle mit einem Verfügbarkeits-SLA von 99, 999%. Sie unterstützt moderne Anwendungen durch Hochverfü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-Backend verwenden, um mit Spanner zu arbeiten

Aufgaben

In diesem Codelab geht es um die Integration 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, Magento in Spanner zu integrieren. Sie werden Folgendes tun:

Richten Sie eine GCE-Instanz mit Magento ein
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 mithilfe der hier beschriebenen Schritte eine Compute Engine-Instanz in der Google Cloud Platform.

Ä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 als Standard belassen, aber achten Sie darauf, „HTTP-Traffic zulassen“ auszuwählen. und "Allow HTTPS traffic", da wir die Weboberfläche von Magento nutzen.

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. Die Instanzerstellung kann ein bis zwei Minuten dauern.

Sobald es erstellt ist, kannst du dich anmelden, indem du auf „SSH“ klickst in der Cloud Console:

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 zunächst eine bestimmte Software installiert werden. Insbesondere installieren Sie 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*

Mit dem obigen Befehl dpkg wird eine interaktive Eingabeaufforderung zur Installation von MySQL 5.7 Server aufgerufen. 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 sehen Sie einige Warnungen, dass diese Version nicht mehr unterstützt 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 überprüfen Um zu überprüfen, ob der Server in der lokalen Umgebung gehostet wird, greifen Sie mit der im Installationsbefehl übergebenen Basis-URL auf den Speicher zu. 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 widergespiegelt werden, ohne durch im Cache gespeicherte Werte beeinträchtigt zu werden.

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 im Arbeitsspeicher speichert, gehen alle Statuswerte, einschließlich Daten, Schema und Konfigurationen, beim Neustart verloren. Der Emulator bietet dieselben APIs wie der Spanner-Produktionsdienst und ist für die lokale Entwicklung und Tests vorgesehen, nicht für Produktionsbereitstellungen.

Ü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 der obigen Magento-Installation 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 einer Größe von mehreren zehn GB zu Bewertungszwecken und nicht für umfangreiche Migrationen vorgesehen.

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 erstellt, die von Spanner nicht unterstützt werden.

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

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

HarbourBridge installieren

Laden Sie das Tool auf Ihren Computer herunter und installieren Sie es. Damit dies funktioniert, ist die Installation von Golang erforderlich. Es kann eine Weile dauern, bis alle erforderlichen Module auf einer neuen Instanz installiert sind, ohne dass Go bereits 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 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 eingefügt werden

Verzweigung des Magento-Projekts klonen

Klonen Sie den PHP-Anwendungscode für Magento, der die Änderungen für die Module Catalog, Wunschliste und Einkaufswagen enthält, aus 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 Sie ändern werden. Dazu verwenden wir den Code von magento-spanner-port.

Verbindung zu Spanner ändern

Mit den folgenden Schritten können Sie überprüfen, ob die Änderungen am Code in der Benutzeroberfläche übernommen werden:

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

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

Zunächst 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 abstraktionsfähige Klasse in Magento, damit jetzt mithilfe der im Spanner-Adapter neu erstellten Verbindungsfunktion eine Verbindung zu Spanner hergestellt wird. Fügen Sie die grünen Linien nach den weißen Linien in der Datei ein. 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 Sie die Datenabrufmethode vom MySQL-Adapter in den Spanner-Adapter ändern . Ändern Sie die Methode _loadAttributes in SummaryCollection, 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 eingefügt werden

Fertig! Jetzt können Sie die Magento-Installation im Browser starten und überprü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)

Aktualisieren Sie nun den Bildschirm, um zu bestätigen, dass der Name der Uhr in „Analog-Spanner ausrichten“ geändert wurde. wie über das Spanner-Terminal aktualisiert wird.

4. Glückwunsch

Sie haben das Katalogmodul von Magento so verbunden, dass es mit Spanner funktioniert. Es handelt sich nicht um eine vollständige Integration, aber Sie kennen jetzt die Elemente, die 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: