Configura un bilanciatore del carico di rete proxy interno tra regioni con backend di gruppi di istanze VM

Questo documento fornisce istruzioni per configurare un bilanciatore del carico di rete proxy interno tra regioni per i tuoi servizi eseguiti sulle VM di Compute Engine.

Prima di iniziare

Prima di seguire questa guida, acquisisci familiarità con i seguenti argomenti:

Autorizzazioni

Per seguire questa guida, devi essere in grado di creare istanze e modificare un in un progetto. Devi essere un progetto proprietario o editor, oppure devi avere i seguenti ruoli IAM di Compute Engine.

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

Per ulteriori informazioni, consulta le seguenti guide:

Panoramica della configurazione

Puoi configurare il bilanciatore del carico come mostrato nel seguente diagramma:

Deployment ad alta disponibilità del bilanciatore del carico di rete proxy interno tra regioni.
Deployment ad alta disponibilità del bilanciatore del carico di rete proxy interno tra regioni (fai clic per ingrandire).

Come mostrato nel diagramma, questo esempio crea un bilanciatore del carico di rete proxy interno tra regioni in un una rete VPC, con un backend e due gruppi di istanze gestite di backend (MIG) nella regione REGION_A e REGION_B regioni.

Il diagramma mostra quanto segue:

  1. Una rete VPC con le seguenti subnet:

    • Subnet SUBNET_A e subnet solo proxy in REGION_A.
    • Subnet SUBNET_B e subnet solo proxy in REGION_B.

    Devi creare subnet solo proxy in ogni regione di una rete VPC in cui utilizzi bilanciatori del carico di rete proxy interni tra regioni. Lo stato della regione una subnet solo proxy è condivisa tra tutti i bilanciatori del carico di rete proxy interni tra regioni in regione. Indirizzi di origine dei pacchetti inviati dal bilanciatore del carico ai backend del tuo servizio vengono allocati una subnet solo proxy. In questo esempio, la subnet solo proxy per la regione REGION_B ha un intervallo di indirizzi IP principali di 10.129.0.0/23 e per REGION_A ha un intervallo di indirizzi IP principali di 10.130.0.0/23, che è il la dimensione subnet consigliata.

  2. La configurazione dell'alta disponibilità include backend di gruppo di istanze gestite per Deployment delle VM di Compute Engine nelle regioni REGION_A e REGION_B. Se i backend in una regione non sono attivi, il failover del traffico viene eseguito in un'altra regione.

  3. Un servizio di backend globale che monitora l'utilizzo e l'integrità dei di backend.

  4. Un proxy TCP di destinazione globale, che riceve una richiesta dal e lo inoltra al servizio di backend.

  5. Regole di forwarding globali, che hanno l'indirizzo IP interno regionale del tuo bilanciatore del carico e può inoltrare ogni richiesta in entrata al proxy di destinazione.

    L'indirizzo IP interno associato alla regola di forwarding può provenire da una subnet nella stessa rete e nella stessa regione dei backend. Tieni presente quanto segue condizioni:

    • L'indirizzo IP può (ma non è necessario) provenire dalla stessa subnet gruppi di istanza di backend.
    • L'indirizzo IP non deve provenire da una subnet solo proxy riservata che il flag --purpose impostato su GLOBAL_MANAGED_PROXY.
    • Se si desidera utilizzare lo stesso indirizzo IP interno con più inoltri regole, imposta il flag dell'indirizzo IP --purpose su SHARED_LOADBALANCER_VIP.

Configura la rete e le subnet

All'interno della rete VPC, configura una subnet in ogni regione in cui sono configurati i backend. Inoltre, configura un proxy-only-subnet in ogni regione in cui vuoi configurare il bilanciatore del carico.

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

  • Rete. La rete è un VPC in modalità personalizzata denominata NETWORK.

  • Subnet per i backend.

    • Una subnet denominata SUBNET_A nel La regione REGION_A utilizza 10.1.2.0/24 come principale Intervallo IP.
    • Una subnet denominata SUBNET_B nel La regione REGION_B utilizza 10.1.3.0/24 come principale Intervallo IP.

  • Subnet per i proxy.

    • Una subnet denominata PROXY_SN_A in la regione REGION_A utilizza 10.129.0.0/23 per nell'intervallo IP principale.
    • Una subnet denominata PROXY_SN_B nel La regione REGION_B utilizza 10.130.0.0/23 per nell'intervallo IP principale.

È possibile accedere ai bilanciatori del carico delle applicazioni interni tra regioni da qualsiasi regione all'interno del VPC. In questo modo, i client di qualsiasi regione possono accedere a livello globale ai backend del tuo bilanciatore del carico.

Configura le subnet di backend

Console

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

    Vai alle reti VPC

  2. Fai clic su Crea rete VPC.

  3. Specifica un nome per la rete.

  4. Nella sezione Subnet, imposta la Modalità di creazione subnet su Personalizzato.

  5. Creare una subnet per i backend del bilanciatore del carico. Nella sezione Nuova subnet inserisci le seguenti informazioni:

    • Specifica un nome per la subnet.
    • Seleziona una regione: REGION_A
    • Inserisci un intervallo di indirizzi IP: 10.1.2.0/24

  6. Fai clic su Fine.

  7. Fai clic su Aggiungi subnet.

  8. Creare una subnet per i backend del bilanciatore del carico. Nel subnet, inserisci le seguenti informazioni:

    • Specifica un nome per la subnet.
    • Seleziona una regione: REGION_B
    • Inserisci un intervallo di indirizzi IP: 10.1.3.0/24

  9. Fai clic su Fine.

  10. Fai clic su Crea.

gcloud

  1. Crea la rete VPC personalizzata con il comando gcloud compute networks create:

    gcloud compute networks create NETWORK \
    --subnet-mode=custom

  2. Crea una subnet nella rete NETWORK nel REGION_A regione con il comando gcloud compute networks subnets create:

    gcloud compute networks subnets create SUBNET_A \
    --network=NETWORK \
    --range=10.1.2.0/24 \
    --region=REGION_A

  3. Crea una subnet nella rete NETWORK nel REGION_B regione con il comando gcloud compute networks subnets create:

    gcloud compute networks subnets create SUBNET_B \
    --network=NETWORK \
    --range=10.1.3.0/24 \
    --region=REGION_B

Terraform

Per creare la rete VPC, utilizza la risorsa google_compute_network.

resource "google_compute_network" "default" {
  auto_create_subnetworks = false
  name                    = "lb-network-crs-reg"
  provider                = google-beta
}

Per creare le subnet VPC nella rete lb-network-crs-reg, utilizza la risorsa google_compute_subnetwork.

resource "google_compute_subnetwork" "subnet_a" {
  provider      = google-beta
  ip_cidr_range = "10.1.2.0/24"
  name          = "lbsubnet-uswest1"
  network       = google_compute_network.default.id
  region        = "us-west1"
}
resource "google_compute_subnetwork" "subnet_b" {
  provider      = google-beta
  ip_cidr_range = "10.1.3.0/24"
  name          = "lbsubnet-useast1"
  network       = google_compute_network.default.id
  region        = "us-east1"
}

API

Invia una richiesta POST a Metodo networks.insert. Sostituisci PROJECT_ID con il tuo ID progetto.

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

{
 "routingConfig": {
   "routingMode": "regional"
 },
 "name": "NETWORK",
 "autoCreateSubnetworks": false
}

Invia una richiesta POST a Metodo subnetworks.insert. Sostituisci PROJECT_ID con il tuo ID progetto.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION_A/subnetworks

{
 "name": "SUBNET_A",
 "network": "projects/PROJECT_ID/global/networks/lb-network-crs-reg",
 "ipCidrRange": "10.1.2.0/24",
 "region": "projects/PROJECT_ID/regions/REGION_A",
}

Invia una richiesta POST a Metodo subnetworks.insert. Sostituisci PROJECT_ID con il tuo ID progetto.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION_B/subnetworks

{
 "name": "SUBNET_B",
 "network": "projects/PROJECT_ID/global/networks/NETWORK",
 "ipCidrRange": "10.1.3.0/24",
 "region": "projects/PROJECT_ID/regions/REGION_B",
}

Configura la subnet solo proxy

Una subnet solo proxy fornisce una insieme di indirizzi IP che Google Cloud utilizza per eseguire i proxy Envoy per tuo conto. La i proxy terminano le connessioni dal client e creano nuove connessioni di backend.

Questa subnet solo proxy viene utilizzata da tutto il carico a livello di regione basato su Envoy nella stessa regione della rete VPC. Possono esserci solo una subnet solo proxy attiva per uno scopo specifico, per regione e per rete.

Console

Se utilizzi la console Google Cloud, puoi attendere e creare l'account più avanti nella pagina Bilanciamento del carico.

Se vuoi creare ora la subnet solo proxy, segui questi passaggi:

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

    Vai alle reti VPC

  2. Fai clic sul nome della rete VPC.
  3. Nella scheda Subnet, fai clic su Aggiungi subnet.
  4. Specifica un nome per la subnet solo proxy.
  5. Seleziona una regione: REGION_A
  6. Nell'elenco Finalità, seleziona Proxy gestito tra regioni.
  7. Nel campo Intervallo di indirizzi IP, inserisci 10.129.0.0/23.
  8. Fai clic su Aggiungi.

Crea la subnet solo proxy in REGION_B

  1. Nella scheda Subnet, fai clic su Aggiungi subnet.
  2. Specifica un nome per la subnet solo proxy.
  3. Seleziona una regione: REGION_B
  4. Nell'elenco Finalità, seleziona Proxy gestito tra regioni.
  5. Nel campo Intervallo di indirizzi IP, inserisci 10.130.0.0/23.
  6. Fai clic su Aggiungi.

gcloud

Crea le subnet solo proxy con gcloud compute networks subnets create.

    gcloud compute networks subnets create PROXY_SN_A \
        --purpose=GLOBAL_MANAGED_PROXY \
        --role=ACTIVE \
        --region=REGION_A \
        --network=NETWORK \
        --range=10.129.0.0/23
    
    gcloud compute networks subnets create PROXY_SN_B \
        --purpose=GLOBAL_MANAGED_PROXY \
        --role=ACTIVE \
        --region=REGION_B \
        --network=NETWORK \
        --range=10.130.0.0/23

Terraform

Per creare la subnet solo proxy VPC in lb-network-crs-reg usa la risorsa google_compute_subnetwork.

resource "google_compute_subnetwork" "proxy_subnet_a" {
  provider      = google-beta
  ip_cidr_range = "10.129.0.0/23"
  name          = "proxy-only-subnet1"
  network       = google_compute_network.default.id
  purpose       = "GLOBAL_MANAGED_PROXY"
  region        = "us-west1"
  role          = "ACTIVE"
  lifecycle {
    ignore_changes = [ipv6_access_type]
  }
}
resource "google_compute_subnetwork" "proxy_subnet_b" {
  provider      = google-beta
  ip_cidr_range = "10.130.0.0/23"
  name          = "proxy-only-subnet2"
  network       = google_compute_network.default.id
  purpose       = "GLOBAL_MANAGED_PROXY"
  region        = "us-east1"
  role          = "ACTIVE"
  lifecycle {
    ignore_changes = [ipv6_access_type]
  }
}

API

Crea le subnet solo proxy con subnetworks.insert, in sostituzione PROJECT_ID con il tuo ID progetto.

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION_A/subnetworks

    {
      "name": " PROXY_SN_A",
      "ipCidrRange": "10.129.0.0/23",
      "network": "projects/PROJECT_ID/global/networks/NETWORK",
      "region": "projects/PROJECT_ID/regions/REGION_A",
      "purpose": "GLOBAL_MANAGED_PROXY",
      "role": "ACTIVE"
    }
   
    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION_B/subnetworks

    {
      "name": "PROXY_SN_B",
      "ipCidrRange": "10.130.0.0/23",
      "network": "projects/PROJECT_ID/global/networks/NETWORK",
      "region": "projects/PROJECT_ID/regions/REGION_B",
      "purpose": "GLOBAL_MANAGED_PROXY",
      "role": "ACTIVE"
    }

Configurazione delle regole del firewall

Questo esempio utilizza le seguenti regole firewall:

  • fw-ilb-to-backends. Una regola in entrata, applicabile alle istanze da caricare bilanciata, che consente la connettività SSH in entrata sulla porta TCP 22 da qualsiasi . Puoi scegliere un intervallo di indirizzi IP di origine più restrittivo per questa regola. della Ad esempio, puoi specificare solo gli intervalli di indirizzi IP del sistema da cui avviare sessioni SSH. Questo esempio utilizza il tag target allow-ssh per identificare le VM a cui si applica la regola firewall.

  • fw-healthcheck. Una regola in entrata, applicabile alle istanze con bilanciamento del carico, che consente tutto il traffico TCP da Google Cloud sistemi di controllo dell'integrità (in 130.211.0.0/22 e 35.191.0.0/16). Questo utilizza il tag di destinazione load-balanced-backend per identificare le VM a cui si applica la regola firewall.

  • fw-backends. Una regola in entrata, applicabile alle istanze che vengono con bilanciamento del carico, che consente il traffico TCP sulle porte 80, 443 e 8080 da i proxy gestiti del bilanciatore del carico di rete del proxy interno. Questo esempio utilizza il tag di destinazione load-balanced-backend per identificare le VM a cui si applica la regola firewall.

Senza queste regole firewall, il campo di blocco predefinito una regola in entrata blocca in entrata alle istanze di backend.

I tag target e definire le istanze di backend. Senza i tag di destinazione, il firewall e vengono applicate a tutte le istanze di backend nella rete VPC. Quando crei le VM di backend, assicurati di includere i tag di destinazione specificati, come illustrato in Creazione di un'istanza gestita .

Console

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

    Vai a Criteri firewall

  2. Fai clic su Crea regola firewall per creare la regola in modo da consentire le richieste in entrata Connessioni SSH:

    • Nome: fw-ilb-to-backends
    • Rete: NETWORK
    • 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.
      • Seleziona la casella di controllo TCP, quindi inserisci 22 per il numero di porta.

  3. Fai clic su Crea.

  4. Fai clic su Crea regola firewall una seconda volta per creare la regola che consente Controlli di integrità di Google Cloud:

    • Nome: fw-healthcheck
    • Rete: NETWORK
    • Direzione del traffico: in entrata
    • Azione in caso di corrispondenza: Consenti
    • Target: tag di destinazione specificati
    • Tag di destinazione: load-balanced-backend
    • Filtro di origine: Intervalli IPv4
    • Intervalli IPv4 di origine: 130.211.0.0/22 e 35.191.0.0/16

    • Protocolli e porte:

      • Scegli Protocolli e porte specificati.
      • Seleziona la casella di controllo TCP, quindi inserisci 80 per il numero di porta.

      Come best practice, limita questa regola ai soli protocolli e porte che corrispondano a quelli usati dal controllo di integrità. Se utilizzi tcp:80 per il protocollo e la porta, Google Cloud può utilizzare HTTP sulla porta 80 per contattare le VM, ma non è possibile utilizzare HTTPS porta 443 per contattarlo.

  5. Fai clic su Crea.

  6. Fai clic su Crea regola firewall una terza volta per creare la regola che consente ai server proxy del bilanciatore del carico per connettere i backend:

    • Nome: fw-backends
    • Rete: NETWORK
    • Direzione del traffico: in entrata
    • Azione in caso di corrispondenza: Consenti
    • Target: tag di destinazione specificati
    • Tag di destinazione: load-balanced-backend
    • Filtro di origine: Intervalli IPv4
    • Intervalli IPv4 di origine: 10.129.0.0/23 e 10.130.0.0/23
    • Protocolli e porte:
        .
      • Scegli Protocolli e porte specificati.
      • Seleziona la casella di controllo TCP, quindi inserisci 80, 443, 8080 per numeri di porta.

  7. Fai clic su Crea.

gcloud

  1. Crea la regola firewall fw-ilb-to-backends per consentire la connettività SSH a VM con il tag di rete allow-ssh. Se ometti source-ranges, Google Cloud interpreta la regola nel significato che Fonte.

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

  2. Crea la regola fw-healthcheck per consentire a Google Cloud e controlli di integrità. Questo esempio consente tutto il traffico TCP proveniente dal controllo di integrità i probatori; ma puoi configurare un insieme più ristretto di porte e alle esigenze aziendali.

    gcloud compute firewall-rules create fw-healthcheck \
    --network=NETWORK \
    --action=allow \
    --direction=ingress \
    --source-ranges=130.211.0.0/22,35.191.0.0/16 \
    --target-tags=load-balanced-backend \
    --rules=tcp

  3. Crea la regola fw-backends per consentire l'uso del bilanciatore del carico di rete del proxy interno per connettersi ai tuoi backend. Imposta source-ranges su per la subnet solo proxy, ad esempio 10.129.0.0/23 e 10.130.0.0/23.

    gcloud compute firewall-rules create fw-backends \
    --network=NETWORK \
    --action=allow \
    --direction=ingress \
    --source-ranges=SOURCE_RANGE \
    --target-tags=load-balanced-backend \
    --rules=tcp:80,tcp:443,tcp:8080

API

Crea la regola firewall fw-ilb-to-backends effettuando una richiesta POST a il metodo firewalls.insert, sostituendo PROJECT_ID con il tuo ID progetto.

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

{
 "name": "fw-ilb-to-backends",
 "network": "projects/PROJECT_ID/global/networks/NETWORK",
 "sourceRanges": [
   "0.0.0.0/0"
 ],
 "targetTags": [
   "allow-ssh"
 ],
 "allowed": [
  {
    "IPProtocol": "tcp",
    "ports": [
      "22"
    ]
  }
 ],
"direction": "INGRESS"
}

Crea la regola firewall fw-healthcheck effettuando una richiesta POST a il metodo firewalls.insert, sostituendo PROJECT_ID con il tuo ID progetto.

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

{
 "name": "fw-healthcheck",
 "network": "projects/PROJECT_ID/global/networks/NETWORK",
 "sourceRanges": [
   "130.211.0.0/22",
   "35.191.0.0/16"
 ],
 "targetTags": [
   "load-balanced-backend"
 ],
 "allowed": [
   {
     "IPProtocol": "tcp"
   }
 ],
 "direction": "INGRESS"
}

Crea la regola firewall fw-backends per consentire il traffico TCP all'interno di una subnet proxy per firewalls.insert, sostituendo PROJECT_ID con il tuo ID progetto.

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

{
 "name": "fw-backends",
 "network": "projects/PROJECT_ID/global/networks/NETWORK",
 "sourceRanges": [
   "10.129.0.0/23",
   "10.130.0.0/23"
 ],
 "targetTags": [
   "load-balanced-backend"
 ],
 "allowed": [
   {
     "IPProtocol": "tcp",
     "ports": [
       "80"
     ]
   },
 {
     "IPProtocol": "tcp",
     "ports": [
       "443"
     ]
   },
   {
     "IPProtocol": "tcp",
     "ports": [
       "8080"
     ]
   }
 ],
 "direction": "INGRESS"
}

Creare un gruppo di istanze gestite

Questa sezione mostra come creare un modello e un gruppo di istanze gestite. La un gruppo di istanze gestite fornisce istanze VM che eseguono i server di backend di un un esempio di bilanciatore del carico di rete proxy interno tra regioni. Per il gruppo di istanze, puoi definire una richiesta e mappare il nome di una porta alla porta pertinente. Il servizio di backend del bilanciatore del carico inoltra il traffico alle porte denominate. Il traffico proveniente dai client viene bilanciato verso i server di backend. Per dimostrazione i backend gestiscono i propri nomi host.

Console

  1. Nella console Google Cloud, vai a la pagina Modelli di istanza.

    Vai a Modelli di istanza

    1. Fai clic su Crea modello istanza.
    2. In Nome, inserisci gil4-backendeast1-template.
    3. Assicurati che il disco di avvio sia impostato su un'immagine Debian, ad esempio Debian GNU/Linux 12 (bookworm). Queste istruzioni utilizzano comandi sono disponibili solo su Debian, come apt-get.
    4. Fai clic su Opzioni avanzate.
    5. Fai clic su Networking e configura i seguenti campi:
        .
      1. In Tag di rete, inserisci allow-ssh e load-balanced-backend.
      2. In Interfacce di rete, seleziona quanto segue:
          .
        • Rete: NETWORK
        • Subnet: SUBNET_B

    6. Fai clic su Gestione. Inserisci lo script seguente nel Script di avvio.

      #! /bin/bash
apt-get update
apt-get install apache2 -y
a2ensite default-ssl
a2enmod ssl
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
systemctl restart apache2

    7. Fai clic su Crea.

    8. Fai clic su Crea modello istanza.

    9. In Nome, inserisci gil4-backendwest1-template.

    10. Assicurati che il disco di avvio sia impostato su un'immagine Debian, ad esempio Debian GNU/Linux 12 (bookworm). Queste istruzioni utilizzano comandi sono disponibili solo su Debian, come apt-get.

    11. Fai clic su Opzioni avanzate.

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

      1. In Tag di rete, inserisci allow-ssh e load-balanced-backend.
      2. In Interfacce di rete, seleziona quanto segue:
          .
        • Rete: NETWORK
        • Subnet: SUBNET_A

    13. Fai clic su Gestione. Inserisci lo script seguente nel Script di avvio.

      #! /bin/bash
apt-get update
apt-get install apache2 -y
a2ensite default-ssl
a2enmod ssl
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
systemctl restart apache2

    14. Fai clic su Crea.

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

    Vai a Gruppi di istanze

    1. Fai clic su Crea gruppo di istanze.
    2. Seleziona Nuovo gruppo di istanze gestite (stateless). Per ulteriori informazioni consulta le informazioni sui MIG stateless o stateful.
    3. In Nome, inserisci gl7-ilb-mig-a.
    4. Per Località, seleziona Zona singola.
    5. In Regione, seleziona REGION_A.
    6. In Zona, seleziona ZONE_A.
    7. In Modello di istanza, seleziona gil4-backendwest1-template.

    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.

      Se vuoi, nella sezione Scalabilità automatica della UI puoi configurare il gruppo di istanze per aggiungere o rimuovere automaticamente in base all'utilizzo della CPU dell'istanza.

    9. Fai clic su Crea.

    10. Fai clic su Crea gruppo di istanze.

    11. Seleziona Nuovo gruppo di istanze gestite (stateless). Per ulteriori informazioni consulta le informazioni sui MIG stateless o stateful.

    12. In Nome, inserisci gl7-ilb-mig-b.

    13. Per Località, seleziona Zona singola.

    14. In Regione, seleziona REGION_B.

    15. In Zona, seleziona ZONE_B.

    16. In Modello di istanza, seleziona gil4-backendeast1-template.

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

      Se vuoi, nella sezione Scalabilità automatica della UI puoi configurare il gruppo di istanze per aggiungere o rimuovere automaticamente di Compute Engine in base all'utilizzo della CPU dell'istanza.

    18. Fai clic su Crea.

gcloud

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

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

    gcloud compute instance-templates create gil4-backendwest1-template \
   --region=REGION_A \
   --network=NETWORK \
   --subnet=SUBNET_A \
   --tags=allow-ssh,load-balanced-backend \
   --image-family=debian-12 \
   --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://169.254.169.254/computeMetadata/v1/instance/name)"
     echo "Page served from: $vm_hostname" | \
     tee /var/www/html/index.html
     systemctl restart apache2'

    gcloud compute instance-templates create gil4-backendeast1-template \
    --region=REGION_B \
    --network=NETWORK \
    --subnet=SUBNET_B \
    --tags=allow-ssh,load-balanced-backend \
    --image-family=debian-12 \
    --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://169.254.169.254/computeMetadata/v1/instance/name)"
      echo "Page served from: $vm_hostname" | \
      tee /var/www/html/index.html
      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 gl7-ilb-mig-a \
    --zone=ZONE_A \
    --size=2 \
    --template=gil4-backendwest1-template

    gcloud compute instance-groups managed create gl7-ilb-mig-b \
    --zone=ZONE_B \
    --size=2 \
    --template=gil4-backendeast1-template

API

Crea il modello di istanza con Metodo instanceTemplates.insert, sostituendo PROJECT_ID con il tuo ID progetto.

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

{
  "name":"gil4-backendwest1-template",
  "properties":{
     "machineType":"e2-standard-2",
     "tags":{
       "items":[
         "allow-ssh",
         "load-balanced-backend"
       ]
     },
     "metadata":{
        "kind":"compute#metadata",
        "items":[
          {
            "key":"startup-script",
            "value":"#! /bin/bash\napt-get update\napt-get install
            apache2 -y\na2ensite default-ssl\na2enmod ssl\n
            vm_hostname=\"$(curl -H \"Metadata-Flavor:Google\"           
            \\\nhttp://169.254.169.254/computeMetadata/v1/instance/name)\"\n
            echo \"Page served from: $vm_hostname\" | \\\ntee
            /var/www/html/index.html\nsystemctl restart apache2"
          }
        ]
     },
     "networkInterfaces":[
       {
         "network":"projects/PROJECT_ID/global/networks/NETWORK",
         "subnetwork":"regions/REGION_A/subnetworks/SUBNET_A",
         "accessConfigs":[
           {
             "type":"ONE_TO_ONE_NAT"
           }
         ]
       }
     ],
     "disks":[
       {
         "index":0,
         "boot":true,
         "initializeParams":{
           "sourceImage":"projects/debian-cloud/global/images/family/debian-12"
         },
         "autoDelete":true
       }
     ]
  }
}

Crea un gruppo di istanze gestite in ogni zona con Metodo instanceGroupManagers.insert, sostituendo PROJECT_ID con il tuo ID progetto.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/{zone}/instanceGroupManagers

{
  "name": "gl7-ilb-mig-a",
  "zone": "projects/PROJECT_ID/zones/ZONE_A",
  "instanceTemplate": "projects/PROJECT_ID/global/instanceTemplates/gil4-backendwest1-template",
  "baseInstanceName": "gl4-ilb-migb",
  "targetSize": 2
}

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

{
  "name":"gil4-backendeast1-template",
  "properties":{
     "machineType":"e2-standard-2",
     "tags":{
       "items":[
         "allow-ssh",
         "load-balanced-backend"
       ]
     },
     "metadata":{
        "kind":"compute#metadata",
        "items":[
          {
            "key":"startup-script",
            "value":"#! /bin/bash\napt-get update\napt-get install
            apache2 -y\na2ensite default-ssl\na2enmod ssl\n
            vm_hostname=\"$(curl -H \"Metadata-Flavor:Google\"           
            \\\nhttp://169.254.169.254/computeMetadata/v1/instance/name)\"\n
            echo \"Page served from: $vm_hostname\" | \\\ntee
            /var/www/html/index.html\nsystemctl restart apache2"
          }
        ]
     },
     "networkInterfaces":[
       {
         "network":"projects/PROJECT_ID/global/networks/NETWORK",
         "subnetwork":"regions/REGION_B/subnetworks/SUBNET_B",
         "accessConfigs":[
           {
             "type":"ONE_TO_ONE_NAT"
           }
         ]
       }
     ],
     "disks":[
       {
         "index":0,
         "boot":true,
         "initializeParams":{
           "sourceImage":"projects/debian-cloud/global/images/family/debian-12"
         },
         "autoDelete":true
       }
     ]
  }
}

Crea un gruppo di istanze gestite in ogni zona con Metodo instanceGroupManagers.insert, sostituendo PROJECT_ID con il tuo ID progetto.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/{zone}/instanceGroupManagers

{
  "name": "gl7-ilb-mig-b",
  "zone": "projects/PROJECT_ID/zones/ZONE_A",
  "instanceTemplate": "projects/PROJECT_ID/global/instanceTemplates/gil4-backendwest1-template",
  "baseInstanceName": "gl4-ilb-migb",
  "targetSize": 2
}

Configura il bilanciatore del carico

Questo esempio mostra come creare il seguente bilanciatore del carico di rete proxy interno tra regioni di risorse:

  • Un controllo di integrità TCP globale.
  • Un servizio di backend globale con gli stessi gruppi di istanze gestite del backend.
  • Un proxy di destinazione globale.
  • Due regole di forwarding globali con indirizzi IP a livello di regione. Per l'indirizzo IP della regola di forwarding, utilizza SUBNET_A o Intervallo di indirizzi IP SUBNET_B. Se prova a utilizzare una subnet solo proxy, la creazione della regola di forwarding non riesce.

Disponibilità proxy

A volte le regioni di Google Cloud non hanno una capacità proxy sufficiente per un nuovo bilanciatore del carico. In questo caso, la console Google Cloud fornisce quando crei il bilanciatore del carico. A risolvere il problema, puoi procedere in uno dei seguenti modi:

  • Seleziona una regione diversa per il bilanciatore del carico. Questo può essere un esempio se hai backend in un'altra regione.
  • Seleziona una rete VPC in cui è già allocata una subnet solo proxy.

  • Attendi che il problema relativo alla capacità venga risolto.

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. Per 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 proxy e fai clic su Avanti.
  5. Per Pubblico o interno, seleziona Interno e fai clic Avanti.
  6. Per Deployment tra più regioni o in una singola regione, seleziona Ideale per carichi di lavoro tra regioni e fai clic su Avanti.
  7. Fai clic su Configura.

Configurazione di base

  1. Specifica un nome per il bilanciatore del carico.
  2. In Rete, seleziona NETWORK.

Configura il frontend con due regole di forwarding

  1. Fai clic su Configurazione frontend.
    1. Specifica un nome per la regola di forwarding.
    2. Nell'elenco Regione subnet, seleziona REGION_A.

      Prenotare una subnet solo proxy

    3. Nell'elenco Subnet, seleziona SUBNET_A.
    4. Nell'elenco Indirizzo IP, fai clic su Crea indirizzo IP. Viene visualizzata la pagina Prenota un indirizzo IP interno statico.
      • Specifica un nome per l'indirizzo IP statico.
      • Nell'elenco Indirizzo IP statico, seleziona Fammi scegliere.
      • Nel campo Indirizzo IP personalizzato, inserisci 10.1.2.99.
      • Seleziona Prenota.
  2. Fai clic su Fine.
  3. Per aggiungere la seconda regola di forwarding, fai clic su Aggiungi IP e porta frontend.
    1. Specifica un nome per la regola di forwarding.
    2. Nell'elenco Regione subnet, seleziona REGION_B.

      Prenotare una subnet solo proxy

    3. Nell'elenco Subnet, seleziona SUBNET_B.
    4. Nell'elenco Indirizzo IP, fai clic su Crea indirizzo IP. Viene visualizzata la pagina Prenota un indirizzo IP interno statico.
      • Specifica un nome per l'indirizzo IP statico.
      • Nell'elenco Indirizzo IP statico, seleziona Fammi scegliere.
      • Nel campo Indirizzo IP personalizzato, inserisci 10.1.3.99.
      • Seleziona Prenota.
  4. Fai clic su Fine.
Configura il servizio di backend
  1. Fai clic su Configurazione backend.
  2. Nell'elenco Crea o seleziona servizi di backend, fai clic su Crea un di backend.
  3. Specifica un nome per il servizio di backend.
  4. Per Protocollo, seleziona TCP.
  5. In Porta denominata, inserisci http.
  6. Nell'elenco Tipo di backend, seleziona Gruppo di istanze.
  7. Nella sezione Nuovo backend:
    • Nell'elenco Gruppo di istanze, seleziona gl7-ilb-mig-a in REGION_A.
    • Imposta Numeri di porta su 80.
    • Fai clic su Fine.
    • Per aggiungere un altro backend, fai clic su Aggiungi backend.
    • Nell'elenco Gruppo di istanze, seleziona gl7-ilb-mig-b in REGION_B.
    • Imposta Numeri di porta su 80.
    • Fai clic su Fine.
  8. Nell'elenco Controllo di integrità, fai clic su Crea un controllo di integrità.
    • Nel campo Nome, inserisci global-http-health-check.
    • Imposta Protocollo su HTTP.
    • Imposta Porta su 80.
    • Fai clic su Salva.

Rivedi la configurazione

  1. Fai clic su Esamina e finalizza.
  2. Rivedi le impostazioni di configurazione del bilanciatore del carico.
  3. Fai clic su Crea.

gcloud

  1. Definisci il controllo di integrità TCP con il comando gcloud compute health-checks create tcp.

    gcloud compute health-checks create tcp global-health-check \
   --use-serving-port \
   --global

  2. Definisci il servizio di backend con il comando gcloud compute backend-services create.

    gcloud compute backend-services create gl4-gilb-backend-service \
  --load-balancing-scheme=INTERNAL_MANAGED \
  --protocol=TCP \
  --enable-logging \
  --logging-sample-rate=1.0 \
  --health-checks=global-health-check \
  --global-health-checks \
  --global

  3. Aggiungi backend al servizio di backend con il comando gcloud compute backend-services add-backend.

    gcloud compute backend-services add-backend gl4-gilb-backend-service \
  --balancing-mode=CONNECTION \
  --max-connections=50 \
  --instance-group=gl4-ilb-migb \
  --instance-group-zone=ZONE_A \
  --global

    gcloud compute backend-services add-backend gl4-gilb-backend-service \
  --balancing-mode=CONNECTION \
  --max-connections=50 \
  --instance-group=gl4-ilb-migb \
  --instance-group-zone=ZONE_B \
  --global

  4. Crea il proxy di destinazione.

    Crea il proxy di destinazione con il comando gcloud compute target-tcp-proxies create.

    gcloud compute target-tcp-proxies create gilb-tcp-proxy \
  --backend-service=gl4-gilb-backend-service \
  --global

  5. Creare due regole di forwarding, una con un VIP (10.1.2.99) in REGION_B e un'altra con VIP (10.1.3.99) nel mese di REGION_A. Per ulteriori informazioni, consulta Prenotare un indirizzo IPv4 interno statico.

    Per le reti personalizzate, devi fare riferimento alla subnet nella personalizzata. Tieni presente che questa è la subnet della VM, non la subnet proxy.

    Usa il comando gcloud compute forwarding-rules create con i flag corretti.

    gcloud compute forwarding-rules create gil4forwarding-rule-a \
  --load-balancing-scheme=INTERNAL_MANAGED \
  --network=NETWORK \
  --subnet=SUBNET_A \
  --subnet-region=REGION_A \
  --address=10.1.2.99 \
  --ports=80 \
  --target-tcp-proxy=gilb-tcp-proxy \
  --global

    gcloud compute forwarding-rules create gil4forwarding-rule-b \
  --load-balancing-scheme=INTERNAL_MANAGED \
  --network=NETWORK \
  --subnet=SUBNET_B \
  --subnet-region=REGION_B \
  --address=10.1.3.99 \
  --ports=80 \
  --target-tcp-proxy=gilb-tcp-proxy \
  --global

API

Crea il controllo di integrità effettuando una richiesta POST all'indirizzo healthChecks.insert, sostituendo PROJECT_ID con il tuo ID progetto.

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

{
"name": "global-health-check",
"type": "TCP",
"httpHealthCheck": {
  "portSpecification": "USE_SERVING_PORT"
}
}

Crea il servizio di backend globale effettuando una richiesta POST all'istanza backendServices.insert, sostituendo PROJECT_ID con il tuo ID progetto.

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

{
"name": "gl4-gilb-backend-service",
"backends": [
  {
    "group": "projects/PROJECT_ID/zones/ZONE_A/instanceGroups/gl4-ilb-migb",
    "balancingMode": "CONNECTION"
  },
  {
    "group": "projects/PROJECT_ID/zones/ZONE_B/instanceGroups/gl4-ilb-migb",
    "balancingMode": "CONNECTION"
  }
],
"healthChecks": [
  "projects/PROJECT_ID/regions/global/healthChecks/global-health-check"
],
"loadBalancingScheme": "INTERNAL_MANAGED"
}

Crea il proxy TCP di destinazione inviando una richiesta POST al targetTcpProxies.insert, sostituendo PROJECT_ID con il tuo ID progetto.

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

{
"name": "l4-ilb-proxy",
}

Crea la regola di forwarding effettuando una richiesta POST all'oggetto forwardingRules.insert, sostituendo PROJECT_ID con il tuo ID progetto.

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

{
"name": "gil4forwarding-rule-a",
"IPAddress": "10.1.2.99",
"IPProtocol": "TCP",
"portRange": "80-80",
"target": "projects/PROJECT_ID/global/targetTcpProxies/l4-ilb-proxy",
"loadBalancingScheme": "INTERNAL_MANAGED",
"subnetwork": "projects/PROJECT_ID/regions/REGION_A/subnetworks/SUBNET_A",
"network": "projects/PROJECT_ID/global/networks/NETWORK",
"networkTier": "PREMIUM"
}

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

{
"name": "gil4forwarding-rule-b",
"IPAddress": "10.1.3.99",
"IPProtocol": "TCP",
"portRange": "80-80",
"target": "projects/PROJECT_ID/global/targetTcpProxies/l4-ilb-proxy",
"loadBalancingScheme": "INTERNAL_MANAGED",
"subnetwork": "projects/PROJECT_ID/regions/REGION_B/subnetworks/SUBNET_B",
"network": "projects/PROJECT_ID/global/networks/NETWORK",
"networkTier": "PREMIUM"
}

Crea la regola di forwarding effettuando una richiesta POST all'oggetto globalForwardingRules.insert, sostituendo PROJECT_ID con il tuo ID progetto.

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

{
"name": "gil4forwarding-rule-a",
"IPAddress": "10.1.2.99",
"IPProtocol": "TCP",
"portRange": "80-80",
"target": "projects/PROJECT_ID/global/targetTcpProxies/l4-ilb-proxy",
"loadBalancingScheme": "INTERNAL_MANAGED",
"subnetwork": "projects/PROJECT_ID/regions/REGION_A/subnetworks/SUBNET_A",
"network": "projects/PROJECT_ID/global/networks/NETWORK",
"networkTier": "PREMIUM"
}

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

{
"name": "gil4forwarding-rule-b",
"IPAddress": "10.1.3.99",
"IPProtocol": "TCP",
"portRange": "80-80",
"target": "projects/PROJECT_ID/global/targetTcpProxies/l4-ilb-proxy",
"loadBalancingScheme": "INTERNAL_MANAGED",
"subnetwork": "projects/PROJECT_ID/regions/REGION_B/subnetworks/SUBNET_B",
"network": "projects/PROJECT_ID/global/networks/NETWORK",
"networkTier": "PREMIUM"
}

Testa il bilanciatore del carico

Crea un'istanza VM per testare la connettività

  1. Crea una VM client in REGION_B e REGION_A regioni:

    gcloud compute instances create l4-ilb-client-a \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --network=NETWORK \
    --subnet=SUBNET_A \
    --zone=ZONE_A \
    --tags=allow-ssh

    gcloud compute instances create l4-ilb-client-b \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --network=NETWORK \
    --subnet=SUBNET_B \
    --zone=ZONE_B \
    --tags=allow-ssh

  2. Utilizza SSH per connetterti a ciascuna istanza client.

    gcloud compute ssh l4-ilb-client-a --zone=ZONE_A

    gcloud compute ssh l4-ilb-client-b --zone=ZONE_B

  3. Verifica che l'indirizzo IP utilizzi il suo nome host

    • Verifica che la VM client possa raggiungere entrambi gli indirizzi IP. Il comando dovrebbe riuscire e restituire il nome della VM di backend che ha gestito la richiesta:

      curl 10.1.2.99

      curl 10.1.3.99

Testa failover

  1. Verifica il failover ai backend nella regione REGION_A quando i backend in REGION_B non sono integri o non sono raggiungibili. Per simulare il failover, rimuovi tutti backend di REGION_B:

    gcloud compute backend-services remove-backend gl4-gilb-backend-service \
  --instance-group=gl4-ilb-migb \
  --instance-group-zone=ZONE_B \
  --global

  2. Connettiti tramite SSH a una VM client in REGION_B.

    gcloud compute ssh l4-ilb-client-b \
   --zone=ZONE_B

  3. Invia richieste all'indirizzo IP con bilanciamento del carico nella regione REGION_B. L'output comando mostra le risposte delle VM di backend in REGION_A:

    {
RESULTS=
for i in {1..100}
do
  RESULTS="$RESULTS:$(curl -k -s 'https://test.example.com:443' --connect-to test.example.com:443:10.1.3.99:443)"
done
echo "***"
echo "*** Results of load-balancing to 10.1.3.99: "
echo "***"
echo "$RESULTS" | tr ':' '\n' | grep -Ev "^$" | sort | uniq -c
echo
}

Opzioni di configurazione aggiuntive

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

Protocollo PROXY per conservare le informazioni di connessione del client

Il bilanciatore del carico di rete proxy interno termina le connessioni TCP il client e crea nuove connessioni alle istanze VM. Per impostazione predefinita, le informazioni sull'IP e sulla porta del client originali non vengono conservate.

Per conservare e inviare le informazioni di connessione originali alle tue istanze, Attiva il protocollo PROXY (versione 1). Questo protocollo invia un'intestazione aggiuntiva contenente l'origine Indirizzo IP, indirizzo IP di destinazione e numeri di porta per l'istanza come parte della richiesta.

Assicurati che le istanze di backend del bilanciatore del carico di rete del proxy interno eseguano il protocollo HTTP o HTTPS che supportano le intestazioni del protocollo PROXY. Se l'interfaccia HTTP o I server HTTPS non sono configurate per supportare le intestazioni del protocollo PROXY, le istanze di backend diverse. Ad esempio, il protocollo PROXY non funziona con il protocollo Software server. Puoi utilizzare un software del server web diverso, ad esempio Nginx.

Se imposti il protocollo PROXY per il traffico degli utenti, devi impostarlo anche per il tuo controlli di integrità. Se stai controllando lo stato di integrità e la pubblicazione sulla stessa porta, imposta il valore --proxy-header del controllo di integrità in modo che corrisponda dell'impostazione del bilanciatore del carico.

L'intestazione del protocollo PROXY è in genere una singola riga di testo leggibile testo nel seguente formato:

PROXY TCP4 <client IP> <load balancing IP> <source port> <dest port>\r\n

Di seguito è riportato un esempio del protocollo PROXY:

PROXY TCP4 192.0.2.1 198.51.100.1 15221 110\r\n

Nell'esempio precedente, l'IP client è 192.0.2.1, l'IP di bilanciamento del carico è 198.51.100.1, la porta del client è 15221 e la porta di destinazione è 110.

Nei casi in cui l'IP del client non è noto, il bilanciatore del carico genera un'intestazione del protocollo PROXY nel seguente formato:

PROXY UNKNOWN\r\n

Aggiorna l'intestazione del protocollo PROXY per il proxy TCP di destinazione

L'esempio di configurazione del bilanciatore del carico in questa pagina mostra come Abilita l'intestazione del protocollo PROXY durante la creazione del bilanciatore del carico di rete proxy interno. Utilizza questi per modificare l'intestazione del protocollo PROXY per un proxy TCP di destinazione esistente.

Console

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

    Vai a Bilanciamento del carico

  2. Fai clic su Modifica per il tuo carico. con il bilanciatore del carico di rete passthrough esterno regionale.

  3. Fai clic su Configurazione frontend.

  4. Modifica il valore del campo Protocollo proxy su On.

  5. Fai clic su Update (Aggiorna) per salvare le modifiche.

gcloud

Nel comando seguente, modifica il campo --proxy-header e impostalo su NONE o PROXY_V1, a seconda delle tue esigenze.

gcloud compute target-ssl-proxies update int-tcp-target-proxy \
    --proxy-header=[NONE | PROXY_V1]

Utilizza lo stesso indirizzo IP tra più regole di forwarding interno

Per fare in modo che più regole di forwarding interno condividano lo stesso indirizzo IP interno, devi prenotare l'indirizzo IP e impostare il flag --purpose su SHARED_LOADBALANCER_VIP.

gcloud 

gcloud compute addresses create SHARED_IP_ADDRESS_NAME \
    --region=REGION \
    --subnet=SUBNET_NAME \
    --purpose=SHARED_LOADBALANCER_VIP

Abilita affinità sessione

La configurazione di esempio crea un servizio di backend senza affinità sessione.

Queste procedure mostrano come aggiornare un servizio di backend per un carico di esempio in modo che il servizio di backend utilizzi l'affinità IP client dell'affinità cookie generato.

Quando è abilitata l'affinità IP client, il bilanciatore del carico indirizza una particolare delle richieste del client alla stessa VM di backend in base a un hash creato l'indirizzo IP del client e l'indirizzo IP del bilanciatore del carico (l'indirizzo IP interno di una regola di forwarding interno).

Console

Per abilitare l'affinità sessione IP client:

  1. Nella console Google Cloud, vai alla pagina Bilanciamento del carico.
    Vai a Bilanciamento del carico
  2. Fai clic su Backend.
  3. Fai clic sul nome del servizio di backend che hai creato per questo esempio e fai clic su Modifica.
  4. Nella pagina Dettagli servizio di backend, fai clic su Avanzate. configurazione.
  5. In Affinità sessione, seleziona IP client dal menu.
  6. Fai clic su Aggiorna.

gcloud

Utilizza il seguente comando gcloud per aggiornare BACKEND_SERVICE servizio di backend, specificando affinità sessione IP client:

gcloud compute backend-services update BACKEND_SERVICE \
    --global \
    --session-affinity=CLIENT_IP

Abilita svuotamento della connessione

Puoi abilitare lo svuotamento della connessione sui servizi di backend per garantire il minimo agli utenti quando un'istanza che gestisce il traffico viene terminato, rimosso manualmente o rimosso da un gestore della scalabilità automatica. Per scoprire di più su per svuotamento della connessione, leggi Attivazione dello svuotamento della connessione documentazione.

Passaggi successivi