GSP1122

Panoramica

La gestione della creazione, del deployment e degli aggiornamenti continui delle applicazioni è fondamentale per le operazioni cloud. Le domande chiave riguardano l'ottimizzazione delle risorse per rispettare gli SLA (accordi sul livello di servizio), il deployment delle modifiche al codice, gli aggiornamenti delle VM senza interruzioni e la configurazione del bilanciamento del carico/di rete. AWS sfrutta le pipeline Code Deploy, i gruppi di deployment sulle istanze EC2 con scalabilità automatica e la configurazione IAM e del firewall. I ruoli di servizio sono fondamentali per l'esecuzione e la comunicazione delle applicazioni, mentre i gateway NAT, i bilanciatori del carico, i controlli di integrità e le strategie di replica completano la configurazione dell'infrastruttura. L'aggiornamento delle VM potrebbe comportare l'aggiornamento anche delle istanze con trigger e funzioni Lambda.

Google Cloud offre una flessibilità analoga. Gli script di avvio possono recuperare gli aggiornamenti del codice, facilitando gli aggiornamenti in sequenza senza tempi di inattività. Sebbene esistano soluzioni come GKE e App Engine, Compute Engine garantisce un controllo granulare su VM e bilanciatori del carico. Questo lab mostra come eseguire il deployment e scalare l'applicazione di e-commerce "Fancy Store" su Compute Engine, mettendo in evidenza questo potente approccio alla gestione delle applicazioni web.

Obiettivi

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 zona predefinita

• Imposta la zona e la configurazione del progetto predefinite:

gcloud config set compute/zone {{{ project_0.default_zone | "ZONE" }}}

Puoi trovare ulteriori informazioni nella documentazione relativa alle regioni e alle zone.

Nota: quando esegui gcloud sul tuo computer, le impostazioni di configurazione sono rese persistenti in tutte le sessioni. In Cloud Shell, invece, devi impostarle per ogni nuova sessione o riconnessione.

Attività 1: abilita l'API Compute Engine e Gemini Code Assist

A questo punto abilita l'API Compute Engine.

• Esegui questo comando per abilitare l'API Compute Engine:

gcloud services enable compute.googleapis.com

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à 2: crea un bucket Cloud Storage

In questa attività configurerai un bucket Cloud Storage per ospitare il codice che crei e i tuoi script di avvio.

• Da Cloud Shell, esegui questo comando per creare un nuovo bucket Cloud Storage:

gsutil mb gs://fancy-store-{{{project_0.project_id | BUCKET}}}

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

Attività 3: clona il repository del codice sorgente

In questa attività utilizzerai 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. 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:

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

L'output dovrebbe essere simile al seguente.

Output:

Microservizio Products in ascolto sulla porta 8082! Microservizio Frontend in ascolto sulla porta 8080! Microservizio Orders in ascolto sulla porta 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 le istanze di Compute Engine

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

Nei passaggi che seguono, eseguirai diverse 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. Fai clic su Apri editor nella barra laterale di Cloud Shell per aprire l'editor di codice.

2. Vai alla cartella monolith-to-microservices.

3. Fai clic su File > New File (Nuovo file) e crea un file denominato startup-script.sh.

Dopodiché, utilizzerai le azioni intelligenti basate sull'AI di Gemini Code Assist per modificare il file dello script bash.

4. Incolla il codice seguente nel file.

#!/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-[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. Fai clic su File > Save (Salva) per salvare il file.

6. Nell'editor di codice di Cloud Shell, assicurati che la "sequenza di fine riga" sia impostata su "LF" e non su "CRLF". Conferma in basso a destra nell'editor di codice.

• Se è impostata su CRLF, fai clic su CRLF e poi seleziona LF nel menu a discesa per modificarla.

7. Con il file dello script bash startup-script.sh aperto nell'editor di file, Gemini Code Assist è disponibile, come indicato dall'icona nell'angolo in alto a destra dell'editor.

8. Nella barra degli strumenti, fai clic sull'icona Gemini Code Assist: azioni intelligenti .

9. Per chiedere a Gemini Code Assist di aiutarti ad aggiornare il file startup-script.sh, incolla il seguente prompt nel campo di testo incorporato di Gemini Code Assist che si apre dalla barra degli strumenti.

In the startup-script.sh file, replace the [PROJECT_ID] placeholder with {{{project_0.project_id | PROJECT_ID}}}.

10. Per richiedere a Gemini Code Assist di modificare il codice di conseguenza, premi Invio.

11. Quando richiesto nella vista Gemini Diff, fai clic su Accetta.

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

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

Dopodiché, utilizzerai le azioni intelligenti basate sull'AI di Gemini Code Assist per generare una spiegazione dello scopo dello script bash e del suo ruolo nell'automatizzazione del deployment di un microservizio Node.js.

12. Apri il file data.csv in Esplora file. Come in precedenza, Gemini Code Assist è disponibile, come indicato dall'icona nell'angolo in alto a destra dell'editor.

13. Fai clic sull'icona Gemini Code Assist: azioni intelligenti e seleziona Spiegazione.

14. 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 esperto presso Cymbal AI. Fornisci una spiegazione completa dello scopo e della funzionalità dello script bash startup-script.sh. La spiegazione è destinata a un nuovo membro del team e deve trattare i seguenti punti: * Una panoramica generale della funzione principale dello script in un workflow di deployment automatizzato. * Una suddivisione dei passaggi chiave, tra cui l'installazione delle dipendenze dell'applicazione (npm) e il recupero del codice sorgente da una posizione di archiviazione remota. * Il ruolo di supervisore nella gestione del processo di applicazione, per garantire che si avvii automaticamente e si riavvii in caso di errore. * Una spiegazione di come lo script configura l'ambiente di produzione, inclusa la creazione di utenti (useradd) e le best practice di sicurezza. Per i miglioramenti suggeriti, non apportare modifiche ai contenuti del file.

Nella chat di Gemini Code Assist vengono visualizzate spiegazioni dettagliate del codice del file startup-script.sh dello script bash.

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.

15. 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 | BUCKET}}}

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 dai service account per impostazione predefinita e, pertanto, inaccessibile tramite browser web. Le istanze di Compute Engine saranno automaticamente in grado di accedere tramite un service account.

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.

• 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 | BUCKET}}}/ 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-medium 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 \ --machine-type=e2-medium \ --tags=backend \ --metadata=startup-script-url=https://storage.googleapis.com/fancy-store-{{{project_0.project_id | BUCKET}}}/startup-script.sh Nota: se ti viene chiesto di specificare una zona, assicurati di aver configurato una zona predefinita nella sezione Configurazione di questo lab.

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 ZONE MACHINE_TYPE PREEMPTIBLE INTERNAL_IP EXTERNAL_IP STATUS backend {{{ project_0.default_zone | "ZONE" }}} e2-medium 10.128.0.2 34.68.223.88 RUNNING

2. Copia l'IP esterno del backend.

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

4. Nell'editor di codice, seleziona View (Visualizza) > Toggle Hidden Files (Attiva/disattiva file nascosti) per visualizzare il file .env.

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

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

7. Salva il file.

8. Esegui questo comando per ricreare la build di react-app, che aggiornerà il codice del frontend:

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

9. Quindi, copia il codice dell'applicazione nel bucket Cloud Storage con il comando seguente:

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

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 \ --machine-type=e2-medium \ --tags=frontend \ --metadata=startup-script-url=https://storage.googleapis.com/fancy-store-{{{project_0.project_id | BUCKET}}}/startup-script.sh Nota: il comando di deployment e lo script di avvio vengono utilizzati con le istanze sia 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

In questa sezione creerai le regole firewall per consentire l'accesso alla porta 8080 per il frontend e alle porte 8081-8082 per il backend. I comandi firewall utilizzano i tag assegnati durante la creazione dell'istanza per l'applicazione:

1. Esegui questi comandi per configurare le regole firewall:

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: {{{ project_0.default_zone | "ZONE" }}} MACHINE_TYPE: e2-medium PREEMPTIBLE: INTERNAL_IP: 10.128.0.2 EXTERNAL_IP: 34.27.178.79 STATUS: RUNNING NAME: frontend ZONE: {{{ project_0.default_zone | "ZONE" }}} MACHINE_TYPE: e2-medium 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 30 secondi, quindi esegui questo comando per monitorare l'avvio dell'applicazione, sostituendo FRONTEND_ADDRESS con l'indirizzo IP esterno dell'istanza di frontend:

watch -n 2 curl http://[FRONTEND_ADDRESS]:8080

Quando vedi un output simile al seguente, il sito web dovrebbe essere pronto.

4. Premi Ctrl+C per annullare il comando watch

5. Apri una nuova scheda del browser e vai all'indirizzo http://[FRONTEND_ADDRESS]:8080 per accedere al sito web, dove [FRONTEND_ADDRESS] corrisponde all'indirizzo EXTERNAL_IP del frontend che hai determinato più sopra.

6. 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. In questo lab 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 il template di istanza dall'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 questi comandi per arrestare entrambe le istanze:

gcloud compute instances stop frontend gcloud compute instances stop backend

2. Quindi, esegui questi comandi per creare il template di istanza da ciascuna delle istanze di origine:

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

3. Verifica che i template di istanza siano stati creati con il seguente comando:

gcloud compute instance-templates list

Output di esempio:

NAME MACHINE_TYPE PREEMPTIBLE CREATION_TIMESTAMP fancy-be e2-medium 2020-02-03T10:34:12.966-08:00 fancy-fe e2-medium 2020-02-03T10:34:01.082-08: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

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 un gruppo di istanze gestite

1. Quindi, 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 \ --base-instance-name fancy-fe \ --size 2 \ --template fancy-fe gcloud compute instance-groups managed create fancy-be-mig \ --base-instance-name fancy-be \ --size 2 \ --template fancy-be

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. Per la tua applicazione, esegui questo comando per assicurarti che 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 \ --named-ports frontend:8080 gcloud compute instance-groups set-named-ports fancy-be-mig \ --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: utilizzeremo controlli di integrità distinti 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 questi comandi 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. Crea una regola firewall per consentire ai probe del controllo di integrità di connettersi ai microservizi sulle porte 8080-8081 con questo comando:

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. Esegui questi comandi per applicare i controlli di integrità ai rispettivi servizi:

gcloud compute instance-groups managed update fancy-fe-mig \ --health-check fancy-fe-hc \ --initial-delay 300 gcloud compute instance-groups managed update fancy-be-mig \ --health-check fancy-be-hc \ --initial-delay 300 Nota: potrebbero essere necessari 15 minuti prima che il ripristino automatico inizi a monitorare le istanze del 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 gruppi di istanze gestite, utilizza i bilanciatori del carico HTTP(S) per gestire il traffico verso i microservizi di frontend e backend, nonché 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:

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

5. Crea i controlli di integrità 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.

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

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

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

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

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

10. Esegui questo comando per creare il proxy collegato alla mappa URL:

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

11. 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é a quello 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. Ricrea la build di react-app, che aggiorna il codice del frontend:

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-{{{project_0.project_id | BUCKET}}}/

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 \ --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. Aspetta circa 30 secondi dopo l'invio del comando rolling-action replace per dare tempo alle istanze di essere elaborate, quindi verifica lo stato del gruppo di istanze gestite fino a quando le istanze sono visualizzate nell'elenco:

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

2. Quando gli elementi sono visualizzati nell'elenco, esci dal comando watch premendo Ctrl+C.

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

4. 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/{{{ project_0.default_zone | "ZONE" }}}/instanceGroups/fancy-fe-mig status: healthStatus: - healthState: HEALTHY instance: https://www.googleapis.com/compute/v1/projects/my-gce-codelab/zones/{{{ project_0.default_zone | "ZONE" }}}/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/{{{ project_0.default_zone | "ZONE" }}}/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.

5. 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: scala i gruppi di istanze 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 \ --max-num-replicas 2 \ --target-load-balancing-utilization 0.60 gcloud compute instance-groups managed set-autoscaling \ fancy-be-mig \ --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. Gestisci la scalabilità in 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. Ora apporterai un semplice modifica che ha lo scopo di utilizzare un tipo di macchina più grande e la pubblicherai.

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

2. Ora modifica il tipo di macchina nel tuo template di istanza passando dal tipo di macchina e2-medium a un tipo di macchina personalizzata con 4 vCPU e 3840 MiB di RAM.

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

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

4. Crea il nuovo template di istanza:

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

5. Implementa il template di istanza aggiornato nel gruppo di istanze gestite:

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

6. Attendi 30 secondi, quindi esegui questo comando per monitorare lo stato dell'aggiornamento:

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

L'operazione richiede alcuni istanti.

Quando almeno un'istanza sarà nella condizione seguente:

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

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

8. Ctrl+C per uscire dal processo watch.

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

gcloud compute instances describe [VM_NAME] | grep machineType

Output di esempio previsto:

machineType: https://www.googleapis.com/compute/v1/projects/project-name/zones/{{{ project_0.default_zone | "ZONE" }}}/machineTypes/custom-4-3840

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 ( theme.spacing(3, 2), }} > Fancy Fashion & Style Online
Tired of mainstream fashion ideas, popular trends and societal norms? This line of lifestyle products will help you catch up with the Fancy trend and express your personal style. Start shopping Fancy items now! ); }

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 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-{{{project_0.project_id | BUCKET}}}/

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 \ --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. Aspetta circa 30 secondi dopo l'invio del comando rolling-action replace per dare tempo alle istanze di essere elaborate, quindi verifica lo stato del gruppo di istanze gestite fino a quando le istanze sono visualizzate nell'elenco:

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

3. Quando gli elementi sono visualizzati nell'elenco, esci dal comando watch premendo Ctrl+C.

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

5. 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/{{{ project_0.default_zone | "ZONE" }}}/instanceGroups/fancy-fe-mig status: healthStatus: - healthState: HEALTHY instance: https://www.googleapis.com/compute/v1/projects/my-gce-codelab/zones/{{{ project_0.default_zone | "ZONE" }}}/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/{{{ project_0.default_zone | "ZONE" }}}/instances/fancy-fe-cgrt ipAddress: 10.128.0.11 port: 8080 kind: compute#backendServiceGroupHealth

6. Quando gli elementi sono visualizzati nell'elenco, esci dal comando watch premendo Ctrl+C.

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

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

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]

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:

Output di esempio:

NAME TYPE TARGET HTTP_STATUS STATUS TIMESTAMP repair-1568314034627-5925f90ee238d-fe645bf0-7becce15 compute.instances.repair.recreateInstance {{{ project_0.default_zone | "ZONE" }}}/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 monitorare l'operazione anche dalla console: vai al Menu di navigazione > Compute Engine > Istanze VM.

Complimenti!

Complimenti! In questo lab hai eseguito il deployment e hai scalato e aggiornato il tuo sito web su Compute Engine, acquisendo esperienza pratica con Compute Engine, i gruppi di istanze gestite, i bilanciatori del carico e i controlli di integrità. Questo lab evidenzia come sia Google Cloud che AWS facilitano i deployment di applicazioni basate su VM con bilanciatori del carico per internet. L'approccio di Google Cloud sfrutta gli script di avvio per unificare il deployment del codice e la configurazione delle VM, semplifica la gestione delle VM con la scalabilità automatica, offre il bilanciamento del carico HTTP(S) esterno globale e consente aggiornamenti continui di immagini e applicazioni all'interno dello script di avvio e del workflow MIG.

Prossimi passi/Scopri di più

• Per saperne di più, vedi Ripristino automatico e controlli di integrità nei gruppi di istanze gestite

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: 14 ottobre 2025

Ultimo test del lab: 14 ottobre 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.