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

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 sottoreti 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 del tuo 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 del tuo 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

Console

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

   Vai a Policy del 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. Per 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 e 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 e 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 e 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à di 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
   

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

7. Nella sezione Disco di avvio, assicurati che sia selezionata l'opzione Debian GNU/Linux 12 (bookworm) per le opzioni del disco di avvio. 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 la 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

Console

Per creare un gruppo di endpoint di rete zonale:

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

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

   Vai a Gruppi di endpoint di rete

2. Fai clic su 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 Personalizzata, inserisci il Numero di porta da utilizzare per l'endpoint.

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 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'
   

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 ibrida, 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 Subnet, scegli come indicato nel passaggio precedente.

8. Per 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 su 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 Personalizzata, puoi inserire un Numero di porta diverso per l'endpoint da utilizzare.

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

7. Dopo aver aggiunto tutti gli endpoint non Google 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 della 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 configurati in precedenza on-premise o nel tuo ambiente cloud. Ripeti --add-endpoint tutte le volte necessarie.

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 il logging 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 relativa al 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 gcloud CLI relativa al 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:

   • Crea un certificato gestito da Google emesso dalla tua istanza di Certificate Authority Service.
   • Crea un certificato gestito da Google con autorizzazione DNS.

   Dopo aver creato il certificato gestito da Google, collega il certificato 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:

   • Crea una chiave privata e un certificato.

   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 inoltro, una con un VIPIP_ADDRESS1 nella regioneREGION_A e un'altra con un VIP IP_ADDRESS2nella 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 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
   

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 set di record

  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 del tuo 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"
              }
            ]
          }
        }
      ]
    }
  }
}

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

4. Nella pagina Modifica bilanciatore del carico delle applicazioni interno tra regioni, fai clic su Configurazione backend.

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

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

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

8. Fai clic su editModifica per configurare il rilevamento delle anomalie.

   Verifica che le seguenti opzioni siano configurate con questi valori:

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

   In questo esempio, l'analisi di rilevamento degli outlier 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 espulso dal pool di bilanciamento del carico del 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 degli outlier. Se vengono soddisfatte le condizioni di espulsione, è 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 delle anomalie, come evidenziato nella seguente configurazione YAML, nella sezione outlierDetection:

   In questo esempio, l'analisi di rilevamento degli outlier 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 espulso dal pool di bilanciamento del carico del 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 degli outlier. Se vengono soddisfatte le condizioni di espulsione, è 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 degli outlier è ora abilitato nel servizio di backend.