Configura il failover per i bilanciatori del carico di rete passthrough interni

Questa guida utilizza un esempio per insegnare come configurare il failover per un bilanciatore del carico di rete passthrough interno di Google Cloud. Prima di seguire questa guida, acquisisci familiarità con i seguenti argomenti:

• Concetti sul bilanciatore del carico di rete passthrough interno
• Concetti sul failover per i bilanciatori del carico di rete passthrough interni
• Panoramica delle regole firewall
• Concetti sul controllo di integrità

Autorizzazioni

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

Attività	Ruolo richiesto
Crea reti, subnet e componenti del bilanciatore del carico	Amministratore rete
Aggiungi e rimuovi regole firewall	Amministratore sicurezza
Creare istanze	Amministratore istanze Compute

Per ulteriori informazioni, consulta le seguenti guide:

• Controllo dell'accesso
• Condizioni IAM

Configurazione

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

1. Una rete VPC di esempio con subnet personalizzate
2. Regole firewall che consentono le connessioni in entrata alle VM di backend
3. VM di backend:
   • Un backend principale in un gruppo di istanze non gestite nella zona us-west1-a
   • Un backend di failover in un gruppo di istanze non gestite nella zona us-west1-c
4. Una VM client per testare le connessioni e osservare il comportamento di failover
5. I seguenti componenti del bilanciatore del carico di rete passthrough interno:
   • Un controllo di integrità per il servizio di backend
   • Un servizio di backend interno nella regione us-west1 per gestire la distribuzione della connessione tra le VM di backend
   • Una regola di forwarding interno e un indirizzo IP interno per il frontend del bilanciatore del carico

L'architettura di questo esempio è la seguente:

Esempio di failover semplice per un bilanciatore del carico di rete passthrough interno (fai clic per ingrandire).

Nota: in questo esempio, i gruppi di istanze non gestite vengono utilizzati sia per i backend primari che per quelli di failover. Per ulteriori informazioni, consulta la pagina relativa ai gruppi di istanze supportati.

Configurazione di rete, regione e subnet

Questo esempio utilizza la seguente rete VPC, regione e subnet:

• Rete: la rete è una rete VPC in modalità personalizzata denominata lb-network.

• Regione: la regione è us-west1.

• Subnet: la subnet lb-subnet utilizza l'intervallo IP 10.1.2.0/24.

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

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

Console

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

   Vai a Reti VPC

2. Fai clic su Crea rete VPC.

3. Inserisci un Nome pari a 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
     • Intervallo di indirizzi IP: 10.1.2.0/24
     • 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. Crea una subnet nella rete lb-network nella regione us-west1:

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

API

Effettua 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
}

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

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

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

Configurazione delle regole del firewall

In questo esempio vengono utilizzate le seguenti regole firewall:

• fw-allow-lb-subnet: una regola in entrata, applicabile a tutte le destinazioni nella rete VPC, che consente il traffico da origini nell'intervallo 10.1.2.0/24. Questa regola consente il traffico in entrata da qualsiasi origine all'interno di lb-subnet verso le istanze (VM) con bilanciamento del carico.

• fw-allow-ssh: una regola in entrata applicata alle istanze sottoposte a bilanciamento del carico, che consente la connettività SSH in entrata sulla porta TCP 22 da qualsiasi indirizzo. Puoi scegliere un intervallo IP di origine più restrittivo per questa regola. Ad esempio, puoi specificare gli intervalli IP dei sistemi da cui prevedi di avviare sessioni SSH. Questo esempio utilizza il tag di destinazione allow-ssh per identificare le VM a cui si applica la regola firewall.

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

Senza queste regole firewall, la regola predefinita nega il traffico in entrata blocca il traffico in entrata verso le istanze di backend.

Nota: devi creare una regola firewall per consentire i controlli di integrità dagli intervalli IP dei sistemi probe Google Cloud. Consulta gli intervalli IP del probe per ulteriori informazioni.

Console

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

   Vai a Criteri firewall

2. Fai clic su Crea regola firewall e inserisci le seguenti informazioni per creare la regola e consentire il traffico delle subnet:

   • Nome: fw-allow-lb-subnet
   • Rete: lb-network
   • Priorità: 1000
   • Direzione del traffico: in entrata
   • Azione in caso di corrispondenza: consenti
   • Destinazioni: Tutte le istanze nella rete
   • Filtro di origine: intervalli IPv4
   • Intervalli IPv4 di origine: 10.1.2.0/24
   • Protocolli e porte: Consenti tutto

3. Fai clic su Crea.

4. Fai di nuovo clic su Crea regola firewall per creare la regola che consenta le connessioni SSH in entrata:

   • Nome: fw-allow-ssh
   • Rete: lb-network
   • Priorità: 1000
   • Direzione del traffico: in entrata
   • Azione in caso di corrispondenza: consenti
   • Target: Tag di destinazione specificati
   • Tag di destinazione: allow-ssh
   • Filtro di origine: intervalli IPv4
   • Intervalli IPv4 di origine: 0.0.0.0/0
   • Protocolli e porte: scegli Protocolli e porte specificati, quindi digita tcp:22

5. Fai clic su Crea.

6. Fai clic su Crea regola firewall una terza volta per creare la regola e consentire i controlli di integrità di Google Cloud:

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

7. Fai clic su Crea.

gcloud

1. Crea la regola firewall fw-allow-lb-subnet per consentire la comunicazione con la subnet:

   gcloud compute firewall-rules create fw-allow-lb-subnet \
       --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 con 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. 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-subnet effettuando una richiesta POST al metodo firewalls.insert. Sostituisci PROJECT_ID con l'ID del tuo progetto Google Cloud.

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

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

Crea la regola firewall fw-allow-ssh effettuando una richiesta POST al metodo firewalls.insert. Sostituisci PROJECT_ID con l'ID del tuo progetto Google Cloud.

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 effettuando una richiesta POST al metodo firewalls.insert. Sostituisci PROJECT_ID con l'ID del tuo progetto Google Cloud.

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
}

Creazione di VM e gruppi di istanze di backend

In questo passaggio, creerai le VM di backend e i gruppi di istanze non gestite:

• Il gruppo di istanze ig-a in us-west1-a è un backend principale con due VM:
  • vm-a1
  • vm-a2
• Il gruppo di istanze ig-c in us-west1-c è un backend di failover con due VM:
  • vm-c1
  • vm-c2

I backend primari e di failover sono posizionati in zone distinte per garantire chiarezza le istruzioni e gestire il failover nel caso in cui una zona non sia disponibile.

Ogni VM principale e di backup è configurata per eseguire un server web Apache sulle porte TCP 80 e 443. A ogni VM viene assegnato un indirizzo IP interno in lb-subnet per l'accesso client e un indirizzo IP esterno (pubblico) temporaneo per l'accesso SSH. Per informazioni sulla rimozione degli indirizzi IP esterni, consulta Rimozione degli indirizzi IP esterni dalle VM di backend.

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

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

Per semplicità di apprendimento, tutte le VM primarie e di backup eseguono Debian GNU/Linux 10.

Console

Crea VM di backend

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

   Vai a Istanze VM

2. Ripeti i passaggi seguenti per creare quattro VM, utilizzando le seguenti combinazioni di nome e zona.

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

3. Fai clic su Crea istanza.

4. Imposta il Nome come indicato nel passaggio 2.

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

6. Nella sezione Disco di avvio, assicurati che l'immagine selezionata sia Debian GNU/Linux 10 (buster). Fai clic su Scegli per cambiare l'immagine, se necessario.

7. Fai clic su Opzioni avanzate.

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

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

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

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

10. Fai clic su Crea.

Crea gruppi di istanze

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

   Vai a Gruppi di istanze

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

   • Gruppo di istanze: ig-a, zona: us-west1-a, VM: vm-a1 e vm-a2
   • 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, poi scegli una Zona come indicato nel passaggio 2.

7. In Rete, inserisci lb-network.

8. In Subnet, inserisci lb-subnet.

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

10. Fai clic su Crea.

gcloud

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

   • VM_NAME di vm-a1 e ZONE di us-west1-a
   • VM_NAME di vm-a2 e ZONE di us-west1-a
   • VM_NAME di vm-c1 e ZONE di us-west1-c
   • VM_NAME di vm-c2 e ZONE di us-west1-c

   gcloud compute instances create VM_NAME \
       --zone=ZONE \
       --image-family=debian-10 \
       --image-project=debian-cloud \
       --tags=allow-ssh,allow-health-check \
       --subnet=lb-subnet \
       --metadata=startup-script='#! /bin/bash
         apt-get update
         apt-get install apache2 -y
         a2ensite default-ssl
         a2enmod ssl
         vm_hostname="$(curl -H "Metadata-Flavor:Google" \
         http://metadata.google.internal/computeMetadata/v1/instance/name)"
         echo "Page served from: $vm_hostname" | \
         tee /var/www/html/index.html
         systemctl restart apache2'
   

2. Crea 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

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

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

• VM_NAME di vm-a1 e ZONE di us-west1-a
• VM_NAME di vm-a2 e ZONE di us-west1-a
• VM_NAME di vm-c1 e ZONE di us-west1-c
• VM_NAME di vm-c2 e ZONE di us-west1-c

Sostituisci quanto segue:

• PROJECT_ID: il tuo ID progetto
• ZONE: la zona dell'istanza

• DEBIAN_IMAGE_NAME: il nome dell'immagine Debian dell'istanza. L'attuale DEBIAN_IMAGE_NAME può essere ottenuto eseguendo il seguente comando gcloud:

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

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\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\nsystemctl restart apache2"
     }
   ]
 },
 "scheduling": {
   "preemptible": false
 },
 "deletionProtection": false
}

Crea due gruppi di istanze inviando una richiesta POST al metodo instanceGroups.insert. Sostituisci PROJECT_ID con l'ID del tuo progetto Google Cloud.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/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 ciascun gruppo di istanze inviando una richiesta POST al metodo instanceGroups.addInstances. Sostituisci PROJECT_ID con l'ID del tuo progetto Google Cloud.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/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"
   }
 ]
}

Creazione di una VM client

In questo esempio viene creata una VM client (vm-client) nella stessa regione del bilanciatore del carico. Il client viene utilizzato per dimostrare il funzionamento del failover.

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.

4. Imposta Zona su us-west1-a.

5. Fai clic su Opzioni avanzate.

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

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 utilizzata dalle VM principali e di backup.

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

Fai una richiesta POST al metodo instances.insert.

Sostituisci quanto segue:

• PROJECT_ID: il tuo ID progetto

• DEBIAN_IMAGE_NAME: il nome dell'immagine Debian dell'istanza. L'attuale DEBIAN_IMAGE_NAME può essere ottenuto eseguendo il seguente comando gcloud:

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

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
}

Configurazione dei componenti del bilanciatore del carico

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

• Controllo di integrità: in questo esempio viene utilizzato un controllo di integrità HTTP che verifica semplicemente la risposta di una risposta 200 (OK) HTTP. Per ulteriori informazioni, consulta la sezione relativa ai controlli di integrità della panoramica sul bilanciatore del carico di rete passthrough interno.

• Servizio di backend: poiché l'esempio trasmette il traffico HTTP attraverso il bilanciatore del carico, la configurazione specifica TCP, non UDP. Per illustrare il failover, questo servizio di backend ha un rapporto di failover 0.75.

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

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

Console

Avvia la configurazione

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

   Vai a Bilanciamento del carico

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

Configurazione di base

1. Imposta il campo Nome su be-ilb.
2. Imposta Regione su us-west1.
3. Imposta Rete su lb-network.
4. Fai clic su Configurazione backend e apporta le seguenti modifiche:
   1. In Backend, nella sezione Nuovo elemento, seleziona il gruppo di istanze ig-a. Assicurati che l'opzione Usa questo gruppo di istanze come gruppo di failover per il backup non sia selezionata. Fai clic su Fine.
   2. Fai clic su Aggiungi backend. Nella sezione Nuovo elemento visualizzata, seleziona il gruppo di istanze ig-c. Seleziona Utilizza questo gruppo di istanze come gruppo di failover per il backup. Fai clic su Fine.
   3. In Controllo di integrità, scegli Crea un altro controllo di integrità, inserisci le seguenti informazioni e fai clic su Salva e continua:
      • Nome: hc-http-80
      • Protocollo: HTTP
      • Porta: 80
      • Protocollo proxy: NONE
      • Percorso di 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à a livello di regione, utilizza gcloud o l'API.
   4. Fai clic su Configurazioni avanzate. Nella sezione Criterio di failover, configura quanto segue:
      • Rapporto di failover: 0.75
      • Seleziona Abilita lo svuotamento della connessione al failover.
   5. Verifica che sia presente un segno di spunta blu accanto a Configurazione backend prima di continuare. In caso contrario, rivedi questo passaggio.
5. Fai clic su Configurazione frontend. Nella sezione Nuovo IP e nuova porta frontend, apporta le seguenti modifiche:
   1. Nome: fr-ilb
   2. Subnet: ilb-subnet
   3. In IP interno, scegli Prenota un indirizzo IP interno statico, inserisci le seguenti informazioni e fai clic su Prenota:
      • Nome: ip-ilb
      • Indirizzo IP statico: Scelta manuale
      • Indirizzo IP personalizzato: 10.1.2.99
   4. Porte: scegli Singola e inserisci 80 come Numero porta.
   5. Verifica che sia presente un segno di spunta blu accanto a Configurazione frontend prima di continuare. In caso contrario, rivedi questo passaggio.
6. Fai clic su Esamina e finalizza. Controlla le impostazioni.
7. Fai clic su Crea.

gcloud

1. Creare un nuovo controllo di integrità HTTP per verificare la connettività TCP alle VM su 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 \
       --failover-ratio 0.75
   

3. Aggiungi il backend principale 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
   

4. Aggiungi il backend di failover al servizio di backend:

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

5. Creare una regola di forwarding per il servizio di backend. Quando crei la regola di forwarding, specifica 10.1.2.99 per l'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 \
       --backend-service=be-ilb \
       --backend-service-region=us-west1
   

API

Crea il controllo di integrità inviando una richiesta POST al metodo regionHealthChecks.insert. Sostituisci PROJECT_ID con l'ID progetto.

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 a livello di regione inviando una richiesta POST al metodo regionBackendServices.insert. Sostituisci PROJECT_ID con l'ID progetto.

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"
    "failover": true
  }
],
"failoverPolicy": {
  "failoverRatio": 0.75
},
"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 effettuando una richiesta POST al metodo forwardingRules.insert. Sostituisci PROJECT_ID con l'ID progetto.

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

Test

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

Procedura di test del client

Questa procedura contatta il bilanciatore del carico dalla VM client. Userai questa procedura per completare gli altri test.

1. Connettiti all'istanza VM client.

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

2. Effettua una richiesta web al bilanciatore del carico utilizzando curl per contattare il relativo indirizzo IP.

   curl http://10.1.2.99
   

3. Prendi nota del testo restituito dal comando curl. Il nome della VM di backend che genera la risposta viene visualizzato nel testo; ad esempio: Page served from: vm-a1

Test dello stato iniziale

Dopo aver configurato il bilanciatore del carico di esempio, tutte e quattro le VM di backend dovrebbero essere integri:

• le due VM principali, vm-a1 e vm-a2
• le due VM di backup, vm-c1 e vm-c2

Segui la procedura di test del cliente. Ripeti il secondo passaggio alcune volte. Il comportamento previsto prevede che il traffico venga gestito dalle due VM principali, vm-a1 e vm-a2, poiché entrambe sono integri. Dovresti vedere che ogni VM principale restituisce una risposta all'incirca la metà delle volte perché non è stata configurata alcuna affinità di sessione per questo bilanciatore del carico.

Test del failover

Questo test simula l'errore di vm-a1, per consentirti di osservare il comportamento di failover.

1. Connettiti alla VM vm-a1.

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

2. Arresta il server web Apache. Dopo dieci secondi, Google Cloud considera che questa VM non è integro. (Il controllo di integrità hc-http-80 che hai creato nella configurazione utilizza l'intervallo di controllo predefinito di cinque secondi e la soglia di stato non integro di due probe non riusciti consecutivi).

   sudo apachectl stop
   

3. Segui la procedura di test del cliente. Ripeti il secondo passaggio alcune volte. Il comportamento previsto prevede che il traffico venga gestito dalle due VM di backup, vm-c1 e vm-c2. Poiché una sola VM principale, vm-a2, è in stato integro, il rapporto tra VM primarie in stato integro e VM principali totali è 0.5. Questo numero è inferiore alla soglia di failover di 0.75, pertanto Google Cloud ha riconfigurato il pool attivo del bilanciatore del carico in modo da utilizzare le VM di backup. Dovresti vedere che ogni VM di backup fornisce una risposta circa la metà delle volte purché non sia stata configurata alcuna affinità sessione per questo bilanciatore del carico.

Test del failover

Questo test simula il failover riavviando il server Apache su vm-a1.

1. Connettiti alla VM vm-a1.

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

2. Avvia il server web Apache e attendi 10 secondi.

   sudo apachectl start
   

3. Segui la procedura di test del cliente. Ripeti il secondo passaggio alcune volte. Il comportamento previsto prevede che il traffico venga gestito dalle due VM principali, vm-a1 e vm-a2. Con entrambe le VM principali in stato integro, il rapporto tra VM primarie e VM principali totali è 1.0, maggiore della soglia di failover 0.75. Di conseguenza, Google Cloud ha configurato il pool attivo in modo che utilizzi di nuovo le VM principali.

Aggiunta di altre VM di backend

Questa sezione estende la configurazione di esempio aggiungendo altre VM primarie e di backup al bilanciatore del carico. Per farlo, crea altri due gruppi di istanze di backend per dimostrare che è possibile distribuire le VM primarie e di backup tra più zone nella stessa regione:

• Un terzo gruppo di istanze, ig-d in us-west1-c, funge da backend principale con due VM:
  • vm-d1
  • vm-d2
• Un quarto gruppo di istanze, ig-b in us-west1-a, funge da backend di failover con due VM:
  • vm-b1
  • vm-b2

L'architettura modificata per questo esempio ha il seguente aspetto:

Failover del bilanciatore del carico di rete passthrough interno multizona (fai clic per ingrandire).

Crea VM e gruppi di istanze aggiuntivi

Segui questi passaggi per creare le VM principali e di backup aggiuntive e i relativi gruppi di istanze non gestite corrispondenti.

Console

Crea VM di backend

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

   Vai a Istanze VM

2. Ripeti i passaggi seguenti per creare quattro VM, utilizzando le seguenti combinazioni di nome e zona.

   • Nome: vm-b1, zona: us-west1-a
   • Nome: vm-b2, zona: us-west1-a
   • Nome: vm-d1, zona: us-west1-c
   • Nome: vm-d2, zona: us-west1-c

3. Fai clic su Crea istanza.

4. Imposta il Nome come indicato nel passaggio 2.

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

6. Nella sezione Disco di avvio, assicurati che l'immagine selezionata sia Debian GNU/Linux 10 (buster). Fai clic su Scegli per cambiare l'immagine, se necessario.

7. Fai clic su Opzioni avanzate e apporta le seguenti modifiche:

   • Fai clic su Networking e aggiungi i seguenti tag di rete: allow-ssh e allow-health-check
   • Fai clic sul pulsante di modifica in Interfacce di rete e apporta le seguenti modifiche, poi fai clic su Fine:
     • Rete: lb-network
     • Subnet: lb-subnet
     • IP interno principale: Temporaneo (automatico)
     • IP esterno: Temporaneo

   • Fai clic su Gestione. Nel campo Script di avvio, copia e incolla i seguenti contenuti dello script. I contenuti dello script sono identici per tutte e quattro le VM:

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

8. 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 passaggi seguenti per creare due gruppi di istanze non gestite, ciascuno con due VM in una, utilizzando queste combinazioni.

   • Gruppo di istanze: ig-b, zona: us-west1-a, VM: vm-b1 e vm-b2
   • Gruppo di istanze: ig-d, zona: us-west1-c, VM: vm-d1 e vm-d2

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, poi scegli una Zona come indicato nel passaggio 2.

7. In Rete, inserisci lb-network.

8. In Subnet, inserisci lb-subnet.

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

10. Fai clic su Crea.

gcloud

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

   • VM_NAME di vm-b1 e ZONE di us-west1-a
   • VM_NAME di vm-b2 e ZONE di us-west1-a
   • VM_NAME di vm-d1 e ZONE di us-west1-c
   • VM_NAME di vm-d2 e ZONE di us-west1-c

   gcloud compute instances create VM_NAME \
       --zone=ZONE \
       --image-family=debian-10 \
       --image-project=debian-cloud \
       --tags=allow-ssh,allow-health-check \
       --subnet=lb-subnet \
       --metadata=startup-script='#! /bin/bash
         apt-get update
         apt-get install apache2 -y
         a2ensite default-ssl
         a2enmod ssl
         vm_hostname="$(curl -H "Metadata-Flavor:Google" \
         http://metadata.google.internal/computeMetadata/v1/instance/name)"
         echo "Page served from: $vm_hostname" | \
         tee /var/www/html/index.html
         systemctl restart apache2'
   

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

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

3. Aggiungi le VM ai gruppi di istanze appropriati:

   gcloud compute instance-groups unmanaged add-instances ig-b \
       --zone=us-west1-a \
       --instances=vm-b1,vm-b2
   gcloud compute instance-groups unmanaged add-instances ig-d \
       --zone=us-west1-c \
       --instances=vm-d1,vm-d2
   

API

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

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

• VM_NAME di vm-b1 e ZONE di us-west1-a
• VM_NAME di vm-b2 e ZONE di us-west1-a
• VM_NAME di vm-d1 e ZONE di us-west1-c
• VM_NAME di vm-d2 e ZONE di us-west1-c

Sostituisci quanto segue:

• PROJECT_ID: il tuo ID progetto

• DEBIAN_IMAGE_NAME: il nome dell'immagine Debian dell'istanza. L'attuale DEBIAN_IMAGE_NAME può essere ottenuto eseguendo il seguente comando gcloud:

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

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\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\nsystemctl restart apache2"
     }
   ]
 },
 "scheduling": {
   "preemptible": false
 },
 "deletionProtection": false
}

Crea due gruppi di istanze inviando una richiesta POST al metodo instanceGroups.insert. Sostituisci PROJECT_ID con l'ID progetto.

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

{
 "name": "ig-b",
 "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-d",
 "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 ciascun gruppo di istanze inviando una richiesta POST al metodo instanceGroups.addInstances. Sostituisci PROJECT_ID con l'ID progetto.

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

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

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

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

Aggiunta di un backend principale

Puoi utilizzare questa procedura come modello per aggiungere un gruppo di istanze non gestite a un servizio di backend di un bilanciatore del carico di rete passthrough interno esistente come backend principale. Per la configurazione di esempio, questa procedura mostra come aggiungere il gruppo di istanze ig-d come backend principale al bilanciatore del carico be-ilb.

Console

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

   Vai a Bilanciamento del carico

2. Nella scheda Bilanciatori del carico, fai clic sul nome di un bilanciatore del carico UDP interno o TCP interno esistente (in questo esempio, be-ilb).

3. Fai clic su Modifica .

4. In Configurazione backend, fai clic su Aggiungi backend e seleziona un gruppo di istanze non gestite (in questo esempio, ig-d).

5. Assicurati che l'opzione Utilizza questo gruppo di istanze come gruppo di failover per il backup non sia selezionata.

6. Fai clic su Fine, quindi su Aggiorna.

gcloud

Usa il comando gcloud seguente per aggiungere un backend primario a un servizio di backend di un bilanciatore del carico di rete passthrough interno esistente.

gcloud compute backend-services add-backend BACKEND_SERVICE_NAME \
   --instance-group INSTANCE_GROUP_NAME \
   --instance-group-zone INSTANCE_GROUP_ZONE \
   --region REGION

Sostituisci quanto segue:

• BACKEND_SERVICE_NAME: il nome del servizio di backend del bilanciatore del carico. In questo esempio, utilizza be-ilb.
• INSTANCE_GROUP_NAME: il nome del gruppo di istanze da aggiungere come backend principale. In questo esempio, utilizza ig-d.
• INSTANCE_GROUP_ZONE: è la zona in cui viene definito il gruppo di istanze. In questo esempio, utilizza us-west1-c.
• REGION: la regione del bilanciatore del carico. In questo esempio, utilizza us-west1.

API

Aggiungi un backend principale a un servizio di backend esistente con il metodo regionBackendServices.patch.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/backendServices/BACKEND_SERVICE_NAME

{
  "backends":
  [
    {
      "balancingMode": "connection",
      "failover": false,
      "group": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/INSTANCE_GROUP_ZONE/instanceGroups/INSTANCE_GROUP_NAME"
    }
  ]
}

Sostituisci quanto segue:

• PROJECT_ID: il tuo ID progetto
• REGION: la regione del bilanciatore del carico. Ad esempio, utilizza us-west1.
• BACKEND_SERVICE_NAME: il nome del servizio di backend del bilanciatore del carico. In questo esempio, utilizza be-ilb.
• INSTANCE_GROUP_NAME: il nome del gruppo di istanze da aggiungere come backend principale. In questo esempio, utilizza ig-d.
• INSTANCE_GROUP_ZONE: la zona in cui è definito il gruppo di istanze. In questo esempio, utilizza us-west1-c.

Aggiunta di un backend di failover

Puoi utilizzare questa procedura come modello per aggiungere un gruppo di istanze non gestite a un servizio di backend di un bilanciatore del carico di rete passthrough interno esistente come backend di failover. Per la configurazione di esempio, questa procedura mostra come aggiungere il gruppo di istanze ig-b come backend di failover al bilanciatore del carico be-ilb.

Console

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

   Vai a Bilanciamento del carico

2. Nella scheda Bilanciatori del carico, fai clic sul nome di un bilanciatore del carico esistente di tipo TCP/UDP (interno) (in questo esempio, be-ilb).

3. Fai clic su Modifica .

4. In Configurazione backend, fai clic su Aggiungi backend e seleziona un gruppo di istanze non gestite (in questo esempio, ig-b).

5. Seleziona Usa questo gruppo di istanze come gruppo di failover per il backup.

6. Fai clic su Fine, quindi su Aggiorna.

gcloud

Usa il comando gcloud seguente per aggiungere un backend di failover a un servizio di backend di un bilanciatore del carico di rete passthrough interno esistente.

gcloud compute backend-services add-backend BACKEND_SERVICE_NAME \
   --instance-group INSTANCE_GROUP_NAME \
   --instance-group-zone INSTANCE_GROUP_ZONE \
   --region REGION \
   --failover

Sostituisci quanto segue:

• BACKEND_SERVICE_NAME: il nome del servizio di backend del bilanciatore del carico. In questo esempio, utilizza be-ilb.
• INSTANCE_GROUP_NAME: il nome del gruppo di istanze da aggiungere come backend principale. In questo esempio, utilizza ig-b.
• INSTANCE_GROUP_ZONE: è la zona in cui viene definito il gruppo di istanze. In questo esempio, utilizza us-west1-a.
• REGION è la regione del bilanciatore del carico. In questo esempio, utilizza us-west1.

API

Aggiungi un backend di failover a un servizio di backend esistente con il metodo regionBackendServices.patch.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/backendServices/BACKEND_SERVICE_NAME

{
  "backends":
  [
    {
      "balancingMode": "connection",
      "failover": true,
      "group": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/INSTANCE_GROUP_ZONE/instanceGroups/INSTANCE_GROUP_NAME"
    }
  ]
}

Sostituisci quanto segue:

• PROJECT_ID: il tuo ID progetto
• BACKEND_SERVICE_NAME: il nome del servizio di backend del bilanciatore del carico. In questo esempio, utilizza be-ilb.
• INSTANCE_GROUP_NAME: il nome del gruppo di istanze da aggiungere come backend principale. In questo esempio, utilizza ig-b.
• INSTANCE_GROUP_ZONE: è la zona in cui viene definito il gruppo di istanze. In questo esempio, utilizza us-west1-a.
• REGION: la regione del bilanciatore del carico. In questo esempio, utilizza us-west1.

Conversione di un backend primario o di failover

Puoi convertire un backend principale in un backend di failover o viceversa, senza dover rimuovere il gruppo di istanze dal servizio di backend del bilanciatore del carico di rete passthrough interno.

Console

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

   Vai a Bilanciamento del carico

2. Nella scheda Bilanciatori del carico, fai clic sul nome di un bilanciatore del carico esistente di tipo TCP/UDP (interno).

3. Fai clic su Modifica .

4. In Configurazione backend, fai clic sul nome di uno dei gruppi di istanze di backend. Quindi:

   • Per rendere il gruppo di istanze un backend di failover, seleziona Utilizza questo gruppo di istanze come gruppo di failover per il backup.
   • Per rendere il gruppo di istanze un backend principale, deseleziona Utilizza questo gruppo di istanze come gruppo di failover per il backup.

5. Fai clic su Fine, quindi su Aggiorna.

gcloud

Usa il seguente comando gcloud per convertire un backend primario esistente in un backend di failover:

gcloud compute backend-services update-backend BACKEND_SERVICE_NAME \
   --instance-group INSTANCE_GROUP_NAME \
   --instance-group-zone INSTANCE_GROUP_ZONE \
   --region REGION \
   --failover

Usa il seguente comando gcloud per convertire un backend di failover esistente in un backend primario:

gcloud compute backend-services update-backend BACKEND_SERVICE_NAME \
   --instance-group INSTANCE_GROUP_NAME \
   --instance-group-zone INSTANCE_GROUP_ZONE \
   --region REGION \
   --no-failover

Sostituisci quanto segue:

• BACKEND_SERVICE_NAME: nome del servizio di backend del bilanciatore del carico
• INSTANCE_GROUP_NAME: nome del gruppo di istanze da aggiungere come backend principale
• INSTANCE_GROUP_ZONE: la zona in cui è definito il gruppo di istanze
• REGION: la regione del bilanciatore del carico

API

Converti un backend principale in un backend di failover o viceversa utilizzando il metodo regionBackendServices.patch.

Per convertire un backend primario in un backend di failover:

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/backendServices/BACKEND_SERVICE_NAME

{
  "backends":
  [
    {
      "failover": true,
      "group": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/INSTANCE_GROUP_ZONE/instanceGroups/INSTANCE_GROUP_NAME"
    }
  ]
}

Per convertire un backend di failover in un backend primario:

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/backendServices/BACKEND_SERVICE_NAME

{
  "backends":
  [
    {
      "failover": false,
      "group": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/INSTANCE_GROUP_ZONE/instanceGroups/INSTANCE_GROUP_NAME"
    }
  ],
}

Sostituisci quanto segue:

• PROJECT_ID: il tuo ID progetto
• BACKEND_SERVICE_NAME: nome del servizio di backend del bilanciatore del carico
• INSTANCE_GROUP_NAME: nome del gruppo di istanze da aggiungere come backend principale
• INSTANCE_GROUP_ZONE: la zona in cui è definito il gruppo di istanze
• REGION: la regione del bilanciatore del carico

Configurazione dei criteri di failover

Questa sezione descrive come gestire un criterio di failover per un servizio di backend di un bilanciatore del carico di rete passthrough interno. Un criterio di failover è composto dai seguenti elementi:

• Rapporto di failover
• Eliminazione del traffico quando tutte le VM di backend sono in stato non integro
• Svuotamento connessioni al failover

Per maggiori informazioni sui parametri di un criterio di failover, consulta:

• Impostazione di un rapporto di failover
• Interruzione del traffico in assenza di una VM in stato integro
• Svuotamento delle connessioni in caso di failover e failover

Definizione di un criterio di failover

Le seguenti istruzioni descrivono come definire il criterio di failover per un bilanciatore del carico di rete passthrough interno esistente.

Console

Per definire un criterio di failover utilizzando la console Google Cloud, devi avere almeno un backend di failover.

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

   Vai a Bilanciamento del carico

2. Nella scheda Bilanciatori del carico, fai clic sul nome di un bilanciatore del carico esistente di tipo TCP/UDP (interno).

3. Fai clic su Modifica .

4. Assicurati di avere almeno un backend di failover. In almeno uno dei backend del bilanciatore del carico deve essere selezionata l'opzione Usa questo gruppo di istanze come gruppo di failover per il backup.

5. Fai clic su Configurazioni avanzate.

   • Per il Criterio di failover, imposta il Rapporto di failover su un valore compreso tra 0.0 e 1.0.
   • Seleziona la casella accanto a Abilita traffico di origine se vuoi eliminare il traffico quando tutte le VM attive e tutte le VM di backup sono in stato non integro.
   • Seleziona la casella accanto a Abilita lo svuotamento della connessione al failover se vuoi terminare rapidamente le connessioni esistenti durante il failover.

6. Fai clic su Esamina e finalizza e poi su Aggiorna.

gcloud

Per definire un criterio di failover utilizzando gcloud CLI, aggiorna il servizio di backend del bilanciatore del carico:

gcloud compute backend-services update BACKEND_SERVICE_NAME \
   --region REGION \
   --failover-ratio FAILOVER_RATIO \
   --drop-traffic-if-unhealthy \
   --no-connection-drain-on-failover

Sostituisci quanto segue:

• BACKEND_SERVICE_NAME: il nome del servizio di backend del bilanciatore del carico. In questo esempio, utilizza be-ilb.
• REGION: la regione del bilanciatore del carico. In questo esempio, utilizza us-west1.
• FAILOVER_RATIO: il rapporto di failover. I valori possibili sono compresi tra 0.0 e 1.0 inclusi. In questo esempio, utilizza 0.75.
• --drop-traffic-if-unhealthy indica al bilanciatore del carico di ignorare il traffico quando tutte le VM principali e tutte le VM di backup sono in stato non integro. Cambia questo valore in --no-drop-traffic-if-unhealthy se vuoi distribuire il traffico tra tutte le VM principali quando tutte le VM di backend sono in stato non integro.
• --no-connection-drain-on-failover indica al bilanciatore del carico di terminare rapidamente le connessioni TCP esistenti durante il failover. Utilizza --connection-drain-on-failover per abilitare lo svuotamento della connessione durante il failover.

API

Usa il metodo regionBackendServices.patch per definire il criterio di failover.

PATCH https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/backendServices/BACKEND_SERVICE_NAME

{
  "failoverPolicy":
  {
    "failoverRatio": FAILOVER_RATIO,
    "dropTrafficIfUnhealthy": [true|false],
    "disableConnectionDrainOnFailover": [true|false]
  }
}

Sostituisci quanto segue:

• PROJECT_ID: il tuo ID progetto
• REGION: la regione del bilanciatore del carico
• BACKEND_SERVICE_NAME: nome del servizio di backend del bilanciatore del carico
• FAILOVER_RATIO: il rapporto di failover. I valori possibili sono compresi tra 0.0 e 1.0 inclusi.
• L'impostazione di dropTrafficIfUnhealthy su true indica al bilanciatore del carico di eliminare il traffico quando tutte le VM principali e tutte le VM di backup sono in stato non integro. Imposta questo valore su false se vuoi distribuire il traffico tra tutte le VM principali quando tutte le VM di backend sono in stato non integro.
• L'impostazione di disableConnectionDrainOnFailover su true indica al bilanciatore del carico di terminare rapidamente le connessioni TCP esistenti quando si esegue un failover. Imposta questo valore su false per abilitare lo svuotamento della connessione durante il failover.

Visualizzazione di un criterio di failover

Le seguenti istruzioni descrivono come visualizzare il criterio di failover esistente per un bilanciatore del carico di rete passthrough interno.

Console

La console Google Cloud mostra le impostazioni del criterio di failover esistenti quando modifichi un bilanciatore del carico di rete passthrough interno. Per istruzioni, consulta la sezione Definire un criterio di failover.

gcloud

Per elencare le impostazioni del criterio di failover mediante gcloud CLI, utilizza il seguente comando. Le impostazioni non definite in un criterio di failover usano i valori predefiniti del criterio di failover.

gcloud compute backend-services describe BACKEND_SERVICE_NAME \
   --region REGION \
   --format="get(failoverPolicy)"

Sostituisci quanto segue:

• BACKEND_SERVICE_NAME: nome del servizio di backend del bilanciatore del carico
• REGION: la regione del bilanciatore del carico

API

Usa il metodo regionBackendServices.get per visualizzare il criterio di failover.

La risposta alla richiesta API mostra il criterio di failover. Di seguito è riportato un esempio.

GET https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/backendServices/BACKEND_SERVICE_NAME

Sostituisci quanto segue:

• PROJECT_ID: il tuo ID progetto
• REGION: la regione del bilanciatore del carico
• BACKEND_SERVICE_NAME: nome del servizio di backend del bilanciatore del carico

{
...
"failoverPolicy": {
  "disableConnectionDrainOnFailover": false,
  "dropTrafficIfUnhealthy": false,
  "failoverRatio": 0.75
...
}

Passaggi successivi

• Per i concetti fondamentali, consulta Panoramica del bilanciatore del carico di rete passthrough interno.
• Per informazioni importanti sul failover, consulta i concetti del failover per i bilanciatori del carico di rete passthrough interni.
• Consulta Configurare un bilanciatore del carico di rete passthrough interno per un esempio di configurazione del bilanciatore del carico di rete passthrough interno.
• Consulta Logging e monitoraggio del bilanciatore del carico di rete passthrough interno per informazioni su come configurare Logging e Monitoring per il bilanciatore del carico di rete passthrough interno.
• Consulta Bilanciatori del carico di rete passthrough interni e reti connesse per informazioni sull'accesso ai bilanciatori del carico di rete passthrough interni da reti peer connesse alla tua rete VPC.
• Per informazioni su come risolvere i problemi relativi al bilanciatore del carico di rete passthrough interno, consulta l'articolo sulla risoluzione dei problemi dei bilanciatori del carico di rete passthrough interni.
• Esegui la pulizia della configurazione del bilanciatore del carico.