Questa pagina è stata tradotta dall'API Cloud Translation.

Ospita e scala un'app web in Google Cloud con Compute Engine

1. Introduzione

Esistono molti modi per eseguire il deployment di siti web in Google Cloud e ciascuna soluzione offre funzionalità, capacità e livelli di controllo diversi. Compute Engine offre un livello profondo di controllo sull'infrastruttura utilizzata per eseguire un sito web, ma richiede anche un maggior impegno per la gestione operativa rispetto a soluzioni come Google Kubernetes Engine, App Engine o altre. Compute Engine offre un controllo granulare degli aspetti dell'infrastruttura, tra cui le macchine virtuali, il bilanciatore del carico e altro ancora. Oggi eseguirai il deployment di un'app di esempio, il sito web di e-commerce di Fancy Store, per mostrare come si può eseguire il deployment e scalare facilmente un sito web con Compute Engine.

Obiettivi didattici

Creare istanze di Compute Engine
Creare modelli di istanzeda istanze sorgente
Creare gruppi di istanze gestite
Come configurare i controlli di integrità e la riparazione automatica
Come creare il bilanciamento del carico HTTP(S)
Come creare controlli di integrità per i bilanciatori del carico
Utilizzare una rete CDN (Content Delivery Network) per la memorizzazione nella cache

Al termine del codelab, le istanze all'interno dei gruppi di istanze gestite ti forniranno riparazione automatica, bilanciamento del carico, scalabilità automatica e aggiornamenti in sequenza per il tuo sito web.

Prerequisiti

Per una panoramica introduttiva dei concetti utilizzati in questo lab, consulta il materiale riportato di seguito:
Ti diamo il benvenuto in Google Cloud Platform, la piattaforma Essentials di Google Cloud
Introduzione a Google Cloud Compute Engine
Introduzione a Google Cloud Storage
Per iniziare: Cloud Shell

2. Configurazione dell'ambiente

Configurazione dell'ambiente autogestito

Accedi alla console Cloud e crea un nuovo progetto o riutilizzane uno esistente. Se non hai ancora un account Gmail o Google Workspace, devi crearne uno.

Ricorda l'ID progetto, un nome univoco in tutti i progetti Google Cloud (il nome precedente è già stato utilizzato e non funzionerà correttamente). Verrà indicato più avanti in questo codelab come PROJECT_ID.

Successivamente, dovrai abilitare la fatturazione in Cloud Console per utilizzare le risorse Google Cloud.

Eseguire questo codelab non dovrebbe costare molto. Assicurati di seguire le istruzioni nella sezione "Pulizia" in cui viene spiegato come arrestare le risorse in modo da non incorrere in fatturazione oltre questo tutorial. I nuovi utenti di Google Cloud sono idonei al programma prova senza costi di 300$.

abilita l'API Compute Engine

Il passaggio successivo consiste nel abilitare l'API Compute Engine. L'abilitazione di un'API richiede l'accettazione dei Termini di servizio e la responsabilità di fatturazione per l'API.

In Cloud Shell, esegui il comando riportato di seguito per abilitare l'API Compute Engine:

gcloud services enable compute.googleapis.com

Cloud Shell

Mentre Google Cloud può essere utilizzato da remoto dal tuo laptop, in questo codelab utilizzerai Cloud Shell, un ambiente a riga di comando in esecuzione nel cloud.

Questa macchina virtuale basata su Debian viene caricata con tutti gli strumenti di sviluppo necessari. Offre una home directory permanente da 5 GB e viene eseguita in Google Cloud, migliorando notevolmente le prestazioni di rete e l'autenticazione. Ciò significa che per questo codelab è sufficiente un browser (sì, funziona su Chromebook).

Per attivare Cloud Shell dalla console Cloud, fai semplicemente clic su Attiva Cloud Shell (il provisioning e la connessione all'ambiente dovrebbero richiedere solo pochi minuti).

Screen Shot 2017-06-14 at 10.13.43 PM.png

Dopo la connessione a Cloud Shell, dovresti vedere che hai già eseguito l'autenticazione e che il progetto è già impostato su PROJECT_ID.

gcloud auth list

Output comando

Credentialed accounts:
 - <myaccount>@<mydomain>.com (active)

gcloud config list project

Output comando

[core]
project = <PROJECT_ID>

Se, per qualche motivo, il progetto non è impostato, invia semplicemente il seguente comando:

gcloud config set project <PROJECT_ID>

Stai cercando il tuo PROJECT_ID? Controlla l'ID utilizzato nei passaggi di configurazione o cercalo nella dashboard della console Cloud:

Cloud Shell imposta anche alcune variabili di ambiente per impostazione predefinita, cosa che può essere utile quando eseguirai comandi futuri.

echo $GOOGLE_CLOUD_PROJECT

Output comando

<PROJECT_ID>

Infine, imposta la zona e la configurazione del progetto predefinite.

gcloud config set compute/zone us-central1-f

Puoi scegliere zone diverse. Per ulteriori informazioni, consulta Regioni e Zone.

crea un bucket Cloud Storage

Utilizzeremo un bucket Cloud Storage per ospitare il codice che crei e i nostri script di avvio. In Cloud Shell, esegui questo comando per creare un nuovo bucket Cloud Storage:

gsutil mb gs://fancy-store-$DEVSHELL_PROJECT_ID

3. clona il repository di codice sorgente

Utilizzerai il sito web di e-commerce esistente di Fancy Store basato sul repository monolith-to-microservices come base per il tuo sito web. Clonerai il codice sorgente dal tuo repository per concentrarti sugli aspetti del deployment in Compute Engine. In seguito, eseguirai un piccolo aggiornamento del codice per dimostrare la semplicità degli aggiornamenti in Compute Engine.

Puoi clonare automaticamente il repository di codice nel progetto, nonché aprire Cloud Shell e l'editor di codice integrato tramite il seguente link: Apri in Cloud Shell.

In alternativa, puoi clonare manualmente il repository con i comandi seguenti all'interno di Cloud Shell:

cd ~
git clone https://github.com/googlecodelabs/monolith-to-microservices.git
cd ~/monolith-to-microservices

Nel prompt dei comandi di Cloud Shell, esegui la build iniziale del codice per consentire l'esecuzione in locale dell'app. L'esecuzione dello script potrebbe richiedere alcuni minuti.

./setup.sh

Fai la tua due diligence e testa la tua app. Esegui questo comando per avviare il server web:

cd microservices
npm start

Output:

Products microservice listening on port 8082!
Frontend microservice listening on port 8080!
Orders microservice listening on port 8081!

Visualizza l'anteprima dell'app facendo clic sull'icona dell'anteprima web e selezionando "Anteprima sulla porta 8080".

Dovrebbe aprirsi una nuova finestra in cui puoi vedere il frontend di Fancy Store in azione.

Puoi chiudere questa finestra dopo aver visualizzato il sito web. Per interrompere il processo del server web, premi Control+C (Command+C su Macintosh) nella finestra del terminale.

4. crea istanze di Compute Engine

Ora che il tuo ambiente di sviluppo è pronto, puoi eseguire il deployment di alcune istanze di Compute Engine. Nei seguenti passaggi potrai:

Creare uno script di avvio per configurare le istanze.
Clonare il codice sorgente e caricarlo in Cloud Storage.
Eseguire il deployment di un'istanza di Compute Engine per ospitare i microservizi di backend.
Riconfigurare il codice del frontend in modo che utilizzi l'istanza dei microservizi di backend.
Eseguire il deployment di un'istanza di Compute Engine per ospitare il microservizio del frontend.
Configurare la rete per consentire la comunicazione.

Crea script di avvio

Lo script di avvio serve a comunicare all'istanza le operazioni da eseguire ogni volta che viene avviata. In questo modo le istanze vengono configurate automaticamente.

Fai clic sull'icona a forma di matita nella barra laterale di Cloud Shell per aprire l'editor di codice.

Vai alla cartella monolith-to-microservices. Fai clic su File > Nuovo file e crea un file denominato startup-script.sh.

Nel nuovo file, incolla il seguente codice, che verrà modificato dopo averlo incollato:

#!/bin/bash

# Install logging monitor. The monitor will automatically pick up logs sent to
# syslog.
curl -s "https://storage.googleapis.com/signals-agents/logging/google-fluentd-install.sh" | bash
service google-fluentd restart &

# Install dependencies from apt
apt-get update
apt-get install -yq ca-certificates git build-essential supervisor psmisc

# Install nodejs
mkdir /opt/nodejs
curl https://nodejs.org/dist/v8.12.0/node-v8.12.0-linux-x64.tar.gz | tar xvzf - -C /opt/nodejs --strip-components=1
ln -s /opt/nodejs/bin/node /usr/bin/node
ln -s /opt/nodejs/bin/npm /usr/bin/npm

# Get the application source code from the Google Cloud Storage bucket.
mkdir /fancy-store
gsutil -m cp -r gs://fancy-store-[DEVSHELL_PROJECT_ID]/monolith-to-microservices/microservices/* /fancy-store/

# Install app dependencies.
cd /fancy-store/
npm install

# Create a nodeapp user. The application will run as this user.
useradd -m -d /home/nodeapp nodeapp
chown -R nodeapp:nodeapp /opt/app

# Configure supervisor to run the node app.
cat >/etc/supervisor/conf.d/node-app.conf << EOF
[program:nodeapp]
directory=/fancy-store
command=npm start
autostart=true
autorestart=true
user=nodeapp
environment=HOME="/home/nodeapp",USER="nodeapp",NODE_ENV="production"
stdout_logfile=syslog
stderr_logfile=syslog
EOF

supervisorctl reread
supervisorctl update

Ora, nell'editor di codice, trova il testo [DEVSHELL_PROJECT_ID] e sostituiscilo con l'output del comando seguente:

echo $DEVSHELL_PROJECT_ID

Output di esempio:

my-gce-codelab-253520

La riga di codice in startup-script.sh ora dovrebbe essere simile alla seguente:

gs://fancy-store-my-gce-codelab-253520/monolith-to-microservices/microservices/* /fancy-store/

Lo script di avvio esegue queste attività:

Installazione dell'agente Logging, che raccoglie automaticamente i log da syslog
Installazione di Node.js e Supervisor, che esegue l’app come daemon
Clonazione del codice sorgente dell'app dal bucket Cloud Storage e installazione delle dipendenze
La configurazione di Supervisor, che esegue l'app, assicura che l'app venga riavviata se si chiude inaspettatamente o viene arrestata da un amministratore o da un processo e invia lo stdout e lo stderr dell'app a syslog affinché l'agente Logging raccolga

Ora copia il file startup-script.sh creato nel bucket Cloud Storage creato in precedenza:

gsutil cp ~/monolith-to-microservices/startup-script.sh gs://fancy-store-$DEVSHELL_PROJECT_ID

Il file è ora accessibile all'indirizzo https://storage.googleapis.com/[BUCKET_NAME]/startup-script.sh. [BUCKET_NAME] rappresenta il nome del bucket Cloud Storage. Sarà visualizzabile solo dagli utenti autorizzati e dagli account di servizio per impostazione predefinita, quindi non sarà accessibile tramite un browser web. Le istanze di Compute Engine saranno automaticamente in grado di accedervi tramite i propri account di servizio.

Copia il codice nel bucket di Cloud Storage

Quando vengono lanciate, le istanze eseguono il pull del codice dal bucket Cloud Storage, così puoi archiviare alcune variabili di configurazione nel file ".env" del codice.

Copia il codice clonato nel bucket Cloud Storage:

cd ~
rm -rf monolith-to-microservices/*/node_modules
gsutil -m cp -r monolith-to-microservices gs://fancy-store-$DEVSHELL_PROJECT_ID/

Esegui il deployment dell'istanza del backend

La prima istanza di cui eseguirai il deployment sarà l'istanza di backend, che ospiterà i microservizi degli ordini e dei prodotti.

Esegui questo comando in Cloud Shell per creare un'istanza f1-micro configurata per utilizzare lo script di avvio creato in precedenza e contrassegnata come istanza di backend, in modo da poter applicare regole firewall specifiche in un secondo momento:

gcloud compute instances create backend \
    --machine-type=f1-micro \
    --image=debian-9-stretch-v20190905 \
    --image-project=debian-cloud \
    --tags=backend \
    --metadata=startup-script-url=https://storage.googleapis.com/fancy-store-$DEVSHELL_PROJECT_ID/startup-script.sh

Configura la connessione al backend

Prima di eseguire il deployment del frontend dell'app, devi aggiornare la configurazione in modo che punti al backend di cui hai eseguito il deployment.

Recupera l'indirizzo IP esterno del backend, che può essere visualizzato dal comando seguente nella scheda EXTERNAL_IP per l'istanza di backend:

gcloud compute instances list

Output di esempio:

NAME     ZONE           MACHINE_TYPE  PREEMPTIBLE  INTERNAL_IP  EXTERNAL_IP   STATUS
backend  us-central1-a  f1-micro                   10.128.0.2   34.68.223.88  RUNNING

Nell'editor di codice di Cloud Shell, vai alla cartella monolith-to-microservices > react-app. Dal menu dell'editor di codice, seleziona Visualizza > Attiva/disattiva File nascosti per visualizzare il file .env.

Modifica il file .env in modo che punti all'indirizzo IP esterno del backend. [BACKEND_ADDRESS] di seguito rappresenta l'indirizzo IP esterno dell'istanza di backend determinato dal comando precedente nello strumento gcloud.

REACT_APP_ORDERS_URL=http://[BACKEND_ADDRESS]:8081/api/orders
REACT_APP_PRODUCTS_URL=http://[BACKEND_ADDRESS]:8082/api/products

Salva il file.

Usa il seguente comando per ricreare la build di reazione-app, che aggiornerà il codice del frontend:

cd ~/monolith-to-microservices/react-app
npm install && npm run-script build

Copia il codice dell'app nel bucket Cloud Storage:

cd ~
rm -rf monolith-to-microservices/*/node_modules
gsutil -m cp -r monolith-to-microservices gs://fancy-store-$DEVSHELL_PROJECT_ID/

Esegui il deployment dell'istanza del frontend

Ora che il codice è stato configurato, puoi eseguire il deployment dell'istanza di frontend. Esegui quanto segue per eseguire il deployment dell'istanza di frontend con un comando simile a prima, ma questa istanza è taggata come "frontend" ai fini del firewall.

gcloud compute instances create frontend \
    --machine-type=f1-micro \
    --image=debian-9-stretch-v20190905 \
    --image-project=debian-cloud \
    --tags=frontend \
    --metadata=startup-script-url=https://storage.googleapis.com/fancy-store-$DEVSHELL_PROJECT_ID/startup-script.sh

Configura la rete

Crea le regole del firewall per consentire l'accesso alla porta 8080 per il frontend e alle porte 8081 e 8082 per il backend. I comandi firewall utilizzano i tag assegnati durante la creazione dell'istanza per l'app.

gcloud compute firewall-rules create fw-fe \
    --allow tcp:8080 \
    --target-tags=frontend

gcloud compute firewall-rules create fw-be \
    --allow tcp:8081-8082 \
    --target-tags=backend

A questo punto il sito web dovrebbe essere funzionante. Determina l'indirizzo IP esterno del frontend. L'indirizzo può essere determinato cercando l'EXTERNAL_IP dell'istanza di frontend:

gcloud compute instances list

Output di esempio:

NAME      ZONE           MACHINE_TYPE  PREEMPTIBLE  INTERNAL_IP  EXTERNAL_IP      STATUS
backend   us-central1-a  f1-micro                   10.128.0.2   104.198.235.171  RUNNING
frontend  us-central1-a  f1-micro                   10.128.0.3   34.69.141.9      RUNNING

L'avvio e la configurazione dell'istanza potrebbero richiedere qualche minuto. Per monitorare l'idoneità dell'app, esegui le operazioni seguenti:

watch -n 5 curl http://[EXTERNAL_IP]:8080

Quando vedi un output simile al seguente, il sito web dovrebbe essere pronto. Premi Control+C (Command+C su Macintosh) al prompt dei comandi per annullare il comando watch.

Passa all'indirizzo http://[FRONTEND_ADDRESS]:8080 con una nuova scheda del browser web per accedere al sito web, dove [FRONTEND_ADDRESS] corrisponde all'EXTERNAL_IP determinato sopra.

Prova ad andare alle pagine Products e Orders, che dovrebbero funzionare.

5. crea gruppi di istanze gestite

Per consentire la scalabilità dell'applicazione, verranno creati gruppi di istanze gestite che utilizzeranno le istanze di frontend e di backend come modelli di istanza.

Un gruppo di istanze gestite contiene istanze identiche che puoi gestire come entità singole in zone singole. I gruppi di istanze gestite assicurano l'alta disponibilità delle app agendo proattivamente per far sì che le istanze siano disponibili, ossia che il loro stato sia IN ESECUZIONE. Utilizzerai i gruppi di istanze gestite per consentire alle istanze di frontend e backend di fornire riparazione automatica, bilanciamento del carico, scalabilità automatica e aggiornamenti in sequenza.

Crea il modello di istanza dall'istanza di origine

Prima di poter creare un gruppo di istanze gestite, devi creare un modello di istanza che costituirà la base per il gruppo. I modelli di istanza consentono di definire il tipo di macchina, l'immagine del disco di avvio o l'immagine del container, la rete e altre proprietà dell'istanza da utilizzare quando si creano nuove istanze di macchine virtuali (VM). Puoi utilizzare i modelli di istanza per creare le istanze di un gruppo di istanze gestite o anche per creare singole istanze.

Per creare un modello di istanza, utilizza le istanze esistenti che hai creato.

Innanzitutto, devi arrestare entrambe le istanze.

gcloud compute instances stop frontend

gcloud compute instances stop backend

Ora crea il modello di istanza dalle istanze di origine.

gcloud compute instance-templates create fancy-fe \
    --source-instance=frontend

gcloud compute instance-templates create fancy-be \
    --source-instance=backend

Verifica che i modelli di istanza siano stati creati:

gcloud compute instance-templates list

Output di esempio:

NAME      MACHINE_TYPE  PREEMPTIBLE  CREATION_TIMESTAMP
fancy-be  f1-micro                   2019-09-12T07:52:57.544-07:00
fancy-fe  f1-micro                   2019-09-12T07:52:48.238-07:00

Crea un gruppo di istanze gestite

Creerai due gruppi di istanze gestite, uno per il frontend e uno per il backend. Questi gruppi di istanze gestite utilizzeranno i modelli di istanza creati in precedenza e saranno configurati in modo che vengano avviate due istanze in ogni gruppo. Le istanze verranno denominate automaticamente in base al valore "base-instance-name" specificato con l'aggiunta di caratteri casuali.

gcloud compute instance-groups managed create fancy-fe-mig \
    --base-instance-name fancy-fe \
    --size 2 \
    --template fancy-fe

gcloud compute instance-groups managed create fancy-be-mig \
    --base-instance-name fancy-be \
    --size 2 \
    --template fancy-be

Per la tua applicazione, il microservizio frontend viene eseguito sulla porta 8080, mentre i microservizi di backend vengono eseguiti sulla porta 8081 per gli ordini e sulla porta 8082 per i prodotti. Dato che si tratta di porte non standard, devi specificare le porte denominate per identificarle. Le porte denominate sono metadati costituiti da coppie chiave:valore che rappresentano il nome del servizio e la porta su cui è eseguito. Le porte denominate possono essere assegnate a un gruppo di istanze, per indicare che il servizio è disponibile su tutte le istanze del gruppo. Queste informazioni vengono utilizzate dal bilanciatore del carico, che configurerai in seguito.

gcloud compute instance-groups set-named-ports fancy-fe-mig \ 
    --named-ports frontend:8080

gcloud compute instance-groups set-named-ports fancy-be-mig \
    --named-ports orders:8081,products:8082

Configura la riparazione automatica

Per migliorare la disponibilità dell'app stessa e verificare che risponda, puoi configurare un criterio di riparazione automatica per i gruppi di istanze gestite.

Un criterio di riparazione automatica si basa su un controllo di integrità basato sull'app per verificare che un'app risponda come previsto. Verificare che un'app risponda offre un controllo più preciso rispetto alla semplice verifica che l'istanza sia nello stato IN ESECUZIONE, che è il comportamento predefinito.

Crea un controllo di integrità che ripari l'istanza se restituisce uno stato non integro per tre volte consecutive per il frontend e il backend:

gcloud compute health-checks create http fancy-fe-hc \
    --port 8080 \
    --check-interval 30s \
    --healthy-threshold 1 \
    --timeout 10s \
    --unhealthy-threshold 3

gcloud compute health-checks create http fancy-be-hc \
    --port 8081 \
    --request-path=/api/orders \
    --check-interval 30s \
    --healthy-threshold 1 \
    --timeout 10s \
    --unhealthy-threshold 3

Crea una regola firewall per consentire ai probe del controllo di integrità di connettersi ai microservizi sulle porte 8080 e 8081:

gcloud compute firewall-rules create allow-health-check \
    --allow tcp:8080-8081 \
    --source-ranges 130.211.0.0/22,35.191.0.0/16 \
    --network default

Applica i controlli di integrità ai rispettivi servizi:

gcloud compute instance-groups managed update fancy-fe-mig \
    --health-check fancy-fe-hc \
    --initial-delay 300

gcloud compute instance-groups managed update fancy-be-mig \
    --health-check fancy-be-hc \
    --initial-delay 300

Continua con il codelab per consentire alla riparazione automatica di monitorare le istanze del gruppo. In seguito, simulerai un errore per testare la riparazione automatica.

6. Crea bilanciatore del carico

Per integrare i nostri gruppi di istanze gestite, utilizzerai il bilanciamento del carico HTTP(S) per gestire il traffico verso i microservizi di frontend e backend e le mappature per inviare il traffico ai servizi di backend appropriati in base alle regole di percorso. Ciò esporrà un singolo indirizzo IP con bilanciamento del carico per tutti i servizi.

Per saperne di più sulle opzioni di bilanciamento del carico disponibili in Google Cloud, consulta Panoramica del bilanciamento del carico.

Crea bilanciamento del carico HTTP(S)

Google Cloud offre molti tipi diversi di bilanciamento del carico, ma per il traffico utilizzerai il bilanciamento del carico HTTP(S). Il bilanciamento del carico HTTP(S) è strutturato come segue:

Una regola di forwarding indirizza le richieste in arrivo a un Proxy HTTP di destinazione.
Il Proxy HTTP di destinazione controlla ogni richiesta a fronte di una mappa di URL per determinare il servizio di backend appropriato per la richiesta.
Il servizio di backend indirizza ogni richiesta a un backend appropriato in base alla capacità di servizio, alla zona e all'integrità dell'istanza dei backend che gli sono collegati. L'integrità di ciascuna istanza di backend viene verificata utilizzando un controllo di integrità HTTP. Se il servizio di backend è configurato in modo da utilizzare un controllo di integrità HTTPS o HTTP/2, la richiesta verrà criptata quando viene inviata all'istanza di backend.
Le sessioni tra il bilanciatore del carico e l'istanza possono utilizzare il protocollo HTTP, HTTPS o HTTP/2. Se utilizzi HTTPS o HTTP/2, ogni istanza dei servizi di backend deve avere un certificato SSL.

Crea i controlli di integrità che verranno utilizzati per determinare quali istanze sono in grado di gestire il traffico per ciascun servizio.

gcloud compute http-health-checks create fancy-fe-frontend-hc \
  --request-path / \
  --port 8080

gcloud compute http-health-checks create fancy-be-orders-hc \
  --request-path /api/orders \
  --port 8081

gcloud compute http-health-checks create fancy-be-products-hc \
  --request-path /api/products \
  --port 8082

Crea i servizi di backend corrispondenti alla destinazione del traffico con bilanciamento del carico. I servizi di backend utilizzeranno i controlli di integrità e le porte denominate che hai creato.

gcloud compute backend-services create fancy-fe-frontend \
  --http-health-checks fancy-fe-frontend-hc \
  --port-name frontend \
  --global

gcloud compute backend-services create fancy-be-orders \
  --http-health-checks fancy-be-orders-hc \
  --port-name orders \
  --global

gcloud compute backend-services create fancy-be-products \
  --http-health-checks fancy-be-products-hc \
  --port-name products \
  --global

Aggiungi i servizi di backend.

gcloud compute backend-services add-backend fancy-fe-frontend \
  --instance-group fancy-fe-mig \
  --instance-group-zone us-central1-f \
  --global

gcloud compute backend-services add-backend fancy-be-orders \
  --instance-group fancy-be-mig \
  --instance-group-zone us-central1-f \
  --global

gcloud compute backend-services add-backend fancy-be-products \
  --instance-group fancy-be-mig \
  --instance-group-zone us-central1-f \
  --global

Crea una mappa URL. La mappa URL stabilisce quali URL sono indirizzati a quali servizi di backend.

gcloud compute url-maps create fancy-map \
  --default-service fancy-fe-frontend

Crea un matcher di percorso per consentire l'instradamento dei percorsi /api/orders e /api/products ai rispettivi servizi.

gcloud compute url-maps add-path-matcher fancy-map \
   --default-service fancy-fe-frontend \
   --path-matcher-name orders \
   --path-rules "/api/orders=fancy-be-orders,/api/products=fancy-be-products"

Crea il proxy collegato alla mappa URL creata.

gcloud compute target-http-proxies create fancy-proxy \
  --url-map fancy-map

Creare una regola di forwarding globale che colleghi un indirizzo IP pubblico e una porta al proxy.

gcloud compute forwarding-rules create fancy-http-rule \
  --global \
  --target-http-proxy fancy-proxy \
  --ports 80

Aggiorna configurazione

Ora che hai un nuovo indirizzo IP statico, devi aggiornare il codice sul frontend in modo che punti al nuovo indirizzo anziché all'indirizzo temporaneo utilizzato in precedenza, che puntava all'istanza di backend.

In Cloud Shell, passa alla cartella reCAPTCHA-app, che contiene il file .env che contiene la configurazione.

cd ~/monolith-to-microservices/react-app/

Trova l'indirizzo IP del bilanciatore del carico:

gcloud compute forwarding-rules list --global

Output di esempio:

NAME                    REGION  IP_ADDRESS     IP_PROTOCOL  TARGET
fancy-http-rule          34.102.237.51  TCP          fancy-proxy

Modifica il file .env con il tuo editor di testo preferito (ad esempio GNU nano) in modo che punti all'indirizzo IP pubblico del bilanciatore del carico. [LB_IP] rappresenta l'indirizzo IP esterno dell'istanza di backend.

REACT_APP_ORDERS_URL=http://[LB_IP]/api/orders
REACT_APP_PRODUCTS_URL=http://[LB_IP]/api/products

Ricrea la build di reazione-app, che aggiornerà il codice del frontend.

cd ~/monolith-to-microservices/react-app
npm install && npm run-script build

Copia il codice dell'applicazione nel bucket GCS.

cd ~
rm -rf monolith-to-microservices/*/node_modules
gsutil -m cp -r monolith-to-microservices gs://fancy-store-$DEVSHELL_PROJECT_ID/

Aggiorna le istanze di frontend

Ora vuoi che le istanze di frontend del gruppo di istanze gestite eseguano il pull del nuovo codice. Le tue istanze eseguono il pull del codice all'avvio, quindi puoi inviare un comando di riavvio in sequenza.

gcloud compute instance-groups managed rolling-action restart fancy-fe-mig \
    --max-unavailable 100%

Testa il sito web

Attendi circa 30 secondi dopo l'invio del comando rolling-action replace per concedere alle istanze il tempo di essere elaborate. Quindi, controlla lo stato del gruppo di istanze gestite fino a quando le istanze non vengono visualizzate nell'elenco.

watch -n 5 gcloud compute instance-groups list-instances fancy-fe-mig

Una volta visualizzati gli elementi nell'elenco, esci dal comando watch premendo Control+C (Command+C su Macintosh).

Verifica che il servizio sia elencato come integro.

watch -n 5 gcloud compute backend-services get-health fancy-fe-frontend --global

Output di esempio:

---
backend: https://www.googleapis.com/compute/v1/projects/my-gce-codelab/zones/us-central1-a/instanceGroups/fancy-fe-mig
status:
  healthStatus:
  - healthState: HEALTHY
    instance: https://www.googleapis.com/compute/v1/projects/my-gce-codelab/zones/us-central1-a/instances/fancy-fe-x151
    ipAddress: 10.128.0.7
    port: 8080
  - healthState: HEALTHY
    instance: https://www.googleapis.com/compute/v1/projects/my-gce-codelab/zones/us-central1-a/instances/fancy-fe-cgrt
    ipAddress: 10.128.0.11
    port: 8080
  kind: compute#backendServiceGroupHealth

Quando gli elementi vengono visualizzati nell'elenco, esci dal comando watch premendo Control+C (Command+C su Macintosh).

L'applicazione sarà quindi accessibile tramite http://[LB_IP], dove [LB_IP] è l'IP_ADDRESS specificato per il bilanciatore del carico, che puoi trovare con il seguente comando:

gcloud compute forwarding-rules list --global

7. gestisci la scalabilità in Compute Engine

Finora hai creato due gruppi di istanze gestite, ciascuno con due istanze. La configurazione è completamente funzionale, ma è una configurazione statica indipendentemente dal carico. Ora creerai un criterio di scalabilità automatica basato sull'utilizzo per scalare automaticamente ciascun gruppo di istanze gestite.

Ridimensiona automaticamente in base all'utilizzo

Per creare il criterio di scalabilità automatica, esegui questi comandi in Cloud Shell. Creerà un gestore della scalabilità automatica sui gruppi di istanze gestite che aggiunge automaticamente le istanze quando il bilanciatore del carico supera il 60% di utilizzo e le rimuove quando il bilanciatore del carico ha un utilizzo inferiore al 60%.

gcloud compute instance-groups managed set-autoscaling \
  fancy-fe-mig \
  --max-num-replicas 5 \
  --target-load-balancing-utilization 0.60

gcloud compute instance-groups managed set-autoscaling \
  fancy-be-mig \
  --max-num-replicas 5 \
  --target-load-balancing-utilization 0.60

Abilita rete CDN (Content Delivery Network)

Un'altra funzionalità che può essere utile per la scalabilità è l'abilitazione di Cloud CDN, un servizio di rete CDN (Content Delivery Network), per fornire funzionalità di memorizzazione nella cache per il servizio frontend. Per farlo, puoi eseguire questo comando sul tuo servizio frontend:

gcloud compute backend-services update fancy-fe-frontend \
    --enable-cdn --global

Ora, quando un utente richiede contenuti dal bilanciatore del carico, la richiesta arriva a un frontend Google, che prima cerca una risposta alla richiesta dell'utente nella cache di Cloud CDN. Se il frontend trova una risposta memorizzata nella cache, la invia all'utente. In tal caso si parla di successo della cache.

Altrimenti, se il frontend non riesce a trovare una risposta memorizzata nella cache per la richiesta, invia una richiesta direttamente al backend. Se la risposta alla richiesta può essere memorizzata nella cache, il frontend la archivia nella cache di Cloud CDN, in modo che possa essere utilizzata per richieste successive.

8. Aggiorna sito web

Aggiorna il modello di istanza

I modelli di istanza esistenti non sono modificabili. Tuttavia, poiché le tue istanze sono stateless e tutta la configurazione viene eseguita tramite lo script di avvio, devi modificare il modello di istanza solo se vuoi cambiare l'immagine principale delle impostazioni del modello. Ora apporterai una semplice modifica per utilizzare un tipo di macchina più grande e distribuirla.

Aggiornare l'istanza di frontend, che funge da base per il modello di istanza. Durante l'aggiornamento, metterai un file nella versione aggiornata dell'immagine del modello di istanza, quindi aggiornerai il modello di istanza, implementerai il nuovo modello e confermerai che il file esiste nelle istanze del gruppo di istanze gestite.

Puoi modificare il tipo di macchina del tuo modello di istanza passando dal tipo di macchina standard f1-micro a un tipo di macchina personalizzata con 4 vCPU e 3840 MiB di RAM.

In Cloud Shell, esegui questo comando per modificare il tipo di macchina dell'istanza di frontend:

gcloud compute instances set-machine-type frontend --machine-type custom-4-3840

Crea il nuovo modello di istanza:

gcloud compute instance-templates create fancy-fe-new \
    --source-instance=frontend \
    --source-instance-zone=us-central1-a

Implementa il modello di istanza aggiornato nel gruppo di istanze gestite:

gcloud compute instance-groups managed rolling-action start-update fancy-fe-mig \
    --version template=fancy-fe-new

Monitora lo stato dell'aggiornamento:

watch -n 2 gcloud compute instance-groups managed list-instances fancy-fe-mig

Quando hai più di un'istanza con stato IN ESECUZIONE, ACTION impostato su None e INSTANCE_TEMPLATE come nuovo nome di modello (fancy-fe-new), copia il nome di una delle macchine elencate per utilizzarlo nel comando successivo.

Control+S (Command+S su Macintosh) per uscire dal processo di visualizzazione.

Esegui il comando seguente per vedere se la macchina virtuale utilizza il nuovo tipo di macchina (custom-4-3840), in cui [VM_NAME] è l'istanza appena creata:

gcloud compute instances describe [VM_NAME] | grep machineType

Output di esempio previsto:

machineType: https://www.googleapis.com/compute/v1/projects/project-name/zones/us-central1-f/machineTypes/custom-4-3840

apporta modifiche al sito web

Il tuo team di marketing ti ha chiesto di modificare la home page del sito. Secondo il team, dovrebbe essere più ricca di informazioni relative all'azienda e a ciò che commercializza. In questa sezione, potrai aggiungere del testo alla home page per soddisfare la richiesta del team di marketing. Uno dei tuoi sviluppatori ha già creato le modifiche con il nome del file index.js.new. Puoi copiare il file in index.js e le modifiche dovrebbero essere applicate. Segui le istruzioni riportate di seguito per applicare le modifiche appropriate.

Esegui questi comandi, copia il file aggiornato con il nome file corretto, quindi stampane il contenuto per verificare le modifiche:

cd ~/monolith-to-microservices/react-app/src/pages/Home
mv index.js.new index.js
cat ~/monolith-to-microservices/react-app/src/pages/Home/index.js

Il codice risultante dovrebbe avere l'aspetto seguente:

/*
Copyright 2019 Google LLC

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    https://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

import React from "react";
import { makeStyles } from "@material-ui/core/styles";
import Paper from "@material-ui/core/Paper";
import Typography from "@material-ui/core/Typography";
const useStyles = makeStyles(theme => ({
  root: {
    flexGrow: 1
  },
  paper: {
    width: "800px",
    margin: "0 auto",
    padding: theme.spacing(3, 2)
  }
}));
export default function Home() {
  const classes = useStyles();
  return (
    <div className={classes.root}>
      <Paper className={classes.paper}>
        <Typography variant="h5">
          Fancy Fashion &amp; Style Online
        </Typography>
        <br />
        <Typography variant="body1">
          Tired of mainstream fashion ideas, popular trends and societal norms?
          This line of lifestyle products will help you catch up with the Fancy trend and express your personal style.
          Start shopping Fancy items now!
        </Typography>
      </Paper>
    </div>
  );
}

Hai aggiornato i componenti React, ma devi creare la build dell'app React per generare i file statici. Esegui questo comando per creare la build dell'app React e copiarla nella directory pubblica del monolite:

cd ~/monolith-to-microservices/react-app
npm install && npm run-script build

Quindi, esegui nuovamente il push del codice al bucket Cloud Storage.

cd ~
rm -rf monolith-to-microservices/*/node_modules
gsutil -m cp -r monolith-to-microservices gs://fancy-store-$DEVSHELL_PROJECT_ID/

Esegui il push delle modifiche con aggiornamenti in sequenza

Ora puoi forzare il riavvio di tutte le istanze per eseguire il pull dell'aggiornamento.

gcloud compute instance-groups managed rolling-action restart fancy-fe-mig \
    --max-unavailable=100%

Attendi circa 30 secondi dopo l'emissione del comando di riavvio dell'azione in sequenza per concedere alle istanze il tempo di essere elaborate, quindi controlla lo stato del gruppo di istanze gestite fino a quando le istanze non vengono visualizzate nell'elenco.

watch -n 5 gcloud compute instance-groups list-instances fancy-fe-mig

Quando gli elementi vengono visualizzati nell'elenco, esci dal comando watch premendo Control+S (Command+S su Macintosh).

Esegui il comando riportato di seguito per confermare che il servizio sia contrassegnato come integro:

watch -n 5 gcloud compute backend-services get-health fancy-fe-frontend --global

Output di esempio:

---
backend: https://www.googleapis.com/compute/v1/projects/my-gce-codelab/zones/us-central1-a/instanceGroups/fancy-fe-mig
status:
  healthStatus:
  - healthState: HEALTHY
    instance: https://www.googleapis.com/compute/v1/projects/my-gce-codelab/zones/us-central1-a/instances/fancy-fe-x151
    ipAddress: 10.128.0.7
    port: 8080
  - healthState: HEALTHY
    instance: https://www.googleapis.com/compute/v1/projects/my-gce-codelab/zones/us-central1-a/instances/fancy-fe-cgrt
    ipAddress: 10.128.0.11
    port: 8080
  kind: compute#backendServiceGroupHealth

Una volta visualizzati gli elementi nell'elenco, esci dal comando watch premendo Control+S (Command+S su Macintosh).

Per invalidare i contenuti memorizzati nella cache all'interno della rete di distribuzione dei contenuti e garantire la visualizzazione dei contenuti aggiornati, esegui il comando seguente:

gcloud compute url-maps invalidate-cdn-cache fancy-map \
    --path "/*"

Vai al sito web tramite http://[LB_IP] dove [LB_IP] è l'IP_ADDRESS specificato per il bilanciatore del carico, che puoi trovare con il seguente comando:

gcloud compute forwarding-rules list --global

Le modifiche apportate al nuovo sito web ora dovrebbero essere visibili.

Simula un errore

Per confermare che il controllo di integrità funziona, accedi a un'istanza e interrompi i servizi. Per trovare il nome di un'istanza, esegui il comando seguente:

gcloud compute instance-groups list-instances fancy-fe-mig

Da qui, Secure Shell in una delle istanze, dove INSTANCE_NAME è una delle istanze elencate.

gcloud compute ssh [INSTANCE_NAME]

In questo caso, utilizza supervisorctl per arrestare l'app.

sudo supervisorctl stop nodeapp; sudo killall node

Esci dall'istanza.

exit

Monitora le operazioni di riparazione.

watch -n 5 gcloud compute operations list \
--filter='operationType~compute.instances.repair.*'

Cerca il seguente output di esempio:

NAME                                                  TYPE                                       TARGET                                 HTTP_STATUS  STATUS  TIMESTAMP
repair-1568314034627-5925f90ee238d-fe645bf0-7becce15  compute.instances.repair.recreateInstance  us-central1-a/instances/fancy-fe-1vqq  200          DONE    2019-09-12T11:47:14.627-07:00

Una volta rilevata la riparazione, Control+C (Command+S su Macintosh) per uscire dal comando watch. A questo punto, il gruppo di istanze gestite ricrea l'istanza per ripararla.

9. Esegui la pulizia

Quando è tutto pronto, il modo più semplice per ripulire tutte le attività eseguite è eliminare il progetto. L'eliminazione del progetto comporta l'eliminazione del bilanciatore del carico, delle istanze, dei modelli e di altri elementi creati durante il codelab per garantire che non vengano addebitati costi ricorrenti imprevisti. Esegui quanto segue in Cloud Shell, dove PROJECT_ID è l'ID progetto completo, non solo il nome del progetto.

gcloud projects delete [PROJECT_ID]

Conferma l'eliminazione inserendo "Y" quando richiesto.

10. Complimenti!

Hai eseguito il deployment del sito web, lo hai reso scalabile e lo hai aggiornato su Compute Engine. Hai acquisito esperienza con Compute Engine, i gruppi di istanze gestite, il bilanciamento del carico e i controlli di integrità.