Configura un bilanciatore del carico di rete passthrough interno con backend di gruppi di istanze VM per più protocolli

Questa pagina fornisce istruzioni per creare bilanciatori del carico di rete passthrough interni per bilanciare il traffico per più protocolli.

Per configurare un bilanciatore del carico per più protocolli, tra cui TCP e UDP, devi creare una regola di inoltro con il protocollo impostato suL3_DEFAULT. Questa regola di forwarding punta a un servizio di backend con il protocollo impostato su UNSPECIFIED.

In questo esempio, utilizziamo un bilanciatore del carico di rete passthrough interno per distribuire il traffico tra una VM di backend nella regione us-west1. Il bilanciatore del carico ha una regola di forwarding con protocolloL3_DEFAULT per gestire TCP, UDP, ICMP, ICMPv6, SCTP, ESP, AH e GRE.

Bilanciatore del carico di rete passthrough interno per più protocolli (fai clic per ingrandire).

Prima di iniziare

• Installa Google Cloud CLI. Per una panoramica completa dello strumento, consulta la panoramica dell'interfaccia a riga di comando gcloud. Puoi trovare i comandi relativi al bilanciamento del carico nei documenti di riferimento dell'API e di gcloud CLI. Se non hai mai eseguito l'interfaccia alla gcloud CLI, esegui prima il comando gcloud init per autenticarti.
• Scopri di più su bash.

Autorizzazioni

Per ottenere le autorizzazioni necessarie per completare questa guida, chiedi all'amministratore di concederti i seguenti ruoli IAM nel progetto:

• Per creare risorse di bilanciatori del carico: Amministratore bilanciatore del carico Compute (roles/compute.loadBalancerAdmin)
• Per creare istanze e gruppi di istanze Compute Engine: Amministratore di istanze Compute (roles/compute.instanceAdmin.v1)
• Per creare componenti di rete: Compute Network Admin (roles/compute.networkAdmin)

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

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

Nota: anche i ruoli di base IAM potrebbero contenere le autorizzazioni per completare questa guida. Non dovresti concedere i ruoli di base in un ambiente di produzione, ma puoi farlo in un ambiente di sviluppo o di test.

Configura il bilanciatore del carico per il traffico L3_DEFAULT

I passaggi descritti in questa sezione riguardano le seguenti configurazioni:

• Un esempio che utilizza una rete VPC in modalità personalizzata denominata lb-network. Puoi utilizzare una rete in modalità automatica se vuoi gestire solo il traffico IPv4. Tuttavia, il traffico IPv6 richiede una subnet in modalità personalizzata.
• Una subnet a stack singolo (stack-type impostato su IPv4), necessaria per il traffico IPv4. Quando crei una subnet a stack singolo in una rete VPC in modalità personalizzata, scegli un intervallo di subnet IPv4 per la subnet. Per il traffico IPv6, è necessaria una subnet a doppio stack (stack-type impostato su IPv4_IPv6). Quando crei una subnet a doppio stack in una rete VPC in modalità personalizzata, scegli un tipo di accesso IPv6 per la subnet. Per questo esempio, abbiamo impostato il parametro ipv6-access-type della sottorete su INTERNAL. Ciò significa che alle nuove VM in questa subnet possono essere assegnati sia indirizzi IPv4 interni sia indirizzi IPv6 interni.
• Regole firewall che consentono le connessioni in entrata alle VM di backend.
• Il gruppo di istanza di backend e i componenti del bilanciatore del carico utilizzati per questo esempio si trovano in questa regione e subnet:
  • Regione: us-west1
  • Subnet: lb-subnet, con intervallo di indirizzi IPv4 principale10.1.2.0/24. Sebbene tu scelga quale intervallo di indirizzi IPv4 deve essere configurato sulla subnet, l'intervallo di indirizzi IPv6 viene assegnato automaticamente. Google fornisce un blocco CIDR IPv6 di dimensioni fisse (/64).
• Una VM di backend in un gruppo di istanze gestite nella zona us-west1-a.
• Una VM client per testare le connessioni ai backend.
• Un bilanciatore del carico di rete passthrough interno con i seguenti componenti:
  • Un controllo di integrità per il servizio di backend.
  • Un servizio di backend nella regione us-west1 con il protocollo impostato su UNSPECIFIED per gestire la distribuzione delle connessioni al gruppo di istanze a livello di zona.
  • Una regola di forwarding con il protocollo impostato su L3_DEFAULT e la porta impostata su ALL.

Nota: puoi modificare il nome della rete, della regione e i parametri della sottorete. Tuttavia, i passaggi successivi di questa guida utilizzano i parametri rete, regione e sottorete come descritto nell'elenco precedente.

Configura una rete, una regione e una subnet

Per configurare le subnet con intervalli IPv6 interni, abilita un intervallo IPv6 interno ULA della rete VPC (Virtual Private Cloud). Gli intervalli di subnet IPv6 interni vengono allocati da questo intervallo. Per creare la rete e la sottorete di esempio:

Console

Per supportare sia il traffico IPv4 che IPv6, svolgi i seguenti passaggi:

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. Se vuoi configurare intervalli di indirizzi IPv6 interni sulle subnet di questa rete, completa i seguenti passaggi:

   1. Per Intervallo IPv6 interno ULA rete VPC, seleziona Abilitato.
   2. In Alloca intervallo IPv6 interno, seleziona Automaticamente o Manualmente.

      Suggerimento per professionisti: se selezioni Manualmente, inserisci un intervallo /48 all'interno dell'intervallo fd20::/20. Se l'intervallo è in uso, ti viene chiesto di fornire un altro intervallo.

5. In Modalità di creazione subnet, seleziona Personalizzata.

6. Nella sezione Nuova subnet, specifica i seguenti parametri di configurazione per una subnet:

   1. In Nome, inserisci lb-subnet.
   2. In Regione, seleziona us-west1.
   3. Per creare una subnet a doppio stack, seleziona IPv4 e IPv6 (stack doppio) per Tipo di stack IP.
   4. Per Intervallo IPv4, inserisci 10.1.2.0/24.
   5. In Tipo di accesso IPv6, seleziona Interno.

7. Fai clic su Fine.

8. Fai clic su Crea.

Per supportare il traffico IPv4, segui questi passaggi:

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.
   • Nella sezione Nuova subnet, inserisci le seguenti informazioni:
     • Nome: lb-subnet
     • Regione: us-west1
     • Tipo di stack IP: IPv4 (stack singolo)
     • Intervallo di indirizzi IP: 10.1.2.0/24
   • Fai clic su Fine.

5. Fai clic su Crea.

gcloud

Per il traffico IPv4 e IPv6, utilizza i seguenti comandi:

1. Per creare una nuova rete VPC in modalità personalizzata, esegui il comando gcloud compute networks create.

   Per configurare intervalli IPv6 interni su qualsiasi subnet di questa rete, utilizza il flag --enable-ula-internal-ipv6. Questa opzione assegna un prefisso ULA /48 all'interno dell'intervallo fd20::/20 utilizzato da Google Cloud per gli intervalli di sottoreti IPv6 interni.

   gcloud compute networks create lb-network \
    --subnet-mode=custom \
    --enable-ula-internal-ipv6
   

2. All'interno di lb-network, crea una subnet per i backend nella regione us-west1.

   Per creare le subnet, esegui il comando gcloud compute networks subnets create:

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

Per solo traffico IPv4, utilizza i seguenti comandi:

1. Per creare la rete VPC personalizzata, utilizza il comando gcloud compute networks create:

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

2. Per creare la subnet per i backend nella regione us-west1 all'interno della rete lb-network, utilizza il comando gcloud compute networks subnets create.

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

API

Per il traffico IPv4 e IPv6, utilizza i seguenti comandi:

1. Crea una nuova rete VPC in modalità personalizzata. Invia una richiesta POST al metodo networks.insert.

   Per configurare intervalli IPv6 interni su qualsiasi subnet di questa rete, imposta enableUlaInternalIpv6 su true. Questa opzione assegna un intervallo /48 all'interno dell'intervallo fd20::/20 utilizzato da Google per gli intervalli di subnet IPv6 interni.

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks
   {
     "autoCreateSubnetworks": false,
     "name": "lb-network",
     "mtu": MTU,
     "enableUlaInternalIpv6": true,
   }
   

   Sostituisci quanto segue:

   • PROJECT_ID: l'ID del progetto in cui viene creata la rete VPC.
   • MTU: l'unità massima di trasmissione della rete. Il valore della MTU può essere 1460 (predefinito) o 1500. Esamina la panoramica dell'unità massima di trasmissione prima di impostare l'MTU su 1500.

2. Invia una richiesta POST al metodo subnetworks.insert.

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/subnetworks
   {
   "ipCidrRange": "10.1.2.0/24",
   "network": "lb-network",
   "name": "lb-subnet"
   "stackType": IPV4_IPV6,
   "ipv6AccessType": Internal
   }
   

Per solo traffico IPv4, segui questi passaggi:

1. Invia una richiesta POST al metodo networks.insert. Sostituisci PROJECT_ID con l'ID del tuo progettoGoogle Cloud .

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks
   {
   "name": "lb-network",
   "autoCreateSubnetworks": false
   }
   

2. Invia due richieste POST al metodo subnetworks.insert:

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks
   {
   "name": "lb-subnet",
   "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
   "ipCidrRange": "10.1.2.0/24",
   "privateIpGoogleAccess": false
   }
   

Configurazione delle regole del firewall

Questo esempio utilizza le seguenti regole firewall:

• fw-allow-lb-access: una regola di ingresso, applicabile a tutti i target della rete VPC, che consente il traffico dalle origini negli intervalli 10.1.2.0/24. Questa regola consente il traffico in entrata da qualsiasi client che si trova nella subnet.

• fw-allow-lb-access-ipv6: una regola di ingresso, applicabile a tutte le destinazioni della rete VPC, che consente il traffico dalle origini nell'intervallo IPv6 configurato nella subnet. Questa regola consente il traffico IPv6 in entrata da qualsiasi client che si trova nella subnet.

• fw-allow-ssh: una regola in entrata, applicabile alle istanze sottoposte a 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 stai avviando le sessioni SSH. Questo esempio utilizza il tag di destinazione allow-ssh per identificare le VM a cui deve essere applicato.

• fw-allow-health-check: una regola di ingresso, applicabile alle istanze bilanciate in base al carico, che consente il traffico dai sistemi di controllo della salute Google Cloud (130.211.0.0/22 e 35.191.0.0/16). Questo esempio utilizza il tag target allow-health-check per identificare le istanze a cui deve essere applicato.

• fw-allow-health-check-ipv6: una regola di ingresso, applicabile alle istanze bilanciate in base al carico, che consente il traffico dai sistemi di controllo della salute di Google Cloud (2600:2d00:1:b029::/64). Questo esempio utilizza il tag target allow-health-check-ipv6 per identificare le istanze a cui deve essere applicato.

Senza queste regole firewall, la regola default-deny per il traffico in entrata blocca il traffico in entrata verso le istanze di backend.

Nota: devi creare una regola firewall per consentire i controlli di integrità dagli intervalli IP dei sistemi di probe Google Cloud . Per ulteriori informazioni, consulta Intervalli IP e regole del firewall per i sondaggi.

Console

1. Nella console Google Cloud , vai alla pagina Regole firewall.

   Vai a Policy del firewall

2. Per consentire al traffico IPv4 TCP, UDP e ICMP di raggiungere il gruppo di istanza di backend ig-a:

   • Fai clic su Crea regola firewall.
   • Nome: fw-allow-lb-access
   • Rete: lb-network
   • Priorità: 1000
   • Direzione del traffico: In entrata
   • Azione in caso di corrispondenza: Consenti
   • Destinazioni: Tutte le istanze nella rete
   • Filtro di origine: Intervalli IPv4
   • Intervalli IPv4 di origine: 10.1.2.0/24
   • Protocolli e porte: seleziona Protocolli e porte specificati.
     • Seleziona TCP e inserisci ALL.
     • Seleziona UDP.
     • Seleziona Altro e inserisci ICMP.

3. Fai clic su Crea.

4. Per consentire le connessioni SSH in entrata:

   • Fai clic su Crea regola firewall.
   • Nome: fw-allow-ssh
   • Rete: lb-network
   • Priorità: 1000
   • 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, quindi digita tcp:22.

5. Fai clic su Crea.

6. Per consentire al traffico TCP, UDP e ICMP IPv6 di raggiungere il gruppo di istanza di backend ig-a:

   • Fai clic su Crea regola firewall.
   • Nome: fw-allow-lb-access-ipv6
   • Rete: lb-network
   • Priorità: 1000
   • Direzione del traffico: In entrata
   • Azione in caso di corrispondenza: Consenti
   • Destinazioni: Tutte le istanze nella rete
   • Filtro di origine: intervalli IPv6
   • Intervalli IPv6 di origine: IPV6_ADDRESS assegnati in lb-subnet
   • Protocolli e porte: seleziona Protocolli e porte specificati.
     • Seleziona TCP e inserisci 0-65535.
     • Seleziona UDP.
     • Seleziona Altro e per il protocollo ICMPv6 inserisci 58.

7. Fai clic su Crea.

8. Per consentire i controlli di integrità IPv6 di Google Cloud :

   • Fai clic su Crea regola firewall.
   • Nome: fw-allow-health-check-ipv6
   • Rete: lb-network
   • Priorità: 1000
   • Direzione del traffico: In entrata
   • Azione in caso di corrispondenza: Consenti
   • Target: Tag di destinazione specificati
   • Tag di destinazione: allow-health-check-ipv6
   • Filtro di origine: intervalli IPv6
   • Intervalli IPv6 di origine: 2600:2d00:1:b029::/64
   • Protocolli e porte: Consenti tutto

9. Fai clic su Crea.

10. Per consentire i controlli di integrità IPv4 di Google Cloud :

    • Fai clic su Crea regola firewall.
    • Nome: fw-allow-health-check
    • Rete: lb-network
    • Priorità: 1000
    • 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: Consenti tutto

11. Fai clic su Crea.

gcloud

1. Per consentire al traffico TCP IPv4 di raggiungere il gruppo di istanza di backend ig-a, crea la seguente regola:

   gcloud compute firewall-rules create fw-allow-lb-access \
       --network=lb-network \
       --action=allow \
       --direction=ingress \
       --source-ranges=10.1.2.0/24 \
       --rules=tcp,udp,icmp
   

2. Crea la regola firewall fw-allow-ssh per consentire la connettività SSH alle VM utilizzando il tag di rete allow-ssh. Se ometti source-ranges, Google Cloud interpreta la regola come qualsiasi origine.

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

3. Per consentire al traffico IPv6 di raggiungere il gruppo di istanza di backend ig-a, crea la seguente regola:

   gcloud compute firewall-rules create fw-allow-lb-access-ipv6 \
       --network=lb-network \
       --action=allow \
       --direction=ingress \
       --source-ranges=IPV6_ADDRESS \
       --rules=all
   

   Sostituisci IPV6_ADDRESS con l'indirizzo IPv6 assegnato in lb-subnet.

4. Crea la regola firewall fw-allow-health-check per consentire i controlli di integrità di Google Cloud.

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

5. Crea la regola fw-allow-health-check-ipv6 per consentire i controlli di integrità IPv6 di Google Cloud.

   gcloud compute firewall-rules create fw-allow-health-check-ipv6 \
      --network=lb-network \
      --action=allow \
      --direction=ingress \
      --target-tags=allow-health-check-ipv6 \
      --source-ranges=2600:2d00:1:b029::/64 \
      --rules=tcp,udp,icmp
   

API

1. Per creare la regola firewall fw-allow-lb-access, invia una richiesta POST al metodo firewalls.insert. Sostituisci PROJECT_ID con l'ID del tuo progettoGoogle Cloud .

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls
   {
   "name": "fw-allow-lb-access",
   "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
   "priority": 1000,
   "sourceRanges": [
     "10.1.2.0/24"
   ],
   "allPorts": true,
   "allowed": [
     {
       "IPProtocol": "tcp"
     },
     {
       "IPProtocol": "udp"
     },
     {
       "IPProtocol": "icmp"
     }
   ],
   "direction": "INGRESS",
   "logConfig": {
     "enable": false
   },
   "disabled": false
   }
   

2. Crea la regola firewall fw-allow-lb-access-ipv6 inviando una richiesta POST al metodo firewalls.insert.

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls
   {
    "name": "fw-allow-lb-access-ipv6",
    "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
    "priority": 1000,
    "sourceRanges": [
      "IPV6_ADDRESS"
    ],
    "allPorts": true,
    "allowed": [
      {
         "IPProtocol": "tcp"
       },
       {
         "IPProtocol": "udp"
       },
       {
         "IPProtocol": "58"
       }
    ],
    "direction": "INGRESS",
    "logConfig": {
       "enable": false
    },
    "disabled": false
   }
   

   Sostituisci IPV6_ADDRESS con l'indirizzo IPv6 assegnato in lb-subnet.

3. Per creare la regola firewall fw-allow-ssh, invia una richiesta POST al metodo firewalls.insert:

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls
   {
   "name": "fw-allow-ssh",
        "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
   "priority": 1000,
   "sourceRanges": [
     "0.0.0.0/0"
   ],
   "targetTags": [
     "allow-ssh"
   ],
   "allowed": [
    {
      "IPProtocol": "tcp",
      "ports": [
        "22"
      ]
    }
   ],
   "direction": "INGRESS",
   "logConfig": {
    "enable": false
   },
   "disabled": false
   }
   

4. Per creare la regola firewall fw-allow-health-check, invia una richiesta POST al metodo firewalls.insert:

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls
   {
   "name": "fw-allow-health-check",
   "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
   "priority": 1000,
   "sourceRanges": [
     "130.211.0.0/22",
     "35.191.0.0/16"
   ],
   "targetTags": [
     "allow-health-check"
   ],
   "allowed": [
     {
       "IPProtocol": "tcp"
     },
     {
       "IPProtocol": "udp"
     },
     {
       "IPProtocol": "icmp"
     }
   ],
   "direction": "INGRESS",
   "logConfig": {
     "enable": false
   },
   "disabled": false
   }
   

5. Crea la regola firewall fw-allow-health-check-ipv6 inviando una richiesta POST al metodo firewalls.insert.

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls
   {
   "name": "fw-allow-health-check-ipv6",
   "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
   "priority": 1000,
   "sourceRanges": [
     "2600:2d00:1:b029::/64"
   ],
   "targetTags": [
     "allow-health-check-ipv6"
   ],
   "allowed": [
     {
       "IPProtocol": "tcp"
     },
     {
       "IPProtocol": "udp"
     }
   ],
   "direction": "INGRESS",
   "logConfig": {
     "enable": false
   },
   "disabled": false
   }
   

Crea VM e gruppi di istanze di backend

Per questo scenario di bilanciamento del carico, crea un gruppo di istanze gestite zonali Compute Engine e installa un server web Apache.

Per gestire il traffico IPv4 e IPv6, configura le VM di backend come a doppio stack. Imposta stack-type della VM su IPv4_IPv6. Le VM ereditano anche l'impostazioneipv6-access-type (in questo esempio, INTERNAL) dalla subnet. Per maggiori dettagli sui requisiti IPv6, consulta la Panoramica del bilanciatore del carico di rete passthrough interno: Regole di inoltro.

Se vuoi utilizzare le VM esistenti come backend, aggiornale in modo che siano dual-stack utilizzando il comando gcloud compute instances network-interfaces update.

Le istanze che partecipano come VM di backend per i bilanciatori del carico di rete passthrough interni devono eseguire l'ambiente guest Linux, l'ambiente guest Windows o altri processi che forniscono funzionalità equivalenti.

Per semplicità di istruzione, le VM di backend eseguono Debian GNU/Linux 10.

Crea il gruppo di istanze

Console

Per supportare sia il traffico IPv4 che IPv6, svolgi i seguenti passaggi:

1. Creare un modello di istanza. Nella console Google Cloud , vai alla pagina Modelli di istanza.

   Vai a Modelli di istanza

   1. Fai clic su Crea modello istanza.
   2. In Nome, inserisci vm-a1.
   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. Espandi la sezione Opzioni avanzate.

   5. Espandi la sezione Gestione e poi copia il seguente script nel campo Script di avvio. Lo script di avvio configura inoltre il server Apache in modo che ascolti sulla porta 8080 anziché sulla porta 80.

      #! /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
      

   6. Espandi la sezione Networking e specifica quanto segue:

      1. In Tag di rete, aggiungi allow-ssh e allow-health-check-ipv6.
      2. In Interfacce di rete, fai clic sull'interfaccia predefinita e configura i seguenti campi:
         • Rete: lb-network
         • Subnet: lb-subnet
         • Tipo di stack IP: IPv4 e IPv6 (stack doppio)

   7. Fai clic su Crea.

Per supportare il traffico IPv4, segui questi passaggi:

1. Creare un modello di istanza. Nella console Google Cloud , vai alla pagina Modelli di istanza.

   Vai a Modelli di istanza

2. Fai clic su Crea modello istanza.

   1. In Nome, inserisci vm-a1.
   2. 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.
   3. Espandi la sezione Opzioni avanzate.

   4. Espandi la sezione Gestione e poi copia il seguente script nel campo Script di avvio. Lo script di avvio configura inoltre il server Apache in modo che ascolti sulla porta 8080 anziché sulla porta 80.

      #! /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
      

   5. Espandi la sezione Networking e specifica quanto segue:

      1. In Tag di rete, aggiungi allow-ssh e allow-health-check.
      2. In Interfacce di rete, fai clic sull'interfaccia predefinita e configura i seguenti campi:
         • Rete: lb-network
         • Subnet: lb-subnet
         • Tipo di stack IP: IPv4 (stack singolo)

   6. Fai clic su Crea.

3. Creare un gruppo di istanze gestite. Vai alla pagina Gruppi di istanze nella console Google Cloud .

   Vai a Gruppi di istanze

   1. Fai clic su Crea gruppo di istanze.
   2. Scegli Nuovo gruppo di istanze gestite (stateless). Per ulteriori informazioni, consulta Gruppi di istanze gestite stateless o stateful.
   3. In Nome, inserisci ig-a.
   4. In Località, seleziona Zona singola.
   5. Per Regione, seleziona us-west1.
   6. In Zona, seleziona us-west1-a.
   7. In Modello di istanza, seleziona vm-a1.

   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. Fai clic su Crea.

gcloud

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

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

   Lo script di avvio configura inoltre il server Apache in modo che ascolti sulla porta 8080 anziché sulla porta 80.

   Per gestire sia il traffico IPv4 che IPv6, utilizza il seguente comando.

   gcloud compute instance-templates create vm-a1 \
       --region=us-west1 \
       --network=lb-network \
       --subnet=lb-subnet \
       --ipv6-network-tier=PREMIUM \
       --stack-type=IPv4_IPv6 \
       --tags=allow-ssh \
       --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'
   

   In alternativa, se vuoi gestire solo il traffico IPv4, utilizza il seguente comando.

   gcloud compute instance-templates create vm-a1 \
       --region=us-west1 \
       --network=lb-network \
       --subnet=lb-subnet \
       --tags=allow-ssh \
       --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 gruppo di istanze gestite nella zona con il comando gcloud compute instance-groups managed create.

   gcloud compute instance-groups managed create ig-a \
       --zone us-west1-a \
       --size 2 \
       --template vm-a1
   

api

Per gestire sia il traffico IPv4 che IPv6, segui questi passaggi:

1. Crea una VM inviando richieste POST al metodo instances.insert:

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances
   {
   "name": "vm-a1",
   "tags": {
    "items": [
      "allow-health-check-ipv6",
      "allow-ssh"
    ]
   },
   "machineType": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/machineTypes/e2-standard-2",
   "canIpForward": false,
   "networkInterfaces": [
    {
      "stackType": "IPV4_IPV6",
      "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
      "subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
      "accessConfigs": [
        {
          "type": "ONE_TO_ONE_NAT",
          "name": "external-nat",
          "networkTier": "PREMIUM"
        }
      ]
    }
   ],
   "disks": [
    {
      "type": "PERSISTENT",
      "boot": true,
      "mode": "READ_WRITE",
      "autoDelete": true,
      "deviceName": "vm-a1",
      "initializeParams": {
        "sourceImage": "projects/debian-cloud/global/images/DEBIAN_IMAGE_NAME",
        "diskType": "projects/PROJECT_ID/zones/ZONE/diskTypes/pd-standard",
        "diskSizeGb": "10"
      }
    }
   ],
   "metadata": {
    "items": [
      {
        "key": "startup-script",
        "value": "#! /bin/bash\napt-get update\napt-get install apache2 -y\na2ensite default-ssl\na2enmod ssl\nvm_hostname="$(curl -H "Metadata-Flavor:Google" \\\nhttp://metadata.google.internal/computeMetadata/v1/instance/name)"\necho "Page served from: $vm_hostname" | \\\ntee /var/www/html/index.html\nsed -ire "s/^Listen 80$/Listen 8080/g" /etc/\\napache2/ports.conf\nsystemctl restart apache2"
      }
    ]
   },
   "scheduling": {
    "preemptible": false
   },
   "deletionProtection": false
   }
   

Per gestire il traffico IPv4, segui questi passaggi.

1. Crea una VM inviando richieste POST al metodo instances.insert:

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances
   {
   "name": "vm-a1",
   "tags": {
    "items": [
      "allow-health-check",
      "allow-ssh"
    ]
   },
   "machineType": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/machineTypes/e2-standard-2",
   "canIpForward": false,
   "networkInterfaces": [
    {
      "stackType": "IPV4",
      "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
      "subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
      "accessConfigs": [
        {
          "type": "ONE_TO_ONE_NAT",
          "name": "external-nat",
          "networkTier": "PREMIUM"
        }
      ]
    }
   ],
   "disks": [
    {
      "type": "PERSISTENT",
      "boot": true,
      "mode": "READ_WRITE",
      "autoDelete": true,
      "deviceName": "vm-a1",
      "initializeParams": {
        "sourceImage": "projects/debian-cloud/global/images/DEBIAN_IMAGE_NAME",
        "diskType": "projects/PROJECT_ID/zones/ZONE/diskTypes/pd-standard",
        "diskSizeGb": "10"
      }
    }
   ],
   "metadata": {
    "items": [
      {
        "key": "startup-script",
        "value": "#! /bin/bash\napt-get update\napt-get install apache2 -y\na2ensite default-ssl\na2enmod ssl\nvm_hostname="$(curl -H "Metadata-Flavor:Google" \\\nhttp://metadata.google.internal/computeMetadata/v1/instance/name)"\necho "Page served from: $vm_hostname" | \\\ntee /var/www/html/index.html\nsed -ire "s/^Listen 80$/Listen 8080/g" /etc/\\napache2/ports.conf\nsystemctl restart apache2"
      }
    ]
   },
   "scheduling": {
    "preemptible": false
   },
   "deletionProtection": false
   }
   

2. Crea un gruppo di istanze inviando una richiesta POST al metodo instanceGroups.insert.

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instanceGroups
   
   {
   "name": "ig-a",
   "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
   "subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet"
   }
   

3. Aggiungi istanze a ogni gruppo di istanze inviando una richiesta POST al metodo instanceGroups.addInstances.

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instanceGroups/ig-a/addInstances
   
   {
   "instances": [
   {
    "instance": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instances/vm-a1"
   }
   ]
   }
   

Crea una VM client

Questo esempio crea una VM client nella stessa regione delle VM di backend (server). Il client viene utilizzato per convalidare la configurazione del bilanciatore del carico e dimostrare il comportamento previsto come descritto nella sezione Test.

Per il traffico IPv4 e IPv6:

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 vm-client-ipv6.

4. Imposta Zona su us-west1-a.

5. Espandi la sezione Opzioni avanzate e apporta le seguenti modifiche:

   • Espandi Networking e aggiungi allow-ssh a Tag di rete.
   • In Interfacce di rete, fai clic su Modifica, apporta le seguenti modifiche e poi fai clic su Fine:
     • Rete: lb-network
     • Subnet: lb-subnet
     • Tipo di stack IP: IPv4 e IPv6 (stack doppio)
     • IP interno principale: Temporaneo (automatico)
     • IP esterno: Temporaneo

6. Fai clic su Crea.

gcloud

La VM client può trovarsi in qualsiasi zona della stessa regione del bilanciatore del carico e può utilizzare qualsiasi sottorete della regione. In questo esempio, il client si trova nella zona us-west1-a e utilizza la stessa sottorete delle VM di backend.

gcloud compute instances create vm-client-ipv6 \
    --zone=us-west1-a \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --stack-type=IPV4_IPV6 \
    --tags=allow-ssh \
    --subnet=lb-subnet

api

Invia una richiesta POST al metodo instances.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instances

{
 "name": "vm-client-ipv6",
 "tags": {
   "items": [
     "allow-ssh"
   ]
 },
 "machineType": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/machineTypes/e2-standard-2",
 "canIpForward": false,
 "networkInterfaces": [
   {
     "stackType": "IPV4_IPV6",
     "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
     "subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
     "accessConfigs": [
       {
         "type": "ONE_TO_ONE_NAT",
         "name": "external-nat",
         "networkTier": "PREMIUM"
       }
     ]
   }
 ],
 "disks": [
   {
     "type": "PERSISTENT",
     "boot": true,
     "mode": "READ_WRITE",
     "autoDelete": true,
     "deviceName": "vm-client",
     "initializeParams": {
       "sourceImage": "projects/debian-cloud/global/images/debian-image-name",
       "diskType": "projects/PROJECT_ID/zones/us-west1-a/diskTypes/pd-standard",
       "diskSizeGb": "10"
     }
   }
 ],
 "scheduling": {
   "preemptible": false
 },
 "deletionProtection": false
}

Per il traffico IPv4:

Console

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

   Vai a Istanze VM

2. Fai clic su Crea istanza.

3. In Nome, inserisci vm-client.

4. In Zona, inserisci us-west1-a.

5. Espandi la sezione Opzioni avanzate.

6. Espandi 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: lb-subnet

7. Fai clic su Crea.

gcloud

La VM client può trovarsi in qualsiasi zona della stessa regione del bilanciatore del carico e può utilizzare qualsiasi sottorete della regione. In questo esempio, il client si trova nella zona us-west1-a e utilizza la stessa sottorete delle VM di backend.

gcloud compute instances create vm-client \
    --zone=us-west1-a \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --tags=allow-ssh \
    --subnet=lb-subnet

API

Invia una richiesta POST al metodo instances.insert. Sostituisci PROJECT_ID con l'ID del tuo progetto Google Cloud .

 POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instances
 {
    "name": "vm-client",
    "tags": {
      "items": [
        "allow-ssh"
      ]
  },
    "machineType": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/machineTypes/e2-standard-2",
    "canIpForward": false,
    "networkInterfaces": [
      {
        "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
        "subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
        "accessConfigs": [
          {
            "type": "ONE_TO_ONE_NAT",
            "name": "external-nat",
            "networkTier": "PREMIUM"
          }
        ]
      }
    ],
    "disks": [
      {
        "type": "PERSISTENT",
        "boot": true,
        "mode": "READ_WRITE",
        "autoDelete": true,
        "deviceName": "vm-client",
        "initializeParams": {
          "sourceImage": "projects/debian-cloud/global/images/debian-image-name",
          "diskType": "projects/PROJECT_ID/zones/us-west1-a/diskTypes/pd-standard",
          "diskSizeGb": "10"
        }
      }
    ],
    "scheduling": {
      "preemptible": false
     },
    "deletionProtection": false
  }
  

Configura i componenti del bilanciatore del carico

Crea un bilanciatore del carico per più protocolli.

gcloud

1. Crea un controllo di integrità HTTP per la porta 80. Questo controllo di integrità viene utilizzato per verificare l'integrità dei backend nel gruppo di istanze ig-a.

   gcloud compute health-checks create http hc-http-80 \
       --region=us-west1 \
       --port=80
   

2. Crea il servizio di backend con il protocollo impostato su UNSPECIFIED:

   gcloud compute backend-services create be-ilb-l3-default \
       --load-balancing-scheme=internal \
       --protocol=UNSPECIFIED \
       --region=us-west1 \
       --health-checks=hc-http-80 \
       --health-checks-region=us-west1
   

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

   gcloud compute backend-services add-backend be-ilb-l3-default \
       --region=us-west1 \
       --instance-group=ig-a \
       --instance-group-zone=us-west1-a
   

4. Per il traffico IPv6: crea una regola di forwarding con il protocollo impostato su L3_DEFAULT per gestire tutto il traffico del protocollo IPv6 supportato. Tutte le porte devono essere configurate con regole di forwarding L3_DEFAULT.

   gcloud compute forwarding-rules create fr-ilb-ipv6 \
      --region=us-west1 \
      --load-balancing-scheme=internal \
      --subnet=lb-subnet \
      --ip-protocol=L3_DEFAULT \
      --ports=ALL \
      --backend-service=be-ilb-l3-default \
      --backend-service-region=us-west1 \
      --ip-version=IPV6
   

5. Per il traffico IPv4: crea una regola di forwarding con il protocollo impostato suL3_DEFAULT per gestire tutto il traffico del protocollo IPv4 supportato. Tutte le porte devono essere configurate con regole di forwarding L3_DEFAULT. Utilizza 10.1.2.99 come indirizzo IP interno.

   gcloud compute forwarding-rules create fr-ilb-l3-default \
      --region=us-west1 \
      --load-balancing-scheme=internal \
      --network=lb-network \
      --subnet=lb-subnet \
      --address=10.1.2.99 \
      --ip-protocol=L3_DEFAULT \
      --ports=ALL \
      --backend-service=be-ilb-l3-default \
      --backend-service-region=us-west1
   

API

1. Crea il controllo di integrità inviando una richiesta POST al metodo regionHealthChecks.insert. Sostituisci PROJECT_ID con l'ID del tuo progettoGoogle Cloud .

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/regionHealthChecks
   
   {
   "name": "hc-http-80",
   "type": "HTTP",
   "httpHealthCheck": {
    "port": 80
   }
   }
   

2. Crea il servizio di backend regionale inviando una richiesta POST al metodo regionBackendServices.insert:

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices
   
   {
   "name": "be-ilb-l3-default",
   "backends": [
    {
      "group": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instanceGroups/ig-a",
      "balancingMode": "CONNECTION"
    }
   ],
   "healthChecks": [
    "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/healthChecks/hc-http-80"
   ],
   "loadBalancingScheme": "INTERNAL",
   "protocol": "UNSPECIFIED",
   "connectionDraining": {
    "drainingTimeoutSec": 0
   }
   }
   

3. Per il traffico IPv6: crea la regola di forwarding inviando una richiesta POST al metodo forwardingRules.insert.

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules
   
   {
   "name": "fr-ilb-ipv6",
   "IPProtocol": "L3_DEFAULT",
   "allPorts": true,
   "loadBalancingScheme": "INTERNAL",
   "subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
   "backendService": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices/be-ilb-l3-default",
   "ipVersion": "IPV6",
   "networkTier": "PREMIUM"
   }
   

4. Per il traffico IPv4: crea la regola di forwarding inviando una richiesta POST al metodo forwardingRules.insert:

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules
   
   {
   "name": "fr-ilb-l3-default",
   "IPAddress": "10.1.2.99",
   "IPProtocol": "L3_DEFAULT",
   "allPorts": true,
   "loadBalancingScheme": "INTERNAL",
   "subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
   "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
   "backendService": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices/be-ilb-l3-default",
   "networkTier": "PREMIUM"
   }
   

Testa il bilanciatore del carico

I seguenti test mostrano come convalidare la configurazione del bilanciatore del carico e scoprirne il comportamento previsto.

Testa la connessione dalla VM client

Questo test contatta il bilanciatore del carico da una VM client separata, ovvero non da una VM di backend del bilanciatore del carico.

gcloud:IPv6

1. Connettiti all'istanza VM client.

   gcloud compute ssh vm-client-ipv6 --zone=us-west1-a
   

2. Descrivi la regola di forwarding IPv6 fr-ilb-ipv6. Prendi nota del IPV6_ADDRESS nella descrizione.

   gcloud compute forwarding-rules describe fr-ilb-ipv6 --region=us-west1
   

3. Dai client con connettività IPv6, esegui il seguente comando. Sostituisci IPV6_ADDRESS con l'indirizzo IPv6 temporaneo nella fr-ilb-ipv6 regola di forwarding.

   curl -m 10 -s http://IPV6_ADDRESS:80
   

   Ad esempio, se l'indirizzo IPv6 assegnato è [fd20:1db0:b882:802:0:46:0:0/96]:80, il comando dovrebbe avere il seguente aspetto:

   curl -m 10 -s http://[fd20:1db0:b882:802:0:46:0:0]:80
   

gcloud:IPv4

1. Connettiti all'istanza VM client.

   gcloud compute ssh vm-client --zone=us-west1-a
   

2. Descrivi la regola di forwarding IPv4 fr-ilb.

   gcloud compute forwarding-rules describe fr-ilb --region=us-west1
   

3. Invia una richiesta web al bilanciatore del carico utilizzando curl per contattare il relativo indirizzo IP. Ripeti la richiesta per vedere che le risposte provengono da diverse VM di backend. Il nome della VM che genera la risposta viene visualizzato nel testo della risposta HTML in base ai contenuti di /var/www/html/index.html su ogni VM di backend. Le risposte previste sono simili a Page served from: vm-a1.

   curl http://10.1.2.99
   

   La regola di forwarding è configurata per gestire le porte 80 e 53. Per inviare il traffico a queste porte, aggiungi i due punti (:) e il numero di porta dopo l'indirizzo IP, come segue:

   curl http://10.1.2.99:80
   

Invia un ping all'indirizzo IP del bilanciatore del carico

Questo test dimostra un comportamento previsto: puoi inviare un ping all'indirizzo IP del bilanciatore del carico.

gcloud:IPv6

1. Connettiti all'istanza VM client.

   gcloud compute ssh vm-client-ipv6 --zone=us-west1-a
   

2. Prova a inviare un ping all'indirizzo IPv6 del bilanciatore del carico. Sostituisci IPV6_ADDRESS con l'indirizzo IPv6 temporaneo nella fr-ilb-ipv6 regola di forwarding.

   Noterai che ricevi una risposta e che il comando ping funziona in questo esempio.

   ping6 IPV6_ADDRESS
   

   Ad esempio, se l'indirizzo IPv6 assegnato è [2001:db8:1:1:1:1:1:1/96], il comando è il seguente:

   ping6 2001:db8:1:1:1:1:1:1
   

   L'output è simile al seguente:

   @vm-client: ping IPV6_ADDRESS
   PING IPV6_ADDRESS (IPV6_ADDRESS) 56(84) bytes of data.
   64 bytes from IPV6_ADDRESS: icmp_seq=1 ttl=64 time=1.58 ms
   

gcloud:IPv4

1. Connettiti all'istanza VM client.

   gcloud compute ssh vm-client --zone=us-west1-a
   

2. Prova a inviare un ping all'indirizzo IPv4 del bilanciatore del carico. Noterai che ricevi una risposta e che il comando ping funziona in questo esempio.

   ping 10.1.2.99
   

   L'output è il seguente:

   @vm-client: ping 10.1.2.99
   PING 10.1.2.99 (10.1.2.99) 56(84) bytes of data.
   64 bytes from 10.1.2.99: icmp_seq=1 ttl=64 time=1.58 ms
   64 bytes from 10.1.2.99: icmp_seq=2 ttl=64 time=0.242 ms
   64 bytes from 10.1.2.99: icmp_seq=3 ttl=64 time=0.295 ms
   

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 eseguire queste operazioni in qualsiasi ordine.

Puoi prenotare un indirizzo IP interno statico per il tuo esempio. Questa configurazione consente a più regole di inoltro interne di utilizzare lo stesso indirizzo IP con protocolli e porte diversi. I backend del bilanciatore del carico di esempio devono trovarsi ancora nella regioneus-west1.

Il seguente diagramma mostra l'architettura di questo esempio.

Un bilanciatore del carico di rete passthrough interno per più protocolli che utilizza un indirizzo IP interno statico (fai clic per ingrandire).

Puoi anche prendere in considerazione le seguenti configurazioni regola di forwarding:

• Regole di inoltro con più porte:

  • Protocollo TCP con porte 80,8080
  • Protocollo L3_DEFAULT con porte ALL

• Regole di inoltro con tutte le porte:

  • Protocollo TCP con porte ALL
  • Protocollo L3_DEFAULT con porte ALL

Prenota indirizzo IPv4 interno statico

Prenota un indirizzo IP interno statico per 10.1.2.99 e imposta il relativo --purpose flag su SHARED_LOADBALANCER_VIP. Il flag --purpose è obbligatorio affinché molte regole di inoltro possano utilizzare lo stesso indirizzo IP interno.

gcloud

Utilizza il comando gcloud compute addresses create:

gcloud compute addresses create internal-lb-ipv4 \
    --region us-west1 \
    --subnet lb-subnet \
    --purpose SHARED_LOADBALANCER_VIP \
    --addresses 10.1.2.99

API

Chiama il metodo addresses.insert. Sostituisci PROJECT_ID con l'ID del tuo progettoGoogle Cloud .

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/addresses

Il corpo della richiesta deve includere il addressType, che deve essere INTERNAL, il name dell'indirizzo e il subnetwork a cui appartiene l'indirizzo IP. Devi specificare address come 10.1.2.99.

{
  "addressType": "INTERNAL",
  "name": "internal-lb-ipv4",
  "subnetwork": "regions/us-west1/subnetworks/lb-subnet",
  "purpose": "SHARED_LOADBALANCER_VIP",
  "address": "10.1.2.99"
}

Configura i componenti del bilanciatore del carico

Configura tre bilanciatori del carico con i seguenti componenti:

• Il primo bilanciatore del carico ha una regola di forwarding con protocollo TCP e porta 80. Il traffico TCP che arriva all'indirizzo IP interno sulla porta 80 viene gestito dalla regola di forwarding TCP.
• Il secondo bilanciatore del carico ha una regola di forwarding con protocollo UDP e porta 53. Il traffico UDP che arriva all'indirizzo IP interno sulla porta 53 viene gestito dalla regola di forwarding UDP.
• Il terzo bilanciatore del carico ha una regola di forwarding con protocollo L3_DEFAULT e porta ALL. Tutto il resto del traffico che non corrisponde alle regole di inoltro TCP o UDP viene gestito dalla regola di forwarding L3_DEFAULT.
• Tutti e tre i bilanciatori del carico condividono lo stesso indirizzo IP interno statico (internal-lb-ipv4) nelle regole di inoltro.

Crea il primo bilanciatore del carico

Crea il primo bilanciatore del carico per il traffico TCP sulla porta 80.

gcloud

1. Crea il servizio di backend per il traffico TCP:

   gcloud compute backend-services create be-ilb \
       --load-balancing-scheme=internal \
       --protocol=tcp \
       --region=us-west1 \
       --health-checks=hc-http-80 \
       --health-checks-region=us-west1
   

2. Aggiungi il gruppo di istanze al servizio di backend:

   gcloud compute backend-services add-backend be-ilb \
       --region=us-west1 \
       --instance-group=ig-a \
       --instance-group-zone=us-west1-a
   

3. Crea una regola di forwarding per il servizio di backend. Utilizza l'indirizzo IP interno statico riservato (internal-lb-ipv4) per l'indirizzo IP interno.

   gcloud compute forwarding-rules create fr-ilb \
       --region=us-west1 \
       --load-balancing-scheme=internal \
       --network=lb-network \
       --subnet=lb-subnet \
       --address=internal-lb-ipv4 \
       --ip-protocol=TCP \
       --ports=80 \
       --backend-service=be-ilb \
       --backend-service-region=us-west1
   

API

1. Crea il servizio di backend regionale inviando una richiesta POST al metodo regionBackendServices.insert. Sostituisci PROJECT_ID con l'ID del tuo progettoGoogle Cloud .

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices
   {
   "name": "be-ilb",
   "backends": [
    {
      "group": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instanceGroups/ig-a",
      "balancingMode": "CONNECTION"
    }
   ],
   "healthChecks": [
    "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/healthChecks/hc-http-80"
   ],
   "loadBalancingScheme": "INTERNAL",
   "protocol": "TCP",
   "connectionDraining": {
    "drainingTimeoutSec": 0
   }
   }
   

2. Create the forwarding rule by making a POST request to the forwardingRules.insert method:

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules
   
   {
   "name": "fr-ilb",
   "IPAddress": "internal-lb-ipv4",
   "IPProtocol": "TCP",
   "ports": [
    "80"
   ],
   "loadBalancingScheme": "INTERNAL",
   "subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
   "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
   "backendService": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices/be-ilb",
   "networkTier": "PREMIUM"
   }
   

Crea il secondo bilanciatore del carico

Crea il secondo bilanciatore del carico per il traffico UDP sulla porta 53.

gcloud

1. Crea il servizio di backend con il protocollo impostato su UDP:

   gcloud compute backend-services create be-ilb-udp \
       --load-balancing-scheme=internal \
       --protocol=UDP \
       --region=us-west1 \
       --health-checks=hc-http-80 \
       --health-checks-region=us-west1
   

2. Aggiungi il gruppo di istanze al servizio di backend:

   gcloud compute backend-services add-backend be-ilb-udp \
       --region=us-west1 \
       --instance-group=ig-a \
       --instance-group-zone=us-west1-a
   

3. Crea una regola di forwarding per il servizio di backend. Utilizza l'indirizzo IP interno statico riservato (internal-lb-ipv4) per l'indirizzo IP interno.

   gcloud compute forwarding-rules create fr-ilb-udp \
       --region=us-west1 \
       --load-balancing-scheme=internal \
       --network=lb-network \
       --subnet=lb-subnet \
       --address=internal-lb-ipv4 \
       --ip-protocol=UDP \
       --ports=53 \
       --backend-service=be-ilb-udp \
       --backend-service-region=us-west1
   

API

1. Crea il servizio di backend regionale inviando una richiesta POST al metodo regionBackendServices.insert. Sostituisci PROJECT_ID con l'ID del tuo progettoGoogle Cloud .

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices
   {
   "name": "be-ilb-udp",
   "backends": [
    {
     "group": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instanceGroups/ig-a",
     "balancingMode": "CONNECTION"
    }
   ],
   "healthChecks": [
    "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/healthChecks/hc-http-80"
   ],
   "loadBalancingScheme": "INTERNAL",
   "protocol": "UDP",
   "connectionDraining": {
    "drainingTimeoutSec": 0
   }
   }
   

2. Crea la regola di forwarding inviando una richiesta POST al metodo forwardingRules.insert:

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules
   
   {
   "name": "fr-ilb-udp",
   "IPAddress": "internal-lb-ipv4",
   "IPProtocol": "UDP",
   "ports": [
    "53"
   ],
   "loadBalancingScheme": "INTERNAL",
   "subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
   "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
   "backendService": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices/be-ilb-udp",
   "networkTier": "PREMIUM"
   }
   

Crea il terzo bilanciatore del carico

Crea la regola di forwarding del terzo bilanciatore del carico in modo che utilizzi l'indirizzo IP interno statico riservato.

gcloud

Crea la regola di forwarding con il protocollo impostato su L3_DEFAULT per gestire tutto l'altro traffico del protocollo IPv4 supportato. Utilizza l'indirizzo IP interno statico riservato (internal-lb-ipv4) come indirizzo IP interno.

gcloud compute forwarding-rules create fr-ilb-l3-default \
    --region=us-west1 \
    --load-balancing-scheme=internal \
    --network=lb-network \
    --subnet=lb-subnet \
    --address=internal-lb-ipv4 \
    --ip-protocol=L3_DEFAULT \
    --ports=ALL \
    --backend-service=be-ilb-l3-default \
    --backend-service-region=us-west1

API

Crea la regola di forwarding inviando una richiesta POST al metodo forwardingRules.insert. Sostituisci PROJECT_ID con l'ID del tuo progettoGoogle Cloud .

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules

{
"name": "fr-ilb-l3-default",
"IPAddress": "internal-lb-ipv4",
"IPProtocol": "L3_DEFAULT",
"ports": [
  "ALL"
],
"loadBalancingScheme": "INTERNAL",
"subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
"network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
"backendService": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices/be-ilb-l3-default",
"networkTier": "PREMIUM"
}

Testa il bilanciatore del carico

Per testare il bilanciatore del carico, segui i passaggi descritti nella sezione precedente.

Passaggi successivi

• Per informazioni sui concetti importanti, consulta la panoramica del bilanciatore del carico di rete passthrough interno.
• Per scoprire come configurare il failover, consulta Configura il failover per il bilanciatore del carico di rete passthrough interno.
• Per informazioni sulla configurazione del logging e del monitoraggio per i bilanciatori del carico di rete passthrough interni, consulta Logging e monitoraggio dei bilanciatori del carico di rete passthrough interni.
• Per scoprire di più sulla risoluzione dei problemi, consulta Risolvere i problemi relativi ai bilanciatori del carico di rete passthrough interni.
• Pulisci la configurazione di un bilanciatore del carico.