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

Questa guida utilizza un esempio per insegnare i concetti di base dei Google Cloud bilanciatori del carico di rete passthrough interni. Prima di seguire questa guida, acquisisci familiarità con quanto segue:

• Concetti relativi al bilanciatore del carico di rete passthrough interno
• Come funzionano i bilanciatori del carico di rete passthrough interni
• Panoramica delle regole firewall
• Concetti sul controllo di integrità

---

Per seguire le indicazioni dettagliate per questa attività direttamente nella Google Cloud console, fai clic su Procedura guidata:

Procedura guidata

---

Autorizzazioni

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

Attività	Ruolo richiesto
Crea reti, subnet e componenti del bilanciatore del carico	Compute Network Admin (roles/compute.networkAdmin)
Aggiungere e rimuovere regole firewall	Amministratore della sicurezza di Compute (roles/compute.securityAdmin)
Creazione delle istanze	Compute Instance Admin (roles/compute.instanceAdmin)

Per ulteriori informazioni, consulta le seguenti guide:

• Controllo dell'accesso
• Condizioni IAM

Configura il bilanciatore del carico con subnet e backend solo IPv4

Questa guida mostra come configurare e testare un bilanciatore del carico di rete passthrough interno. I passaggi di questa sezione descrivono come configurare quanto segue:

1. Un esempio che utilizza una rete VPC in modalità personalizzata denominata lb-network.
2. 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.
3. Regole firewall che consentono le connessioni in entrata alle istanze di macchine virtuali (VM) di backend.
4. Il gruppo di istanza di backend, che si trova nella seguente regione e subnet per questo esempio:
   • Regione: us-west1
   • Subnet: lb-subnet, con intervallo di indirizzi IPv4 principali 10.1.2.0/24.
5. Quattro VM di backend: due VM in un gruppo di istanze non gestite nella zona us-west1-a e due VM in un gruppo di istanze non gestite nella zona us-west1-c. Per dimostrare l'accesso globale, questo esempio crea una seconda VM client di test in una regione e una subnet diverse:
   • Regione: europe-west1
   • Subnet: europe-subnet, con intervallo di indirizzi IP principali 10.3.4.0/24
6. Una VM client per testare le connessioni.
7. I seguenti componenti del bilanciatore del carico di rete passthrough interno:
   • Un controllo di integrità per il servizio di backend.
   • Un servizio di backend interno nella regione us-west1 per gestire la distribuzione delle connessioni ai due gruppi di istanze a livello di zona.
   • Una regola di forwarding interna e un indirizzo IP interno per il frontend del bilanciatore del carico.

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

L'architettura per questo esempio ha questo aspetto:

Esempio di configurazione del bilanciatore del carico di rete passthrough interno (fai clic per ingrandire).

Nota: per semplicità, questo esempio utilizza gruppi di istanze non gestite. In produzione, valuta la possibilità di utilizzare un gruppo di istanze gestite, come illustrato in Gruppi di istanze gestite.

Configura una rete, una regione e una subnet

Per creare la rete e la subnet di esempio, segui questi passaggi.

Console

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

   Vai a Reti VPC

2. Fai clic su Crea rete VPC.

3. In Nome, inserisci lb-network.

4. Nella sezione Subnet, segui questi passaggi:

   1. Imposta Modalità di creazione subnet su Personalizzata.
   2. 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
   3. Fai clic su Fine.
   4. Fai clic su Aggiungi subnet e inserisci le seguenti informazioni:
      • Nome: europe-subnet
      • Regione: europe-west1
      • Tipo di stack IP: IPv4 (stack singolo)
      • Intervallo di indirizzi IP: 10.3.4.0/24
   5. Fai clic su Fine.

5. Fai clic su Crea.

gcloud

1. Crea la rete VPC personalizzata:

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

2. Nella rete lb-network, crea una subnet per i backend nella regione us-west1:

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

3. Nella rete lb-network, crea un'altra subnet per testare l'accesso globale nella regione europe-west1:

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

API

Invia una richiesta POST al metodo networks.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks

{
 "routingConfig": {
   "routingMode": "REGIONAL"
 },
 "name": "lb-network",
 "autoCreateSubnetworks": false
}

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
}

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/europe-west1/subnetworks

{
 "name": "europe-subnet",
 "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
  "ipCidrRange": "10.3.4.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 tutte le destinazioni nella rete VPC, che consente il traffico dalle origini negli intervalli 10.1.2.0/24 e 10.3.4.0/24. Questa regola consente il traffico in entrata da qualsiasi client che si trova in una delle due subnet. In un secondo momento ti consente di configurare e testare l'accesso globale.

• fw-allow-ssh: una regola in entrata, applicabile alle istanze con bilanciamento del carico, che consente la connettività SSH in entrata sulla porta TCP 22 da qualsiasi indirizzo. Puoi scegliere un intervallo IP di origine più restrittivo per questa regola. Ad esempio, puoi specificare solo gli intervalli IP del sistema da cui inizierai 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 in entrata, applicabile alle istanze con bilanciamento del carico, che consente il traffico proveniente dai sistemi di controllo di integrità Google Cloud (130.211.0.0/22 e 35.191.0.0/16). Questo esempio utilizza il tag di destinazione allow-health-check per identificare le istanze a cui deve essere applicata.

Senza queste regole firewall, la regola default-deny per il traffico in entrata blocca il traffico in ingresso 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, vedi Intervalli IP probe.

Console

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

   Vai a Criteri firewall

2. Per consentire il traffico nella subnet, fai clic su Crea regola firewall e inserisci le seguenti informazioni:

   • 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: Consenti tutto

3. Fai clic su Crea.

4. Per consentire le connessioni SSH in entrata, fai di nuovo clic su Crea regola firewall e inserisci le seguenti informazioni:

   • 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: seleziona Protocolli e porte specificati, seleziona la casella di controllo TCP e poi inserisci 22 in Porte.

5. Fai clic su Crea.

6. Per consentire i controlli di integrità Google Cloud , fai clic su Crea regola firewall una terza volta e inserisci le seguenti informazioni:

   • 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

7. Fai clic su Crea.

gcloud

1. Crea la regola firewall fw-allow-lb-access per consentire la comunicazione dall'interno della subnet:

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

2. Crea la regola firewall fw-allow-ssh per consentire la connettività SSH alle VM con il tag di rete allow-ssh. Se ometti source-ranges, Google Cloud interpreta la regola 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. Crea la regola fw-allow-health-check per consentire i controlli di integrità 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
   

API

Crea la regola firewall fw-allow-lb-access 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",
 "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
 "priority": 1000,
 "sourceRanges": [
   "10.1.2.0/24", "10.3.4.0/24"
 ],
 "allowed": [
   {
     "IPProtocol": "tcp"
   },
   {
     "IPProtocol": "udp"
   },
   {
     "IPProtocol": "icmp"
   }
 ],
 "direction": "INGRESS",
 "logConfig": {
   "enable": false
 },
 "disabled": false
}

Crea la regola firewall fw-allow-ssh inviando 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
}

Crea la regola firewall fw-allow-health-check 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",
 "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
}

Crea VM di backend e gruppi di istanze

Questo esempio utilizza due gruppi di istanze non gestite, ciascuno con due VM di backend (server). Per dimostrare la natura regionale dei bilanciatori del carico di rete passthrough interni, i due gruppi di istanze vengono posizionati in zone separate, us-west1-a e us-west1-c.

• Il gruppo di istanze ig-a contiene queste due VM:
  • vm-a1
  • vm-a2
• Il gruppo di istanze ig-c contiene queste due VM:
  • vm-c1
  • vm-c2

Il traffico verso tutte e quattro le VM di backend è bilanciato.

Per supportare questo esempio e le opzioni di configurazione aggiuntive, ognuna delle quattro VM esegue un server web Apache che rimane in ascolto sulle seguenti porte TCP: 80, 8008, 8080, 8088, 443 e 8443.

A ogni VM viene assegnato un indirizzo IP interno in lb-subnet e un indirizzo IP esterno (pubblico) temporaneo. Puoi rimuovere gli indirizzi IP esterni in un secondo momento.

L'indirizzo IP esterno per le VM di backend non è obbligatorio, ma è utile per questo esempio perché consente alle VM di backend di scaricare Apache da internet e di connettersi tramite SSH.

Per impostazione predefinita, Apache è configurato per il binding a qualsiasi indirizzo IP. I bilanciatori del carico di rete passthrough interni distribuiscono i pacchetti mantenendo l'IP di destinazione. Assicurati che il software del server in esecuzione sulle VM di backend sia in ascolto sull'indirizzo IP della regola di forwarding interno del bilanciatore del carico. Se configuri più regole di forwarding interno, assicurati che il software sia in ascolto dell'indirizzo IP interno associato a ciascuna. L'indirizzo IP di destinazione di un pacchetto recapitato a una VM di backend da un bilanciatore del carico di rete passthrough interno è l'indirizzo IP interno della regola di forwarding.

Per semplicità didattica, queste VM di backend eseguono Debian GNU/Linux 12.

Console

Crea VM di backend

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

   Vai a Istanze VM

2. Ripeti i passaggi da 3 a 8 per ogni VM, utilizzando le seguenti combinazioni di nome e zona.

   • Nome: vm-a1, zona: us-west1-a
   • Nome: vm-a2, zona: us-west1-a
   • Nome: vm-c1, zona: us-west1-c
   • Nome: vm-c2, zona: us-west1-c

3. Fai clic su Crea istanza.

4. Imposta il Nome come indicato nel passaggio 2.

5. Per Regione, seleziona us-west1 e scegli una Zona come indicato nel passaggio 2.

6. Nella sezione Disco di avvio, assicurati che per le opzioni del disco di avvio sia selezionata l'opzione Debian GNU/Linux 12 (bookworm). Se necessario, fai clic su Cambia per modificare l'immagine.

7. Fai clic su Opzioni avanzate.

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

   1. In Tag di rete, inserisci allow-ssh e allow-health-check.
   2. In Interfacce di rete, seleziona quanto segue:
      • Rete: lb-network
      • Subnet: lb-subnet
      • Tipo di stack IP: IPv4 (stack singolo)
      • Indirizzo IPv4 interno principale: Temporaneo (automatico)
      • Indirizzo IPv4 esterno: Temporaneo

9. Fai clic su Gestione e poi inserisci il seguente script nel campo Script di avvio. I contenuti dello script sono identici per tutte e quattro le VM.

   
   #! /bin/bash
   if [ -f /etc/startup_script_completed ]; then
   exit 0
   fi
   apt-get update
   apt-get install apache2 -y
   a2ensite default-ssl
   a2enmod ssl
   file_ports="/etc/apache2/ports.conf"
   file_http_site="/etc/apache2/sites-available/000-default.conf"
   file_https_site="/etc/apache2/sites-available/default-ssl.conf"
   http_listen_prts="Listen 80\nListen 8008\nListen 8080\nListen 8088"
   http_vh_prts="*:80 *:8008 *:8080 *:8088"
   https_listen_prts="Listen 443\nListen 8443"
   https_vh_prts="*:443 *:8443"
   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
   prt_conf="$(cat "$file_ports")"
   prt_conf_2="$(echo "$prt_conf" | sed "s|Listen 80|${http_listen_prts}|")"
   prt_conf="$(echo "$prt_conf_2" | sed "s|Listen 443|${https_listen_prts}|")"
   echo "$prt_conf" | tee "$file_ports"
   http_site_conf="$(cat "$file_http_site")"
   http_site_conf_2="$(echo "$http_site_conf" | sed "s|*:80|${http_vh_prts}|")"
   echo "$http_site_conf_2" | tee "$file_http_site"
   https_site_conf="$(cat "$file_https_site")"
   https_site_conf_2="$(echo "$https_site_conf" | sed "s|_default_:443|${https_vh_prts}|")"
   echo "$https_site_conf_2" | tee "$file_https_site"
   systemctl restart apache2
   touch /etc/startup_script_completed
   

10. Fai clic su Crea.

Crea gruppi di istanze

1. Nella console Google Cloud , vai alla pagina Gruppi di istanze.

   Vai a Gruppi di istanze

2. Ripeti i seguenti passaggi per creare due gruppi di istanze non gestite, ciascuno con due VM, utilizzando queste combinazioni.

   • Nome del gruppo di istanze: ig-a, zona: us-west1-a, VM: vm-a1 e vm-a2
   • Nome del gruppo di istanze: ig-c, zona: us-west1-c, VM: vm-c1 e vm-c2

3. Fai clic su Crea gruppo di istanze.

4. Fai clic su Nuovo gruppo di istanze non gestito.

5. Imposta Nome come indicato nel passaggio 2.

6. Nella sezione Località, seleziona us-west1 per Regione, quindi scegli una Zona come indicato nel passaggio 2.

7. In Rete, seleziona lb-network.

8. In Subnet, seleziona lb-subnet.

9. Nella sezione Istanze VM, aggiungi le VM come indicato nel passaggio 2.

10. Fai clic su Crea.

gcloud

1. Crea le quattro VM eseguendo il seguente comando quattro volte, utilizzando queste quattro combinazioni per [VM-NAME] e [ZONE]. I contenuti dello script sono identici per tutte e quattro le VM.

   • VM-NAME: vm-a1, ZONE: us-west1-a
   • VM-NAME: vm-a2, ZONE: us-west1-a
   • VM-NAME: vm-c1, ZONE: us-west1-c
   • VM-NAME: vm-c2, ZONE: us-west1-c

   gcloud compute instances create VM-NAME \
       --zone=ZONE \
       --image-family=debian-12 \
       --image-project=debian-cloud \
       --tags=allow-ssh,allow-health-check \
       --subnet=lb-subnet \
       --metadata=startup-script='#! /bin/bash
   if [ -f /etc/startup_script_completed ]; then
   exit 0
   fi
   apt-get update
   apt-get install apache2 -y
   a2ensite default-ssl
   a2enmod ssl
   file_ports="/etc/apache2/ports.conf"
   file_http_site="/etc/apache2/sites-available/000-default.conf"
   file_https_site="/etc/apache2/sites-available/default-ssl.conf"
   http_listen_prts="Listen 80\nListen 8008\nListen 8080\nListen 8088"
   http_vh_prts="*:80 *:8008 *:8080 *:8088"
   https_listen_prts="Listen 443\nListen 8443"
   https_vh_prts="*:443 *:8443"
   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
   prt_conf="$(cat "$file_ports")"
   prt_conf_2="$(echo "$prt_conf" | sed "s|Listen 80|${http_listen_prts}|")"
   prt_conf="$(echo "$prt_conf_2" | sed "s|Listen 443|${https_listen_prts}|")"
   echo "$prt_conf" | tee "$file_ports"
   http_site_conf="$(cat "$file_http_site")"
   http_site_conf_2="$(echo "$http_site_conf" | sed "s|*:80|${http_vh_prts}|")"
   echo "$http_site_conf_2" | tee "$file_http_site"
   https_site_conf="$(cat "$file_https_site")"
   https_site_conf_2="$(echo "$https_site_conf" | sed "s|_default_:443|${https_vh_prts}|")"
   echo "$https_site_conf_2" | tee "$file_https_site"
   systemctl restart apache2
   touch /etc/startup_script_completed'
   

2. Crea i due gruppi di istanze non gestite in ogni zona:

   gcloud compute instance-groups unmanaged create ig-a \
       --zone=us-west1-a
   gcloud compute instance-groups unmanaged create ig-c \
       --zone=us-west1-c
   

3. Aggiungi le VM ai gruppi di istanze appropriati:

   gcloud compute instance-groups unmanaged add-instances ig-a \
       --zone=us-west1-a \
       --instances=vm-a1,vm-a2
   gcloud compute instance-groups unmanaged add-instances ig-c \
       --zone=us-west1-c \
       --instances=vm-c1,vm-c2
   

API

Per le quattro VM, utilizza i seguenti nomi e zone:

• VM-NAME: vm-a1, ZONE: us-west1-a
• VM-NAME: vm-a2, ZONE: us-west1-a
• VM-NAME: vm-c1, ZONE: us-west1-c
• VM-NAME: vm-c2, ZONE: us-west1-c

Puoi ottenere l'DEBIAN_IMAGE_NAME corrente eseguendo il seguente comando gcloud:

gcloud compute images list \
 --filter="family=debian-12"

Crea quattro VM di backend effettuando quattro richieste POST al metodo instances.insert:

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances

{
 "name": "VM-NAME",
 "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": [
   {
     "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-NAME",
     "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\nfile_ports=\"/etc/apache2/ports.conf\"\nfile_http_site=\"/etc/apache2/sites-available/000-default.conf\"\nfile_https_site=\"/etc/apache2/sites-available/default-ssl.conf\"\nhttp_listen_prts=\"Listen 80\\nListen 8008\\nListen 8080\\nListen 8088\"\nhttp_vh_prts=\"*:80 *:8008 *:8080 *:8088\"\nhttps_listen_prts=\"Listen 443\\nListen 8443\"\nhttps_vh_prts=\"*:443 *:8443\"\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\nprt_conf=\"$(cat \"$file_ports\")\"\nprt_conf_2=\"$(echo \"$prt_conf\" | sed \"s|Listen 80|${http_listen_prts}|\")\"\nprt_conf=\"$(echo \"$prt_conf_2\" | sed \"s|Listen 443|${https_listen_prts}|\")\"\necho \"$prt_conf\" | tee \"$file_ports\"\nhttp_site_conf=\"$(cat \"$file_http_site\")\"\nhttp_site_conf_2=\"$(echo \"$http_site_conf\" | sed \"s|*:80|${http_vh_prts}|\")\"\necho \"$http_site_conf_2\" | tee \"$file_http_site\"\nhttps_site_conf=\"$(cat \"$file_https_site\")\"\nhttps_site_conf_2=\"$(echo \"$https_site_conf\" | sed \"s|_default_:443|${https_vh_prts}|\")\"\necho \"$https_site_conf_2\" | tee \"$file_https_site\"\nsystemctl restart apache2"
     }
   ]
 },
 "scheduling": {
   "preemptible": false
 },
 "deletionProtection": false
}

Crea due gruppi 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"
}

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-c/instanceGroups

{
 "name": "ig-c",
 "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"
}

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",
     "instance": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instances/vm-a2"
   }
 ]
}

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-c/instanceGroups/ig-c/addInstances

{
 "instances": [
   {
     "instance": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-c/instances/vm-c1",
     "instance": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-c/instances/vm-c2"
   }
 ]
}

Configura i componenti del bilanciatore del carico

Questi passaggi configurano tutti i componenti del bilanciatore del carico di rete passthrough interno, a partire dal controllo di integrità e dal servizio di backend fino ai componenti frontend:

• Controllo di integrità: in questo esempio, utilizzi un controllo di integrità HTTP che controlla una risposta HTTP 200 (OK). Per saperne di più, consulta la sezione sui controlli di integrità della panoramica del bilanciatore del carico di rete passthrough interno.

• Servizio di backend: poiché devi trasmettere il traffico HTTP attraverso il bilanciatore del carico interno, devi utilizzare TCP, anziché UDP.

• Regola di forwarding: questo esempio crea una singola regola di forwarding interno.

• Indirizzo IP interno: in questo esempio, specifichi un indirizzo IP interno, 10.1.2.99, quando crei la regola di forwarding.

Console

Avvia la configurazione

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

   Vai a Bilanciamento del carico

2. Fai clic su Crea bilanciatore del carico.
3. In Tipo di bilanciatore del carico, seleziona Bilanciatore del carico di rete (TCP/UDP/SSL) e fai clic su Avanti.
4. Per Proxy o passthrough, seleziona Bilanciatore del carico passthrough e fai clic su Avanti.
5. In Pubblico o interno, seleziona Interno e fai clic su Avanti.
6. Fai clic su Configura.

Configurazione di base

Nella pagina Crea bilanciatore del carico di rete passthrough interno, inserisci le seguenti informazioni:

• Nome bilanciatore del carico: be-ilb
• Regione: us-west1
• Rete: lb-network

Configura i backend

1. Fai clic su Configurazione backend.
2. Per gestire solo il traffico IPv4, nella sezione Nuovo backend di Backend, seleziona Tipo di stack IP come IPv4 (stack singolo).
3. In Gruppo di istanze, seleziona il gruppo di istanze ig-c e fai clic su Fine.
4. Fai clic su Aggiungi un backend e ripeti il passaggio per aggiungere ig-a.

5. Nell'elenco Controllo di integrità, seleziona Crea un controllo di integrità, inserisci le seguenti informazioni e fai clic su Salva.

   • Nome: hc-http-80
   • Protocollo:HTTP
   • Porta:80
   • Protocollo proxy: NONE
   • Percorso richiesta: /

   Tieni presente che quando utilizzi la console Google Cloud per creare il bilanciatore del carico, il controllo di integrità è globale. Se vuoi creare un controllo di integrità regionale, utilizza gcloud o l'API.

6. Verifica che sia presente un segno di spunta blu accanto a Configurazione backend prima di continuare.

Configura il frontend

1. Fai clic su Configurazione frontend.
2. Nella sezione Nuovi IP e porta frontend, segui questi passaggi:
   1. In Nome, inserisci fr-ilb.
   2. In Subnet, seleziona lb-subnet.
   3. Nella sezione Scopo IP interno, nell'elenco Indirizzo IP, seleziona Crea indirizzo IP, inserisci le seguenti informazioni e fai clic su Prenota.
      • Nome: ip-ilb
      • Versione IP:IPv4
      • Indirizzo IP statico:Scelta manuale
      • Indirizzo IP personalizzato: 10.1.2.99
   4. In Porte, seleziona Multiple e poi in Numeri di porta inserisci 80,8008,8080 e 8088.
   5. Verifica che sia presente un segno di spunta blu accanto a Configurazione frontend prima di continuare.

Rivedi la configurazione

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

gcloud

1. Crea un nuovo controllo di integrità HTTP regionale per testare la connettività HTTP alle VM sulla porta 80.

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

2. Crea il servizio di backend per il traffico HTTP:

   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
   

3. Aggiungi i due gruppi 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
   gcloud compute backend-services add-backend be-ilb \
       --region=us-west1 \
       --instance-group=ig-c \
       --instance-group-zone=us-west1-c
   

4. Crea una regola di forwarding per il servizio di backend. Quando crei la regola di forwarding, specifica 10.1.2.99 per l'indirizzo IP interno nella subnet.

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

API

Crea il controllo di integrità inviando una richiesta POST al metodo regionHealthChecks.insert.

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

{
"name": "hc-http-80",
"type": "HTTP",
"httpHealthCheck": {
  "port": 80
}
}

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",
"backends": [
  {
    "group": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instanceGroups/ig-a",
    "balancingMode": "CONNECTION"
  },
  {
    "group": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-c/instanceGroups/ig-c",
    "balancingMode": "CONNECTION"
  }
],
"healthChecks": [
  "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/healthChecks/hc-http-80"
],
"loadBalancingScheme": "INTERNAL",
"connectionDraining": {
  "drainingTimeoutSec": 0
 }
}

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",
"IPAddress": "10.1.2.99",
"IPProtocol": "TCP",
"ports": [
  "80", "8008", "8080", "8088"
],
"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"
}

Testa il bilanciatore del carico

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

Crea una VM client

Questo esempio crea una VM client (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.

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 Regione, seleziona us-west1.

5. In Zona, seleziona us-west1-a.

6. Fai clic su Opzioni avanzate.

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

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

8. Fai clic su Crea.

gcloud

La VM client può trovarsi in qualsiasi zona della stessa regione del bilanciatore del carico e può utilizzare qualsiasi subnet di quella regione. In questo esempio, il client si trova nella zona us-west1-a e utilizza la stessa subnet 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.

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
}

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. Il comportamento previsto implica che il traffico venga distribuito tra le quattro VM di backend perché non è stata configurata alcuna affinità sessione.

1. Connettiti all'istanza VM client.

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

2. 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 virtù dei contenuti di /var/www/html/index.html su ogni VM di backend. Ad esempio, le risposte previste sono simili a Page served from: vm-a1 e Page served from: vm-a2.

   curl http://10.1.2.99
   

   La regola di forwarding è configurata per gestire le porte 80, 8008, 8080 e 8088. Per inviare il traffico a queste altre porte, aggiungi i due punti (:) e il numero di porta dopo l'indirizzo IP, in questo modo:

   curl http://10.1.2.99:8008
   

   Se aggiungi un'etichetta di servizio alla regola di forwarding interno, puoi utilizzare il DNS interno per contattare il bilanciatore del carico utilizzando il nome del servizio.

     curl http://web-test.fr-ilb.il4.us-west1.lb.PROJECT_ID.internal
     

Invia un ping all'indirizzo IP del bilanciatore del carico

Questo test dimostra un comportamento previsto: non è possibile inviare un ping all'indirizzo IP del bilanciatore del carico. Questo perché i bilanciatori del carico di rete passthrough interni vengono implementati nella programmazione di rete virtuale e non sono dispositivi separati.

1. Connettiti all'istanza VM client.

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

2. Prova a inviare un ping all'indirizzo IP del bilanciatore del carico. Noterai che non ricevi una risposta e che il comando ping scade dopo 10 secondi in questo esempio.

   timeout 10 ping 10.1.2.99
   

Inviare richieste da VM con bilanciamento del carico

Questo test dimostra che quando una VM di backend invia pacchetti all'indirizzo IP della regola di forwarding del bilanciatore del carico, queste richieste vengono reindirizzate alla VM stessa. Ciò vale indipendentemente dallo stato del controllo di integrità della VM di backend.

I bilanciatori del carico di rete passthrough interni vengono implementati utilizzando la programmazione delle reti virtuali e la configurazione delle VM nel sistema operativo guest. Sulle VM Linux, l'ambiente guest crea una route per l'indirizzo IP del bilanciatore del carico nella tabella di routing locale del sistema operativo.

Poiché questa route locale si trova all'interno della VM stessa (non è una route nella rete VPC), i pacchetti inviati all'indirizzo IP del bilanciatore del carico non vengono elaborati dalla rete VPC. I pacchetti inviati all'indirizzo IP del bilanciatore del carico rimangono all'interno del sistema operativo della VM.

1. Connettiti a una VM di backend, ad esempio vm-a1:

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

   Importante: non potrai connetterti a una VM di backend in questo modo se hai rimosso il suo indirizzo IP esterno. Per le opzioni di connessione se le VM di backend non hanno indirizzi IP esterni, consulta Scegliere un'opzione di connessione per le VM solo interne.

2. Invia una richiesta web al bilanciatore del carico (per indirizzo IP o nome del servizio) utilizzando curl. La risposta proviene dalla stessa VM di backend che effettua la richiesta. Le richieste ripetute ricevono la stessa risposta. La risposta prevista durante il test da vm-a1 è sempre Page served from: vm-a1.

   curl http://10.1.2.99
   

3. Ispeziona la tabella di routing locale, cercando una destinazione che corrisponda all'indirizzo IP del bilanciatore del carico stesso, 10.1.2.99. Questa route è una parte necessaria di un bilanciatore del carico di rete passthrough interno, ma dimostra anche perché una richiesta da una VM dietro il bilanciatore del carico riceve sempre una risposta dalla stessa VM.

   ip route show table local | grep 10.1.2.99
   

Quando una VM di backend per un bilanciatore del carico di rete passthrough interno invia pacchetti all'indirizzo IP della regola di forwarding del bilanciatore del carico, i pacchetti vengono sempre reindirizzati alla VM che effettua la richiesta. Questo perché un bilanciatore del carico di rete passthrough interno è un bilanciatore del carico passthrough e viene implementato creando una route locale per l'indirizzo IP del bilanciatore del carico all'interno del sistema operativo guest della VM, come indicato in questa sezione. Se hai un caso d'uso in cui i backend con bilanciamento del carico devono inviare traffico TCP all'indirizzo IP del bilanciatore del carico e vuoi che il traffico venga distribuito come se provenisse da un backend senza bilanciamento del carico, valuta la possibilità di utilizzare un bilanciatore del carico di rete proxy interno regionale.

Per ulteriori informazioni, vedi Bilanciatori del carico di rete passthrough interni come hop successivi.

Configura il bilanciatore del carico con subnet e backend dual-stack

Questo documento mostra come configurare e testare un bilanciatore del carico di rete passthrough interno che supporta il traffico IPv4 e IPv6. I passaggi descritti in questa sezione spiegano come configurare quanto segue:

1. L'esempio in questa pagina utilizza una rete VPC in modalità personalizzata denominata lb-network-dual-stack. Il traffico IPv6 richiede una subnet in modalità personalizzata.
2. Una subnet a doppio stack (stack-type impostato su IPV4_IPV6), necessaria per il traffico IPv6. Quando crei una subnet a doppio stack su una rete VPC in modalità personalizzata, scegli un tipo di accesso IPv6 per la subnet. Per questo esempio, impostiamo il parametro ipv6-access-type della subnet su INTERNAL. Ciò significa che alle nuove VM in questa subnet possono essere assegnati sia indirizzi IPv4 interni sia indirizzi IPv6 interni. Per istruzioni, consulta la documentazione VPC sull'aggiunta di una subnet dual stack.
3. Regole firewall che consentono le connessioni in entrata alle VM di backend.
4. Il gruppo di istanza di backend, che si trova nella seguente regione e subnet per questo esempio:
   • Regione: us-west1
   • Subnet: lb-subnet, con intervallo di indirizzi IPv4 principali 10.1.2.0/24. Sebbene tu scelga l'intervallo di indirizzi IPv4 da configurare nella subnet, l'intervallo di indirizzi IPv6 viene assegnato automaticamente. Google fornisce un blocco CIDR IPv6 di dimensioni fisse (/64).
5. Quattro VM di backend dual stack: due VM in un gruppo di istanze non gestite nella zona us-west1-a e due VM in un gruppo di istanze non gestite nella zona us-west1-c. Per dimostrare l'accesso globale, questo esempio crea una seconda VM client di test in una regione e subnet diverse:
   • Regione: europe-west1
   • Subnet: europe-subnet, con intervallo di indirizzi IP principali 10.3.4.0/24
6. Una VM client per testare le connessioni.
7. I seguenti componenti del bilanciatore del carico di rete passthrough interno:
   • Un controllo di integrità per il servizio di backend.
   • Un servizio di backend interno nella regione us-west1 per gestire la distribuzione delle connessioni ai due gruppi di istanze a livello di zona.
   • Due regole di forwarding interne per il frontend del bilanciatore del carico.

Il seguente diagramma mostra l'architettura di questo esempio:

Esempio di configurazione del bilanciatore del carico di rete passthrough interno (fai clic per ingrandire).

Nota: per semplicità, questo esempio utilizza gruppi di istanze non gestite. In produzione, valuta la possibilità di utilizzare un gruppo di istanze gestite, come illustrato in Gruppi di istanze gestite.

Configura una rete, una regione e una subnet

Il bilanciatore del carico di rete passthrough interno di esempio descritto in questa pagina viene creato in una rete VPC in modalità personalizzata denominata lb-network-dual-stack.

Per configurare le subnet con intervalli IPv6 interni, abilita un intervallo IPv6 interno ULA della rete VPC. Gli intervalli di subnet IPv6 interni vengono allocati da questo intervallo.

Console

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

   Vai a Reti VPC

2. Fai clic su Crea rete VPC.

3. In Nome, inserisci lb-network-dual-stack.

4. Se vuoi configurare intervalli di indirizzi IPv6 interni sulle subnet di questa rete, completa questi passaggi:

   1. Per Impostazioni dell'indirizzo IPv6 privato, seleziona Configura un intervallo IPv6 interno ULA per questa rete VPC.
   2. Per Alloca intervallo IPv6 interno, seleziona Automaticamente o Manualmente. Se selezioni Manualmente, inserisci un intervallo di /48 all'interno dell'intervallo fd20::/20. Se l'intervallo è in uso, ti viene chiesto di fornire un intervallo diverso.

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

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

   • Nome: lb-subnet
   • Regione: us-west1
   • Tipo di stack IP: IPv4 e IPv6 (stack doppio)
   • Intervallo IPv4: 10.1.2.0/24.
   • Tipo di accesso IPv6: Interno

7. Fai clic su Fine.

8. Fai clic su Aggiungi subnet e inserisci le seguenti informazioni:

   • Nome: europe-subnet
   • Regione: europe-west1
   • Tipo di stack IP: IPv4 (stack singolo)
   • Intervallo di indirizzi IP: 10.3.4.0/24

9. Fai clic su Fine.

10. Fai clic su Crea.

gcloud

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

   Per configurare gli intervalli IPv6 interni su qualsiasi subnet di questa rete, utilizza il flag --enable-ula-internal-ipv6. Questa opzione assegna un prefisso ULA /48 dall'intervallo fd20::/20 utilizzato da Google Cloud per gli intervalli di subnet IPv6 interni. Se vuoi selezionare l'intervallo IPv6 /48 assegnato, utilizza il flag --internal-ipv6-range per specificare un intervallo.

   gcloud compute networks create lb-network-dual-stack \
    --subnet-mode=custom \
    --enable-ula-internal-ipv6 \
    --internal-ipv6-range=ULA_IPV6_RANGE \
    --bgp-routing-mode=regional
   

   Sostituisci ULA_IPV6_RANGE con un prefisso /48 all'interno dell'intervallo fd20::/20 utilizzato da Google per gli intervalli di subnet IPv6 interni. Se non utilizzi il flag --internal-ipv6-range, Google seleziona un prefisso /48 per la rete, ad esempio fd20:bc7:9a1c::/48.

2. All'interno della rete NETWORK, crea una subnet per i backend nella regione us-west1 e un'altra subnet per testare l'accesso globale nella regione europe-west1.

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

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

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

API

Crea una nuova rete VPC in modalità personalizzata.

Per configurare gli intervalli IPv6 interni su qualsiasi subnet in questa rete, imposta enableUlaInternalIpv6 su true. Questa opzione assegna un intervallo /48 dall'intervallo fd20::/20 utilizzato da Google per gli intervalli di subnet IPv6 interni. Se vuoi selezionare l'intervallo IPv6 /48 assegnato, utilizza anche il campo internalIpv6Range per specificare un intervallo.

 POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks
 {
   "autoCreateSubnetworks": false,
   "name": "lb-network-dual-stack",
   "mtu": MTU,
   "enableUlaInternalIpv6": true,
   "internalIpv6Range": "ULA_IPV6_RANGE",
   "routingConfig": {
   "routingMode": "DYNAMIC_ROUTING_MODE"
  }
 }
 

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. Consulta la panoramica dell'unità massima di trasmissione prima di impostare l'MTU su 1500.
• ULA_IPV6_RANGE: un prefisso /48 all'interno dell'intervallo fd20::/20 utilizzato da Google per gli intervalli di subnet IPv6 interni. Se non fornisci un valore per internalIpv6Range, Google seleziona un prefisso /48 per la rete.

• DYNAMIC_ROUTING_MODE: global o regional per controllare il comportamento di annuncio di route dei router cloud nella rete. Per saperne di più, consulta la sezione Modalità di routing dinamico.

  Per saperne di più, consulta il metodo networks.insert.

Invia due richieste 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-dual-stack",
   "name": "lb-subnet"
   "stackType": IPV4_IPV6,
   "ipv6AccessType": Internal
 }
 

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

Configurazione delle regole del firewall

Questo esempio utilizza le seguenti regole firewall:

• fw-allow-lb-access: una regola di ingresso, applicabile a tutte le destinazioni nella rete VPC, che consente il traffico dalle origini negli intervalli 10.1.2.0/24 e 10.3.4.0/24. Questa regola consente il traffico in entrata da qualsiasi client che si trova in una delle due subnet. In un secondo momento, potrai configurare e testare l'accesso globale.

• fw-allow-lb-access-ipv6: una regola di ingresso, applicabile a tutte le destinazioni nella rete VPC, che consente il traffico proveniente da origini nell'intervallo IPv6 configurato nella subnet. Questa regola consente il traffico IPv6 in entrata da qualsiasi client che si trova in una delle due subnet. In un secondo momento, potrai configurare e testare l'accesso globale.

• fw-allow-ssh: una regola in entrata, applicabile alle istanze con bilanciamento del carico, che consente la connettività SSH in entrata sulla porta TCP 22 da qualsiasi indirizzo. Puoi scegliere un intervallo IP di origine più restrittivo per questa regola. Ad esempio, puoi specificare solo gli intervalli IP del sistema da cui avvii le sessioni SSH. Questo esempio utilizza il tag di destinazione allow-ssh per identificare le VM a cui deve essere applicato.

• fw-allow-health-check: una regola in entrata, applicabile alle istanze con bilanciamento del carico, che consente il traffico proveniente dai sistemi di controllo di integrità Google Cloud (130.211.0.0/22 e 35.191.0.0/16). Questo esempio utilizza il tag di destinazione allow-health-check per identificare le istanze a cui deve essere applicata.

• fw-allow-health-check-ipv6: una regola in entrata, applicabile alle istanze sottoposte a bilanciamento del carico, che consente il traffico proveniente dai sistemi di controllo di integrità (2600:2d00:1:b029::/64). Questo esempio utilizza il tag di destinazione allow-health-check-ipv6 per identificare le istanze a cui deve essere applicata. Google Cloud

Senza queste regole firewall, la regola default-deny per il traffico in entrata blocca il traffico in ingresso 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 di probe.

Console

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

   Vai a Criteri firewall

2. Per creare la regola per consentire il traffico nella subnet, fai clic su Crea regola firewall e inserisci le seguenti informazioni:

   • Nome: fw-allow-lb-access
   • Rete: lb-network-dual-stack
   • 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 e 10.3.4.0/24
   • Protocolli e porte: Consenti tutto

3. Fai clic su Crea.

4. Per consentire il traffico nella subnet IPv6, fai di nuovo clic su Crea regola firewall e inserisci le seguenti informazioni:

   • Nome: fw-allow-lb-access-ipv6
   • Rete: lb-network-dual-stack
   • 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 assegnato in lb-subnet
   • Protocolli e porte: Consenti tutto

5. Fai clic su Crea.

6. Per consentire le connessioni SSH in entrata, fai di nuovo clic su Crea regola firewall e inserisci le seguenti informazioni:

   • Nome: fw-allow-ssh
   • Rete: lb-network-dual-stack
   • 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: seleziona Protocolli e porte specificati, seleziona la casella di controllo TCP e poi inserisci 22 in Porte.

7. Fai clic su Crea.

8. Per consentire i controlli di integrità IPv6, fai di nuovo clic su Crea regola firewall e inserisci le seguenti informazioni: Google Cloud

   • Nome: fw-allow-health-check-ipv6
   • Rete: lb-network-dual-stack
   • 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à Google Cloud , fai di nuovo clic su Crea regola firewall e inserisci le seguenti informazioni:

    • Nome: fw-allow-health-check
    • Rete: lb-network-dual-stack
    • 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. Crea la regola firewall fw-allow-lb-access per consentire la comunicazione con la subnet:

   gcloud compute firewall-rules create fw-allow-lb-access \
       --network=lb-network-dual-stack \
       --action=allow \
       --direction=ingress \
       --source-ranges=10.1.2.0/24,10.3.4.0/24 \
       --rules=all
   

2. Crea la regola firewall fw-allow-lb-access-ipv6 per consentire la comunicazione con la subnet:

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

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

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

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

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

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

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

   gcloud compute firewall-rules create fw-allow-health-check \
       --network=lb-network-dual-stack \
       --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
   

API

1. Crea la regola firewall fw-allow-lb-access 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",
   "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network-dual-stack",
   "priority": 1000,
   "sourceRanges": [
     "10.1.2.0/24", "10.3.4.0/24"
   ],
   "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-dual-stack",
    "priority": 1000,
    "sourceRanges": [
      "IPV6_ADDRESS"
    ],
    "allowed": [
      {
         "IPProtocol": "tcp"
       },
       {
         "IPProtocol": "udp"
       },
       {
         "IPProtocol": "icmp"
       }
    ],
    "direction": "INGRESS",
    "logConfig": {
       "enable": false
    },
    "disabled": false
   }
   

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

3. Crea la regola firewall fw-allow-ssh inviando 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-dual-stack",
   "priority": 1000,
   "sourceRanges": [
     "0.0.0.0/0"
   ],
   "targetTags": [
     "allow-ssh"
   ],
   "allowed": [
    {
      "IPProtocol": "tcp",
      "ports": [
        "22"
      ]
    }
   ],
   "direction": "INGRESS",
   "logConfig": {
    "enable": false
   },
   "disabled": false
   }
   

4. 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-dual-stack",
   "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
   }
   

5. Crea la regola firewall fw-allow-health-check 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",
   "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network-dual-stack",
   "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
   }
   

Crea VM di backend e gruppi di istanze

Questo esempio utilizza due gruppi di istanze non gestite, ciascuno con due VM di backend (server). Per dimostrare la natura regionale dei bilanciatori del carico di rete passthrough interni, i due gruppi di istanze vengono posizionati in zone separate, us-west1-a e us-west1-c.

• Il gruppo di istanze ig-a contiene queste due VM:
  • vm-a1
  • vm-a2
• Il gruppo di istanze ig-c contiene queste due VM:
  • vm-c1
  • vm-c2

Il traffico verso tutte e quattro le VM di backend è bilanciato.

Per supportare questo esempio e le opzioni di configurazione aggiuntive, ognuna delle quattro VM esegue un web server Apache che è in ascolto sulle seguenti porte TCP: 80,8008, 8080, 8088, 443 e 8443.

A ogni VM viene assegnato un indirizzo IP interno in lb-subnet e un indirizzo IP esterno (pubblico) temporaneo. Puoi rimuovere gli indirizzi IP esterni in un secondo momento.

L'indirizzo IP esterno per le VM di backend non è obbligatorio, ma è utile per questo esempio perché consente alle VM di backend di scaricare Apache da internet e di connettersi tramite SSH.

Per impostazione predefinita, Apache è configurato per il binding a qualsiasi indirizzo IP. I bilanciatori del carico di rete passthrough interni distribuiscono i pacchetti mantenendo l'IP di destinazione.

Assicurati che il software del server in esecuzione sulle VM di backend sia in ascolto sull'indirizzo IP della regola di forwarding interno del bilanciatore del carico. Se configuri più regole di forwarding interno, assicurati che il software sia in ascolto dell'indirizzo IP interno associato a ciascuna. L'indirizzo IP di destinazione di un pacchetto recapitato a una VM di backend da un bilanciatore del carico di rete passthrough interno è l'indirizzo IP interno della regola di forwarding.

Se utilizzi gruppi di istanze gestite, assicurati che il tipo di stack della subnet corrisponda al tipo di stack dei modelli di istanza utilizzati dai gruppi di istanze gestite. La subnet deve essere a doppio stack se il gruppo di istanze gestite utilizza un modello di istanza a doppio stack.

Per semplicità didattica, queste VM di backend eseguono Debian GNU/Linux 12.

Console

Crea VM di backend

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

   Vai a Istanze VM

2. Ripeti i passaggi da 3 a 8 per ogni VM, utilizzando le seguenti combinazioni di nome e zona.

   • Nome: vm-a1, zona: us-west1-a
   • Nome: vm-a2, zona: us-west1-a
   • Nome: vm-c1, zona: us-west1-c
   • Nome: vm-c2, zona: us-west1-c

3. Fai clic su Crea istanza.

4. Imposta il Nome come indicato nel passaggio 2.

5. Per Regione, seleziona us-west1 e scegli una Zona come indicato nel passaggio 2.

6. Nella sezione Disco di avvio, assicurati che per le opzioni del disco di avvio sia selezionata l'opzione Debian GNU/Linux 12 (bookworm). Se necessario, fai clic su Cambia per modificare l'immagine.

7. Fai clic su Opzioni avanzate.

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

   1. In Tag di rete, inserisci allow-ssh e allow-health-check-ipv6.
   2. In Interfacce di rete, seleziona quanto segue:
      • Rete: lb-network-dual-stack
      • Subnet: lb-subnet
      • Tipo di stack IP: IPv4 e IPv6 (stack doppio)
      • Indirizzo IPv4 interno principale: Temporaneo (automatico)
      • Indirizzo IPv4 esterno: Temporaneo

   3. Fai clic su Gestione e poi inserisci il seguente script nel campo Script di avvio. I contenuti dello script sono identici per tutte e quattro le VM.

      #! /bin/bash
      if [ -f /etc/startup_script_completed ]; then
      exit 0
      fi
      apt-get update
      apt-get install apache2 -y
      a2ensite default-ssl
      a2enmod ssl
      file_ports="/etc/apache2/ports.conf"
      file_http_site="/etc/apache2/sites-available/000-default.conf"
      file_https_site="/etc/apache2/sites-available/default-ssl.conf"
      http_listen_prts="Listen 80\nListen 8008\nListen 8080\nListen 8088"
      http_vh_prts="*:80 *:8008 *:8080 *:8088"
      https_listen_prts="Listen 443\nListen 8443"
      https_vh_prts="*:443 *:8443"
      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
      prt_conf="$(cat "$file_ports")"
      prt_conf_2="$(echo "$prt_conf" | sed "s|Listen 80|${http_listen_prts}|")"
      prt_conf="$(echo "$prt_conf_2" | sed "s|Listen 443|${https_listen_prts}|")"
      echo "$prt_conf" | tee "$file_ports"
      http_site_conf="$(cat "$file_http_site")"
      http_site_conf_2="$(echo "$http_site_conf" | sed "s|*:80|${http_vh_prts}|")"
      echo "$http_site_conf_2" | tee "$file_http_site"
      https_site_conf="$(cat "$file_https_site")"
      https_site_conf_2="$(echo "$https_site_conf" | sed "s|_default_:443|${https_vh_prts}|")"
      echo "$https_site_conf_2" | tee "$file_https_site"
      systemctl restart apache2
      touch /etc/startup_script_completed
      

9. Fai clic su Crea.

Crea gruppi di istanze

1. Nella console Google Cloud , vai alla pagina Gruppi di istanze.

   Vai a Gruppi di istanze

2. Ripeti i seguenti passaggi per creare due gruppi di istanze non gestite, ciascuno con due VM, utilizzando queste combinazioni.

   • Nome del gruppo di istanze: ig-a, zona: us-west1-a, VM: vm-a1 e vm-a2
   • Nome del gruppo di istanze: ig-c, zona: us-west1-c, VM: vm-c1 e vm-c2

3. Fai clic su Crea gruppo di istanze.

4. Fai clic su Nuovo gruppo di istanze non gestito.

5. Imposta Nome come indicato nel passaggio 2.

6. Nella sezione Località, seleziona us-west1 per la Regione, quindi scegli una Zona come indicato nel passaggio 2.

7. In Rete, seleziona lb-network-dual-stack.

8. In Subnet, seleziona lb-subnet.

9. Nella sezione Istanze VM, aggiungi le VM come indicato nel passaggio 2.

10. Fai clic su Crea.

gcloud

1. Per creare le quattro VM, esegui il comando gcloud compute instances create quattro volte, utilizzando queste quattro combinazioni per [VM-NAME] e [ZONE]. I contenuti dello script sono identici per tutte e quattro le VM.

   • VM-NAME: vm-a1, ZONE: us-west1-a
   • VM-NAME: vm-a2, ZONE: us-west1-a
   • VM-NAME: vm-c1, ZONE: us-west1-c

   • VM-NAME: vm-c2, ZONE: us-west1-c

     gcloud compute instances create VM-NAME \
       --zone=ZONE \
       --image-family=debian-12 \
       --image-project=debian-cloud \
       --tags=allow-ssh,allow-health-check-ipv6 \
       --subnet=lb-subnet \
       --stack-type=IPV4_IPV6 \
       --metadata=startup-script='#! /bin/bash
     if [ -f /etc/startup_script_completed ]; then
     exit 0
     fi
     apt-get update
     apt-get install apache2 -y
     a2ensite default-ssl
     a2enmod ssl
     file_ports="/etc/apache2/ports.conf"
     file_http_site="/etc/apache2/sites-available/000-default.conf"
     file_https_site="/etc/apache2/sites-available/default-ssl.conf"
     http_listen_prts="Listen 80\nListen 8008\nListen 8080\nListen 8088"
     http_vh_prts="*:80 *:8008 *:8080 *:8088"
     https_listen_prts="Listen 443\nListen 8443"
     https_vh_prts="*:443 *:8443"
     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
     prt_conf="$(cat "$file_ports")"
     prt_conf_2="$(echo "$prt_conf" | sed "s|Listen 80|${http_listen_prts}|")"
     prt_conf="$(echo "$prt_conf_2" | sed "s|Listen 443|${https_listen_prts}|")"
     echo "$prt_conf" | tee "$file_ports"
     http_site_conf="$(cat "$file_http_site")"
     http_site_conf_2="$(echo "$http_site_conf" | sed "s|*:80|${http_vh_prts}|")"
     echo "$http_site_conf_2" | tee "$file_http_site"
     https_site_conf="$(cat "$file_https_site")"
     https_site_conf_2="$(echo "$https_site_conf" | sed "s|_default_:443|${https_vh_prts}|")"
     echo "$https_site_conf_2" | tee "$file_https_site"
     systemctl restart apache2
     touch /etc/startup_script_completed'
     

2. Crea i due gruppi di istanze non gestite in ogni zona:

   gcloud compute instance-groups unmanaged create ig-a \
       --zone=us-west1-a
   gcloud compute instance-groups unmanaged create ig-c \
       --zone=us-west1-c
   

3. Aggiungi le VM ai gruppi di istanze appropriati:

   gcloud compute instance-groups unmanaged add-instances ig-a \
       --zone=us-west1-a \
       --instances=vm-a1,vm-a2
   gcloud compute instance-groups unmanaged add-instances ig-c \
       --zone=us-west1-c \
       --instances=vm-c1,vm-c2
   

api

Per le quattro VM, utilizza i seguenti nomi e zone:

• VM-NAME: vm-a1, ZONE: us-west1-a
• VM-NAME: vm-a2, ZONE: us-west1-a
• VM-NAME: vm-c1, ZONE: us-west1-c
• VM-NAME: vm-c2, ZONE: us-west1-c

Puoi ottenere l'attuale DEBIAN_IMAGE_NAME eseguendo il seguente comando gcloud:

gcloud compute images list \
 --filter="family=debian-12"

Crea quattro VM di backend effettuando quattro richieste POST al metodo instances.insert:

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances

{
 "name": "VM-NAME",
 "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-dual-stack",
     "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-NAME",
     "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\nfile_ports=\"/etc/apache2/ports.conf\"\nfile_http_site=\"/etc/apache2/sites-available/000-default.conf\"\nfile_https_site=\"/etc/apache2/sites-available/default-ssl.conf\"\nhttp_listen_prts=\"Listen 80\\nListen 8008\\nListen 8080\\nListen 8088\"\nhttp_vh_prts=\"*:80 *:8008 *:8080 *:8088\"\nhttps_listen_prts=\"Listen 443\\nListen 8443\"\nhttps_vh_prts=\"*:443 *:8443\"\nvm_hostname=\"$(curl -H \"Metadata-Flavor:Google\" \\\nhttp://169.254.169.254/computeMetadata/v1/instance/name)\"\necho \"Page served from: $vm_hostname\" | \\\ntee /var/www/html/index.html\nprt_conf=\"$(cat \"$file_ports\")\"\nprt_conf_2=\"$(echo \"$prt_conf\" | sed \"s|Listen 80|${http_listen_prts}|\")\"\nprt_conf=\"$(echo \"$prt_conf_2\" | sed \"s|Listen 443|${https_listen_prts}|\")\"\necho \"$prt_conf\" | tee \"$file_ports\"\nhttp_site_conf=\"$(cat \"$file_http_site\")\"\nhttp_site_conf_2=\"$(echo \"$http_site_conf\" | sed \"s|*:80|${http_vh_prts}|\")\"\necho \"$http_site_conf_2\" | tee \"$file_http_site\"\nhttps_site_conf=\"$(cat \"$file_https_site\")\"\nhttps_site_conf_2=\"$(echo \"$https_site_conf\" | sed \"s|_default_:443|${https_vh_prts}|\")\"\necho \"$https_site_conf_2\" | tee \"$file_https_site\"\nsystemctl restart apache2"
     }
   ]
 },
 "scheduling": {
   "preemptible": false
 },
 "deletionProtection": false
}

Crea due gruppi 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-dual-stack",
 "subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet"
}

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-c/instanceGroups

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

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",
     "instance": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instances/vm-a2"
   }
 ]
}

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-c/instanceGroups/ig-c/addInstances

{
 "instances": [
   {
     "instance": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-c/instances/vm-c1",
     "instance": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-c/instances/vm-c2"
   }
 ]
}

Configura i componenti del bilanciatore del carico

Questi passaggi configurano tutti i componenti del bilanciatore del carico di rete passthrough interno, a partire dal controllo di integrità e dal servizio di backend fino ai componenti frontend:

• Controllo di integrità:in questo esempio, utilizzi un controllo di integrità HTTP che controlla una risposta HTTP 200 (OK). Per saperne di più, consulta la sezione sui controlli di integrità della panoramica del bilanciatore del carico di rete passthrough interno.

• Servizio di backend:poiché devi trasmettere il traffico HTTP attraverso il bilanciatore del carico interno, devi utilizzare TCP, anziché UDP.

• Regola di forwarding:questo esempio crea due regole di forwarding interno per il traffico IPv4 e IPv6.

• Indirizzo IP interno:in questo esempio, specifichi un indirizzo IP interno, 10.1.2.99, quando crei la regola di forwarding IPv4. Per ulteriori informazioni, consulta Indirizzo IP interno. Anche se scegli l'indirizzo IPv4 da configurare, l'indirizzo IPv6 viene assegnato automaticamente.

Console

Avvia la configurazione

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

   Vai a Bilanciamento del carico

2. Fai clic su Crea bilanciatore del carico.
3. In Tipo di bilanciatore del carico, seleziona Bilanciatore del carico di rete (TCP/UDP/SSL) e fai clic su Avanti.
4. Per Proxy o passthrough, seleziona Bilanciatore del carico passthrough e fai clic su Avanti.
5. In Pubblico o interno, seleziona Interno e fai clic su Avanti.
6. Fai clic su Configura.

Configurazione di base

Nella pagina Crea bilanciatore del carico di rete passthrough interno, inserisci le seguenti informazioni:

• Nome bilanciatore del carico: be-ilb
• Regione: us-west1
• Rete: lb-network-dual-stack

Configurazione backend

1. Fai clic su Configurazione backend.
2. Nella sezione Nuovo backend di Backend, seleziona Tipo di stack IP come IPv4 e IPv6 (stack doppio).
3. In Gruppo di istanze, seleziona il gruppo di istanze ig-a e fai clic su Fine.
4. Fai clic su Aggiungi un backend e ripeti il passaggio per aggiungere ig-c.
5. Nell'elenco Controllo di integrità, seleziona Crea un controllo di integrità, inserisci le seguenti informazioni e fai clic su Salva:
   • Nome: hc-http-80
   • Ambito: regionale.
   • Protocollo: HTTP.
   • Porta: 80.
   • Protocollo proxy: NONE.
   • Percorso richiesta: /.
6. Verifica che sia presente un segno di spunta blu accanto a Configurazione backend.

Configurazione frontend

1. Fai clic su Configurazione frontend. Nella sezione Nuovi IP e porta frontend, segui questi passaggi:
   1. In Nome, inserisci fr-ilb-ipv6.
   2. Per gestire il traffico IPv6, segui questi passaggi:
      1. In Versione IP, seleziona IPv6.
      2. In Subnet, seleziona lb-subnet. L'intervallo di indirizzi IPv6 nella regola di forwarding è sempre temporaneo.
      3. In Porte, seleziona Multiple e poi, nel campo Numero porta, inserisci 80,8008,8080,8088.
      4. Fai clic su Fine.
   3. Per gestire il traffico IPv4, segui questi passaggi:
      1. Fai clic su Aggiungi IP e porta frontend.
      2. In Nome, inserisci fr-ilb.
      3. In Subnet, seleziona lb-subnet.
      4. Nella sezione Scopo IP interno, seleziona Crea indirizzo IP dall'elenco Indirizzo IP, inserisci le seguenti informazioni e poi fai clic su Prenota.
         • Nome: ip-ilb
         • Versione IP:IPv4
         • Indirizzo IP statico:Scelta manuale
         • Indirizzo IP personalizzato: 10.1.2.99
      5. In Porte, seleziona Multiple e poi in Numeri di porta inserisci 80,8008,8080 e 8088.
      6. Fai clic su Fine.
      7. Verifica che sia presente un segno di spunta blu accanto a Configurazione frontend prima di continuare.

Rivedi la configurazione

1. Fai clic su Esamina e finalizza. Controlla tutte le impostazioni.
2. Se le impostazioni sono corrette, fai clic su Crea. La creazione del bilanciatore del carico di rete passthrough interno richiede alcuni minuti.

gcloud

1. Crea un nuovo controllo di integrità HTTP regionale per testare la connettività HTTP alle VM sulla porta 80.

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

2. Crea il servizio di backend per il traffico HTTP:

   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
   

3. Aggiungi i due gruppi 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
   gcloud compute backend-services add-backend be-ilb \
       --region=us-west1 \
       --instance-group=ig-c \
       --instance-group-zone=us-west1-c
   

4. Crea due regole di forwarding per il servizio di backend. Quando crei la regola di forwarding IPv4, specifica 10.1.2.99 per l'indirizzo IP interno nella subnet per gli indirizzi IPv4.

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

   gcloud compute forwarding-rules create fr-ilb-ipv6 \
       --region=us-west1 \
       --load-balancing-scheme=internal \
       --subnet=lb-subnet \
       --ip-protocol=TCP \
       --ports=80,8008,8080,8088 \
       --backend-service=be-ilb \
       --backend-service-region=us-west1 \
       --ip-version=IPV6
   

api

Crea il controllo di integrità inviando una richiesta POST al metodo regionHealthChecks.insert.

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

{
"name": "hc-http-80",
"type": "HTTP",
"httpHealthCheck": {
  "port": 80
}
}

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",
"backends": [
  {
    "group": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instanceGroups/ig-a",
    "balancingMode": "CONNECTION"
  },
  {
    "group": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-c/instanceGroups/ig-c",
    "balancingMode": "CONNECTION"
  }
],
"healthChecks": [
  "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/healthChecks/hc-http-80"
],
"loadBalancingScheme": "INTERNAL",
"connectionDraining": {
  "drainingTimeoutSec": 0
 }
}

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": "TCP",
"ports": [
  "80", "8008", "8080", "8088"
],
"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",
"ipVersion": "IPV6",
"networkTier": "PREMIUM"
}

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",
"IPAddress": "10.1.2.99",
"IPProtocol": "TCP",
"ports": [
  "80", "8008", "8080", "8088"
],
"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",
"networkTier": "PREMIUM"
}

Testa il bilanciatore del carico

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

Crea una VM client

Questo esempio crea una VM client (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.

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 Regione, seleziona us-west1.

5. In Zona, seleziona us-west1-a.

6. Fai clic su Opzioni avanzate.

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

   1. In Tag di rete, inserisci allow-ssh.
   2. In Interfacce di rete, seleziona quanto segue:
      • Rete: lb-network-dual-stack
      • Subnet: lb-subnet
      • Tipo di stack IP: IPv4 e IPv6 (stack doppio)
      • IP interno principale: Temporaneo (automatico)
      • IP esterno: Temporaneo
   3. Fai clic su Fine.

8. Fai clic su Crea.

gcloud

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

gcloud compute instances create vm-client \
    --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",
 "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-dual-stack",
     "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
}

Testa la connessione

Questo test contatta il bilanciatore del carico da una VM client separata, ovvero non da una VM di backend del bilanciatore del carico. Il comportamento previsto implica che il traffico venga distribuito tra le quattro VM di backend.

1. Connettiti all'istanza VM client.

   gcloud compute ssh vm-client --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. Descrivi la regola di forwarding IPv4 fr-ilb.

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

4. Dai client con connettività IPv6, esegui questo comando:

   $ 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 essere simile a questo:

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

5. Dai client con connettività IPv4, esegui questo comando:

   $ curl -m 10 -s http://10.1.2.99:80
   

   Sostituisci i segnaposto con valori validi:

   • IPV6_ADDRESS è l'indirizzo IPv6 temporaneo nella regola di forwarding fr-ilb-ipv6.

Configura il bilanciatore del carico con subnet e backend solo IPv6

Anteprima

Questo prodotto o questa funzionalità sono soggetti ai "Termini dell'offerta pre-GA" nella sezione 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 saperne di più, consulta le descrizioni della fase di lancio.

Questo documento mostra come configurare e testare un bilanciatore del carico di rete passthrough interno che supporta solo il traffico IPv6. I passaggi descritti in questa sezione spiegano come configurare quanto segue:

1. Una rete VPC in modalità personalizzata denominata lb-network-ipv6-only. Il traffico IPv6 richiede una subnet in modalità personalizzata.
2. Una subnet interna solo IPv6 denominata lb-subnet-ipv6-only (stack-type impostato su IPV6_ONLY), necessaria per il traffico solo IPv6.
3. Regole firewall che consentono le connessioni in entrata alle VM di backend.
4. Il gruppo di istanza di backend, che si trova nella seguente regione e subnet per questo esempio:
   • Regione: us-west1
   • Subnet: lb-subnet-ipv6-only l'intervallo di indirizzi IPv6 per la subnet viene assegnato automaticamente. Google fornisce un blocco CIDR IPv6 di dimensioni fisse (/64).
5. Quattro VM di backend solo IPv6: due VM in un gruppo di istanze non gestite nella zona us-west1-a e due VM in un gruppo di istanze non gestite nella zona us-west1-c.
6. Un server TCP IPv6 sulle VM di backend. Il server è in attesa di connessioni in entrata sul VIP specificato della regola di forwarding del bilanciatore del carico e sull'interfaccia di rete specificata. Il server accetta le connessioni client in entrata, invia una risposta e poi chiude la connessione.
7. Una VM client per testare le connessioni.
8. I seguenti componenti del bilanciatore del carico di rete passthrough interno:
   • Un controllo di integrità per il servizio di backend
   • Un servizio di backend interno nella regione us-west1 per gestire la distribuzione delle connessioni ai due gruppi di istanze a livello di zona
   • Una regola di forwarding IPv6

Configura una rete, una regione e una subnet

Il bilanciatore del carico di rete passthrough interno di esempio descritto in questa pagina viene creato in una rete VPC in modalità personalizzata denominata lb-network-ipv6-only.

Per configurare le subnet con intervalli IPv6 interni, abilita un intervallo IPv6 interno ULA della rete VPC. Gli intervalli di subnet IPv6 interni vengono allocati da questo intervallo.

In un secondo momento, nella sezione Installa un server TCP IPv6 sulle VM di backend utilizzando uno script Bash di avvio di questo documento, l'intervallo della subnet IPv6 interna viene utilizzato per creare una regola di routing per instradare il traffico dalla subnet VPC tramite il gateway e l'interfaccia di rete specificati.

Console

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

   Vai a Reti VPC

2. Fai clic su Crea rete VPC.

3. In Nome, inserisci lb-network-ipv6-only.

4. Se vuoi configurare intervalli di indirizzi IPv6 interni sulle subnet di questa rete, completa questi passaggi:

   1. Per Impostazioni dell'indirizzo IPv6 privato, seleziona Configura un intervallo IPv6 interno ULA per questa rete VPC.
   2. Per Alloca intervallo IPv6 interno, seleziona Automaticamente o Manualmente. Se selezioni Manualmente, inserisci un intervallo di /48 all'interno dell'intervallo fd20::/20. Se l'intervallo è già in uso, ti viene chiesto di fornire un intervallo diverso.

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

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

   • Nome: lb-subnet-ipv6-only
   • Regione: us-west1
   • Tipo di stack IP: IPv6 (stack singolo)
   • Tipo di accesso IPv6: Interno

7. Fai clic su Fine.

8. Fai clic su Crea.

gcloud

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.

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

2. Configura una subnet con ipv6-access-type impostato su INTERNAL. Ciò indica che le VM in questa subnet possono avere solo indirizzi IPv6 interni.Per creare la subnet, esegui il comando gcloud compute networks subnets create.

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

Configurazione delle regole del firewall

Questo esempio utilizza le seguenti regole firewall:

• fw-allow-lb-access-ipv6-only: una regola di ingresso, applicabile a tutte le destinazioni nella rete VPC, che consente il traffico da tutte le origini IPv6.

• fw-allow-ssh: una regola in entrata, applicabile alle istanze con bilanciamento del carico, che consente la connettività SSH in entrata sulla porta TCP 22 da qualsiasi indirizzo. Puoi scegliere un intervallo IP di origine più restrittivo per questa regola. Ad esempio, puoi specificare solo gli intervalli IP del sistema da cui avvii le sessioni SSH. Questo esempio utilizza il tag di destinazione allow-ssh per identificare le VM a cui deve essere applicato.

• fw-allow-health-check-ipv6-only: una regola in entrata, applicabile alle istanze sottoposte a bilanciamento del carico, che consente il traffico proveniente dai sistemi di controllo di integrità Google Cloud (2600:2d00:1:b029::/64). Questo esempio utilizza il tag di destinazione allow-health-check-ipv6 per identificare le istanze a cui deve essere applicata.

Senza queste regole firewall, la regola default-deny per il traffico in entrata blocca il traffico in ingresso 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 saperne di più, consulta Intervalli IP probe e regole firewall.

Console

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

   Vai a Criteri firewall

2. Per consentire il traffico nella subnet IPv6, fai di nuovo clic su Crea regola firewall e inserisci le seguenti informazioni:

   • Nome: fw-allow-lb-access-ipv6-only
   • Rete: lb-network-ipv6-only
   • 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: ::/0
   • Protocolli e porte: Consenti tutto

3. Fai clic su Crea.

4. Per consentire le connessioni SSH in entrata, fai di nuovo clic su Crea regola firewall e inserisci le seguenti informazioni:

   • Nome: fw-allow-ssh
   • Rete: lb-network-ipv6-only
   • 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: seleziona Protocolli e porte specificati, seleziona la casella di controllo TCP e poi inserisci 22 in Porte.

5. Fai clic su Crea.

6. Per consentire i controlli di integrità IPv6, fai di nuovo clic su Crea regola firewall e inserisci le seguenti informazioni: Google Cloud

   • Nome: fw-allow-health-check-ipv6-only
   • Rete: lb-network-ipv6-only
   • 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

7. Fai clic su Crea.

gcloud

1. Crea la regola firewall fw-allow-lb-access-ipv6-only per consentire il traffico IPv6 a tutte le istanze VM nella rete VPC.

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

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

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

3. Crea la regola fw-allow-health-check-ipv6 per consentire i controlli di integrità IPv6Google Cloud .

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

Crea VM di backend e gruppi di istanze

Questo esempio utilizza due gruppi di istanze non gestite, ciascuno con due VM di backend. Per dimostrare la natura regionale dei bilanciatori del carico di rete passthrough interni, i due gruppi di istanze vengono posizionati in zone separate, us-west1-a e us-west1-c.

• Il gruppo di istanze ig-a contiene queste due VM:
  • vm-a1
  • vm-a2
• Il gruppo di istanze ig-c contiene queste due VM:
  • vm-c1
  • vm-c2

Il traffico verso tutte e quattro le VM di backend è bilanciato.

Console

Crea VM di backend

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

   Vai a Istanze VM

2. Ripeti questi passaggi per ogni VM, utilizzando le seguenti combinazioni di nome e zona.

   • Nome: vm-a1, zona: us-west1-a
   • Nome: vm-a2, zona: us-west1-a
   • Nome: vm-c1, zona: us-west1-c
   • Nome: vm-c2, zona: us-west1-c

3. Fai clic su Crea istanza.

4. Imposta il Nome come indicato nel passaggio 2.

5. Per Regione, seleziona us-west1 e scegli una Zona come indicato nel passaggio 2.

6. Nella sezione Disco di avvio, assicurati che per le opzioni del disco di avvio sia selezionata l'opzione Debian GNU/Linux 12 (bookworm). Se necessario, fai clic su Cambia per modificare l'immagine.

7. Fai clic su Opzioni avanzate.

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

   1. In Tag di rete, inserisci allow-ssh e allow-health-check-ipv6.
   2. In Interfacce di rete, seleziona quanto segue:
      • Rete: lb-network-ipv6-only
      • Subnet: lb-subnet-ipv6-only
      • Tipo di stack IP: IPv6 (stack singolo)
      • Indirizzo IPv6 interno principale: Temporaneo (automatico)

9. Fai clic su Crea.

La VM di backend deve eseguire un server TCP IPv6 che ascolti le connessioni in entrata. Installa questo server sulle VM di backend dopo aver configurato il bilanciatore del carico. Questo perché lo script del server crea un socket che si associa alla regola di forwarding del bilanciatore del carico.

Crea gruppi di istanze

1. Nella console Google Cloud , vai alla pagina Gruppi di istanze.

   Vai a Gruppi di istanze

2. Ripeti i seguenti passaggi per creare due gruppi di istanze non gestite, ciascuno con due VM, utilizzando queste combinazioni.

   • Nome del gruppo di istanze: ig-a, zona: us-west1-a, VM: vm-a1 e vm-a2
   • Nome del gruppo di istanze: ig-c, zona: us-west1-c, VM: vm-c1 e vm-c2

3. Fai clic su Crea gruppo di istanze.

4. Fai clic su Nuovo gruppo di istanze non gestito.

5. Imposta Nome come indicato nel passaggio 2.

6. Nella sezione Località, seleziona us-west1 per la Regione, quindi scegli una Zona come indicato nel passaggio 2.

7. In Rete, seleziona lb-network-ipv6-only.

8. In Subnet, seleziona lb-subnet-ipv6-only.

9. Nella sezione Istanze VM, aggiungi le VM come indicato nel passaggio 2.

10. Fai clic su Crea.

gcloud

1. Per creare le quattro VM, esegui il comando gcloud compute instances create quattro volte, utilizzando queste quattro combinazioni per [VM-NAME] e [ZONE].

   • VM-NAME: vm-a1, ZONE: us-west1-a
   • VM-NAME: vm-a2, ZONE: us-west1-a
   • VM-NAME: vm-c1, ZONE: us-west1-c
   • VM-NAME: vm-c2, ZONE: us-west1-c

   gcloud beta compute instances create VM-NAME \
       --zone=ZONE \
       --image-family=debian-12 \
       --image-project=debian-cloud \
       --tags=allow-ssh,allow-health-check-ipv6 \
       --subnet=lb-subnet-ipv6-only \
       --stack-type=IPV6_ONLY
   

   La VM di backend deve eseguire un server TCP IPv6 che ascolti le connessioni in entrata. Installa questo server sulle VM di backend dopo aver configurato il bilanciatore del carico. Questo perché lo script del server crea un socket che si associa alla regola di forwarding del bilanciatore del carico.

2. Crea i due gruppi di istanze non gestite in ogni zona:

   gcloud beta compute instance-groups unmanaged create ig-a \
       --zone=us-west1-a
   gcloud beta compute instance-groups unmanaged create ig-c \
       --zone=us-west1-c
   

3. Aggiungi le VM ai gruppi di istanze appropriati:

   gcloud beta compute instance-groups unmanaged add-instances ig-a \
     --zone=us-west1-a \
     --instances=vm-a1,vm-a2
   gcloud beta compute instance-groups unmanaged add-instances ig-c \
     --zone=us-west1-c \
     --instances=vm-c1,vm-c2
   

Configura i componenti del bilanciatore del carico

Questi passaggi configurano tutti i componenti del bilanciatore del carico di rete passthrough interno, a partire dal controllo di integrità e dal servizio di backend fino ai componenti frontend:

Console

Avvia la configurazione

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

   Vai a Bilanciamento del carico

2. Fai clic su Crea bilanciatore del carico.
3. In Tipo di bilanciatore del carico, seleziona Bilanciatore del carico di rete (TCP/UDP/SSL) e fai clic su Avanti.
4. Per Proxy o passthrough, seleziona Bilanciatore del carico passthrough e fai clic su Avanti.
5. In Pubblico o interno, seleziona Interno e fai clic su Avanti.
6. Fai clic su Configura.

Configurazione di base

Nella pagina Crea bilanciatore del carico di rete passthrough interno, inserisci le seguenti informazioni:

• Nome bilanciatore del carico: ilb-ipv6-only
• Regione: us-west1
• Rete: lb-network-ipv6-only

Configurazione backend

1. Fai clic su Configurazione backend.
2. Nella sezione Nuovo backend di Backend, seleziona il Tipo di stack IP come IPv6 (stack singolo).
3. In Gruppo di istanze, seleziona il gruppo di istanze ig-a e fai clic su Fine.
4. Fai clic su Aggiungi un backend e ripeti il passaggio per aggiungere ig-c.
5. Nell'elenco Controllo di integrità, seleziona Crea un controllo di integrità, inserisci le seguenti informazioni e fai clic su Salva:
   • Nome: hc-http-80
   • Ambito: regionale.
   • Protocollo: HTTP.
   • Porta: 80.
   • Protocollo proxy: NONE.
   • Percorso richiesta: /.
6. Verifica che sia presente un segno di spunta blu accanto a Configurazione backend.

Configurazione frontend

1. Fai clic su Configurazione frontend. Nella sezione Nuovi IP e porta frontend:
   1. In Nome, inserisci fr-ilb-ipv6-only.
   2. Per gestire il traffico IPv6, segui questi passaggi:
      1. In Versione IP, seleziona IPv6. Il server TCP IPv6 che creerai nella sezione seguente si associa al VIP della regola di forwarding.
      2. In Subnet, seleziona lb-subnet-ipv6-only. L'intervallo di indirizzi IPv6 nella regola di forwarding è sempre temporaneo.
      3. Per Porte, seleziona Multiple e poi nel campo Numero porta, inserisci 80,8008,8080,8088.
      4. Fai clic su Fine.
   3. Verifica che sia presente un segno di spunta blu accanto a Configurazione frontend prima di continuare.

Rivedi la configurazione

1. Fai clic su Esamina e finalizza. Controlla tutte le impostazioni.
2. Se le impostazioni sono corrette, fai clic su Crea. La creazione del bilanciatore del carico di rete passthrough interno richiede alcuni minuti.

gcloud

1. Crea un nuovo controllo di integrità HTTP regionale per testare la connettività HTTP alle VM sulla porta 80.

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

2. Crea il servizio di backend:

   gcloud beta compute backend-services create ilb-ipv6-only \
       --load-balancing-scheme=INTERNAL \
       --protocol=tcp \
       --region=us-west1 \
       --health-checks=hc-http-80 \
       --health-checks-region=us-west1
   

3. Aggiungi i due gruppi di istanze al servizio di backend:

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

   gcloud beta compute backend-services add-backend ilb-ipv6-only \
       --region=us-west1 \
       --instance-group=ig-c \
       --instance-group-zone=us-west1-c
   

4. Crea la regola di forwarding IPv6 con un indirizzo IPv6 temporaneo.

   gcloud beta compute forwarding-rules create fr-ilb-ipv6-only \
       --region=us-west1 \
       --load-balancing-scheme=INTERNAL \
       --subnet=lb-subnet-ipv6-only \
       --ip-protocol=TCP \
       --ports=80,8008,8080,8088 \
       --backend-service=ilb-ipv6-only \
       --backend-service-region=us-west1 \
       --ip-version=IPV6
   

   Il server TCP IPv6 che creerai nella sezione seguente si associa al VIP della regola di forwarding.

Installa un server TCP IPv6 sulle VM di backend utilizzando uno script Bash di avvio

In questo esempio, lo script di avvio Bash per le VM di backend contiene quanto segue:

• Comandi di Networking per instradare tutti i pacchetti in uscita provenienti da una subnet tramite un gateway e un'interfaccia di rete specifici.
• Script server Python (server.py), che è un server TCP IPv6, che ascolta le connessioni in entrata sull'interfaccia di rete e sul VIP specificati. Accetta le connessioni client in entrata, invia una risposta e poi chiude la connessione.

Devi aggiungere i seguenti dettagli nello script Bash:

• Indirizzo gateway
• Intervallo di subnet
• VIP della regola di forwarding
• Interfaccia di rete

Puoi identificare l'indirizzo del gateway e l'intervallo di subnet eseguendo il comando ip -6 route show table all nella VM di backend. Per saperne di più sui comandi utilizzati nello script Bash di avvio, consulta la sezione Appendice.

Per aggiungere uno script di avvio all'istanza VM:

Nota: devi eseguire questi passaggi per ogni VM di backend che hai creato in precedenza.

Console

1. Nell'elenco delle istanze VM che hai creato in precedenza, fai clic sull'istanza VM che devi aggiornare.

2. Fai clic su Modifica.

3. Nella sezione Metadati, inserisci il seguente script nel campo Script di avvio.

   Nota: lo script del server server.py a cui viene fatto riferimento nello script Bash è archiviato nella cartella radice della VM di backend.

   #!/bin/bash
   
   # Replace these with your actual values. Run the 'ip -6 route show table all' command to find the correct values.
   GATEWAY_ADDRESS=fe80::57:2ff:fe36:ffbe
   SUBNET_RANGE=fd20:307:120c:2000::/64
   
   # Add a custom default route to routing table 1.
   # The following command sends packets to the gateway using the network interface named 'ens4'.
   sudo ip route add default via $GATEWAY_ADDRESS dev ens4 table 1
   
   # Add a source-based policy routing rule.
   # The following command adds a rule to route all outgoing packets originating
   # from a specified subnet. If the source address matches the subnet,
   # the system uses the default route defined in table 1 to forward the traffic.
   sudo ip -6 rule add from $SUBNET_RANGE table 1
   
   # Allow the server to bind to a non-local IPv6 address--the VIP of the load balancer.
   sudo sysctl -w net.ipv6.ip_nonlocal_bind=1
   
   # Overview:
   # This script sets up a simple IPv6 TCP server using Python's socket library.
   # The server binds to a specific network interface and listens on a specified Virtual IP (VIP) address and port (default: 80).
   # It accepts incoming client connections, sends a simple response ("Thank you for connecting"), and then closes the connection.
   # Key features:
   # - Uses IPv6 (AF_INET6) for networking.
   # - Binds to a specific network interface using SO_BINDTODEVICE.
   # - Handles multiple client connections in a loop.
   # - Demonstrates basic socket programming concepts like binding, listening, accepting, and sending data.
   # Note: Replace placeholders like 'FORWARDING_RULE_VIP' and 'ens4' with actual values for your setup.
   
   # Write the Python file locally.
   cat << 'EOF' > server.py
   
   # Import the socket library to work with network connections
   import socket
   import urllib.request
   
   # Fetch the VM hostname from Google Cloud metadata server
   def get_vm_hostname():
       url = "http://metadata.google.internal/computeMetadata/v1/instance/name"
       req = urllib.request.Request(url, headers={"Metadata-Flavor": "Google"})
       with urllib.request.urlopen(req) as response:
           return response.read().decode()
   
   vm_hostname = get_vm_hostname()
   
   # Create a socket object for IPv6 and TCP connections
   # AF_INET6 specifies IPv6, SOCK_STREAM specifies TCP
   server_socket = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
   
   # Set the SO_REUSEADDR option to allow reusing the address
   # This is useful to avoid "address already in use" errors when restarting the server
   server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
   
   # Specify the network interface to bind the server to
   # Replace "ens4" with the name of your network interface
   interface_name = "ens4"
   # Get the index of the network interface
   interface_index = socket.if_nametoindex(interface_name)
   # Bind the socket to the specified network interface
   server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_BINDTODEVICE, interface_name.encode())
   
   # Bind the socket to an address and port
   # Replace 'FORWARDING_RULE_VIP' with the actual VIP (Virtual IP) address
   server_address = ('FORWARDING_RULE_VIP', 80, 0, 0)
   server_socket.bind(server_address)
   
   # Start listening for incoming connections
   # The argument '5' specifies the maximum number of queued connections
   server_socket.listen(5)
   
   # Print a message indicating that the server is ready to accept connections
   print(f"Server listening on {server_address}, bound to {interface_name}")
   
   # Serve incoming connections
   while True:
       client_socket, client_address = server_socket.accept()
       print(f"Accepted connection from {client_address}")
   
       # Generate response body
       body = f"Thank you for connecting to {vm_hostname}\n"
   
       # Construct a proper HTTP/1.1 response
       response = (
           "HTTP/1.1 200 OK\r\n"
           f"Content-Length: {len(body)}\r\n"
           "Content-Type: text/plain\r\n"
           "Connection: close\r\n"
           "\r\n"
           f"{body}"
       )
   
       # Send the response and close the connection
       client_socket.sendall(response.encode())
       client_socket.close()
   EOF
   
   # Make the Python script executable
   chmod +x server.py
   
   # Run the server
   sudo python3 server.py
   
   

4. Fai clic su Salva.

5. Riavvia l'istanza.

gcloud

1. Crea uno script di avvio.

   nano startup.sh
   

2. Aggiungi il seguente script e salva il file.

   Nota: lo script del server server.py a cui viene fatto riferimento nello script Bash è archiviato nella cartella radice della VM di backend.

   #!/bin/bash
   
   # Replace these with your actual values. Run the 'ip -6 route show table all' command to find the correct values.
   GATEWAY_ADDRESS=fe80::57:2ff:fe36:ffbe
   SUBNET_RANGE=fd20:307:120c:2000::/64
   
   # Add a custom default route to routing table 1.
   # The following command sends packets to the gateway using the network interface named 'ens4'.
   sudo ip route add default via $GATEWAY_ADDRESS dev ens4 table 1
   
   # Add a source-based policy routing rule.
   # The following command adds a rule to route all outgoing packets originating
   # from a specified subnet. If the source address matches the subnet,
   # the system uses the default route defined in table 1 to forward the traffic.
   sudo ip -6 rule add from $SUBNET_RANGE table 1
   
   # Allow the server to bind to a non-local IPv6 address--the VIP of the load balancer.
   sudo sysctl -w net.ipv6.ip_nonlocal_bind=1
   
   # Overview:
   # This script sets up a simple IPv6 TCP server using Python's socket library.
   # The server binds to a specific network interface and listens on a specified Virtual IP (VIP) address and port (default: 80).
   # It accepts incoming client connections, sends a simple response ("Thank you for connecting"), and then closes the connection.
   # Key features:
   # - Uses IPv6 (AF_INET6) for networking.
   # - Binds to a specific network interface using SO_BINDTODEVICE.
   # - Handles multiple client connections in a loop.
   # - Demonstrates basic socket programming concepts like binding, listening, accepting, and sending data.
   # Note: Replace placeholders like 'FORWARDING_RULE_VIP' and 'ens4' with actual values for your setup.
   
   # Write the Python file locally.
   cat << 'EOF' > server.py
   
   # Import the socket library to work with network connections
   import socket
   import urllib.request
   
   # Fetch the VM hostname from Google Cloud metadata server
   def get_vm_hostname():
       url = "http://metadata.google.internal/computeMetadata/v1/instance/name"
       req = urllib.request.Request(url, headers={"Metadata-Flavor": "Google"})
       with urllib.request.urlopen(req) as response:
           return response.read().decode()
   
   vm_hostname = get_vm_hostname()
   
   # Create a socket object for IPv6 and TCP connections
   # AF_INET6 specifies IPv6, SOCK_STREAM specifies TCP
   server_socket = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
   
   # Set the SO_REUSEADDR option to allow reusing the address
   # This is useful to avoid "address already in use" errors when restarting the server
   server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
   
   # Specify the network interface to bind the server to
   # Replace "ens4" with the name of your network interface
   interface_name = "ens4"
   # Get the index of the network interface
   interface_index = socket.if_nametoindex(interface_name)
   # Bind the socket to the specified network interface
   server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_BINDTODEVICE, interface_name.encode())
   
   # Bind the socket to an address and port
   # Replace 'FORWARDING_RULE_VIP' with the actual VIP (Virtual IP) address
   server_address = ('FORWARDING_RULE_VIP', 80, 0, 0)
   server_socket.bind(server_address)
   
   # Start listening for incoming connections
   # The argument '5' specifies the maximum number of queued connections
   server_socket.listen(5)
   
   # Print a message indicating that the server is ready to accept connections
   print(f"Server listening on {server_address}, bound to {interface_name}")
   
   # Serve incoming connections
   while True:
       client_socket, client_address = server_socket.accept()
       print(f"Accepted connection from {client_address}")
   
       # Generate response body
       body = f"Thank you for connecting to {vm_hostname}\n"
   
       # Construct a proper HTTP/1.1 response
       response = (
           "HTTP/1.1 200 OK\r\n"
           f"Content-Length: {len(body)}\r\n"
           "Content-Type: text/plain\r\n"
           "Connection: close\r\n"
           "\r\n"
           f"{body}"
       )
   
       # Send the response and close the connection
       client_socket.sendall(response.encode())
       client_socket.close()
   EOF
   
   # Make the Python script executable
   chmod +x server.py
   
   # Run the server
   sudo python3 server.py
   
   

3. Aggiungi il file dei metadati all'istanza VM.

   gcloud compute instances add-metadata VM-NAME \
     --metadata-from-file=startup-script=startup.sh
   

4. Riavvia l'istanza.

Testa il bilanciatore del carico

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

Crea una VM client

Questo esempio crea una VM client (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.

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 Regione, seleziona us-west1.

5. In Zona, seleziona us-west1-a.

6. Fai clic su Opzioni avanzate.

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

   1. In Tag di rete, inserisci allow-ssh.
   2. In Interfacce di rete, seleziona quanto segue:
      • Rete: lb-network-ipv6-only
      • Subnet: lb-subnet-ipv6-only
      • Tipo di stack IP: IPv6 (stack singolo)
   3. Fai clic su Fine.

8. Fai clic su Crea.

gcloud

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

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

Testa la connessione

Questo test contatta il bilanciatore del carico da una VM client separata, ovvero non da una VM di backend del bilanciatore del carico. Il comportamento previsto implica che il traffico venga distribuito tra le quattro VM di backend.

1. Connettiti all'istanza VM client utilizzando SSH.

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

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

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

3. Dai client con connettività IPv6, esegui questo comando:

   curl http://IPV6_ADDRESS:80
   

   Ad esempio, se l'indirizzo IPv6 assegnato è [fd20:307:120c:2000:0:1:0:0/96]:80, il comando dovrebbe essere simile a questo:

   curl http://[fd20:307:120c:2000:0:1:0:0]:80
   

Opzioni di configurazione aggiuntive

Questa sezione espande l'esempio di configurazione per fornire opzioni di configurazione alternative e aggiuntive. Tutte le attività sono facoltative. Puoi eseguirli in qualsiasi ordine.

Abilita accesso globale

Puoi abilitare l'accesso globale per il bilanciatore del carico di rete passthrough interno di esempio per renderlo accessibile ai client in tutte le regioni. I backend del bilanciatore del carico di esempio devono comunque trovarsi in una regione (us-west1).

Bilanciatore del carico di rete passthrough interno con accesso globale (fai clic per ingrandire).

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

Console

Modifica la regola di forwarding del bilanciatore del carico

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

   Vai a Bilanciamento del carico

2. Nella colonna Nome, fai clic sul bilanciatore del carico di rete passthrough interno. Il bilanciatore del carico di esempio si chiama be-ilb.

3. Fai clic su Configurazione frontend.

4. Fai clic su Modifica .

5. Nella sezione Accesso globale, seleziona Attiva.

6. Fai clic su Fine.

7. Fai clic su Aggiorna.

Nella pagina Dettagli del bilanciatore del carico, verifica che la configurazione frontend indichi Regionale (REGION) con accesso globale.

gcloud

1. Aggiorna la regola di forwarding del bilanciatore del carico di esempio, fr-ilb, in modo da includere il flag --allow-global-access.

   gcloud compute forwarding-rules update fr-ilb \
      --region=us-west1 \
      --allow-global-access
   

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

   gcloud compute forwarding-rules describe fr-ilb \
      --region=us-west1 \
      --format="get(name,region,allowGlobalAccess)"
   

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

API

Invia una richiesta PATCH al metodo forwardingRules/patch.

PATCH https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules/fr-ilb

{
"allowGlobalAccess": true
}

Crea una VM client per testare l'accesso globale

Console

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

   Vai a Istanze VM

2. Fai clic su Crea istanza.

3. Imposta Nome su vm-client2.

4. Imposta Regione su europe-west1.

5. Imposta Zona su europe-west1-b.

6. Fai clic su Opzioni avanzate.

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

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

8. Fai clic su Crea.

gcloud

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

gcloud compute instances create vm-client2 \
    --zone=europe-west1-b \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --tags=allow-ssh \
    --subnet=europe-subnet

API

Invia una richiesta POST al metodo instances.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/europe-west1-b/instances

{
"name": "vm-client2",
"tags": {
  "items": [
    "allow-ssh"
  ]
},
"machineType": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/europe-west1-b/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/europe-west1/subnetworks/europe-subnet",
    "accessConfigs": [
      {
        "type": "ONE_TO_ONE_NAT",
        "name": "external-nat",
        "networkTier": "PREMIUM"
      }
    ]
  }
],
"disks": [
  {
    "type": "PERSISTENT",
    "boot": true,
    "mode": "READ_WRITE",
    "autoDelete": true,
    "deviceName": "vm-client2",
    "initializeParams": {
      "sourceImage": "projects/debian-cloud/global/images/debian-image-name",
      "diskType": "projects/PROJECT_ID/zones/europe-west1-b/diskTypes/pd-standard",
      "diskSizeGb": "10"
    }
  }
],
"scheduling": {
  "preemptible": false
},
"deletionProtection": false
}

Connettiti alla VM client e testa la connettività

Per testare la connettività, esegui questo comando:

  gcloud compute ssh vm-client2 --zone=europe-west1-b
  

Testa la connessione al bilanciatore del carico su tutte le porte configurate, come hai fatto da vm-client nella regione us-west1�. Testa la connettività HTTP sulle quattro porte configurate nella regola di forwarding:

  curl http://10.1.2.99
  curl http://10.1.2.99:8008
  curl http://10.1.2.99:8080
  curl http://10.1.2.99:8088
  

Configura i gruppi di istanze gestite

Importante: i gruppi di istanze gestite non sono supportati come backend per i bilanciatori del carico che utilizzano subnet e backend solo IPv6.

La configurazione di esempio ha creato due gruppi di istanze non gestite. Puoi invece utilizzare gruppi di istanze gestite, inclusi i gruppi di istanze gestite a livello di zona e di regione, come backend per i bilanciatori del carico di rete passthrough interni.

I gruppi di istanze gestite richiedono la creazione di un modello di istanza. Questa procedura mostra come sostituire i due gruppi di istanze non gestite a livello di zona dell'esempio con un unico gruppo di istanze gestite a livello di regione. Un gruppo di istanze gestite regionale crea automaticamente VM in più zone della regione, semplificando la distribuzione del traffico di produzione tra le zone.

I gruppi di istanze gestite supportano anche la scalabilità automatica e la riparazione automatica. Se utilizzi la scalabilità automatica con i bilanciatori del carico di rete passthrough interni, non puoi scalare in base al bilanciamento del carico.

Questa procedura mostra come modificare il servizio di backend per il bilanciatore del carico di rete passthrough interno di esempio in modo che utilizzi un gruppo di istanze gestite a livello di regione.

Console

Modello di istanza

1. Nella console Google Cloud , vai alla pagina Template di istanza VM.

   Vai a Modelli di istanza VM

2. Fai clic su Crea modello istanza.

3. Imposta Nome su template-vm-ilb.

4. Scegli un tipo di macchina.

5. Nella sezione Disco di avvio, assicurati che per le opzioni del disco di avvio sia selezionata l'opzione Debian GNU/Linux 12 (bookworm). Se necessario, fai clic su Cambia per modificare l'immagine.

6. Fai clic su Opzioni avanzate.

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

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

8. Fai clic su Gestione e poi, nel campo Script di avvio, inserisci il seguente script:

   #! /bin/bash
   if [ -f /etc/startup_script_completed ]; then
   exit 0
   fi
   apt-get update
   apt-get install apache2 -y
   a2ensite default-ssl
   a2enmod ssl
   file_ports="/etc/apache2/ports.conf"
   file_http_site="/etc/apache2/sites-available/000-default.conf"
   file_https_site="/etc/apache2/sites-available/default-ssl.conf"
   http_listen_prts="Listen 80\nListen 8008\nListen 8080\nListen 8088"
   http_vh_prts="*:80 *:8008 *:8080 *:8088"
   https_listen_prts="Listen 443\nListen 8443"
   https_vh_prts="*:443 *:8443"
   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
   prt_conf="$(cat "$file_ports")"
   prt_conf_2="$(echo "$prt_conf" | sed "s|Listen 80|${http_listen_prts}|")"
   prt_conf="$(echo "$prt_conf_2" | sed "s|Listen 443|${https_listen_prts}|")"
   echo "$prt_conf" | tee "$file_ports"
   http_site_conf="$(cat "$file_http_site")"
   http_site_conf_2="$(echo "$http_site_conf" | sed "s|*:80|${http_vh_prts}|")"
   echo "$http_site_conf_2" | tee "$file_http_site"
   https_site_conf="$(cat "$file_https_site")"
   https_site_conf_2="$(echo "$https_site_conf" | sed "s|_default_:443|${https_vh_prts}|")"
   echo "$https_site_conf_2" | tee "$file_https_site"
   systemctl restart apache2
   touch /etc/startup_script_completed
   

9. Fai clic su Crea.

Gruppo di istanze gestite

1. Nella console Google Cloud , vai alla pagina Gruppi di istanze.

   Vai a Gruppi di istanze

2. Fai clic su Crea gruppo di istanze.

3. Imposta Nome su ig-ilb.

4. Per Località, scegli Più zone e imposta la Regione su us-west1.

5. Imposta Modello di istanza su template-vm-ilb.

6. (Facoltativo) Configura la scalabilità automatica. Non puoi scalare automaticamente il gruppo di istanze in base all'utilizzo del bilanciamento del carico HTTP perché il gruppo di istanze è un backend per il bilanciatore del carico di rete passthrough interno.

7. Imposta il numero minimo di istanze su 1 e il numero massimo di istanze su 6.

8. (Facoltativo) Configura la riparazione automatica. Se configuri la riparazione automatica, utilizza lo stesso controllo di integrità utilizzato dal servizio di backend per il bilanciatore del carico di rete passthrough interno. In questo esempio, utilizza hc-http-80.

9. Fai clic su Crea.

gcloud

1. Crea il modello di istanza. Se vuoi, puoi impostare altri parametri, come il tipo di macchina, per il modello di immagine da utilizzare.

   gcloud compute instance-templates create template-vm-ilb \
       --image-family=debian-12 \
       --image-project=debian-cloud \
       --tags=allow-ssh,allow-health-check \
       --subnet=lb-subnet \
       --region=us-west1 \
       --network=lb-network \
       --metadata=startup-script='#! /bin/bash
   if [ -f /etc/startup_script_completed ]; then
   exit 0
   fi
   apt-get update
   apt-get install apache2 -y
   a2ensite default-ssl
   a2enmod ssl
   file_ports="/etc/apache2/ports.conf"
   file_http_site="/etc/apache2/sites-available/000-default.conf"
   file_https_site="/etc/apache2/sites-available/default-ssl.conf"
   http_listen_prts="Listen 80\nListen 8008\nListen 8080\nListen 8088"
   http_vh_prts="*:80 *:8008 *:8080 *:8088"
   https_listen_prts="Listen 443\nListen 8443"
   https_vh_prts="*:443 *:8443"
   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
   prt_conf="$(cat "$file_ports")"
   prt_conf_2="$(echo "$prt_conf" | sed "s|Listen 80|${http_listen_prts}|")"
   prt_conf="$(echo "$prt_conf_2" | sed "s|Listen 443|${https_listen_prts}|")"
   echo "$prt_conf" | tee "$file_ports"
   http_site_conf="$(cat "$file_http_site")"
   http_site_conf_2="$(echo "$http_site_conf" | sed "s|*:80|${http_vh_prts}|")"
   echo "$http_site_conf_2" | tee "$file_http_site"
   https_site_conf="$(cat "$file_https_site")"
   https_site_conf_2="$(echo "$https_site_conf" | sed "s|_default_:443|${https_vh_prts}|")"
   echo "$https_site_conf_2" | tee "$file_https_site"
   systemctl restart apache2
   touch /etc/startup_script_completed'
   

2. Crea un gruppo di istanze gestite regionale utilizzando il modello:

   gcloud compute instance-groups managed create ig-ilb \
       --template=template-vm-ilb \
       --region=us-west1 \
       --size=6
   

3. Aggiungi il gruppo di istanze gestite a livello di regione come backend al servizio di backend che hai già creato:

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

4. Disconnetti i due gruppi di istanze non gestite (zionali) dal servizio di backend:

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

Rimuovi gli indirizzi IP esterni dalle VM di backend

Quando hai creato le VM di backend, a ognuna è stato assegnato un indirizzo IP esterno temporaneo in modo che potesse scaricare Apache utilizzando uno script di avvio. Poiché le VM di backend vengono utilizzate solo da un bilanciatore del carico di rete passthrough interno, puoi rimuovere i relativi indirizzi IP esterni. La rimozione degli indirizzi IP esterni impedisce alle VM di backend di accedere direttamente a internet.

Importante: la rimozione dell'indirizzo IP esterno da una VM limita le modalità di connessione. Per maggiori dettagli, vedi Scegliere un'opzione di connessione per le VM solo interne. È utile lasciare gli indirizzi IP esterni sulle VM di backend se devi dimostrare come vengono gestite le richieste da una VM di backend all'indirizzo IP del bilanciatore del carico.

Console

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

   Vai a Istanze VM

2. Ripeti i seguenti passaggi per ogni VM di backend.

3. Fai clic sul nome della VM di backend, ad esempio vm-a1.

4. Fai clic su Modifica.

5. Nella sezione Interfacce di rete, fai clic sulla rete.

6. Nell'elenco IP esterno, seleziona Nessuno e fai clic su Fine.

7. Fai clic su Salva.

gcloud

1. Per cercare la zona di un'istanza, ad esempio se utilizzi un gruppo di istanze gestite regionale, esegui il seguente comando per ogni istanza per determinare la relativa zona. Sostituisci [SERVER-VM] con il nome della VM da cercare.

   gcloud compute instances list --filter="name=[SERVER-VM]"
   

2. Ripeti il seguente passaggio per ogni VM di backend. Sostituisci [SERVER-VM] con il nome della VM e [ZONE] con la zona della VM.

   gcloud compute instances delete-access-config [SERVER-VM] \
       --zone=[ZONE] \
       --access-config-name=external-nat
   

API

Effettua una richiesta POST al metodo instances.deleteAccessConfig per ogni VM di backend, sostituendovm-a1 con il nome della VM e sostituendo us-west1-a con la zona della VM.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instances/vm-a1/deleteAccessConfig?accessConfig=external-nat&networkInterface=None

Utilizza un indirizzo IP interno riservato

Quando crei VM di backend e gruppi di istanze, l'istanza VM utilizza un indirizzo IPv4 o IPv6 interno temporaneo.

I seguenti passaggi mostrano come promuovere un indirizzo IPv4 o IPv6 interno a un indirizzo IPv4 o IPv6 interno statico e poi aggiornare l'istanza VM in modo che utilizzi l'indirizzo IP interno statico:

1. Promuovi un indirizzo IPv4 o IPv6 interno temporaneo in uso a un indirizzo statico.
2. Modifica o assegna un indirizzo IPv6 interno a un'istanza esistente.

In alternativa, i seguenti passaggi mostrano come prenotare un nuovo indirizzo IPv4 o IPv6 interno statico e poi aggiornare l'istanza VM in modo che utilizzi l'indirizzo IP interno statico:

1. Prenota un nuovo indirizzo IPv4 o IPv6 interno statico.

   A differenza della prenotazione IPv4 interna, la prenotazione IPv6 interna non supporta la prenotazione di un indirizzo IP specifico dalla subnet. Viene invece allocato automaticamente un intervallo di indirizzi IPv6 interno /96 dall'intervallo di indirizzi IPv6 interno /64 della subnet.

2. Modifica o assegna un indirizzo IPv6 interno a un'istanza esistente.

Per saperne di più, consulta Come prenotare un indirizzo IP interno statico.

Accetta il traffico su tutte le porte

La regola di forwarding del bilanciatore del carico, non il suo servizio di backend, determina la porta o le porte su cui il bilanciatore del carico accetta il traffico. Per informazioni sullo scopo di ciascun componente, consulta la sezione Componenti.

Quando hai creato la regola di forwarding di questo bilanciatore del carico di esempio, hai configurato le porte 80, 8008, 8080 e 8088. Lo script di avvio che installa Apache lo configura anche per accettare connessioni HTTPS sulle porte 443 e 8443.

Per supportare queste sei porte, puoi configurare la regola di forwarding in modo che accetti il traffico su tutte le porte. Con questa strategia, puoi anche configurare la regola o le regole firewall che consentono le connessioni in entrata alle VM di backend in modo che consentano solo determinate porte.

Questa procedura mostra come eliminare la regola di forwarding corrente del bilanciatore del carico e crearne una nuova che accetti il traffico su tutte le porte.

Nota: se provi a modificare la regola di forwarding esistente aggiungendo una nuova porta, potresti riscontrare il seguente errore: Forwarding rule's port range is conflicting with forwarding rule: resource_type: FORWARDING_RULE resource_name: "<EXISTING_FORWARDING_RULE_NAME>"

Per saperne di più su quando utilizzare questa configurazione, consulta Bilanciatori del carico di rete passthrough interni e regole di forwarding con un indirizzo IP comune.

Console

Eliminare la regola di forwarding e crearne una nuova

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

   Vai a Bilanciamento del carico

2. Fai clic sul bilanciatore del carico be-ilb e poi su Modifica.

3. Fai clic su Configurazione frontend.

4. Tieni il puntatore del mouse sulla regola di forwarding 10.1.2.9 e fai clic su Elimina.

5. Fai clic su Aggiungi IP e porta frontend.

6. Nella sezione Nuovi IP e porta frontend, inserisci le seguenti informazioni e fai clic su Fine:

   • Nome: fr-ilb
   • Subnet: lb-subnet
   • IP interno: ip-ilb
   • Porte: Tutte.

7. Verifica che sia presente un segno di spunta blu accanto a Configurazione frontend prima di continuare.

8. Fai clic su Esamina e finalizza e rivedi le impostazioni di configurazione del bilanciatore del carico.

9. Fai clic su Crea.

gcloud

1. Elimina la regola di forwarding esistente, fr-ilb.

   gcloud compute forwarding-rules delete fr-ilb \
       --region=us-west1
   

2. Crea una regola di forwarding sostitutiva, con lo stesso nome, la cui configurazione della porta utilizza la parola chiave ALL. Gli altri parametri della regola di forwardingo rimangono invariati.

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

API

Elimina la regola di forwarding inviando una richiesta DELETE al metodo forwardingRules.delete.

DELETE https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules/fr-ilb

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",
"IPAddress": "10.1.2.99",
"IPProtocol": "TCP",
"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",
"networkTier": "PREMIUM"
}

Testa il traffico su tutte le porte configurate

Connettiti all'istanza VM client e testa le connessioni HTTP e HTTPS.

• Connettiti alla VM client:

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

• Verifica la connettività HTTP su tutte e quattro le porte:

  curl http://10.1.2.99
  curl http://10.1.2.99:8008
  curl http://10.1.2.99:8080
  curl http://10.1.2.99:8088
  

• Testa la connettività HTTPS sulle porte 443 e 8443. Il flag --insecure è obbligatorio perché ogni server Apache nella configurazione di esempio utilizza un certificato autofirmato.

  curl https://10.1.2.99 --insecure
  curl https://10.1.2.99:8443 --insecure
  

• Osserva che le richieste HTTP (su tutte e quattro le porte) e le richieste HTTPS (su entrambe le porte) sono distribuite tra tutte le VM di backend.

Accettare il traffico su più porte utilizzando due regole di forwarding

Quando hai creato la regola di forwarding di questo bilanciatore del carico di esempio, hai configurato le porte 80, 8008, 8080 e 8088. Lo script di avvio che installa Apache lo configura anche per accettare connessioni HTTPS sulle porte 443 e 8443.

Una strategia alternativa alla configurazione di una singola regola di forwarding per accettare il traffico su tutte le porte consiste nel creare più regole di forwarding, ognuna delle quali supporta cinque o meno porte.

Questa procedura mostra come sostituire la regola di forwarding del bilanciatore del carico di esempio con due regole di forwarding, una che gestisce il traffico sulle porte 80, 8008, 8080 e 8088 e l'altra che gestisce il traffico sulle porte 443 e 8443.

Per saperne di più su quando utilizzare questa configurazione, consulta Bilanciatori del carico di rete passthrough interni e regole di forwarding con un indirizzo IP comune.

Console

1. Nella console Google Cloud , vai alla pagina Regole di forwarding.

   Vai a Regole di forwarding

2. Nella colonna Nome, fai clic su fr-ilb e poi su Elimina.

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

   Vai a Bilanciamento del carico

4. Nella colonna Nome, fai clic su be-ilb.

5. Fai clic su Modifica.

6. Fai clic su Configurazione frontend.

7. Fai clic su Aggiungi IP e porta frontend.

8. Nella sezione Nuovi IP e porta frontend, segui questi passaggi:

   1. In Nome, inserisci fr-ilb-http.
   2. In Subnet, seleziona lb-subnet.
   3. In Scopo IP interno, seleziona Condiviso.
   4. Nell'elenco Indirizzo IP, seleziona Crea indirizzo IP, inserisci le seguenti informazioni e fai clic su Prenota:
      • Nome: internal-10-1-2-99
      • Indirizzo IP statico: Scelta manuale
      • Indirizzo IP personalizzato: 10.1.2.99
   5. In Porte, seleziona Multiple e poi in Numeri di porta inserisci 80,8008,8080 e 8088.
   6. Fai clic su Fine.

9. Fai clic su Aggiungi IP e porta frontend.

10. Nella sezione Nuovi IP e porta frontend, segui questi passaggi:

    1. In Nome, inserisci fr-ilb-https.
    2. In Subnet, seleziona lb-subnet.
    3. In Scopo IP interno, seleziona Condiviso.
    4. Nell'elenco Indirizzo IP, seleziona internal-10-1-2-99.
    5. In Porte, seleziona Multiple, quindi in Numeri di porta inserisci 443 e 8443.
    6. Fai clic su Fine.

11. Fai clic su Esamina e finalizza e rivedi le impostazioni di configurazione del bilanciatore del carico.

12. Fai clic su Aggiorna.

gcloud

1. Elimina la regola di forwarding esistente, fr-ilb.

   gcloud compute forwarding-rules delete fr-ilb \
       --region=us-west1
   

2. Crea un indirizzo IP interno statico (riservato) per 10.1.2.99 e imposta il relativo flag --purpose su SHARED_LOADBALANCER_VIP. Il flag --purpose è necessario per consentire a due regole di forwarding interno di utilizzare lo stesso indirizzo IP interno.

   gcloud compute addresses create internal-10-1-2-99 \
       --region=us-west1 \
       --subnet=lb-subnet \
       --addresses=10.1.2.99 \
       --purpose=SHARED_LOADBALANCER_VIP
   

   1. Crea due regole di forwarding sostitutive con i seguenti parametri:

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

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

API

Elimina la regola di forwarding inviando una richiesta DELETE al metodo forwardingRules.delete.

DELETE https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules/fr-ilb

Crea un indirizzo IP interno statico (prenotato) per 10.1.2.99 e imposta il suo scopo su SHARED_LOADBALANCER_VIP effettuando una richiesta POST al metodo addresses.insert.

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

{
"name": "internal-10-1-2-99",
"address": "10.1.2.99",
"prefixLength": 32,
"addressType": INTERNAL,
"purpose": SHARED_LOADBALANCER_VIP,
"subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet"
}

Crea due regole di forwarding inviando due richieste POST al metodo forwardingRules.insert.

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

{
"name": "fr-ilb-http",
"IPAddress": "10.1.2.99",
"IPProtocol": "TCP",
"ports": [
  "80", "8008", "8080",  "8088"
],
"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"
}

{
"name": "fr-ilb-https",
"IPAddress": "10.1.2.99",
"IPProtocol": "TCP",
"ports": [
  "443", "8443"
],
"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"
}

Testare il traffico su più porte configurate

Connettiti all'istanza VM client e testa le connessioni HTTP e HTTPS.

• Connettiti alla VM client:

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

• Verifica la connettività HTTP su tutte e quattro le porte:

  curl http://10.1.2.99
  curl http://10.1.2.99:8008
  curl http://10.1.2.99:8080
  curl http://10.1.2.99:8088
  

• Testa la connettività HTTPS sulle porte 443 e 8443. Il flag --insecure è obbligatorio perché ogni server Apache nella configurazione di esempio utilizza un certificato autofirmato.

  curl https://10.1.2.99 --insecure
  curl https://10.1.2.99:8443 --insecure
  

• Osserva che le richieste HTTP (su tutte e quattro le porte) e le richieste HTTPS (su entrambe le porte) sono distribuite tra tutte le VM di backend.

Utilizzare l'affinità sessione

La configurazione di esempio crea un servizio di backend senzaaffinità sessionee.

Questa procedura mostra come aggiornare il servizio di backend per il bilanciatore del carico di rete passthrough interno di esempio in modo che utilizzi la affinità sessione in base a un hash creato a partire dagli indirizzi IP del client e dall'indirizzo IP della regola di forwarding interno del bilanciatore del carico.

Per i tipi di affinità sessione supportati, vedi Opzioni di affinità sessione.

Nota: per i bilanciatori del carico UDP interni, l'impostazione dell'affinità sessione è supportata nell'interfaccia alla gcloud CLI e nell'API. Non puoi impostare l'affinità di sessione per il traffico UDP utilizzando la Google Cloud console.

Console

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

   Vai a Bilanciamento del carico

2. Fai clic su be-ilb (il nome del servizio di backend che hai creato per questo esempio) e poi su Modifica.

3. Nella pagina Modifica bilanciatore del carico di rete passthrough interno, fai clic su Configurazione backend.

4. Dall'elenco Affinità sessione, seleziona IP client.

5. Fai clic su Aggiorna.

gcloud

Utilizza il seguente comando gcloud per aggiornare il servizio di backend be-ilb, specificando l'affinità sessione IP client:

gcloud compute backend-services update be-ilb \
    --region=us-west1 \
    --session-affinity CLIENT_IP

API

Invia una richiesta PATCH al metodo regionBackendServices/patch.

PATCH https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices/be-ilb

{
"sessionAffinity": "CLIENT_IP"
}

Configura un criterio di monitoraggio delle connessioni

Questa sezione mostra come aggiornare il servizio di backend per modificare la policy di monitoraggio delle connessioni predefinita del bilanciatore del carico.

Un criterio di monitoraggio delle connessioni include le seguenti impostazioni:

• Modalità di monitoraggio
• Persistenza della connessione su backend in stato non integro
• Timeout di inattività

Nota: non puoi utilizzare la console Google Cloud per configurare un criterio di monitoraggio delle connessioni. Utilizza Google Cloud CLI o l'[API REST](/compute/docs/reference/rest/v1/regionBackendServices).

gcloud

Utilizza il seguente comando gcloud compute backend-services per aggiornare la policy di monitoraggio delle connessioni per il servizio di backend:

gcloud compute backend-services update BACKEND_SERVICE \
    --region=REGION \
    --tracking-mode=TRACKING_MODE \
    --connection-persistence-on-unhealthy-backends=CONNECTION_PERSISTENCE_BEHAVIOR \
    --idle-timeout-sec=IDLE_TIMEOUT_VALUE

Sostituisci i segnaposto con valori validi:

• BACKEND_SERVICE: il servizio di backend che stai aggiornando
• REGION: la regione del servizio di backend che stai aggiornando
• TRACKING_MODE: la modalità di monitoraggio della connessione da utilizzare per i pacchetti in entrata; per l'elenco dei valori supportati, vedi Modalità di monitoraggio
• CONNECTION_PERSISTENCE_BEHAVIOR: il comportamento di persistenza della connessione quando i backend non sono integri; per l'elenco dei valori supportati, vedi Persistenza della connessione su backend in stato non integro

• IDLE_TIMEOUT_VALUE: il numero di secondi per cui deve essere mantenuta una voce della tabella di monitoraggio delle connessioni dopo che il bilanciatore del carico elabora l'ultimo pacchetto corrispondente alla voce

  Puoi modificare questa proprietà solo quando il monitoraggio della connessione è inferiore a 5 tuple (ovvero quando l&#39affinità sessionee è configurata su CLIENT_IP o CLIENT_IP_PROTO e la modalità di monitoraggio è PER_SESSION).

  Il valore predefinito è 600 secondi (10 minuti). Il valore massimo configurabile del timeout di inattività è 57.600 secondi (16 ore).

Utilizzare l'affinità a livello di zona

Anteprima

Questo prodotto o questa funzionalità sono soggetti ai "Termini dell'offerta pre-GA" nella sezione 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 saperne di più, consulta le descrizioni della fase di lancio.

Questa sezione mostra come configurare un bilanciatore del carico di rete passthrough interno per abilitare l'affinità zonale sul servizio di backend del bilanciatore del carico. Per impostazione predefinita, l'affinità di zona è disattivata. Per ulteriori informazioni, consulta Affinità zonale per i bilanciatori del carico di rete passthrough interni.

• Utilizza il seguente comando per configurare l'opzione di affinità di zona ZONAL_AFFINITY_STAY_WITHIN_ZONE. Per ulteriori informazioni su come funziona questa opzione, consulta Come funziona ZONAL_AFFINITY_STAY_WITHIN_ZONE.

  gcloud beta compute backend-services update be-ilb \
      --zonal-affinity-spillover=ZONAL_AFFINITY_STAY_WITHIN_ZONE \
      --region=us-west1
  

• Utilizza il seguente comando per configurare l'affinità zonale ZONAL_AFFINITY_SPILL_CROSS_ZONE con il rapporto di overflow 0.0 predefinito. Per ulteriori informazioni su come funziona questa opzione, consulta le sezioni Come funzionano ZONAL_AFFINITY_SPILL_CROSS_ZONE e il rapporto di overflow e Rapporto di overflow pari a zero.

  gcloud beta compute backend-services update be-ilb \
      --zonal-affinity-spillover=ZONAL_AFFINITY_SPILL_CROSS_ZONE \
      --region=us-west1
  

• Utilizza il seguente comando per configurare l'affinità di zona ZONAL_AFFINITY_SPILL_CROSS_ZONE con un rapporto di overflow del 30%. Per saperne di più su come funziona questa opzione, consulta le sezioni Come funzionano ZONAL_AFFINITY_SPILL_CROSS_ZONE e il rapporto di overflow e Rapporto di overflow diverso da zero.

  gcloud beta compute backend-services update be-ilb \
      --zonal-affinity-spillover=ZONAL_AFFINITY_SPILL_CROSS_ZONE \
      --zonal-affinity-spillover-ratio=0.3 \
      --region=us-west1
  

Crea una regola di forwarding in un'altra subnet

Questa procedura crea un secondo indirizzo IP e una seconda regola di forwarding in una subnet diversa per dimostrare che puoi creare più regole di forwarding per un bilanciatore del carico di rete passthrough interno. La regione della regola di forwarding deve corrispondere a quella del servizio di backend.

In base alle regole firewall, i client di qualsiasi subnet nella regione possono contattare l'indirizzo IP del bilanciatore del carico di rete passthrough interno.

Console

Aggiungi la seconda subnet

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

   Vai a Reti VPC

2. Fai clic su Crea rete VPC.

3. Fai clic su lb-network.

4. Nella sezione Subnet, segui questi passaggi:

   1. Fai clic su Aggiungi subnet.
   2. Nella sezione Nuova subnet, inserisci le seguenti informazioni:
      • Nome: second-subnet
      • Regione: us-west1
      • Intervallo di indirizzi IP: 10.5.6.0/24
   3. Fai clic su Aggiungi.

Aggiungere la seconda regola di inoltro

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

   Vai a Bilanciamento del carico

2. Fai clic sul bilanciatore del carico be-ilb e poi su Modifica.

3. Fai clic su Configurazione frontend.

4. Fai clic su Aggiungi IP e porta frontend.

5. Nella sezione Nuovi IP e porta frontend, imposta i seguenti campi e fai clic su Fine:

   • Nome: fr-ilb-2
   • Versione IP: IPv4
   • Subnet: second-subnet
   • IP interno: ip-ilb
   • Porte: 80 e 443

6. Verifica che sia presente un segno di spunta blu accanto a Configurazione frontend prima di continuare.

7. Fai clic su Esamina e finalizza e rivedi le impostazioni di configurazione del bilanciatore del carico.

8. Fai clic su Crea.

gcloud

1. Crea una seconda subnet nella rete lb-network nella regione us-west1:

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

2. Crea una seconda regola di forwarding per le porte 80 e 443. Gli altri parametri per questa regola, inclusi l'indirizzo IP e il servizio di backend, sono gli stessi della regola di forwarding principale, fr-ilb.

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

API

Invia una richiesta POST al metodo subnetworks.insert.

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

{
 "name": "second-subnet",
 "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
 "ipCidrRange": "10.5.6.0/24",
 "privateIpGoogleAccess": false
}

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-2",
"IPAddress": "10.5.6.99",
"IPProtocol": "TCP",
"ports": [
  "80", "443"
],
"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"
}

Testare la nuova regola di forwarding

Connettiti all'istanza VM client e testa le connessioni HTTP e HTTPS agli indirizzi IP.

1. Connettiti alla VM client:

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

2. Verifica la connettività HTTP agli indirizzi IP:

   curl http://10.1.2.99
   curl http://10.5.6.99
   

3. Verifica la connettività HTTPS. L'utilizzo di --insecure è obbligatorio perché la configurazione del server Apache nella configurazione di esempio utilizza certificati autofirmati.

   curl https://10.1.2.99 --insecure
   curl https://10.5.6.99 --insecure
   

4. Osserva che le richieste vengono gestite da tutte le VM di backend, indipendentemente dal protocollo (HTTP o HTTPS) o dall'indirizzo IP utilizzato.

Utilizzare il sottoinsieme del backend

La configurazione di esempio crea un servizio di backend senza sottoinsieme.

Questa procedura mostra come abilitare il sottoinsieme sul servizio di backend per il bilanciatore del carico di rete passthrough interno di esempio, in modo che il deployment possa essere scalato a un numero maggiore di istanze di backend.

Attenzione: l'attivazione del sottoinsieme di backend potrebbe essere temporaneamente interrotta e potrebbe interrompere le connessioni TCP esistenti.

Devi abilitare il sottoinsieme solo se devi supportare più di 250 VM di backend su un singolo bilanciatore del carico.

Nota:questa funzionalità non supporta gli indirizzi IPv6.

Per ulteriori informazioni su questo caso d'uso, consulta la sezione Sottoinsieme del backend.

gcloud

Utilizza il seguente comando gcloud per aggiornare il servizio di backend be-ilb, specificando la policy di sottoinsieme:

gcloud compute backend-services update be-ilb \
    --subsetting-policy=CONSISTENT_HASH_SUBSETTING

API

Invia una richiesta PATCH al metodo regionBackendServices/patch.

PATCH https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices/be-ilb

{
"subsetting":
  {
    "policy": CONSISTENT_HASH_SUBSETTING
  }
}

Crea un bilanciatore del carico per Mirroring pacchetto

Packet Mirroring ti consente di copiare e raccogliere i dati dei pacchetti da istanze specifiche in un VPC. I dati raccolti possono aiutarti a rilevare le minacce alla sicurezza e monitorare le prestazioni delle applicazioni.

Il mirroring pacchetto richiede un bilanciatore del carico di rete passthrough interno per bilanciare il traffico verso un gruppo di istanze di destinazioni raccoglitore. Per creare un bilanciatore del carico di rete passthrough interno per Mirroring pacchetto:

Console

Avvia la configurazione

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

   Vai a Bilanciamento del carico

2. Fai clic su Crea bilanciatore del carico.
3. In Tipo di bilanciatore del carico, seleziona Bilanciatore del carico di rete (TCP/UDP/SSL) e fai clic su Avanti.
4. Per Proxy o passthrough, seleziona Bilanciatore del carico passthrough e fai clic su Avanti.
5. In Pubblico o interno, seleziona Interno e fai clic su Avanti.
6. Fai clic su Configura.

Configurazione di base

1. In Nome bilanciatore del carico, inserisci un nome.
2. Per Regione, seleziona la regione delle istanze VM in cui vuoi eseguire il mirroring dei pacchetti.
3. In Rete, seleziona la rete in cui vuoi eseguire il mirroring dei pacchetti.
4. Fai clic su Configurazione backend.
5. Nella sezione Nuovo backend, seleziona il gruppo di istanze a cui inoltrare i pacchetti in Gruppo di istanze.
6. Nell'elenco Controllo di integrità, seleziona Crea un controllo di integrità, inserisci le seguenti informazioni e fai clic su Salva:
   1. In Name (Nome), inserisci un nome per il controllo di integrità.
   2. In Protocollo, seleziona HTTP.
   3. Per Porta, inserisci 80.
7. Fai clic su Configurazione frontend.
8. Nella sezione Nuovi IP e porta frontend, segui questi passaggi:
   1. In Nome, inserisci un nome.
   2. In Subnet, seleziona una subnet nella stessa regione delle istanze da eseguire il mirroring.
   3. In Porte, seleziona Tutte.
   4. Fai clic su Configurazioni avanzate e seleziona la casella di controllo Abilita questo bilanciatore del carico per il mirroring dei pacchetti.
   5. Fai clic su Fine.
9. Fai clic su Crea.

gcloud

1. Crea un nuovo controllo di integrità HTTP regionale per testare la connettività HTTP a un gruppo di istanze sulla porta 80:

   gcloud compute health-checks create http HEALTH_CHECK_NAME \
       --region=REGION \
       --port=80
   

   Sostituisci quanto segue:

   • HEALTH_CHECK_NAME: il nome del controllo di integrità.
   • REGION: la regione delle istanze VM per cui vuoi eseguire il mirroring dei pacchetti.

2. Crea un servizio di backend per il traffico HTTP:

   gcloud compute backend-services create COLLECTOR_BACKEND_SERVICE \
       --region=REGION \
       --health-checks-region=REGION \
       --health-checks=HEALTH_CHECK_NAME \
       --load-balancing-scheme=internal \
       --protocol=tcp
   

   Sostituisci quanto segue:

   • COLLECTOR_BACKEND_SERVICE: il nome del servizio di backend.
   • REGION: la regione delle istanze VM in cui vuoi eseguire il mirroring dei pacchetti.
   • HEALTH_CHECK_NAME: il nome del controllo di integrità.

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

   gcloud compute backend-services add-backend COLLECTOR_BACKEND_SERVICE \
       --region=REGION \
       --instance-group=INSTANCE_GROUP \
       --instance-group-zone=ZONE
   

   Sostituisci quanto segue:

   • COLLECTOR_BACKEND_SERVICE: il nome del servizio di backend.
   • REGION: la regione del gruppo di istanze.
   • INSTANCE_GROUP: il nome del gruppo di istanze.
   • ZONE: la zona del gruppo di istanze.

4. Crea una regola di forwarding per il servizio di backend:

   gcloud compute forwarding-rules create FORWARDING_RULE_NAME \
       --region=REGION \
       --network=NETWORK \
       --subnet=SUBNET \
       --backend-service=COLLECTOR_BACKEND_SERVICE \
       --load-balancing-scheme=internal \
       --ip-protocol=TCP \
       --ports=all \
       --is-mirroring-collector
   

   Sostituisci quanto segue:

   • FORWARDING_RULE_NAME: il nome della regola di inoltro.
   • REGION: la regione della regola di forwarding.
   • NETWORK: la rete per la regola di forwarding.
   • SUBNET: una subnet nella regione delle VM in cui vuoi eseguire il mirroring dei pacchetti.
   • COLLECTOR_BACKEND_SERVICE: il servizio di backend per questo bilanciatore del carico.

Nota: non puoi utilizzare il protocollo L3_DEFAULT nella regola di forwarding per configurare il mirroring del pacchetto.

Passaggi successivi

• Per informazioni di base importanti, consulta la panoramica del bilanciatore del carico di rete passthrough interno.
• Per informazioni importanti sul failover, consulta Concetti sul failover per i bilanciatori del carico di rete passthrough interni.
• Consulta Bilanciamento del carico interno e nomi DNS per le opzioni di nomi DNS disponibili che il bilanciatore del carico può utilizzare.
• Per i passaggi di configurazione e un esempio di configurazione del failover del bilanciatore del carico di rete passthrough interno, consulta Configurazione del failover per i bilanciatori del carico di rete passthrough interni.
• Per informazioni sulla configurazione di logging e monitoraggio per i bilanciatori del carico di rete passthrough interni, consulta Logging e monitoraggio del bilanciatore del carico di rete passthrough interno.
• Per informazioni sull'accesso ai bilanciatori del carico di rete passthrough interni dalle reti peer connesse alla tua rete VPC, consulta la sezione Bilanciatori del carico di rete passthrough interni e reti connesse.
• Consulta la pagina Risolvere i problemi relativi ai bilanciatori del carico di rete passthrough interni per informazioni su come risolvere i problemi relativi al bilanciatore del carico di rete passthrough interno.
• Pulisci la configurazione del bilanciatore del carico.

Appendice: Introduzione allo script Bash IPv6

Questa sezione fornisce una breve descrizione dei diversi comandi di rete correlati allo script di avvio Bash utilizzato per installare un server TCP IPv6 sulle VM di backend. Non è necessario ripetere questi passaggi. Sono descritti qui solo per fornire contesto e facilitare la comprensione.

1. Mostra tutte le route IPv6.

   ip -6 route show table all
   

   L'output è il seguente:

   fd20:307:120c:2000::/64 via fe80::57:2ff:fe36:ffbe dev ens4 proto ra metric 100 expires 62sec pref medium
   fe80::/64 dev ens4 proto kernel metric 256 pref medium
   default via fe80::57:2ff:fe36:ffbe dev ens4 proto ra metric 100 expires 62sec mtu 1460 pref medium
   local ::1 dev lo table local proto kernel metric 0 pref medium
   local fd20:307:120c:2000:0:b:: dev ens4 table local proto kernel metric 0 pref medium
   local fe80::56:24ff:feb1:59b3 dev ens4 table local proto kernel metric 0 pref medium
   multicast ff00::/8 dev ens4 table local proto kernel metric 256 pref medium
   

   Dall'output del passaggio precedente, identifica quanto segue:

   • Indirizzo IPv6 locale rispetto al collegamento (che inizia con fe80::/10): nell'output di esempio, l'indirizzo locale rispetto al collegamento è fe80::57:2ff:fe36:ffbe. Questo indirizzo link-local viene utilizzato nella route predefinita definita nella tabella di routing 1. Questa route predefinita viene creata nel passaggio 2.
   • Subnet /64: questa subnet viene indicata nella regola di routing basata su policy di origine nel passaggio 3

2. Aggiungi una route predefinita personalizzata nella tabella di routing 1.

   Il seguente comando invia pacchetti al gateway utilizzando l'interfaccia di rete denominata ens4.

   sudo ip route add default via GATEWAY_ADDRESS dev ens4 table 1
   

   Dopo aver eseguito questo comando, viene aggiunto un percorso predefinito a una tabella di routing personalizzata (tabella 1), che punta al gateway fe80::57:2ff:fe36:ffbe tramite l'interfaccia ens4.

   Se esegui di nuovo il comando ip -6 route show table all, l'output è il seguente:

   default via fe80::57:2ff:fe36:ffbe dev ens4 table 1 metric 1024 pref medium
   fd20:307:120c:2000::/64 via fe80::57:2ff:fe36:ffbe dev ens4 proto ra metric 100 expires 89sec pref medium
   fe80::/64 dev ens4 proto kernel metric 256 pref medium
   default via fe80::57:2ff:fe36:ffbe dev ens4 proto ra metric 100 expires 89sec mtu 1460 pref medium
   local ::1 dev lo table local proto kernel metric 0 pref medium
   local fd20:307:120c:2000:0:1::/96 dev ens4 table local proto 66 metric 1024 pref medium
   local fd20:307:120c:2000:0:b:: dev ens4 table local proto kernel metric 0 pref medium
   local fe80::56:24ff:feb1:59b3 dev ens4 table local proto kernel metric 0 pref medium
   multicast ff00::/8 dev ens4 table local proto kernel metric 256 pref medium
   

3. Aggiungi una regola di routing basata sull'origine.

   Il seguente comando aggiunge una regola per instradare tutti i pacchetti in uscita provenienti da una subnet specificata. Se l'indirizzo di origine corrisponde alla subnet, il sistema utilizza la route predefinita definita nella tabella 1 per inoltrare il traffico.

   sudo ip -6 rule add from SUBNET_RANGE table 1
   

4. Per visualizzare l'elenco delle regole di routing delle policy, esegui questo comando.

   ip -6 rule show
   

   L'output è il seguente:

   0:      from all lookup local
   32765:  from fd20:307:120c:2000::/64 lookup 1
   32766:  from all lookup main
   

   La riga con from fd20:... lookup 1 è la regola che hai aggiunto, che indica al kernel di utilizzare la tabella di routing 1 per il traffico proveniente da quella subnet.

5. Consenti al server di eseguire il binding a un indirizzo IPv6 non locale, ovvero l'IP virtuale del bilanciatore del carico.

   sudo sysctl -w net.ipv6.ip_nonlocal_bind=1