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

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:

   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
}

Console

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

   Vai a Policy del 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: allow
   • 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: allow
   • 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, la casella di controllo TCP e inserisci 22 in Porte.

5. Fai clic su Crea.

6. Per consentire i controlli di integrità di 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: allow
   • 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à di Google Cloud.

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

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
}

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. In Regione, seleziona us-west1 e scegli una Zona come indicato nel passaggio 2.

6. Nella sezione Disco di avvio, assicurati che sia selezionata l'opzione Debian GNU/Linux 12 (bookworm) per le opzioni del disco di avvio. 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: Ephemeral (automatic)
      • Indirizzo IPv4 esterno: Ephemeral

9. Fai clic su Gestione e, nel campo Script di avvio, inserisci il seguente script. 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.

Creare 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 gestite.

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 quattro volte il seguente comando, 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 il valore DEBIAN_IMAGE_NAME corrente eseguendo il seguente comando gcloud:

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

Crea quattro VM di backend inviando 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"
   }
 ]
}

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 del 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 il 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:
   1. In Nome, inserisci fr-ilb.
   2. In Subnet, seleziona lb-subnet.
   3. Nella sezione Finalità dell'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:Scegli per me
      • Indirizzo IP personalizzato: 10.1.2.99
   4. In Porte, seleziona Più porte e 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. Rivedi le impostazioni di configurazione del bilanciatore del carico.
3. (Facoltativo) Fai clic su Codice equivalente per visualizzare la richiesta dell'API REST che verrà utilizzata per creare il bilanciatore del carico.
4. Fai clic su Crea.

gcloud

1. Crea un nuovo controllo di integrità HTTP a livello di regione per verificare 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"
}

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 sottorete della regione. In questo esempio, il client si trova nella zona us-west1-a e utilizza la stessa sottorete delle VM di backend.

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

API

Invia una richiesta POST al metodo instances.insert.

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
}

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 i seguenti passaggi:

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

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 intervalli IPv6 interni su qualsiasi subnet di questa rete, utilizza il flag --enable-ula-internal-ipv6. Questa opzione assegna un prefisso ULA /48 all'interno dell'intervallo fd20::/20 utilizzato da Google Cloud per gli intervalli di 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 intervalli IPv6 interni su qualsiasi subnet di questa rete, imposta enableUlaInternalIpv6 su true. Questa opzione assegna un intervallo /48 all'interno dell'intervallo fd20::/20 utilizzato da Google per gli intervalli di subnet IPv6 interni. Se vuoi selezionare l'intervallo IPv6 /48 da assegnare, 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. Esamina 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 ulteriori informazioni, consulta la modalità di routing dinamico.

  Per ulteriori informazioni, 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
 }
 

Console

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

   Vai a Policy del 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: allow
   • 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: allow
   • Destinazioni: Tutte le istanze nella rete
   • Filtro di origine: intervalli IPv6
   • Intervalli IPv6 di origine: IPV6_ADDRESS assegnati 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: allow
   • 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, la casella di controllo TCP e inserisci 22 in Porte.

7. Fai clic su Crea.

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

   • Nome: fw-allow-health-check-ipv6
   • Rete: lb-network-dual-stack
   • Priorità: 1000
   • Direzione del traffico: in entrata
   • Azione in caso di corrispondenza: allow
   • 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à di 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: allow
    • 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à IPv6 di Google 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à di 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
   }
   

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. In Regione seleziona us-west1 e scegli una Zona come indicato nel passaggio 2.

6. Nella sezione Disco di avvio, assicurati che sia selezionata l'opzione Debian GNU/Linux 12 (bookworm) per le opzioni del disco di avvio. 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: Ephemeral (automatic)
      • Indirizzo IPv4 esterno: Ephemeral

   3. Fai clic su Gestione e, nel campo Script di avvio, inserisci il seguente script. 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 gestite.

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-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 il valore corrente di DEBIAN_IMAGE_NAME eseguendo il seguente comando gcloud:

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

Crea quattro VM di backend inviando 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"
   }
 ]
}

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 del 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 il 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 accanto a Configurazione backend sia visualizzato un segno di spunta blu.

Configurazione frontend

1. Fai clic su Configurazione frontend. Nella sezione Nuovi IP e porta frontend:
   1. In Nome, inserisci fr-ilb-ipv6.
   2. Per gestire il traffico IPv6:
      1. Per 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 Più porte e nel campo Numero porta inserisci 80,8008,8080,8088.
      4. Fai clic su Fine.
   3. Per gestire il traffico IPv4:
      1. Fai clic su Aggiungi IP e porta frontend.
      2. In Nome, inserisci fr-ilb.
      3. In Subnet, seleziona lb-subnet.
      4. Nella sezione Finalità dell'IP interno, nell'elenco Indirizzo IP, seleziona Crea indirizzo IP, inserisci le seguenti informazioni e poi fai clic su Prenota.
         • Nome: ip-ilb
         • Versione IP: IPv4
         • Indirizzo IP statico:Scegli per me
         • Indirizzo IP personalizzato: 10.1.2.99
      5. In Porte, seleziona Più porte e 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 a livello di regione per verificare 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 inoltro 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"
}

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: Ephemeral (automatic)
      • IP esterno: Ephemeral
   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 sottorete della regione. In questo esempio, il client si trova nella zona us-west1-a e utilizza la stessa sottorete delle VM di backend.

gcloud compute instances create vm-client \
    --zone=us-west1-a \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --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
}

Console

Modifica la regola di inoltro 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 è denominato be-ilb.

3. Fai clic su Configurazione frontend.

4. Fai clic su Modifica edit.

5. In 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 per una regola di forwarding è abilitato l'accesso globale. 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
}

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 sottorete della regione. In questo esempio, il client si trova nella zona europe-west1-b e utilizza la stessa sottorete 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
}

Console

Modello di istanza

1. Nella console Google Cloud, vai alla pagina Modelli 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 sia selezionata l'opzione Debian GNU/Linux 12 (bookworm) per le opzioni del disco di avvio. 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, 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 Regione su us-west1.

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

6. (Facoltativo) Configura la scalabilità automatica. Non puoi eseguire la scalabilità automatica del 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 Numero minimo di istanze su 1 e 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, da utilizzare per il modello di immagine.

   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. Scollega i due gruppi di istanze non gestite (a livello di zona) 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
   

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 editModifica.

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 a livello di regione , esegui il seguente comando per ogni istanza per determinarne la zona. Sostituisci [SERVER-VM] con il nome della VM da cercare.

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

2. Ripeti il passaggio seguente 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

Invia una richiesta POST al metodo instances.deleteAccessConfig per ogni VM di backend, sostituendovm-a1 con il nome della VM e 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

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 sopra la regola di forwarding 10.1.2.9 e fai clic su deleteElimina.

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 per la regola di forwarding 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"
}

Console

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

   Vai a Regole di inoltro

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:

   1. In Nome, inserisci fr-ilb-http.
   2. In Subnet, seleziona lb-subnet.
   3. Per 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 Più porte e 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:

    1. In Nome, inserisci fr-ilb-https.
    2. In Subnet, seleziona lb-subnet.
    3. Per Scopo IP interno, seleziona Condiviso.
    4. Nell'elenco Indirizzo IP, seleziona internal-10-1-2-99.
    5. In Porte, seleziona Più porte e 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 (prenotato) per 10.1.2.99 e imposta il relativo flag --purpose su SHARED_LOADBALANCER_VIP. Il flag --purpose è obbligatorio affinché due regole di inoltro interno possano 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 inoltro 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 impostane lo scopo su SHARED_LOADBALANCER_VIP inviando 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 inoltro 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"
}

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. Nell'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 del 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"
}

gcloud

Utilizza il seguente comando gcloud compute backend-services per aggiornare il criterio 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, consulta Modalità di monitoraggio
• CONNECTION_PERSISTENCE_BEHAVIOR: il comportamento della persistenza della connessione quando i backend non sono integri. Per l'elenco dei valori supportati, consulta 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 ha elaborato l'ultimo pacchetto corrispondente alla voce

  Puoi modificare questa proprietà solo quando il monitoraggio delle connessioni è inferiore a 5 tuple (ovvero quando l'affinità sessione è 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 del tempo di attesa inattivo configurabile è 57.600 secondi (16 ore).

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:

   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 di 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"
}

gcloud

Utilizza il seguente comando gcloud per aggiornare il servizio di backend be-ilb, specificando il criterio 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
  }
}

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, in Gruppo di istanze, seleziona il gruppo di istanze a cui inoltrare i pacchetti.
6. Nell'elenco Controllo di integrità, seleziona Crea un controllo di integrità, inserisci le seguenti informazioni e fai clic su Salva:
   1. In Nome, inserisci un nome per il controllo di integrità.
   2. In Protocollo, seleziona HTTP.
   3. In Porta, inserisci 80.
7. Fai clic su Configurazione frontend.
8. Nella sezione Nuovi IP e porta frontend:
   1. In Nome, inserisci un nome.
   2. In Subnet, seleziona una sottorete 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 verificare 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 le quali 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 per la regola di forwarding.
   • NETWORK: la rete per la regola di forwarding.
   • SUBNET: una sottorete nella regione delle VM dove vuoi eseguire il mirroring dei pacchetti.
   • COLLECTOR_BACKEND_SERVICE: il servizio di backend per questo bilanciatore del carico.