Configura un bilanciatore del carico di rete passthrough esterno globale per più protocolli IP

Anteprima

Questo prodotto o funzionalità sono soggetti ai "Termini dell'offerta pre-GA" nella sezione dei Termini di servizio generali dei Termini specifici dei servizi. I prodotti e le funzionalità pre-GA sono disponibili "così come sono" e potrebbero avere un supporto limitato. Per ulteriori informazioni, consulta le descrizioni della fase di lancio.

Questo documento mostra come creare un bilanciatore del carico di rete passthrough esterno globale per bilanciare il traffico TCP, UDP, ESP, GRE, ICMP e ICMPv6.

Puoi utilizzare questa configurazione per:

• Bilancia il carico del traffico che utilizza protocolli IP diversi da TCP o UDP.

• Eroga più protocolli con un unico bilanciatore del carico. Ad esempio, i servizi IPsec in genere gestiscono una combinazione di traffico ESP e IKE e NAT-T basato su UDP.

Prima di iniziare

Assicurati che la tua configurazione soddisfi i seguenti prerequisiti.

Installa Google Cloud CLI

Le istruzioni di questa guida utilizzano Google Cloud CLI per configurare un bilanciatore del carico di rete passthrough esterno globale. Per installarla, vedi Installa gcloud CLI.

Ruoli obbligatori

Se hai creato il progetto, ti viene concesso il ruolo Proprietario (roles/owner). Per impostazione predefinita, il ruolo Proprietario (roles/owner) o il ruolo Editor (roles/editor) include le autorizzazioni necessarie per seguire questo documento.

Se non sei il creatore del progetto, le autorizzazioni richieste devono essere concesse al principal appropriato. Ad esempio, un'entità può essere un Account Google (per gli utenti finali) o un service account.

Per ottenere le autorizzazioni necessarie per configurare un bilanciatore del carico di rete pass-through esterno globale con backend di gruppi di istanze VM, chiedi all'amministratore di concederti i seguenti ruoli IAM nel progetto:

• Crea una rete VPC, una subnet e componenti di bilanciamento del carico: Ruolo Compute Network Admin (roles/compute.networkAdmin)
• Crea regole firewall: Ruolo Compute Security Admin (roles/compute.securityAdmin)
• Crea istanze VM: Ruolo Compute Instance Admin (roles/compute.instanceAdmin)

Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

Potresti anche riuscire a ottenere le autorizzazioni richieste tramite i ruoli personalizzati o altri ruoli predefiniti.

Per saperne di più su ruoli e autorizzazioni per Cloud Load Balancing, consulta Ruoli e autorizzazioni. Per saperne di più sulla definizione delle policy IAM con concessioni condizionali per le regole di forwarding, consulta Condizioni IAM per le regole di forwarding.

Panoramica della configurazione

Il seguente diagramma mostra due bilanciatori del carico di rete passthrough esterni globali per la stessa coppia di indirizzi IP, ognuno dei quali serve un insieme diverso di protocolli e porte IP. Per capire come funziona un bilanciatore del carico di rete passthrough esterno globale, consulta la sezione Architettura nella guida alla panoramica.

Nota: devi configurare i componenti di un bilanciatore del carico di rete passthrough esterno globale utilizzando gcloud o l'API REST e non la console Google Cloud .

1. Bilanciatore del carico TCP sulla porta 80

   La regola di forwarding di questo bilanciatore del carico è configurata per acquisire solo il traffico TCP in arrivo specificamente sulla porta 80.

   • Quando un pacchetto arriva a un indirizzo IP di una regola di forwarding, Google Cloud controlla innanzitutto se si tratta di un pacchetto TCP e se la porta di destinazione è esattamente 80.
   • Se queste condizioni sono soddisfatte, questo pacchetto viene acquisito da questa regola di forwarding TCP specifica e instradato a un backend in base al servizio di backend a cui viene fatto riferimento.

2. Bilanciatore del carico L3_DEFAULT per il traffico TCP:8080 e UDP

   La regola di forwarding di questo bilanciatore del carico utilizza il protocollo L3_DEFAULT ed è configurata per accettare il traffico su tutte le porte. In questa configurazione, funge da regola catch-all che gestisce il traffico che la prima regola di forwarding non gestisce (ad esempio UDP, ICMP e tutto il traffico TCP diverso dalla porta 80).

   • Se un pacchetto arriva a un indirizzo IP della regola di forwarding che non corrisponde al traffico TCP specifico in arrivo sulla regola della porta 80 (ad esempio, se si tratta di traffico UDP, di un ping ICMP o di traffico TCP sulla porta 8080 o 443), questo pacchetto viene acquisito dalla regola di forwarding L3_DEFAULT.
   • Aggiungi una regola firewall per consentire solo al traffico TCP:8080 e UDP di raggiungere le istanze VM di backend. Pertanto, anche se la regola di forwarding L3_DEFAULT acquisisce tutto il traffico del protocollo IP su tutte le porte, la regola firewall limita il traffico bilanciato del carico al traffico TCP:8080 e UDP.
   • Il pacchetto viene quindi indirizzato a un backend in base al servizio di backend a cui viene fatto riferimento.

   Google Cloud assegna la priorità alla regola TCP più specifica sulla porta 80 prima di consentire al traffico rimanente di passare a una regola L3_DEFAULT sullo stesso indirizzo IP.

   Nota: poiché L3_DEFAULT è una regola catch-all, come best practice di sicurezza, devi configurare regole firewall di autorizzazione in entrata che consentano solo i protocolli e le porte IP di cui hai bisogno.

Due bilanciatori del carico di rete passthrough esterni globali per la stessa coppia di indirizzi IP, ciascuno dei quali serve un insieme diverso di protocolli e porte IP (fai clic per ingrandire).

Configura la rete e le subnet

L'esempio utilizza una rete VPC in modalità personalizzata denominata lb-network con subnet in due regioni diverse.

La tabella seguente riepiloga la compatibilità tra i tipi di traffico del bilanciatore del carico, le interfacce di rete delle VM di backend e i tipi di stack delle subnet VPC. Assicurati di avere familiarità con i requisiti di compatibilità dell'interfaccia di rete della VM di backend con le subnet VPC descritti nella guida all'architettura del bilanciatore del carico di rete passthrough esterno globale.

Tipo di traffico del bilanciatore del carico	Tipo di stack dell'interfaccia di rete della VM di backend	Tipo di stack della subnet VPC
Solo traffico IPv4	IPV4_ONLY	IPV4_ONLY o IPV4_IPV6
	IPV4_IPV6	IPV4_IPV6
Solo traffico IPv6	IPV6_ONLY	IPV6_ONLY o IPV4_IPV6
	IPV4_IPV6	IPV4_IPV6
Traffico IPv4 e IPv6	IPV4_IPV6	IPV4_IPV6

I backend utilizzati in questo esempio si trovano nelle seguenti regioni e subnet. Sebbene tu possa scegliere quale intervallo di indirizzi IPv4 configurare nella subnet, Google Cloud assegna automaticamente un intervallo di indirizzi IPv6 /64 all'intera subnet.

• Regione: us-west1

  • Subnet: lb-subnet-us, con intervallo di indirizzi IPv4 principali 10.1.2.0/24.

• Regione: europe-west2

  • Subnet: lb-subnet-eu, con intervallo di indirizzi IPv4 principali 10.1.3.0/24.

gcloud

1. Crea una rete VPC. In questo esempio, la rete VPC si chiama lb-network.

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

2. All'interno della rete VPC (lb-network), crea subnet in due regioni.

   Crea una subnet denominata lb-subnet-us per i backend nella regione us-west1.

   Per creare una subnet solo IPv4, utilizza il seguente comando:

   gcloud compute networks subnets create lb-subnet-us \
       --stack-type=IPV4_ONLY \
       --network=lb-network \
       --range=10.1.2.0/24 \
       --region=us-west1
   

   Per creare una subnet dual-stack, utilizza il seguente comando:

   gcloud compute networks subnets create lb-subnet-us \
       --stack-type=IPV4_IPV6 \
       --ipv6-access-type=EXTERNAL \
       --network=lb-network \
       --range=10.1.2.0/24 \
       --region=us-west1
   

   Per creare una subnet solo IPv6, utilizza il seguente comando:

   gcloud compute networks subnets create lb-subnet-us \
       --stack-type=IPV6_ONLY \
       --ipv6-access-type=EXTERNAL \
       --network=lb-network \
       --region=us-west1
   

   Crea una subnet denominata lb-subnet-eu per i backend nella regione europe-west2.

   Per creare una subnet solo IPv4, utilizza il seguente comando:

   gcloud compute networks subnets create lb-subnet-eu \
       --stack-type=IPV4_ONLY \
       --network=lb-network \
       --range=10.1.3.0/24 \
       --region=europe-west2
   

   Per creare una subnet dual-stack, utilizza il seguente comando:

   gcloud compute networks subnets create lb-subnet-eu \
       --stack-type=IPV4_IPV6 \
       --ipv6-access-type=EXTERNAL \
       --network=lb-network \
       --range=10.1.3.0/24 \
       --region=europe-west2
   

   Per creare una subnet solo IPv6, utilizza il seguente comando:

   gcloud compute networks subnets create lb-subnet-eu \
       --stack-type=IPV6_ONLY \
       --ipv6-access-type=EXTERNAL \
       --network=lb-network \
       --range=10.1.3.0/24 \
       --region=europe-west2
   

Prenota indirizzi IP esterni globali

Prenota due indirizzi IP esterni globali, uno per ogni gruppo di disponibilità. Come mostrato nella panoramica della configurazione, i due bilanciatori del carico di rete passthrough esterni globali condividono la stessa coppia di indirizzi IP.

Per un bilanciatore del carico di rete passthrough esterno globale, gli indirizzi IP della regola di forwarding sono completamente disaccoppiati dalle subnet VPC. Gli indirizzi IP appartengono a pool di indirizzi IP esterni globali di proprietà di Google o a prefissi delegati pubblici IPv4 esterni globali di gruppi di disponibilità distinti e non sono associati ad alcuna subnet VPC.

Quando configuri una regola di forwarding IPv6, gli indirizzi IP della regola di forwarding vengono allocati come prefissi /96.

gcloud

Per il traffico IPv4:

1. Prenota il primo indirizzo IP esterno globale denominato lb-ipv4-ag0 nel gruppo di disponibilità 0.

   gcloud beta compute addresses create lb-ipv4-ag0 \
       --global \
       --purpose=PASSTHROUGH_LOAD_BALANCER_AVAILABILITY_GROUP0 \
       --ip-version=IPV4
   

2. Prenota il secondo indirizzo IP esterno globale lb-ipv4-ag1 nel gruppo di disponibilità 1.

   gcloud beta compute addresses create lb-ipv4-ag1 \
       --global \
       --purpose=PASSTHROUGH_LOAD_BALANCER_AVAILABILITY_GROUP1 \
       --ip-version=IPV4
   

Per il traffico IPv6:

1. Prenota il primo indirizzo IP esterno globale denominato lb-ipv6-ag0 nel gruppo di disponibilità 0.

   gcloud beta compute addresses create lb-ipv6-ag0 \
       --global \
       --purpose=PASSTHROUGH_LOAD_BALANCER_AVAILABILITY_GROUP0 \
       --ip-version=IPV6
   

2. Prenota il secondo indirizzo IP esterno globale lb-ipv6-ag1 nel gruppo di disponibilità 1.

   gcloud beta compute addresses create lb-ipv6-ag1 \
       --global \
       --purpose=PASSTHROUGH_LOAD_BALANCER_AVAILABILITY_GROUP1 \
       --ip-version=IPV6
   

Configura un bilanciatore del carico per il traffico TCP sulla porta 80

Segui i passaggi descritti in questa sezione per configurare un bilanciatore del carico di rete passthrough esterno globale che acquisisce il traffico TCP sulla porta 80.

Crea regole firewall per consentire solo il traffico TCP:80

Per configurare in modo sicuro l'ambiente di produzione, devi creare due regole firewall separate:

• Regola firewall per il controllo di integrità, configurata per consentire il traffico in entrata da:

  • Gli intervalli IP dei controlli di integrità di Google e
  • il protocollo IP e le porte configurati nel controllo di integrità

• Regola firewall per il traffico utente, configurata per consentire il traffico in entrata da:

  • gli intervalli IP di origine client specifici che devono accedere al bilanciatore del carico e
  • il protocollo IP e le porte configurati nelle regole di forwarding

Tieni presente quanto segue:

• Se la tua applicazione serve tutti gli utenti di internet senza alcuna limitazione, configura gli intervalli IP di origine 0.0.0.0/0 per il traffico IPv4 e ::/0 per il traffico IPv6.

• Se hai configurato il controllo di integrità per eseguire il probe del protocollo e delle porte IP del bilanciamento del carico, puoi configurare una singola regola firewall unendo le regole firewall per il controllo di integrità e il traffico utente.

gcloud

Crea una regola firewall che consenta al traffico TCP da tutti gli intervalli di origine di raggiungere le istanze VM di backend sulla porta 80. Questa porta e questo protocollo vengono utilizzati sia per il bilanciamento del carico che per il controllo di integrità.

• Per consentire tutto il traffico IPv4, esegui questo comando:

    gcloud compute firewall-rules create allow-traffic-tcp-80-ipv4 \
        --network=lb-network \
        --target-tags=allow-traffic-tcp-80 \
        --allow=tcp:80 \
        --source-ranges=0.0.0.0/0
  

• Per consentire tutto il traffico IPv6, esegui questo comando:

    gcloud compute firewall-rules create allow-traffic-tcp-80-ipv6 \
        --network=lb-network \
        --target-tags=allow-traffic-tcp-80 \
        --allow=tcp:80 \
        --source-ranges=::/0
  

Crea istanze VM di backend

Per questo esempio di bilanciamento del carico, crea gruppi di istanze gestite nelle zone us-west1-a e europe-west2-a. Il gruppo di istanze gestite è costituito da istanze VM che ospitano i server di backend del bilanciatore del carico. A scopo dimostrativo, i backend eseguono il server Apache sulla porta 80. In risposta alle richieste dei client, gestiscono i propri nomi host.

Il gruppo di istanze fa riferimento a un modello di istanza, che viene utilizzato per creare VM di backend.

La tabella seguente riepiloga la compatibilità tra i tipi di traffico del bilanciatore del carico, le interfacce di rete delle VM di backend e i tipi di stack delle subnet VPC. Assicurati di avere familiarità con i requisiti di compatibilità dell'interfaccia di rete della VM di backend con le subnet VPC descritti nella guida all'architettura del bilanciatore del carico di rete passthrough esterno globale.

Tipo di traffico del bilanciatore del carico	Tipo di stack dell'interfaccia di rete della VM di backend	Tipo di stack della subnet VPC
Solo traffico IPv4	IPV4_ONLY	IPV4_ONLY o IPV4_IPV6
	IPV4_IPV6	IPV4_IPV6
Solo traffico IPv6	IPV6_ONLY	IPV6_ONLY o IPV4_IPV6
	IPV4_IPV6	IPV4_IPV6
Traffico IPv4 e IPv6	IPV4_IPV6	IPV4_IPV6

Crea un template di istanza

In questo esempio, crei template di istanza regionali nelle regioni us-west1 e europe-west2.

gcloud

1. Crea un template di istanza nella regione us-west1.

   Per creare VM di backend con interfacce di rete solo IPv4, utilizza il seguente comando.

   gcloud compute instance-templates create ig-template-us-tcp-80 \
       --region=us-west1 \
       --network=lb-network \
       --subnet=lb-subnet-us \
       --stack-type=IPV4_ONLY \
       --tags=allow-traffic-tcp-80 \
       --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'
   

   Per creare VM di backend con interfacce di rete dual stack, utilizza il seguente comando.

   gcloud compute instance-templates create ig-template-us-tcp-80 \
       --region=us-west1 \
       --network=lb-network \
       --subnet=lb-subnet-us \
       --ipv6-network-tier=PREMIUM \
       --stack-type=IPV4_IPV6 \
       --tags=allow-traffic-tcp-80 \
       --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'
   

   Per creare VM di backend con interfacce di rete solo IPv6, utilizza il seguente comando.

   gcloud compute instance-templates create ig-template-us-tcp-80 \
       --region=us-west1 \
       --network=lb-network \
       --subnet=lb-subnet-us \
       --ipv6-network-tier=PREMIUM \
       --stack-type=IPV6_ONLY \
       --tags=allow-traffic-tcp-80 \
       --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 template di istanza nella regione europe-west2.

   Per creare VM di backend con interfacce di rete solo IPv4, utilizza il seguente comando.

   gcloud compute instance-templates create ig-template-eu-tcp-80 \
       --region=europe-west2 \
       --network=lb-network \
       --subnet=lb-subnet-eu \
       --stack-type=IPV4_ONLY \
       --tags=allow-traffic-tcp-80 \
       --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'
   

   Per creare VM di backend con interfacce di rete dual stack, utilizza il seguente comando.

   gcloud compute instance-templates create ig-template-eu-tcp-80 \
       --region=europe-west2 \
       --network=lb-network \
       --subnet=lb-subnet-eu \
       --ipv6-network-tier=PREMIUM \
       --stack-type=IPV4_IPV6 \
       --tags=allow-traffic-tcp-80 \
       --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'
   

   Per creare VM di backend con interfacce di rete solo IPv6, utilizza il seguente comando.

   gcloud compute instance-templates create ig-template-eu-tcp-80 \
       --region=europe-west2 \
       --network=lb-network \
       --subnet=lb-subnet-eu \
       --ipv6-network-tier=PREMIUM \
       --stack-type=IPV6_ONLY \
       --tags=allow-traffic-tcp-80 \
       --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'
   

Crea gruppi di istanze gestite a livello di zona

In questo esempio, crei due gruppi di istanze gestite a livello di zona: uno nella zona us-west1-a e l'altro nella zona europe-west2-a.

gcloud

1. Crea un gruppo di istanze gestite nella zona us-west1-a.

   gcloud compute instance-groups managed create ig-us-tcp-80 \
     --template=ig-template-us-tcp-80 \
     --size=2 \
     --zone=us-west1-a
   

2. Crea un gruppo di istanze gestite nella zona europe-west2-a.

   gcloud compute instance-groups managed create ig-eu-tcp-80 \
     --template=ig-template-eu-tcp-80 \
     --size=2 \
     --zone=europe-west2-a
   

Crea i componenti di Cloud Load Balancing

Per creare i componenti Cloud Load Balancing di un bilanciatore del carico di rete passthrough esterno globale, segui questi passaggi.

gcloud

1. Crea un controllo di integrità TCP configurato per generare probe TCP:80.

   gcloud compute health-checks create tcp hc-tcp-80 \
     --global \
     --port=80
   

2. Crea un servizio di backend globale con lo schema di bilanciamento del carico EXTERNAL_PASSTHROUGH.

   gcloud beta compute backend-services create lb-backend-service-tcp-80 \
     --load-balancing-scheme=EXTERNAL_PASSTHROUGH \
     --health-checks=hc-tcp-80 \
     --global
   

3. Aggiungi i gruppi di istanze come backend al servizio di backend.

   Aggiungi il gruppo di istanze nella zona us-west1-a al servizio di backend.

   gcloud beta compute backend-services add-backend lb-backend-service-tcp-80 \
       --instance-group=ig-us-tcp-80 \
       --instance-group-zone=us-west1-a \
       --balancing-mode=UTILIZATION \
       --max-utilization=0.7 \
       --global
   

   Aggiungi il gruppo di istanze nella zona europe-west2-a al servizio di backend.

   gcloud beta compute backend-services add-backend lb-backend-service-tcp-80 \
       --instance-group=ig-eu-tcp-80 \
       --instance-group-zone=europe-west2-a \
       --balancing-mode=UTILIZATION \
       --max-utilization=0.7 \
       --global
   

4. Crea una regola di forwarding globale per gestire il traffico TCP:80.

   Assicurati che la versione IP della regola di forwarding corrisponda al tipo di stack delle interfacce di rete VM di backend.

   La regola di forwarding fa riferimento agli indirizzi IP di ogni gruppo di disponibilità.

   Per il traffico IPv4:

   gcloud beta compute forwarding-rules create lb-forwarding-rule-tcp-80-ipv4 \
     --load-balancing-scheme=EXTERNAL_PASSTHROUGH \
     --ip-protocol=TCP \
     --ports=80 \
     --backend-service=lb-backend-service-tcp-80 \
     --global \
     --ip-addresses=lb-ipv4-ag0,lb-ipv4-ag1
   

   Per il traffico IPv6:

   gcloud beta compute forwarding-rules create lb-forwarding-rule-tcp-80-ipv6 \
     --load-balancing-scheme=EXTERNAL_PASSTHROUGH \
     --ip-protocol=TCP \
     --ports=80 \
     --backend-service=lb-backend-service-tcp-80 \
     --global \
     --ip-addresses=lb-ipv6-ag0,lb-ipv6-ag1
   

Configura un bilanciatore del carico per il traffico TCP:8080 e UDP

Segui i passaggi descritti in questa sezione per configurare un bilanciatore del carico di rete passthrough esterno globale per gestire il traffico TCP:8080 e UDP.

Crea regole firewall per consentire solo il traffico TCP:8080 e UDP

Per configurare in modo sicuro l'ambiente di produzione, devi creare due regole firewall separate:

• Regola firewall per il controllo di integrità, configurata per consentire il traffico in entrata da:

  • Gli intervalli IP dei controlli di integrità di Google e
  • il protocollo IP e le porte configurati nel controllo di integrità

• Regola firewall per il traffico utente, configurata per consentire il traffico in entrata da:

  • gli intervalli IP di origine client specifici che devono accedere al bilanciatore del carico e
  • il protocollo IP e le porte configurati nelle regole di forwarding

Tieni presente quanto segue:

• Se la tua applicazione serve tutti gli utenti di internet senza alcuna limitazione, configura gli intervalli IP di origine 0.0.0.0/0 per il traffico IPv4 e ::/0 per il traffico IPv6.

• Se hai configurato il controllo di integrità per eseguire il probe del protocollo e delle porte IP del bilanciamento del carico, puoi configurare una singola regola firewall unendo le regole firewall per il controllo di integrità e il traffico utente.

gcloud

Crea una regola firewall che consenta il traffico TCP:8080 e UDP da tutti gli intervalli di origine per raggiungere le istanze VM di backend. Questi protocolli vengono utilizzati per il bilanciamento del carico, mentre la porta TCP 8080 viene utilizzata anche per il controllo di integrità.

1. Per consentire al traffico IPv4 di raggiungere i backend nei gruppi di istanze ig-us-l3-default e ig-eu-l3-default, crea la seguente regola firewall.

   gcloud compute firewall-rules create allow-traffic-l3-default-ipv4 \
       --network=lb-network \
       --target-tags=allow-traffic-l3-default \
       --allow=tcp:8080,udp \
       --source-ranges=0.0.0.0/0
   

2. Per consentire al traffico IPv6 di raggiungere i backend nei gruppi di istanze ig-us-l3-default e ig-eu-l3-default, crea la seguente regola firewall.

   gcloud compute firewall-rules create allow-traffic-l3-default-ipv6 \
       --network=lb-network \
       --target-tags=allow-traffic-l3-default \
       --allow=tcp:8080,udp \
       --source-ranges=::/0
   

Crea istanze VM di backend

Per questo esempio di bilanciamento del carico, crea gruppi di istanze gestite nelle zone us-west1-a e europe-west2-a. Il gruppo di istanze gestite è costituito da istanze VM che ospitano i server di backend del bilanciatore del carico. A scopo dimostrativo, i backend gestiscono i propri nomi host. Lo script di avvio configura anche il server Apache per l'ascolto sulla porta 8080 anziché sulla porta 80.

Il gruppo di istanze fa riferimento a un modello di istanza, che viene utilizzato per creare VM di backend.

La tabella seguente riepiloga la compatibilità tra i tipi di traffico del bilanciatore del carico, le interfacce di rete delle VM di backend e i tipi di stack delle subnet VPC. Assicurati di avere familiarità con i requisiti di compatibilità dell'interfaccia di rete della VM di backend con le subnet VPC descritti nella guida all'architettura del bilanciatore del carico di rete passthrough esterno globale.

Tipo di traffico del bilanciatore del carico	Tipo di stack dell'interfaccia di rete della VM di backend	Tipo di stack della subnet VPC
Solo traffico IPv4	IPV4_ONLY	IPV4_ONLY o IPV4_IPV6
	IPV4_IPV6	IPV4_IPV6
Solo traffico IPv6	IPV6_ONLY	IPV6_ONLY o IPV4_IPV6
	IPV4_IPV6	IPV4_IPV6
Traffico IPv4 e IPv6	IPV4_IPV6	IPV4_IPV6

Crea un template di istanza

In questo esempio, crei template di istanza regionali nelle regioni us-west1 e europe-west2.

gcloud

1. Crea un template di istanza nella regione us-west1.

   Per creare VM di backend con interfacce di rete solo IPv4, utilizza il seguente comando.

   gcloud compute instance-templates create ig-template-us-l3-default \
       --region=us-west1 \
       --network=lb-network \
       --subnet=lb-subnet-us \
       --stack-type=IPV4_ONLY \
       --tags=allow-traffic-l3-default \
       --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
       sed -ire "s/^Listen 80$/Listen 8080/g" /etc/apache2/ports.conf
       systemctl restart apache2'
   

   Per creare VM di backend con interfacce di rete dual stack, utilizza il seguente comando.

   gcloud compute instance-templates create ig-template-us-l3-default \
       --region=us-west1 \
       --network=lb-network \
       --subnet=lb-subnet-us \
       --ipv6-network-tier=PREMIUM \
       --stack-type=IPV4_IPV6 \
       --tags=allow-traffic-l3-default \
       --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
       sed -ire "s/^Listen 80$/Listen 8080/g" /etc/apache2/ports.conf
       systemctl restart apache2'
   

   Per creare VM di backend con interfacce di rete solo IPv6, utilizza il seguente comando.

   gcloud compute instance-templates create ig-template-us-l3-default \
       --region=us-west1 \
       --network=lb-network \
       --subnet=lb-subnet-us \
       --ipv6-network-tier=PREMIUM \
       --stack-type=IPV6_ONLY \
       --tags=allow-traffic-l3-default \
       --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
       sed -ire "s/^Listen 80$/Listen 8080/g" /etc/apache2/ports.conf
       systemctl restart apache2'
   

2. Crea un template di istanza nella regione europe-west2.

   Per creare VM di backend con interfacce di rete solo IPv4, utilizza il seguente comando.

   gcloud compute instance-templates create ig-template-eu-l3-default \
       --region=europe-west2 \
       --network=lb-network \
       --subnet=lb-subnet-eu \
       --stack-type=IPV4_ONLY \
       --tags=allow-traffic-l3-default \
       --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
       sed -ire "s/^Listen 80$/Listen 8080/g" /etc/apache2/ports.conf
       systemctl restart apache2'
   

   Per creare VM di backend con interfacce di rete dual stack, utilizza il seguente comando.

   gcloud compute instance-templates create ig-template-eu-l3-default \
       --region=europe-west2 \
       --network=lb-network \
       --subnet=lb-subnet-eu \
       --ipv6-network-tier=PREMIUM \
       --stack-type=IPV4_IPV6 \
       --tags=allow-traffic-l3-default \
       --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
       sed -ire "s/^Listen 80$/Listen 8080/g" /etc/apache2/ports.conf
       systemctl restart apache2'
   

   Per creare VM di backend con interfacce di rete solo IPv6, utilizza il seguente comando.

   gcloud compute instance-templates create ig-template-eu-l3-default \
       --region=europe-west2 \
       --network=lb-network \
       --subnet=lb-subnet-eu \
       --ipv6-network-tier=PREMIUM \
       --stack-type=IPV6_ONLY \
       --tags=allow-traffic-l3-default \
       --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
       sed -ire "s/^Listen 80$/Listen 8080/g" /etc/apache2/ports.conf
       systemctl restart apache2'
   

Crea gruppi di istanze gestite a livello di zona

In questo esempio, crei due gruppi di istanze gestite a livello di zona: uno nella zona us-west1-a e l'altro nella zona europe-west2-a.

gcloud

1. Crea un gruppo di istanze gestite nella zona us-west1-a.

   gcloud compute instance-groups managed create ig-us-l3-default \
     --template=ig-template-us-l3-default \
     --size=2 \
     --zone=us-west1-a
   

2. Crea un gruppo di istanze gestite nella zona europe-west2-a.

   gcloud compute instance-groups managed create ig-eu-l3-default \
     --template=ig-template-eu-l3-default \
     --size=2 \
     --zone=europe-west2-a
   

Crea i componenti di Cloud Load Balancing

Per creare i componenti Cloud Load Balancing di un bilanciatore del carico di rete passthrough esterno globale, segui questi passaggi.

gcloud

1. Crea un controllo di integrità TCP configurato per generare probe TCP:8080.

   gcloud compute health-checks create tcp hc-tcp-8080 \
     --global \
     --port=8080
   

2. Crea un servizio di backend globale con lo schema di bilanciamento del carico EXTERNAL_PASSTHROUGH.

   gcloud beta compute backend-services create lb-backend-service-l3-default \
     --load-balancing-scheme=EXTERNAL_PASSTHROUGH \
     --health-checks=hc-tcp-8080 \
     --global
   

3. Aggiungi i gruppi di istanze come backend al servizio di backend.

   Aggiungi il gruppo di istanze nella zona us-west1-a al servizio di backend.

   gcloud beta compute backend-services add-backend lb-backend-service-l3-default \
       --instance-group=ig-us-l3-default \
       --instance-group-zone=us-west1-a \
       --balancing-mode=UTILIZATION \
       --max-utilization=0.7 \
       --global
   

   Aggiungi il gruppo di istanze nella zona europe-west2-a al servizio di backend.

   gcloud beta compute backend-services add-backend lb-backend-service-l3-default \
       --instance-group=ig-eu-l3-default \
       --instance-group-zone=europe-west2-a \
       --balancing-mode=UTILIZATION \
       --max-utilization=0.7 \
       --global
   

4. Crea una regola di forwarding globale con il campo ip-protocol impostato su L3_DEFAULT per gestire tutto il traffico del protocollo IP (traffico TCP diverso dalla porta 80, UDP, ESP e ICMP). Devi creare due regole di forwarding per gestire il traffico IPv4 e IPv6.

   Assicurati che la versione IP della regola di forwarding corrisponda al tipo di stack delle interfacce di rete VM di backend.

   La regola di forwarding fa riferimento agli indirizzi IP di ogni gruppo di disponibilità.

   Nota: anche se la regola di forwarding L3_DEFAULT acquisisce tutto il traffico del protocollo IP su tutte le porte, la regola firewall consente solo al traffico TCP:8080 e UDP di raggiungere le istanze VM di backend.

   Per il traffico IPv4:

   gcloud beta compute forwarding-rules create lb-forwarding-rule-l3-default-ipv4 \
     --load-balancing-scheme=EXTERNAL_PASSTHROUGH \
     --ip-protocol=L3_DEFAULT \
     --ports=all \
     --backend-service=lb-backend-service-l3-default \
     --global \
     --ip-addresses=lb-ipv4-ag0,lb-ipv4-ag1
   

   Per il traffico IPv6:

   gcloud beta compute forwarding-rules create lb-forwarding-rule-l3-default-ipv6 \
     --load-balancing-scheme=EXTERNAL_PASSTHROUGH \
     --ip-protocol=L3_DEFAULT \
     --ports=all \
     --backend-service=lb-backend-service-l3-default \
     --global \
     --ip-addresses=lb-ipv6-ag0,lb-ipv6-ag1
   

testa il bilanciatore del carico

Ora che il servizio di bilanciamento del carico è configurato, puoi iniziare a inviare traffico agli indirizzi IP esterni del bilanciatore del carico e osservare la distribuzione del traffico alle istanze di backend.

Ottieni gli indirizzi IP esterni del bilanciatore del carico

1. Ottieni gli indirizzi IP prenotati collegati alla regola di forwarding. La regola di forwarding per entrambi i bilanciatori del carico utilizza la stessa coppia di indirizzi IP, quindi puoi utilizzare lb-forwarding-rule-tcp-80-ipv4 o lb-forwarding-rule-l3-default-ipv4 per visualizzare gli indirizzi IP esterni.

     gcloud compute forwarding-rules describe lb-forwarding-rule-tcp-80-ipv4 \
         --global
   

   Vengono restituiti due indirizzi IP, uno per ogni gruppo di disponibilità. Nei passaggi seguenti, questi indirizzi IP vengono indicati come IP_ADDRESS_AVAILABILITY_GROUP_0 e IP_ADDRESS_AVAILABILITY_GROUP_1.

Invia traffico al bilanciatore del carico

Questa procedura invia traffico esterno al bilanciatore del carico. Esegui i seguenti test per verificare che il traffico TCP sulla porta 80 venga bilanciato dal carico dai gruppi di istanze ig-us-tcp-80 o ig-eu-tcp-80, mentre tutto il resto del traffico (TCP:8080 e UDP) venga bilanciato dal carico dai gruppi di istanze ig-us-l3-default o ig-eu-l3-default.

Verifica del comportamento con richieste TCP sulla porta 80

1. Invia richieste web (tramite TCP sulla porta 80) al bilanciatore del carico utilizzando curl per contattare il relativo indirizzo IP.

   • Dai client con connettività IPv4, esegui questo comando:

     while true; do curl -m1 IP_ADDRESS_AVAILABILITY_GROUP_0; done
     

   Prendi nota del testo restituito dal comando curl. Il testo mostra il nome della VM di backend che genera la risposta, ad esempio Page served from: VM_NAME. Le risposte provengono solo da istanze nei gruppi di istanze ig-us-tcp-80 o ig-eu-tcp-80.

   Ciò dimostra che il traffico TCP inviato all'indirizzo IP del bilanciatore del carico sulla porta 80 viene gestito dalla regola di forwarding TCP.

Verifica del comportamento con le richieste TCP sulla porta 8080

Invia richieste web (tramite TCP sulla porta 8080) al bilanciatore del carico utilizzando curl per contattare il relativo indirizzo IP.

• Dai client con connettività IPv4, esegui questo comando:

  while true; do curl -m1 IP_ADDRESS_AVAILABILITY_GROUP_0:8080; done
  

  Prendi nota del testo restituito dal comando curl. Le risposte provengono solo da istanze nei gruppi di istanze ig-us-l3-default o ig-eu-l3-default.

  Ciò dimostra che il traffico TCP inviato all'indirizzo IP del bilanciatore del carico sulla porta 8080 viene gestito dalla regola di forwarding L3_DEFAULT.

Controlla la tabella di routing locale per gli indirizzi IP del bilanciatore del carico

Le tabelle di routing locali delle VM di backend contengono gli indirizzi IP del bilanciatore del carico di rete passthrough esterno globale.

Per controllare le route locali sulla VM di backend, connettiti alla VM di backend utilizzando SSH ed esegui questo comando:

  ip route list table local

L'output è il seguente:

local 10.1.2.5 dev ens4 proto kernel scope host src 10.1.2.5
local 127.0.0.0/8 dev lo proto kernel scope host src 127.0.0.1
local 127.0.0.1 dev lo proto kernel scope host src 127.0.0.1
broadcast 127.255.255.255 dev lo proto kernel scope link src 127.0.0.1
local 136.124.69.214 dev ens4 proto 66 scope host
local 136.124.83.205 dev ens4 proto 66 scope host

Nell'esempio precedente, 136.124.69.214 e 136.124.83.205 sono gli indirizzi IP assegnati alla regola di forwarding del bilanciatore del carico. Le voci di riga local 136.124.69.214 dev ens4 proto 66 scope host e local 136.124.83.205 dev ens4 proto 66 scope host nella tabella di routing locale della VM consentono ai pacchetti indirizzati agli indirizzi IP del bilanciatore del carico di essere accettati dal backend. L' Google Cloud ambiente guest è responsabile dell'aggiunta di questa voce.

La voce della tabella di routing locale nella VM di backend accetta il pacchetto per la consegna all'host locale, dove lo stack di rete lo consegna all'applicazione in ascolto. I pacchetti di risposta dell'applicazione vengono quindi inviati direttamente al client.

Tieni presente che l'indirizzo IP del bilanciatore del carico non è effettivamente configurato sull'interfaccia di rete della VM. Per verificarlo, esegui questo comando:

  ip addr list

L'output è il seguente. Gli indirizzi IP (136.124.69.214 e 136.124.83.205) vengono visualizzati nella tabella di routing locale, ma non sono configurati nell'interfaccia di rete.

1: lo:  mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
    inet6 ::1/128 scope host noprefixroute
       valid_lft forever preferred_lft forever
2: ens4:  mtu 1460 qdisc fq_codel state UP group default qlen 1000
    link/ether 42:01:0a:01:02:0d brd ff:ff:ff:ff:ff:ff
    altname enp0s4
    inet 10.1.2.13/32 metric 100 scope global dynamic ens4
       valid_lft 84283sec preferred_lft 84283sec
    inet6 fe80::4001:aff:fe01:20d/64 scope link
       valid_lft forever preferred_lft forever

Passaggi successivi

• Riferimenti all'API Cloud Load Balancing e a gcloud CLI
• Pulizia di una configurazione di bilanciamento del carico