Configura un bilanciatore del carico delle applicazioni interno tra regioni con connettività ibrida

Questa pagina mostra come eseguire il deployment di un bilanciatore del carico delle applicazioni interno multiregionale per bilanciare il carico del traffico verso endpoint di rete on-premise o in altri cloud pubblici e raggiungibili utilizzando la connettività ibrida.

Se non l'hai ancora fatto, consulta la panoramica dei NEG di connettività ibrida per comprendere i requisiti di rete per configurare il bilanciamento del carico ibrido.

Panoramica della configurazione

L'esempio configura un bilanciatore del carico delle applicazioni interno tra regioni per i backend NEG di connettività ibrida e a livello di zona mista, come mostrato nella figura seguente:

Esempio di bilanciatore del carico delle applicazioni interno tra regioni per backend NEG connettività ibrida e a livello di zona mista.
Esempio di bilanciatore del carico delle applicazioni interno tra regioni per backend NEG connettività ibrida e a livello di zona mista (fai clic per ingrandire).

Devi configurare la connettività ibrida prima di impostare un deployment del bilanciamento del carico ibrido. A seconda del prodotto di connettività ibrida che scegli, utilizza Cloud VPN o Cloud Interconnect (dedicato o partner).

Configura una risorsa del certificato SSL

Crea una risorsa del certificato SSL di Certificate Manager come descritto di seguito:

Ti consigliamo di utilizzare un certificato gestito da Google.

Autorizzazioni

Per configurare il bilanciamento del carico ibrido, devi disporre delle seguenti autorizzazioni:

  • On Google Cloud

  • Nel tuo ambiente on-premise o in un altro ambiente non cloudGoogle Cloud

    • Autorizzazioni per configurare endpoint di rete che consentono di raggiungere i servizi nel tuo ambiente on-premise o in altri ambienti cloud daGoogle Cloud utilizzando una combinazione di IP:Port. Per ulteriori informazioni, contatta l'amministratore di rete del tuo ambiente.
    • Autorizzazioni per creare regole firewall nel tuo ambiente on-premise o in altri ambienti cloud per consentire ai probe del controllo di integrità di Google di raggiungere gli endpoint.

Inoltre, per completare le istruzioni riportate in questa pagina, devi creare un NEG di connettività ibrida, un bilanciatore del carico e NEG di zona (e i relativi endpoint) da utilizzare come backend basati su Google Cloudper il bilanciatore del carico.

Devi essere proprietario o editor del progetto oppure disporre dei seguenti ruoli IAM di Compute Engine.

Attività Ruolo richiesto
Crea reti, subnet e componenti del bilanciatore del carico Compute Network Admin (roles/compute.networkAdmin)
Aggiungere e rimuovere regole firewall Compute Security Admin (roles/compute.securityAdmin)
Creazione delle istanze Compute Instance Admin (roles/compute.instanceAdmin)

Stabilire la connettività ibrida

Il tuo Google Cloud ambiente on-premise o altri ambienti cloud devono essere connessi tramite connettività ibrida utilizzando tunnel Cloud VPN o collegamenti VLAN di Cloud Interconnect con router Cloud o VM appliance router. Ti consigliamo di utilizzare una connessione a disponibilità elevata.

Un router Cloud abilitato con il routing dinamico globale apprende l'endpoint specifico tramite il protocollo Border Gateway Protocol (BGP) e lo programma nella rete VPC Google Cloud . Il routing dinamico regionale non è supportato. Anche le route statiche non sono supportate.

Puoi utilizzare la stessa rete o una rete VPC diversa all'interno dello stesso progetto per configurare sia il networking ibrido (Cloud Interconnect o Cloud VPN o una VM appliance router) sia il bilanciatore del carico. Nota quanto segue:

  • Se utilizzi reti VPC diverse, le due reti devono essere connesse tramite il peering di rete VPC oppure devono essere spoke VPC nello stesso hub Network Connectivity Center.

  • Se utilizzi la stessa rete VPC, assicurati che gli intervalli CIDR delle subnet della rete VPC non siano in conflitto con gli intervalli CIDR remoti. Quando gli indirizzi IP si sovrappongono, le route di subnet hanno la priorità sulla connettività remota.

Per istruzioni, consulta la seguente documentazione:

Configura l'ambiente esterno a Google Cloud

Per configurare l'ambiente on-premise o un altro ambiente cloud per il bilanciamento del carico ibrido:

  • Configura gli endpoint di rete per esporre i servizi on-premise a Google Cloud (IP:Port).
  • Configura le regole firewall nel tuo ambiente on-premise o in un altro ambiente cloud.
  • Configura il router Cloud per annunciare determinate route richieste al tuo ambiente privato.

Configura endpoint di rete

Dopo aver configurato la connettività ibrida, configuri uno o più endpoint di rete all'interno del tuo ambiente on-premise o di altri ambienti cloud raggiungibili tramite Cloud Interconnect o Cloud VPN o appliance router utilizzando una combinazione IP:port. Questa combinazione IP:port è configurata come uno o più endpoint per il NEG di connettività ibrida che viene creato in Google Cloud in un secondo momento di questa procedura.

Se esistono più percorsi per l'endpoint IP, il routing segue il comportamento descritto nella panoramica di Cloud Router.

Configura le regole firewall

Le seguenti regole firewall devono essere create nel tuo ambiente on-premise o in un altro ambiente cloud:

  • Crea una regola firewall di autorizzazione in entrata in ambienti on-premise o in altri cloud per consentire al traffico dalla subnet solo proxy della regione di raggiungere gli endpoint.

  • L'autorizzazione del traffico dagli intervalli di probe del controllo di integrità di Google non è obbligatoria per i NEG ibridi. Tuttavia, se utilizzi una combinazione di NEG ibridi e zonali in un unico servizio di backend, devi consentire il traffico dagli intervalli di probe di controllo di integrità di Google per i NEG zonali.

Configura Cloud Router per annunciare i seguenti intervalli IP personalizzati al tuo ambiente on-premise o a un altro ambiente cloud:

  • L'intervallo della subnet solo proxy della regione.

Configura l'ambiente Google Cloud

Per i passaggi seguenti, assicurati di utilizzare la stessa rete VPC (denominata NETWORK in questa procedura) che è stata utilizzata per configurare la connettività ibrida tra gli ambienti.

Inoltre, assicurati che le regioni utilizzate (denominate REGION_A e REGION_B in questa procedura) siano le stesse utilizzate per creare il tunnel Cloud VPN o i collegamenti VLAN di Cloud Interconnect.

Se vuoi, puoi configurare le policy di routing DNS di tipo GEO per instradare il traffico client al VIP del bilanciatore del carico nella regione più vicina al client durante le interruzioni regionali.

Configura le subnet di backend

Utilizza questa subnet per creare i backend NEG zonali del bilanciatore del carico:

Console

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

    Vai a Reti VPC

  2. Vai alla rete utilizzata per configurare la connettività ibrida tra gli ambienti.

  3. Nella sezione Subnet:

    • Imposta Modalità di creazione subnet su Personalizzata.
    • 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.
    • Fai clic su Fine.

  4. Fai clic su Crea.

  5. Per aggiungere altre subnet in regioni diverse, fai clic su Aggiungi subnet e ripeti i passaggi precedenti per REGION_B

gcloud

  1. Crea subnet nella rete utilizzata per configurare la connettività ibrida tra gli ambienti.

    gcloud compute networks subnets create SUBNET_A \
    --network=NETWORK \
    --range=LB_SUBNET_RANGE1 \
    --region=REGION_A

    gcloud compute networks subnets create SUBNET_B \
    --network=NETWORK \
    --range=LB_SUBNET_RANGE2 \
    --region=REGION_B

API

Invia una richiesta POST al metodo subnetworks.insert. Sostituisci PROJECT_ID con l'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/NETWORK",
 "ipCidrRange": "LB_SUBNET_RANGE1",
 "region": "projects/PROJECT_ID/regions/REGION_A",
}

Invia una richiesta POST al metodo subnetworks.insert. Sostituisci PROJECT_ID con l'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": "LB_SUBNET_RANGE2",
 "region": "projects/PROJECT_ID/regions/REGION_B",
}

Sostituisci quanto segue:

  • SUBNET_A e SUBNET_B: il nome delle subnet
  • LB_SUBNET_RANGE1 e LB_SUBNET_RANGE2: l'intervallo di indirizzi IP per le subnet
  • REGION_A e REGION_B: le regioni in cui hai configurato il bilanciatore del carico

Configura la subnet solo proxy

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

Questa subnet solo proxy viene utilizzata da tutti i bilanciatori del carico regionali basati su Envoy nella stessa regione della rete VPC. Può esserci una sola subnet solo proxy attiva per un determinato scopo, per regione e per rete.

Console

Se utilizzi la console Google Cloud , puoi attendere e creare la subnet solo proxy in un secondo momento nella pagina Bilanciamento del carico.

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

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

    Vai a Reti VPC

  2. Fai clic sul nome della rete VPC.
  3. Nella scheda Subnet, fai clic su Aggiungi subnet.
  4. Fornisci un Nome per la subnet solo proxy.
  5. Nell'elenco Regione, seleziona REGION_A.
  6. Nell'elenco Scopo, seleziona Proxy gestito cross-region.
  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. Fai clic su Aggiungi subnet.
  2. Fornisci un Nome per la subnet solo proxy.
  3. Nell'elenco Regione, seleziona REGION_B.
  4. Nell'elenco Scopo, seleziona Proxy gestito cross-region.
  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 il comando 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=PROXY_ONLY_SUBNET_RANGE1
    
    gcloud compute networks subnets create PROXY_SN_B \
        --purpose=GLOBAL_MANAGED_PROXY \
        --role=ACTIVE \
        --region=REGION_B \
        --network=NETWORK \
        --range=PROXY_ONLY_SUBNET_RANGE2

Sostituisci quanto segue:

  • PROXY_SN_A e PROXY_SN_B: il nome delle subnet solo proxy
  • PROXY_ONLY_SUBNET_RANGE1 e PROXY_ONLY_SUBNET_RANGE2: l'intervallo di indirizzi IP per le subnet solo proxy
  • REGION_A e REGION_B: le regioni in cui hai configurato il bilanciatore del carico

API

Crea le subnet solo proxy con il metodo subnetworks.insert, sostituendo PROJECT_ID con l'ID progetto.

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

    {
      "name": "PROXY_SN_A",
      "ipCidrRange": "PROXY_ONLY_SUBNET_RANGE1",
      "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": "PROXY_ONLY_SUBNET_RANGE2",
      "network": "projects/PROJECT_ID/global/networks/NETWORK",
      "region": "projects/PROJECT_ID/regions/REGION_B",
      "purpose": "GLOBAL_MANAGED_PROXY",
      "role": "ACTIVE"
    }

Crea regole firewall

In questo esempio, crei le seguenti regole firewall per i backend NEG a livello di zona su Google Cloud:

  • fw-allow-health-check: una regola in entrata, applicabile alle istanze con bilanciamento del carico, che consente il traffico proveniente dai sistemi di controllo di integritàGoogle Cloud (130.211.0.0/22 e 35.191.0.0/16). Questo esempio utilizza il tag di destinazione allow-health-check per identificare i NEG di zona a cui deve essere applicata.
  • fw-allow-ssh: una regola in entrata che consente la connettività SSH in entrata sulla porta TCP 22 da qualsiasi indirizzo. Puoi scegliere un intervallo di indirizzi IP di origine più restrittivo per questa regola. Ad esempio, puoi specificare solo gli intervalli IP dei sistemi da cui inizierai le sessioni SSH. Questo esempio utilizza il tag di destinazione allow-ssh per identificare le istanze di macchine virtuali (VM) a cui deve essere applicato.

  • fw-allow-proxy-only-subnet: una regola di ingresso che consente alle connessioni dalla subnet solo proxy di raggiungere i backend NEG zonali.

Console

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

    Vai a Criteri firewall

  2. Fai clic su Crea regola firewall per creare la regola che consente il traffico proveniente dai probe del controllo di integrità:

    1. Inserisci un nome per fw-allow-health-check.
    2. In Rete, seleziona NETWORK.
    3. In Destinazioni, seleziona Tag di destinazione specificati.
    4. Compila il campo Tag di destinazione con allow-health-check.
    5. Imposta Filtro di origine su Intervalli IPv4.
    6. Imposta Intervalli IPv4 di origine su 130.211.0.0/22 e 35.191.0.0/16.
    7. In Protocolli e porte, seleziona Protocolli e porte specificati.
    8. Seleziona TCP, quindi inserisci 80 per il numero di porta.
    9. Fai clic su Crea.

  3. Fai di nuovo clic su Crea regola firewall per creare la regola per consentire le connessioni SSH in entrata:

    1. Nome: fw-allow-ssh
    2. Rete: NETWORK
    3. Priorità: 1000
    4. Direzione del traffico: in entrata
    5. Azione in caso di corrispondenza: Consenti
    6. Target: Tag di destinazione specificati
    7. Tag di destinazione: allow-ssh
    8. Filtro di origine: intervalli IPv4
    9. Intervalli IPv4 di origine: 0.0.0.0/0
    10. Protocolli e porte: scegli Protocolli e porte specificati.
    11. Seleziona TCP, quindi inserisci 22 per il numero di porta.
    12. Fai clic su Crea.

  4. Fai di nuovo clic su Crea regola firewall per creare la regola che consente le connessioni in entrata dalla subnet solo proxy:

    1. Nome: fw-allow-proxy-only-subnet
    2. Rete: NETWORK
    3. Priorità: 1000
    4. Direzione del traffico: in entrata
    5. Azione in caso di corrispondenza: Consenti
    6. Target: Tag di destinazione specificati
    7. Tag di destinazione: allow-proxy-only-subnet
    8. Filtro di origine: intervalli IPv4
    9. Intervalli IPv4 di origine: PROXY_ONLY_SUBNET_RANGE1 e PROXY_ONLY_SUBNET_RANGE2
    10. Protocolli e porte: scegli Protocolli e porte specificati
    11. Seleziona TCP, quindi inserisci 80 per il numero di porta.
    12. Fai clic su Crea.

gcloud

  1. Crea la regola fw-allow-health-check-and-proxy per consentire ai controlli di integrità Google Cloud di raggiungere le istanze di backend sulla porta TCP 80:

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

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

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

  3. Crea una regola firewall di autorizzazione in entrata per la subnet solo proxy per consentire al bilanciatore del carico di comunicare con le istanze di backend sulla porta TCP 80:

    gcloud compute firewall-rules create fw-allow-proxy-only-subnet \
    --network=NETWORK \
    --action=allow \
    --direction=ingress \
    --target-tags=allow-proxy-only-subnet \
    --source-ranges=PROXY_ONLY_SUBNET_RANGE1,PROXY_ONLY_SUBNET_RANGE2 \
    --rules=tcp:80

Configura il NEG a livello di zona

Per i backend basati su Google Cloud, ti consigliamo di configurare più NEG zonali nella stessa regione in cui hai configurato la connettività ibrida.

Per questo esempio, configura un NEG a livello di zona (con endpoint di tipo GCE_VM_IP_PORT) nella regione REGION_A. Crea prima le VM nella zona ZONE_A. Quindi, crea un NEG zonale nella zona ZONE_A e poi aggiungi gli endpoint di rete delle VM al NEG. Per supportare l'alta disponibilità, configura un NEG zonale simile nella regione REGION_B. Se i backend in una regione non sono attivi, il traffico viene sottoposto a failover nell'altra regione.

Crea VM

Console

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

    Vai a Istanze VM

  2. Ripeti i passaggi da 3 a 8 per ogni VM, utilizzando le seguenti combinazioni di nome e zona.

    • Nome: di vm-a1
      • Zona: ZONE_A nella regione REGION_A
      • Subnet: SUBNET_A
    • Nome: di vm-b1
      • Zona: ZONE_B nella regione REGION_B
      • Subnet: SUBNET_B

  3. Fai clic su Crea istanza.

  4. Imposta il nome come indicato nel passaggio precedente.

  5. Per Regione, scegli come indicato nel passaggio precedente.

  6. Per la zona, scegli come indicato nel passaggio precedente.

  7. Nella sezione Disco di avvio, assicurati che per le opzioni del disco di avvio sia selezionata l'opzione Debian GNU/Linux 12 (bookworm). Fai clic su Scegli per modificare l'immagine, se necessario.

  8. Nella sezione Opzioni avanzate, espandi Networking e segui questi passaggi:

    • Aggiungi i seguenti Tag di rete: allow-ssh,allow-health-check e allow-proxy-only-subnet.
    • Nella sezione Interfacce di rete, fai clic su Aggiungi un'interfaccia di rete, apporta le seguenti modifiche e poi fai clic su Fine:
      • Rete: NETWORK
      • Subnet: come indicato nel passaggio precedente.
      • IP interno principale: Temporaneo (automatico)
      • IP esterno: Temporaneo

    • Espandi Gestione. Nel campo Automazione, copia e incolla i seguenti contenuti dello script. I contenuti dello script sono identici per tutte 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

  9. Fai clic su Crea.

gcloud

Crea le VM eseguendo il seguente comando, utilizzando queste combinazioni per il nome della VM e della relativa zona. I contenuti dello script sono identici per entrambe le VM.

gcloud compute instances create VM_NAME \
    --zone=GCP_NEG_ZONE \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --tags=allow-ssh,allow-health-check,allow-proxy-only-subnet \
    --subnet=LB_SUBNET_NAME \
    --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'
  • VM_NAME di vm-a1
    • La zona GCP_NEG_ZONE come ZONE_A nella regione REGION_A
    • La subnet LB_SUBNET_NAME come SUBNET_A
  • VM_NAME di vm-b1
    • ZonaGCP_NEG_ZONE come ZONE_B nella regione REGION_B
    • Subnet LB_SUBNET_NAME come SUBNET_B

Crea il NEG a livello di zona

Console

Per creare un gruppo di endpoint di rete a livello di zona:

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

    Vai a Gruppi di endpoint di rete

  2. Ripeti i passaggi da 3 a 8 per ogni NEG zonale, utilizzando le seguenti combinazioni di nome e zona:

    • Nome: neg-1
      • Zona: ZONE_A nella regione REGION_A
      • Subnet: SUBNET_A
    • Nome: neg-2
      • Zona: ZONE_B nella regione REGION_B
      • Subnet: SUBNET_B

  3. Fai clic su Crea gruppo di endpoint di rete.

  4. Imposta il nome come indicato nel passaggio precedente.

  5. Seleziona il tipo di gruppo di endpoint di rete: Gruppo di endpoint di rete (a livello di zona).

  6. Seleziona la rete: NETWORK

  7. Seleziona la subnet come indicato nel passaggio precedente.

  8. Seleziona la zona come indicato nel passaggio precedente.

  9. Inserisci la Porta predefinita: 80.

  10. Fai clic su Crea.

Aggiungi endpoint al NEG di zona:

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

    Vai a Gruppi di endpoint di rete

  2. Fai clic sul nome del gruppo di endpoint di rete creato nel passaggio precedente. Viene visualizzata la pagina Dettagli gruppo di endpoint di rete.

  3. Nella sezione Endpoint di rete in questo gruppo, fai clic su Aggiungi endpoint di rete. Viene visualizzata la pagina Aggiungi endpoint di rete.

  4. Seleziona un'istanza VM per aggiungere i relativi indirizzi IP interni come endpoint di rete. Nella sezione Interfaccia di rete vengono visualizzati il nome, la zona e la subnet della VM.

  5. Inserisci l'indirizzo IP del nuovo endpoint di rete.

  6. Seleziona il Tipo di porta.

    1. Se selezioni Predefinito, l'endpoint utilizza la porta predefinita 80 per tutti gli endpoint nel gruppo di endpoint di rete. Questo è sufficiente per il nostro esempio perché il server Apache gestisce le richieste sulla porta 80.
    2. Se selezioni Personalizzato, inserisci il Numero di porta per l'endpoint da utilizzare.

  7. Per aggiungere altri endpoint, fai clic su Aggiungi endpoint di rete e ripeti i passaggi precedenti.

  8. Dopo aver aggiunto tutti gli endpoint, fai clic su Crea.

gcloud

  1. Crea NEG di zona (con endpoint GCE_VM_IP_PORT) utilizzando le combinazioni di nome, zona e subnet. Utilizza il comando gcloud compute network-endpoint-groups create.

    gcloud compute network-endpoint-groups create GCP_NEG_NAME \
    --network-endpoint-type=GCE_VM_IP_PORT \
    --zone=GCP_NEG_ZONE \
    --network=NETWORK \
    --subnet=LB_SUBNET_NAME
    • Nome: neg-1
      • Zona GCP_NEG_ZONE: ZONE_A nella regione REGION_A
      • Subnet LB_SUBNET_NAME: SUBNET_A
    • Nome: neg-2
      • Zona GCP_NEG_ZONE: ZONE_B nella regione REGION_B
      • Subnet LB_SUBNET_NAME: SUBNET_B

    Puoi specificare una porta utilizzando l'opzione --default-port durante la creazione del NEG oppure specificare un numero di porta per ogni endpoint come mostrato nel passaggio successivo.

  2. Aggiungi endpoint a neg1 e neg2.

    gcloud compute network-endpoint-groups update neg1 \
    --zone=ZONE_A \
    --add-endpoint='instance=vm-a1,port=80'

    gcloud compute network-endpoint-groups update neg2 \
    --zone=ZONE_B \
    --add-endpoint='instance=vm-b1,port=80'

Configura il NEG di connettività ibrida

Quando crei il NEG, utilizza una zona che riduca al minimo la distanza geografica tra Google Cloud e il tuo ambiente on-premise o un altro ambiente cloud. Ad esempio, se ospiti un servizio in un ambiente on-premise a Francoforte, in Germania, puoi specificare la zona europe-west3-a Google Cloud quando crei il gruppo di elenchi di esclusione.

Inoltre, se utilizzi Cloud Interconnect, la zona utilizzata per creare il NEG si trova nella stessa regione in cui è stato configurato il collegamento Cloud Interconnect.

I NEG ibridi supportano solo i controlli di integrità Envoy distribuiti.

Console

Per creare un gruppo di endpoint di rete con connettività ibrida:

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

    Vai a Gruppi di endpoint di rete

  2. Fai clic su Crea gruppo di endpoint di rete.

  3. Ripeti i passaggi da 4 a 9 per ogni NEG ibrido, utilizzando le seguenti combinazioni di nome e zona.

    • Nome ON_PREM_NEG_NAME: hybrid-1
      • Zona: ON_PREM_NEG_ZONE1
      • Subnet: SUBNET_A
    • Nome ON_PREM_NEG_NAME: hybrid-2
      • Zona: ON_PREM_NEG_ZONE2
      • Subnet: SUBNET_B

  4. Imposta il nome come indicato nel passaggio precedente.

  5. Seleziona il tipo di gruppo di endpoint di rete: gruppo di endpoint di rete con connettività ibrida (a livello di zona).

  6. Seleziona la rete: NETWORK

  7. Per la subnet, scegli come indicato nel passaggio precedente.

  8. Per la Zona, scegli come indicato nel passaggio precedente.

  9. Inserisci la Porta predefinita.

  10. Fai clic su Crea

Aggiungi endpoint al NEG di connettività ibrida:

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

    Vai a Gruppi di endpoint di rete

  2. Fai clic sul nome del gruppo di endpoint di rete creato nel passaggio precedente. Viene visualizzata la pagina Dettagli gruppo di endpoint di rete.

  3. Nella sezione Endpoint di rete in questo gruppo, fai clic su Aggiungi endpoint di rete. Viene visualizzata la pagina Aggiungi endpoint di rete.

  4. Inserisci l'indirizzo IP del nuovo endpoint di rete.

  5. Seleziona il Tipo di porta.

    1. Se selezioni Predefinito, l'endpoint utilizza la porta predefinita per tutti gli endpoint nel gruppo di endpoint di rete.
    2. Se selezioni Personalizzato, puoi inserire un Numero di porta diverso da utilizzare per l'endpoint.

  6. Per aggiungere altri endpoint, fai clic su Aggiungi endpoint di rete e ripeti i passaggi precedenti.

  7. Dopo aver aggiunto tutti gli endpoint nonGoogle Cloud , fai clic su Crea.

gcloud

  1. Crea un NEG di connettività ibrida che utilizzi le seguenti combinazioni di nomi. Utilizza il comando gcloud compute network-endpoint-groups create.

    gcloud compute network-endpoint-groups create ON_PREM_NEG_NAME \
    --network-endpoint-type=NON_GCP_PRIVATE_IP_PORT \
    --zone=ON_PREM_NEG_ZONE \
    --network=NETWORK
    • Nome ON_PREM_NEG_NAME: hybrid-1
      • Zona ON_PREM_NEG_ZONE: ON_PREM_NEG_ZONE1
    • Nome ON_PREM_NEG_NAME: hybrid-2
      • Zona GCP_NEG_ZONE: ON_PREM_NEG_ZONE2

  2. Aggiungi l'endpoint VM di backend on-premise a ON_PREM_NEG_NAME:

    gcloud compute network-endpoint-groups update ON_PREM_NEG_NAME \
    --zone=ON_PREM_NEG_ZONE \
    --add-endpoint="ip=ON_PREM_IP_ADDRESS_1,port=PORT_1" \
    --add-endpoint="ip=ON_PREM_IP_ADDRESS_2,port=PORT_2"

Puoi utilizzare questo comando per aggiungere gli endpoint di rete che hai configurato in precedenza on-premise o nel tuo ambiente cloud. Ripeti --add-endpoint tutte le volte necessarie.

Configura il bilanciatore del carico

Console

gcloud

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

    gcloud compute health-checks create http gil7-basic-check \
   --use-serving-port \
   --global

  2. Crea il servizio di backend e abilita la registrazione con il comando gcloud compute backend-services create.

    gcloud compute backend-services create BACKEND_SERVICE \
  --load-balancing-scheme=INTERNAL_MANAGED \
  --protocol=HTTP \
  --enable-logging \
  --logging-sample-rate=1.0 \
  --health-checks=gil7-basic-check \
  --global-health-checks \
  --global

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

    gcloud compute backend-services add-backend BACKEND_SERVICE \
  --global \
  --balancing-mode=RATE \
  --max-rate-per-endpoint=MAX_REQUEST_RATE_PER_ENDPOINT \
  --network-endpoint-group=neg1 \
  --network-endpoint-group-zone=ZONE_A \
  --network-endpoint-group=neg2 \
  --network-endpoint-group-zone=ZONE_B

    Per informazioni dettagliate sulla configurazione della modalità di bilanciamento, consulta la documentazione gcloud CLI per il flag --max-rate-per-endpoint.

  4. Aggiungi i NEG ibridi come backend al servizio di backend.

    gcloud compute backend-services add-backend BACKEND_SERVICE \
  --global \
  --balancing-mode=RATE \
  --max-rate-per-endpoint=MAX_REQUEST_RATE_PER_ENDPOINT \
  --network-endpoint-group=hybrid1 \
  --network-endpoint-group-zone=ON_PREM_NEG_ZONE1 \
  --network-endpoint-group=hybrid2 \
  --network-endpoint-group-zone=ON_PREM_NEG_ZONE2 \

    Per informazioni dettagliate sulla configurazione della modalità di bilanciamento, consulta la documentazione di gcloud CLI per il parametro --max-rate-per-endpoint.

  5. Crea la mappa URL con il comando gcloud compute url-maps create.

    gcloud compute url-maps create gil7-map \
  --default-service=BACKEND_SERVICE \
  --global

  6. Crea il proxy di destinazione.

    Per HTTP:

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

    gcloud compute target-http-proxies create gil7-http-proxy \
  --url-map=gil7-map \
  --global

    Per HTTPS:

    Per creare un certificato gestito da Google, consulta la seguente documentazione:

    Dopo aver creato il certificato gestito da Google, collegalo al proxy di destinazione. Le mappe dei certificati non sono supportate dai bilanciatori del carico delle applicazioni interni tra regioni.

    Per creare un certificato autogestito, consulta la seguente documentazione:

    Assegna i percorsi file ai nomi delle variabili.

    export LB_CERT=PATH_TO_PEM_FORMATTED_FILE

    export LB_PRIVATE_KEY=PATH_TO_PEM_LB_PRIVATE_FILE

    Crea un certificato SSL per tutte le regioni utilizzando il comando gcloud certificate-manager certificates create.

    gcloud certificate-manager certificates create gilb-certificate \
  --private-key-file=$LB_CERT \
  --certificate-file=$LB_PRIVATE_KEY \
  --scope=all-regions

    Utilizza il certificato SSL per creare un proxy di destinazione con il comando gcloud compute target-https-proxies create

    gcloud compute target-https-proxies create gil7-https-proxy \
  --url-map=gil7-map \
  --certificate-manager-certificates=gilb-certificate \
  --global

  7. Crea due regole di forwarding, una con un VIP IP_ADDRESS1 nella regione REGION_A e un'altra con un VIP IP_ADDRESS2 nella regione REGION_B. Per l'indirizzo IP della regola di forwarding, utilizza l'intervallo di indirizzi IP LB_SUBNET_RANGE1 o LB_SUBNET_RANGE2. Se provi a utilizzare la subnet solo proxy, la creazione della regola di forwarding non va a buon fine.

    Per le reti personalizzate, devi fare riferimento alla subnet nella regola di inoltro. Tieni presente che si tratta della subnet della VM, non della subnet del proxy.

    Per HTTP:

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

    gcloud compute forwarding-rules create FWRULE_A \
  --load-balancing-scheme=INTERNAL_MANAGED \
  --network=NETWORK \
  --subnet=SUBNET_A \
  --subnet-region=REGION_A \
  --address=IP_ADDRESS1 \
  --ports=80 \
  --target-http-proxy=gil7-http-proxy \
  --global

    gcloud compute forwarding-rules create FWRULE_B \
  --load-balancing-scheme=INTERNAL_MANAGED \
  --network=NETWORK \
  --subnet=SUBNET_B \
  --subnet-region=REGION_B \
  --address=IP_ADDRESS2 \
  --ports=80 \
  --target-http-proxy=gil7-http-proxy \
  --global

    Per HTTPS:

    Crea la regola di forwarding con il comando gcloud compute forwarding-rules create con i flag corretti.

    gcloud compute forwarding-rules create FWRULE_A \
  --load-balancing-scheme=INTERNAL_MANAGED \
  --network=NETWORK \
  --subnet=SUBNET_A \
  --subnet-region=REGION_A \
  --address=IP_ADDRESS1 \
  --ports=443 \
  --target-https-proxy=gil7-https-proxy \
  --global

    gcloud compute forwarding-rules create FWRULE_B \
  --load-balancing-scheme=INTERNAL_MANAGED \
  --network=NETWORK \
  --subnet=SUBNET_B \
  --subnet-region=REGION_B \
  --address=IP_ADDRESS2 \
  --ports=443 \
  --target-https-proxy=gil7-https-proxy \
  --global

Collegare il dominio al bilanciatore del carico

Dopo aver creato il bilanciatore del carico, prendi nota dell'indirizzo IP associato al bilanciatore del carico, ad esempio IP_ADDRESS1 e IP_ADDRESS2. Per indirizzare il tuo dominio al bilanciatore del carico, crea un record A utilizzando Cloud DNS o il servizio di registrazione del dominio. Se hai aggiunto più domini al certificato SSL, devi aggiungere un record A per ciascuno, tutti indirizzati all'indirizzo IP del bilanciamento del carico.

testa il bilanciatore del carico

Crea un'istanza VM per testare la connettività

  1. Crea una VM client:

    gcloud compute instances create l7-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 l7-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 ogni istanza client.

    gcloud compute ssh l7-ilb-client-a \
   --zone=ZONE_A

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

  3. Verifica che l'indirizzo IP stia gestendo il proprio 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:

      Per il test HTTP:

      curl IP_ADDRESS1

      curl IP_ADDRESS2

      Per il test HTTPS:

      curl -k -s 'https://DOMAIN_NAME:443' --connect-to DOMAIN_NAME:443:IP_ADDRESS1:443

      curl -k -s 'https://DOMAIN_NAME:443' --connect-to DOMAIN_NAME:443:IP_ADDRESS2:443

      Sostituisci DOMAIN_NAME con il nome di dominio dell'applicazione, ad esempio test.example.com.

      Il flag -k fa sì che curl salti la convalida del certificato.

    • (Facoltativo) Utilizza il record DNS configurato per risolvere l'indirizzo IP più vicino alla VM client. Ad esempio, DNS_ENTRY può essere service.example.com.

      curl DNS_ENTRY

Esegui 100 richieste

Esegui 100 richieste curl e verifica dalle risposte che il carico sia bilanciato.

Per HTTP:

  • 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:

    {
  RESULTS=
  for i in {1..100}
  do
    RESULTS="$RESULTS:$(curl --silent IP_ADDRESS1)"
  done
  echo "***"
  echo "*** Results of load-balancing to IP_ADDRESS1: "
  echo "***"
  echo "$RESULTS" | tr ':' '\n' | grep -Ev "^$" | sort | uniq -c
  echo
}

    {
  RESULTS=
  for i in {1..100}
  do
    RESULTS="$RESULTS:$(curl --silent IP_ADDRESS2)"
  done
  echo "***"
  echo "*** Results of load-balancing to IP_ADDRESS2: "
  echo "***"
  echo "$RESULTS" | tr ':' '\n' | grep -Ev "^$" | sort | uniq -c
  echo
}

Per HTTPS:

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

    Sostituisci DOMAIN_NAME con il nome di dominio dell'applicazione, ad esempio test.example.com.

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

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

Testa il failover

  1. Verifica il failover ai backend nella regione REGION_A quando i backend nella regione REGION_B sono in stato non integro o non raggiungibili. Simuliamo questa situazione rimuovendo tutti i backend da REGION_B:

    gcloud compute backend-services remove-backend BACKEND_SERVICE \
   --balancing-mode=RATE \
   --network-endpoint-group=neg2 \
   --network-endpoint-group-zone=ZONE_B

  2. Utilizza SSH per connetterti alla VM client in REGION_B.

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

  3. Invia richieste all'indirizzo IP bilanciato del carico nella regione REGION_B. L'output è simile al seguente:

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

Opzioni di configurazione aggiuntive

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

Configura le policy di routing DNS

Se i tuoi client si trovano in più regioni, potresti voler rendere accessibile il bilanciatore del carico delle applicazioni interno tra regioni utilizzando VIP in queste regioni. Puoi utilizzare le norme di routing DNS di tipo GEO per instradare il traffico client al VIP del bilanciatore del carico nella regione più vicina al client. Questa configurazione multiregionale riduce al minimo la latenza e i costi di transito di rete. Inoltre, ti consente di configurare una soluzione di bilanciamento del carico globale basata su DNS che offre resilienza alle interruzioni a livello di regione.

Cloud DNS supporta il controllo di integrità e consente il failover automatico quando gli endpoint non superano i controlli di integrità. Durante un failover, Cloud DNS regola automaticamente la suddivisione del traffico tra gli endpoint integri rimanenti. Per ulteriori informazioni, consulta Gestire le policy di routing DNS e i controlli di integrità.

gcloud

Per creare una voce DNS con un TTL di 30 secondi, utilizza il comando gcloud dns record-sets create.

gcloud dns record-sets create DNS_ENTRY --ttl="30" \
  --type="A" --zone="service-zone" \
  --routing-policy-type="GEO" \
  --routing-policy-data="REGION_A=gil7-forwarding-rule-a@global;REGION_B=gil7-forwarding-rule-b@global" \
  --enable-health-checking

Sostituisci quanto segue:

  • DNS_ENTRY: DNS o nome di dominio del record set

    Ad esempio, service.example.com

  • REGION_A e REGION_B: le regioni in cui hai configurato il bilanciatore del carico

API

Crea il record DNS inviando una richiesta POST al metodo ResourceRecordSets.create. Sostituisci PROJECT_ID con l'ID progetto.

POST https://www.googleapis.com/dns/v1/projects/PROJECT_ID/managedZones/SERVICE_ZONE/rrsets
{
  "name": "DNS_ENTRY",
  "type": "A",
  "ttl": 30,
  "routingPolicy": {
    "geo": {
      "items": [
        {
          "location": "REGION_A",
          "healthCheckedTargets": {
            "internalLoadBalancers": [
              {
                "loadBalancerType": "globalL7ilb",
                "ipAddress": "IP_ADDRESS",
                "port": "80",
                "ipProtocol": "tcp",
                "networkUrl": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
                "project": "PROJECT_ID"
              }
            ]
          }
        },
        {
          "location": "REGION_B",
          "healthCheckedTargets": {
            "internalLoadBalancers": [
              {
                "loadBalancerType": "globalL7ilb",
                "ipAddress": "IP_ADDRESS_B",
                "port": "80",
                "ipProtocol": "tcp",
                "networkUrl": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
                "project": "PROJECT_ID"
              }
            ]
          }
        }
      ]
    }
  }
}

Aggiorna il timeout keepalive HTTP del client

Il bilanciatore del carico creato nei passaggi precedenti è stato configurato con un valore predefinito per il timeout keep-alive HTTP client.

Per aggiornare il timeout keepalive HTTP del client, segui queste istruzioni.

Console

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

    Vai a Bilanciamento del carico.

  2. Fai clic sul nome del bilanciatore del carico da modificare.
  3. Fai clic su Modifica.
  4. Fai clic su Configurazione frontend.
  5. Espandi Funzionalità avanzate. In Timeout keepalive HTTP, inserisci un valore di timeout.
  6. Fai clic su Aggiorna.
  7. Per rivedere le modifiche, fai clic su Rivedi e finalizza, quindi fai clic su Aggiorna.

gcloud

Per un bilanciatore del carico HTTP, aggiorna il proxy HTTP di destinazione utilizzando il comando gcloud compute target-http-proxies update:

      gcloud compute target-http-proxies update TARGET_HTTP_PROXY_NAME \
          --http-keep-alive-timeout-sec=HTTP_KEEP_ALIVE_TIMEOUT_SEC \
          --global

Per un bilanciatore del carico HTTPS, aggiorna il proxy HTTPS di destinazione utilizzando il comando gcloud compute target-https-proxies update:

      gcloud compute target-https-proxies update TARGET_HTTPS_PROXY_NAME \
          --http-keep-alive-timeout-sec=HTTP_KEEP_ALIVE_TIMEOUT_SEC \
          --global

Sostituisci quanto segue:

  • TARGET_HTTP_PROXY_NAME: il nome del proxy HTTP di destinazione.
  • TARGET_HTTPS_PROXY_NAME: il nome del proxy HTTPS di destinazione.
  • HTTP_KEEP_ALIVE_TIMEOUT_SEC: il valore del timeout keepalive HTTP da 5 a 600 secondi.

Abilita rilevamento outlier

Puoi attivare il rilevamento di outlier sui servizi di backend globali per identificare i NEG serverless non integri e ridurre il numero di richieste inviate ai NEG serverless non integri.

Il rilevamento dei valori anomali è abilitato nel servizio di backend utilizzando uno dei seguenti metodi:

  • Il metodo consecutiveErrors (outlierDetection.consecutiveErrors), in cui un codice di stato HTTP della serie 5xx viene considerato un errore.
  • Il metodo consecutiveGatewayFailure (outlierDetection.consecutiveGatewayFailure), in cui solo i codici di stato HTTP 502, 503 e 504 sono considerati errori.

Per attivare il rilevamento degli outlier per un servizio di backend esistente: Tieni presente che, anche dopo aver attivato il rilevamento dei valori anomali, alcune richieste possono essere inviate al servizio non integro e restituire un codice di stato 5xx ai client. Per ridurre ulteriormente il tasso di errore, puoi configurare valori più aggressivi per i parametri di rilevamento degli outlier. Per ulteriori informazioni, vedi il campo outlierDetection.

Console

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

    Vai a Bilanciamento del carico

  2. Fai clic sul nome del bilanciatore del carico di cui vuoi modificare il servizio di backend.

  3. Nella pagina Dettagli del bilanciatore del carico, fai clic su Modifica.

  4. Nella pagina Modifica bilanciatore del carico delle applicazioni interno cross-region, fai clic su Configurazione backend.

  5. Nella pagina Configurazione backend, fai clic su Modifica per il servizio di backend che vuoi modificare.

  6. Scorri verso il basso ed espandi la sezione Configurazioni avanzate.

  7. Nella sezione Rilevamento outlier, seleziona la casella di controllo Attiva.

  8. Fai clic su Modifica per configurare il rilevamento degli outlier.

    Verifica che le seguenti opzioni siano configurate con questi valori:

    Proprietà Valore
    Errori consecutivi 5
    Intervallo 1000
    Tempo di espulsione base 30000
    Percentuale massima di espulsione 50
    Applicazione di errori consecutivi 100

    In questo esempio, l'analisi di rilevamento dei valori anomali viene eseguita ogni secondo. Se il numero di codici di stato HTTP 5xx consecutivi ricevuti da un proxy Envoy è pari o superiore a cinque, l'endpoint di backend viene escluso dal pool di bilanciamento del carico di quel proxy Envoy per 30 secondi. Quando la percentuale di applicazione è impostata su 100%, il servizio di backend applica l'espulsione degli endpoint non integri dai pool di bilanciamento del carico di questi proxy Envoy specifici ogni volta che viene eseguita l'analisi di rilevamento outlier. Se le condizioni di espulsione sono soddisfatte, è possibile espellere fino al 50% degli endpoint del backend dal pool di bilanciamento del carico.

  9. Fai clic su Salva.

  10. Per aggiornare il servizio di backend, fai clic su Aggiorna.

  11. Per aggiornare il bilanciatore del carico, nella pagina Modifica bilanciatore del carico delle applicazioni interno tra regioni, fai clic su Aggiorna.

gcloud

  1. Esporta il servizio di backend in un file YAML.

    gcloud compute backend-services export BACKEND_SERVICE_NAME \
  --destination=BACKEND_SERVICE_NAME.yaml --global

    Sostituisci BACKEND_SERVICE_NAME con il nome del servizio di backend.

  2. Modifica la configurazione YAML del servizio di backend per aggiungere i campi per il rilevamento di outlier come evidenziato nella seguente configurazione YAML, nella sezione outlierDetection:

    In questo esempio, l'analisi di rilevamento dei valori anomali viene eseguita ogni secondo. Se il numero di codici di stato HTTP 5xx consecutivi ricevuti da un proxy Envoy è pari o superiore a cinque, l'endpoint di backend viene escluso dal pool di bilanciamento del carico di quel proxy Envoy per 30 secondi. Quando la percentuale di applicazione è impostata su 100%, il servizio di backend applica l'espulsione degli endpoint non integri dai pool di bilanciamento del carico di questi proxy Envoy specifici ogni volta che viene eseguita l'analisi di rilevamento outlier. Se le condizioni di espulsione sono soddisfatte, è possibile espellere fino al 50% degli endpoint del backend dal pool di bilanciamento del carico. 

    name: BACKEND_SERVICE_NAME
backends:
- balancingMode: UTILIZATION
  capacityScaler: 1.0
  group: https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION_A/networkEndpointGroups/SERVERLESS_NEG_NAME
- balancingMode: UTILIZATION
  capacityScaler: 1.0
  group: https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION_B/networkEndpointGroups/SERVERLESS_NEG_NAME_2
outlierDetection:
  baseEjectionTime:
    nanos: 0
    seconds: 30
  consecutiveErrors: 5
  enforcingConsecutiveErrors: 100
  interval:
    nanos: 0
    seconds: 1
  maxEjectionPercent: 50
port: 80
selfLink: https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/backendServices/BACKEND_SERVICE_NAME
sessionAffinity: NONE
timeoutSec: 30
...

    Sostituisci quanto segue:

    • BACKEND_SERVICE_NAME: il nome del servizio di backend
    • PROJECT_ID: l'ID del progetto
    • REGION_A e REGION_B: le regioni in cui è stato configurato il bilanciatore del carico.
    • SERVERLESS_NEG_NAME: il nome del primo NEG serverless
    • SERVERLESS_NEG_NAME_2: il nome del secondo NEG serverless

  3. Aggiorna il servizio di backend importando la configurazione più recente.

    gcloud compute backend-services import BACKEND_SERVICE_NAME \
  --source=BACKEND_SERVICE_NAME.yaml --global

    Il rilevamento outlier è ora abilitato sul servizio di backend.

Passaggi successivi