Configura un bilanciatore del carico delle applicazioni interno tra regioni con backend di gruppi di istanze VM

Questo documento fornisce istruzioni per configurare un bilanciatore del carico delle applicazioni interno tra regioni per i servizi in esecuzione su istanze di macchine virtuali (VM) Compute Engine.

Prima di iniziare

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

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 seguire questa guida, devi essere in grado di creare istanze e modificare una rete in un progetto. Devi essere un proprietario o un editor del progetto oppure devi disporre di tutti i seguenti ruoli IAM di Compute Engine.

Attività Ruolo richiesto
Crea reti, subnet e componenti del bilanciatore del carico Amministratore rete Compute
Aggiungere e rimuovere 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 delle applicazioni interno tra regioni.
Deployment ad alta disponibilità del bilanciatore del carico delle applicazioni interno tra regioni (fai clic per ingrandire).

Come mostrato nel diagramma, questo esempio crea un bilanciatore del carico delle applicazioni interno tra regioni in un una rete VPC, con un backend e due gruppi di istanze gestite di backend nel REGION_A e REGION_B regioni.

Il diagramma mostra quanto segue:

  1. Una rete VPC con le seguenti subnet:

    • Subnet SUBNET_A e una 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 di bilanciatori del carico delle applicazioni interni tra regioni. La subnet solo proxy della regione è condivisa tra tutti i bilanciatori del carico delle applicazioni interni tra regioni della regione. Gli indirizzi di origine dei pacchetti inviati dal bilanciatore del carico ai backend del servizio vengono allocati dalla subnet solo proxy. In questo esempio, la subnet solo proxy per la regione REGION_A ha un intervallo di indirizzi IP principali 10.129.0.0/23 e per REGION_B ha un intervallo di indirizzi IP principali 10.130.0.0/23, ovvero la dimensione subnet consigliata.

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

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

  4. Una mappa URL globale che analizza l'URL di una richiesta e inoltra le richieste a servizi di backend specifici in base all'host e al percorso dell'URL della richiesta.

  5. Un proxy HTTP o HTTPS di destinazione globale riceve una richiesta dall'utente e la inoltra alla mappa URL. Per HTTPS, configura un protocollo SSL globale di una risorsa di certificazione. Il proxy di destinazione utilizza il certificato SSL per decriptare il traffico SSL se configuri il bilanciamento del carico HTTPS. Il proxy di destinazione può inoltrare alle istanze utilizzando HTTP o HTTPS.

  6. Regole di forwarding globali hanno l'indirizzo IP interno regionale del tuo bilanciatore del carico, per 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 deve) provenire dalla stessa subnet dei gruppi di istanze di backend.
    • L'indirizzo IP non deve provenire da una subnet solo proxy riservata con il flag --purpose impostato su GLOBAL_MANAGED_PROXY.
    • Se vuoi utilizzare lo stesso indirizzo IP interno con più regole di inoltro, imposta il flag --purpose dell'indirizzo IP su SHARED_LOADBALANCER_VIP.

  7. (Facoltativo) Configura i criteri di routing DNS di tipo GEO per instradare il traffico client all'indirizzo VIP del bilanciatore del carico nella regione più vicina al client.

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 seguente rete VPC, regione e subnet:

  • Rete. La rete è una rete 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 nella regione REGION_B utilizza 10.1.3.0/24 per il suo intervallo IP principale.

  • 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 nella regione REGION_B utilizza 10.130.0.0/23 per il suo 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 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 Modalità di creazione subnet su Personalizzata.

  5. Crea 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. Crea 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_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 nella regione REGION_B 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 al 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 al 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. I proxy terminano le connessioni dal client e creano nuove connessioni ai backend.

Questa subnet solo proxy viene utilizzata da tutto il carico a livello di regione basato su Envoy nella stessa regione della rete VPC. Può 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 la sottorete solo proxy più tardi nella pagina Equilibrazione 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. Fornisci un nome per la subnet solo proxy.
  5. Seleziona una regione: REGION_A
  6. Nell'elenco Scopi, 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. Fornisci 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 della VPC nella rete lb-network-crs-reg utilizza 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 il metodo subnetworks.insert, sostituendo PROJECT_ID con l'ID del tuo 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 di destinazione 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 di 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 con bilanciamento del carico, che consente il traffico TCP sulle porte 80, 443 e 8080 da dei proxy gestiti del bilanciatore del carico delle applicazioni interno. Questo esempio utilizza il tag di destinazioneload-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, le regole del firewall si applicano 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 che consenta gli accessi 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 solo ai protocolli e alle porte che corrispondono a quelli utilizzati 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 come qualsiasi origine.

    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 i controlli di integrità di Google Cloud. Questo esempio consente tutto il traffico TCP proveniente dai probe del controllo di integrità. Tuttavia, puoi configurare un insieme più ristretto di porte in base alle tue esigenze.

    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 ai proxy dell'Application Load Balancer interno di connettersi ai tuoi backend. Imposta source-ranges sugli intervalli allocati della 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

Terraform

Per creare le regole firewall, utilizza la risorsa google_compute_firewall.

resource "google_compute_firewall" "fw_healthcheck" {
  name          = "gl7-ilb-fw-allow-hc"
  provider      = google-beta
  direction     = "INGRESS"
  network       = google_compute_network.default.id
  source_ranges = ["130.211.0.0/22", "35.191.0.0/16", "35.235.240.0/20"]
  allow {
    protocol = "tcp"
  }
}
 
resource "google_compute_firewall" "fw_ilb_to_backends" {
  name          = "fw-ilb-to-fw"
  provider      = google-beta
  network       = google_compute_network.default.id
  source_ranges = ["0.0.0.0/0"]
  allow {
    protocol = "tcp"
    ports    = ["22", "80", "443", "8080"]
  }
}
 
resource "google_compute_firewall" "fw_backends" {
  name          = "gl7-ilb-fw-allow-ilb-to-backends"
  direction     = "INGRESS"
  network       = google_compute_network.default.id
  source_ranges = ["10.129.0.0/23", "10.130.0.0/23"]
  target_tags   = ["http-server"]
  allow {
    protocol = "tcp"
    ports    = ["80", "443", "8080"]
  }
}

API

Crea la regola firewall fw-ilb-to-backends inviando una richiesta POST al metodo firewalls.insert, sostituendo PROJECT_ID con l'ID del tuo 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 delle applicazioni 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 sui server di backend. A scopo dimostrativo, 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 gil7-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 che segue nel campo 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 gil7-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 che segue nel campo 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 Gruppi di istanze gestite stateless o stateful.
    3. In Nome, inserisci gl7-ilb-mig-a.
    4. In Località, seleziona Zona singola.
    5. In Regione, seleziona REGION_A.
    6. In Zona, seleziona ZONE_A.
    7. In Modello di istanza, seleziona gil7-backendwest1-template.

    8. Specifica il numero di istanze che vuoi creare nel gruppo.

      Per questo esempio, specifica le seguenti opzioni in Scalabilità automatica:

      • Per la modalità di scalabilità automatica, seleziona Off:do not autoscale.
      • In Numero massimo di istanze, inserisci 2.

      Se vuoi, nella sezione Scalabilità automatica dell'interfaccia utente puoi configurare il gruppo di istanze in modo da aggiungere o rimuovere automaticamente le istanze in base all'utilizzo della CPU delle istanze.

    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 Gruppi di istanze gestite 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 gil7-backendeast1-template.

    17. Specifica il numero di istanze che vuoi creare nel gruppo.

      Per questo esempio, specifica le seguenti opzioni in Scalabilità automatica:

      • Per la 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 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 con il comando gcloud compute instance-templates create.

    gcloud compute instance-templates create gil7-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 gil7-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=gil7-backendwest1-template

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

Terraform

Per creare il modello di istanza, utilizza la risorsa google_compute_instance_template.

resource "google_compute_instance_template" "instance_template_a" {
  name         = "gil7-backendwest1-template"
  provider     = google-beta
  machine_type = "e2-small"
  region       = "us-west1"
  tags         = ["http-server"]

  network_interface {
    network    = google_compute_network.default.id
    subnetwork = google_compute_subnetwork.subnet_a.id
    access_config {
      # add external ip to fetch packages
    }
  }
  disk {
    source_image = "debian-cloud/debian-11"
    auto_delete  = true
    boot         = true
  }

  # install nginx and serve a simple web page
  metadata = {
    startup-script = <<-EOF1
      #! /bin/bash
      set -euo pipefail

      export DEBIAN_FRONTEND=noninteractive
      apt-get update
      apt-get install -y nginx-light jq

      NAME=$(curl -H "Metadata-Flavor: Google" "http://metadata.google.internal/computeMetadata/v1/instance/hostname")
      IP=$(curl -H "Metadata-Flavor: Google" "http://metadata.google.internal/computeMetadata/v1/instance/network-interfaces/0/ip")
      METADATA=$(curl -f -H "Metadata-Flavor: Google" "http://metadata.google.internal/computeMetadata/v1/instance/attributes/?recursive=True" | jq 'del(.["startup-script"])')

      cat <<EOF > /var/www/html/index.html
      <pre>
      Name: $NAME
      IP: $IP
      Metadata: $METADATA
      </pre>
      EOF
    EOF1
  }
  lifecycle {
    create_before_destroy = true
  }
}
 
resource "google_compute_instance_template" "instance_template_b" {
  name         = "gil7-backendeast1-template"
  provider     = google-beta
  machine_type = "e2-small"
  region       = "us-east1"
  tags         = ["http-server"]

  network_interface {
    network    = google_compute_network.default.id
    subnetwork = google_compute_subnetwork.subnet_b.id
    access_config {
      # add external ip to fetch packages
    }
  }
  disk {
    source_image = "debian-cloud/debian-11"
    auto_delete  = true
    boot         = true
  }

  # install nginx and serve a simple web page
  metadata = {
    startup-script = <<-EOF1
      #! /bin/bash
      set -euo pipefail

      export DEBIAN_FRONTEND=noninteractive
      apt-get update
      apt-get install -y nginx-light jq

      NAME=$(curl -H "Metadata-Flavor: Google" "http://metadata.google.internal/computeMetadata/v1/instance/hostname")
      IP=$(curl -H "Metadata-Flavor: Google" "http://metadata.google.internal/computeMetadata/v1/instance/network-interfaces/0/ip")
      METADATA=$(curl -f -H "Metadata-Flavor: Google" "http://metadata.google.internal/computeMetadata/v1/instance/attributes/?recursive=True" | jq 'del(.["startup-script"])')

      cat <<EOF > /var/www/html/index.html
      <pre>
      Name: $NAME
      IP: $IP
      Metadata: $METADATA
      </pre>
      EOF
    EOF1
  }
  lifecycle {
    create_before_destroy = true
  }
}

Per creare il gruppo di istanze gestite, utilizza la risorsa google_compute_instance_group_manager.

resource "google_compute_region_instance_group_manager" "mig_a" {
  name     = "gl7-ilb-miga"
  provider = google-beta
  region   = "us-west1"
  version {
    instance_template = google_compute_instance_template.instance_template_a.id
    name              = "primary"
  }
  base_instance_name = "vm"
  target_size        = 2
}
 
resource "google_compute_region_instance_group_manager" "mig_b" {
  name     = "gl7-ilb-migb"
  provider = google-beta
  region   = "us-east1"
  version {
    instance_template = google_compute_instance_template.instance_template_b.id
    name              = "primary"
  }
  base_instance_name = "vm"
  target_size        = 2
}

API

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

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

{
  "name":"gil7-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 il metodo instanceGroupManagers.insert, sostituendo PROJECT_ID con l'ID del tuo 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/gil7-backendwest1-template",
  "baseInstanceName": "gl7-ilb-mig-b",
  "targetSize": 2
}

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

{
  "name":"gil7-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_B",
  "instanceTemplate": "projects/PROJECT_ID/global/instanceTemplates/gil7-backendwest1-template",
  "baseInstanceName": "gl7-ilb-mig-b",
  "targetSize": 2
}

Configura il bilanciatore del carico

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

  • Un controllo di integrità HTTP globale.
  • Un servizio di backend globale con i gruppi di istanze gestite come backend.
  • Una mappa URL. Assicurati di fare riferimento a una mappa URL globale per il proxy HTTP(S) di destinazione. Una mappa URL globale instrada le richieste a un servizio di backend globale in base alle regole che definisci per l'host e il percorso di un URL in entrata. Una mappa URL globale è possibile fare riferimento a una regola proxy di destinazione globale.
  • Un certificato SSL globale (per HTTPS).
  • 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 SUBNET_B. Se prova a utilizzare una subnet solo proxy, la creazione della regola di forwarding non riesce.

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 delle applicazioni (HTTP/HTTPS) e fai clic su Avanti.
  4. In Pubblico o interno, seleziona Interno e fai clic su Avanti.
  5. Per Deployment tra più regioni o in una singola regione, seleziona Ideale per carichi di lavoro tra regioni e fai clic su Avanti.
  6. 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

Per HTTP:

  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.
      • Fornisci un nome per l'indirizzo IP statico.
      • Nell'elenco Indirizzo IP statico, seleziona Scelta manuale.
      • Nel campo Indirizzo IP personalizzato, inserisci 10.1.2.99.
      • Seleziona Prenota.
  2. Fai clic su Fine.
  3. Per aggiungere la seconda regola di inoltro, fai clic su Aggiungi IP e porta frontend.
    1. Specifica un nome per la regola di inoltro.
    2. Nell'elenco Regione della sottorete, seleziona REGION_B.

      Riservazione di 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.
      • Fornisci 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.

Per HTTPS:

Se utilizzi HTTPS tra il client e il bilanciatore del carico, hai bisogno di una o più risorse del certificato SSL per configurare il proxy. Per creare un all-regions certificato gestito da Google, consulta la seguente documentazione:

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

Per creare un certificato autogestito all-regions, consulta la documentazione seguente: Esegui il deployment di un certificato autogestito a livello di regione.

  1. Fai clic su Configurazione frontend.
    1. Specifica un nome per la regola di forwarding.
    2. Nel campo Protocollo, seleziona HTTPS (includes HTTP/2).
    3. Assicurati che Porta sia impostata su 443.
    4. Nell'elenco Regione della sottorete, seleziona REGION_A.

      Riservazione di una subnet solo proxy

    5. Nell'elenco Subnet, seleziona SUBNET_A.
    6. Nell'elenco Indirizzo IP, fai clic su Crea indirizzo IP. Viene visualizzata la pagina Prenota un indirizzo IP interno statico.
      • Fornisci 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.
    7. Nella sezione Aggiungi certificato, seleziona il certificato.
    8. (Facoltativo) Per aggiungere certificati oltre al certificato SSL principale:
      1. Fai clic su Aggiungi certificato.
      2. Seleziona il certificato dall'elenco.
    9. Seleziona un criterio SSL dall'elenco Criterio SSL. Se non hai creato alcun criterio SSL, viene applicato un criterio SSL predefinito di Google Cloud.
    10. Fai clic su Fine.

    Aggiungi la seconda configurazione frontend:

    1. Fornisci un nome per la configurazione frontend.
    2. Nel campo Protocollo, seleziona HTTPS (includes HTTP/2).
    3. Assicurati che Porta sia impostata su 443.
    4. Nell'elenco Regione della sottorete, seleziona REGION_B.

      Prenotare una subnet solo proxy

    5. Nell'elenco Subnet, seleziona SUBNET_B.
    6. Nell'elenco Indirizzo IP, fai clic su Crea indirizzo IP. Viene visualizzata la pagina Prenota un indirizzo IP interno statico.
      • Fornisci 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.
    7. Nella sezione Aggiungi certificato, seleziona il certificato.
    8. (Facoltativo) Per aggiungere certificati oltre al certificato SSL principale:
      1. Fai clic su Aggiungi certificato.
      2. Seleziona il certificato dall'elenco.
    9. Seleziona un criterio SSL dall'elenco dei criteri SSL, Se non hai creato qualsiasi criterio SSL, viene applicato un criterio SSL predefinito di Google Cloud.
    10. 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. In Protocollo, seleziona HTTP.
    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 gl4-ilb-miga 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 gl4-ilb-migb 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.

    Configurare le regole di routing

    1. Fai clic su Regole di routing.
    2. In Modalità, seleziona Regola host e percorso semplice.
    3. Assicurati che esista un solo servizio di backend per qualsiasi host e percorso senza corrispondenza.

    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à HTTP con il comando gcloud compute health-checks create http.

    gcloud compute health-checks create http global-http-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 BACKEND_SERVICE_NAME \
  --load-balancing-scheme=INTERNAL_MANAGED \
  --protocol=HTTP \
  --enable-logging \
  --logging-sample-rate=1.0 \
  --health-checks=global-http-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 BACKEND_SERVICE_NAME \
  --balancing-mode=UTILIZATION \
  --instance-group=gl7-ilb-mig-a \
  --instance-group-zone=ZONE_A \
  --global

    gcloud compute backend-services add-backend BACKEND_SERVICE_NAME \
  --balancing-mode=UTILIZATION \
  --instance-group=gl7-ilb-mig-b \
  --instance-group-zone=ZONE_B \
  --global

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

    gcloud compute url-maps create gl7-gilb-url-map \
  --default-service=BACKEND_SERVICE_NAME \
  --global

  5. 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=gl7-gilb-url-map \
  --global

    Per HTTPS:

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

    Dopo aver creato il certificato gestito da Google, allega il certificato direttamente 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 dei file ai nomi delle variabili.

    export LB_CERT=PATH_TO_PEM_FORMATTED_FILE

    export LB_PRIVATE_KEY=PATH_TO_LB_PRIVATE_KEY_FILE

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

    gcloud certificate-manager certificates create gilb-certificate \
  --private-key-file=$LB_PRIVATE_KEY \
  --certificate-file=$LB_CERT \
  --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=gl7-gilb-url-map \
  --certificate-manager-certificates=gilb-certificate \
  --global

  6. Crea due regole di inoltro, una con un VIP (10.1.2.99) nella regione REGION_B e un'altra con un VIP (10.1.3.99) nella regione REGION_A. Per ulteriori informazioni, consulta Prenota un indirizzo IPv4 interno statico.

    Per le reti personalizzate, devi fare riferimento alla subnet nella regola di inoltro. Tieni presente che questa è la subnet della VM, non la subnet 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=10.1.2.99 \
  --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=10.1.3.99 \
  --ports=80 \
  --target-http-proxy=gil7-http-proxy \
  --global

    Per HTTPS:

    Usa 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=10.1.2.99 \
  --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=10.1.3.99 \
  --ports=443 \
  --target-https-proxy=gil7-https-proxy \
  --global

Terraform

Per creare il controllo di integrità, utilizza la risorsa google_compute_health_check.

resource "google_compute_health_check" "default" {
  provider = google-beta
  name     = "global-http-health-check"
  http_health_check {
    port_specification = "USE_SERVING_PORT"
  }
}

Per creare il servizio di backend, utilizza la risorsa google_compute_backend_service.

resource "google_compute_backend_service" "default" {
  name                  = "gl7-gilb-backend-service"
  provider              = google-beta
  protocol              = "HTTP"
  load_balancing_scheme = "INTERNAL_MANAGED"
  timeout_sec           = 10
  health_checks         = [google_compute_health_check.default.id]
  backend {
    group           = google_compute_region_instance_group_manager.mig_a.instance_group
    balancing_mode  = "UTILIZATION"
    capacity_scaler = 1.0
  }
  backend {
    group           = google_compute_region_instance_group_manager.mig_b.instance_group
    balancing_mode  = "UTILIZATION"
    capacity_scaler = 1.0
  }
}

Per creare la mappa URL, utilizza la risorsa google_compute_url_map.

resource "google_compute_url_map" "default" {
  name            = "gl7-gilb-url-map"
  provider        = google-beta
  default_service = google_compute_backend_service.default.id
}

Per creare il proxy HTTP di destinazione, utilizza la risorsa google_compute_target_http_proxy.

resource "google_compute_target_http_proxy" "default" {
  name     = "gil7target-http-proxy"
  provider = google-beta
  url_map  = google_compute_url_map.default.id
}

Per creare le regole di forwarding, utilizza la risorsa google_compute_forwarding_rule.

resource "google_compute_global_forwarding_rule" "fwd_rule_a" {
  provider              = google-beta
  depends_on            = [google_compute_subnetwork.proxy_subnet_a]
  ip_address            = "10.1.2.99"
  ip_protocol           = "TCP"
  load_balancing_scheme = "INTERNAL_MANAGED"
  name                  = "gil7forwarding-rule-a"
  network               = google_compute_network.default.id
  port_range            = "80"
  target                = google_compute_target_http_proxy.default.id
  subnetwork            = google_compute_subnetwork.subnet_a.id
}
 
resource "google_compute_global_forwarding_rule" "fwd_rule_b" {
  provider              = google-beta
  depends_on            = [google_compute_subnetwork.proxy_subnet_b]
  ip_address            = "10.1.3.99"
  ip_protocol           = "TCP"
  load_balancing_scheme = "INTERNAL_MANAGED"
  name                  = "gil7forwarding-rule-b"
  network               = google_compute_network.default.id
  port_range            = "80"
  target                = google_compute_target_http_proxy.default.id
  subnetwork            = google_compute_subnetwork.subnet_b.id
}

Per scoprire come applicare o rimuovere una configurazione Terraform, consulta: Comandi Terraform di base.

API

Crea il controllo di integrità inviando una richiesta POST al metodo healthChecks.insert, sostituendo PROJECT_ID con l'ID del tuo progetto.

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

{
"name": "global-http-health-check",
"type": "HTTP",
"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": "BACKEND_SERVICE_NAME",
"backends": [
  {
    "group": "projects/PROJECT_ID/zones/ZONE_A/instanceGroups/gl7-ilb-mig-a",
    "balancingMode": "UTILIZATION"
  },
  {
    "group": "projects/PROJECT_ID/zones/ZONE_B/instanceGroups/gl7-ilb-mig-b",
    "balancingMode": "UTILIZATION"
  }
],
"healthChecks": [
  "projects/PROJECT_ID/regions/global/healthChecks/global-http-health-check"
],
"loadBalancingScheme": "INTERNAL_MANAGED"
}

Crea la mappa URL inviando una richiesta POST alla urlMaps.insert, sostituendo PROJECT_ID con il tuo ID progetto.

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

{
"name": "l7-ilb-map",
"defaultService": "projects/PROJECT_ID/global/backendServices/BACKEND_SERVICE_NAME"
}

Per HTTP:

Crea il proxy HTTP di destinazione effettuando una richiesta POST al targetHttpProxies.insert, sostituendo PROJECT_ID con il tuo ID progetto.

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

{
"name": "l7-ilb-proxy",
"urlMap": "projects/PROJECT_ID/global/urlMaps/l7-ilb-map"
}

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": "FWRULE_A",
"IPAddress": "10.1.2.99",
"IPProtocol": "TCP",
"portRange": "80-80",
"target": "projects/PROJECT_ID/global/targetHttpProxies/l7-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": "gil7forwarding-rule-b",
"IPAddress": "10.1.3.99",
"IPProtocol": "TCP",
"portRange": "80-80",
"target": "projects/PROJECT_ID/global/targetHttpProxies/l7-ilb-proxy",
"loadBalancingScheme": "INTERNAL_MANAGED",
"subnetwork": "projects/PROJECT_ID/regions/REGION_B/subnetworks/SUBNET_B",
"network": "projects/PROJECT_ID/global/networks/NETWORK",
"networkTier": "PREMIUM"
}

Per HTTPS:

Leggi i file del certificato e della chiave privata, quindi crea il certificato SSL. L'esempio seguente mostra come fare questo con Python.

from pathlib import Path
from pprint import pprint
from typing import Union

from googleapiclient import discovery


def create_regional_certificate(
    project_id: str,
    region: str,
    certificate_file: Union[str, Path],
    private_key_file: Union[str, Path],
    certificate_name: str,
    description: str = "Certificate created from a code sample.",
) -> dict:
    """
    Create a regional SSL self-signed certificate within your Google Cloud project.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        region: name of the region you want to use.
        certificate_file: path to the file with the certificate you want to create in your project.
        private_key_file: path to the private key you used to sign the certificate with.
        certificate_name: name for the certificate once it's created in your project.
        description: description of the certificate.

        Returns:
        Dictionary with information about the new regional SSL self-signed certificate.
    """
    service = discovery.build("compute", "v1")

    # Read the cert into memory
    with open(certificate_file) as f:
        _temp_cert = f.read()

    # Read the private_key into memory
    with open(private_key_file) as f:
        _temp_key = f.read()

    # Now that the certificate and private key are in memory, you can create the
    # certificate resource
    ssl_certificate_body = {
        "name": certificate_name,
        "description": description,
        "certificate": _temp_cert,
        "privateKey": _temp_key,
    }
    request = service.regionSslCertificates().insert(
        project=project_id, region=region, body=ssl_certificate_body
    )
    response = request.execute()
    pprint(response)

    return response

Crea il proxy HTTPS di destinazione inviando una richiesta POST al metodo targetHttpsProxies.insert, sostituendo PROJECT_ID con l'ID del tuo progetto.

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

{
"name": "l7-ilb-proxy",
"urlMap": "projects/PROJECT_ID/global/urlMaps/l7-ilb-map",
"sslCertificates": /projects/PROJECT_ID/global/sslCertificates/SSL_CERT_NAME
}

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": "FWRULE_A",
"IPAddress": "10.1.2.99",
"IPProtocol": "TCP",
"portRange": "80-80",
"target": "projects/PROJECT_ID/global/targetHttpsProxies/l7-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": "FWRULE_B",
"IPAddress": "10.1.3.99",
"IPProtocol": "TCP",
"portRange": "80-80",
"target": "projects/PROJECT_ID/global/targetHttpsProxies/l7-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:

    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 utilizzi il suo nome host

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

      curl 10.1.2.99

      curl 10.1.3.99

      Per il test HTTPS, sostituisci curl con la seguente riga di comando:

      curl -k 'https://test.example.com:443' --connect-to test.example.com:443:10.1.2.99:443

      curl -k 'https://test.example.com:443' --connect-to test.example.com:443:10.1.3.99:443

      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_NAME può essere service.example.com.

      curl DNS_NAME

Eseguire 100 richieste e verificare che siano con bilanciamento del carico

Per HTTP:

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

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

Per HTTPS:

  {
    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.2.99:443)"
    done
    echo ""
    echo " Results of load-balancing to 10.1.2.99: "
    echo "***"
    echo "$RESULTS" | tr ':' '\n' | grep -Ev "^$" | sort | uniq -c
    echo
  }
  

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

Test del 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 i backend da REGION_B:

    gcloud compute backend-services remove-backend BACKEND_SERVICE_NAME \
   --balancing-mode=UTILIZATION \
   --instance-group=gl7-ilb-mig-b \
   --instance-group-zone=ZONE_B

  2. Connettiti tramite SSH a una 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 del 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 opzioni di configurazione alternative e aggiuntive. Tutte le attività sono facoltative. Puoi eseguirle in qualsiasi ordine.

Attivare l'affinità sessione

Queste procedure mostrano come aggiornare un servizio di backend per l'esempio Bilanciatore del carico delle applicazioni interno regionale o bilanciatore del carico delle applicazioni interno tra regioni in modo che il servizio di backend utilizza affinità cookie generato, l'affinità dei campi di intestazione o l'affinità dei cookie HTTP.

Quando l'affinità cookie generata è attiva, il bilanciatore del carico emette un cookie alla prima richiesta. Per ogni richiesta successiva con lo stesso cookie, il caricamento Il bilanciatore indirizza la richiesta alla stessa istanza di macchina virtuale (VM) backend o endpoint. In questo esempio, il cookie è denominato GCILB.

Quando l'affinità del campo dell'intestazione è abilitata, il bilanciatore del carico instrada le richieste alle VM o agli endpoint di backend in un gruppo di endpoint di rete (NEG) in base al valore dell'intestazione HTTP denominata nel flag --custom-request-header. L'affinità del campo dell'intestazione è valida solo se il criterio di località del bilanciamento del carico è RING_HASH o MAGLEV e l'hash coerente del servizio di backend specifica il nome dell'intestazione HTTP.

Quando l'affinità cookie HTTP è abilitata, il bilanciatore del carico instrada le richieste a di backend o endpoint in un NEG, in base a un cookie HTTP denominato Flag HTTP_COOKIE con il flag facoltativo --affinity-cookie-ttl. Se il client non fornisce il cookie nella sua richiesta HTTP, il proxy genera il cookie e lo restituisce al client in un'intestazione Set-Cookie. Cookie HTTP di affinità è valido solo se il criterio per le località di bilanciamento del carico è RING_HASH o MAGLEV e l'hash coerente del servizio di backend specifica la cookie HTTP.

Console

Per attivare o modificare l'affinità di sessione per un servizio di backend:

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

    Vai a Bilanciamento del carico

  2. Fai clic su Backend.
  3. Fai clic su gil7-backend-service (il nome del servizio di backend 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 il tipo di affinità sessione che preferisci.
  6. Fai clic su Aggiorna.

gcloud

Utilizza i seguenti comandi Google Cloud CLI per aggiornare a diversi tipi di affinità sessione:

    gcloud compute backend-services update gil7-backend-service \
        --session-affinity=[GENERATED_COOKIE | HEADER_FIELD | HTTP_COOKIE | CLIENT_IP] \
        --global

API

Per impostare l'affinità sessione, effettua una richiesta "PATCH" alla backendServices/patch.

    PATCH https://compute.googleapis.com/compute/v1/projects/[PROJECT_ID]/global/backendServices/gil7-backend-service
    {
    "sessionAffinity": ["GENERATED_COOKIE" | "HEADER_FIELD" | "HTTP_COOKIE" | "CLIENT_IP" ]
    }

Limitare i client che possono inviare traffico al bilanciatore del carico

Puoi impedire ai client di connettersi a un VIP della regola di inoltro del bilanciatore del carico delle applicazioni interno configurando regole firewall in uscita su questi client. Imposta queste regole firewall su VM client specifiche in base agli account di servizio o ai tag.

Non puoi utilizzare le regole firewall per limitare il traffico in entrata a VIP di regole di inoltro del bilanciatore del carico delle applicazioni interno specifici. Qualsiasi client sullo stesso VPC e nella stessa regione della regola di forwarding che il VIP può generalmente inviare il traffico al VIP della regola di forwarding.

Inoltre, tutte le richieste ai backend provengono da proxy che utilizzano indirizzi IP La subnet solo proxy intervallo. Non è possibile creare regole firewall che consentono o negano il traffico in entrata il traffico su questi backend in base alla regola di forwarding VIP utilizzata da un client.

Ecco alcuni esempi di come utilizzare le regole firewall in uscita per limitare il traffico al VIP della regola di forwarding del bilanciatore del carico.

Console

Per identificare le VM client, tagga le VM specifiche che vuoi limitare. Questi tag vengono utilizzati per associare le regole firewall alle VM client con tag. Poi aggiungi il tag a TARGET_TAG. nei passaggi successivi.

Per configurarlo, utilizza una singola regola firewall o più regole.

Singola regola firewall in uscita

Puoi configurare una regola di uscita del firewall per negare tutto il traffico in uscita dalle VM client taggate all'IP virtuale di un bilanciatore del carico.

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

    Vai a Regole firewall

  2. Fai clic su Crea regola firewall per creare la regola per negare il traffico in uscita. il traffico dalle VM client codificate al VIP di un bilanciatore del carico.

    • Nome: fr-deny-access
    • Rete: lb-network
    • Priorità: 100
    • Direzione del traffico: in uscita
    • Azione in caso di corrispondenza: Nega
    • Target: tag di destinazione specificati
    • Tag di destinazione: TARGET_TAG
    • Filtro di destinazione: intervalli IP
    • Intervalli IP di destinazione: 10.1.2.99
    • Protocolli e porte:
      • Scegli Protocolli e porte specificati.
      • Seleziona la casella di controllo tcp, quindi inserisci 80 per il numero di porta.

  3. Fai clic su Crea.

Più regole firewall in uscita

Un approccio più scalabile implica l'impostazione di due regole. Una regola predefinita di bassa priorità che impedisce a tutti i client di accedere al VIP del bilanciatore del carico. Una seconda regola con priorità più alta che consente a un sottoinsieme di client taggati di accedere al VIP del bilanciatore del carico. Solo le VM con tag possono accedere al VIP.

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

    Vai a Regole firewall

  2. Fai clic su Crea regola firewall per creare la regola con priorità inferiore per negare l'accesso per impostazione predefinita:

    • Nome: fr-deny-all-access-low-priority
    • Rete: lb-network
    • Priorità: 200
    • Direzione del traffico: In uscita
    • Azione in caso di corrispondenza: Nega
    • Target: tag di destinazione specificati
    • Tag di destinazione: TARGET_TAG
    • Filtro di destinazione: intervalli IP
    • Intervalli IP di destinazione: 10.1.2.99
    • Protocolli e porte:
      • Scegli Protocolli e porte specificati.
      • Seleziona la casella di controllo TCP, quindi inserisci 80 per il numero di porta.

  3. Fai clic su Crea.

  4. Fai clic su Crea regola firewall per creare la regola con priorità più elevata per consentire il traffico da determinate istanze con tag.

    • Nome: fr-allow-some-access-high-priority
    • Rete: lb-network
    • Priorità: 100
    • Direzione del traffico: In uscita
    • Azione in caso di corrispondenza: Consenti
    • Target: tag di destinazione specificati
    • Tag di destinazione: TARGET_TAG
    • Filtro di destinazione: intervalli IP
    • Intervalli IP di destinazione: 10.1.2.99
    • Protocolli e porte:
      • Scegli Protocolli e porte specificati.
      • Seleziona la casella di controllo TCP, quindi inserisci 80 per il numero di porta.

  5. Fai clic su Crea.

gcloud

Per identificare le VM client, tagga VM specifiche vuoi limitare. Aggiungi il tag al campo TARGET_TAG seguendo questi passaggi.

Per configurarlo, utilizza una singola regola firewall o più regole.

Singola regola firewall in uscita

Puoi configurare una regola di uscita del firewall per negare tutto il traffico in uscita dalle VM client taggate all'IP virtuale di un bilanciatore del carico.

gcloud compute firewall-rules create fr-deny-access \
  --network=lb-network \
  --action=deny \
  --direction=egress \
  --rules=tcp \
  --priority=100 \
  --destination-ranges=10.1.2.99 \
  --target-tags=TARGET_TAG

Più regole firewall in uscita

Un approccio più scalabile implica l'impostazione di due regole: una predefinita, una priorità bassa che impedisce a tutti i client di accedere al VIP del bilanciatore del carico, seconda, una regola di priorità più alta che consente a un sottoinsieme di client con tag di accedere il VIP del bilanciatore del carico. Solo le VM codificate possono accedere al VIP.

  1. Crea la regola di priorità inferiore:

    gcloud compute firewall-rules create fr-deny-all-access-low-priority \
  --network=lb-network \
  --action=deny \
  --direction=egress \
  --rules=tcp \
  --priority=200 \
  --destination-ranges=10.1.2.99

  2. Crea la regola con priorità più alta:

    gcloud compute firewall-rules create fr-allow-some-access-high-priority \
  --network=lb-network \
  --action=allow \
  --direction=egress \
  --rules=tcp \
  --priority=100 \
  --destination-ranges=10.1.2.99 \
  --target-tags=TARGET_TAG

Per utilizzare gli account di servizio anziché i tag per controllare l'accesso, utilizza l'opzione --target-service-accounts anziché il flag --target-tags durante la creazione delle regole firewall.

Scala l'accesso limitato ai backend del bilanciatore del carico delle applicazioni interno in base alle subnet

Mantenimento di regole firewall separate o aggiunta di nuovi indirizzi IP con bilanciamento del carico di regole esistenti, come descritto nella sezione precedente, diventa scomodo perché aumenta il numero di regole di forwarding. Un modo per evitarlo è allocare gli indirizzi IP delle regole di inoltro da una subnet riservata. Quindi, il traffico proveniente da istanze con tag gli account di servizio possono essere consentiti o bloccati utilizzando la subnet riservata come dell'intervallo di destinazione per le regole firewall. In questo modo puoi controllare in modo efficace l'accesso a un gruppo di VIP delle regole di inoltro senza dover gestire le regole di uscita del firewall per VIP.

Di seguito sono riportati i passaggi generali per eseguire questa configurazione, supponendo che crei tutte le altre risorse richieste del bilanciatore del carico separatamente.

gcloud

  1. Crea una subnet a livello di regione che verrà utilizzata per allocare IP con bilanciamento del carico indirizzi per le regole di forwarding:

    gcloud compute networks subnets create l7-ilb-restricted-subnet \
  --network=lb-network \
  --region=us-west1 \
  --range=10.127.0.0/24

  2. Crea una regola di forwarding che prenda un indirizzo dal una subnet. L'esempio seguente utilizza l'indirizzo 10.127.0.1 della subnet creato nel passaggio precedente. 

    gcloud compute forwarding-rules create l7-ilb-forwarding-rule-restricted \
  --load-balancing-scheme=INTERNAL_MANAGED \
  --network=lb-network \
  --subnet=l7-ilb-restricted-subnet \
  --address=10.127.0.1 \
  --ports=80 \
  --global \
  --target-http-proxy=gil7-http-proxy

  3. Crea una regola firewall per limitare il traffico destinato agli indirizzi IP dell'intervallo nella subnet della regola di inoltro (l7-ilb-restricted-subnet):

    gcloud compute firewall-rules create restrict-traffic-to-subnet \
  --network=lb-network \
  --action=deny \
  --direction=egress \
  --rules=tcp:80 \
  --priority=100 \
  --destination-ranges=10.127.0.0/24 \
  --target-tags=TARGET_TAG

Utilizzare lo stesso indirizzo IP tra più regole di inoltro interne

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
Se devi reindirizzare il traffico HTTP a HTTPS, puoi creare due regole di forwarding che utilizzano un indirizzo IP comune. Per ulteriori informazioni, consulta la sezione Configurazione reindirizzamento da HTTP a HTTPS per bilanciatori del carico delle applicazioni interni.

Configura i criteri di routing DNS

Se i tuoi clienti si trovano in più regioni, potresti voler rendere accessibile il bilanciatore del carico delle applicazioni interno tra regioni utilizzando VIP in queste regioni. Questa configurazione multiregione riduce al minimo la latenza e i costi di transito della rete. Inoltre, ti consente di configurare una soluzione di bilanciamento del carico globale basata su DNS che offre resilienza contro le interruzioni a livello di regione. Per ulteriori informazioni, vedi Gestire i criteri di routing DNS e i controlli di integrità.

gcloud

Per creare una voce DNS con un TTL di 30 secondi, utilizza la 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"
              }
            ]
          }
        }
      ]
    }
  }
}

Aggiorna il timeout keepalive HTTP del client

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

Per aggiornare il timeout keepalive HTTP del client, segui le istruzioni riportate di seguito.

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. Per il timeout keepalive HTTP, inserisci un valore di timeout.
  6. Fai clic su Aggiorna.
  7. Per rivedere le modifiche, fai clic su Rivedi e finalizza e poi su Aggiorna.

gcloud

Per un bilanciatore del carico HTTP, aggiorna il proxy HTTP di destinazione utilizzando il metodo 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 metodo 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: valore di timeout keepalive HTTP da 5 a 600 secondi.

Abilita rilevamento outlier

Puoi attivare il rilevamento delle anomalie 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 delle anomalie viene attivato nel servizio di backend utilizzando uno dei seguenti metodi:

  • Il metodo consecutiveErrors (outlierDetection.consecutiveErrors), in che un codice di stato HTTP della serie 5xx viene classificato come 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 degli outlier, alcune richieste possono essere inviate al servizio non integro e restituire un codice 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, consulta 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 eseguire il servizio di backend modifica.

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

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

  5. Nella pagina Configurazione backend, fai clic su Modifica per il servizio di backend che che desideri 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 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 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 ricevuto da un Il proxy Envoy è pari o superiore a cinque, l'endpoint di backend viene escluso dalla di bilanciamento del carico del proxy Envoy per 30 secondi. Quando la percentuale di applicazione è impostata al 100%, il servizio di backend applica esclusione di endpoint in stato non integro dai rispettivi pool di bilanciamento del carico proxy Envoy specifici ogni volta che viene eseguita l'analisi di rilevamento degli outlier. Se sono soddisfatte le condizioni di espulsione, fino al 50% degli endpoint di backend il pool di bilanciamento del carico può essere escluso.

  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 di 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 del rilevamento di 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 sono soddisfatte le condizioni di espulsione, fino al 50% degli endpoint di backend il pool di bilanciamento del carico può essere escluso. 

    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 backend servizio
    • PROJECT_ID: l'ID del progetto
    • REGION_A e REGION_B: e 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 nel servizio di backend.

Passaggi successivi