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

1. Introduzione

Esistono vari 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 consente di avere un controllo granulare degli aspetti dell'infrastruttura, tra cui le macchine virtuali, il bilanciatore del carico e così via. Oggi eseguirai il deployment di un'app di esempio, il sito web di e-commerce di Fancy Store, per mostrare come si può facilmente eseguire il deployment e gestire la scalabilità di 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 controlli di integrità e riparazione automatica
Creare il bilanciamento del carico HTTP(S)
Creare controlli di integrità per i bilanciatori del carico
Usare una rete CDN (Content Delivery Network) per la memorizzazione nella cache

Alla fine 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 che utilizzeremo in questo lab, consulta il materiale riportato di seguito:
Ti diamo il benvenuto in Google Cloud Platform - The Essentials of GCP
Guida introduttiva a Google Cloud Compute Engine
Guida introduttiva a Google Cloud Storage
Guida introduttiva: Cloud Shell

2. Configurazione dell'ambiente

Configurazione dell'ambiente autonomo

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 tra tutti i progetti Google Cloud (il nome sopra è già stato utilizzato e non funzionerà per te, mi dispiace). In questo codelab verrà chiamato PROJECT_ID.

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

L'esecuzione di questo codelab non dovrebbe costare molto, se non nulla. Assicurati di seguire le istruzioni riportate nella sezione "Pulizia", che ti consiglia come arrestare le risorse in modo da non incorrere in addebiti oltre questo tutorial. I nuovi utenti di Google Cloud possono beneficiare del programma prova senza costi di 300$.

Abilita l'API Compute Engine

A questo punto, devi abilitare l'API Compute Engine. L'abilitazione di un'API richiede l'accettazione dei termini di servizio e della responsabilità di fatturazione per l'API.

In Cloud Shell, esegui questo comando per abilitare l'API Compute Engine:

gcloud services enable compute.googleapis.com

Cloud Shell

Sebbene Google Cloud possa essere gestito 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 di cui avrai bisogno. Offre una home directory permanente da 5 GB e viene eseguita in Google Cloud, migliorando notevolmente le prestazioni e l'autenticazione della rete. Ciò significa che per questo codelab ti servirà solo un browser (sì, funziona su Chromebook).

Per attivare Cloud Shell dalla console Cloud, fai clic su Attiva Cloud Shell (bastano pochi istanti per eseguire il provisioning e connettersi all'ambiente).

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

Una volta eseguita la connessione a Cloud Shell, dovresti vedere che il tuo account è già autenticato e il progetto è già impostato sul tuo 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, esegui questo comando:

gcloud config set project <PROJECT_ID>

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

Cloud Shell imposta anche alcune variabili di ambiente per impostazione predefinita, che potrebbero essere utili quando esegui i 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 una serie di zone diverse. Per saperne di più, consulta Regioni e zone.

crea un bucket Cloud Storage

Utilizzeremo un bucket Cloud Storage per ospitare il codice che creiamo 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 Fancy Store esistente basato sul repository monolith-to-microservices come base per il tuo sito web. Clonerai il codice sorgente dal repository per concentrarti sugli aspetti del deployment in Compute Engine. Più avanti, eseguirai un piccolo aggiornamento del codice a dimostrazione di come sia semplice eseguire aggiornamenti su 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 riportati di seguito in Cloud Shell:

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

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

./setup.sh

Esegui la due diligence e testa l'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 in azione il frontend di Fancy Store.

Puoi chiudere questa finestra dopo aver visualizzato il sito web. Per arrestare 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 lo 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 > New File (Nuovo file) e crea un file denominato startup-script.sh.

Nel nuovo file, incolla il seguente codice, una parte del quale modificherai 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, individua 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
Configurazione di Supervisor, che esegue l'app, assicura che l'app venga riavviata se si chiude inaspettatamente o se viene interrotta da un amministratore o da un processo e invia lo stdout e lo stderr dell'app a syslog per la raccolta da parte dell'agente Logging

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

Ora è accessibile all'indirizzo https://storage.googleapis.com/[BUCKET_NAME]/startup-script.sh. [BUCKET_NAME] rappresenta il nome del bucket Cloud Storage. e sarà visualizzabile solo dagli utenti autorizzati e dai service account per impostazione predefinita e, pertanto, inaccessibile tramite browser web. Le istanze di Compute Engine saranno automaticamente in grado di accedere tramite i service account.

Copia il codice nel bucket di Cloud Storage

Quando vengono lanciate, le istanze eseguono il pull del codice dal bucket Cloud Storage, in modo da poter 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 eseguire il deployment sarà quella di backend, che ospiterà i microservizi Orders e Products.

Esegui questo comando in Cloud Shell per creare un'istanza f1-micro configurata per l'utilizzo dello script di avvio creato in precedenza e taggata 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 seguente comando nella scheda EXTERNAL_IP dell'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 determinata 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.

Utilizza questo comando per ricreare la build di react-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. Utilizza i comandi seguenti per eseguire il deployment dell'istanza di frontend con un comando simile a quello utilizzato in precedenza, 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 firewall necessarie 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

Il sito web ora dovrebbe essere funzionante. Determina l'indirizzo IP esterno del frontend. L'indirizzo può essere determinato cercando l'EXTERNAL_IP dell'istanza del 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. Esegui questo comando per monitorare la preparazione dell'app:

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.

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

Prova ad andare alle pagine Prodotti e Ordini, che dovrebbero funzionare.

5. crea gruppi di istanze gestite

Per consentire la scalabilità dell'applicazione, verranno creati gruppi di istanze gestite che useranno 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 di backend di fornire funzionalità di riparazione automatica, bilanciamento del carico, scalabilità automatica e aggiornamento in sequenza.

Crea il modello di istanza dall'istanza di origine

Per poter creare un gruppo di istanze gestite, devi prima creare un modello di istanza che costituirà la base per il gruppo. I modelli di istanza ti permettono 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 crei nuove istanze di macchine virtuali (VM). Puoi utilizzare i template di istanza per creare le istanze di un gruppo di istanze gestite o anche per creare singole istanze.

Per creare il 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 in ogni gruppo vengano avviate due istanze. Le istanze verranno denominate automaticamente in base al parametro "base-instance-name" specificato, con l'aggiunta di caratteri scelti a caso.

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 e i microservizi backend vengono eseguiti sulla porta 8081 per gli ordini e sulla porta 8082 per i prodotti. Poiché non sono porte 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 riparazione automatica

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

Una policy di riparazione automatica si affida a 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 RUNNING, che è il comportamento predefinito.

Crea un controllo di integrità che ripari l'istanza se restituisce lo stato non integro 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 lasciare alla riparazione automatica il tempo di monitorare le istanze del gruppo. In seguito, simulerai un errore per testare la riparazione automatica.

6. Crea bilanciatore del carico

A complemento dei nostri gruppi di istanze gestite, utilizzerai il bilanciamento del carico HTTP(S) per indirizzare il traffico ai microservizi di frontend e backend e utilizzerai le mappature per inviare il traffico ai servizi di backend appropriati in base a regole di instradamento. In questo modo esporrai un unico 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 la Panoramica di bilanciamento del carico.

Crea il bilanciamento del carico HTTP(S)

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

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 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 stabilire 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 definisce 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

Crea una regola di forwarding globale che collega 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 react-app, che contiene il file .env in cui si trova 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 l'editor di testo che preferisci (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 react-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 aver emesso il comando rolling-action restart per dare tempo alle istanze di essere elaborate. Poi controlla lo stato del gruppo di istanze gestite finché 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+C (Command+C su Macintosh).

Conferma 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 sono 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 è totalmente funzionante, ma è una configurazione statica indipendentemente dal carico. Ora creerai una policy di scalabilità automatica basata 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. Creeranno un gestore della scalabilità automatica sui gruppi di istanze gestite, che aggiunge automaticamente istanze se l'utilizzo del bilanciatore del carico supera il 60% e le rimuove quando l'utilizzo del bilanciatore del carico scende al di sotto del 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 la 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 servizio di 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 Google Front End, che prima cerca nella cache di Cloud CDN una risposta alla richiesta dell'utente. Se il frontend trova una risposta memorizzata nella cache, la invia all'utente. Questa situazione viene definita 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 il sito web

Aggiorna il modello di istanza

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

Aggiorna l'istanza di frontend, che funge da base per il modello di istanza. Per l'aggiornamento, inserirai un file nella versione aggiornata dell'immagine del modello di istanza, quindi lo aggiornerai, implementerai il nuovo modello e verificherai che il file esista nelle istanze del gruppo di istanze gestite.

Modificherai il tipo di macchina del modello di istanza passando dal tipo di macchina standard f1-micro a un tipo di macchina personalizzato con 4 vCPU e 3840 MiB di RAM.

In Cloud Shell, esegui questo comando per modificare il tipo di macchina dell'istanza 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

Una volta che hai più di un'istanza con lo stato RUNNING, ACTION impostato su None e INSTANCE_TEMPLATE impostato come nome del nuovo 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 watch.

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 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, aggiungerai del testo alla home page per soddisfare la richiesta del team di marketing. Uno dei tuoi sviluppatori ha già creato le modifiche in un file denominato index.js.new. Puoi copiare il file in index.js e le modifiche verranno implementate. Segui le istruzioni riportate di seguito per applicare le modifiche appropriate.

Esegui i comandi seguenti, copia il file aggiornato nel file corretto, quindi stampane il contenuto per controllare 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 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 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%

Aspetta circa 30 secondi dopo aver emesso il comando rolling-action restart per dare tempo alle istanze di essere elaborate, quindi controlla lo stato del gruppo di istanze gestite fino a quando le istanze sono visualizzate nell'elenco.

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

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

Esegui questo comando per confermare che il servizio sia elencato come healthy:

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+S (Command+S su Macintosh).

Per invalidare i contenuti memorizzati nella cache all'interno della rete CDN (Content Delivery Network) e assicurarti che vengano visualizzati 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 verificare che il controllo di integrità funzioni correttamente, accedi a un'istanza e interrompi i servizi. Per trovare il nome di un'istanza, esegui questo comando:

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

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

gcloud compute ssh [INSTANCE_NAME]

Nell'istanza, utilizza supervisorctl per interrompere 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

Dopo aver notato la riparazione, premi Control+C (Command+S su Macintosh) per uscire dal comando dell'orologio. 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 eliminare 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 si verifichino addebiti ricorrenti imprevisti. Esegui il seguente comando 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 in Compute Engine. Ora hai acquisito esperienza con Compute Engine, i gruppi di istanze gestite, il bilanciamento del carico e i controlli di integrità.