Integrazione di Magento con Cloud Spanner

1. Introduzione

Integrazione di Magento con un backend Cloud Spanner

Magento è una piattaforma di e-commerce open source basata su PHP molto diffusa che archivia i dati in MySQL.

Questo codelab è una prova concettuale per utilizzare Cloud Spanner anziché MySQL per il modulo Catalog. Questo è utile per chiunque sia interessato a integrare, testare ed eseguire il deployment di Magento o di altre applicazioni PHP con Spanner.

Spanner è il database completamente gestito, di livello aziendale, distribuito e coerente di Google Cloud che combina i vantaggi del modello di database relazionale con la scalabilità orizzontale non relazionale. È progettato per supportare implementazioni di elaborazione delle transazioni online globali, semantica SQL, scalabilità orizzontale ad alta affidabilità e coerenza transazionale. Spanner è in grado di gestire grandi volumi di dati. Il suo utilizzo non è limitato ad applicazioni di grandi dimensioni, ma consente la standardizzazione di un singolo motore del database per tutti i carichi di lavoro che richiedono RDBMS. Spanner offre zero tempi di inattività per la manutenzione pianificata o gli errori a livello di regione, con un SLA (accordo sul livello del servizio) di disponibilità del 99,999%. Supporta le applicazioni moderne fornendo alta affidabilità e scalabilità.

Obiettivi didattici

Come installare Magento su GCE
Come configurare l'emulatore Spanner
Come eseguire la migrazione di uno schema MySQL esistente a Spanner utilizzando HarbourBridge
Cosa devi modificare per integrare applicazioni PHP come Magento che utilizzano MySQL per il backend del database in modo che funzionino con Spanner

Cosa creerai

Questo codelab si concentra sull'integrazione di Magento con Spanner. I blocchi di codice e le istruzioni di configurazione sono forniti per essere copiati e incollati, ma non sono discussi in dettaglio.

In questo codelab, inizierai a integrare Magento con Spanner. Imparerai a:

Configura un'istanza GCE con Magento installato
Installa l'emulatore di Spanner
Installa lo strumento HarbourBridge per la migrazione dei dati da MySQL a Spanner
Modifica le raccolte Magento per caricare il catalogo dei prodotti da Spanner

Che cosa ti serve

Un progetto cloud Google Cloud collegato a un account di fatturazione.
La conoscenza della configurazione di PHP, Linux e Apache è un vantaggio.
L'esperienza con Magento sarà utile, ma non è obbligatoria.

2. Preparazione dell'istanza GCE

Crea l'istanza GCE

Crea un'istanza di Compute Engine in Google Cloud Platform seguendo i passaggi descritti qui.

Quando crei l'istanza GCE, modifica il tipo di istanza in e2-standard-2 e le dimensioni del disco di avvio in 20 GB. Puoi lasciare tutto come predefinito, ma assicurati di selezionare "Consenti traffico HTTP" e "Consenti traffico HTTPS", poiché utilizzeremo l'interfaccia web di Magento.

Il risultato è un tipo di macchina e2-standard-2 che non è un'istanza con core condiviso e ha 2 vCPU, 8 GB di RAM e 20 GB di spazio su disco.

Il sistema operativo è Debian 10. La creazione dell'istanza potrebbe richiedere un paio di minuti.

Una volta creato, accedi facendo clic su "SSH" nella console Cloud:

Si aprirà una nuova finestra del browser e verrà visualizzato un terminale.

Installare il software prerequisito

Prima di poter eseguire Magento, è necessario installare alcuni software prerequisiti. Nello specifico, installerai PHP, Elastic, MySQL e Apache come descritto di seguito.

Installa alcuni pacchetti richiesti.

sudo apt update

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

Installa i moduli PHP richiesti per Magento.

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

Installa Elasticsearch e avvia il servizio

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

Installare MySQL

Stai installando MySQL per installare lo schema Magento predefinito. In un secondo momento, eseguirai la migrazione dello schema a Spanner utilizzando HarbourBridge.

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

sudo dpkg -i mysql-apt-config*

Il comando dpkg riportato sopra visualizza una richiesta interattiva per installare il server MySQL 5.7. Seleziona le opzioni:

Server e cluster MySQL
mysql-5.7
OK

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

Installa Apache2

sudo apt -y install apache2

sudo a2enmod proxy_fcgi rewrite

Installa e configura Magento2

Il progetto Magento Commerce Cloud include uno schema di database e servizi per accedere completamente al sito e allo store Magento.

Il modo più semplice per installare ed eseguire questa operazione è seguire le istruzioni di Magento per l'installazione tramite Composer:

Installa Magento versione 2.4.2 utilizzando Composer. Magento 2 richiede la versione 1.x di Composer. Potresti visualizzare alcuni avvisi relativi al ritiro del supporto per questa versione.

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

Impostare le autorizzazioni per le cartelle

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 {} +

Configura l'host virtuale Magento creando /etc/apache2/sites-available/magento.conf con i contenuti riportati di seguito.

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>

Crea i link simbolici e riavvia apache2.

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

Crea il database e l'utente per Magento in MySQL

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

Verifica del workspace locale Per verificare che l'ambiente locale ospiti il server, accedi allo store utilizzando l'URL di base che hai inserito nel comando di installazione. Per questo esempio, puoi accedere al negozio Magento locale utilizzando i seguenti formati URL:

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

GCEexternalIP si trova nella console Google Cloud:

Per modificare l'URI del pannello di amministrazione, utilizza questo comando per individuarlo:

php bin/magento info:adminuri

Disattiva la cache della pagina intera Per scopi di sviluppo, puoi disattivare la cache della pagina intera di Magento2. In questo modo potrai modificare i dati in Spanner e visualizzarli sul sito web senza essere influenzato dai valori memorizzati nella cache.

php bin/magento cache:disable full_page

Configura Spanner

Installa l'emulatore Spanner

Cloud SDK fornisce un emulatore locale in memoria, che puoi utilizzare per sviluppare e testare le tue applicazioni senza costi senza creare un progetto GCP o un account di fatturazione. Poiché l'emulatore archivia i dati solo in memoria, tutto lo stato, inclusi dati, schema e configurazioni, viene perso al riavvio. L'emulatore offre le stesse API del servizio di produzione Spanner ed è destinato allo sviluppo e ai test locali, non alle implementazioni di produzione.

Utilizza il link riportato di seguito per ulteriori informazioni su installazione, utilizzo e deployment dell'emulatore:

Utilizzo dell'emulatore Spanner

# 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

Esegui la migrazione di Magento MySQL a Spanner

Prima di procedere con l'integrazione di Spanner, utilizzeremo uno strumento chiamato HarbourBridge per convertire in Spanner il database MySQL creato nell'ambito dell'installazione di Magento descritta sopra.

Nella sua essenza, HarbourBridge fornisce un flusso di lavoro automatizzato per caricare i contenuti di un database MySQL o PostgreSQL esistente in Spanner. Non richiede alcuna configurazione: non è necessario scrivere manifest o mappe dei dati. Importa invece il database di origine, crea uno schema Spanner, crea un nuovo database Spanner compilato con i dati del database di origine e genera un report di valutazione dettagliato. HarbourBridge è destinato al caricamento di database fino a qualche decina di GB a scopo di valutazione, non per migrazioni su larga scala.

HarbourBridge esegue il bootstrap della migrazione iniziale a Spanner utilizzando un database di origine MySQL o PostgreSQL esistente per consentirti di iniziare rapidamente a utilizzare Spanner. Genera un report di valutazione con un punteggio complessivo di idoneità alla migrazione per Spanner, un'analisi tabella per tabella dei mapping dei tipi e un elenco delle funzionalità utilizzate nel database di origine che non sono supportate da Spanner.

HarbourBridge può essere utilizzato con l'emulatore Spanner o direttamente con un'istanza Spanner.

Il file README di HarbourBridge contiene una guida rapida passo passo per l'utilizzo dello strumento con un'istanza Spanner.

Installa HarbourBridge

Scarica lo strumento sul tuo computer e installalo. Per il funzionamento, è necessario installare golang. L'installazione di tutti i moduli richiesti su una nuova istanza senza Go configurato in precedenza può richiedere un po' di tempo.

# 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

Eseguire la migrazione dei dati

Utilizza il seguente comando per eseguire la migrazione del database Magento in Spanner:

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

Configura lo strumento spanner-cli

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

3. Converti Magento per funzionare con Spanner

Ora che Magento è in esecuzione e l'istanza Spanner è stata creata con la migrazione del database Magento, lavoreremo alla modifica di Magento per utilizzare i dati archiviati in Spanner.

Per convertire l'installazione di Magento verranno eseguiti i seguenti passaggi:

Clona il progetto magento-spanner-port
Modificare la connessione a Spanner
Verifica che i dettagli del catalogo siano compilati da Spanner

Clona il fork del progetto Magento

Clona il codice dell'applicazione PHP per Magento che contiene le modifiche per i moduli Catalogo, Lista dei desideri e Carrello dall'URL Git indicato di seguito.

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

La tua home directory dovrebbe essere simile a questa:

$ ls
go  harbourbridge  magento-spanner-port  magento2

Dove magento2 è il codebase che modificheremo utilizzando il codice di magento-spanner-port.

Modificare la connessione a Spanner

Per verificare se le modifiche al codice si riflettono nell'interfaccia utente, possiamo seguire i passaggi riportati di seguito:

Per un'implementazione di esempio, consulta il link di GitHub https://github.com/searceinc/magento-spanner-port.

Richiedi la libreria client PHP google/cloud-spanner
Aggiungi l'adattatore Spanner per creare la connessione a Spanner.
Configura l'istanza Spanner e le informazioni sul server.
Aggiungi SpannerInterface e Spanner all'adattatore per implementare la connessione a Spanner.

Innanzitutto, dobbiamo installare la libreria PHP cloud-spanner utilizzando Composer. Nella directory magento2, esegui questo comando:

cd ~/magento2
composer require google/cloud-spanner

Poi aggiungiamo i file dell'adattatore Spanner da magento-spanner-port al nostro codebase magento2:

~/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

Ora modifica il file DB/Adapter/Spanner/Spanner.php per inserire le informazioni di connettività Spanner per $project_id, $instance e $database:

$ 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();
    }

Modifica la classe AbstractDB all'interno di Magento per connetterti a Spanner utilizzando la funzione di connessione appena creata all'interno di Spanner Adapter. Aggiungi le righe verdi dopo le righe bianche nel file. Consulta 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;
    }
...

Una volta stabilita la connessione, dobbiamo modificare il metodo di recupero dei dati dall'adattatore MySQL all'adattatore Spanner . Modifica il metodo _loadAttributes in AbstractCollection per connetterti a Spanner e recuperare i dati da Spanner. Sostituisci la linea rossa con le linee in verde.

Fai riferimento a /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);

...

Verifica che i dettagli del catalogo siano compilati da Spanner

È tutto. Ora puoi andare all'installazione di Magento nel browser e verificare che i dati vengano caricati.

Ad esempio, queste sono le voci di catalogo per gli smartwatch:

Modifica i dati di Spanner tramite il terminale per uno dei prodotti ed esegui query sui dati tramite il terminale per confermare la modifica in Spanner.

$ 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)

Ora ricarica la schermata per verificare che il nome dello smartwatch sia stato modificato in "Aim Analog Spanner" come aggiornato tramite il terminale Spanner.

4. Complimenti

Congratulazioni, hai collegato correttamente il modulo Catalog di Magento per funzionare con Spanner. Non si tratta di un'integrazione completa, ma ora conosci gli elementi per connettere un'applicazione PHP come Magento a un'istanza Spanner.

Pulizia

Una volta completata la configurazione e la convalida della prova di fattibilità, potresti voler eliminare le risorse GCP create durante la procedura. Ciò includerebbe la macchina virtuale Compute Engine, nonché un'istanza Cloud Spanner se hai deciso di utilizzarne una anziché l'emulatore.

Passaggi successivi

Questo è solo un modello prototipo per una POC di Spanner.

Se vuoi saperne di più su come lavorare con Spanner e sulle tecnologie che abbiamo utilizzato in questo codelab, ecco alcune risorse aggiuntive: