Configura un bilanciatore del carico di rete proxy interno regionale con backend di gruppi di istanze VM

Il bilanciatore del carico di rete proxy interno regionale è un bilanciatore del carico di livello 4 regionale basato su proxy che ti consente di eseguire e scalare il traffico di servizio TCP dietro un indirizzo IP interno accessibile solo ai client nella stessa rete VPC o ai client connessi alla tua rete VPC.

Prima di iniziare, leggi la panoramica del bilanciatore del carico di rete proxy interno regionale.

Questa guida contiene le istruzioni per configurare un bilanciatore del carico di rete proxy interno regionale con un backend del gruppo di istanze gestite (MIG). Per questo esempio, configuri il seguente deployment:

Configurazione di esempio del bilanciatore del carico di rete proxy interno regionale con backend di gruppi di istanze

In questo esempio, utilizzeremo il bilanciatore del carico per distribuire il traffico TCP tra le VM di backend in due gruppi di istanze gestite a livello di zona nella regione REGION_A. Ai fini dell'esempio, il servizio è un insieme di server Apache configurati per rispondere sulla porta 110. Molti browser non consentono la porta 110, quindi la sezione di test utilizza curl.

Il bilanciatore del carico di rete proxy interno regionale è un bilanciatore del carico regionale. Tutti i componenti del bilanciatore del carico devono trovarsi nella stessa regione del bilanciatore del carico.

Routing basato su SNI: questa pagina mostra anche un'architettura di deployment alternativa che puoi utilizzare per configurare il routing basato su SNI. Per il routing basato su SNI, utilizzi le route TLS per definire come viene distribuito il traffico. Per maggiori dettagli, vedi Creare un bilanciatore del carico con route TLS.

Autorizzazioni

Per seguire questa guida, devi essere in grado di creare istanze e modificare una rete in un progetto. Devi avere il ruolo di proprietario o editor del progetto oppure disporre di tutti i seguenti ruoli IAM di Compute Engine:

Attività	Ruolo richiesto
Crea reti, subnet e componenti del bilanciatore del carico	Network Admin
Aggiungere e rimuovere regole firewall	Security Admin
Creare istanze	Compute Instance Admin

Per saperne di più, consulta le guide seguenti:

• Controllo dell'accesso
• Condizioni IAM

Configura la rete e le subnet

Hai bisogno di una rete VPC con due subnet: una per i backend del bilanciatore del carico e l'altra per i proxy del bilanciatore del carico. I bilanciatori del carico di rete proxy interni regionali sono regionali. Il traffico all'interno della rete VPC viene instradato al bilanciatore del carico se l'origine del traffico si trova in una subnet nella stessa regione del bilanciatore del carico.

Questo esempio utilizza la seguente rete VPC, regione e subnet:

• Rete. La rete è una rete VPC in modalità personalizzata denominata lb-network.

• Subnet per i backend. Una subnet denominata backend-subnet nella regione REGION_A utilizza 10.1.2.0/24 per il suo intervallo IP primario.

• Subnet per i proxy. Una subnet denominata proxy-only-subnet nella regione REGION_A utilizza 10.129.0.0/23 per il suo intervallo IP primario.

Per dimostrare l'accesso globale, questo esempio crea anche una seconda VM client di test in una regione diversa (REGION_B) e una subnet con intervallo di indirizzi IP primari 10.3.4.0/24.

Nota: puoi modificare il nome della rete, della regione e i parametri delle subnet. Tuttavia, i passaggi successivi di questa guida utilizzano i parametri di rete, regione e subnet come descritto qui.

Crea la rete e le subnet

Console

1. Nella console Google Cloud , vai alla pagina Reti VPC.

   Vai a Reti VPC

2. Fai clic su Crea rete VPC.

3. In Nome, inserisci lb-network.

4. Nella sezione Subnet, imposta Modalità di creazione subnet su Personalizzata.

5. Crea una subnet per i backend del bilanciatore del carico. Nella sezione Nuova subnet, inserisci le seguenti informazioni:

   • Nome: backend-subnet
   • Regione: REGION_A
   • Intervallo di indirizzi IP: 10.1.2.0/24

6. Fai clic su Fine.

7. Fai clic su Aggiungi subnet.

8. Crea una subnet per dimostrare l'accesso globale. Nella sezione Nuova subnet, inserisci le seguenti informazioni:

   • Nome: test-global-access-subnet
   • Regione: REGION_B
   • Intervallo di indirizzi IP: 10.3.4.0/24

9. Fai clic su Fine.

10. Fai clic su Crea.

gcloud

1. Crea la rete VPC personalizzata con il comando gcloud compute networks create:

   gcloud compute networks create lb-network --subnet-mode=custom
   

2. Crea una subnet nella rete lb-network nella regione REGION_A con il comando gcloud compute networks subnets create:

   gcloud compute networks subnets create backend-subnet \
      --network=lb-network \
      --range=10.1.2.0/24 \
      --region=REGION_A
   

   Sostituisci REGION_A con il nome della regione di destinazione Google Cloud .

3. Crea una subnet nella rete lb-network nella regione REGION_B con il comando gcloud compute networks subnets create:

   gcloud compute networks subnets create test-global-access-subnet \
      --network=lb-network \
      --range=10.3.4.0/24 \
      --region=REGION_B
   

   Sostituisci REGION_B con il nome della regione Google Cloud in cui vuoi creare la seconda subnet per testare l'accesso globale.

Crea la subnet solo proxy

Una subnet solo proxy fornisce un insieme di indirizzi IP che Google 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 basati su Envoy nella regione REGION_A della rete VPC lb-network.

Importante: non tentare di assegnare indirizzi dalla subnet solo proxy alla regola di forwarding o ai backend del bilanciatore del carico. Assegni l'indirizzo IP della regola di forwarding e gli indirizzi IP dell'istanza di backend da un intervallo di subnet (o intervalli) diverso, non questo.Google Cloud Riserva questo intervallo di subnet per i proxy gestiti da Google Cloud.

Console

Se utilizzi la console Google Cloud , puoi attendere e creare la subnet solo proxy in un secondo momento nella pagina Bilanciamento del carico.

Se vuoi creare subito la subnet solo proxy, segui questi passaggi:

1. Nella console Google Cloud , vai alla pagina Reti VPC.
   Vai a Reti VPC
2. Fai clic sul nome della rete VPC condiviso: lb-network.
3. Fai clic su Aggiungi subnet.
4. In Nome, inserisci proxy-only-subnet.
5. In Regione, seleziona REGION_A.
6. Imposta Scopo su Proxy gestito a livello di regione.
7. In Intervallo di indirizzi IP, inserisci 10.129.0.0/23.
8. Fai clic su Aggiungi.

gcloud

Crea la subnet solo proxy con il comando gcloud compute networks subnets create.

gcloud compute networks subnets create proxy-only-subnet \
    --purpose=REGIONAL_MANAGED_PROXY \
    --role=ACTIVE \
    --region=REGION_A \
    --network=lb-network \
    --range=10.129.0.0/23

Crea regole firewall

Questo esempio richiede le seguenti regole firewall:

• fw-allow-ssh. 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 IP di origine più restrittivo per questa regola. Ad esempio, puoi specificare solo gli intervalli IP del sistema da cui avvii le sessioni SSH. Questo esempio utilizza il tag di destinazione allow-ssh.

• fw-allow-health-check. Una regola in entrata, applicabile alle istanze con bilanciamento del carico, che consente tutto il traffico TCP dai sistemi di controllo di integrità Google Cloud(in 130.211.0.0/22 e 35.191.0.0/16). Questo esempio utilizza il tag di destinazione allow-health-check.

• fw-allow-proxy-only-subnet. Una regola Ingress che consente alle connessioni dalla subnet solo proxy di raggiungere i backend.

Senza queste regole firewall, la regola default-deny per 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

1. Nella console Google Cloud , vai alla pagina Policy firewall.
   Vai a Criteri firewall
2. Fai clic su Crea regola firewall per creare la regola per consentire le connessioni SSH in entrata:
   • Nome: fw-allow-ssh
   • Rete: lb-network
   • Direzione del traffico: in entrata
   • Azione in caso di corrispondenza: Consenti
   • Target: 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.
3. Fai clic su Crea.
4. Fai clic su Crea regola firewall una seconda volta per creare la regola per consentire i controlli di integritàGoogle Cloud :
   • Nome: fw-allow-health-check
   • Rete: lb-network
   • Direzione del traffico: in entrata
   • Azione in caso di corrispondenza: Consenti
   • Target: Tag di destinazione specificati
   • Tag di destinazione: allow-health-check
   • Filtro di origine: intervalli IPv4
   • Intervalli IPv4 di origine: 130.211.0.0/22 e 35.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 che corrispondono a quelli utilizzati dal controllo di integrità. Se utilizzi tcp:80 per il protocollo e la porta, Google Cloud può utilizzare HTTP sulla porta 80 per contattare le tue VM, ma non può utilizzare HTTPS sulla porta 443 per contattarle.
5. Fai clic su Crea.
6. Fai clic su Crea regola firewall una terza volta per creare la regola che consente ai server proxy del bilanciatore del carico di connettere i backend:
   • Nome: fw-allow-proxy-only-subnet
   • Rete: lb-network
   • Direzione del traffico: in entrata
   • Azione in caso di corrispondenza: Consenti
   • Target: Tag di destinazione specificati
   • Tag di destinazione: allow-proxy-only-subnet
   • Filtro di origine: intervalli IPv4
   • Intervalli IPv4 di origine: 10.129.0.0/23
   • Protocolli e porte:
     • Scegli Protocolli e porte specificati.
     • Seleziona la casella di controllo TCP, quindi inserisci 80 per i numeri di porta.
7. Fai clic su Crea.

gcloud

1. Crea la regola firewall fw-allow-ssh per consentire la connettività SSH alle VM con il tag di rete allow-ssh. Se ometti source-ranges, Google Cloud interpreta la regola in modo che si riferisca a qualsiasi origine.

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

2. Crea la regola fw-allow-health-check per consentire i controlli di integrità Google Cloud. Questo esempio consente tutto il traffico TCP dai probe di controllo di integrità. Tuttavia, puoi configurare un insieme più ristretto di porte per soddisfare le tue esigenze.

   gcloud compute firewall-rules create fw-allow-health-check \
      --network=lb-network \
      --action=allow \
      --direction=ingress \
      --source-ranges=130.211.0.0/22,35.191.0.0/16 \
      --target-tags=allow-health-check \
      --rules=tcp:80
   

3. Crea la regola fw-allow-proxy-only-subnet per consentire ai proxy Envoy della regione di connettersi ai tuoi backend. Imposta --source-ranges sugli intervalli allocati della subnet solo proxy, in questo esempio 10.129.0.0/23.

   gcloud compute firewall-rules create fw-allow-proxy-only-subnet \
      --network=lb-network \
      --action=allow \
      --direction=ingress \
      --source-ranges=10.129.0.0/23 \
      --target-tags=allow-proxy-only-subnet \
      --rules=tcp:80
   

Prenota l'indirizzo IP del bilanciatore del carico

Per prenotare un indirizzo IP interno statico per il bilanciatore del carico, consulta Prenota un nuovo indirizzo IPv4 o IPv6 interno statico.

Nota: assicurati di utilizzare il nome della subnet che hai specificato quando hai creato la subnet.

Creare un gruppo di istanze gestite

Questa sezione mostra come creare due backend del gruppo di istanze gestite (MIG) nella regione REGION_A per il bilanciatore del carico. Il gruppo di istanze gestite fornisce istanze VM che eseguono i server Apache di backend per questo bilanciatore del carico di rete proxy interno regionale di esempio. In genere, un bilanciatore del carico di rete proxy interno regionale non viene utilizzato per il traffico HTTP, ma il software Apache è di uso comune per i test.

Console

1. Crea un template di istanza. Nella console Google Cloud , vai alla pagina Modelli di istanza.

   Vai a Modelli di istanza

   1. Fai clic su Crea template di istanza.
   2. In Nome, inserisci int-tcp-proxy-backend-template.
   3. Assicurati che il disco di avvio sia impostato su un'immagine Debian, ad esempio Debian GNU/Linux 12 (bookworm). Queste istruzioni utilizzano comandi disponibili solo su Debian, come apt-get.
   4. Fai clic su Opzioni avanzate.
   5. Fai clic su Networking e configura i seguenti campi:
      1. In Tag di rete, inserisci allow-ssh, allow-health-check e allow-proxy-only-subnet.
      2. In Interfacce di rete, seleziona quanto segue:
         • Rete: lb-network
         • Subnet: backend-subnet

   6. Fai clic su Gestione. Inserisci il seguente script 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://metadata.google.internal/computeMetadata/v1/instance/name)"
      echo "Page served from: $vm_hostname" | \
      tee /var/www/html/index.html
      systemctl restart apache2
      

   7. Fai clic su Crea.

2. Creare un gruppo di istanze gestite. Nella console Google Cloud , vai alla pagina Gruppi di istanze.

   Vai a Gruppi di istanze

   1. Fai clic su Crea gruppo di istanze.
   2. Seleziona Nuovo gruppo di istanze gestite (stateless). Per saperne di più, consulta MIG stateless o stateful.
   3. In Nome, inserisci mig-a.
   4. In Località, seleziona Zona singola.
   5. In Regione, seleziona REGION_A.
   6. In Zona, seleziona ZONE_A1.
   7. In Template di istanza, seleziona int-tcp-proxy-backend-template.

   8. Specifica il numero di istanze che vuoi creare nel gruppo.

      Per questo esempio, specifica le seguenti opzioni in Scalabilità automatica:

      • Per la Modalità di scalabilità automatica, seleziona Off:do not autoscale.
      • In Numero massimo di istanze, inserisci 2.

   9. Per Mappatura delle porte, fai clic su Aggiungi porta.

      • In Nome porta, inserisci tcp80.
      • In Numero porta, inserisci 80.

   10. Fai clic su Crea.

3. Ripeti il passaggio 2 per creare un secondo gruppo di istanze gestite con le seguenti impostazioni:

   1. Nome: mig-c
   2. Zona: ZONE_A2 Mantieni invariate tutte le altre impostazioni.

gcloud

Le istruzioni per gcloud in questa guida presuppongono che tu stia utilizzando Cloud Shell o un altro ambiente con bash installato.

1. Crea un template di istanza VM con server HTTP utilizzando il comando gcloud compute instance-templates create.

   gcloud compute instance-templates create int-tcp-proxy-backend-template \
      --region=REGION_A \
      --network=lb-network \
      --subnet=backend-subnet \
      --tags=allow-ssh,allow-health-check,allow-proxy-only-subnet \
      --image-family=debian-12 \
      --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://metadata.google.internal/computeMetadata/v1/instance/name)"
        echo "Page served from: $vm_hostname" | \
        tee /var/www/html/index.html
        systemctl restart apache2'
   

2. Crea un gruppo di istanze gestite nella zona ZONE_A1.

   gcloud compute instance-groups managed create mig-a \
      --zone=ZONE_A1 \
      --size=2 \
      --template=int-tcp-proxy-backend-template
   

   Sostituisci ZONE_A1 con il nome della zona nella regione di destinazione Google Cloud .

3. Crea un gruppo di istanze gestite nella zona ZONE_A2.

   gcloud compute instance-groups managed create mig-c \
      --zone=ZONE_A2 \
      --size=2 \
      --template=int-tcp-proxy-backend-template
   

   Sostituisci ZONE_A2 con il nome di un'altra zona nella regione di destinazione Google Cloud .

Configura il bilanciatore del carico

Console

Avvia la configurazione

1. Nella console Google Cloud , vai alla pagina Bilanciamento del carico.

   Vai a Bilanciamento del carico

2. Fai clic su Crea bilanciatore del carico.
3. In Tipo di bilanciatore del carico, seleziona Bilanciatore del carico di rete (TCP/UDP/SSL) e fai clic su Avanti.
4. Per Proxy o passthrough, seleziona Bilanciatore del carico proxy e fai clic su Avanti.
5. In Pubblico o interno, seleziona Interno e fai clic su Avanti.
6. In Deployment tra regioni o in una regione singola, seleziona Ideale per workload regionali e fai clic su Avanti.
7. Fai clic su Configura.

Configurazione di base

1. In Nome, inserisci my-int-tcp-lb.
2. In Regione, seleziona REGION_A.
3. In Rete, seleziona lb-network.

Riservare una subnet solo proxy

Nota: se hai già creato la subnet solo proxy, il pulsante Riserva subnet non viene visualizzato. Puoi saltare questa sezione e continuare con i passaggi nella sezione Configurazione backend.

Per riservare una subnet solo proxy:

1. Fai clic su Riserva subnet.
2. In Nome, inserisci proxy-only-subnet.
3. In Intervallo di indirizzi IP, inserisci 10.129.0.0/23.
4. Fai clic su Aggiungi.

Configurazione backend

1. Fai clic su Configurazione backend.
2. In Tipo di backend, seleziona Gruppo di istanze.
3. In Protocollo, seleziona TCP.
4. In Porta denominata, inserisci tcp80.
5. Nell'elenco Controllo di integrità, fai clic su Crea un controllo di integrità, quindi inserisci le seguenti informazioni:
   • Nome: tcp-health-check
   • Protocollo: TCP
   • Porta: 80
6. Fai clic su Crea.
7. Configura il primo backend:
   1. In Nuovo backend, seleziona il gruppo di istanze mig-a.
   2. In Numeri di porta, inserisci 80.
   3. Mantieni i restanti valori predefiniti e fai clic su Fine.
8. Configura il secondo backend:
   1. Fai clic su Aggiungi backend.
   2. In Nuovo backend, seleziona il gruppo di istanze mig-c.
   3. In Numeri di porta, inserisci 80.
   4. Mantieni i restanti valori predefiniti e fai clic su Fine.
9. Nella console Google Cloud , verifica che sia presente un segno di spunta accanto a Configurazione backend. In caso contrario, assicurati di aver completato tutti i passaggi.

Configurazione frontend

1. Fai clic su Configurazione frontend.
2. In Nome, inserisci int-tcp-forwarding-rule.
3. In Subnet, seleziona backend-subnet.
4. In Indirizzo IP, seleziona l'indirizzo IP prenotato in precedenza: LB_IP_ADDRESS
5. In Numero porta, inserisci 110. La regola di forwarding inoltra solo i pacchetti con una porta di destinazione corrispondente.
6. In questo esempio, non attivare il protocollo proxy perché non funziona con il software Apache HTTP Server. Per saperne di più, vedi Protocollo proxy.
7. Fai clic su Fine.
8. Nella console Google Cloud , verifica che sia presente un segno di spunta accanto a Configurazione frontend. In caso contrario, assicurati di aver completato tutti i passaggi precedenti.

Esamina e finalizza

1. Fai clic su Esamina e finalizza.
2. Rivedi le impostazioni di configurazione del bilanciatore del carico.
3. (Facoltativo) Fai clic su Codice equivalente per visualizzare la richiesta dell'API REST che verrà utilizzata per creare il bilanciatore del carico.
4. Fai clic su Crea.

gcloud

1. Crea un controllo di integrità a livello di regione.

   gcloud compute health-checks create tcp tcp-health-check \
      --region=REGION_A \
      --use-serving-port
   

2. Crea un servizio di backend.

   gcloud compute backend-services create internal-tcp-proxy-bs \
      --load-balancing-scheme=INTERNAL_MANAGED \
      --protocol=TCP \
      --region=REGION_A \
      --health-checks=tcp-health-check \
      --health-checks-region=REGION_A
   

3. Aggiungi gruppi di istanze al servizio di backend.

   gcloud compute backend-services add-backend internal-tcp-proxy-bs \
      --region=REGION_A \
      --instance-group=mig-a \
      --instance-group-zone=ZONE_A1 \
      --balancing-mode=UTILIZATION \
      --max-utilization=0.8
   

   gcloud compute backend-services add-backend internal-tcp-proxy-bs \
      --region=REGION_A \
      --instance-group=mig-c \
      --instance-group-zone=ZONE_A2 \
      --balancing-mode=UTILIZATION \
      --max-utilization=0.8
   

4. Crea un proxy TCP di destinazione interno.

   gcloud compute target-tcp-proxies create int-tcp-target-proxy \
      --backend-service=internal-tcp-proxy-bs \
      --proxy-header=NONE \
      --region=REGION_A
   

   Se vuoi attivare l'intestazione proxy, impostala su PROXY_V1 anziché su NONE. In questo esempio, non attivare il protocollo proxy perché non funziona con il software Apache HTTP Server. Per saperne di più, vedi Protocollo proxy.

5. Crea la regola di forwarding. Per --ports, specifica un singolo numero di porta compreso tra 1 e 65535. Questo esempio utilizza la porta 110. La regola di forwarding inoltra solo i pacchetti con una porta di destinazione corrispondente.

   gcloud compute forwarding-rules create int-tcp-forwarding-rule \
      --load-balancing-scheme=INTERNAL_MANAGED \
      --network=lb-network \
      --subnet=backend-subnet \
      --region=REGION_A \
      --target-tcp-proxy=int-tcp-target-proxy \
      --target-tcp-proxy-region=REGION_A \
      --address=int-tcp-ip-address \
      --ports=110
   

Testa il bilanciatore del carico

Per testare il bilanciatore del carico, crea una VM client nella stessa regione del bilanciatore del carico. Poi invia il traffico dal client al bilanciatore del carico.

Crea una VM client

Crea una VM client (client-vm) nella stessa regione del bilanciatore del carico.

Console

1. Nella console Google Cloud , vai alla pagina Istanze VM.

   Vai a Istanze VM

2. Fai clic su Crea istanza.

3. Imposta Nome su client-vm.

4. Imposta Zona su ZONE_A1.

5. Fai clic su Opzioni avanzate.

6. Fai clic su Networking e configura i seguenti campi:

   1. In Tag di rete, inserisci allow-ssh.
   2. In Interfacce di rete, seleziona quanto segue:
      • Rete: lb-network
      • Subnet: backend-subnet

7. Fai clic su Crea.

gcloud

La VM client deve trovarsi nella stessa rete VPC e nella stessa regione del bilanciatore del carico. Non è necessario che si trovi nella stessa subnet o zona. Il client utilizza la stessa subnet delle VM di backend.

gcloud compute instances create client-vm \
    --zone=ZONE_A1 \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --tags=allow-ssh \
    --subnet=backend-subnet

Invia traffico al bilanciatore del carico

Nota: potrebbero essere necessari alcuni minuti per propagare la configurazione del bilanciatore del carico a livello globale dopo il primo deployment.

Ora che hai configurato il bilanciatore del carico, puoi testare l'invio di traffico all'indirizzo IP del bilanciatore del carico.

1. Utilizza SSH per connetterti all'istanza client.

   gcloud compute ssh client-vm \
      --zone=ZONE_A1
   

2. Verifica che il bilanciatore del carico fornisca i nomi host di backend come previsto.

   1. Utilizza il comando compute addresses describe per visualizzare l'indirizzo IP del bilanciatore del carico:

      gcloud compute addresses describe int-tcp-ip-address \
       --region=REGION_A
      

      Prendi nota dell'indirizzo IP.

   2. Invia traffico al bilanciatore del carico. Sostituisci IP_ADDRESS con l'indirizzo IP del bilanciatore del carico.

      curl IP_ADDRESS:110
      

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.

Crea un bilanciatore del carico con route TLS

Questa sezione mostra come creare un bilanciatore del carico che può utilizzare il routing basato su SNI. Il routing basato su SNI consente ai bilanciatori del carico di rete proxy di instradare il traffico a servizi di backend specifici in base al nome host SNI (Server Name Indication) fornito durante l'handshake TLS.

Per creare questo bilanciatore del carico, utilizziamo le stesse reti, subnet e regole firewall create in precedenza in questa pagina. Configura il deployment mostrato nel diagramma seguente:

Configurazione del bilanciatore del carico di rete proxy interno regionale con route TLS.

Crea un backend di un gruppo di istanze gestite

Questa sezione mostra come creare backend del gruppo di istanze gestite (MIG) per il bilanciatore del carico. Il MIG fornisce istanze VM che eseguono i server di backend per questo esempio.

Le istruzioni di Google Cloud CLI in questa guida presuppongono che tu stia utilizzando Cloud Shell o un altro ambiente con bash installato.

1. Crea un modello di istanza con un servizio HTTPS "echo" esposto sulla porta 443.

   gcloud compute instance-templates create INSTANCE_TEMPLATE_NAME \
   --region=REGION_A \
   --network=NETWORK \
   --subnet=SUBNET_A \
   --stack-type=IPv4_ONLY \
   --tags=allow-ssh,allow-health-check,allow-proxy-only-subnet \
   --image-family=debian-12 \
   --image-project=debian-cloud \
   --metadata=startup-script='#! /bin/bash
   sudo sed -i "s/^#DNS=.*/DNS=8.8.8.8 8.8.4.4/" /etc/systemd/resolved.conf
   sudo systemctl restart systemd-resolved
   sudo rm -rf /var/lib/apt/lists/*
   sudo apt-get -y clean
   sudo apt-get -y update
   sudo apt-get -y install ca-certificates curl gnupg software-properties-common
   sudo curl -fsSL https://download.docker.com/linux/debian/gpg | sudo apt-key add -
   sudo add-apt-repository -y "deb [arch=amd64] https://download.docker.com/linux/debian $(lsb_release -cs) stable"
   sudo apt-get -y update
   sudo apt-get -y install docker-ce
   sudo which docker
   echo "{ \"registry-mirrors\": [\"https://mirror.gcr.io\"] }" | sudo tee -a /etc/docker/daemon.json
   sudo service docker restart
   sudo docker run -e HTTPS_PORT=9999 -p 443:9999 --rm -dt mendhak/http-https-echo:22'
   

   Sostituisci quanto segue:

   • INSTANCE_TEMPLATE_NAME: un nome per il template di istanza.
   • REGION_A: la regione per il template di istanza.
   • NETWORK: il nome della rete.
   • SUBNET_A: il nome della subnet.

2. Crea un gruppo di istanze gestite basato sul modello di istanza:

   gcloud compute instance-groups managed create INSTANCE_GROUP_NAME \
     --zone=ZONE_A \
     --size=2 \
     --template=INSTANCE_TEMPLATE_NAME
   

   Sostituisci ZONE_A con la zona del gruppo di istanze.

3. Imposta il nome della porta di pubblicazione per il gruppo di istanze gestite:

   gcloud compute instance-groups managed set-named-ports INSTANCE_GROUP_NAME \
     --named-ports=PORT_NAME:PORT_NUMBER \
     --zone=ZONE_A
   

   Sostituisci quanto segue:

   • PORT_NAME: un nome per la porta di pubblicazione, ad esempio tcp443.
   • PORT_NUMBER: un numero di porta per la porta di pubblicazione, ad esempio 443.

Configura il firewall

Configura una regola firewall per consentire il traffico dal bilanciatore del carico e dai probe di controllo di integrità alle istanze di backend.

gcloud compute firewall-rules create FIREWALL_RULE_NAME \
    --network=NETWORK \
    --action=allow \
    --direction=ingress \
    --source-ranges=130.211.0.0/22,35.191.0.0/16 \
   --target-tags=allow-health-check \
    --rules=tcp:443

Sostituisci FIREWALL_RULE_NAME con un nome per la regola firewall.

Configura il bilanciatore del carico

1. Crea un controllo di integrità HTTPS:

   gcloud compute health-checks create http HTTPS_HEALTH_CHECK_NAME \
       --region=REGION_A \
       --port=HC_PORT
   

   Sostituisci quanto segue:

   • HTTPS_HEALTH_CHECK_NAME: un nome per il controllo di integrità.
   • HC_PORT: la porta per il controllo di integrità, ad esempio 443.
   • REGION_A: la regione per il controllo di integrità.

2. Crea un servizio di backend:

   gcloud compute backend-services create BACKEND_SERVICE_NAME \
       --load-balancing-scheme=INTERNAL_MANAGED \
       --protocol=TCP \
       --port-name=PORT_NAME \
       --region=REGION_A \
       --health-checks=tcp-health-check \
       --health-checks-region=REGION_A
   

   Sostituisci quanto segue:

   • BACKEND_SERVICE_NAME: un nome per il servizio di backend.
   • PORT_NAME: il nome della porta per il servizio di backend. Utilizza la stessa porta denominata configurata nel gruppo di istanze, ad esempio tcp443.
   • HTTPS_HEALTH_CHECK_NAME: il nome del controllo di integrità HTTPS.

3. Aggiungi il gruppo di istanza di backend al servizio di backend:

   gcloud compute backend-services add-backend BACKEND_SERVICE_NAME \
       --balancing-mode=UTILIZATION \
       --max-utilization=0.8
       --instance-group=INSTANCE_GROUP_NAME \
       --instance-group-zone=ZONE_A \
       --region=REGION_A
     

   Sostituisci quanto segue:

   • INSTANCE_GROUP_NAME: il nome del gruppo di istanza di backend.
   • ZONE_A: la zona del gruppo di istanze.

4. Crea un proxy TCP di destinazione.

   gcloud beta compute target-tcp-proxies create TARGET_TCP_PROXY_NAME \
       --load-balancing-scheme=INTERNAL_MANAGED \
       --proxy-header=NONE \
       --region=REGION_A
   

   Sostituisci TARGET_TCP_PROXY_NAME con il nome del proxy TCP di destinazione.

5. Crea una specifica di route TLS e salvala in un file YAML.

   cat <<EOF | tee YAML_FILE_NAME
   name: TLS_ROUTE_NAME
   targetProxies:
   - projects/PROJECT_NUMBER/locations/REGION_A/targetTcpProxies/TARGET_TCP_PROXY
   rules:
   - matches:
     - sniHost:
       - example.com
     action:
     destinations:
     - serviceName: projects/PROJECT_NUMBER/locations/REGION_A/backendServices/BACKEND_SERVICE_NAME
   EOF
   

   Sostituisci quanto segue:

   • YAML_FILE_NAME: un nome per il file YAML, ad esempio tls-route.yaml.
   • TLS_ROUTE_NAME: un nome per la route TLS.
   • PROJECT_NUMBER: il numero del progetto.

6. Utilizza il file di specifica YAML per creare la risorsa di route TLS.

   gcloud network-services tls-routes import TLS_ROUTE_NAME \
     --source=YAML_FILE_NAME \
     --location=REGION_A
   

7. Crea la regola di forwarding.

   gcloud compute forwarding-rules create FORWARDING_RULE_NAME \
     --load-balancing-scheme=INTERNAL_MANAGED \
     --network=NETWORK \
     --subnet=SUBNET_A \
     --region=REGION_A \
     --target-tcp-proxy=TARGET_TCP_PROXY_NAME \
     --target-tcp-proxy-region=REGION_A \
     --address=IP_ADDRESS \
     --ports=PORT_NUMBER
   

   Sostituisci quanto segue:

   • FORWARDING_RULE_NAME: un nome per la regola di forwarding.
   • NETWORK: il nome della rete.
   • SUBNET_A: il nome della subnet nella stessa regione del bilanciatore del carico.
   • IP_ADDRESS: l'indirizzo IP del bilanciatore del carico.
   • PORT_NUMBER: la porta utilizzata dalla regola di inoltro, ad esempio 443.

testa il bilanciatore del carico

Nota: potrebbero essere necessari alcuni minuti per propagare la configurazione del bilanciatore del carico dopo il primo deployment.

Ora che hai configurato il bilanciatore del carico, puoi testare l'invio di traffico all'indirizzo IP del bilanciatore del carico.

1. Verifica di poter accedere al servizio HTTPS tramite il bilanciatore del carico.

   curl https://example.com --resolve example.com:443:IP_ADDRESS -k
   

   Vedrai il comando restituire una risposta da una delle VM nel gruppo di istanze gestite con il seguente output nella console.

   "path": "/",
   "headers": {
     "host": "example.com",
     "user-agent": "curl/7.81.0",
     "accept": "*/*"
   },
   "method": "GET",
   "body": "",
   "fresh": false,
   "hostname": "example.com",
   "ip": "::ffff:10.142.0.2",
   "ips": [],
   "protocol": "https",
   "query": {},
   "subdomains": [],
   "xhr": false,
   "os": {
     "hostname": "0cd3aec9b351"
   },
   "connection": {
     "servername": "example.com"
   }
   

   Puoi verificare ulteriormente che se fornisci un nome host SNI diverso che non corrisponde a una route TLS o se non fornisci alcun nome host SNI, la richiesta viene eliminata.

   • Esegui un test con un nome host SNI che non corrisponde a example.com per assicurarti che la connessione venga rifiutata.

   curl https://unknown.com --resolve unknown.com:443:IP_ADDRESS -k
   

   • Esegui un test con una connessione di testo normale senza TLS per assicurarti che la connessione venga rifiutata.

   curl example.com:443 --resolve example.com:443:IP_ADDRESS -k
   

   Questi comandi restituiscono il seguente errore.

   curl: (35) OpenSSL SSL_connect: Connection reset by peer in connection
   

   Quando il bilanciamento del carico rifiuta queste connessioni non valide, nei proxyStatus log viene visualizzato il codice di errore connection_refused.

Abilita accesso globale

Puoi abilitare l'accesso globale per il bilanciatore del carico in modo che sia accessibile ai client in tutte le regioni. I backend del bilanciatore del carico di esempio devono comunque trovarsi in una regione (REGION_A).

Bilanciatore del carico di rete proxy interno regionale con accesso globale (fai clic per ingrandire)

Non puoi modificare una regola di forwarding regionale esistente per attivare l'accesso globale. A questo scopo, devi creare una nuova regola di forwarding. Inoltre, dopo la creazione di una regola di forwarding con accesso globale abilitato, non è possibile modificarla. Per disattivare l'accesso globale, devi creare una nuova regola di forwarding per l'accesso regionale ed eliminare la precedente regola di forwarding per l'accesso globale.

Per configurare l'accesso globale, apporta le seguenti modifiche alla configurazione.

Console

Crea una nuova regola di forwarding per il bilanciatore del carico:

1. Nella console Google Cloud , vai alla pagina Bilanciamento del carico.

   Vai a Bilanciamento del carico

2. Nella colonna Nome, fai clic sul bilanciatore del carico.

3. Fai clic su Configurazione frontend.

4. Fai clic su Aggiungi IP e porta frontend.

5. Inserisci il nome e i dettagli della subnet per la nuova regola di forwarding.

6. In Subnet, seleziona backend-subnet.

7. Per Indirizzo IP, puoi selezionare lo stesso indirizzo IP di una regola di forwarding esistente, prenotare un nuovo indirizzo IP o utilizzare un indirizzo IP temporaneo. La condivisione dello stesso indirizzo IP in più regole di forwarding è possibile solo se imposti il flag --purpose dell'indirizzo IP su SHARED_LOADBALANCER_VIP durante la creazione dell'indirizzo IP.

8. In Numero porta, inserisci 110.

9. Per Accesso globale, seleziona Attiva.

10. Fai clic su Fine.

11. Fai clic su Aggiorna.

gcloud

1. Crea una nuova regola di forwarding per il bilanciatore del carico con il flag --allow-global-access.

   gcloud compute forwarding-rules create int-tcp-forwarding-rule-global-access \
      --load-balancing-scheme=INTERNAL_MANAGED \
      --network=lb-network \
      --subnet=backend-subnet \
      --region=REGION_A \
      --target-tcp-proxy=int-tcp-target-proxy \
      --target-tcp-proxy-region=REGION_A \
      --address=int-tcp-ip-address \
      --ports=110 \
      --allow-global-access
   

2. Puoi utilizzare il comando gcloud compute forwarding-rules describe per determinare se l'accesso globale è abilitato per una regola di forwarding. Ad esempio:

   gcloud compute forwarding-rules describe int-tcp-forwarding-rule-global-access \
      --region=REGION_A \
      --format="get(name,region,allowGlobalAccess)"
   

   Quando l'accesso globale è abilitato, la parola True viene visualizzata nell'output dopo il nome e la regione della regola di forwarding.

Crea una VM client per testare l'accesso globale

Console

1. Nella console Google Cloud , vai alla pagina Istanze VM.

   Vai a Istanze VM

2. Fai clic su Crea istanza.

3. Imposta Nome su test-global-access-vm.

4. Imposta Zona su ZONE_B1.

5. Fai clic su Opzioni avanzate.

6. Fai clic su Networking e configura i seguenti campi:

   1. In Tag di rete, inserisci allow-ssh.
   2. In Interfacce di rete, seleziona quanto segue:
      • Rete: lb-network
      • Subnet: test-global-access-subnet

7. Fai clic su Crea.

gcloud

Crea una VM client nella zona ZONE_B1.

gcloud compute instances create test-global-access-vm \
    --zone=ZONE_B1 \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --tags=allow-ssh \
    --subnet=test-global-access-subnet

Sostituisci ZONE_B1 con il nome della zona nella regione REGION_B.

Connettiti alla VM client e testa la connettività

1. Utilizza ssh per connetterti all'istanza client:

   gcloud compute ssh test-global-access-vm \
       --zone=ZONE_B1
   

2. Utilizza il comando gcloud compute addresses describe per ottenere l'indirizzo IP del bilanciatore del carico:

   gcloud compute addresses describe int-tcp-ip-address \
       --region=REGION_A
   

   Prendi nota dell'indirizzo IP.

3. Invia traffico al bilanciatore del carico; sostituisci IP_ADDRESS con l'indirizzo IP del bilanciatore del carico:

   curl IP_ADDRESS:110
   

Protocollo PROXY per conservare le informazioni sulla connessione client

Il bilanciatore del carico di rete proxy termina le connessioni TCP dal client e crea nuove connessioni alle istanze. Per impostazione predefinita, le informazioni originali su porta e IP client non vengono conservate.

Per conservare e inviare le informazioni di connessione originali alle tue istanze, attiva il protocollo PROXY versione 1. Questo protocollo invia un'intestazione aggiuntiva che contiene l'indirizzo IP di origine, l'indirizzo IP di destinazione e i numeri di porta all'istanza come parte della richiesta.

Assicurati che le istanze di backend del bilanciatore del carico di rete proxy eseguano server che supportano le intestazioni del protocollo PROXY. Se i server non sono configurati per supportare le intestazioni del protocollo PROXY, le istanze di backend restituiscono risposte vuote.

Se imposti il protocollo PROXY per il traffico utente, puoi impostarlo anche per i controlli di integrità. Se controlli l'integrità e pubblichi i contenuti sulla stessa porta, imposta --proxy-header del controllo di integrità in modo che corrisponda all'impostazione del bilanciatore del carico.

L'intestazione del protocollo PROXY è in genere una singola riga di testo leggibile dall'utente nel seguente formato:

PROXY TCP4 <client IP> <load balancing IP> <source port> <dest port>\r\n

L'esempio seguente mostra un protocollo PROXY:

PROXY TCP4 192.0.2.1 198.51.100.1 15221 110\r\n

Nell'esempio precedente, l'IP client è 192.0.2.1, l'IP di bilanciamento del carico è 198.51.100.1, la porta client è 15221 e la porta di destinazione è 110.

Quando l'IP client non è noto, il bilanciatore del carico genera un'intestazione del protocollo PROXY nel seguente formato:

PROXY UNKNOWN\r\n

Aggiorna l'intestazione del protocollo PROXY per il proxy di destinazione

Non puoi aggiornare l'intestazione del protocollo PROXY nel proxy di destinazione esistente. Devi creare un nuovo proxy di destinazione con l'impostazione richiesta per l'intestazione del protocollo PROXY. Segui questi passaggi per creare un nuovo frontend con le impostazioni richieste:

Console

1. Nella console Google Cloud , vai alla pagina Bilanciamento del carico.

   Vai a Bilanciamento del carico

2. Fai clic sul nome del bilanciatore del carico da modificare.
3. Fai clic su Modifica per il bilanciatore del carico.
4. Fai clic su Configurazione frontend.
5. Elimina il vecchio IP e la vecchia porta frontend.
6. Fai clic su Aggiungi IP e porta frontend.
   1. In Nome, inserisci int-tcp-forwarding-rule.
   2. In Subnet, seleziona backend-subnet.
   3. In Indirizzo IP, seleziona l'indirizzo IP prenotato in precedenza: LB_IP_ADDRESS
   4. In Numero porta, inserisci 110. La regola di forwarding inoltra solo i pacchetti con una porta di destinazione corrispondente.
   5. Modifica il valore del campo Protocollo proxy impostandolo su On.
   6. Fai clic su Fine.
7. Fai clic su Update (Aggiorna) per salvare le modifiche.

gcloud

1. Nel comando seguente, modifica il campo --proxy-header e impostalo su NONE o PROXY_V1 a seconda delle tue esigenze.

      gcloud compute target-tcp-proxies create TARGET_PROXY_NAME \
          --backend-service=BACKEND_SERVICE \
          --proxy-header=[NONE | PROXY_V1] \
          --region=REGION
      

2. Elimina la regola di forwarding esistente.

      gcloud compute forwarding-rules delete int-tcp-forwarding-rule \
          --region=REGION
      

3. Crea una nuova regola di forwarding e associala al proxy di destinazione.

      gcloud compute forwarding-rules create int-tcp-forwarding-rule \
          --load-balancing-scheme=INTERNAL_MANAGED \
          --network=lb-network \
          --subnet=backend-subnet \
          --region=REGION \
          --target-tcp-proxy=TARGET_PROXY_NAME \
          --target-tcp-proxy-region=REGION \
          --address=LB_IP_ADDRESS \
          --ports=110
      

Abilita l'affinità sessione

La configurazione di esempio crea un servizio di backend senza affinità sessione.

Queste procedure mostrano come aggiornare un servizio di backend per il bilanciatore del carico di rete proxy interno regionale di esempio in modo che il servizio di backend utilizzi l'affinità IP client o l'affinità cookie generato.

Quando l'affinità IP client è abilitata, il bilanciatore del carico indirizza le richieste di un determinato client alla stessa VM di backend in base a un hash creato dall'indirizzo IP del client e dall'indirizzo IP del bilanciatore del carico (l'indirizzo IP interno di una regola di forwarding interno).

Console

Per abilitare l'affinità sessione IP client:

1. Nella console Google Cloud , vai alla pagina Bilanciamento del carico.
   Vai a Bilanciamento del carico
2. Fai clic su Backend.
3. Fai clic su internal-tcp-proxy-bs (il nome del servizio di backend che hai creato per questo esempio) e fai clic su Modifica.
4. Nella pagina Dettagli del servizio di backend, fai clic su Configurazione avanzata.
5. In Affinità sessione, seleziona IP client dal menu.
6. Fai clic su Aggiorna.

gcloud

Utilizza il seguente comando Google Cloud CLI per aggiornare il servizio di backend internal-tcp-proxy-bs, specificando l'affinità sessione IP client:

gcloud compute backend-services update internal-tcp-proxy-bs \
    --region=REGION_A \
    --session-affinity=CLIENT_IP

Abilita lo svuotamento della connessione

Puoi attivare svuotamento della connessione sui servizi di backend per garantire un'interruzione minima per gli utenti quando un'istanza che gestisce il traffico viene terminata, rimossa manualmente o rimossa da uno strumento di scalabilità automatica. Per scoprire di più sullo svuotamento della connessione, consulta la documentazione relativa all'attivazione dello svuotamento della connessione.

Passaggi successivi

• Converti il bilanciatore del carico di rete proxy in IPv6
• Panoramica del bilanciatore del carico di rete proxy interno regionale
• Utilizzo del monitoraggio
• Esegui la pulizia della configurazione del bilanciatore del carico