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

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

Obiettivi didattici

In questo lab imparerai a:

• Creare istanze di Compute Engine.
• Creare template 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 ripristino automatico, 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 Inizia il 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 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: per eseguire questo lab, utilizza una finestra del browser in modalità di navigazione in incognito (consigliata) o privata. Ciò evita 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: utilizza solo l'account studente per questo lab. Se utilizzi un altro account Google Cloud, potrebbero essere addebitati costi su quell'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 aprirà una finestra di dialogo per permetterti di selezionare il metodo di pagamento. A sinistra, trovi il riquadro Dettagli lab con le seguenti informazioni:

   • Il pulsante Apri la 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 accedere ai prodotti e ai servizi Google Cloud, fai clic sul menu di navigazione o digita il nome del servizio o del prodotto nel campo Cerca.

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.

2. Fai clic nelle seguenti finestre:

   • Continua nella finestra delle informazioni di Cloud Shell.
   • Autorizza Cloud Shell a utilizzare le tue credenziali per effettuare chiamate API 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 {{{project_0.project_id | "PROJECT_ID"}}}

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

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

gcloud auth list

4. Fai clic su Autorizza.

Output:

ACTIVE: * ACCOUNT: {{{user_0.username | "ACCOUNT"}}} 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_0.project_id | "PROJECT_ID"}}} Nota: per la documentazione completa di gcloud, in Google Cloud, fai riferimento alla guida Panoramica dell'interfaccia a riga di comando gcloud.

Imposta 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 in Cloud Shell 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 questo comando:

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-{{{project_0.project_id | Project ID}}}

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

Attività 3: clona un repository di codice sorgente

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

In questa attività clonerai il codice sorgente, in modo da poterti concentrare 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. Esegui questi comandi per clonare il codice sorgente e quindi passare 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 con questo comando:

./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 questo comando:

nvm install --lts

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

cd microservices npm start

Dovrebbe essere restituito questo output:

Output:

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.

Abilita Gemini Code Assist nell'IDE di Cloud Shell

Puoi utilizzare Gemini Code Assist in un ambiente di sviluppo integrato (IDE) come Cloud Shell per ricevere indicazioni sul codice o risolvere problemi di programmazione. Prima di poter iniziare a utilizzare Gemini Code Assist, devi abilitarlo.

1. In Cloud Shell, abilita l'API Gemini for Google Cloud con il seguente comando:

gcloud services enable cloudaicompanion.googleapis.com

2. Fai clic su Apri editor nella barra degli strumenti di Cloud Shell.

Nota: per aprire l'editor di Cloud Shell, fai clic su Apri editor nella barra degli strumenti di Cloud Shell. Puoi passare da Cloud Shell all'editor di codice o viceversa facendo clic su Apri editor o Apri terminale, a seconda del caso.

3. Nel riquadro a sinistra, fai clic sull'icona Impostazioni, quindi nella vista Impostazioni, cerca Gemini Code Assist.

4. Trova la casella di controllo per Geminicodeassist: Enable (Geminicodeassist: Abilita) e assicurati che sia selezionata, quindi chiudi le Impostazioni.

5. Fai clic su Cloud Code - No Project(Cloud Code - Nessun progetto) nella barra di stato nella parte inferiore dello schermo.

6. Autorizza il plug-in come indicato. Se non viene selezionato automaticamente un progetto, fai clic su Seleziona un progetto Google Cloud e scegli .

7. Verifica che il tuo progetto Google Cloud () venga visualizzato nel messaggio di stato di Cloud Code nella barra di stato.

Attività 4: crea le istanze di Compute Engine

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

Nelle prossime sezioni, eseguirai le seguenti azioni:

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. Nel terminale Cloud Shell, esegui questo comando per creare un file denominato startup-script.sh:

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

2. Fai clic su Apri editor nella barra degli strumenti 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. Dopodiché, modificherai una parte del codice dopo averlo aggiunto:

#!/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. Per aggiornare il file startup-script.sh, fai clic sull'icona Gemini Code Assist: azioni intelligenti e incolla quanto segue nel prompt per trovare e sostituire il testo per [DEVSHELL_PROJECT_ID].

In qualità di sviluppatore di applicazioni presso Cymbal AI, aggiorna il file "startup-script.sh". Sostituisci [DEVSHELL_PROJECT_ID] con l'ID progetto: {{{project_0.project_id | Project ID}}}.

6. Premi Invio per aggiornare il file. Quando richiesto nella vista Gemini Diff, fai clic su Accetta.

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

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

7. Fai clic su Salva o premi Ctrl+S per salvare il file startup-script.sh, ma non chiuderlo ancora.

8. Fai riferimento alla parte inferiore destra dell'editor di codice di Cloud Shell e assicurati che "End of Line Sequence" sia impostato su "LF", non su "CRLF".

• Se è impostato su CRLF, fai clic su CRLF e quindi seleziona LF dal menu a discesa.
• Se è già impostato su LF, lascialo invariato.

Usa Gemini Code Assist per scoprire di più sul file dello script di avvio

Per aiutarti a incrementare la produttività riducendo al minimo il cambio di contesto, Gemini Code Assist fornisce azioni intelligenti basate sull'AI direttamente nel tuo editor di codice. Ad esempio, puoi utilizzare la funzionalità "Spiegazione" per consentire a Gemini Code Assist di fornirti maggiori informazioni su un particolare file, blocco di codice o funzione.

In questa sezione, chiedi a Gemini Code Assist di fornire maggiori informazioni su uno script di avvio per un nuovo membro del team che non lo conosce.

1. Con il file startup-script.sh aperto, fai clic sull'icona Gemini Code Assist: azioni intelligenti sulla barra degli strumenti e seleziona Spiegazione.

2. Gemini Code Assist apre un riquadro della chat con il prompt precompilato Spiegazione. Nella casella di testo incorporata della chat di Code Assist, sostituisci il prompt precompilato con quello seguente e fai clic su Invia:

Sei uno sviluppatore di applicazioni presso Cymbal AI. Un nuovo membro del team non conosce questo script di avvio. Spiega in dettaglio il file "startup-script.sh", analizzando i componenti chiave utilizzati nel codice. Non suggerire miglioramenti o modifiche al file.

La spiegazione del codice nel file startup-script.sh viene visualizzata nella chat di Gemini Code Assist.

3. Chiudi il file startup-script.sh.

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

gsutil cp ~/monolith-to-microservices/startup-script.sh gs://fancy-store-{{{project_0.project_id | 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 il loro service account.

Attività eseguite dallo script di avvio:

• 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. Tuttavia, 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.

• Esegui questo comando per copiare il codice clonato nel tuo bucket:

cd ~ rm -rf monolith-to-microservices/*/node_modules gsutil -m cp -r monolith-to-microservices gs://fancy-store-{{{project_0.project_id | 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 è quella di backend, che ospita 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 questo comando 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={{{project_0.default_zone | zone}}} \ --machine-type=e2-standard-2 \ --tags=backend \ --metadata=startup-script-url=https://storage.googleapis.com/fancy-store-{{{project_0.project_id | 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 scheda 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. Nello Spazio di esplorazione di Cloud Shell, vai a monolith-to-microservices > react-app.

4. Nell'editor di codice, seleziona Visualizza > Attiva/disattiva file nascosti 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 eseguito di recente.

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, esegui questo comando per copiare 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-{{{project_0.project_id | Project ID}}}/

Esegui il deployment dell'istanza di frontend

Ora che il codice è stato configurato, puoi eseguire il deployment dell'istanza di frontend.

• Utilizza i comandi riportati di seguito 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={{{project_0.default_zone | zone}}} \ --machine-type=e2-standard-2 \ --tags=frontend \ --metadata=startup-script-url=https://storage.googleapis.com/fancy-store-{{{project_0.project_id | Project ID}}}/startup-script.sh Nota: il comando di deployment e lo script di avvio vengono utilizzati con le istanze sia frontend che 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 microservizi necessari.

Configura la rete

1. Esegui questo comando per creare 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 questo comando 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 diversi minuti.

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, vengono creati gruppi di istanze gestite che usano le istanze di frontend e di backend come template 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 affidabilità delle app agendo proattivamente per far sì che le istanze siano disponibili, ossia che il loro stato sia RUNNING. Utilizzerai i gruppi di istanze gestite per consentire alle istanze di frontend e di backend di fornire funzionalità di ripristino automatico, bilanciamento del carico, scalabilità automatica e aggiornamento in sequenza.

Crea un template di istanza da un'istanza di origine

Per poter creare un gruppo di istanze gestite, devi prima creare un template di istanza che costituirà la base per il gruppo. I template 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 template di istanza per creare le istanze di un gruppo di istanze gestite o anche per creare singole istanze.

Per creare un template di istanza, utilizza le istanze esistenti che avevi creato in precedenza.

1. Innanzitutto, esegui questo comando per arrestare entrambe le istanze:

gcloud compute instances stop frontend --zone={{{project_0.default_zone | zone}}} gcloud compute instances stop backend --zone={{{project_0.default_zone | zone}}}

2. Quindi, crea il template di istanza da ciascuna delle istanze di origine con questi comandi:

gcloud compute instance-templates create fancy-fe \ --source-instance-zone={{{project_0.default_zone | zone}}} \ --source-instance=frontend gcloud compute instance-templates create fancy-be \ --source-instance-zone={{{project_0.default_zone | zone}}} \ --source-instance=backend

3. Esegui questo comando per confermare la creazione dei template di istanza:

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 template di istanza, esegui questo comando per eliminare la VM di backend e risparmiare spazio per le risorse:

gcloud compute instances delete backend --zone={{{project_0.default_zone | zone}}}

5. Digita e premi y quando richiesto.

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

Crea gruppi di istanze gestite

1. Ora esegui questi comandi per creare due gruppi di istanze gestite, uno per il frontend e uno per il backend:

gcloud compute instance-groups managed create fancy-fe-mig \ --zone={{{project_0.default_zone | zone}}} \ --base-instance-name fancy-fe \ --size 2 \ --template fancy-fe gcloud compute instance-groups managed create fancy-be-mig \ --zone={{{project_0.default_zone | zone}}} \ --base-instance-name fancy-be \ --size 2 \ --template fancy-be

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

2. Esegui questo comando per assicurarti che per la tua applicazione il microservizio frontend venga eseguito sulla porta 8080 e il microservizio backend venga eseguito sulla porta 8081 per orders e sulla porta 8082 per products:

gcloud compute instance-groups set-named-ports fancy-fe-mig \ --zone={{{project_0.default_zone | zone}}} \ --named-ports frontend:8080 gcloud compute instance-groups set-named-ports fancy-be-mig \ --zone={{{project_0.default_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 configurerai in seguito.

Configura il ripristino automatico

Per migliorare la disponibilità dell'applicazione stessa e per verificare che risponda, configura una policy di ripristino automatico per i gruppi di istanze gestite.

Una policy di ripristino automatico 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 RUNNING, che è il comportamento predefinito.

Nota: vengono utilizzati controlli di integrità separati per il bilanciamento del carico e per il ripristino automatico. 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 il ripristino automatico 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. Esegui questo comando per creare 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. Esegui questo comando per creare una regola firewall che consenta ai probe del controllo di integrità di connettersi 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 con i seguenti comandi:

gcloud compute instance-groups managed update fancy-fe-mig \ --zone={{{project_0.default_zone | zone}}} \ --health-check fancy-fe-hc \ --initial-delay 300 gcloud compute instance-groups managed update fancy-be-mig \ --zone={{{project_0.default_zone | zone}}} \ --health-check fancy-be-hc \ --initial-delay 300 Nota: possono essere necessari 15 minuti prima che il ripristino automatico inizi a monitorare le istanze nel gruppo.

4. Procedi con il lab per lasciare al ripristino automatico il tempo di monitorare le istanze del gruppo. Alla fine del lab simulerai un errore per testare il ripristino automatico.

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 di Cloud Load Balancing.

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:

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

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. Esegui questo comando per creare 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. Esegui questo comando per creare i servizi di backend corrispondenti alla destinazione del traffico con bilanciamento del carico. I servizi di backend utilizzano 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. Esegui questo comando per aggiungere i servizi di backend del bilanciatore del carico:

gcloud compute backend-services add-backend fancy-fe-frontend \ --instance-group-zone={{{project_0.default_zone | zone}}} \ --instance-group fancy-fe-mig \ --global gcloud compute backend-services add-backend fancy-be-orders \ --instance-group-zone={{{project_0.default_zone | zone}}} \ --instance-group fancy-be-mig \ --global gcloud compute backend-services add-backend fancy-be-products \ --instance-group-zone={{{project_0.default_zone | zone}}} \ --instance-group fancy-be-mig \ --global

4. Esegui questo comando per creare una mappa URL che definisce quali URL sono indirizzati a quali servizi di backend:

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

5. Esegui questo comando per creare un matcher di percorso che consenta 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. Esegui questo comando per creare il proxy collegato alla mappa URL:

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

7. Esegui questo comando per creare 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é a quello temporaneo utilizzato in precedenza, che puntava all'istanza di backend.

1. In Cloud Shell, esegui questo comando per passare 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 eseguendo questo comando:

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. Esegui questi comandi 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

6. Esegui questo comando per copiare 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-{{{project_0.project_id | 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, esegui questo comando per inviare un comando di riavvio in sequenza:

gcloud compute instance-groups managed rolling-action replace fancy-fe-mig \ --zone={{{project_0.default_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 questo comando 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 ripristinata 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 di 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

Controllerai l'applicazione più avanti nel lab.

Attività 7: scala 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 una policy di scalabilità automatica basata sull'utilizzo per scalare automaticamente ciascun gruppo di istanze gestite.

Ridimensiona automaticamente in base all'utilizzo

• Per creare una policy di scalabilità automatica, esegui questo comando:

gcloud compute instance-groups managed set-autoscaling \ fancy-fe-mig \ --zone={{{project_0.default_zone | zone}}} \ --max-num-replicas 2 \ --target-load-balancing-utilization 0.60 gcloud compute instance-groups managed set-autoscaling \ fancy-be-mig \ --zone={{{project_0.default_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 questo 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 la 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. Scala Compute Engine

Attività 8: aggiorna il sito web

Aggiorna il template di istanza

I template 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 template se vuoi cambiarne le impostazioni. In questa attività apporterai una semplice modifica per utilizzare un tipo di macchina più grande e distribuirla.

Completa i seguenti passaggi per eseguire queste azioni:

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

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

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

gcloud compute instances set-machine-type frontend \ --zone={{{project_0.default_zone | zone}}} \ --machine-type e2-small

2. Esegui questo comando per creare il nuovo template di istanza:

gcloud compute instance-templates create fancy-fe-new \ --region=$REGION \ --source-instance=frontend \ --source-instance-zone={{{project_0.default_zone | zone}}}

3. Implementa il template di istanza aggiornato nel gruppo di istanze gestite con il seguente comando:

gcloud compute instance-groups managed rolling-action start-update fancy-fe-mig \ --zone={{{project_0.default_zone | zone}}} \ --version template=fancy-fe-new

4. Attendi tre minuti, quindi esegui questo comando per monitorare lo stato dell'aggiornamento:

watch -n 2 gcloud compute instance-groups managed list-instances fancy-fe-mig \ --zone={{{project_0.default_zone | zone}}}

Questo processo richiede diversi minuti.

Assicurati di avere almeno un'istanza nella condizione seguente prima di procedere:

• STATUS: RUNNING
• ACTION impostato su None
• INSTANCE_TEMPLATE: il nome del nuovo template (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 questo comando 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={{{project_0.default_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ù rappresentativa dell'azienda e di ciò che commercializza.

In questa sezione, aggiungerai 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 di seguito 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 essere simile all'output seguente.

Output:

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

4. Quindi esegui questo comando per eseguire nuovamente il push di questo codice nel bucket:

cd ~ rm -rf monolith-to-microservices/*/node_modules gsutil -m cp -r monolith-to-microservices gs://fancy-store-{{{project_0.project_id | Project ID}}}/

Esegui il push delle modifiche con sostituzioni in sequenza

1. Ora esegui questo comando per forzare la sostituzione di tutte le istanze per eseguire il pull dell'aggiornamento:

gcloud compute instance-groups managed rolling-action replace fancy-fe-mig \ --zone={{{project_0.default_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 questo comando 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, decidi di accedere a un'istanza e interrompere i servizi.

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

gcloud compute instance-groups list-instances fancy-fe-mig --zone={{{project_0.default_zone | zone}}}

2. Copia il nome di un'istanza, quindi esegui questo comando tramite SSH nell'istanza, dove INSTANCE_NAME è una delle istanze elencate:

gcloud compute ssh [INSTANCE_NAME] --zone={{{project_0.default_zone | zone}}}

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

4. All'interno dell'istanza, esegui questo comando per utilizzare supervisorctl per interrompere l'applicazione:

sudo supervisorctl stop nodeapp; sudo killall node

5. Esegui questo comando per uscire dall'istanza:

exit

6. Monitora le operazioni di riparazione:

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

Il completamento del processo richiede diversi minuti.

Cerca il seguente output di esempio:

Output:

NAME: repair-1755080598062-63c3c8b99843b-eed8dabc-f1833ea3 TYPE: compute.instances.repair.recreateInstance TARGET: us-east4-c/instances/fancy-fe-tn40 HTTP_STATUS: 200 STATUS: DONE TIMESTAMP: 2025-08-13T03:23:18.062-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ù

• Ripristino automatico 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: 25 agosto 2025

Ultimo test del lab: 25 agosto 2025

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