Questa pagina è stata tradotta dall'API Cloud Translation.

Configura il bilanciamento del carico ponderato

Questa guida fornisce istruzioni per creare un bilanciatore del carico di rete passthrough esterno ponderato per ogni istanza di macchina virtuale (VM) utilizzando un servizio di backend regionale.

In questo tutorial, crei un gruppo di istanze con tre istanze VM e assegni i pesi per ogni istanza. Crea un controllo di integrità HTTP per segnalare i pesi delle istanze di backend. Il bilanciamento del carico ponderato è abilitato sul servizio di backend con il criterio di bilanciatore del carico per le località come WEIGHTED_MAGLEV.

Prima di iniziare

Leggi la panoramica del bilanciatore del carico di rete passthrough esterno basato sul servizio di backend.
Installa Google Cloud CLI. Per una panoramica completa dello strumento, consulta la panoramica dell'interfaccia a riga di comando gcloud. Puoi trovare i comandi relativi al bilanciamento del carico nel riferimento all'gcloud CLI e all'interfaccia a riga di comando gcloud.

Se non hai mai eseguito Google Cloud CLI, esegui prima gcloud init per autenticarti.

Abilita l'API di calcolo.

gcloud services enable compute.googleapis.com

Creare reti VPC, subnet e regole firewall

Crea una rete VPC, una subnet e regole firewall di autorizzazione in entrata per consentire le connessioni alle VM di backend del bilanciatore del carico.

Crea una rete e una subnet VPC.

a. Per creare la rete VPC, esegui il comando gcloud compute networks create:
```
gcloud compute networks create NETWORK_NAME --subnet-mode custom
```
b. In questo esempio, l'intervallo di indirizzi IPv4 principale della subnet è 10.10.0.0/24. Per creare la subnet, esegui il comando gcloud compute networks subnets create:
```
gcloud compute networks subnets create SUBNET_NAME \
  --network=NETWORK_NAME \
  --range=10.10.0.0/24 \
  --region=us-central1
```
Sostituisci quanto segue:
- NETWORK_NAME: il nome della rete VPC da creare.
- SUBNET_NAME: il nome della subnet da creare.
Crea una regola firewall di autorizzazione in entrata per consentire l'invio dei pacchetti alle porte TCP di destinazione 80 e 443 alle VM di backend. In questo esempio, la regola firewall consente le connessioni da qualsiasi indirizzo IP di origine. La regola firewall si applica alle VM con il tag di rete network-lb-tag.

Per creare la regola firewall, esegui il comando gcloud compute firewall-rules create:
```
gcloud compute firewall-rules create FIREWALL_RULE_NAME \
   --direction=INGRESS \
   --priority=1000 \
   --network=NETWORK_NAME \
   --action=ALLOW \
   --rules=tcp:80,tcp:443 \
   --source-ranges=0.0.0.0/0 \
   --target-tags=network-lb-tag
```
Sostituisci FIREWALL_RULE_NAME con il nome della regola del firewall da creare.

Crea istanze VM e assegna i pesi

Crea tre istanze VM e assegna i pesi:

Configura tre istanze VM di backend per restituire i pesi nell'X-Load-Balancing-Endpoint-Weight con le risposte HTTP. Per questo tutorial, configura un'istanza di backend per segnalare un peso pari a zero, una seconda istanza di backend per segnalare un peso pari a 100 e una terza istanza di backend per segnalare un peso pari a 900.

Per creare le istanze, esegui il comando gcloud compute instances create:

gcloud compute instances create instance-0 \
  --zone=us-central1-a \
  --tags=network-lb-tag \
  --image-family=debian-12 \
  --image-project=debian-cloud \
  --subnet=SUBNET_NAME \
  --metadata=load-balancing-weight=0,startup-script='#! /bin/bash
  apt-get update
  apt-get install apache2 -y
  ln -sr /etc/apache2/mods-available/headers.load /etc/apache2/mods-enabled/headers.load
  vm_hostname="$(curl -H "Metadata-Flavor:Google" \
  http://169.254.169.254/computeMetadata/v1/instance/name)"
  echo "Page served from: $vm_hostname" | \
  tee /var/www/html/index.html
  lb_weight="$(curl -H "Metadata-Flavor:Google" \
  http://169.254.169.254/computeMetadata/v1/instance/attributes/load-balancing-weight)"
  echo "Header set X-Load-Balancing-Endpoint-Weight \"$lb_weight\"" | \
  tee /etc/apache2/conf-enabled/headers.conf
  systemctl restart apache2'

gcloud compute instances create instance-100 \
  --zone=us-central1-a \
  --tags=network-lb-tag \
  --image-family=debian-12 \
  --image-project=debian-cloud \
  --subnet=SUBNET_NAME \
  --metadata=load-balancing-weight=100,startup-script='#! /bin/bash
  apt-get update
  apt-get install apache2 -y
  ln -sr /etc/apache2/mods-available/headers.load /etc/apache2/mods-enabled/headers.load
  vm_hostname="$(curl -H "Metadata-Flavor:Google" \
  http://169.254.169.254/computeMetadata/v1/instance/name)"
  echo "Page served from: $vm_hostname" | \
  tee /var/www/html/index.html
  lb_weight="$(curl -H "Metadata-Flavor:Google" \
  http://169.254.169.254/computeMetadata/v1/instance/attributes/load-balancing-weight)"
  echo "Header set X-Load-Balancing-Endpoint-Weight \"$lb_weight\"" | \
  tee /etc/apache2/conf-enabled/headers.conf
  systemctl restart apache2'

gcloud compute instances create instance-900 \
  --zone=us-central1-a \
  --tags=network-lb-tag \
  --image-family=debian-12 \
  --image-project=debian-cloud \
  --subnet=SUBNET_NAME \
  --metadata=load-balancing-weight=900,startup-script='#! /bin/bash
    apt-get update
    apt-get install apache2 -y
    ln -sr /etc/apache2/mods-available/headers.load /etc/apache2/mods-enabled/headers.load
    vm_hostname="$(curl -H "Metadata-Flavor:Google" \
    http://169.254.169.254/computeMetadata/v1/instance/name)"
    echo "Page served from: $vm_hostname" | \
    tee /var/www/html/index.html
    lb_weight="$(curl -H "Metadata-Flavor:Google" \
    http://169.254.169.254/computeMetadata/v1/instance/attributes/load-balancing-weight)"
    echo "Header set X-Load-Balancing-Endpoint-Weight \"$lb_weight\"" | \
    tee /etc/apache2/conf-enabled/headers.conf
    systemctl restart apache2'

Crea un gruppo di istanze

In questo tutorial fornisci istruzioni per creare un gruppo di istanze non gestite contenente tutte e tre le istanze VM(instance-0, instance-100 e instance-900).

Per creare il gruppo di istanze, esegui il comando gcloud compute instance-groups unmanaged create:

gcloud compute instance-groups unmanaged create INSTANCE_GROUP \     
  --zone=us-central1-a

gcloud compute instance-groups unmanaged add-instances INSTANCE_GROUP \
  --zone=us-central1-a \
  --instances=instance-0,instance-100,instance-900

Sostituisci INSTANCE_GROUP con il nome del gruppo di istanze da creare.

Crea un controllo di integrità HTTP

In questo tutorial fornisci istruzioni per creare un controllo di integrità HTTP per leggere la risposta HTTP contenente il peso della VM di backend."

Per creare il controllo di integrità HTTP, esegui il comando gcloud compute health-checks create:
```
gcloud compute health-checks create http HTTP_HEALTH_CHECK_NAME \
  --region=us-central1
```
Sostituisci HTTP_HEALTH_CHECK_NAME con il nome del controllo di integrità HTTP da creare.

Crea un servizio di backend

L'esempio seguente fornisce istruzioni per creare un servizio di backend esterno regionale configurato per utilizzare il bilanciamento del carico ponderato.

Crea un servizio di backend con il controllo di integrità HTTP e imposta il criterio del bilanciatore del carico per la località su WEIGHTED_MAGLEV.
- Per creare il servizio di backend, esegui il comando gcloud compute backend-services create:
```
gcloud compute backend-services create BACKEND_SERVICE_NAME \
  --load-balancing-scheme=external \
  --protocol=tcp \
  --region=us-central1 \
  --health-checks=HTTP_HEALTH_CHECK_NAME \
  --health-checks-region=us-central1 \
  --locality-lb-policy=WEIGHTED_MAGLEV
```
  Sostituisci BACKEND_SERVICE_NAME con il nome del servizio di backend da creare.

Aggiungi il gruppo di istanze al servizio di backend.

Per aggiungere il gruppo di istanze, esegui il comando gcloud compute backend-services add-backend:

gcloud compute backend-services add-backend BACKEND_SERVICE_NAME \
  --instance-group=INSTANCE_GROUP \
  --instance-group-zone=us-central1-a \
  --region=us-central1

Prenota un indirizzo IP esterno regionale per il bilanciatore del carico.
- Per prenotare uno o più indirizzi IP, esegui il comando gcloud compute addresses create:
```
gcloud compute addresses create ADDRESS_NAME \
 --region us-central1
```
  Sostituisci ADDRESS_NAME con il nome dell'indirizzo IP da creare.
  
  Utilizza il comando compute addresses describe per visualizzare il risultato. Prendi nota dell'indirizzo IP esterno statico prenotato (IP_ADDRESS).
```
gcloud compute addresses describe ADDRESS_NAME
```
Crea una regola di forwarding utilizzando l'indirizzo IP esterno regionale riservato IP_ADDRESS. Collega la regola di forwarding al servizio di backend.
- Per creare la regola di forwarding, esegui il comando gcloud compute forwarding-rules create:
```
gcloud compute forwarding-rules create FORWARDING_RULE \
  --region=us-central1 \
  --ports=80 \
  --address=IP_ADDRESS \
  --backend-service=BACKEND_SERVICE_NAME
```
  Sostituisci quanto segue:
  
  FORWARDING_RULE: il nome della regola di inoltro da creare.
  
  IP_ADDRESS: l'indirizzo IP da assegnare all'istanza. Utilizza l'indirizzo IP esterno statico prenotato, non il nome dell'indirizzo.

Verifica i pesi del backend utilizzando l'API del servizio di backend

Verifica che i pesi del backend vengano registrati correttamente nel controllo di integrità HTTP.

Per ottenere i pesi dei backend (insieme agli stati di integrità) da un servizio di backend, esegui il comando gcloud compute backend-services get-health:
```
gcloud compute backend-services get-health BACKEND_SERVICE_NAME \
  --region=us-central1
```

L'output è il seguente:

backend: https://www.googleapis.com/compute/projects/project-name/{project}/zones/us-central1-a/instanceGroups/{instance-group-name}
status:
  healthStatus:
  - forwardingRule: https://www.googleapis.com/compute/projects/{project}/regions/us-central1/forwardingRules/{firewall-rule-name}
    forwardingRuleIp: 34.135.46.66
    healthState: HEALTHY
    instance: https://www.googleapis.com/compute/projects/{project}/zones/us-central1-a/instances/instance-0
    ipAddress: 10.10.0.5
    port: 80
    weight: '0'
  - forwardingRule: https://www.googleapis.com/compute/projects/{project}/regions/us-central1/forwardingRules/{firewall-rule-name}
    forwardingRuleIp: 34.135.46.66
    healthState: HEALTHY
    instance: https://www.googleapis.com/compute/projects/{project}/zones/us-central1-a/instances/instance-100
    ipAddress: 10.10.0.6
    port: 80
    weight: '100'
  - forwardingRule: https://www.googleapis.com/compute/projects/{project}/regions/us-central1/forwardingRules/{firewall-rule-name}
    forwardingRuleIp: 34.135.46.66
    healthState: HEALTHY
    instance: https://www.googleapis.com/compute/projects/{project}/zones/us-central1-a/instances/instance-900
    ipAddress: 10.10.0.7
    port: 80
    weight: '900'
  kind: compute#backendServiceGroupHealth