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

Console

Per supportare il traffico IPv4 e IPv6, segui questi passaggi:

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

   Vai a Reti VPC

2. Fai clic su Crea rete VPC.

3. In Nome, inserisci lb-network.

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

   1. In Intervallo IPv6 interno ULA rete VPC, seleziona Abilitato.
   2. Per Assegna 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:

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

7. Fai clic su Fine.

8. Fai clic su Crea.

Per supportare il traffico IPv4, segui questa procedura:

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

   Vai a Reti VPC

2. Fai clic su Crea rete VPC.

3. In Nome, inserisci lb-network.

4. Nella sezione Subnet:

   • Imposta Modalità di creazione subnet su Personalizzata.
   • Nella sezione Nuova subnet, inserisci le informazioni seguenti:
     • Nome: lb-subnet
     • Regione: us-west1
     • Tipo di stack IP: IPv4 (stack singolo)
     • Intervallo di indirizzi IP: 10.1.2.0/24
   • Fai clic su Fine.

5. Fai clic su Crea.

gcloud

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

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

   Per configurare intervalli IPv6 interni su qualsiasi subnet in 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.

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

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

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

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

Per solo traffico IPv4, utilizza i seguenti comandi:

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

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

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

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

API

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

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

   Per configurare intervalli IPv6 interni in qualsiasi subnet in 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 interne.

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

   Sostituisci quanto segue:

   • PROJECT_ID: l'ID del progetto in cui viene creata la rete VPC.
   • MTU: l'unità massima di trasmissione della rete. La MTU può essere 1460 (predefinita) o 1500. Consulta la panoramica delle unità di trasmissione massime prima di impostare la MTU su 1500.

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

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

Per solo il traffico IPv4, segui la procedura riportata di seguito:

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

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

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

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

Console

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

   Vai a Criteri firewall

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

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

3. Fai clic su Crea.

4. Per consentire le connessioni SSH in entrata:

   • Fai clic su Crea regola firewall.
   • Nome: fw-allow-ssh
   • Rete: lb-network
   • Priorità: 1000
   • Direzione del traffico: In entrata
   • Azione in caso di corrispondenza: Consenti
   • Target: Tag di destinazione specificati
   • Tag di destinazione: allow-ssh
   • Filtro di origine: Intervalli IPv4
   • Intervalli IPv4 di origine: 0.0.0.0/0
   • Protocolli e porte: scegli Protocolli e porte specificati, poi digita tcp:22.

5. Fai clic su Crea.

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

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

7. Fai clic su Crea.

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

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

9. Fai clic su Crea.

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

    • Fai clic su Crea regola firewall.
    • Nome: fw-allow-health-check
    • Rete: lb-network
    • Priorità: 1000
    • Direzione del traffico: In entrata
    • Azione in caso di corrispondenza: Consenti
    • Target: Tag di destinazione specificati
    • Tag di destinazione: allow-health-check
    • Filtro di origine: Intervalli IPv4
    • Intervalli IPv4 di origine: 130.211.0.0/22 e 35.191.0.0/16
    • Protocolli e porte: Consenti tutto

11. Fai clic su Crea.

gcloud

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

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

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

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

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

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

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

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

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

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

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

API

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

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

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

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

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

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

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

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

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

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

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

Console

Per supportare il traffico IPv4 e IPv6, segui questi passaggi:

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

   Vai a Modelli di istanza

   1. Fai clic su Crea modello istanza.
   2. In Nome, inserisci vm-a1.
   3. Assicurati che il disco di avvio sia impostato su un'immagine Debian, ad esempio Debian GNU/Linux 10 (buster). Queste istruzioni utilizzano comandi disponibili solo su Debian, come apt-get.
   4. Espandi la sezione Opzioni avanzate.

   5. Espandi la sezione Gestione, quindi copia lo script seguente nel campo Script di avvio. Lo script di avvio configura inoltre il server Apache per l'ascolto sulla porta 8080 anziché sulla porta 80.

      #! /bin/bash
      apt-get update
      apt-get install apache2 -y
      a2ensite default-ssl
      a2enmod ssl
      vm_hostname="$(curl -H "Metadata-Flavor:Google" \
      http://metadata.google.internal/computeMetadata/v1/instance/name)"
      echo "Page served from: $vm_hostname" | \
      tee /var/www/html/index.html
      sed -ire 's/^Listen 80$/Listen 8080/g' /etc/apache2/ports.conf
      systemctl restart apache2
      

   6. Espandi la sezione Networking, quindi specifica quanto segue:

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

   7. Fai clic su Crea.

Per supportare il traffico IPv4, segui questa procedura:

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

   Vai a Modelli di istanza

2. Fai clic su Crea modello istanza.

   1. In Nome, inserisci vm-a1.
   2. Assicurati che il disco di avvio sia impostato su un'immagine Debian, ad esempio Debian GNU/Linux 10 (buster). Queste istruzioni utilizzano comandi disponibili solo su Debian, come apt-get.
   3. Espandi la sezione Opzioni avanzate.

   4. Espandi la sezione Gestione, quindi copia lo script seguente nel campo Script di avvio. Lo script di avvio configura inoltre il server Apache per l'ascolto sulla porta 8080 anziché sulla porta 80.

      #! /bin/bash
      apt-get update
      apt-get install apache2 -y
      a2ensite default-ssl
      a2enmod ssl
      vm_hostname="$(curl -H "Metadata-Flavor:Google" \
      http://metadata.google.internal/computeMetadata/v1/instance/name)"
      echo "Page served from: $vm_hostname" | \
      tee /var/www/html/index.html
      sed -ire 's/^Listen 80$/Listen 8080/g' /etc/apache2/ports.conf
      systemctl restart apache2
      

   5. Espandi la sezione Networking, quindi specifica quanto segue:

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

   6. Fai clic su Crea.

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

   Vai a Gruppi di istanze

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

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

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

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

   9. Fai clic su Crea.

gcloud

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

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

   Lo script di avvio configura inoltre il server Apache per l'ascolto sulla porta 8080 anziché sulla porta 80.

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

   gcloud compute instance-templates create vm-a1 \
       --region=us-west1 \
       --network=lb-network \
       --subnet=lb-subnet \
       --ipv6-network-tier=PREMIUM \
       --stack-type=IPv4_IPv6 \
       --tags=allow-ssh \
       --image-family=debian-10 \
       --image-project=debian-cloud \
       --metadata=startup-script='#! /bin/bash
         apt-get update
         apt-get install apache2 -y
         a2ensite default-ssl
         a2enmod ssl
         vm_hostname="$(curl -H "Metadata-Flavor:Google" \
         http://metadata.google.internal/computeMetadata/v1/instance/name)"
         echo "Page served from: $vm_hostname" | \
         tee /var/www/html/index.html
         sed -ire "s/^Listen 80$/Listen 8080/g" /etc/apache2/ports.conf
         systemctl restart apache2'
   

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

   gcloud compute instance-templates create vm-a1 \
       --region=us-west1 \
       --network=lb-network \
       --subnet=lb-subnet \
       --tags=allow-ssh \
       --image-family=debian-10 \
       --image-project=debian-cloud \
       --metadata=startup-script='#! /bin/bash
         apt-get update
         apt-get install apache2 -y
         a2ensite default-ssl
         a2enmod ssl
         vm_hostname="$(curl -H "Metadata-Flavor:Google" \
         http://metadata.google.internal/computeMetadata/v1/instance/name)"
         echo "Page served from: $vm_hostname" | \
         tee /var/www/html/index.html
         sed -ire "s/^Listen 80$/Listen 8080/g" /etc/apache2/ports.conf
         systemctl restart apache2'
   

2. Crea un gruppo di istanze gestite nella zona con il comando gcloud compute instance-groups managed create.

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

api

Per gestire il traffico IPv4 e IPv6, segui questi passaggi:

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

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

Per gestire il traffico IPv4, segui la procedura riportata di seguito.

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

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

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

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

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

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

Console

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

   Vai a Istanze VM

2. Fai clic su Crea istanza.

3. Imposta il campo Nome su vm-client-ipv6.

4. Imposta Zona su us-west1-a.

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

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

6. Fai clic su Crea.

gcloud

La VM client può trovarsi in qualsiasi zona nella stessa regione del bilanciatore del carico e può utilizzare qualsiasi subnet in 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-ipv6 \
    --zone=us-west1-a \
    --image-family=debian-10 \
    --image-project=debian-cloud \
    --stack-type=IPV4_IPV6 \
    --tags=allow-ssh \
    --subnet=lb-subnet

api

Invia una richiesta POST al metodo instances.insert.

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

{
 "name": "vm-client-ipv6",
 "tags": {
   "items": [
     "allow-ssh"
   ]
 },
 "machineType": "http://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/machineTypes/e2-standard-2",
 "canIpForward": false,
 "networkInterfaces": [
   {
     "stackType": "IPV4_IPV6",
     "network": "http://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
     "subnetwork": "http://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 Istanze VM.

   Vai a Istanze VM

2. Fai clic su Crea istanza.

3. In Nome, inserisci vm-client.

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

5. Espandi la sezione Opzioni avanzate.

6. Espandi Networking, quindi configura i seguenti campi:

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

7. Fai clic su Crea.

gcloud

La VM client può trovarsi in qualsiasi zona nella stessa regione del bilanciatore del carico e può utilizzare qualsiasi subnet in 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-10 \
    --image-project=debian-cloud \
    --tags=allow-ssh \
    --subnet=lb-subnet

API

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

 POST http://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instances
 {
    "name": "vm-client",
    "tags": {
      "items": [
        "allow-ssh"
      ]
  },
    "machineType": "http://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/machineTypes/e2-standard-2",
    "canIpForward": false,
    "networkInterfaces": [
      {
        "network": "http://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
        "subnetwork": "http://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
  }
  

gcloud

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

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

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

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

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

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

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

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

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

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

API

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

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

2. Crea il servizio di backend a livello di regione effettuando una richiesta POST al metodo regionBackendServices.insert:

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

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

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

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

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

gcloud:IPv6

1. Connettiti all'istanza VM client.

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

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

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

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

   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:

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

gcloud:IPv4

1. Connettiti all'istanza VM client.

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

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

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

3. Invia una richiesta web al bilanciatore del carico utilizzando curl per contattare il relativo indirizzo IP. Ripeti la richiesta in modo da vedere che le risposte provengono da VM di backend diverse. 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. Il formato delle risposte previste è: Page served from: vm-a1.

   curl http://10.1.2.99
   

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

   curl http://10.1.2.99:80
   

gcloud:IPv6

1. Connettiti all'istanza VM client.

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

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

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

   ping6 IPV6_ADDRESS
   

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

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

   L'output è simile al seguente:

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

gcloud:IPv4

1. Connettiti all'istanza VM client.

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

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

   ping 10.1.2.99
   

   L'output è il seguente:

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

gcloud

Usa il comando gcloud compute addresses create:

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

API

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

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

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

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

gcloud

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

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

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

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

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

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

API

1. Crea il servizio di backend a livello di regione inviando una richiesta POST al metodo regionBackendServices.insert. Sostituisci PROJECT_ID con l'ID del tuo progetto Google Cloud.

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

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

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

gcloud

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

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

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

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

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

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

API

1. Crea il servizio di backend a livello di regione inviando una richiesta POST al metodo regionBackendServices.insert. Sostituisci PROJECT_ID con l'ID del tuo progetto Google Cloud.

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

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

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

gcloud

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

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

API

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

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

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