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

Questa guida alla configurazione mostra come creare un bilanciatore del carico delle applicazioni esterno globale con un gruppo di istanze gestite Compute Engine come backend.

Per i concetti generali, consulta Panoramica del bilanciatore del carico delle applicazioni esterno

Se sei un utente esistente del bilanciatore del carico delle applicazioni classico, assicurati di consulta Pianifica la tua migrazione al bilanciatore del carico delle applicazioni esterno globale quando pianifichi un nuovo deployment con il bilanciatore del carico delle applicazioni esterno globale.

Per seguire le indicazioni dettagliate per questa attività direttamente nella console Google Cloud, fai clic su Procedura guidata:

Procedura guidata

Topologie del bilanciatore del carico

Per un bilanciatore del carico HTTPS, devi creare la configurazione mostrata in nel diagramma seguente.

Bilanciatore del carico delle applicazioni esterno con backend di un gruppo di istanze gestite
Figura 1. Bilanciatore del carico delle applicazioni esterno con un backend di gruppo di istanze gestite (MIG) (fai clic per ingrandire).

Per un bilanciatore del carico HTTP, puoi creare la configurazione mostrata in nel diagramma seguente.

Bilanciatore del carico delle applicazioni esterno con backend di un gruppo di istanze gestite
Figura 2. Bilanciatore del carico delle applicazioni esterno con un backend di gruppo di istanze gestite (MIG) (fai clic per ingrandire).

La sequenza degli eventi nei diagrammi è la seguente:

  1. Un client invia una richiesta di contenuti all'indirizzo IPv4 esterno definito nel regola di inoltro.

  2. Per un bilanciatore del carico HTTPS, la regola di forwarding indirizza la richiesta al proxy HTTPS di destinazione.

    Per un bilanciatore del carico HTTP, la regola di inoltro indirizza la richiesta al proxy HTTP di destinazione.

  3. Il proxy di destinazione utilizza la regola nell'URL per determinare che un singolo servizio di backend riceve tutte le richieste.

  4. Il bilanciatore del carico determina che il backend ha una sola istanza gruppo e indirizza la richiesta a un'istanza di macchina virtuale (VM) in gruppo.

  5. La VM gestisce i contenuti richiesti dall'utente.

Prima di iniziare

Completa i seguenti passaggi prima di creare il bilanciatore del carico.

Configura una risorsa del certificato SSL

Per un bilanciatore del carico HTTPS, crea una risorsa del certificato SSL come descritto in seguenti:

Ti consigliamo di utilizzare un certificato gestito da Google.

In questo esempio si presuppone che tu abbia già una risorsa del certificato SSL denominata www-ssl-cert.

Configurare le autorizzazioni

Per completare i passaggi di questa guida, devi disporre dell'autorizzazione per creare di istanze Compute Engine, regole firewall e indirizzi IP riservati in un progetto. Devi avere un proprietario o un editor del progetto ruolo oppure devi disporre dei seguenti Ruoli IAM di Compute Engine.

Attività Ruolo richiesto
Creazione delle istanze Amministratore istanza
Aggiungere e rimuovere regole firewall Amministratore sicurezza
Crea componenti del bilanciatore del carico Amministratore di rete
(Facoltativo) Crea un progetto Project Creator

Per ulteriori informazioni, consulta le seguenti guide:

Configura la rete e le subnet

Per creare la rete e la subnet di esempio, segui questi passaggi.

Console

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

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

    Vai alle 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 sottoreti di questa rete, completa i seguenti passaggi:

    1. Per Intervallo IPv6 interno ULA della rete VPC, seleziona Abilitato.

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

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

  5. In Modalità di creazione subnet, scegli Personalizzata.

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

    1. Nel campo Nome, fornisci un nome per la sottorete.
    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'indirizzo IPv4 principale per la subnet.

      Sebbene sia possibile configurare un intervallo di indirizzi IPv4 nella subnet, non puoi scegliere l'intervallo degli indirizzi IPv6 per la subnet. Google fornisce un CIDR IPv6 di dimensione fissa (/64) bloccare.

    5. In Tipo di accesso IPv6, seleziona Esterno.

  7. Fai clic su Fine.

  8. Fai clic su Crea.

Per supportare solo il traffico IPv4, svolgi i seguenti passaggi:

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

    Vai alle 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, specifica 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'indirizzo IPv4 principale 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 update NETWORK \
    [ --enable-ula-internal-ipv6 [ --internal-ipv6-range=ULA_IPV6_RANGE ]] \
    --switch-to-custom-subnet-mode

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

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

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

    Per solo traffico IPv4, utilizza il seguente comando:

    gcloud compute networks subnets update SUBNET \
   --network=NETWORK \
   --stack-type=IPV4_ONLY \
   --range=10.1.2.0/24 \
   --region=REGION_A

Sostituisci quanto segue:

  • NETWORK: un nome per la rete VPC

  • ULA_IPV6_RANGE: un prefisso /48 all'interno dell'intervallo fd20::/20 utilizzato da Google per gli intervalli di subnet IPv6 interni. Se non usare il flag --internal-ipv6-range, Google seleziona un prefisso /48 per la rete

  • SUBNET: un nome per la subnet

  • REGION_A: il nome della regione

Creare un gruppo di istanze gestite

Per configurare un bilanciatore del carico con un backend di Compute Engine, le VM devono essere in un gruppo di istanze. Questa guida descrive come creare un account gruppo di istanze VM con VM Linux su cui è in esecuzione Apache, quindi configura il carico e del bilanciamento del carico. Un gruppo di istanze gestite crea ciascuna delle sue istanze gestite in base ai modelli di istanza specificati.

Il gruppo di istanze gestite fornisce VM che eseguono i server di backend di un bilanciatore del carico HTTP(S) esterno. A scopo dimostrativo, i backend gestiscono i propri nomi host.

Prima di creare un gruppo di istanze gestite, crea un modello di istanza.

Console

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

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

    Vai a Modelli 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 10 (buster). Queste istruzioni utilizzano comandi sono 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 Modifica. Configura il 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 la script seguente:

    #! /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 sia quello IPv6, esegui il seguente 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-10 \
  --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 google_compute_instance_template risorsa.

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

Crea il gruppo di istanze gestite e seleziona il modello di istanza.

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 in base al 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 google_compute_instance_group_manager risorsa.

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.

Aggiungi una porta denominata al gruppo di istanze

Per il gruppo di istanze, definisci un servizio HTTP e mappa un nome di porta alla porta pertinente. Il servizio di bilanciamento del carico inoltra il traffico verso la porta denominata. Per ulteriori informazioni, consulta Porte denominate.

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

  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 la 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 nell'esempio di gruppo di istanze gestite.

Configurare una regola firewall

In questo esempio, crei la regola firewall fw-allow-health-check. Si tratta di una regola in entrata che consente il traffico proveniente dai sistemi di controllo di integrità di Google Cloud (130.211.0.0/22 e 35.191.0.0/16). Questo esempio utilizza il tag di destinazione allow-health-check per identificare le VM.

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 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 google_compute_firewall risorsa.

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.

Crea la regola firewall per il controllo di integrità IPv6

Assicurati di avere una regola di ingresso, applicabile alle istanze bilanciate in base al carico, che consenta il traffico dai sistemi di controllo di integrità di Google Cloud (2600:2d00:1:b029::/64). Questo esempio utilizza il tag di destinazione allow-health-check-ipv6 per identificare le istanze VM a cui si applica.

Senza questa regola firewall, la regola di traffico in entrata IPv6 implicita blocca il traffico IPv6 in entrata verso le istanze di backend.

Console

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

    Vai a Criteri firewall

  2. Per consentire il traffico della 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

Prenotare un indirizzo IP esterno

Ora che le tue istanze sono operative, configura un IP esterno statico e globale utilizzato dai clienti per raggiungere il bilanciatore del carico.

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 esterno statico.

  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 il google_compute_global_address risorsa.

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.

configura il bilanciatore del carico

In questo esempio, utilizzi HTTPS (frontend) tra il client e il carico con il bilanciatore del carico di rete passthrough esterno regionale. Per HTTPS, sono necessarie una o più risorse del certificato SSL per configurare il proxy. Ti consigliamo di utilizzare un certificato gestito da Google.

Anche se utilizzi HTTPS sul frontend, puoi utilizzare HTTP sul backend. Google cripta automaticamente il traffico tra i Google Front End (GFE) e i tuoi backend che si trovano all'interno delle reti VPC di Google Cloud.

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. Per Deployment globale o in una regione singola, seleziona Ideale per carichi di lavoro 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 come 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 tuo certificato SSL principale.
  6. (Facoltativo) Crea un criterio SSL:
    1. Nell'elenco Criterio SSL, seleziona Crea un .
    2. Imposta il nome del criterio SSL su my-ssl-policy.
    3. Per Versione TLS minima, seleziona TLS 1.0.
    4. In 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 Abilita reindirizzamento da HTTP a HTTPS. casella di controllo per attivare i reindirizzamenti.

    L'attivazione di questa casella di controllo crea un carico HTTP parziale aggiuntivo che utilizza lo stesso indirizzo IP del carico HTTPS e reindirizza le richieste HTTP in entrata al tuo carico del bilanciatore del carico tramite il frontend HTTPS del bilanciatore.

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

  8. Fai clic su Fine.

Configurazione backend

  1. Fai clic su Configurazione backend.
  2. In 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 Preferenza per IPv6.
  5. In 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 un criterio di sicurezza del backend predefinito. Il criterio di sicurezza predefinito limita il traffico oltre una soglia configurata dall'utente. Per ulteriori informazioni sui criteri di sicurezza predefiniti, consulta la Panoramica del limite di velocità.

    1. Per disattivare il criterio di sicurezza predefinito di Google Cloud Armor, seleziona None nel menu elenco dei criteri di sicurezza del backend.
    2. Nella sezione Sicurezza, seleziona Criterio di sicurezza predefinito.
    3. Nel campo Nome norma, accetta i Termini e condizioni d'uso generato o inserisci un nome per il criterio di sicurezza.
    4. Nel campo Conteggio richieste, accetta la richiesta predefinita conteggio o inserisci un numero intero compreso tra 1 e 10,000.
    5. Nel campo Intervallo, seleziona un intervallo.
    6. Nel campo Applica a chiave, scegli uno dei seguenti valori: Tutti, Indirizzo IP o Indirizzo IP X-Forwarded-For. Per ulteriori informazioni su queste opzioni, consulta la sezione Identificazione dei client per il limite di frequenza.
  13. Conserva le altre impostazioni predefinite.
  14. Fai clic su Crea.

Regole di routing

Per le regole di routing, mantieni le impostazioni predefinite.

Esamina e finalizza

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

Attendi che la creazione del bilanciatore del carico sia completa.

Se hai creato un bilanciatore del carico HTTPS e hai selezionato la casella di controllo Abilita il reindirizzamento da HTTP a HTTPS, vedrai anche un bilanciatore del carico HTTP creato con un suffisso -redirect.

  1. Fai clic sul nome del bilanciatore del carico.
  2. Nella schermata Dettagli bilanciatore del carico, tieni presente IP:Port per il bilanciatore del carico.

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 backend predefinito completamente gestito di Google Cloud. 
    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 arrivo al o un 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:

  2. Per HTTPS, crea un proxy HTTPS di destinazione per instradare le richieste al tuo URL mappa. Il proxy è la parte del bilanciatore del carico che contiene il certificato SSL per un bilanciatore del carico HTTPS, quindi in questo passaggio caricherai anche il tuo 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 compreso tra 5 e 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 un criterio 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

Configurare 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 compreso tra 5 e 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.

Collegare il dominio al bilanciatore del carico

Dopo aver creato il bilanciatore del carico, prendi nota dell'indirizzo IP associato dal bilanciatore del carico, ad esempio 30.90.80.100. Per indirizzare il tuo dominio al bilanciatore del carico, crea un record A utilizzando il servizio di registrazione del dominio. Se hai aggiunto più domini al tuo certificato SSL, devi aggiungere un record A per ciascuno, che rimandi all'indirizzo IP del bilanciatore del carico. Ad esempio, per creare record A per www.example.com e example.com, utilizza quanto segue:

NAME                  TYPE     DATA
www                   A        30.90.80.100
@                     A        30.90.80.100

Se utilizzi Cloud DNS come provider DNS, consulta Aggiungere, modificare ed eliminare record.

Verifica il traffico inviato alle istanze

Ora che il servizio di bilanciamento del carico è in esecuzione, puoi inviare il traffico verso la regola di forwarding e osservare la distribuzione del traffico su diverse di Compute Engine.

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 integre. La La colonna Integro deve essere compilata per indicare che entrambe le VM sono integri (2/2). Se la risposta è diversa, prova innanzitutto a ricaricare della pagina. Potrebbero essere necessari alcuni istanti prima che la console Google Cloud annunci che le VM sono in esecuzione correttamente. Se i backend non sembrano integri dopo qualche minuto, rivedi la configurazione del firewall e il tag di rete assegnate alle VM di backend.

  4. Per HTTPS, se utilizzi un certificato gestito da Google, verifica che lo stato della risorsa del 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 è in stato integro, puoi testare il bilanciatore del carico usando un browser web https://IP_ADDRESS (o http://IP_ADDRESS). Sostituisci IP_ADDRESS con indirizzo IP del bilanciatore del carico.
  6. Se hai utilizzato un certificato autofirmato per il test del protocollo 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 alcuni minuti, puoi testare la configurazione eseguendo questo Comando curl.

curl http://IP_ADDRESS

-o-

curl https://HOSTNAME

Configurazione aggiuntiva

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

Aggiorna il timeout keepalive HTTP del client

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

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 esaminare le modifiche, fai clic su Esamina e finalizza e poi fai clic 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.

Passaggi successivi

Per la documentazione correlata:

Per i video correlati: