Bilanciatore del carico HTTPs esterno con codelab sulla gestione avanzata del traffico (Envoy)

1. Introduzione

Ti diamo il benvenuto nel Bilanciatore del carico HTTPs esterno con codelab per la gestione avanzata del traffico (Envoy).

L'ultima versione del bilanciatore del carico HTTP(S) esterno con gestione avanzata del traffico contiene tutte le funzionalità del bilanciatore del carico HTTP(S) esterno classico globale, ma con un elenco in continua crescita di funzionalità di gestione avanzata del traffico. Alcune di queste sono nuove per i nostri bilanciatori del carico, mentre altre offrono funzionalità avanzate rispetto a quelle esistenti. Un elenco parziale di queste funzionalità include:

• Suddivisione del traffico ponderata
• Richiedi mirroring
• Rilevamento outlier
• Nuovi tentativi di richiesta
• Fault injection
• Altre opzioni di affinità della sessione di backend
• Altre opzioni di trasformazione delle intestazioni
• Condivisione delle risorse tra origini (CORS)
• Nuovi algoritmi di bilanciamento del carico

Cosa imparerai a fare

• Come configurare un gruppo di istanze gestite e le regole VPC e del firewall associate
• Come utilizzare le funzionalità avanzate di gestione del traffico del nuovo bilanciatore del carico
• Come verificare che le funzionalità avanzate di gestione del traffico funzionino come previsto.

Che cosa ti serve

• Networking di base e conoscenza di HTTP
• Conoscenza di base della riga di comando Unix/Linux

Topologia codelab e caso d'uso

Figura 1 - Topologia di routing del bilanciatore del carico HTTP

Durante questo lab di codice configurerai tre gruppi di istanze gestite, uno a est, ovest e centrale. Creerai un bilanciatore del carico HTTPS esterno globale. Il bilanciatore del carico utilizzerà diverse funzionalità dell'elenco di funzionalità avanzate supportate dal bilanciatore del carico basato su Envoy. Una volta eseguito il deployment, genererai un carico simulato e verificherai che le configurazioni impostate funzionino correttamente.

2. Configurazione e requisiti

Configurazione dell'ambiente da seguire in modo autonomo

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

• Il Nome progetto è il nome visualizzato dei partecipanti del progetto. Si tratta di una stringa di caratteri non utilizzata dalle API di Google e può essere aggiornata in qualsiasi momento.
• L'ID progetto deve essere univoco in tutti i progetti Google Cloud ed è immutabile (non può essere modificato dopo essere stato impostato). La console Cloud genera automaticamente una stringa univoca. di solito non ti importa cosa sia. Nella maggior parte dei codelab, devi fare riferimento all'ID progetto (che solitamente è identificato come PROJECT_ID), quindi, se non ti piace, generane un altro a caso oppure puoi fare un tentativo personalizzato e controllare se è disponibile. Poi c'è "congelato" dopo la creazione del progetto.
• C'è un terzo valore, il numero di progetto, utilizzato da alcune API. Scopri di più su tutti e tre questi valori nella documentazione.

Attenzione:un ID progetto deve essere univoco a livello globale e non può essere utilizzato da nessun altro utente dopo essere stato selezionato. Sei l'unico utente di quell'ID. Se un progetto viene eliminato, quell'ID non può più essere riutilizzato.

Nota:se utilizzi un account Gmail, puoi lasciare la posizione predefinita impostata su Nessuna organizzazione. Se utilizzi un account Google Workspace, scegli una località adatta alla tua organizzazione.

2. Successivamente, dovrai abilitare la fatturazione nella console Cloud per utilizzare le risorse/le API Cloud. Eseguire questo codelab non dovrebbe costare molto. Per arrestare le risorse in modo da non incorrere in fatturazione oltre questo tutorial, segui eventuali "pulizie" istruzioni riportate alla fine del codelab. I nuovi utenti di Google Cloud sono idonei al programma prova senza costi di 300$.

Avvia Cloud Shell

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

Dalla console di Google Cloud, fai clic sull'icona di Cloud Shell nella barra degli strumenti in alto a destra:

Dovrebbe richiedere solo qualche istante per eseguire il provisioning e connettersi all'ambiente. Al termine, dovresti vedere una schermata simile al seguente:

Questa macchina virtuale viene caricata con tutti gli strumenti di sviluppo necessari. Offre una home directory permanente da 5 GB e viene eseguita su Google Cloud, migliorando notevolmente le prestazioni di rete e l'autenticazione. Tutto il lavoro in questo lab può essere svolto semplicemente con un browser.

Prima di iniziare

All'interno di Cloud Shell, assicurati che l'ID progetto sia configurato

Progetto gcloud config list

gcloud config set progetto [YOUR-PROJECT-NAME]

PROJECT_ID=[YOUR-PROJECT-NAME]

echo $PROJECT_ID

Abilita le API

Abilita tutti i servizi necessari

gcloud services enable compute.googleapis.com
gcloud services enable logging.googleapis.com
gcloud services enable monitoring.googleapis.com

3. crea la rete VPC

Crea una rete VPC

Da Cloud Shell

gcloud compute networks create httplbs --subnet-mode=auto

Output

Created [https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/httplbs].
NAME: httplbs
SUBNET_MODE: AUTO
BGP_ROUTING_MODE: REGIONAL
IPV4_RANGE:
GATEWAY_IPV4:

Crea regole firewall VPC

Dopo aver creato il VPC, creerai ora le regole firewall. La regola firewall verrà utilizzata per consentire a tutti gli IP di accedere all'IP esterno del sito web dell'applicazione di test sulla porta 80 per il traffico http.

Da Cloud Shell

gcloud compute firewall-rules create httplb-allow-http-rule \
--allow tcp:80 \
--network httplbs \
--source-ranges 0.0.0.0/0 \
--priority 700

Output

Creating firewall...working..Created [https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls/httplb-allow-http-rule].
Creating firewall...done.
NAME: httplb-allow-http-rule
NETWORK: httplbs
DIRECTION: INGRESS
PRIORITY: 700
ALLOW: tcp:80
DENY:
DISABLED: False

4. configura i gruppi di istanze gestite

Devi configurare i gruppi di istanze gestite che includono i pattern per le risorse di backend utilizzate dal bilanciatore del carico HTTP. Per prima cosa creeremo i modelli di istanza che definiscono la configurazione delle VM da creare per ogni regione. Successivamente, per un backend in ogni regione, creeremo un gruppo di istanze gestite che fa riferimento a un modello di istanza.

I gruppi di istanze gestite possono avere un ambito a livello di zona o di regione. Per questo esercizio del lab creeremo tre gruppi di istanze gestite a livello di regione, uno in us-east1, uno in us-west1 e uno in us-central1.

In questa sezione puoi vedere uno script di avvio creato in precedenza a cui verrà fatto riferimento durante la creazione dell'istanza. Questo script di avvio installa e attiva le funzionalità del server web che utilizzeremo per simulare un'applicazione web. Puoi esaminare il copione.

Crea i modelli di istanza orientale, occidentale e centrale

Il primo passaggio consiste nel creare il modello di istanza us-east-1.

Da Cloud Shell

gcloud compute instance-templates create us-east1-template \
   --region=us-east1 \
   --network=httplbs \
   --tags=http-server, \
   --image-family=debian-9 \
   --image-project=debian-cloud \
   --metadata=startup-script='#! /bin/bash
     apt-get update
     apt-get install apache2 -y
     a2ensite default-ssl
     a2enmod ssl
     vm_hostname="$(curl -H "Metadata-Flavor:Google" \
     http://169.254.169.254/computeMetadata/v1/instance/name)"
     echo "Page served from: $vm_hostname" | \
     tee /var/www/html/index.html
     systemctl restart apache2'

Output

Created [https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/instanceTemplates/us-east1-template].
NAME: us-east1-template
MACHINE_TYPE: n1-standard-1
PREEMPTIBLE:
CREATION_TIMESTAMP: 2021-11-11T11:02:37.511-08:00

Il passaggio successivo prevede la creazione del modello di istanza us-west-1.

Da Cloud Shell

gcloud compute instance-templates create us-west1-template \
   --region=us-west1 \
   --network=httplbs \
   --tags=http-server, \
   --image-family=debian-9 \
   --image-project=debian-cloud \
   --metadata=startup-script='#! /bin/bash
     apt-get update
     apt-get install apache2 -y
     a2ensite default-ssl
     a2enmod ssl
     vm_hostname="$(curl -H "Metadata-Flavor:Google" \
     http://169.254.169.254/computeMetadata/v1/instance/name)"
     echo "Page served from: $vm_hostname" | \
     tee /var/www/html/index.html
     systemctl restart apache2'

Output

Created [https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/instanceTemplates/us-west1-template].
NAME: us-west1-template
MACHINE_TYPE: n1-standard-1
PREEMPTIBLE:
CREATION_TIMESTAMP: 2021-11-11T11:03:08.577-08:00

Il passaggio successivo è creare il modello di istanza us-central-1.

Da Cloud Shell

gcloud compute instance-templates create us-central1-template \
   --region=us-central1 \
   --network=httplbs \
   --tags=http-server, \
   --image-family=debian-9 \
   --image-project=debian-cloud \
   --metadata=startup-script='#! /bin/bash
     apt-get update
     apt-get install apache2 -y
     a2ensite default-ssl
     a2enmod ssl
     vm_hostname="$(curl -H "Metadata-Flavor:Google" \
     http://169.254.169.254/computeMetadata/v1/instance/name)"
     echo "Page served from: $vm_hostname" | \
     tee /var/www/html/index.html
     systemctl restart apache2'

Output

Created [https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/instanceTemplates/us-central1-template].
NAME: us-central1-template
MACHINE_TYPE: n1-standard-1
PREEMPTIBLE:
CREATION_TIMESTAMP: 2021-11-11T11:03:44.179-08:00

Ora puoi verificare che i modelli di istanza siano stati creati correttamente con il seguente comando gcloud:

Da Cloud Shell

gcloud compute instance-templates list

Output

NAME                  MACHINE_TYPE   PREEMPTIBLE  CREATION_TIMESTAMP
us-central1-template   n1-standard-1         2021-11-09T09:25:37.263-08:00
us-east1-template      n1-standard-1         2021-11-09T09:24:35.275-08:00
us-west1-template      n1-standard-1         2021-11-09T09:25:08.016-08:00

Crea i gruppi di istanze gestite est, ovest e centrali

Ora dobbiamo creare un gruppo di istanze gestite dai modelli di istanza creati in precedenza.

Da Cloud Shell

gcloud compute instance-groups managed create us-east1-mig \
--base-instance-name=us-east1-mig \
--size=1 \
--template=us-east1-template \
--zone=us-east1-b 

Output

Created [https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-east1-b/instanceGroupManagers/us-east1-mig].
NAME: us-east1-mig
LOCATION: us-east1-b
SCOPE: zone
BASE_INSTANCE_NAME: us-east1-mig
SIZE: 0
TARGET_SIZE: 1
INSTANCE_TEMPLATE: us-east1-template
AUTOSCALED: no

Da Cloud Shell

gcloud compute instance-groups managed create us-west1-mig \
--base-instance-name=us-west1-mig \
--size=1 \
--template=us-west1-template \
--zone=us-west1-a  

Output

Created [https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instanceGroupManagers/us-west1-mig].
NAME: us-west1-mig
LOCATION: us-west1-a
SCOPE: zone
BASE_INSTANCE_NAME: us-west1-mig
SIZE: 0
TARGET_SIZE: 1
INSTANCE_TEMPLATE: us-west1-template
AUTOSCALED: no

Da Cloud Shell

gcloud compute instance-groups managed create us-central1-mig \
--base-instance-name=us-central1-mig \
--size=1 \
--template=us-central1-template \
--zone=us-central1-a 

Output

Created [https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-central1-a/instanceGroupManagers/us-central1-mig].
NAME: us-central1-mig
LOCATION: us-central1-a
SCOPE: zone
BASE_INSTANCE_NAME: us-central1-mig
SIZE: 0
TARGET_SIZE: 1
INSTANCE_TEMPLATE: us-central1-template
AUTOSCALED: no

Possiamo verificare che i nostri gruppi di istanze siano stati creati correttamente con il seguente comando gcloud:

Da Cloud Shell

gcloud compute instance-groups list

Output

NAME                  LOCATION      SCOPE   NETWORK         MANAGED INSTANCES
us-central1-mig       us-central1   zone    httplbs          Yes      1
us-west1-mig          us-west1      zone    httplbs          Yes      1
us-east1-mig          us-east1      zone    httplbs          Yes      1

Verifica la funzionalità del server web

Ogni istanza è configurata per eseguire un server web Apache con un semplice script PHP che visualizza:

Per assicurarti che i server web funzionino correttamente, vai a Compute Engine -> di istanze VM di Compute Engine. Assicurati che le nuove istanze (ad es. us-east1-mig-xxx) siano state create in base alle definizioni dei rispettivi gruppi di istanze.

Ora effettua una richiesta web nel tuo browser per assicurarti che il server web sia in esecuzione (l'avvio potrebbe richiedere un minuto). Nella pagina Istanze VM, in Compute Engine, seleziona un'istanza creata dal gruppo di istanze e fai clic sul relativo IP esterno (pubblico).

In alternativa, nel browser, vai all'indirizzo http://<Indirizzo_IP>.

5. Configura il bilanciatore del carico

Crea controllo di integrità

Per prima cosa dobbiamo creare un controllo di integrità di base per garantire che i nostri servizi funzionino correttamente. Verrà creato un controllo di integrità di base. Sono disponibili molte altre personalizzazioni avanzate.

Da Cloud Shell

gcloud compute health-checks create http http-basic-check \
    --port 80

Prenota indirizzo IP esterno

Per questo passaggio dovrai prenotare un indirizzo IP statico disponibile a livello globale che verrà successivamente collegato al bilanciatore del carico.

Da Cloud Shell

gcloud compute addresses create lb-ipv4-2 \
    --ip-version=IPV4 \
    --global

Assicurati di annotare l'indirizzo IP riservato.

gcloud compute addresses describe lb-ipv4-2 \
    --format="get(address)" \
    --global

Creare servizi di backend

Ora dobbiamo creare un servizio di backend per ciascuno dei gruppi di istanze gestite che abbiamo creato in precedenza. Una per est, ovest e centrale.

Creazione di un servizio di backend per il gruppo di istanze gestite orientali.

Da Cloud Shell

gcloud beta compute backend-services create east-backend-service \
    --load-balancing-scheme=EXTERNAL_MANAGED \
    --protocol=HTTP \
    --port-name=http \
    --health-checks=http-basic-check \
    --global

Creazione di un servizio di backend per il gruppo di istanze gestite a ovest.

Da Cloud Shell

gcloud beta compute backend-services create west-backend-service \
    --load-balancing-scheme=EXTERNAL_MANAGED \
    --protocol=HTTP \
    --port-name=http \
    --health-checks=http-basic-check \
    --global

Creazione di un servizio di backend per il gruppo di istanze gestite centralmente.

Da Cloud Shell

gcloud beta compute backend-services create central-backend-service \
    --load-balancing-scheme=EXTERNAL_MANAGED \
    --protocol=HTTP \
    --port-name=http \
    --health-checks=http-basic-check \
    --global

Aggiungere gruppi di istanze gestite ai servizi di backend

Ora che abbiamo creato i rispettivi servizi di backend per ogni cluster di applicazioni, dobbiamo aggiungere i gruppi di istanze gestite che abbiamo creato in precedenza a ciascun servizio di backend.

Aggiungi un gruppo di istanze gestite est al servizio di backend.

Da Cloud Shell

gcloud beta compute backend-services add-backend east-backend-service \
    --balancing-mode='UTILIZATION' \
    --instance-group=us-east1-mig \
    --instance-group-zone=us-east1-b \
    --global

Aggiungi un gruppo di istanze gestite ovest al servizio di backend.

Da Cloud Shell

gcloud beta compute backend-services add-backend west-backend-service \
    --balancing-mode='UTILIZATION' \
    --instance-group=us-west1-mig \
    --instance-group-zone=us-west1-a \
    --global

Aggiungi un gruppo di istanze gestite ovest al servizio di backend.

Da Cloud Shell

gcloud beta compute backend-services add-backend central-backend-service \
    --balancing-mode='UTILIZATION' \
    --instance-group=us-central1-mig \
    --instance-group-zone=us-central1-a \
    --global

Crea mappa URL

La mappa URL è il luogo in cui si troveranno le funzionalità avanzate di gestione del traffico per questo lab. Dobbiamo creare un file .yaml che conterrà la configurazione. All'interno del file .yaml abbiamo creato una corrispondenza del prefisso su /roundrobbin, quindi solo il traffico che corrisponde a /roundrobbin sarà interessato da queste configurazioni. Abbiamo specificato che il 50% del traffico deve essere indirizzato al servizio east-backend-service e il 50% al servizio west-backend-service. Abbiamo aggiunto anche un valore di intestazione della risposta {test} che sarà presente in tutte le risposte. Infine, abbiamo aggiunto che tutto il traffico deve essere sottoposto a mirroring al servizio central-backend-service. Il traffico è duplicato e inviato qui solo a scopo di test.

Salva l'esempio come file .yaml sulla tua macchina.

defaultService: https://www.googleapis.com/compute/v1/projects/[project_id]/global/backendServices/east-backend-service
kind: compute #urlMap
name: web-map-http
hostRules:
- hosts:
  - '*'
  pathMatcher: matcher1
pathMatchers:
- defaultService: https://www.googleapis.com/compute/v1/projects/[project_id]/global/backendServices/east-backend-service
  name: matcher1
  routeRules:
  - matchRules:
    - prefixMatch: /roundrobbin
    priority: 2
    headerAction:
        responseHeadersToAdd:
          - headerName: test
            headerValue: value
            replace: True
    routeAction:
        weightedBackendServices:
        - backendService: https://www.googleapis.com/compute/v1/projects/[project_id]/global/backendServices/east-backend-service
          weight: 50
        - backendService: https://www.googleapis.com/compute/v1/projects/[project_id]/global/backendServices/west-backend-service
          weight: 50
        retryPolicy:
            retryConditions: ['502', '504']
            numRetries: 3
            perTryTimeout:
                seconds: 1
                nanos: 50
        requestMirrorPolicy:
          backendService: https://www.googleapis.com/compute/v1/projects/[project_id]/global/backendServices/central-backend-service

Crea la Mappa URL importando il documento dal tuo computer. Tieni presente che il percorso di origine sarà diverso a seconda di dove salvi il file .yaml.

Da Cloud Shell

gcloud beta compute url-maps import web-map-http \
   --source /Users/[USERNAME]/Documents/Codelab/lbconfig.yaml \
   --global

Crea frontend HTTP

Il passaggio finale nella creazione del bilanciatore del carico è la creazione del frontend. In questo modo l'indirizzo IP che hai prenotato in precedenza verrà mappato alla mappa URL del bilanciatore del carico che hai creato.

Da Cloud Shell

gcloud beta compute target-http-proxies create http-lb-proxy-adv \
    --url-map=web-map-http

Poi devi creare una regola di forwarding globale che mappa l'indirizzo IP riservato in precedenza al proxy HTTP.

Da Cloud Shell

gcloud beta compute forwarding-rules create http-content-rule \
    --load-balancing-scheme EXTERNAL_MANAGED \
    --address=lb-ipv4-2 \
    --global \
    --target-http-proxy=http-lb-proxy-adv \
    --ports=80

6. Verificare il funzionamento delle funzionalità avanzate di gestione del traffico

Per verificare che la funzione di suddivisione del traffico implementata funzioni correttamente, devi generare un po' di carico. Per farlo, creeremo una nuova VM per simulare il carico.

Crea regola firewall per consentire l'accesso SSH

Per poter accedere tramite SSH alla VM per generare traffico da te, devi prima creare una regola firewall che permetta il traffico SSH alla VM.

Da Cloud Shell

gcloud compute firewall-rules create fw-allow-ssh \
    --network=httplbs \
    --action=allow \
    --direction=ingress \
    --target-tags=allow-ssh \
    --rules=tcp:22

Output

NAME          NETWORK  DIRECTION  PRIORITY  ALLOW   DENY  DISABLED
fw-allow-ssh  httplbs  INGRESS    1000      tcp:22        False

Crea Siege-vm

Ora creerai la macchina virtuale siege-vm che utilizzerai per generare il carico.

Da Cloud Shell

gcloud compute instances create siege-vm \
    --network=httplbs \
    --zone=us-east4-c \
    --machine-type=e2-medium \
    --tags=allow-ssh,http-server \
    --metadata=startup-script='sudo apt-get -y install siege'

Output

NAME     ZONE        MACHINE_TYPE INTERNAL_IP  EXTERNAL_IP    STATUS
siege-vm us-east4-c  e2-medium    10.150.0.3   34.85.218.119  RUNNING

Successivamente, potrai accedere tramite SSH alla VM che hai creato. Una volta creato, fai clic su SSH per avviare un terminale e stabilire una connessione.

Dopo la connessione, esegui questo comando per generare il carico. Utilizza l'indirizzo IP che hai prenotato in precedenza per il bilanciatore del carico HTTP esterno.

Da Cloud Shell

siege -c 250 http://$lb-ipv4-2/roundrobbin

Output

New configuration template added to /home/cloudcurriculumdeveloper/.siege
Run siege -C to view the current settings in that file
[alert] Zip encoding disabled; siege requires zlib support to enable it: No such file or directory
** SIEGE 4.0.2
** Preparing 250 concurrent users for battle.
The server is now under siege...

Controlla la distribuzione del carico

Ora che Siege è in esecuzione, è il momento di verificare che il traffico sia distribuito equamente tra i gruppi di istanze gestite da est e ovest. Inoltre, puoi verificare che il mirroring del traffico funzioni e che il traffico venga inviato al gruppo di istanze gestite centrali.

Nella console Cloud, nel menu di navigazione, fai clic su Servizi di rete > Bilanciamento del carico. Fai clic su Backend. Fai clic sul menu avanzato, come illustrato nello screenshot di seguito.

Vai alla scheda Servizi di backend e seleziona il servizio east-backend-service

Potrai vedere la suddivisione del traffico in tempo reale in questo gruppo di istanze gestite. Prendi nota della tariffa, in breve potrai confrontarla con il servizio di backend west.

Allo stesso modo, accedi al servizio west-backend-service. Dovresti vedere anche il traffico verso questo servizio. La frequenza dovrebbe essere simile a quella indicata nel servizio east-backend-service poiché hai configurato una suddivisione del traffico "round robbin" 50/50.

Per verificare che il criterio di mirroring del traffico che hai creato funzioni, devi controllare l'utilizzo del gruppo di istanze gestite central-backend-service. Per farlo, accedi a Compute, Compute Engine, gruppi di istanze e seleziona us-central1-mig. Quindi, vai alla scheda Monitoraggio.

Vedrai i grafici compilati a indicare che il traffico è stato sottoposto a mirroring a questo gruppo di istanze gestite.

Ferma l'assedio

Ora che hai dimostrato che la suddivisione avanzata del traffico funziona, è il momento di fermare l'assedio. Per farlo, torna al terminale SSH di siege-vm e premi Ctrl+C per arrestare la siege.

Convalida l'intestazione della risposta da inviare

Prima di eseguire la pulizia, puoi verificare rapidamente che il bilanciatore del carico http invii l'intestazione della risposta appropriata. L'hai configurato in modo da inviare il test dell'intestazione con il valore dei contenuti. L'esecuzione del comando curl da Cloud Shell restituirà la risposta prevista.

Da Cloud Shell

curl -svo /dev/null http://lb-ipv4-2/roundrobbin

Output

*   Trying lb-ipv4-2..
* TCP_NODELAY set
* Connected to  lb-ipv4-2 ( lb-ipv4-2) port 80 (#0)
> GET /roundrobbin HTTP/1.1
> Host:  lb-ipv4-2
> User-Agent: curl/7.64.1
> Accept: */*
>
< HTTP/1.1 404 Not Found
< date: Wed, 10 Nov 2021 17:05:27 GMT
< server: envoy
< Content-Length: 273
< content-type: text/html; charset=iso-8859-1
< via: 1.1 google
< test: value
<
{ [273 bytes data]
* Connection #0 to host 34.149.2.26 left intact
* Closing connection 0

7. Pulizia del lab

Ora che abbiamo finito di lavorare con l'ambiente del lab, è il momento di eliminarlo. Esegui questi comandi per eliminare l'ambiente di test.

Da Cloud Shell

gcloud compute instances delete siege-vm

gcloud alpha compute forwarding-rules delete http-content-rule --global
gcloud alpha compute target-http-proxies delete http-lb-proxy-adv
gcloud alpha compute url-maps delete web-map-http
gcloud alpha compute backend-services delete east-backend-service --global
gcloud alpha compute backend-services delete west-backend-service --global
gcloud alpha compute backend-services delete central-backend-service --global

gcloud compute addresses delete lb-ipv4-2 --global
gcloud compute health-checks delete http-basic-check 

gcloud compute instance-groups managed delete us-east1-mig --zone us-east1-b
gcloud compute instance-groups managed delete us-west1-mig --zone us-west1-a
gcloud compute instance-groups managed delete us-central1-mig --zone us-central1-a

gcloud compute instance-templates delete "us-east1-template" 
gcloud compute instance-templates delete "us-west1-template" 
gcloud compute instance-templates delete "us-central1-template" 

gcloud compute firewall-rules delete httplb-allow-http-rule
gcloud compute firewall-rules delete fw-allow-ssh

gcloud compute networks delete httplbs 

8. Complimenti

Hai completato il bilanciatore del carico HTTPs esterno con il codelab sulla gestione avanzata del traffico (Envoy).

Argomenti trattati

• Come configurare un gruppo di istanze gestite e le regole VPC e del firewall associate
• Come utilizzare le funzionalità avanzate di gestione del traffico del nuovo bilanciatore del carico
• Come verificare che le funzionalità avanzate di gestione del traffico funzionino come previsto.

Passaggi successivi

• Prova alcune delle altre funzionalità di routing avanzate come la riscrittura degli URL, l'aggiunta di intestazioni CORS e molte altre ( link)