Questo documento fornisce istruzioni per configurare un bilanciatore del carico delle applicazioni interno tra regioni per i tuoi servizi eseguiti su istanze di macchine virtuali (VM) Compute Engine.
Prima di iniziare
Prima di seguire questa guida, acquisisci familiarità con quanto segue:
- Panoramica del bilanciatore del carico delle applicazioni interno, inclusa la sezione Limitazioni
- Panoramica delle regole firewall VPC
Configura una risorsa del certificato SSL
Crea una risorsa del certificato SSL del Gestore certificati come descritto di seguito:
- Esegui il deployment di un certificato autogestito globale.
- Crea un certificato gestito da Google emesso dalla tua istanza di Certificate Authority Service.
- Crea un certificato gestito da Google con autorizzazione DNS.
Ti consigliamo di utilizzare un certificato gestito da Google.
Autorizzazioni
Per seguire questa guida, devi essere in grado di creare istanze e modificare una rete in un progetto. Devi essere un proprietario o un editor del progetto oppure devi disporre di tutti i seguenti ruoli IAM di Compute Engine.
Attività | Ruolo richiesto |
---|---|
Crea reti, subnet e componenti del bilanciatore del carico | Amministratore rete Compute |
Aggiungi e rimuovi regole firewall | Amministratore sicurezza Compute |
Creare istanze | Amministratore istanze Compute |
Per ulteriori informazioni, consulta le seguenti guide:
Panoramica della configurazione
Puoi configurare il bilanciatore del carico come mostrato nel seguente diagramma:
Come mostrato nel diagramma, questo esempio crea un bilanciatore del carico delle applicazioni interno tra regioni in una rete VPC, con un servizio di backend e due gruppi di istanze gestite dal backend nelle regioni REGION_A
e REGION_B
.
Il diagramma mostra quanto segue:
Una rete VPC con le seguenti subnet:
- Subnet
SUBNET_A
e una subnet solo proxy inREGION_A
. - Subnet
SUBNET_B
e una subnet solo proxy inREGION_B
.
Devi creare subnet solo proxy in ogni regione di una rete VPC in cui utilizzi Application Load Balancer interni tra regioni. La subnet solo proxy della regione è condivisa tra tutti gli Application Load Balancer interni tra regioni della regione. Gli indirizzi di origine dei pacchetti inviati dal bilanciatore del carico ai backend del tuo servizio vengono allocati dalla subnet solo proxy. In questo esempio, la subnet solo proxy per la regione
REGION_A
ha un intervallo di indirizzi IP principali pari a10.129.0.0/23
e perREGION_B
ha un intervallo di indirizzi IP principali10.130.0.0/23
, che corrisponde alla dimensione consigliata della subnet.- Subnet
La configurazione dell'alta disponibilità prevede backend di gruppo di istanze gestite per i deployment delle VM di Compute Engine nelle regioni
REGION_A
eREGION_B
. Se i backend in un'area geografica sono inattivi, il traffico esegue il failover nell'altra regione.Un servizio di backend globale che monitora l'utilizzo e l'integrità dei backend.
Una mappa URL globale che analizza l'URL di una richiesta e inoltra le richieste a servizi di backend specifici in base all'host e al percorso dell'URL della richiesta.
Un proxy HTTP o HTTPS di destinazione globale riceve una richiesta dall'utente e la inoltra alla mappa degli URL. Per HTTPS, configura una risorsa del certificato SSL globale. Il proxy di destinazione utilizza il certificato SSL per decriptare il traffico SSL se configuri il bilanciamento del carico HTTPS. Il proxy di destinazione può inoltrare il traffico alle istanze tramite HTTP o HTTPS.
Le regole di forwarding globali prevedono l'indirizzo IP interno a livello di regione del bilanciatore del carico, per inoltrare ogni richiesta in entrata al proxy di destinazione.
L'indirizzo IP interno associato alla regola di forwarding può provenire da una subnet nella stessa rete e nella stessa regione dei backend. Tieni presente le seguenti condizioni:
- L'indirizzo IP può provenire (ma non è necessario) dalla stessa subnet dei gruppi di istanza di backend.
- L'indirizzo IP non deve provenire da una subnet solo proxy riservata con il flag
--purpose
impostato suGLOBAL_MANAGED_PROXY
. - Se vuoi utilizzare lo stesso indirizzo IP interno con più regole di forwarding, imposta il flag
--purpose
dell'indirizzo IP suSHARED_LOADBALANCER_VIP
.
Facoltativo: configura i criteri di routing DNS di tipo
GEO
per instradare il traffico client al VIP del bilanciatore del carico nella regione più vicina al client.
Configurare la rete e le subnet
All'interno della rete VPC, configura una subnet in ogni
regione in cui sono configurati i backend. Inoltre, configura un proxy-only-subnet
in ogni regione in cui vuoi configurare il bilanciatore del carico.
Questo esempio utilizza la seguente rete VPC, la regione e le subnet:
Rete. La rete è una rete VPC in modalità personalizzata denominata
NETWORK
.Subnet per i backend.
- Una subnet denominata
SUBNET_A
nella regioneREGION_A
utilizza10.1.2.0/24
come intervallo IP principale. - Una subnet denominata
SUBNET_B
nella regioneREGION_B
utilizza10.1.3.0/24
come intervallo IP principale.
- Una subnet denominata
Subnet per proxy.
- Una subnet denominata
PROXY_SN_A
nella regioneREGION_A
utilizza10.129.0.0/23
come intervallo IP principale. - Una subnet denominata
PROXY_SN_B
nella regioneREGION_B
utilizza10.130.0.0/23
come intervallo IP principale.
- Una subnet denominata
È possibile accedere ai bilanciatori del carico delle applicazioni interni tra regioni da qualsiasi regione all'interno del VPC. In questo modo, i client di qualsiasi regione possono accedere a livello globale ai backend del bilanciatore del carico.
Configura le subnet di backend
Console
Nella console Google Cloud, vai alla pagina Reti VPC.
Fai clic su Crea rete VPC.
Specifica un nome per la rete.
Nella sezione Subnet, imposta Modalità di creazione subnet su Personalizzata.
Crea una subnet per i backend del bilanciatore del carico. Nella sezione Nuova subnet, inserisci le informazioni seguenti:
- Specifica un nome per la subnet.
- Seleziona una regione: REGION_A
- Inserisci un intervallo di indirizzi IP:
10.1.2.0/24
Fai clic su Fine.
Fai clic su Aggiungi subnet.
Crea una subnet per i backend del bilanciatore del carico. Nella sezione Nuova subnet, inserisci le seguenti informazioni:
- Specifica un nome per la subnet.
- Seleziona una regione: REGION_B
- Inserisci un intervallo di indirizzi IP:
10.1.3.0/24
Fai clic su Fine.
Fai clic su Crea.
gcloud
Crea la rete VPC personalizzata con il comando
gcloud compute networks create
:gcloud compute networks create NETWORK \ --subnet-mode=custom
Crea una subnet nella rete
NETWORK
nella regioneREGION_A
con il comandogcloud compute networks subnets create
:gcloud compute networks subnets create SUBNET_A \ --network=NETWORK \ --range=10.1.2.0/24 \ --region=REGION_A
Crea una subnet nella rete
NETWORK
nella regioneREGION_B
con il comandogcloud compute networks subnets create
:gcloud compute networks subnets create SUBNET_B \ --network=NETWORK \ --range=10.1.3.0/24 \ --region=REGION_B
Terraform
Per creare la rete VPC, utilizza la risorsa google_compute_network
.
Per creare le subnet VPC nella rete lb-network-crs-reg
,
utilizza la risorsa google_compute_subnetwork
.
API
Invia una richiesta POST
al metodo networks.insert
.
Sostituisci PROJECT_ID
con l'ID progetto.
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks { "routingConfig": { "routingMode": "regional" }, "name": "NETWORK", "autoCreateSubnetworks": false }
Invia una richiesta POST
al metodo subnetworks.insert
.
Sostituisci PROJECT_ID
con l'ID progetto.
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION_A/subnetworks { "name": "SUBNET_A", "network": "projects/PROJECT_ID/global/networks/lb-network-crs-reg", "ipCidrRange": "10.1.2.0/24", "region": "projects/PROJECT_ID/regions/REGION_A", }
Invia una richiesta POST
al metodo subnetworks.insert
.
Sostituisci PROJECT_ID
con l'ID progetto.
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION_B/subnetworks { "name": "SUBNET_B", "network": "projects/PROJECT_ID/global/networks/NETWORK", "ipCidrRange": "10.1.3.0/24", "region": "projects/PROJECT_ID/regions/REGION_B", }
Configura la subnet solo proxy
Una subnet solo proxy fornisce un insieme di indirizzi IP che Google Cloud utilizza per eseguire i proxy Envoy per tuo conto. I proxy terminano le connessioni dal client e creano nuove connessioni ai backend.
Questa subnet solo proxy viene utilizzata da tutti i bilanciatori del carico a livello di regione basati su Envoy nella stessa regione della rete VPC. Può esistere una sola subnet solo proxy attiva per uno scopo specifico, per regione e per rete.
Console
Se utilizzi la console Google Cloud, puoi attendere e creare la subnet solo proxy in un secondo momento sulla pagina Bilanciamento del carico.
Se vuoi creare subito una subnet solo proxy, segui questi passaggi:
Nella console Google Cloud, vai alla pagina Reti VPC.
- Fai clic sul nome della rete VPC.
- Nella scheda Subnet, fai clic su Aggiungi subnet.
- Specifica un nome per la subnet solo proxy.
- Seleziona una regione: REGION_A
- Nell'elenco Scopo, seleziona Proxy gestito tra regioni.
- Nel campo Intervallo di indirizzi IP, inserisci
10.129.0.0/23
. - Fai clic su Aggiungi.
Crea la subnet solo proxy in REGION_B
- Nella scheda Subnet, fai clic su Aggiungi subnet.
- Specifica un nome per la subnet solo proxy.
- Seleziona una regione: REGION_B
- Nell'elenco Scopo, seleziona Proxy gestito tra regioni.
- Nel campo Intervallo di indirizzi IP, inserisci
10.130.0.0/23
. - Fai clic su Aggiungi.
gcloud
Crea le subnet solo proxy con il
comando gcloud compute networks subnets create
.
gcloud compute networks subnets create PROXY_SN_A \ --purpose=GLOBAL_MANAGED_PROXY \ --role=ACTIVE \ --region=REGION_A \ --network=NETWORK \ --range=10.129.0.0/23
gcloud compute networks subnets create PROXY_SN_B \ --purpose=GLOBAL_MANAGED_PROXY \ --role=ACTIVE \ --region=REGION_B \ --network=NETWORK \ --range=10.130.0.0/23
Terraform
Per creare la subnet solo proxy VPC nella rete lb-network-crs-reg
, utilizza la risorsa google_compute_subnetwork
.
API
Crea le subnet solo proxy con il
metodo subnetworks.insert
, sostituendo
PROJECT_ID
con il tuo ID progetto.
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION_A/subnetworks { "name": " PROXY_SN_A", "ipCidrRange": "10.129.0.0/23", "network": "projects/PROJECT_ID/global/networks/NETWORK", "region": "projects/PROJECT_ID/regions/REGION_A", "purpose": "GLOBAL_MANAGED_PROXY", "role": "ACTIVE" }
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION_B/subnetworks { "name": "PROXY_SN_B", "ipCidrRange": "10.130.0.0/23", "network": "projects/PROJECT_ID/global/networks/NETWORK", "region": "projects/PROJECT_ID/regions/REGION_B", "purpose": "GLOBAL_MANAGED_PROXY", "role": "ACTIVE" }
Configura le regole firewall
In questo esempio vengono utilizzate le seguenti regole firewall:
fw-ilb-to-backends. Una regola in entrata, applicabile alle istanze con bilanciamento del carico, che consente la connettività SSH in entrata sulla porta TCP
22
da qualsiasi indirizzo. Puoi scegliere un intervallo di indirizzi IP di origine più restrittivo per questa regola; ad esempio, puoi specificare solo gli intervalli di indirizzi IP del sistema da cui avvii le sessioni SSH. Questo esempio utilizza il tag di destinazioneallow-ssh
per identificare le VM a cui si applica la regola firewall.fw-healthcheck. Una regola in entrata, applicabile alle istanze con bilanciamento del carico, che consente tutto il traffico TCP dai sistemi di controllo di integrità di Google Cloud (in
130.211.0.0/22
e35.191.0.0/16
). Questo esempio utilizza il tag di destinazioneload-balanced-backend
per identificare le VM a cui si applica la regola firewall.fw-backends. Una regola in entrata, applicabile alle istanze con bilanciamento del carico, che consente il traffico TCP sulle porte
80
,443
e8080
dai proxy gestiti interni del bilanciatore del carico delle applicazioni. Questo esempio utilizza il tag di destinazioneload-balanced-backend
per identificare le VM a cui si applica la regola firewall.
Senza queste regole firewall, la regola predefinita nega il traffico in entrata blocca il traffico in entrata verso le istanze di backend.
I tag di destinazione definiscono le istanze di backend. Senza i tag di destinazione, le regole firewall si applicano a tutte le istanze di backend nella rete VPC. Quando crei le VM di backend, assicurati di includere i tag di destinazione specificati, come mostrato in Creazione di un gruppo di istanze gestite.
Console
Nella console Google Cloud, vai alla pagina Criteri firewall.
Fai clic su Crea regola firewall per creare la regola che consenta le connessioni SSH in entrata:
- Nome:
fw-ilb-to-backends
- Rete: NETWORK
- Direzione del traffico: in entrata
- Azione in caso di corrispondenza: Consenti
- Destinazioni: tag di destinazione specificati
- Tag di destinazione:
allow-ssh
- Filtro di origine: intervalli IPv4
- Intervalli IPv4 di origine:
0.0.0.0/0
- Protocolli e porte:
- Scegli Protocolli e porte specificati.
- Seleziona la casella di controllo TCP, quindi inserisci
22
per il numero di porta.
- Nome:
Fai clic su Crea.
Fai clic su Crea regola firewall una seconda volta per creare la regola e consentire i controlli di integrità di Google Cloud:
- Nome:
fw-healthcheck
- Rete: NETWORK
- Direzione del traffico: in entrata
- Azione in caso di corrispondenza: Consenti
- Destinazioni: tag di destinazione specificati
- Tag di destinazione:
load-balanced-backend
- Filtro di origine: intervalli IPv4
- Intervalli IPv4 di origine:
130.211.0.0/22
e35.191.0.0/16
Protocolli e porte:
- Scegli Protocolli e porte specificati.
- Seleziona la casella di controllo TCP, quindi inserisci
80
per il numero di porta.
Come best practice, limita questa regola solo ai protocolli e alle porte corrispondenti a quelli utilizzati dal controllo di integrità. Se utilizzi
tcp:80
per il protocollo e la porta, Google Cloud può utilizzare HTTP sulla porta80
per contattare le tue VM, ma non può utilizzare HTTPS sulla porta443
per contattarle.
- Nome:
Fai clic su Crea.
Fai clic su Crea regola firewall una terza volta per creare la regola in modo da consentire ai server proxy del bilanciatore del carico di connettere i backend:
- Nome:
fw-backends
- Rete: NETWORK
- Direzione del traffico: in entrata
- Azione in caso di corrispondenza: Consenti
- Destinazioni: tag di destinazione specificati
- Tag di destinazione:
load-balanced-backend
- Filtro di origine: intervalli IPv4
- Intervalli IPv4 di origine:
10.129.0.0/23
e10.130.0.0/23
- Protocolli e porte:
- Scegli Protocolli e porte specificati.
- Seleziona la casella di controllo TCP, quindi inserisci
80, 443, 8080
per i numeri di porta.
- Nome:
Fai clic su Crea.
gcloud
Crea la regola firewall
fw-ilb-to-backends
per consentire la connettività SSH alle VM con il tag di reteallow-ssh
. Se omettisource-ranges
, Google Cloud interpreta la regola in modo che indichi qualsiasi origine.gcloud compute firewall-rules create fw-ilb-to-backends \ --network=NETWORK \ --action=allow \ --direction=ingress \ --target-tags=allow-ssh \ --rules=tcp:22
Crea la regola
fw-healthcheck
per consentire i controlli di integrità di Google Cloud. Questo esempio consente tutto il traffico TCP dai prober del controllo di integrità. Tuttavia, puoi configurare un insieme più ristretto di porte per soddisfare le tue esigenze.gcloud compute firewall-rules create fw-healthcheck \ --network=NETWORK \ --action=allow \ --direction=ingress \ --source-ranges=130.211.0.0/22,35.191.0.0/16 \ --target-tags=load-balanced-backend \ --rules=tcp
Crea la regola
fw-backends
per consentire ai proxy del bilanciatore del carico delle applicazioni interno di connettersi ai tuoi backend. Impostasource-ranges
sugli intervalli allocati della subnet solo proxy, ad esempio10.129.0.0/23
e10.130.0.0/23
.gcloud compute firewall-rules create fw-backends \ --network=NETWORK \ --action=allow \ --direction=ingress \ --source-ranges=source-range \ --target-tags=load-balanced-backend \ --rules=tcp:80,tcp:443,tcp:8080
Terraform
Per creare le regole firewall, utilizza la risorsa google_compute_firewall
.
API
Crea la regola firewall fw-ilb-to-backends
effettuando una richiesta POST
al metodo firewalls.insert
, sostituendo PROJECT_ID
con il tuo ID progetto.
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls { "name": "fw-ilb-to-backends", "network": "projects/PROJECT_ID/global/networks/NETWORK", "sourceRanges": [ "0.0.0.0/0" ], "targetTags": [ "allow-ssh" ], "allowed": [ { "IPProtocol": "tcp", "ports": [ "22" ] } ], "direction": "INGRESS" }
Crea la regola firewall fw-healthcheck
effettuando una richiesta POST
al metodo firewalls.insert
, sostituendo PROJECT_ID
con il tuo ID progetto.
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls { "name": "fw-healthcheck", "network": "projects/PROJECT_ID/global/networks/NETWORK", "sourceRanges": [ "130.211.0.0/22", "35.191.0.0/16" ], "targetTags": [ "load-balanced-backend" ], "allowed": [ { "IPProtocol": "tcp" } ], "direction": "INGRESS" }
Crea la regola firewall fw-backends
per consentire il traffico TCP all'interno della subnet proxy per il metodo firewalls.insert
, sostituendo PROJECT_ID
con il tuo ID progetto.
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls { "name": "fw-backends", "network": "projects/PROJECT_ID/global/networks/NETWORK", "sourceRanges": [ "10.129.0.0/23", "10.130.0.0/23" ], "targetTags": [ "load-balanced-backend" ], "allowed": [ { "IPProtocol": "tcp", "ports": [ "80" ] }, { "IPProtocol": "tcp", "ports": [ "443" ] }, { "IPProtocol": "tcp", "ports": [ "8080" ] } ], "direction": "INGRESS" }
Creare un gruppo di istanze gestite
Questa sezione mostra come creare un modello e un gruppo di istanze gestite. Il gruppo di istanze gestite fornisce istanze VM che eseguono i server di backend di un Application Load Balancer interno di esempio tra regioni. Per il tuo gruppo di istanze, puoi definire un servizio HTTP e mappare il nome di una porta alla porta pertinente. Il servizio di backend del bilanciatore del carico inoltra il traffico alle porte con nome. Il traffico proveniente dai client viene bilanciato con il bilanciamento del carico verso i server di backend. A scopo dimostrativo, i backend gestiscono i propri nomi host.
Console
Nella console Google Cloud, vai alla pagina Modelli di istanza.
- Fai clic su Crea modello istanza.
- In Nome, inserisci
gil7-backendeast1-template
. - Assicurati che il disco di avvio sia impostato su un'immagine Debian, ad esempio Debian GNU/Linux 10 (buster). Queste istruzioni utilizzano comandi disponibili solo su Debian, come
apt-get
. - Fai clic su Opzioni avanzate.
- Fai clic su Networking e configura i seguenti campi:
- In Tag di rete, inserisci
allow-ssh
eload-balanced-backend
. - In Interfacce di rete, seleziona quanto segue:
- Rete: NETWORK
- Subnet: SUBNET_B
- In Tag di rete, inserisci
Fai clic su Gestione. Inserisci lo script seguente nel campo Script di avvio.
#! /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
Fai clic su Crea.
Fai clic su Crea modello istanza.
In Nome, inserisci
gil7-backendwest1-template
.Assicurati che il disco di avvio sia impostato su un'immagine Debian, ad esempio Debian GNU/Linux 10 (buster). Queste istruzioni utilizzano comandi disponibili solo su Debian, come
apt-get
.Fai clic su Opzioni avanzate.
Fai clic su Networking e configura i seguenti campi:
- In Tag di rete, inserisci
allow-ssh
eload-balanced-backend
. - In Interfacce di rete, seleziona quanto segue:
- Rete: NETWORK
- Subnet: SUBNET_A
- In Tag di rete, inserisci
Fai clic su Gestione. Inserisci lo script seguente nel campo Script di avvio.
#! /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
Fai clic su Crea.
Nella console Google Cloud, vai alla pagina Gruppi di istanze.
- Fai clic su Crea gruppo di istanze.
- Seleziona Nuovo gruppo di istanze gestite (stateless). Per ulteriori informazioni, consulta la pagina relativa a MIG stateless o stateful.
- In Nome, inserisci
gl7-ilb-mig-a
. - In Località, seleziona Zona singola.
- In Regione, seleziona REGION_A.
- In Zona, seleziona ZONE_A.
- In Modello di istanza, seleziona
gil7-backendwest1-template
. Specifica il numero di istanze che vuoi creare nel gruppo.
Per questo esempio, specifica le seguenti opzioni in Scalabilità automatica:
- In Modalità di scalabilità automatica, seleziona
Off:do not autoscale
. - In Numero massimo di istanze, inserisci
2
.
Facoltativamente, nella sezione Scalabilità automatica dell'interfaccia utente, puoi configurare il gruppo di istanze in modo da aggiungere o rimuovere automaticamente le istanze in base all'utilizzo della CPU delle istanze.
- In Modalità di scalabilità automatica, seleziona
Fai clic su Crea.
Fai clic su Crea gruppo di istanze.
Seleziona Nuovo gruppo di istanze gestite (stateless). Per ulteriori informazioni, consulta la pagina relativa a MIG stateless o stateful.
In Nome, inserisci
gl7-ilb-mig-b
.In Località, seleziona Zona singola.
In Regione, seleziona REGION_B.
In Zona, seleziona ZONE_B.
In Modello di istanza, seleziona
gil7-backendeast1-template
.Specifica il numero di istanze che vuoi creare nel gruppo.
Per questo esempio, specifica le seguenti opzioni in Scalabilità automatica:
- In Modalità di scalabilità automatica, seleziona
Off:do not autoscale
. - In Numero massimo di istanze, inserisci
2
.
Facoltativamente, nella sezione Scalabilità automatica dell'interfaccia utente, puoi configurare il gruppo di istanze in modo da aggiungere o rimuovere automaticamente le istanze in base all'utilizzo della CPU delle istanze.
- In Modalità di scalabilità automatica, seleziona
Fai clic su Crea.
gcloud
Le istruzioni di gcloud CLI in questa guida presuppongono che tu stia utilizzando Cloud Shell o un altro ambiente in cui è installato bash.
Crea un modello di istanza VM con server HTTP utilizzando il comando
gcloud compute instance-templates create
.gcloud compute instance-templates create gil7-backendwest1-template \ --region=REGION_A \ --network=NETWORK \ --subnet=SUBNET_A \ --tags=allow-ssh,load-balanced-backend \ --image-family=debian-10 \ --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'
gcloud compute instance-templates create gil7-backendeast1-template \ --region=REGION_B \ --network=NETWORK \ --subnet=SUBNET_B \ --tags=allow-ssh,load-balanced-backend \ --image-family=debian-10 \ --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'
Crea un gruppo di istanze gestite nella zona con il comando
gcloud compute instance-groups managed create
.gcloud compute instance-groups managed create gl7-ilb-mig-a \ --zone=ZONE_A \ --size=2 \ --template=gil7-backendwest1-template
gcloud compute instance-groups managed create gl7-ilb-mig-b \ --zone=ZONE_B \ --size=2 \ --template=gil7-backendeast1-template
Terraform
Per creare il modello di istanza, utilizza la risorsa google_compute_instance_template
.
Per creare il gruppo di istanze gestite, utilizza la risorsa google_compute_instance_group_manager
.
API
Crea il modello di istanza con il metodo instanceTemplates.insert
, sostituendo PROJECT_ID
con il tuo ID progetto.
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/instanceTemplates { "name":"gil7-backendwest1-template", "properties":{ "machineType":"e2-standard-2", "tags":{ "items":[ "allow-ssh", "load-balanced-backend" ] }, "metadata":{ "kind":"compute#metadata", "items":[ { "key":"startup-script", "value":"#! /bin/bash\napt-get update\napt-get install apache2 -y\na2ensite default-ssl\na2enmod ssl\n vm_hostname=\"$(curl -H \"Metadata-Flavor:Google\" \\\nhttp://169.254.169.254/computeMetadata/v1/instance/name)\"\n echo \"Page served from: $vm_hostname\" | \\\ntee /var/www/html/index.html\nsystemctl restart apache2" } ] }, "networkInterfaces":[ { "network":"projects/PROJECT_ID/global/networks/NETWORK", "subnetwork":"regions/REGION_A/subnetworks/SUBNET_A", "accessConfigs":[ { "type":"ONE_TO_ONE_NAT" } ] } ], "disks":[ { "index":0, "boot":true, "initializeParams":{ "sourceImage":"projects/debian-cloud/global/images/family/debian-10" }, "autoDelete":true } ] } }
Crea un gruppo di istanze gestite in ogni zona con il metodo instanceGroupManagers.insert
, sostituendo PROJECT_ID
con il tuo ID progetto.
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/{zone}/instanceGroupManagers { "name": "gl7-ilb-mig-a", "zone": "projects/PROJECT_ID/zones/ZONE_A", "instanceTemplate": "projects/PROJECT_ID/global/instanceTemplates/gil7-backendwest1-template", "baseInstanceName": "gl7-ilb-mig-b", "targetSize": 2 }
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/instanceTemplates { "name":"gil7-backendeast1-template", "properties":{ "machineType":"e2-standard-2", "tags":{ "items":[ "allow-ssh", "load-balanced-backend" ] }, "metadata":{ "kind":"compute#metadata", "items":[ { "key":"startup-script", "value":"#! /bin/bash\napt-get update\napt-get install apache2 -y\na2ensite default-ssl\na2enmod ssl\n vm_hostname=\"$(curl -H \"Metadata-Flavor:Google\" \\\nhttp://169.254.169.254/computeMetadata/v1/instance/name)\"\n echo \"Page served from: $vm_hostname\" | \\\ntee /var/www/html/index.html\nsystemctl restart apache2" } ] }, "networkInterfaces":[ { "network":"projects/PROJECT_ID/global/networks/NETWORK", "subnetwork":"regions/REGION_B/subnetworks/SUBNET_B", "accessConfigs":[ { "type":"ONE_TO_ONE_NAT" } ] } ], "disks":[ { "index":0, "boot":true, "initializeParams":{ "sourceImage":"projects/debian-cloud/global/images/family/debian-10" }, "autoDelete":true } ] } }
Crea un gruppo di istanze gestite in ogni zona con il metodo instanceGroupManagers.insert
, sostituendo PROJECT_ID
con il tuo ID progetto.
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/{zone}/instanceGroupManagers { "name": "gl7-ilb-mig-b", "zone": "projects/PROJECT_ID/zones/ZONE_B", "instanceTemplate": "projects/PROJECT_ID/global/instanceTemplates/gil7-backendwest1-template", "baseInstanceName": "gl7-ilb-mig-b", "targetSize": 2 }
configura il bilanciatore del carico
Questo esempio mostra come creare le seguenti risorse del bilanciatore del carico delle applicazioni interno tra regioni:
- Un controllo di integrità HTTP globale.
- Un servizio di backend globale con i gruppi di istanze gestite come backend.
- Una mappa URL. Assicurati di fare riferimento a una mappa URL globale per il proxy HTTP(S) di destinazione. Una mappa URL globale instrada le richieste a un servizio di backend globale in base a regole che hai definito per l'host e il percorso di un URL in entrata. Una regola del proxy di destinazione globale può fare riferimento a una mappa URL globale.
- Un certificato SSL globale (per HTTPS).
- Un proxy di destinazione globale.
Due regole di forwarding globali con indirizzi IP a livello di regione. Per l'indirizzo IP della regola di forwarding, utilizza l'intervallo di indirizzi IP
SUBNET_A
oSUBNET_B
. Se provi a utilizzare la subnet solo proxy, la creazione della regola di forwarding non va a buon fine.
Console
Avvia la configurazione
Nella console Google Cloud, vai alla pagina Bilanciamento del carico.
- Fai clic su Crea bilanciatore del carico.
- In Tipo di bilanciatore del carico, seleziona Bilanciatore del carico delle applicazioni (HTTP/HTTPS) e fai clic su Avanti.
- In Pubblico o interno, seleziona Interno e fai clic su Avanti.
- Per Deployment tra regioni o regioni singole, seleziona Ideale per carichi di lavoro tra regioni e fai clic su Avanti.
- Fai clic su Configura.
Configurazione di base
- Specifica un nome per il bilanciatore del carico.
- In Rete, seleziona NETWORK.
Configura il frontend con due regole di forwarding
Per HTTP:
- Fai clic su Configurazione frontend.
- Specifica un nome per la regola di forwarding.
- Nell'elenco Regione subnet, seleziona REGION_A.
Prenota una subnet solo proxy
- Nell'elenco Subnet, seleziona SUBNET_A.
- Nell'elenco Indirizzo IP, fai clic su Crea indirizzo IP. Viene visualizzata la pagina Prenota un indirizzo IP interno statico.
- Specifica un nome per l'indirizzo IP statico.
- Nell'elenco Indirizzo IP statico, seleziona Fammi scegliere.
- Nel campo Indirizzo IP personalizzato, inserisci
10.1.2.99
. - Seleziona Prenota.
- Fai clic su Fine.
- Per aggiungere la seconda regola di forwarding, fai clic su Aggiungi IP e porta frontend.
- Specifica un nome per la regola di forwarding.
- Nell'elenco Regione subnet, seleziona REGION_B.
Prenota una subnet solo proxy
- Nell'elenco Subnet, seleziona SUBNET_B.
- Nell'elenco Indirizzo IP, fai clic su Crea indirizzo IP. Viene visualizzata la pagina Prenota un indirizzo IP interno statico.
- Specifica un nome per l'indirizzo IP statico.
- Nell'elenco Indirizzo IP statico, seleziona Fammi scegliere.
- Nel campo Indirizzo IP personalizzato, inserisci
10.1.3.99
. - Seleziona Prenota.
- Fai clic su Fine.
Per HTTPS:
Se utilizzi HTTPS tra il client e il bilanciatore del carico, sono necessarie una o più risorse del certificato SSL per configurare il proxy.
Per creare un certificato all-regions
gestito da Google, consulta la seguente documentazione:
- Crea un certificato gestito da Google emesso dalla tua istanza di Certificate Authority Service.
- Crea un certificato gestito da Google con autorizzazione DNS.
Dopo aver creato il certificato gestito da Google, collegalo direttamente al proxy di destinazione. Le mappe di certificati non sono supportate dai bilanciatori del carico delle applicazioni interni tra regioni.
Per creare un certificato autogestito all-regions
, consulta la seguente documentazione:
Esegui il deployment di un certificato autogestito a livello di regione.
- Fai clic su Configurazione frontend.
- Specifica un nome per la regola di forwarding.
- Nel campo Protocollo, seleziona
HTTPS (includes HTTP/2)
. - Verifica che la porta sia impostata su
443
. - Nell'elenco Regione subnet, seleziona REGION_A.
Prenota una subnet solo proxy
- Nell'elenco Subnet, seleziona SUBNET_A.
- Nell'elenco Indirizzo IP, fai clic su Crea indirizzo IP. Viene visualizzata la pagina Prenota un indirizzo IP interno statico.
- Specifica un nome per l'indirizzo IP statico.
- Nell'elenco Indirizzo IP statico, seleziona Fammi scegliere.
- Nel campo Indirizzo IP personalizzato, inserisci
10.1.3.99
. - Seleziona Prenota.
- Nella sezione Aggiungi certificato, seleziona il certificato.
- (Facoltativo) Per aggiungere certificati oltre al certificato SSL principale:
- Fai clic su Aggiungi certificato.
- Seleziona il certificato dall'elenco.
- Seleziona un criterio SSL dall'elenco dei criteri SSL. Se non hai creato alcun criterio SSL, viene applicato un criterio Google Cloud SSL predefinito.
- Fai clic su Fine.
- Specifica un nome per la configurazione del frontend.
- Nel campo Protocollo, seleziona
HTTPS (includes HTTP/2)
. - Verifica che la porta sia impostata su
443
. - Nell'elenco Regione subnet, seleziona REGION_B.
Prenota una subnet solo proxy
- Nell'elenco Subnet, seleziona SUBNET_B.
- Nell'elenco Indirizzo IP, fai clic su Crea indirizzo IP. Viene visualizzata la pagina Prenota un indirizzo IP interno statico.
- Specifica un nome per l'indirizzo IP statico.
- Nell'elenco Indirizzo IP statico, seleziona Fammi scegliere.
- Nel campo Indirizzo IP personalizzato, inserisci
10.1.3.99
. - Seleziona Prenota.
- Nella sezione Aggiungi certificato, seleziona il certificato.
- (Facoltativo) Per aggiungere certificati oltre al certificato SSL principale:
- Fai clic su Aggiungi certificato.
- Seleziona il certificato dall'elenco.
- Seleziona un criterio SSL dall'elenco dei criteri SSL. Se non hai creato alcun criterio SSL, viene applicato un criterio Google Cloud SSL predefinito.
- Fai clic su Fine.
- Fai clic su Configurazione backend.
- Nell'elenco Crea o seleziona servizi di backend, fai clic su Crea un servizio di backend.
- Specifica un nome per il servizio di backend.
- In Protocollo, seleziona HTTP.
- In Porta denominata, inserisci
http
. - Nell'elenco Tipo di backend, seleziona Gruppo di istanze.
- Nella sezione Nuovo backend:
- Nell'elenco Gruppo di istanze, seleziona
gl7-ilb-mig-a
in REGION_A. - Imposta Numeri di porta su
80
. - Fai clic su Fine.
- Per aggiungere un altro backend, fai clic su Aggiungi backend.
- Nell'elenco Gruppo di istanze, seleziona
gl7-ilb-mig-b
in REGION_B. - Imposta Numeri di porta su
80
. - Fai clic su Fine.
- Nell'elenco Controllo di integrità, fai clic su Crea un controllo di integrità.
- Nel campo Nome, inserisci
global-http-health-check
. - Imposta Protocollo su
HTTP
. - Imposta Porta su
80
. - Fai clic su Salva.
- Fai clic su Regole di routing.
- In Modalità, seleziona Regola host e percorso semplice.
- Assicurati che esista un solo servizio di backend per qualsiasi host senza corrispondenza e qualsiasi percorso senza corrispondenza.
- Fai clic su Esamina e finalizza.
- Rivedi le impostazioni di configurazione del bilanciatore del carico.
- Fai clic su Crea.
Aggiungi la seconda configurazione di frontend:
Configurare le regole di routing
Esamina la configurazione
gcloud
Definisci il controllo di integrità HTTP con il comando
gcloud compute health-checks create http
.gcloud compute health-checks create http global-http-health-check \ --use-serving-port \ --global
Definisci il servizio di backend con il comando
gcloud compute backend-services create
.gcloud compute backend-services create BACKEND_SERVICE_NAME \ --load-balancing-scheme=INTERNAL_MANAGED \ --protocol=HTTP \ --enable-logging \ --logging-sample-rate=1.0 \ --health-checks=global-http-health-check \ --global-health-checks \ --global
Aggiungi backend al servizio di backend con il comando
gcloud compute backend-services add-backend
.gcloud compute backend-services add-backend BACKEND_SERVICE_NAME \ --balancing-mode=UTILIZATION \ --instance-group=gl7-ilb-mig-a \ --instance-group-zone=ZONE_A \ --global
gcloud compute backend-services add-backend BACKEND_SERVICE_NAME \ --balancing-mode=UTILIZATION \ --instance-group=gl7-ilb-mig-b \ --instance-group-zone=ZONE_B \ --global
Crea la mappa degli URL con il comando
gcloud compute url-maps create
.gcloud compute url-maps create gl7-gilb-url-map \ --default-service=BACKEND_SERVICE_NAME \ --global
Crea il proxy di destinazione.
Per HTTP:
Crea il proxy di destinazione con il comando
gcloud compute target-http-proxies create
.gcloud compute target-http-proxies create gil7-http-proxy \ --url-map=gl7-gilb-url-map \ --global
Per HTTPS:
Per creare un certificato gestito da Google, consulta la seguente documentazione:
- Crea un certificato gestito da Google emesso dalla tua istanza di Certificate Authority Service.
- Crea un certificato gestito da Google con autorizzazione DNS.
Dopo aver creato il certificato gestito da Google, collegalo direttamente al proxy di destinazione. Le mappe di certificati non sono supportate dai bilanciatori del carico delle applicazioni interni tra regioni.
Per creare un certificato autogestito, consulta la seguente documentazione:
Assegna i percorsi dei file ai nomi delle variabili.
export LB_CERT=PATH_TO_PEM_FORMATTED_FILE
export LB_PRIVATE_KEY=PATH_TO_LB_PRIVATE_KEY_FILE
Crea un certificato SSL per tutte le regioni utilizzando il comando
gcloud beta certificate-manager certificates create
.gcloud certificate-manager certificates create gilb-certificate \ --private-key-file=$LB_PRIVATE_KEY \ --certificate-file=$LB_CERT \ --scope=all-regions
Utilizza il certificato SSL per creare un proxy di destinazione con il comando
gcloud compute target-https-proxies create
gcloud compute target-https-proxies create gil7-https-proxy \ --url-map=gl7-gilb-url-map \ --certificate-manager-certificates=gilb-certificate \ --global
Crea due regole di forwarding, una con un VIP (
10.1.2.99
) nella regioneREGION_B
e un'altra con un VIP (10.1.3.99
) nella regioneREGION_A
. Per maggiori informazioni, consulta Prenotare un indirizzo IPv4 interno statico.Per le reti personalizzate, devi fare riferimento alla subnet nella regola di forwarding. Tieni presente che si tratta della subnet della VM, non del proxy.
Per HTTP:
Utilizza il comando
gcloud compute forwarding-rules create
con i flag corretti.gcloud compute forwarding-rules create FWRULE_A \ --load-balancing-scheme=INTERNAL_MANAGED \ --network=NETWORK \ --subnet=SUBNET_A \ --subnet-region=REGION_A \ --address=10.1.2.99 \ --ports=80 \ --target-http-proxy=gil7-http-proxy \ --global
gcloud compute forwarding-rules create FWRULE_B \ --load-balancing-scheme=INTERNAL_MANAGED \ --network=NETWORK \ --subnet=SUBNET_B \ --subnet-region=REGION_B \ --address=10.1.3.99 \ --ports=80 \ --target-http-proxy=gil7-http-proxy \ --global
Per HTTPS:
Utilizza il comando
gcloud compute forwarding-rules create
con i flag corretti.gcloud compute forwarding-rules create FWRULE_A \ --load-balancing-scheme=INTERNAL_MANAGED \ --network=NETWORK \ --subnet=SUBNET_A \ --subnet-region=REGION_A \ --address=10.1.2.99 \ --ports=443 \ --target-https-proxy=gil7-https-proxy \ --global
gcloud compute forwarding-rules create FWRULE_B \ --load-balancing-scheme=INTERNAL_MANAGED \ --network=NETWORK \ --subnet=SUBNET_B \ --subnet-region=REGION_B \ --address=10.1.3.99 \ --ports=443 \ --target-https-proxy=gil7-https-proxy \ --global
Terraform
Per creare il controllo di integrità, utilizza la risorsa google_compute_health_check
.
Per creare il servizio di backend, utilizza la risorsa google_compute_backend_service
.
Per creare la mappa URL, utilizza la risorsa google_compute_url_map
.
Per creare il proxy HTTP di destinazione, utilizza la risorsa google_compute_target_http_proxy
.
Per creare le regole di forwarding, utilizza la risorsa google_compute_forwarding_rule
.
Per scoprire come applicare o rimuovere una configurazione Terraform, consulta Comandi Terraform di base.
API
Crea il controllo di integrità effettuando una richiesta POST
al
metodo healthChecks.insert
,
sostituendo PROJECT_ID
con il tuo ID progetto.
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/healthChecks { "name": "global-http-health-check", "type": "HTTP", "httpHealthCheck": { "portSpecification": "USE_SERVING_PORT" } }
Crea il servizio di backend globale effettuando una richiesta POST
al metodo backendServices.insert
, sostituendo PROJECT_ID
con il tuo ID progetto.
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/backendServices { "name": "BACKEND_SERVICE_NAME", "backends": [ { "group": "projects/PROJECT_ID/zones/ZONE_A/instanceGroups/gl7-ilb-mig-a", "balancingMode": "UTILIZATION" }, { "group": "projects/PROJECT_ID/zones/ZONE_B/instanceGroups/gl7-ilb-mig-b", "balancingMode": "UTILIZATION" } ], "healthChecks": [ "projects/PROJECT_ID/regions/global/healthChecks/global-http-health-check" ], "loadBalancingScheme": "INTERNAL_MANAGED" }
Crea la mappa URL inviando una richiesta POST
al
metodo urlMaps.insert
,
sostituendo PROJECT_ID
con l'ID progetto.
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/urlMaps { "name": "l7-ilb-map", "defaultService": "projects/PROJECT_ID/global/backendServices/BACKEND_SERVICE_NAME" }
Per HTTP:
Crea il proxy HTTP di destinazione effettuando una richiesta POST
al metodo targetHttpProxies.insert
, sostituendo PROJECT_ID
con il tuo ID progetto.
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/targetHttpProxy { "name": "l7-ilb-proxy", "urlMap": "projects/PROJECT_ID/global/urlMaps/l7-ilb-map" }
Crea la regola di forwarding effettuando una richiesta POST
al metodo forwardingRules.insert
, sostituendo PROJECT_ID
con il tuo ID progetto.
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/forwardingRules { "name": "FWRULE_A", "IPAddress": "10.1.2.99", "IPProtocol": "TCP", "portRange": "80-80", "target": "projects/PROJECT_ID/global/targetHttpProxies/l7-ilb-proxy", "loadBalancingScheme": "INTERNAL_MANAGED", "subnetwork": "projects/PROJECT_ID/regions/REGION_A/subnetworks/SUBNET_A", "network": "projects/PROJECT_ID/global/networks/NETWORK", "networkTier": "PREMIUM" }
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/forwardingRules { "name": "gil7forwarding-rule-b", "IPAddress": "10.1.3.99", "IPProtocol": "TCP", "portRange": "80-80", "target": "projects/PROJECT_ID/global/targetHttpProxies/l7-ilb-proxy", "loadBalancingScheme": "INTERNAL_MANAGED", "subnetwork": "projects/PROJECT_ID/regions/REGION_B/subnetworks/SUBNET_B", "network": "projects/PROJECT_ID/global/networks/NETWORK", "networkTier": "PREMIUM" }
Per HTTPS:
Leggi i file del certificato e della chiave privata, quindi crea il certificato SSL. L'esempio seguente mostra come eseguire questa operazione con Python.
Crea il proxy HTTPS di destinazione effettuando una richiesta POST
al metodo targetHttpsProxies.insert
, sostituendo PROJECT_ID
con il tuo ID progetto.
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/targetHttpsProxy { "name": "l7-ilb-proxy", "urlMap": "projects/PROJECT_ID/global/urlMaps/l7-ilb-map", "sslCertificates": /projects/PROJECT_ID/global/sslCertificates/SSL_CERT_NAME }
Crea la regola di forwarding effettuando una richiesta POST
al metodo globalForwardingRules.insert
, sostituendo PROJECT_ID
con il tuo ID progetto.
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/forwardingRules { "name": "FWRULE_A", "IPAddress": "10.1.2.99", "IPProtocol": "TCP", "portRange": "80-80", "target": "projects/PROJECT_ID/global/targetHttpsProxies/l7-ilb-proxy", "loadBalancingScheme": "INTERNAL_MANAGED", "subnetwork": "projects/PROJECT_ID/regions/REGION_A/subnetworks/SUBNET_A", "network": "projects/PROJECT_ID/global/networks/NETWORK", "networkTier": "PREMIUM" }
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/forwardingRules { "name": "FWRULE_B", "IPAddress": "10.1.3.99", "IPProtocol": "TCP", "portRange": "80-80", "target": "projects/PROJECT_ID/global/targetHttpsProxies/l7-ilb-proxy", "loadBalancingScheme": "INTERNAL_MANAGED", "subnetwork": "projects/PROJECT_ID/regions/REGION_B/subnetworks/SUBNET_B", "network": "projects/PROJECT_ID/global/networks/NETWORK", "networkTier": "PREMIUM" }
Testa il bilanciatore del carico
Crea un'istanza VM per testare la connettività
Crea una VM client:
gcloud compute instances create l7-ilb-client-a \ --image-family=debian-10 \ --image-project=debian-cloud \ --network=NETWORK \ --subnet=SUBNET_A \ --zone=ZONE_A \ --tags=allow-ssh
gcloud compute instances create l7-ilb-client-b \ --image-family=debian-10 \ --image-project=debian-cloud \ --network=NETWORK \ --subnet=SUBNET_B \ --zone=ZONE_B \ --tags=allow-ssh
Utilizza SSH per connetterti a ciascuna istanza client.
gcloud compute ssh l7-ilb-client-a --zone=ZONE_A
gcloud compute ssh l7-ilb-client-b --zone=ZONE_B
Verifica che l'indirizzo IP fornisca il nome host
Verifica che la VM client possa raggiungere entrambi gli indirizzi IP. Il comando restituisce il nome della VM di backend che ha pubblicato la richiesta:
curl 10.1.2.99
curl 10.1.3.99
Per il test HTTPS, sostituisci
curl
con la riga di comando seguente:curl -k 'https://test.example.com:443' --connect-to test.example.com:443:10.1.2.99:443
curl -k 'https://test.example.com:443' --connect-to test.example.com:443:10.1.3.99:443
Il flag
-k
fa sì che curl ignori la convalida del certificato.(Facoltativo) Utilizza il record DNS configurato per risolvere l'indirizzo IP più vicino alla VM client. Ad esempio, DNS_NAME può essere
service.example.com
.curl DNS_NAME
Eseguire 100 richieste e verificare che siano con bilanciamento del carico
Per HTTP:
{ RESULTS= for i in {1..100} do RESULTS="$RESULTS:$(curl --silent 10.1.2.99)" done echo "" echo " Results of load-balancing to 10.1.2.99: " echo "***" echo "$RESULTS" | tr ':' '\n' | grep -Ev "^$" | sort | uniq -c echo }
{ RESULTS= for i in {1..100} do RESULTS="$RESULTS:$(curl --silent 10.1.3.99)" done echo "" echo " Results of load-balancing to 10.1.3.99: " echo "***" echo "$RESULTS" | tr ':' '\n' | grep -Ev "^$" | sort | uniq -c echo }
Per HTTPS:
{ RESULTS= for i in {1..100} do RESULTS="$RESULTS:$(curl -k -s 'https://test.example.com:443' --connect-to test.example.com:443:10.1.2.99:443)" done echo "" echo " Results of load-balancing to 10.1.2.99: " echo "***" echo "$RESULTS" | tr ':' '\n' | grep -Ev "^$" | sort | uniq -c echo }
{ RESULTS= for i in {1..100} do RESULTS="$RESULTS:$(curl -k -s 'https://test.example.com:443' --connect-to test.example.com:443:10.1.3.99:443)" done echo "" echo " Results of load-balancing to 10.1.3.99: " echo "***" echo "$RESULTS" | tr ':' '\n' | grep -Ev "^$" | sort | uniq -c echo }
Testa il failover
Verifica il failover ai backend nella regione
REGION_A
quando i backend inREGION_B
non sono integri o non raggiungibili. Per simulare il failover, rimuovi tutti i backend daREGION_B
:gcloud compute backend-services remove-backend BACKEND_SERVICE_NAME \ --balancing-mode=UTILIZATION \ --instance-group=gl7-ilb-mig-b \ --instance-group-zone=ZONE_B
Connettiti tramite SSH a una VM client in REGION_B.
gcloud compute ssh l7-ilb-client-b \ --zone=ZONE_B
Invia richieste all'indirizzo IP con bilanciamento del carico nella regione
REGION_B
. L'output comando mostra le risposte delle VM di backend inREGION_A
:{ RESULTS= for i in {1..100} do RESULTS="$RESULTS:$(curl -k -s 'https://test.example.com:443' --connect-to test.example.com:443:10.1.3.99:443)" done echo "***" echo "*** Results of load-balancing to 10.1.3.99: " echo "***" echo "$RESULTS" | tr ':' '\n' | grep -Ev "^$" | sort | uniq -c echo }
Opzioni di configurazione aggiuntive
Questa sezione espande l'esempio di configurazione per fornire opzioni di configurazione alternative e aggiuntive. Tutte le attività sono facoltative. Puoi eseguirli in qualsiasi ordine.
Abilita affinità sessione
Queste procedure mostrano come aggiornare un servizio di backend per l'Application Load Balancer interno regionale o per l'Application Load Balancer interno tra regioni in modo che il servizio di backend utilizzi l'affinità cookie generato, l'affinità del campo dell'intestazione o l'affinità dei cookie HTTP.
Quando è abilitata l'affinità cookie generato, il bilanciatore del carico invia un cookie alla prima richiesta. Per ogni richiesta successiva con lo stesso cookie, il bilanciatore del carico indirizza la richiesta alla stessa istanza di macchina virtuale (VM) di backend o allo stesso endpoint. In questo esempio, il cookie è denominato GCILB
.
Quando l'affinità del campo intestazione è abilitata, il bilanciatore del carico instrada le richieste a VM o endpoint di backend in un gruppo di endpoint di rete (NEG) in base al valore dell'intestazione HTTP denominata nel flag --custom-request-header
.
L'affinità del campo dell'intestazione è valida solo se il criterio di località del bilanciamento del carico è RING_HASH
o MAGLEV
e l'hash coerente del servizio di backend specifica il nome dell'intestazione HTTP.
Quando l'affinità dei cookie HTTP è abilitata, il bilanciatore del carico instrada le richieste a VM o endpoint di backend in un NEG, in base a un cookie HTTP denominato nel flag HTTP_COOKIE
con il flag --affinity-cookie-ttl
facoltativo. Se il client non fornisce il cookie nella sua richiesta HTTP, il proxy genera il cookie e lo restituisce al client in un'intestazione Set-Cookie
. L'affinità dei cookie HTTP è valida solo se il criterio di località del bilanciamento del carico è RING_HASH
o MAGLEV
e l'hash coerente del servizio di backend specifica il cookie HTTP.
Console
Per abilitare o modificare l'affinità sessione per un servizio di backend:
Nella console Google Cloud, vai alla pagina Bilanciamento del carico.
- Fai clic su Backend.
- Fai clic su gil7-backend-service (il nome del servizio di backend creato per questo esempio), quindi fai clic su Modifica.
- Nella pagina Dettagli del servizio di backend, fai clic su Configurazione avanzata.
- In Affinità sessione, seleziona il tipo di affinità sessione che vuoi.
- Fai clic su Update (Aggiorna).
gcloud
Utilizza i seguenti comandi di Google Cloud CLI per aggiornare il servizio di backend a diversi tipi di affinità sessione:
gcloud compute backend-services update gil7-backend-service \ --session-affinity=[GENERATED_COOKIE | HEADER_FIELD | HTTP_COOKIE | CLIENT_IP] \ --global
API
Per impostare l'affinità sessione, crea una richiesta "PATCH" al metodo
backendServices/patch
.
PATCH https://compute.googleapis.com/compute/v1/projects/[PROJECT_ID]/global/backendServices/gil7-backend-service { "sessionAffinity": ["GENERATED_COOKIE" | "HEADER_FIELD" | "HTTP_COOKIE" | "CLIENT_IP" ] }
Limita i client che possono inviare traffico al bilanciatore del carico
Puoi impedire ai client di connettersi a un VIP della regola di forwarding del bilanciatore del carico delle applicazioni interno configurando le regole firewall in uscita su questi client. Imposta queste regole firewall su VM client specifiche in base agli account di servizio o ai tag.
Non puoi utilizzare le regole firewall per limitare il traffico in entrata a VIP specifici delle regola di forwarding del bilanciatore del carico delle applicazioni interno. Qualsiasi client sulla stessa rete VPC e nella stessa regione del VIP della regola di forwarding può in genere inviare il traffico al VIP della regola di forwarding.
Inoltre, tutte le richieste ai backend provengono da proxy che utilizzano indirizzi IP nell'intervallo di subnet solo proxy. Non è possibile creare regole firewall che consentono o negano il traffico in entrata in questi backend in base al VIP della regola di forwarding utilizzato da un client.
Ecco alcuni esempi di come utilizzare le regole firewall in uscita per limitare il traffico al VIP della regola di forwarding del bilanciatore del carico.
Console
Per identificare le VM client, tagga le VM specifiche che vuoi limitare. Questi tag vengono utilizzati per associare le regole firewall
alle VM client con tag. Poi, aggiungi il tag al campo TARGET_TAG
nei seguenti passaggi.
Utilizza una singola regola firewall o più regole per configurarlo.
Singola regola firewall in uscita
Puoi configurare una regola firewall in uscita per negare tutto il traffico in uscita dalle VM client con tag al VIP di un bilanciatore del carico.
Nella console Google Cloud, vai alla pagina Regole firewall.
Fai clic su Crea regola firewall per creare la regola per negare il traffico in uscita dalle VM client con tag al VIP di un bilanciatore del carico.
- Nome:
fr-deny-access
- Rete:
lb-network
- Priorità:
100
- Direzione del traffico: In uscita
- Azione in caso di corrispondenza: Rifiuta
- Destinazioni: tag di destinazione specificati
- Tag di destinazione:
TARGET_TAG
- Filtro di destinazione: intervalli IP
- Intervalli IP di destinazione:
10.1.2.99
- Protocolli e porte:
- Scegli Protocolli e porte specificati.
- Seleziona la casella di controllo tcp, quindi inserisci
80
come numero di porta.
- Nome:
Fai clic su Crea.
Più regole firewall in uscita
Un approccio più scalabile prevede l'impostazione di due regole. Una regola predefinita a bassa priorità che impedisce a tutti i client di accedere al VIP del bilanciatore del carico. Una seconda regola con priorità più alta che consente a un sottoinsieme di client con tag di accedere al VIP del bilanciatore del carico. Solo le VM con tag possono accedere al VIP.
Nella console Google Cloud, vai alla pagina Regole firewall.
Fai clic su Crea regola firewall per creare la regola di priorità inferiore per negare l'accesso per impostazione predefinita:
- Nome:
fr-deny-all-access-low-priority
- Rete:
lb-network
- Priorità:
200
- Direzione del traffico: In uscita
- Azione in caso di corrispondenza: Rifiuta
- Destinazioni: tag di destinazione specificati
- Tag di destinazione:
TARGET_TAG
- Filtro di destinazione: intervalli IP
- Intervalli IP di destinazione:
10.1.2.99
- Protocolli e porte:
- Scegli Protocolli e porte specificati.
- Seleziona la casella di controllo TCP, quindi inserisci
80
per il numero di porta.
- Nome:
Fai clic su Crea.
Fai clic su Crea regola firewall per creare una regola di priorità più elevata che consenta il traffico da determinate istanze con tag.
- Nome:
fr-allow-some-access-high-priority
- Rete:
lb-network
- Priorità:
100
- Direzione del traffico: In uscita
- Azione in caso di corrispondenza: Consenti
- Destinazioni: tag di destinazione specificati
- Tag di destinazione:
TARGET_TAG
- Filtro di destinazione: intervalli IP
- Intervalli IP di destinazione:
10.1.2.99
- Protocolli e porte:
- Scegli Protocolli e porte specificati.
- Seleziona la casella di controllo TCP, quindi inserisci
80
per il numero di porta.
- Nome:
Fai clic su Crea.
gcloud
Per identificare le VM client, tagga le VM specifiche che vuoi limitare. Poi aggiungi il tag al campo TARGET_TAG
come descritto di seguito.
Utilizza una singola regola firewall o più regole per configurarlo.
Singola regola firewall in uscita
Puoi configurare una regola firewall in uscita per negare tutto il traffico in uscita dalle VM client con tag al VIP di un bilanciatore del carico.
gcloud compute firewall-rules create fr-deny-access \ --network=lb-network \ --action=deny \ --direction=egress \ --rules=tcp \ --priority=100 \ --destination-ranges=10.1.2.99 \ --target-tags=TARGET_TAG
Più regole firewall in uscita
Un approccio più scalabile comporta l'impostazione di due regole: una regola predefinita a priorità bassa che impedisce a tutti i client di accedere al VIP del bilanciatore del carico e una seconda regola con priorità più alta che consente a un sottoinsieme di client con tag di accedere al VIP del bilanciatore del carico. Solo le VM con tag possono accedere al VIP.
Crea la regola di priorità più bassa:
gcloud compute firewall-rules create fr-deny-all-access-low-priority \ --network=lb-network \ --action=deny \ --direction=egress \ --rules=tcp \ --priority=200 \ --destination-ranges=10.1.2.99
Crea la regola con priorità più alta:
gcloud compute firewall-rules create fr-allow-some-access-high-priority \ --network=lb-network \ --action=allow \ --direction=egress \ --rules=tcp \ --priority=100 \ --destination-ranges=10.1.2.99 \ --target-tags=TARGET_TAG
Per utilizzare account di servizio anziché tag per controllare l'accesso, usa
l'opzione --target-service-accounts
anziché il flag --target-tags
durante la creazione delle regole firewall.
Scala l'accesso limitato ai backend del bilanciatore del carico delle applicazioni interno in base alle subnet
Mantenere regole firewall separate o aggiungere nuovi indirizzi IP con bilanciamento del carico alle regole esistenti come descritto nella sezione precedente diventa scomodo con l'aumento del numero di regole di forwarding. Un modo per evitare questo problema è allocare gli indirizzi IP regola di forwarding da una subnet riservata. Quindi, il traffico proveniente da istanze con tag o account di servizio può essere consentito o bloccato utilizzando la subnet riservata come intervallo di destinazione per le regole firewall. In questo modo puoi controllare in modo efficace l'accesso a un gruppo di VIP regola di forwarding senza dover mantenere le regole in uscita del firewall per VIP.
Di seguito sono riportati i passaggi generali per la configurazione, supponendo che creerai separatamente tutte le altre risorse del bilanciatore del carico richieste.
gcloud
Crea una subnet a livello di regione che verrà utilizzata per allocare indirizzi IP con bilanciamento del carico per le regole di forwarding:
gcloud compute networks subnets create l7-ilb-restricted-subnet \ --network=lb-network \ --region=us-west1 \ --range=10.127.0.0/24
Creare una regola di forwarding che utilizzi un indirizzo dalla subnet. L'esempio seguente utilizza l'indirizzo
10.127.0.1
della subnet creata nel passaggio precedente.gcloud compute forwarding-rules create l7-ilb-forwarding-rule-restricted \ --load-balancing-scheme=INTERNAL_MANAGED \ --network=lb-network \ --subnet=l7-ilb-restricted-subnet \ --address=10.127.0.1 \ --ports=80 \ --global \ --target-http-proxy=gil7-http-proxy
Crea una regola firewall per limitare il traffico destinato agli indirizzi IP dell'intervallo nella subnet della regola di forwarding (
l7-ilb-restricted-subnet
):gcloud compute firewall-rules create restrict-traffic-to-subnet \ --network=lb-network \ --action=deny \ --direction=egress \ --rules=tcp:80 \ --priority=100 \ --destination-ranges=10.127.0.0/24 \ --target-tags=TARGET_TAG
Utilizza lo stesso indirizzo IP tra più regole di forwarding interno
Affinché più regole di forwarding interno condividano lo stesso indirizzo IP interno,
devi prenotare l'indirizzo IP e impostare il relativo flag --purpose
su
SHARED_LOADBALANCER_VIP
.
gcloud
gcloud compute addresses create SHARED_IP_ADDRESS_NAME \ --region=REGION \ --subnet=SUBNET_NAME \ --purpose=SHARED_LOADBALANCER_VIP
Configura i criteri di routing DNS
Se i tuoi clienti si trovano in più regioni, ti consigliamo di rendere accessibile il bilanciatore del carico delle applicazioni interno tra regioni utilizzando i VIP in queste regioni. Questa configurazione per più regioni riduce al minimo la latenza e i costi di transito della rete. Inoltre, consente di configurare una soluzione di bilanciamento del carico globale e basata su DNS che offra resilienza contro le interruzioni regionali. Per maggiori informazioni, consulta Gestire i controlli di integrità e i criteri di routing DNS.
gcloud
Per creare una voce DNS con un TTL di 30 secondi, utilizza il comando gcloud dns record-sets create
.
gcloud dns record-sets create DNS_ENTRY --ttl="30" \ --type="A" --zone="service-zone" \ --routing-policy-type="GEO" \ --routing-policy-data="REGION_A=gil7-forwarding-rule-a@global;REGION_B=gil7-forwarding-rule-b@global" \ --enable-health-checking
Sostituisci quanto segue:
DNS_ENTRY
: nome DNS o di dominio del set di recordAd esempio,
service.example.com
REGION_A
eREGION_B
: le regioni in cui hai configurato il bilanciatore del carico
API
Crea il record DNS inviando una richiesta POST
al metodo ResourceRecordSets.create
.
Sostituisci PROJECT_ID con l'ID progetto.
POST https://www.googleapis.com/dns/v1/projects/PROJECT_ID/managedZones/SERVICE_ZONE/rrsets { "name": "DNS_ENTRY", "type": "A", "ttl": 30, "routingPolicy": { "geo": { "items": [ { "location": "REGION_A", "healthCheckedTargets": { "internalLoadBalancers": [ { "loadBalancerType": "globalL7ilb", "ipAddress": "gil7-forwarding-rule-a", "port": "80", "ipProtocol": "tcp", "networkUrl": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network", "project": "PROJECT_ID" } ] } }, { "location": "REGION_B", "healthCheckedTargets": { "internalLoadBalancers": [ { "loadBalancerType": "globalL7ilb", "ipAddress": "gil7-forwarding-rule-b", "port": "80", "ipProtocol": "tcp", "networkUrl": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network", "project": "PROJECT_ID" } ] } } ] } } }
Abilita rilevamento outlier
Puoi abilitare il rilevamento di outlier sui servizi di backend globali per identificare i NEG serverless integri e ridurre il numero di richieste inviate ai NEG serverless in stato non integro.
Il rilevamento outlier viene abilitato sul servizio di backend tramite uno dei seguenti metodi:
- Il metodo
consecutiveErrors
(outlierDetection.consecutiveErrors
), in cui un codice di stato HTTP della serie5xx
viene classificato come errore. - Il metodo
consecutiveGatewayFailure
(outlierDetection.consecutiveGatewayFailure
), in cui solo i codici di stato HTTP502
,503
e504
vengono considerati come errori.
Segui i passaggi riportati di seguito per abilitare il rilevamento di outlier per un servizio di backend esistente. Tieni presente che, anche dopo aver abilitato il rilevamento di outlier, alcune richieste possono essere inviate al servizio in stato non integro e restituire un codice di stato 5xx
ai client. Per ridurre ulteriormente la percentuale di errori, puoi configurare valori più restrittivi per i parametri di rilevamento outlier. Per ulteriori informazioni, consulta il campo outlierDetection
.
Console
Nella console Google Cloud, vai alla pagina Bilanciamento del carico.
Fai clic sul nome del bilanciatore del carico di cui vuoi modificare il servizio di backend.
Nella pagina Dettagli del bilanciatore del carico, fai clic su
Modifica.Nella pagina Modifica bilanciatore del carico delle applicazioni interno tra regioni, fai clic su Configurazione backend.
Nella pagina Configurazione backend, fai clic su
Modifica per il servizio di backend che vuoi modificare.Scorri verso il basso ed espandi la sezione Configurazioni avanzate.
Nella sezione Rilevamento outlier, seleziona la casella di controllo Abilita.
Fai clic su
Modifica per configurare il rilevamento outlier.Verifica che le seguenti opzioni siano configurate con questi valori:
Proprietà Valore Errori consecutivi 5 Intervallo 1000 Tempo di espulsione base 30000 Percentuale di espulsione massima 50 Applicazione di errori consecutivi 100 In questo esempio, l'analisi di rilevamento dei valori anomali viene eseguita ogni secondo. Se il numero di codici di stato HTTP
5xx
consecutivi ricevuti da un proxy Envoy è pari o superiore a 5, l'endpoint di backend viene espulso dal pool di bilanciamento del carico di quel proxy Envoy per 30 secondi. Se la percentuale di applicazione è impostata al 100%, il servizio di backend applica l'esclusione di endpoint non integri dai pool di bilanciamento del carico di quei proxy Envoy specifici ogni volta che viene eseguita l'analisi del rilevamento dei outlier. Se le condizioni di espulsione sono soddisfatte, è possibile escludere fino al 50% degli endpoint di backend dal pool di bilanciamento del carico.Fai clic su Salva.
Per aggiornare il servizio di backend, fai clic su Aggiorna.
Per aggiornare il bilanciatore del carico, nella pagina Modifica il bilanciatore del carico delle applicazioni interno tra regioni, fai clic su Aggiorna.
gcloud
Esporta il servizio di backend in un file YAML.
gcloud compute backend-services export BACKEND_SERVICE_NAME \ --destination=BACKEND_SERVICE_NAME.yaml --global
Sostituisci
BACKEND_SERVICE_NAME
con il nome del servizio di backend.Modifica la configurazione YAML del servizio di backend per aggiungere i campi per il rilevamento outlier, come evidenziato nella seguente configurazione YAML.
In questo esempio, l'analisi di rilevamento dei valori anomali viene eseguita ogni secondo. Se il numero di codici di stato HTTP
5xx
consecutivi ricevuti da un proxy Envoy è pari o superiore a 5, l'endpoint di backend viene espulso dal pool di bilanciamento del carico di quel proxy Envoy per 30 secondi. Se la percentuale di applicazione è impostata al 100%, il servizio di backend applica l'esclusione di endpoint non integri dai pool di bilanciamento del carico di quei proxy Envoy specifici ogni volta che viene eseguita l'analisi del rilevamento dei outlier. Se le condizioni di espulsione sono soddisfatte, è possibile escludere fino al 50% degli endpoint di backend dal pool di bilanciamento del carico.name: BACKEND_SERVICE_NAME backends: - balancingMode: UTILIZATION capacityScaler: 1.0 group: https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION_A/networkEndpointGroups/SERVERLESS_NEG_NAME - balancingMode: UTILIZATION capacityScaler: 1.0 group: https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION_B/networkEndpointGroups/SERVERLESS_NEG_NAME_2 outlierDetection: baseEjectionTime: nanos: 0 seconds: 30 consecutiveErrors: 5 enforcingConsecutiveErrors: 100 interval: nanos: 0 seconds: 1 maxEjectionPercent: 50 port: 80 selfLink: https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/backendServices/BACKEND_SERVICE_NAME sessionAffinity: NONE timeoutSec: 30 ...
Sostituisci quanto segue:
BACKEND_SERVICE_NAME
: il nome del servizio di backendPROJECT_ID
: l'ID del progettoREGION_A
eREGION_B
: le regioni in cui è stato configurato il bilanciatore del carico.SERVERLESS_NEG_NAME
: il nome del primo NEG serverlessSERVERLESS_NEG_NAME_2
: il nome del secondo NEG serverless
Aggiorna il servizio di backend importando l'ultima configurazione.
gcloud compute backend-services import BACKEND_SERVICE_NAME \ --source=BACKEND_SERVICE_NAME.yaml --global
Il rilevamento outlier è ora abilitato nel servizio di backend.
Passaggi successivi
- Panoramica del bilanciatore del carico delle applicazioni interno.
- Subnet solo proxy per bilanciatori del carico basati su Envoy.
- Gestire i certificati.
- Esegui la pulizia di una configurazione del bilanciamento del carico.