Configura un bilanciatore del carico delle applicazioni esterno globale con backend di gruppi di istanze VM

Console

Per supportare il traffico IPv4 e IPv6, segui questi passaggi:

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

   Vai a Reti VPC

2. Fai clic su Crea rete VPC.

3. Inserisci un nome per la rete.

4. (Facoltativo) Se vuoi configurare intervalli di indirizzi IPv6 interni sulle subnet di questa rete, completa questi passaggi:

   1. Per Intervallo IPv6 interno ULA rete VPC, seleziona Attivato.

   2. Per Alloca intervallo IPv6 interno, seleziona Automaticamente o Manualmente.

      Se selezioni Manualmente, inserisci un intervallo di /48 all'interno dell'intervallo fd20::/20. Se l'intervallo è in uso, ti viene chiesto di fornire un intervallo diverso.

5. Per la Modalità di creazione subnet, scegli Personalizzata.

6. Nella sezione Nuova subnet, configura i seguenti campi:

   1. Nel campo Nome, fornisci un nome per la subnet.
   2. Nel campo Regione, seleziona una regione.
   3. Per Tipo di stack IP, seleziona IPv4 e IPv6 (stack doppio).

   4. Nel campo Intervallo di indirizzi IP, inserisci un intervallo di indirizzi IP. Questo è l'intervallo IPv4 principale per la subnet.

      Sebbene tu possa configurare un intervallo di indirizzi IPv4 per la subnet, non puoi scegliere l'intervallo di indirizzi IPv6 per la subnet. Google fornisce un blocco CIDR IPv6 di dimensioni fisse (/64).

   5. Per Tipo di accesso IPv6, seleziona Esterno.

7. Fai clic su Fine.

8. Fai clic su Crea.

Per supportare solo il traffico IPv4:

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

   Vai a Reti VPC

2. Fai clic su Crea rete VPC.

3. Nel campo Nome, inserisci un nome per la rete.

4. Per la Modalità di creazione subnet, scegli Personalizzata.

5. Nella sezione Nuova subnet, configura quanto segue:

   1. Nel campo Nome, fornisci un nome per la subnet.
   2. Nel campo Regione, seleziona una regione.
   3. Per Tipo di stack IP, seleziona IPv4 (stack singolo).
   4. Nel campo Intervallo di indirizzi IP, inserisci l'intervallo IPv4 primario per la subnet.

6. Fai clic su Fine.

7. Fai clic su Crea.

gcloud

1. Crea la rete VPC in modalità personalizzata:

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

2. All'interno della rete, crea una subnet per i backend.

   Per il traffico IPv4 e IPv6, utilizza il seguente comando per aggiornare una subnet:

   gcloud compute networks subnets create SUBNET \
      --stack-type=IPV4_IPv6 \
      --ipv6-access-type=EXTERNAL \
      --network=NETWORK \
      --range=IPV4_RANGE \
      --region=REGION_A
   

   Per Solo traffico IPv4, utilizza il seguente comando:

   gcloud compute networks subnets create SUBNET \
      --network=NETWORK \
      --stack-type=IPV4_ONLY \
      --range=IPV4_RANGE \
      --region=REGION_A
   

Sostituisci quanto segue:

• NETWORK: un nome per la rete VPC

• IPV4_RANGE: l'intervallo IPv4 principale per la nuova subnet, nella notazione CIDR. Ad esempio, 10.1.2.0/24.

• SUBNET: un nome per la subnet

• REGION_A: il nome della regione

Console

Per supportare il traffico IPv4 e IPv6, segui questi passaggi:

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

   Vai a Template di istanza

2. Fai clic su Crea modello istanza.

3. In Nome, inserisci lb-backend-template.

4. Nell'elenco Regione, seleziona una regione.

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

6. Espandi Opzioni avanzate.

7. Espandi Networking e configura i seguenti campi:

   1. In Tag di rete, inserisci allow-health-check,allow-health-check-ipv6.
   2. Nella sezione Interfacce di rete, fai clic su editModifica. Configura i seguenti campi:
      • Rete: NETWORK
      • Subnet: SUBNET
      • Tipo di stack IP: IPv4 e IPv6 (stack doppio)
   3. Fai clic su Fine.

8. Espandi Gestione. Nel campo Script di avvio, inserisci il seguente 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
   

9. Fai clic su Crea.

gcloud

Per supportare sia il traffico IPv4 che IPv6, esegui questo comando:

gcloud compute instance-templates create TEMPLATE_NAME \
  --region=REGION \
  --network=NETWORK \
  --subnet=SUBNET \
  --stack-type=IPv4_IPv6 \
  --tags=allow-health-check,allow-health-check-ipv6 \
  --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://metadata.google.internal/computeMetadata/v1/instance/name)"
    echo "Page served from: $vm_hostname" | \
    tee /var/www/html/index.html
    systemctl restart apache2'

Terraform

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

resource "google_compute_instance_template" "default" {
  name = "lb-backend-template"
  disk {
    auto_delete  = true
    boot         = true
    device_name  = "persistent-disk-0"
    mode         = "READ_WRITE"
    source_image = "projects/debian-cloud/global/images/family/debian-11"
    type         = "PERSISTENT"
  }
  labels = {
    managed-by-cnrm = "true"
  }
  machine_type = "n1-standard-1"
  metadata = {
    startup-script = "#! /bin/bash\n     sudo apt-get update\n     sudo apt-get install apache2 -y\n     sudo a2ensite default-ssl\n     sudo a2enmod ssl\n     vm_hostname=\"$(curl -H \"Metadata-Flavor:Google\" \\\n   http://169.254.169.254/computeMetadata/v1/instance/name)\"\n   sudo echo \"Page served from: $vm_hostname\" | \\\n   tee /var/www/html/index.html\n   sudo systemctl restart apache2"
  }
  network_interface {
    access_config {
      network_tier = "PREMIUM"
    }
    network    = "global/networks/default"
    subnetwork = "regions/us-east1/subnetworks/default"
  }
  region = "us-east1"
  scheduling {
    automatic_restart   = true
    on_host_maintenance = "MIGRATE"
    provisioning_model  = "STANDARD"
  }
  service_account {
    email  = "default"
    scopes = ["https://www.googleapis.com/auth/devstorage.read_only", "https://www.googleapis.com/auth/logging.write", "https://www.googleapis.com/auth/monitoring.write", "https://www.googleapis.com/auth/pubsub", "https://www.googleapis.com/auth/service.management.readonly", "https://www.googleapis.com/auth/servicecontrol", "https://www.googleapis.com/auth/trace.append"]
  }
  tags = ["allow-health-check"]
}

Console

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

   Vai a Gruppi di istanze

2. Fai clic su Crea gruppo di istanze.

3. A sinistra, scegli Nuovo gruppo di istanze gestite (stateless).

4. In Nome, inserisci lb-backend-example.

5. In Località, seleziona Zona singola.

6. In Regione, seleziona la regione che preferisci.

7. In Zona, seleziona una zona.

8. In Modello di istanza, seleziona il modello di istanza lb-backend-template.

9. In Modalità di scalabilità automatica, seleziona On: aggiungi e rimuovi istanze al gruppo.

   Imposta Numero minimo di istanze su 2 e Numero massimo di istanze su 2 o più.

10. Per creare il nuovo gruppo di istanze, fai clic su Crea.

gcloud

1. Crea il gruppo di istanze gestite basato sul modello.

   gcloud compute instance-groups managed create lb-backend-example \
      --template=TEMPLATE_NAME --size=2 --zone=ZONE_A
   

Terraform

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

resource "google_compute_instance_group_manager" "default" {
  name = "lb-backend-example"
  zone = "us-east1-b"
  named_port {
    name = "http"
    port = 80
  }
  version {
    instance_template = google_compute_instance_template.default.id
    name              = "primary"
  }
  base_instance_name = "vm"
  target_size        = 2
}

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

Console

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

   Vai a Gruppi di istanze

2. Fai clic su lb-backend-example.

3. Nella pagina Panoramica del gruppo di istanze, fai clic su editModifica.

4. Nella sezione Mappatura delle porte, fai clic su Aggiungi porta.

   1. Come nome della porta, inserisci http. Per il numero di porta, inserisci 80.

5. Fai clic su Salva.

gcloud

Utilizza il comando gcloud compute instance-groups set-named-ports.

gcloud compute instance-groups set-named-ports lb-backend-example \
    --named-ports http:80 \
    --zone ZONE_A

Terraform

L'attributo named_port è incluso nel esempio di gruppo di istanze gestite.

Console

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

   Vai a Criteri firewall

2. Fai clic su Crea regola firewall per creare la regola firewall.

3. In Nome, inserisci fw-allow-health-check.

4. Seleziona una rete.

5. In Target, seleziona Tag di destinazione specificati.

6. Compila il campo Tag di destinazione con allow-health-check.

7. Imposta Filtro di origine su Intervalli IPv4.

8. Imposta Intervalli IPv4 di origine su 130.211.0.0/22 e 35.191.0.0/16.

9. In Protocolli e porte, seleziona Protocolli e porte specificati.

10. Seleziona la casella di controllo TCP, quindi digita 80 per i numeri di porta.

11. Fai clic su Crea.

gcloud

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

Terraform

Per creare la regola firewall, utilizza la risorsa google_compute_firewall.

resource "google_compute_firewall" "default" {
  name          = "fw-allow-health-check"
  direction     = "INGRESS"
  network       = "global/networks/default"
  priority      = 1000
  source_ranges = ["130.211.0.0/22", "35.191.0.0/16"]
  target_tags   = ["allow-health-check"]
  allow {
    ports    = ["80"]
    protocol = "tcp"
  }
}

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

Console

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

   Vai a Criteri firewall

2. Per consentire il traffico nella subnet IPv6, fai di nuovo clic su Crea regola firewall e inserisci le seguenti informazioni:

   • Nome: fw-allow-lb-access-ipv6
   • Rete: NETWORK
   • Priorità: 1000
   • Direzione del traffico: in entrata
   • Target: Tag di destinazione specificati
   • Nel campo Tag di destinazione, inserisci allow-health-check-ipv6.
   • Filtro di origine: intervalli IPv6
   • Intervalli IPv6 di origine: 2600:2d00:1:b029::/64,2600:2d00:1:1::/64
   • Protocolli e porte: Consenti tutto

3. Fai clic su Crea.

gcloud

Per consentire la comunicazione con la subnet, crea la regola firewall fw-allow-lb-access-ipv6:

gcloud compute firewall-rules create fw-allow-lb-access-ipv6 \
  --network=NETWORK \
  --action=allow \
  --direction=ingress \
  --target-tags=allow-health-check-ipv6 \
  --source-ranges=2600:2d00:1:b029::/64,2600:2d00:1:1::/64 \
  --rules=all

Console

1. Nella console Google Cloud , vai alla pagina Indirizzi IP esterni.

   Vai a Indirizzi IP esterni

2. Per prenotare un indirizzo IPv4, fai clic su Prenota indirizzo IP statico esterno.

3. In Nome, inserisci lb-ipv4-1.

4. Imposta Network Service Tier su Premium.

5. Imposta Versione IP su IPv4.

6. Imposta Tipo su Globale.

7. Fai clic su Prenota.

gcloud

gcloud compute addresses create lb-ipv4-1 \
    --ip-version=IPV4 \
    --network-tier=PREMIUM \
    --global

Prendi nota dell'indirizzo IPv4 riservato:

gcloud compute addresses describe lb-ipv4-1 \
    --format="get(address)" \
    --global

Terraform

Per prenotare l'indirizzo IP, utilizza la risorsa google_compute_global_address.

resource "google_compute_global_address" "default" {
  name       = "lb-ipv4-1"
  ip_version = "IPV4"
}

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

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. In Tipo di bilanciatore del carico, seleziona Bilanciatore del carico delle applicazioni (HTTP/HTTPS) e fai clic su Avanti.
4. In Pubblico o interno, seleziona Pubblico (esterno) e fai clic su Avanti.
5. In Deployment globale o in una regione singola, seleziona Ideale per workload globali e fai clic su Avanti.
6. In Generazione del bilanciatore del carico, seleziona Bilanciatore del carico delle applicazioni esterno globale e fai clic su Avanti.
7. Fai clic su Configura.

Configurazione di base

In Nome del bilanciatore del carico, inserisci un valore simile a web-map-https o web-map-http.

Configurazione frontend

1. Fai clic su Configurazione frontend.
2. Imposta Protocollo su HTTPS.
3. Seleziona IPv4 per il traffico IPv4. Imposta Indirizzo IP su lb-ipv4-1, che hai creato in precedenza.
4. Imposta Porta su 443.
5. Fai clic su Certificato e seleziona il certificato SSL principale.
6. (Facoltativo) Crea una policy SSL:
   1. Nell'elenco Policy SSL, seleziona Crea una policy.
   2. Imposta il nome della policy SSL su my-ssl-policy.
   3. In Versione TLS minima, seleziona TLS 1.0.
   4. Per Profilo, seleziona Moderno. Vengono visualizzate le sezioni Funzionalità abilitate e Funzionalità disattivate.
   5. Fai clic su Salva.
   Se non hai creato criteri SSL, viene applicato un criterio SSL predefinito.
7. (Facoltativo) Seleziona la casella di controllo Attiva reindirizzamento da HTTP a HTTPS per attivare i reindirizzamenti.

   Se selezioni questa casella di controllo, viene creato un bilanciatore del carico HTTP parziale aggiuntivo che utilizza lo stesso indirizzo IP del bilanciatore del carico HTTPS e reindirizza le richieste HTTP in entrata al frontend HTTPS del bilanciatore del carico.

   Questa casella di controllo può essere selezionata solo quando è selezionato il protocollo HTTPS e viene utilizzato un indirizzo IP riservato.

8. Fai clic su Fine.

Configurazione backend

1. Fai clic su Configurazione backend.
2. Nella sezione Crea o seleziona servizi di backend e bucket di backend, seleziona Servizi di backend > Crea un servizio di backend.
3. Aggiungi un nome per il servizio di backend, ad esempio web-backend-service.
4. Nell'elenco Criterio di selezione degli indirizzi IP, seleziona Preferisci IPv6.
5. Nella sezione Protocollo, seleziona HTTP.
6. In Porta denominata, inserisci http.
7. In Backend > Nuovo backend > Gruppo di istanze, seleziona il gruppo di istanze, lb-backend-example.
8. In Numeri di porta, inserisci 80.
9. Mantieni le altre impostazioni predefinite.
10. In Controllo di integrità, seleziona Crea un controllo di integrità, quindi aggiungi un nome per il controllo di integrità, ad esempio http-basic-check.
11. Imposta il protocollo su HTTP e poi fai clic su Salva.

12. (Facoltativo) Configura una policy di sicurezza del backend predefinita. Il criterio di sicurezza predefinito limita il traffico in base a una soglia configurata dall'utente. Per ulteriori informazioni sulle norme di sicurezza predefinite, consulta la panoramica della limitazione della frequenza.

    1. Per disattivare i criteri di sicurezza predefiniti di Google Cloud Armor, seleziona None nel menu dell'elenco dei criteri di sicurezza del backend.
    2. Nella sezione Sicurezza, seleziona Norme di sicurezza predefinite.
    3. Nel campo Nome criterio, accetta il nome generato automaticamente o inserisci un nome per il criterio di sicurezza.
    4. Nel campo Conteggio richieste, accetta il conteggio richieste predefinito o inserisci un numero intero compreso tra 1 e 10,000.
    5. Nel campo Intervallo, seleziona un intervallo.
    6. Nel campo Imponi su chiave, scegli uno dei seguenti valori: Tutti, Indirizzo IP o Indirizzo IP X-Forwarded-For. Per saperne di più su queste opzioni, vedi Identificare i client per la limitazione della frequenza.
13. Mantieni le altre impostazioni predefinite.
14. Fai clic su Crea.

Regole di routing

Per Regole di routing, mantieni le impostazioni predefinite.

Esamina e finalizza

1. Fai clic su Esamina e finalizza.
2. Controlla le impostazioni di configurazione del bilanciatore del carico.
3. (Facoltativo) Fai clic su Codice equivalente per visualizzare la richiesta dell'API REST che verrà utilizzata per creare il bilanciatore del carico.
4. Fai clic su Crea.

gcloud

1. Creare un controllo di integrità.

    gcloud compute health-checks create http http-basic-check \
        --port 80
    

2. Crea un servizio di backend.

   gcloud beta compute backend-services create web-backend-service \
       --load-balancing-scheme=EXTERNAL_MANAGED \
       --protocol=HTTP \
       --port-name=http \
       --ip-address-selection-policy=PREFER_IPV6 \
       --health-checks=http-basic-check \
       --global
   

3. Aggiungi il tuo gruppo di istanze come backend del servizio di backend.

   gcloud beta compute backend-services add-backend web-backend-service \
     --instance-group=lb-backend-example \
     --instance-group-zone=ZONE_A \
     --global
   

4. Per HTTP, crea una mappa URL per instradare le richieste in entrata al servizio di backend predefinito.

   gcloud beta compute url-maps create web-map-http \
     --default-service web-backend-service
   

5. Per HTTPS, crea una mappa URL per instradare le richieste in entrata al servizio di backend predefinito.

   gcloud beta compute url-maps create web-map-https \
     --default-service web-backend-service
   

Configurare un frontend HTTPS

Salta questa sezione per i bilanciatori del carico HTTP.

1. Per HTTPS, se non l'hai ancora fatto, crea la risorsa del certificato SSL globale, come mostrato nelle sezioni seguenti:
• Creazione di una risorsa del certificato SSL gestito da Google
• Creazione di una risorsa del certificato SSL autogestito

2. Per HTTPS, crea un proxy HTTPS di destinazione per instradare le richieste alla mappa URL. Il proxy è la parte del bilanciatore del carico che contiene il certificato SSL per un bilanciatore del carico HTTPS, quindi in questo passaggio carichi anche il certificato.

   gcloud beta compute target-https-proxies create http-lb-proxy \
     --http-keep-alive-timeout-sec=HTTP_KEEP_ALIVE_TIMEOUT_SEC \
     --url-map=web-map-https \
     --ssl-certificates=www-ssl-cert
   

   Sostituisci HTTP_KEEP_ALIVE_TIMEOUT_SEC con il valore del timeout keepalive HTTP del client da 5 a 1200 secondi. Il valore predefinito è 610 secondi. Questo campo è facoltativo.

3. Per HTTPS, crea una regola di forwarding globale per instradare le richieste in entrata al proxy.

   gcloud beta compute forwarding-rules create https-content-rule \
     --load-balancing-scheme=EXTERNAL_MANAGED \
     --network-tier=PREMIUM \
     --address=lb-ipv4-1 \
     --global \
     --target-https-proxy=https-lb-proxy \
     --ports=443
   

4. (Facoltativo) Per HTTPS, crea un criterio SSL globale e collegalo al proxy HTTPS.
   Per creare una policy SSL globale:

   gcloud compute ssl-policies create my-ssl-policy \
     --profile MODERN \
     --min-tls-version 1.0
   

   Per collegare il criterio SSL al proxy HTTPS di destinazione globale:

   gcloud compute target-https-proxies update https-lb-proxy \
     --ssl-policy my-ssl-policy
   

Configura un frontend HTTP

Salta questa sezione per i bilanciatori del carico HTTPS.

1. Per HTTP, crea un proxy HTTP di destinazione per instradare le richieste alla mappa URL.

   gcloud beta compute target-http-proxies create http-lb-proxy \
     --http-keep-alive-timeout-sec=HTTP_KEEP_ALIVE_TIMEOUT_SEC \
     --url-map=web-map-http
   

   Sostituisci HTTP_KEEP_ALIVE_TIMEOUT_SEC con il valore del timeout keepalive HTTP del client da 5 a 1200 secondi. Il valore predefinito è 610 secondi. Questo campo è facoltativo.

2. Per HTTP, crea una regola di forwarding globale per instradare le richieste in entrata al proxy.

   gcloud beta compute forwarding-rules create http-content-rule \
     --load-balancing-scheme=EXTERNAL_MANAGED \
     --address=lb-ipv4-1 \
     --global \
     --target-http-proxy=http-lb-proxy \
     --ports=80
   

Terraform

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

   resource "google_compute_health_check" "default" {
     name               = "http-basic-check"
     check_interval_sec = 5
     healthy_threshold  = 2
     http_health_check {
       port               = 80
       port_specification = "USE_FIXED_PORT"
       proxy_header       = "NONE"
       request_path       = "/"
     }
     timeout_sec         = 5
     unhealthy_threshold = 2
   }

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

   resource "google_compute_backend_service" "default" {
     name                            = "web-backend-service"
     connection_draining_timeout_sec = 0
     health_checks                   = [google_compute_health_check.default.id]
     load_balancing_scheme           = "EXTERNAL_MANAGED"
     port_name                       = "http"
     protocol                        = "HTTP"
     session_affinity                = "NONE"
     timeout_sec                     = 30
     backend {
       group           = google_compute_instance_group_manager.default.instance_group
       balancing_mode  = "UTILIZATION"
       capacity_scaler = 1.0
     }
   }

3. Per creare la mappa URL, utilizza la risorsa google_compute_url_map.

   resource "google_compute_url_map" "default" {
     name            = "web-map-http"
     default_service = google_compute_backend_service.default.id
   }

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

   resource "google_compute_target_http_proxy" "default" {
     name    = "http-lb-proxy"
     url_map = google_compute_url_map.default.id
   }

5. Per creare la regola di forwarding, utilizza la risorsa google_compute_global_forwarding_rule.

   resource "google_compute_global_forwarding_rule" "default" {
     name                  = "http-content-rule"
     ip_protocol           = "TCP"
     load_balancing_scheme = "EXTERNAL_MANAGED"
     port_range            = "80-80"
     target                = google_compute_target_http_proxy.default.id
     ip_address            = google_compute_global_address.default.id
   }

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

Console

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

   Vai a Bilanciamento del carico

2. Fai clic sul bilanciatore del carico che hai appena creato.

3. Nella sezione Backend, verifica che le VM siano in stato integro. La colonna Stato integro dovrebbe essere compilata, a indicare che entrambe le VM sono integre (2/2). In caso contrario, prova prima a ricaricare la pagina. Potrebbero essere necessari alcuni istanti prima che la console Google Cloud indichi che le VM sono integre. Se i backend non appaiono integri dopo alcuni minuti, rivedi la configurazione del firewall e il tag di rete assegnato alle tue VM di backend.

4. Per HTTPS, se utilizzi un certificato gestito da Google, verifica che lo stato della risorsa certificato sia ACTIVE. Per ulteriori informazioni, vedi Stato della risorsa del certificato SSL gestito da Google.
5. Dopo che la console Google Cloud mostra che le istanze di backend sono integre, puoi testare il bilanciatore del carico utilizzando un browser web andando all'indirizzo https://IP_ADDRESS (o http://IP_ADDRESS). Sostituisci IP_ADDRESS con l'indirizzo IP del bilanciatore del carico.
6. Se hai utilizzato un certificato autofirmato per testare HTTPS, il browser mostra un avviso. Devi indicare esplicitamente al browser di accettare un certificato autofirmato.
7. Il browser dovrebbe visualizzare una pagina con contenuti che mostrano il nome dell'istanza che ha pubblicato la pagina e la relativa zona (ad esempio, Page served from: lb-backend-example-xxxx). Se il browser non visualizza questa pagina, controlla le impostazioni di configurazione in questa guida.

gcloud

gcloud compute addresses describe lb-ipv4-1 \
   --format="get(address)" \
   --global

Dopo qualche minuto, puoi testare la configurazione eseguendo il seguente comando curl.

curl http://IP_ADDRESS

-o-

curl https://HOSTNAME