GSP662

Panoramica

Esistono molti modi per eseguire il deployment di siti web in Google Cloud. Ogni 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 Engines (GKE), App Engine o altre. Compute Engine consente di avere un controllo granulare degli aspetti dell'infrastruttura, tra cui le macchine virtuali, i bilanciatori del carico e così via.

In questo lab eseguirai il deployment di un'applicazione di esempio, il sito web di e-Commerce "Fancy Store", per illustrare come si può facilmente eseguire il deployment e gestire la scalabilità di un sito web con Compute Engine.

Cosa imparerai a fare

In questo lab imparerai a:

• Creare istanze di Compute Engine
• Creare modelli di istanze dalle istanze di origine
• Creare gruppi di istanze gestite
• Creare e testare controlli di integrità dei gruppi di istanze gestite
• Creare bilanciatori del carico HTTP(S)
• Creare controlli di integrità dei bilanciatori del carico
• Usare una rete CDN (Content Delivery Network) per la memorizzazione nella cache

Alla fine del lab, 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.

Configurazione e requisiti

Prima di fare clic sul pulsante Avvia lab

Leggi le seguenti istruzioni. I lab sono a tempo e non possono essere messi in pausa. Il timer si avvia quando fai clic su Avvia lab e ti mostra per quanto tempo avrai a disposizione le risorse Google Cloud.

Con questo lab pratico avrai la possibilità di completare le attività in prima persona, in un ambiente cloud reale e non di simulazione o demo. Riceverai delle nuove credenziali temporanee che potrai utilizzare per accedere a Google Cloud per la durata del lab.

Per completare il lab, avrai bisogno di:

• Accesso a un browser internet standard (Chrome è il browser consigliato).

Nota: utilizza una finestra del browser in incognito o privata per eseguire questo lab. Ciò evita eventuali conflitti tra il tuo account personale e l'account Studente, che potrebbero causare addebiti aggiuntivi sul tuo account personale.

• È ora di completare il lab: ricorda che, una volta iniziato, non puoi metterlo in pausa.

Nota: se hai già un account o un progetto Google Cloud personale, non utilizzarlo per questo lab per evitare addebiti aggiuntivi al tuo account.

Come avviare il lab e accedere alla console Google Cloud

1. Fai clic sul pulsante Avvia lab. Se devi effettuare il pagamento per il lab, si apre una finestra popup per permetterti di selezionare il metodo di pagamento. A sinistra, trovi il riquadro Dettagli lab con le seguenti informazioni:

   • Il pulsante Apri console Google Cloud
   • Tempo rimanente
   • Credenziali temporanee da utilizzare per il lab
   • Altre informazioni per seguire questo lab, se necessario

2. Fai clic su Apri console Google Cloud (o fai clic con il tasto destro del mouse e seleziona Apri link in finestra di navigazione in incognito se utilizzi il browser Chrome).

   Il lab avvia le risorse e apre un'altra scheda con la pagina di accesso.

   Suggerimento: disponi le schede in finestre separate posizionate fianco a fianco.

   Nota: se visualizzi la finestra di dialogo Scegli un account, fai clic su Usa un altro account.

3. Se necessario, copia il Nome utente di seguito e incollalo nella finestra di dialogo di accesso.

   {{{user_0.username | "Username"}}}

   Puoi trovare il Nome utente anche nel riquadro Dettagli lab.

4. Fai clic su Avanti.

5. Copia la Password di seguito e incollala nella finestra di dialogo di benvenuto.

   {{{user_0.password | "Password"}}}

   Puoi trovare la Password anche nel riquadro Dettagli lab.

6. Fai clic su Avanti.

   Importante: devi utilizzare le credenziali fornite dal lab. Non utilizzare le credenziali del tuo account Google Cloud. Nota: utilizzare il tuo account Google Cloud per questo lab potrebbe comportare addebiti aggiuntivi.

7. Fai clic nelle pagine successive:

   • Accetta i termini e le condizioni.
   • Non inserire opzioni di recupero o l'autenticazione a due fattori, perché si tratta di un account temporaneo.
   • Non registrarti per le prove gratuite.

Dopo qualche istante, la console Google Cloud si apre in questa scheda.

Nota: per visualizzare un menu con un elenco di prodotti e servizi Google Cloud, fai clic sul menu di navigazione in alto a sinistra.

Attiva Cloud Shell

Cloud Shell è una macchina virtuale in cui sono caricati strumenti per sviluppatori. Offre una home directory permanente da 5 GB e viene eseguita su Google Cloud. Cloud Shell fornisce l'accesso da riga di comando alle risorse Google Cloud.

1. Fai clic su Attiva Cloud Shell nella parte superiore della console Google Cloud.

Quando la connessione è attiva, l'autenticazione è già avvenuta e il progetto è impostato sul tuo PROJECT_ID. L'output contiene una riga che dichiara il PROJECT_ID per questa sessione:

Your Cloud Platform project in this session is set to YOUR_PROJECT_ID

gcloud è lo strumento a riga di comando di Google Cloud. È preinstallato su Cloud Shell e supporta il completamento tramite tasto Tab.

2. (Facoltativo) Puoi visualizzare il nome dell'account attivo con questo comando:

gcloud auth list

3. Fai clic su Autorizza.

4. L'output dovrebbe avere ora il seguente aspetto:

Output:

ACTIVE: * ACCOUNT: student-01-xxxxxxxxxxxx@qwiklabs.net To set the active account, run: $ gcloud config set account `ACCOUNT`

5. (Facoltativo) Puoi elencare l'ID progetto con questo comando:

gcloud config list project

Output:

[core] project = <project_ID>

Output di esempio:

[core] project = qwiklabs-gcp-44776a13dea667a6 Nota: per la documentazione completa di gcloud, in Google Cloud, fai riferimento alla Panoramica dell'interfaccia a riga di comando gcloud.

Impostare la regione e la zona

Alcune risorse di Compute Engine risiedono in regioni e zone. Una regione rappresenta una posizione geografica specifica in cui puoi eseguire le tue risorse. Ogni regione è composta da una o più zone.

Esegui questi comandi gcloud nella console Cloud per impostare la regione e la zona predefinite per il lab:

gcloud config set compute/zone "{{{project_0.default_zone|ZONE}}}" export ZONE=$(gcloud config get compute/zone) gcloud config set compute/region "{{{project_0.default_region|REGION}}}" export REGION=$(gcloud config get compute/region)

Attività 1: abilita l'API Compute Engine

• Abilita l'API Compute Engine eseguendo il comando seguente:

gcloud services enable compute.googleapis.com

Attività 2: crea un bucket Cloud Storage

Utilizzerai un bucket Cloud Storage per ospitare il codice che crei e i tuoi script di avvio.

• Da Cloud Shell, esegui il comando riportato di seguito per creare un nuovo bucket Cloud Storage:

gsutil mb gs://fancy-store-$DEVSHELL_PROJECT_ID Nota: l'utilizzo della variabile di ambiente $DEVSHELL_PROJECT_ID in Cloud Shell serve a garantire che i nomi degli oggetti siano univoci. Poiché tutti gli ID progetto in Google Cloud devono essere univoci, l'aggiunta dell'ID progetto dovrebbe rendere univoci anche gli altri nomi.

Fai clic su Controlla i miei progressi per verificare l'obiettivo. Crea un bucket Cloud Storage

Attività 3: clona il repository di codice sorgente

Utilizza il sito web di e-commerce Fancy Store esistente basato sul repository monolith-to-microservices come base per il tuo sito web.

Clona il codice sorgente per concentrarti sugli aspetti del deployment in Compute Engine. Più avanti in questo lab, eseguirai un piccolo aggiornamento del codice a dimostrazione di come sia semplice eseguire aggiornamenti su Compute Engine.

1. Clona il codice sorgente e quindi vai alla directory monolith-to-microservices:

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

2. Esegui la build iniziale del codice per consentire l'esecuzione in locale dell'applicazione:

./setup.sh

Il completamento dello script potrebbe richiedere alcuni minuti.

3. Al termine, assicurati che Cloud Shell stia eseguendo una versione di nodeJS compatibile con il seguente comando:

nvm install --lts

4. Quindi, esegui il comando riportato di seguito per testare l'applicazione, passa alla directory microservices e avvia il server web:

cd microservices npm start

Dovresti vedere l'output seguente:

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

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

Si apre una nuova finestra in cui puoi vedere il frontend di Fancy Store.

Nota: nell'opzione Anteprima dovresti essere in grado di visualizzare il frontend, ma le funzioni Products e Orders non funzioneranno, poiché questi servizi non sono ancora esposti.

6. Chiudi questa finestra dopo aver visualizzato il sito web, quindi premi Ctrl+C nella finestra del terminale per arrestare il processo del server web.

Attività 4: crea istanze di Compute Engine

A questo punto possiamo iniziare il deployment di alcune istanze di Compute Engine.

Nei seguenti passaggi potrai:

1. Creare uno script di avvio per configurare le istanze.
2. Clonare il codice sorgente e caricarlo in Cloud Storage.
3. Eseguire il deployment di un'istanza di Compute Engine per ospitare i microservizi di backend.
4. Riconfigurare il codice del frontend in modo che utilizzi l'istanza dei microservizi di backend.
5. Eseguire il deployment di un'istanza di Compute Engine per ospitare il microservizio del frontend.
6. 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.

1. In Cloud Shell, esegui il comando riportato di seguito per creare un file denominato startup-script.sh:

touch ~/monolith-to-microservices/startup-script.sh

2. Fai clic su Apri editor nella barra laterale di Cloud Shell per aprire l'editor di codice.

3. Vai alla cartella monolith-to-microservices.

4. Aggiungi il codice riportato di seguito al file startup-script.sh. Dopo aver aggiunto il codice ne modificherai una parte:

#!/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/v16.14.0/node-v16.14.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

5. Individua il testo [DEVSHELL_PROJECT_ID] nel file e sostituiscilo con il tuo ID progetto:

La riga di codice all'interno di startup-script.sh ora dovrebbe essere simile a:

gs://fancy-store-{{{project_0.project_id | Project ID}}}/monolith-to-microservices/microservices/* /fancy-store/

6. Salva il file startup-script.sh, ma non chiuderlo ancora.

7. Guarda in basso a destra dell'editor di codice di Cloud Shell e assicurati che l'opzione "End of Line Sequence" sia impostata su "LF" e non su "CRLF".

• Se è impostata su CRLF, fai clic su CRLF e quindi seleziona LF dal menu a discesa.
• Se è già impostata su LF, lasciala invariata.

8. Chiudi il file startup-script.sh.

9. Torna al terminale Cloud Shell ed esegui il comando riportato di seguito per copiare il file startup-script.sh nel tuo bucket:

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

Il file sarà 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 dagli account di servizio per impostazione predefinita e, pertanto, inaccessibile tramite browser web. Le istanze di Compute Engine saranno automaticamente in grado di accedere tramite un account di servizio.

Lo script di avvio esegue queste attività:

• Installa l'agente Logging. L'agente raccoglie automaticamente i log da syslog.
• Installa Node.js e Supervisor. Supervisor esegue l'app come daemon.
• Clona il codice sorgente dell'app dal bucket Cloud Storage e installa le dipendenze.
• Configura Supervisor per l'esecuzione dell'app. Supervisor assicura che l'app venga riavviata se si chiude inaspettatamente o se viene interrotta da un amministratore o da un processo. Inoltre, invia lo stdout e lo stderr dell'app al syslog perché vengano raccolti dall'agente Logging.

Copia il codice nel bucket Cloud Storage

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

Nota: puoi anche scrivere il codice in modo che il pull delle variabili di ambiente venga eseguito da un'altra posizione, ma a scopi dimostrativi questo è un metodo semplice per gestire la configurazione. In fase di produzione, le variabili di ambiente verrebbero probabilmente archiviate al di fuori del codice.

1. Copia il codice clonato nel tuo bucket:

cd ~ rm -rf monolith-to-microservices/*/node_modules gsutil -m cp -r monolith-to-microservices gs://fancy- store-$DEVSHELL_PROJECT_ID/ Nota: le directory delle dipendenze node_modules vengono eliminate per garantire che la copia sia più veloce ed efficiente possibile e vengono ricreate sulle istanze al momento dell'avvio.

Fai clic su Controlla i miei progressi per verificare l'obiettivo. Copia il codice e lo script di avvio nel bucket Cloud Storage.

Esegui il deployment dell'istanza di backend

La prima istanza di cui eseguire il deployment sarà quella di backend, che ospiterà i microservizi Orders e Products.

Nota: in un ambiente di produzione, potrebbe essere utile separare ciascun microservizio associandolo alla propria istanza e gruppo di istanze, in modo da consentirne la scalabilità in modo indipendente. A scopi dimostrativi, entrambi i microservizi di backend (Orders e Products) risiederanno nella stessa istanza e nello stesso gruppo di istanze.

• Esegui il comando riportato di seguito per creare un'istanza e2-standard-2 configurata per l'utilizzo dello script di avvio. L'istanza è taggata come istanza backend in modo che tu possa applicare regole firewall specifiche in un secondo momento:

gcloud compute instances create backend \ --zone=$ZONE \ --machine-type=e2-standard-2 \ --tags=backend \ --metadata=startup-script-url=https://storage.googleapis.com/fancy-store-$DEVSHELL_PROJECT_ID/startup-script.sh

Configura una connessione al backend

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

1. Recupera l'indirizzo IP esterno del backend con il comando riportato di seguito e individua l'istanza di backend nella colonna EXTERNAL_IP:

gcloud compute instances list

Output di esempio:

NAME: backend ZONE: {{{project_0.default_zone | zone}}} MACHINE_TYPE: e2-standard-2 PREEMPTIBLE: INTERNAL_IP: 10.142.0.2 EXTERNAL_IP: 35.237.245.193 STATUS: RUNNING

2. Copia l'IP esterno del backend.

3. In Explorer di Cloud Shell, vai a monolith-to-microservices > react-app.

4. Nell'editor di codice, seleziona View > Toggle Hidden Files per visualizzare il file .env.

Nel passaggio successivo modificherai il file .env in modo che punti all'IP esterno del backend. [BACKEND_ADDRESS] rappresenta l'indirizzo IP esterno dell'istanza di backend determinata dal comando gcloud precedente.

5. Nel file .env, sostituisci localhost con il tuo [BACKEND_ADDRESS]:

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

6. Salva il file.

7. In Cloud Shell, esegui il comando riportato di seguito 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

8. Quindi, copia il codice dell'applicazione 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 di frontend

Ora che il codice è stato configurato, esegui 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. L'istanza viene taggata come frontend ai fini del firewall:

gcloud compute instances create frontend \ --zone=$ZONE \ --machine-type=e2-standard-2 \ --tags=frontend \ --metadata=startup-script-url=https://storage.googleapis.com/fancy-store-$DEVSHELL_PROJECT_ID/startup-script.sh Nota: lo script dei comandi e di avvio del deployment viene utilizzato sia con le istanze di frontend che di backend per semplicità e perché il codice è configurato per avviare tutti i microservizi per impostazione predefinita. Di conseguenza, in questo esempio, tutti i microservizi sono eseguiti sia sul frontend sia sul backend. In un ambiente di produzione, su ciascun componente verrebbero eseguiti solo i servizi necessari.

Configura la rete

1. Crea le regole firewall necessarie per consentire l'accesso alla porta 8080 per il frontend e alle porte 8081-8082 per il backend. I comandi firewall indicati di seguito utilizzano i tag assegnati durante la creazione dell'istanza per l'applicazione:

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 completamente funzionale.

2. Per andare all'IP esterno del frontend, devi conoscerne l'indirizzo. Esegui il comando riportato di seguito e cerca l'EXTERNAL_IP dell'istanza di frontend:

gcloud compute instances list

Output di esempio:

NAME: backend ZONE: us-central1-f MACHINE_TYPE: e2-standard-2 PREEMPTIBLE: INTERNAL_IP: 10.128.0.2 EXTERNAL_IP: 34.27.178.79 STATUS: RUNNING NAME: frontend ZONE: us-central1-f MACHINE_TYPE: e2-standard-2 PREEMPTIBLE: INTERNAL_IP: 10.128.0.3 EXTERNAL_IP: 34.172.241.242 STATUS: RUNNING

L'avvio e la configurazione dell'istanza potrebbero richiedere qualche minuto.

3. Attendi tre minuti, quindi apri una nuova scheda del browser e vai all'indirizzo http://[FRONTEND_ADDRESS]:8080 per accedere al sito web, dove [FRONTEND_ADDRESS] corrisponde all'EXTERNAL_IP del frontend determinato sopra.

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

Fai clic su Controlla i miei progressi per verificare l'obiettivo. Esegui il deployment delle istanze e configura la rete.

Attività 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 (MIG, Managed Instance Group) 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 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 avevi creato in precedenza.

1. Innanzitutto, interrompi le due istanze:

gcloud compute instances stop frontend --zone=$ZONE gcloud compute instances stop backend --zone=$ZONE

2. Quindi, crea un modello di istanza da ciascuna delle istanze di origine:

gcloud compute instance-templates create fancy-fe \ --source-instance-zone=$ZONE \ --source-instance=frontend gcloud compute instance-templates create fancy-be \ --source-instance-zone=$ZONE \ --source-instance=backend

3. Verifica che i modelli di istanza siano stati creati:

gcloud compute instance-templates list

Output di esempio:

NAME: fancy-be MACHINE_TYPE: e2-standard-2 PREEMPTIBLE: CREATION_TIMESTAMP: 2023-07-25T14:52:21.933-07:00 NAME: fancy-fe MACHINE_TYPE: e2-standard-2 PREEMPTIBLE: CREATION_TIMESTAMP: 2023-07-25T14:52:15.442-07:00

4. Dopo aver creato i modelli di istanza, elimina la VM di backend per risparmiare spazio per le risorse:

gcloud compute instances delete backend --zone=$ZONE

5. Digita e premi y quando richiesto.

Normalmente potresti eliminare anche la VM frontend, ma la utilizzerai per aggiornare il modello di istanza più avanti nel lab.

Crea un gruppo di istanze gestite

1. Quindi, crea due gruppi di istanze gestite, uno per il frontend e uno per il backend:

gcloud compute instance-groups managed create fancy-fe-mig \ --zone=$ZONE \ --base-instance-name fancy-fe \ --size 2 \ --template fancy-fe gcloud compute instance-groups managed create fancy-be-mig \ --zone=$ZONE \ --base-instance-name fancy-be \ --size 2 \ --template fancy-be

Questi gruppi di istanze gestite utilizzeranno i modelli di istanza e sono configurati in modo che in ogni gruppo vengano avviate due istanze. Le istanze sono denominate automaticamente in base alla stringa specificata mediante il parametro base-instance-name, con l'aggiunta di caratteri scelti a caso.

2. Per la tua applicazione, il microservizio frontend viene eseguito sulla porta 8080 e il microservizio backend viene eseguito sulla porta 8081 per orders e sulla porta 8082 per products:

gcloud compute instance-groups set-named-ports fancy-fe-mig \ --zone=$ZONE \ --named-ports frontend:8080 gcloud compute instance-groups set-named-ports fancy-be-mig \ --zone=$ZONE \ --named-ports orders:8081,products:8082

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 servizio di bilanciamento del carico HTTP che sarà configurato in seguito.

Configura la riparazione automatica

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

Un criterio di riparazione automatica si affida a un controllo di integrità basato sull'applicazione 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.

Nota: utilizzeremo controlli di integrità distinti per il bilanciamento del carico e per la riparazione automatica. I controlli di integrità del bilanciamento del carico possono e devono essere più aggressivi, in quanto determinano se un'istanza riceve traffico utente. È importante individuare subito le istanze che non rispondono per poter reindirizzare il traffico all'occorrenza. Per contro, il controllo di integrità per la riparazione automatica fa sì che Compute Engine sostituisca proattivamente le istanze che non funzionano, pertanto questo controllo di integrità sarà più prudente rispetto a quello del bilanciamento del carico.

1. Crea un controllo di integrità che ripari l'istanza se restituisce "unhealthy" 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

2. Crea una regola firewall per consentire ai probe del controllo di integrità di collegarsi ai microservizi sulle porte 8080-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

3. Applica i controlli di integrità ai rispettivi servizi:

gcloud compute instance-groups managed update fancy-fe-mig \ --zone=$ZONE \ --health-check fancy-fe-hc \ --initial-delay 300 gcloud compute instance-groups managed update fancy-be-mig \ --zone=$ZONE \ --health-check fancy-be-hc \ --initial-delay 300 Note: potrebbero essere necessari 15 minuti prima che la riparazione automatica inizi a monitorare le istanze del gruppo.

4. Procedi con il lab per lasciare alla riparazione automatica il tempo di monitorare le istanze del gruppo. Alla fine del lab simulerai un errore per testare la riparazione automatica.

Fai clic su Controlla i miei progressi per verificare l'obiettivo. Crea gruppi di istanze gestite

Attività 6: crea bilanciatori del carico

Per integrare i tuoi gruppi di istanze gestite, utilizza i bilanciatori 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 corretti in base alle regole di instradamento. In questo modo viene esposto un singolo IP con bilanciamento del carico per tutti i servizi.

Per scoprire di più sulle opzioni per il bilanciamento del carico disponibili in Google Cloud, consulta la Panoramica del bilanciamento del carico.

Crea il bilanciatore del carico HTTP(S)

Google Cloud offre molti tipi diversi di bilanciatori del carico. Per questo lab utilizzerai un bilanciatore del carico HTTP(S) per il traffico. Un bilanciatore del carico HTTP è così strutturato:

1. Una regola di forwarding indirizza le richieste in arrivo a un Proxy HTTP di destinazione.
2. 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.
3. 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.
4. 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.

Nota: a scopo dimostrativo, per evitare le complessità implicite nell'utilizzo dei certificati SSL, utilizza HTTP invece di HTTPS. In ambiente di produzione raccomandiamo di utilizzare HTTPS per la crittografia, se possibile.

1. 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 Nota: questi controlli di integrità riguardano il bilanciatore del carico e gestiscono solo l'indirizzamento del traffico dal bilanciatore del carico, ma non fanno sì che i gruppi di istanze gestite ricreino le istanze.

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

3. Aggiungi i servizi di backend del bilanciatore del carico:

gcloud compute backend-services add-backend fancy-fe-frontend \ --instance-group-zone=$ZONE \ --instance-group fancy-fe-mig \ --global gcloud compute backend-services add-backend fancy-be-orders \ --instance-group-zone=$ZONE \ --instance-group fancy-be-mig \ --global gcloud compute backend-services add-backend fancy-be-products \ --instance-group-zone=$ZONE \ --instance-group fancy-be-mig \ --global

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

5. 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"

6. Crea il proxy collegato alla mappa URL:

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

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

Fai clic su Controlla i miei progressi per verificare l'obiettivo. Crea bilanciatori del carico HTTP(S)

Aggiorna la configurazione

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

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

2. Trova l'indirizzo IP del bilanciatore del carico:

gcloud compute forwarding-rules list --global

Output di esempio:

NAME: fancy-http-rule REGION: IP_ADDRESS: 34.111.203.235 IP_PROTOCOL: TCP TARGET: fancy-proxy

3. Torna all'editor di Cloud Shell e modifica di nuovo il file .env in modo che punti all'IP pubblico del bilanciatore del carico. [LB_IP] rappresenta l'Indirizzo IP esterno dell'istanza di backend determinata sopra.

REACT_APP_ORDERS_URL=http://[LB_IP]/api/orders REACT_APP_PRODUCTS_URL=http://[LB_IP]/api/products Nota: le porte vengono rimosse nel nuovo indirizzo perché il bilanciatore del carico è configurato per gestire l'inoltro per tuo conto.

4. Salva il file.

5. Aggiorna il codice del frontend ricreando la build di react-app:

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

6. Copia il codice dell'applicazione nel tuo bucket:

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 che hai a disposizione codice e configurazione nuovi, devi fare in modo che le istanze di frontend del gruppo di istanze gestite eseguano il pull del nuovo codice.

Poiché le tue istanze eseguono il pull del codice all'avvio, puoi inviare un comando di riavvio in sequenza:

gcloud compute instance-groups managed rolling-action replace fancy-fe-mig \ --zone=$ZONE \ --max-unavailable 100% Nota: in questo esempio di sostituzione in sequenza, dichiari specificamente che tutte le macchine possono essere sostituite immediatamente attraverso il parametro --max-unavailable. Senza questo parametro, il comando manterrebbe attiva l'istanza mentre ne riavvia altre per assicurare la disponibilità. Ai fini del testing, per velocizzare le operazioni, specifica che la sostituzione deve avvenire immediatamente.

Fai clic su Controlla i miei progressi per verificare l'obiettivo. Aggiorna le istanze di frontend

Testa il sito web

1. Attendi tre minuti dopo l'invio del comando rolling-action replace per concedere alle istanze il tempo di essere elaborate, quindi verifica lo stato del gruppo di istanze gestite. Esegui il comando riportato di seguito per confermare che il servizio venga contrassegnato come HEALTHY:

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

2. Aspetta finché i due servizi non vengono contrassegnati come HEALTHY.

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 Nota: se un'istanza presenta un problema di tipo UNHEALTHY, dovrebbe essere riparata automaticamente. Aspetta che ciò avvenga.

Se, dopo che hai aspettato per qualche minuto, nessuna delle due istanze passa allo stato HEALTHY, significa che ci sono errori nella configurazione delle istanze del frontend che non consentono di accedervi sulla porta 8080. Per eseguire il test, vai alle istanze direttamente sulla porta 8080.

3. Quando entrambi gli elementi vengono contrassegnati come HEALTHY nell'elenco, esci dal comando watch premendo Ctrl+C.

Nota: l'applicazione sarà 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

Più avanti nel lab controllerai l'applicazione.

Attività 7: gestisci la scalabilità in Compute Engine

Fin qui hai creato due gruppi di istanze gestite con due istanze ciascuno. Questa configurazione è totalmente funzionante, 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 un criterio di scalabilità automatica, esegui questo comando:

gcloud compute instance-groups managed set-autoscaling \ fancy-fe-mig \ --zone=$ZONE \ --max-num-replicas 2 \ --target-load-balancing-utilization 0.60 gcloud compute instance-groups managed set-autoscaling \ fancy-be-mig \ --zone=$ZONE \ --max-num-replicas 2 \ --target-load-balancing-utilization 0.60

Questi comandi creano un gestore della scalabilità automatica sui gruppi di istanze gestite, che aggiunge automaticamente istanze se l'utilizzo supera il 60% e le rimuove quando l'utilizzo del bilanciatore del carico scende al di sotto del 60%.

Abilita la Rete CDN (Content Delivery Network)

Un'altra caratteristica che può essere utile per la scalabilità è l'abilitazione di un servizio di rete CDN (Content Delivery Network), per fornire funzionalità di memorizzazione nella cache per il frontend.

• Esegui il seguente comando sul servizio di frontend:

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

Quando un utente richiede i contenuti dal bilanciatore del carico HTTP(S), la richiesta arriva a un Google Front End (GFE) che prima cerca nella cache di Cloud CDN una risposta alla richiesta dell'utente. Se il GFE trova una risposta memorizzata nella cache, la invia all'utente. Questa situazione viene definita successo della cache.

Se il GFE non trova 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 GFE archivia nella cache di Cloud CDN, in modo che possa essere utilizzata per richieste successive.

Fai clic su Controlla i miei progressi per verificare l'obiettivo. Gestisci la scalabilità in Compute Engine

Attività 8: aggiorna il 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 solo modificare il modello se vuoi cambiarne le impostazioni. Ora apporterai un semplice modifica per utilizzare un tipo di macchina più grande e distribuirla.

Completa i seguenti passaggi per:

• Aggiornare l'istanza di frontend che funge da base per il modello di istanza. Per l'aggiornamento, inserisci un file nella versione aggiornata dell'immagine del modello di istanza, quindi aggiorna il modello di istanza, implementa il nuovo modello e poi verifica che il file esista nelle istanze del gruppo di istanze gestite.

• Modificare il tipo di macchina del modello di istanza, passando dal tipo di macchina e2-standard-2 a e2-small.

1. Esegui il comando riportato di seguito per modificare il tipo di macchina dell'istanza di frontend:

gcloud compute instances set-machine-type frontend \ --zone=$ZONE \ --machine-type e2-small

2. Crea il nuovo modello di istanza:

gcloud compute instance-templates create fancy-fe-new \ --region=$REGION \ --source-instance=frontend \ --source-instance-zone=$ZONE

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

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

4. Attendi tre minuti, quindi esegui il comando riportato di seguito per monitorare lo stato dell'aggiornamento:

watch -n 2 gcloud compute instance-groups managed list-instances fancy-fe-mig \ --zone=$ZONE

L'operazione richiederà alcuni minuti.

Quando almeno un'istanza sarà nella condizione seguente:

• STATUS: RUNNING
• ACTION impostato su None
• INSTANCE_TEMPLATE: il nome del nuovo modello (fancy-fe-new)

5. Copia il nome di una delle macchine elencate per utilizzarlo nel prossimo comando.

6. Ctrl+C per uscire dal processo watch.

7. Esegui il comando seguente per verificare se la macchina virtuale utilizza il nuovo tipo di macchina (e2-small), dove [VM_NAME] è l'istanza appena creata:

gcloud compute instances describe [VM_NAME] --zone=$ZONE | grep machineType

Output di esempio previsto:

machineType: https://www.googleapis.com/compute/v1/projects/project-name/zones/us-central1-f/machineTypes/e2-small

Apporta modifiche al sito web

Scenario: 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.

Attività: aggiungi del testo alla home page per soddisfare la richiesta del team di marketing. Uno degli sviluppatori ha già creato le modifiche in un file denominato index.js.new. Puoi semplicemente copiare questo file come index.js per implementare le modifiche. Segui le istruzioni riportate sotto per apportare le modifiche appropriate.

1. Esegui questi comandi per copiare il file aggiornato con il nome file corretto:

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

2. Visualizza i contenuti del file per verificare le modifiche:

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 { Box, Paper, Typography } from "@mui/material"; export default function Home() { return ( <Box sx={{ flexGrow: 1 }}> <Paper elevation={3} sx={{ width: "800px", margin: "0 auto", padding: (theme) => theme.spacing(3, 2), }} > <Typography variant="h5">Welcome to the Fancy Store!</Typography> <br /> <Typography variant="body1"> Take a look at our wide variety of products. </Typography> </Paper> </Box> ); }

Hai aggiornato i componenti React, ma devi creare la build dell'app React per generare i file statici.

3. Esegui il comando riportato di seguito 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

4. Quindi esegui nuovamente il push di questo codice al bucket:

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 sostituzioni in sequenza

1. Ora forza la sostituzione di tutte le istanze per eseguire il pull dell'aggiornamento:

gcloud compute instance-groups managed rolling-action replace fancy-fe-mig \ --zone=$ZONE \ --max-unavailable=100%

Nota: in questo esempio di sostituzione in sequenza, dichiari specificamente che tutte le macchine possono essere sostituite immediatamente attraverso il parametro --max-unavailable. Senza questo parametro, il comando manterrebbe attiva una delle istanze mentre sostituisce le altre. Ai fini del testing, per velocizzare le operazioni, specifica che la sostituzione deve avvenire immediatamente. In un ambiente di produzione, l'utilizzo di un buffer permetterebbe al sito web di continuare a fornire le pagine mentre vengono eseguiti gli aggiornamenti.

Fai clic su Controlla i miei progressi per verificare l'obiettivo. Aggiorna il sito web

2. Attendi tre minuti dopo l'invio del comando rolling-action replace per concedere alle istanze il tempo di essere elaborate, quindi verifica lo stato del gruppo di istanze gestite. Esegui il comando riportato di seguito per confermare che il servizio venga contrassegnato come HEALTHY:

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

3. Attendi qualche istante affinché entrambi i servizi vengano visualizzati e passino allo stato HEALTHY.

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

4. Quando gli elementi vengono visualizzati nell'elenco con lo stato HEALTHY, esci dal comando watch premendo Ctrl+C.

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

1. Per trovare il nome di un'istanza, esegui il comando seguente:

gcloud compute instance-groups list-instances fancy-fe-mig --zone=$ZONE

2. Copia il nome di un'istanza, quindi esegui il comando riportato di seguito tramite Secure Shell nell'istanza, dove INSTANCE_NAME è una delle istanze elencate.

gcloud compute ssh [INSTANCE_NAME] --zone=$ZONE

3. Digita "y" per confermare e premi Invio due volte per non utilizzare una password.

4. All'interno dell'istanza, utilizza supervisorctl per interrompere l'applicazione:

sudo supervisorctl stop nodeapp; sudo killall node

5. Esci dall'istanza:

exit

6. Monitora le operazioni di riparazione:

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

Il completamento dell'operazione richiede alcuni minuti.

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

Il gruppo di istanze gestite ha ricreato l'istanza per ripararla.

7. Puoi anche andare su Menu di navigazione > Compute Engine > Istanze VM per effettuare il monitoraggio tramite la console.

Complimenti!

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

Prossimi passi/Scopri di più

• Riparazione automatica e controlli di integrità nei gruppi di istanze gestite

• Guarda il video del case study Hosting Scalable Web Applications on Google Cloud

Formazione e certificazione Google Cloud

… per utilizzare al meglio le tecnologie Google Cloud. I nostri corsi ti consentono di sviluppare competenze tecniche e best practice per aiutarti a metterti subito al passo e avanzare nel tuo percorso di apprendimento. Offriamo vari livelli di formazione, dal livello base a quello avanzato, con opzioni di corsi on demand, dal vivo e virtuali, in modo da poter scegliere il più adatto in base ai tuoi impegni. Le certificazioni ti permettono di confermare e dimostrare le tue abilità e competenze relative alle tecnologie Google Cloud.

Ultimo aggiornamento del manuale: 26 aprile 2024

Ultimo test del lab: 15 dicembre 2023

Copyright 2024 Google LLC Tutti i diritti riservati. Google e il logo Google sono marchi di Google LLC. Tutti gli altri nomi di società e prodotti sono marchi delle rispettive società a cui sono associati.