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
- Ulteriori opzioni di affinità della sessione di backend
- Ulteriori opzioni di trasformazione dell'intestazione
- 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
- 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.
- 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 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 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 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 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 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 centrale al servizio di backend.
Da Cloud Shell
gcloud 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 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 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 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. Seleziona il bilanciatore del carico web-map-http. Vai alla scheda Monitoring e potrai vedere il grafico seguente.
Potrai vedere la suddivisione del traffico in tempo reale in questo gruppo di istanze gestite. Il traffico è suddiviso in modo uniforme poiché hai configurato una suddivisione 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 --zone=us-east4-c gcloud compute forwarding-rules delete http-content-rule --global gcloud compute target-http-proxies delete http-lb-proxy-adv gcloud compute url-maps delete web-map-http gcloud compute backend-services delete east-backend-service --global gcloud compute backend-services delete west-backend-service --global gcloud 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)