Configura un bilanciatore del carico HTTP(S) esterno a livello di regione con backend dei gruppi di istanze VM

Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Questo documento fornisce istruzioni per la configurazione di un bilanciatore del carico HTTP(S) esterno a livello di area geografica per i servizi eseguiti sulle VM di Compute Engine.

Poiché i bilanciatori del carico HTTP(S) a livello di area geografica consentono di creare bilanciatori del carico in aree geografiche specifiche, vengono spesso utilizzati per carichi di lavoro con requisiti di conformità giurisdizionali. I carichi di lavoro che richiedono l'accesso al gresso del livello di rete standard sono un altro caso d'uso comune dei bilanciatori del carico HTTP(S) esterni a livello di regione, perché i bilanciatori del carico HTTP(S) esterni a livello di area geografica supportano il livello di servizio di rete standard.

Prima di seguire questa guida, acquisisci familiarità con quanto segue:

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
Aggiungere e rimuovere regole firewall Amministratore della sicurezza
Creazione delle istanze Amministratore istanze

Per saperne di più, consulta le seguenti guide:

Panoramica della configurazione

Puoi configurare un bilanciatore del carico HTTP(S) esterno a livello di area geografica come descritto nel seguente flusso di configurazione di alto livello. I passaggi numerati si riferiscono ai numeri nel diagramma.

Componenti numerati del bilanciatore del carico HTTP(S) esterno a livello di regione (fai clic per ingrandire)
Componenti numerati del bilanciatore del carico HTTP(S) a livello di area geografica (fai clic per ingrandire)

Come mostrato nel diagramma, in questo esempio viene creato un bilanciatore del carico HTTP(S) esterno a livello di regione in una rete VPC nella regione us-west1, con un servizio di backend e due gruppi di istanze di backend.

Il diagramma mostra quanto segue:

  1. Una rete VPC con due subnet:

    1. Una subnet viene utilizzata per i backend (gruppi di istanze). Il suo intervallo di indirizzi IP principali è 10.1.2.0/24.

    2. Una subnet è una subnet solo proxy nell'area geografica us-west1. Devi creare una subnet solo proxy in ogni area geografica di una rete VPC in cui utilizzi bilanciatori del carico HTTP(S) esterni a livello di area geografica. La subnet solo proxy della regione è condivisa tra tutti i bilanciatori del carico a livello di regione nella regione. Gli indirizzi di origine dei pacchetti inviati dai bilanciatori del carico ai backend del servizio vengono allocati dalla subnet solo proxy. In questo esempio, la subnet solo proxy per la regione ha un intervallo di indirizzi IP principali di 10.129.0.0/23, che è la dimensione della subnet consigliata. Per scoprire di più, consulta Subnet solo proxy.

  2. Una regola firewall che consente i flussi di traffico della subnet solo proxy nella rete. Ciò significa aggiungere una regola che consente il traffico 80, 443 e 8080 delle porte TCP da 10.129.0.0/23 (l'intervallo della subnet solo proxy in questo esempio). Un'altra regola firewall per i probe del controllo di integrità.

  3. Istanze di backend.

  4. Gruppi di istanze:

    1. Gruppi di istanze gestite o non gestite per i deployment delle VM di Compute Engine
    2. NEG per i deployment GKE

    In ogni zona, puoi avere una combinazione di tipi di gruppi di backend basati sui requisiti del deployment.

  5. Un controllo di integrità a livello di regione che segnala l'idoneità dei tuoi backend.

  6. Un servizio di backend a livello di area geografica che monitora l'utilizzo e l'integrità dei backend.

  7. Una mappa URL a livello di regione 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.

  8. Un proxy HTTP o HTTPS di destinazione a livello di regione, che riceve una richiesta dall'utente e la inoltra alla mappa URL. Per HTTPS, configura una risorsa del certificato SSL a livello di regione. 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 il traffico alle tue istanze utilizzando HTTP o HTTPS.

  9. Una regola di forwarding, che ha l'indirizzo IP esterno del bilanciatore del carico, per inoltrare ogni richiesta in entrata al proxy di destinazione.

    L'indirizzo IP esterno associato alla regola di forwarding viene prenotato utilizzando il comando gcloud compute addresses create, come descritto nella sezione Prenotare l'indirizzo IP del bilanciatore del carico.

Configura la rete e le subnet

È necessaria una rete VPC con due subnet: una per i backend del bilanciatore del carico e l'altra per i proxy del bilanciatore del carico. Un bilanciatore del carico HTTP(S) esterno a livello di regione è a livello di regione. Il traffico all'interno della rete VPC è instradato al bilanciatore del carico, se l'origine del traffico si trova in una subnet nella stessa area geografica del bilanciatore del carico.

Questo esempio utilizza la rete, l'area geografica e le subnet VPC seguenti:

  • Rete. La rete è una rete VPC in modalità personalizzata denominata lb-network.

  • Subnet per i backend. Una subnet denominata backend-subnet nella regione us-west1 utilizza 10.1.2.0/24 per l'intervallo IP principale.

  • Subnet per i proxy. Una subnet denominata proxy-only-subnet nella regione us-west1 utilizza 10.129.0.0/23 per l'intervallo IP principale.

Configura la rete e la subnet per i backend

Console

  1. In Google Cloud Console, vai alla pagina Reti VPC.

    Vai a Reti VPC

  2. Fai clic su Crea rete VPC.

  3. In Nome, inserisci lb-network.

  4. Nella sezione Subnet:

    • Imposta Modalità di creazione subnet su Personalizzata.
    • Nella sezione Nuova subnet, inserisci le seguenti informazioni:
      • Nome: backend-subnet
      • Regione: us-west1
      • Intervallo di indirizzi IP: 10.1.2.0/24
    • Fai clic su Fine.
  5. Fai clic su Create (Crea).

gcloud

  1. Crea la rete VPC personalizzata con il comando gcloud compute networks create:

    gcloud compute networks create lb-network --subnet-mode=custom
    
  2. Crea una subnet nella rete lb-network nell'area geografica us-west1 con il comando gcloud compute networks subnets create:

    gcloud compute networks subnets create backend-subnet \
        --network=lb-network \
        --range=10.1.2.0/24 \
        --region=us-west1
    

Terraform

Per creare la rete VPC, utilizza la risorsa google_compute_network.

resource "google_compute_network" "default" {
  name                    = "lb-network"
  auto_create_subnetworks = false
  routing_mode            = "REGIONAL"
}

Per creare la subnet VPC nella rete lb-network, utilizza la risorsa google_compute_subnetwork.

resource "google_compute_subnetwork" "default" {
  name                       = "backend-subnet"
  ip_cidr_range              = "10.1.2.0/24"
  network                    = google_compute_network.default.id
  private_ipv6_google_access = "DISABLE_GOOGLE_ACCESS"
  purpose                    = "PRIVATE"
  region                     = "us-west1"
  stack_type                 = "IPV4_ONLY"
}

API

  1. Esegui una richiesta POST al metodo networks.insert, sostituendo PROJECT_ID con il tuo ID progetto.

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks
    {
     "routingConfig": {
       "routingMode": "REGIONAL"
     },
     "name": "lb-network",
     "autoCreateSubnetworks": false
    }
    
  2. Esegui una richiesta POST al metodo subnetworks.insert, sostituendo PROJECT_ID con il tuo ID progetto.

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks
    {
     "name": "backend-subnet",
     "network": "projects/PROJECT_ID/global/networks/lb-network",
     "ipCidrRange": "10.1.2.0/24",
     "region": "projects/PROJECT_ID/regions/us-west1",
    }
    

Configura la subnet solo proxy

Una subnet solo proxy fornisce un set di indirizzi IP utilizzati da Google per eseguire i proxy Envoy per tuo conto. I proxy interrompono le connessioni dal client e creano nuove connessioni ai backend.

Questa subnet solo proxy è utilizzata da tutti i bilanciatori del carico a livello di area geografica basati su Envoy nella stessa area geografica della rete VPC lb-network. Per ogni area geografica può essere attiva una sola subnet solo proxy.

Console

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

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

  1. In Google Cloud Console, vai alla pagina Reti VPC.

    Vai a Reti VPC

  2. Fai clic sul nome della rete VPC lb-network.

  3. Fai clic su Aggiungi subnet.

  4. In Nome, inserisci proxy-only-subnet.

  5. In Regione, seleziona us-west1.

  6. Imposta Finalità su Proxy gestito a livello di area geografica.

  7. In Intervallo di indirizzi IP, inserisci 10.129.0.0/23.

  8. Fai clic su Add (Aggiungi).

gcloud

Crea la subnet solo proxy con il comando gcloud compute networks subnets create.

gcloud compute networks subnets create proxy-only-subnet \
  --purpose=REGIONAL_MANAGED_PROXY \
  --role=ACTIVE \
  --region=us-west1 \
  --network=lb-network \
  --range=10.129.0.0/23

Terraform

Per creare la subnet solo proxy VPC nella rete lb-network, utilizza la risorsa google_compute_subnetwork.

resource "google_compute_subnetwork" "proxy_only" {
  name          = "proxy-only-subnet"
  ip_cidr_range = "10.129.0.0/23"
  network       = google_compute_network.default.id
  purpose       = "REGIONAL_MANAGED_PROXY"
  region        = "us-west1"
  role          = "ACTIVE"
}

API

Crea la subnet solo proxy con il metodo subnetworks.insert, sostituendo PROJECT_ID con il tuo ID progetto.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks
{
  "name": "proxy-only-subnet",
  "ipCidrRange": "10.129.0.0/23",
  "network": "projects/PROJECT_ID/global/networks/lb-network",
  "region": "projects/PROJECT_ID/regions/us-west1",
  "purpose": "REGIONAL_MANAGED_PROXY",
  "role": "ACTIVE"
}

Configurazione delle regole del firewall

In questo esempio vengono utilizzate le seguenti regole firewall:

  • fw-allow-health-check. Una regola in entrata, applicabile alle istanze in fase di bilanciamento del carico, che consente l'utilizzo di tutto il traffico TCP proveniente dai sistemi di controllo di integrità di Google Cloud (in 130.211.0.0/22 e 35.191.0.0/16). In questo esempio viene utilizzato il tag di destinazione load-balanced-backend per identificare le VM a cui si applica la regola firewall.

  • fw-allow-proxies. Una regola in entrata, applicabile alle istanze in fase di bilanciamento del carico, che consente il traffico TCP sulle porte 80, 443 e 8080 dai proxy gestiti del bilanciatore del carico HTTP(S) a livello di regione. In questo esempio viene utilizzato il tag di destinazione load-balanced-backend per identificare le VM a cui si applica la regola firewall.

Senza queste regole firewall, la regola default nega in entrata blocca il traffico in entrata verso le istanze di backend.

I tag di destinazione definiscono le istanze di backend. Senza i tag di destinazione, le regole 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 mostrato nella sezione Creazione di un gruppo di istanze gestite.

Console

  1. In Google Cloud Console, vai alla pagina Regole firewall.

    Vai a Regole firewall

  2. Fai clic su Crea regola firewall per creare la regola per consentire i controlli di integrità di Google Cloud:

    • Nome: fw-allow-health-check
    • Rete: lb-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 della 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 tue VM, ma non può utilizzare HTTPS sulla porta 443 per contattarli.
  3. Fai clic su Create (Crea).

  4. Fai clic su Crea regola firewall per creare la regola per consentire ai server proxy del bilanciatore del carico di connettere i backend:

    • Nome: fw-allow-proxies
    • Rete: lb-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
    • Protocolli e porte:
      • Scegli Protocolli e porte specificati.
      • Seleziona la casella di controllo TCP, quindi inserisci 80, 443, 8080 per i numeri della porta.
  5. Fai clic su Create (Crea).

gcloud

  1. Crea la regola fw-allow-health-check per consentire i controlli di integrità di Google Cloud. Questo esempio consente tutto il traffico TCP da probe di controllo di integrità; tuttavia, puoi configurare un insieme di porte più ristrette per soddisfare le tue esigenze.

    gcloud compute firewall-rules create fw-allow-health-check \
        --network=lb-network \
        --action=allow \
        --direction=ingress \
        --source-ranges=130.211.0.0/22,35.191.0.0/16 \
        --target-tags=load-balanced-backend \
        --rules=tcp
    
  2. Crea la regola fw-allow-proxies per consentire la connessione ai proxy di bilanciamento del carico HTTP(S) esterno a livello di regione. Imposta source-ranges sugli intervalli assegnati della subnet solo proxy, ad esempio 10.129.0.0/23.

    gcloud compute firewall-rules create fw-allow-proxies \
      --network=lb-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" "default" {
  name = "fw-allow-health-check"
  allow {
    protocol = "tcp"
  }
  direction     = "INGRESS"
  network       = google_compute_network.default.id
  priority      = 1000
  source_ranges = ["130.211.0.0/22", "35.191.0.0/16"]
  target_tags   = ["load-balanced-backend"]
}
resource "google_compute_firewall" "allow_proxy" {
  name = "fw-allow-proxies"
  allow {
    ports    = ["443"]
    protocol = "tcp"
  }
  allow {
    ports    = ["80"]
    protocol = "tcp"
  }
  allow {
    ports    = ["8080"]
    protocol = "tcp"
  }
  direction     = "INGRESS"
  network       = google_compute_network.default.id
  priority      = 1000
  source_ranges = ["10.129.0.0/23"]
  target_tags   = ["load-balanced-backend"]
}

API

Crea la regola firewall fw-allow-health-check effettuando una richiesta POST al 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-allow-health-check",
  "network": "projects/PROJECT-ID/global/networks/lb-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-allow-proxies per consentire il traffico TCP all'interno della subnet proxy per il metodo firewalls.insert, sostituendo PROJECT_ID con l'ID progetto.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls
{
  "name": "fw-allow-proxies",
  "network": "projects/PROJECT_ID/global/networks/lb-network",
  "sourceRanges": [
    "10.129.0.0/23"
  ],
  "targetTags": [
    "load-balanced-backend"
  ],
  "allowed": [
    {
      "IPProtocol": "tcp",
      "ports": [
        "80"
      ]
    },
    {
      "IPProtocol": "tcp",
      "ports": [
        "443"
      ]
    },
    {
      "IPProtocol": "tcp",
      "ports": [
        "8080"
      ]
    }
  ],
  "direction": "INGRESS"
}

Configurare un bilanciatore del carico HTTP(S) esterno a livello di regione con un servizio basato su VM

Questa sezione mostra la configurazione richiesta per i servizi eseguiti sulle VM di Compute Engine. Le VM client si connettono all'indirizzo IP e alla porta che hai configurato nella regola di forwarding. Quando le applicazioni client inviano traffico a questo indirizzo IP e a questa porta, le loro richieste vengono inoltrate alle tue macchine virtuali di backend (VM) in base alla mappa URL del tuo bilanciatore del carico HTTP(S) esterno a livello di regione.

L'esempio in questa pagina crea esplicitamente un indirizzo IP esterno riservato per la regola di forwarding del bilanciatore del carico HTTP(S) esterno a livello di regione, anziché consentire l'allocazione di un indirizzo IP esterno temporaneo. Come best practice, consigliamo di riservare gli indirizzi IP per le regole di forwarding.

Crea un backend per gruppi di istanze gestite

Questa sezione mostra come creare un modello e un gruppo di istanze gestite. Il gruppo di istanze gestite fornisce istanze VM che eseguono i server di backend di un bilanciatore del carico HTTP(S) esterno di esempio a livello di regione. Il traffico proveniente dai client viene bilanciato in base al carico di questi server di backend. A scopo dimostrativo, i backend forniscono i propri nomi host.

Console

  1. Creare un modello di istanza. In Google Cloud Console, vai alla pagina Modelli di istanza.

    Vai a Modelli di istanza

    1. Fai clic su Crea modello istanza.
    2. In Nome, inserisci l7-xlb-backend-template.
    3. Assicurati che l'opzione Disco di avvio sia impostata su un'immagine Debian, ad esempio Debian GNU/Linux 10 (buster). Queste istruzioni utilizzano comandi disponibili solo su Debian, come apt-get.
    4. Nella sezione Gestione, sicurezza, dischi, networking, single-tenancy, nella scheda Gestione, inserisci lo script seguente nel campo Script di avvio.

      #! /bin/bash
      sudo apt-get update
      sudo apt-get install apache2 -y
      sudo a2ensite default-ssl
      sudo a2enmod ssl
      vm_hostname="$(curl -H "Metadata-Flavor:Google" \
      http://169.254.169.254/computeMetadata/v1/instance/name)"
      sudo echo "Page served from: $vm_hostname" | \
      tee /var/www/html/index.html
      sudo systemctl restart apache2
      
    5. Nella sezione Networking, per Rete, seleziona lb-network e per Subnet seleziona backend-subnet.

    6. Aggiungi il seguente tag di rete: load-balanced-backend.

    7. Fai clic su Create (Crea).

  2. Creare un gruppo di istanze gestite. 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 la sezione MIG stateless o stateful.
    3. In Nome, inserisci l7-xlb-backend-example.
    4. Per Località, seleziona Zona singola.
    5. In Regione, seleziona us-west1.
    6. In Zona, seleziona us-west1-a.
    7. In Modello di istanza, seleziona l7-xlb-backend-template.
    8. 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ù.

    9. Fai clic su Create (Crea).

gcloud

Le istruzioni di gcloud 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 l7-xlb-backend-template \
    --region=us-west1 \
    --network=lb-network \
    --subnet=backend-subnet \
    --tags=load-balanced-backend \
    --image-family=debian-10 \
    --image-project=debian-cloud \
    --metadata=startup-script='#! /bin/bash
    sudo apt-get update
    sudo apt-get install apache2 -y
    sudo a2ensite default-ssl
    sudo a2enmod ssl
    vm_hostname="$(curl -H "Metadata-Flavor:Google" \
    http://169.254.169.254/computeMetadata/v1/instance/name)"
    sudo echo "Page served from: $vm_hostname" | \
    tee /var/www/html/index.html
    sudo 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 l7-xlb-backend-example \
        --zone=us-west1-a \
        --size=2 \
        --template=l7-xlb-backend-template
    

Terraform

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

resource "google_compute_instance_template" "default" {
  name = "l7-xlb-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-10"
    type         = "PERSISTENT"
  }
  labels = {
    managed-by-cnrm = "true"
  }
  machine_type = "n1-standard-1"
  metadata = {
    startup-script = <<EOF
    #! /bin/bash
    sudo apt-get update
    sudo apt-get install apache2 -y
    sudo a2ensite default-ssl
    sudo a2enmod ssl
    vm_hostname="$(curl -H "Metadata-Flavor:Google" \
    http://169.254.169.254/computeMetadata/v1/instance/name)"
    sudo echo "Page served from: $vm_hostname" | \
    tee /var/www/html/index.html
    sudo systemctl restart apache2
    EOF
  }
  network_interface {
    access_config {
      network_tier = "PREMIUM"
    }
    network    = google_compute_network.default.id
    subnetwork = google_compute_subnetwork.default.id
  }
  region = "us-west1"
  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 = ["load-balanced-backend"]
}

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

resource "google_compute_instance_group_manager" "default" {
  name = "l7-xlb-backend-example"
  zone = "us-west1-a"
  named_port {
    name = "http"
    port = 80
  }
  version {
    instance_template = google_compute_instance_template.default.id
    name              = "primary"
  }
  base_instance_name = "vm"
  target_size        = 2
}

API

  1. 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":"l7-xlb-backend-template",
     "properties": {
       "machineType":"e2-standard-2",
       "tags": {
         "items":[
           "load-balanced-backend"
         ]
       },
       "metadata": {
         "kind":"compute#metadata",
         "items":[
           {
             "key":"startup-script",
             "value":"#! /bin/bash\nsudo apt-get update\nsudo apt-get install apache2 -y\nsudo a2ensite default-ssl\nsudo a2enmod ssl\nvm_hostname=\"$(curl -H \"Metadata-Flavor:Google\" \\\nhttp://169.254.169.254/computeMetadata/v1/instance/name)\"\nsudo echo \"Page served from: $vm_hostname\" | \\\ntee /var/www/html/index.html\nsudo systemctl restart apache2"
           }
         ]
       },
       "networkInterfaces":[
         {
           "network":"projects/PROJECT_ID/global/networks/lb-network",
           "subnetwork":"regions/us-west1/subnetworks/backend-subnet",
           "accessConfigs":[
             {
               "type":"ONE_TO_ONE_NAT"
             }
           ]
         }
       ],
       "disks": [
         {
           "index":0,
           "boot":true,
           "initializeParams": {
             "sourceImage":"projects/debian-cloud/global/images/family/debian-10"
           },
           "autoDelete":true
         }
       ]
     }
    }
    
  2. Crea un gruppo di istanze gestite in ogni zona con il metodo instanceGroupManagers.insert, sostituendo PROJECT_ID con l'ID progetto.

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/{zone}/instanceGroupManagers
    {
     "name": "l7-xlb-backend-example",
     "zone": "projects/PROJECT_ID/zones/us-west1-a",
     "instanceTemplate": "projects/PROJECT_ID/global/instanceTemplates/l7-xlb-backend-template",
     "baseInstanceName": "l7-xlb-backend-example",
     "targetSize": 2
    }
    

Aggiungi una porta denominata al gruppo di istanze

Per il tuo gruppo di istanze, definisci un servizio HTTP e mappa un nome di porta alla porta pertinente. Il servizio di backend del bilanciatore del carico inoltra il traffico alla porta denominata.

Console

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

    Vai a Gruppi di istanze

  2. Fai clic sul nome del gruppo di istanze (in questo esempio l7-xlb-backend-example).

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

  4. Fai clic su Specifica il nome della porta per il mapping.

  5. Fai clic su Aggiungi elemento.

  6. Come nome della porta, inserisci http. Come numero di porta, inserisci 80.

  7. Fai clic su Salva.

gcloud

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

gcloud compute instance-groups set-named-ports l7-xlb-backend-example \
    --named-ports http:80 \
    --zone us-west1-a

Terraform

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

Prenota l'indirizzo IP del bilanciatore del carico

Console

  1. In Google Cloud Console, vai alla pagina Prenota un indirizzo statico.

    Vai a Prenotare un indirizzo statico

  2. Scegli un Nome per il nuovo indirizzo.

  3. In Livello di servizio di rete, seleziona Standard.

  4. Per Versione IP, seleziona IPv4. Gli indirizzi IPv6 possono essere solo globali e possono essere utilizzati solo con bilanciatori del carico globali.

  5. Per Tipo, seleziona Regione.

  6. In Area geografica, seleziona us-west1.

  7. Lascia l'opzione Attached to (Associato a) impostata su None. Dopo aver creato il bilanciatore del carico, questo indirizzo IP verrà collegato alla regola di forwarding del bilanciatore del carico.

  8. Fai clic su Prenota per prenotare l'indirizzo IP.

gcloud

  1. Per prenotare un indirizzo IP esterno statico utilizzando gcloud compute, utilizza il comando compute addresses create.

    gcloud compute addresses create ADDRESS_NAME  \
       --region=us-west1 \
       --network-tier=STANDARD
    

    Sostituisci quanto segue:

    • ADDRESS_NAME: il nome che vuoi assegnare a questo indirizzo.
    • REGION: l'area geografica in cui vuoi prenotare questo indirizzo. Questa regione deve essere la stessa del bilanciatore del carico. Tutti gli indirizzi IP a livello di area geografica sono IPv4.
  2. Utilizza il comando compute addresses describe per visualizzare il risultato:

    gcloud compute addresses describe ADDRESS_NAME
    

Terraform

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

resource "google_compute_address" "default" {
  name         = "address-name"
  address_type = "EXTERNAL"
  network_tier = "STANDARD"
  region       = "us-west1"
}

Per scoprire come applicare o rimuovere una configurazione di Terraform, vedi Lavorare con una configurazione di Terraform.

API

Per creare un indirizzo IPv4 a livello di regione, chiama il metodo addresses.insert a livello di regione:

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/addresses

Il corpo della richiesta deve contenere quanto segue:

{
  "name": "ADDRESS_NAME"
  "networkTier": "STANDARD"
  "region": "us-west1"
}

Sostituisci quanto segue:

  • ADDRESS_NAME: il nome dell'indirizzo
  • REGION: il nome della regione per questa richiesta
  • PROJECT_ID: l'ID progetto per questa richiesta

Configura il bilanciatore del carico

L'esempio seguente mostra come creare le seguenti risorse del bilanciatore del carico HTTP(S) a livello di area geografica:

  • Controllo di integrità HTTP
  • Servizio di backend con un gruppo di istanze gestite come backend
  • Una mappa URL
    • Assicurati di fare riferimento a una mappa URL a livello di regione se è stata definita una regione per il proxy HTTP(S) di destinazione. Una mappa URL a livello di area geografica indirizza le richieste a un servizio di backend a livello di area geografica in base alle regole che hai definito per l'host e il percorso di un URL in arrivo. È possibile fare riferimento a una mappa URL a livello di regione solo tramite una regola proxy di destinazione a livello di regione nella stessa area geografica.
  • Certificato SSL (per HTTPS)
  • Proxy di destinazione
  • Regola di forwarding

Disponibilità del proxy

A volte le regioni Google Cloud non hanno una capacità proxy sufficiente per un nuovo bilanciatore del carico. In questo caso, Google Cloud Console fornisce un messaggio di avviso sulla disponibilità del proxy quando crei il bilanciatore del carico. Per risolvere questo problema, puoi procedere in uno dei seguenti modi:

  • Seleziona una regione diversa per il bilanciatore del carico. Questa può essere un'opzione pratica se disponi di backend in un'altra area geografica.
  • Seleziona una rete VPC a cui è già assegnata una subnet solo proxy.
  • Attendi che il problema di capacità venga risolto.

Console

  1. In Google Cloud Console, vai alla pagina Crea un bilanciatore del carico.

    Vai a Creare un bilanciatore del carico

  2. Nella scheda Bilanciamento del carico HTTP(S), fai clic su Avvia configurazione.

  3. Nella sezione Per Internet o solo interno, seleziona Da Internet alle mie VM o ai miei servizi serverless. Questa impostazione significa che il bilanciatore del carico è un bilanciatore del carico HTTP(S) esterno.

  4. Nella sezione Gestione avanzata del traffico:

    1. Seleziona Bilanciatore del carico HTTP(S) con gestione avanzata del traffico.
    2. Seleziona Bilanciatore del carico HTTP(S) a livello di regione.
  5. Fai clic su Continua.

Crea un bilanciatore del carico HTTP(S) esterno a livello di regione

  1. Come nome del bilanciatore del carico, inserisci regional-l7-xlb.
  2. In Regione, seleziona us-west1.
  3. In Rete, seleziona lb-network.

Prenota una subnet solo proxy

Per un bilanciatore del carico HTTP(S) esterno a livello di regione, prenota una subnet solo proxy:

  1. Fai clic su Prenota una subnet.
  2. In Nome, inserisci proxy-only-subnet.

  3. In Intervallo di indirizzi IP, inserisci 10.129.0.0/23.

  4. Fai clic su Add (Aggiungi).

Configurare il frontend

Per HTTP:

  1. Fai clic su Configurazione frontend.
  2. Imposta il nome su l7-xlb-forwarding-rule.
  3. Imposta Protocollo su HTTP.
  4. Imposta il campo Porta su 80.
  5. Seleziona l'indirizzo IP che hai creato in Prenotazione dell'indirizzo IP del bilanciatore del carico.
  6. Fai clic su Fine.

Per HTTPS:

Se utilizzi HTTPS tra il client e il bilanciatore del carico, sono necessarie una o più risorse del certificato SSL per configurare il proxy. Per informazioni su come creare risorse dei certificati SSL, consulta i certificati SSL. I certificati gestiti da Google non sono attualmente supportati con i bilanciatori del carico HTTP(S) esterni a livello di regione.

  1. Fai clic su Configurazione frontend.
  2. Nel campo Nome, inserisci l7-xlb-forwarding-rule.
  3. Nel campo Protocollo, seleziona HTTPS (includes HTTP/2).
  4. Assicurati che la Porta sia impostata su 443.
  5. Seleziona l'indirizzo IP che hai creato in Prenotazione dell'indirizzo IP del bilanciatore del carico.
  6. Nell'elenco Certificato, procedi nel seguente modo:
    1. Se hai già una risorsa del certificato SSL autogestito, seleziona il certificato SSL principale.
    2. Fai clic su Crea un nuovo certificato.
      1. Nel campo Nome, inserisci l7-xlb-cert.
      2. Nei campi appropriati, carica i file in formato PEM:
        • Certificato di chiave pubblica
        • Catena di certificati
        • Chiave privata
      3. Fai clic su Create (Crea).
  7. Facoltativo: per aggiungere certificati oltre al certificato SSL principale:
    1. Fai clic su Aggiungi certificato.
    2. Se hai già un certificato, selezionalo dall'elenco Certificati.
    3. Facoltativo: fai clic su Crea un nuovo certificato e segui le istruzioni specificate nel passaggio precedente.
  8. Seleziona un criterio SSL dall'elenco dei criteri SSL. Se non hai creato criteri SSL, viene applicato un criterio SSL predefinito di GCP.
  9. Fai clic su Fine.

Configura il servizio di backend

  1. Fai clic su Configurazione backend.
  2. Dal menu Crea o seleziona servizi di backend, seleziona Crea un servizio di backend.
  3. Imposta il nome del servizio di backend su l7-xlb-backend-service.
  4. In Protocollo, seleziona HTTP.
  5. In Porta denominata, inserisci http.
  6. Imposta Tipo di backend su Gruppo di istanze.
  7. Nella sezione Nuovo backend:
    1. Imposta Gruppo di istanze su l7-xlb-backend-example.
    2. Imposta Trasferisci numeri su 80.
    3. Imposta Modalità di equilibrio su Utilizzo.
    4. Fai clic su Fine.
  8. Nell'elenco Controllo di integrità, fai clic su Crea controllo di integrità.
    1. Imposta il nome su l7-xlb-basic-check.
    2. Imposta Protocollo su HTTP.
    3. Imposta il campo Porta su 80.
    4. Fai clic su Salva.
  9. Fai clic su Create (Crea).

Configurare le regole di routing

  1. Fai clic su Regole di routing.
  2. In Modalità, seleziona Semplice regola host e percorso.
  3. Assicurati che l7-xlb-backend-service sia l'unico servizio di backend per qualsiasi host senza corrispondenza e qualsiasi percorso senza corrispondenza.

Rivedi la configurazione

Controlla il bilanciatore del carico per assicurarti che sia configurato come previsto, quindi 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 l7-xlb-basic-check \
       --region=us-west1 \
       --request-path='/' \
       --use-serving-port
    
  2. Definisci il servizio di backend con il comando gcloud compute backend-services create.

    gcloud compute backend-services create l7-xlb-backend-service \
      --load-balancing-scheme=EXTERNAL_MANAGED \
      --protocol=HTTP \
      --port-name=http \
      --health-checks=l7-xlb-basic-check \
      --health-checks-region=us-west1 \
      --region=us-west1
    
  3. Aggiungi backend al servizio di backend con il comando gcloud compute backend-services add-backend.

    gcloud compute backend-services add-backend l7-xlb-backend-service \
      --balancing-mode=UTILIZATION \
      --instance-group=l7-xlb-backend-example \
      --instance-group-zone=us-west1-a \
      --region=us-west1
    
  4. Crea la mappa URL con il comando gcloud compute url-maps create.

    gcloud compute url-maps create regional-l7-xlb-map \
      --default-service=l7-xlb-backend-service \
      --region=us-west1
    
  5. Crea il proxy di destinazione.

    Per HTTP:

    Per un bilanciatore del carico HTTP, crea il proxy di destinazione con il comando gcloud compute target-http-proxies create.

    gcloud compute target-http-proxies create l7-xlb-proxy \
      --url-map=regional-l7-xlb-map \
      --url-map-region=us-west1 \
      --region=us-west1
    

    Per HTTPS:

    Per informazioni su come creare risorse dei certificati SSL, consulta i certificati SSL. I certificati gestiti da Google non sono supportati con i bilanciatori del carico HTTP(S) esterni a livello di regione.

    1. Assegna i percorsi dei file ai nomi delle variabili.

      export LB_CERT=path to PEM-formatted file
      
      export LB_PRIVATE_KEY=path to PEM-formatted file
      
    2. Crea un certificato SSL a livello di regione utilizzando il comando gcloud compute ssl-certificates create.

      gcloud compute ssl-certificates create l7-xlb-cert \
       --certificate=$LB_CERT \
       --private-key=$LB_PRIVATE_KEY \
       --region=us-west1
      
    3. Utilizza il certificato SSL a livello di regione per creare un proxy di destinazione con il comando gcloud compute target-https-proxies create.

      gcloud compute target-https-proxies create l7-xlb-proxy \
       --url-map=regional-l7-xlb-map \
       --region=us-west1 \
       --ssl-certificates=l7-xlb-cert
      
  6. Crea la regola di forwarding.

    Per HTTP:

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

    gcloud compute forwarding-rules create l7-xlb-forwarding-rule \
      --load-balancing-scheme=EXTERNAL_MANAGED \
      --network-tier=STANDARD \
      --network=lb-network \
      --address=ADDRESS_NAME \
      --ports=80 \
      --region=us-west1 \
      --target-http-proxy=l7-xlb-proxy \
      --target-http-proxy-region=us-west1
    

    Per HTTPS:

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

    gcloud compute forwarding-rules create l7-xlb-forwarding-rule \
      --load-balancing-scheme=EXTERNAL_MANAGED \
      --network-tier=STANDARD \
      --network=lb-network \
      --address=ADDRESS_NAME \
      --ports=443 \
      --region=us-west1 \
      --target-https-proxy=l7-xlb-proxy \
      --target-https-proxy-region=us-west1
    

Terraform

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

resource "google_compute_region_health_check" "default" {
  name               = "l7-xlb-basic-check"
  check_interval_sec = 5
  healthy_threshold  = 2
  http_health_check {
    port_specification = "USE_SERVING_PORT"
    proxy_header       = "NONE"
    request_path       = "/"
  }
  region              = "us-west1"
  timeout_sec         = 5
  unhealthy_threshold = 2
}

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

resource "google_compute_region_backend_service" "default" {
  name                  = "l7-xlb-backend-service"
  region                = "us-west1"
  load_balancing_scheme = "EXTERNAL_MANAGED"
  health_checks         = [google_compute_region_health_check.default.id]
  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
  }
}

Per creare la mappa URL, utilizza la risorsa google_compute_region_url_map.

resource "google_compute_region_url_map" "default" {
  name            = "regional-l7-xlb-map"
  region          = "us-west1"
  default_service = google_compute_region_backend_service.default.id
}

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

resource "google_compute_region_target_http_proxy" "default" {
  name    = "l7-xlb-proxy"
  region  = "us-west1"
  url_map = google_compute_region_url_map.default.id
}

Per creare la regola di forwarding, utilizza la risorsa google_compute_forwarding_rule.

resource "google_compute_forwarding_rule" "default" {
  name       = "l7-xlb-forwarding-rule"
  provider   = google-beta
  depends_on = [google_compute_subnetwork.proxy_only]
  region     = "us-west1"

  ip_protocol           = "TCP"
  load_balancing_scheme = "EXTERNAL_MANAGED"
  port_range            = "80"
  target                = google_compute_region_target_http_proxy.default.id
  network               = google_compute_network.default.id
  ip_address            = google_compute_address.default.id
  network_tier          = "STANDARD"
}

Per scoprire come applicare o rimuovere una configurazione di Terraform, vedi Lavorare con una configurazione di Terraform.

API

Crea il controllo di integrità effettuando una richiesta POST al metodo regionHealthChecks.insert, sostituendo PROJECT_ID con l'ID progetto.

POST https://compute.googleapis.com/compute/v1/projects/<var>PROJECT_ID</var>/regions/{region}/healthChecks
{
  "name": "l7-xlb-basic-check",
  "type": "HTTP",
  "httpHealthCheck": {
    "portSpecification": "USE_SERVING_PORT"
  }
}

Crea il servizio di backend a livello di area geografica inviando una richiesta POST al metodo regionBackendServices.insert, sostituendo PROJECT_ID con l'ID progetto.

POST https://compute.googleapis.com/compute/v1/projects/<var>PROJECT_ID</var>/regions/us-west1/backendServices
{
  "name": "l7-xlb-backend-service",
  "backends": [
    {
      "group": "projects/<var>PROJECT_ID</var>/zones/us-west1-a/instanceGroups/l7-xlb-backend-example",
      "balancingMode": "UTILIZATION"
    }
  ],
  "healthChecks": [
    "projects/<var>PROJECT_ID</var>/regions/us-west1/healthChecks/l7-xlb-basic-check"
  ],
  "loadBalancingScheme": "EXTERNAL_MANAGED"
}

Crea la mappa URL inviando una richiesta POST al metodo regionUrlMaps.insert, sostituendo PROJECT_ID con l'ID progetto.

POST https://compute.googleapis.com/compute/v1/projects/<var>PROJECT_ID</var>/regions/us-west1/urlMaps
{
  "name": "regional-l7-xlb-map",
  "defaultService": "projects/<var>PROJECT_ID</var>/regions/us-west1/backendServices/l7-xlb-backend-service"
}

Crea il proxy HTTP di destinazione inviando una richiesta POST al metodo regionTargetHttpProxies.insert, sostituendo PROJECT_ID con l'ID progetto.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/targetHttpProxy
{
  "name": "l7-xlb-proxy",
  "urlMap": "projects/PROJECT_ID/global/urlMaps/regional-l7-xlb-map",
  "region": "us-west1"
}

Crea la regola di forwarding inviando una richiesta POST al metodo forwardingRules.insert, sostituendo PROJECT_ID con l'ID progetto.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules
{
  "name": "l7-xlb-forwarding-rule",
  "IPAddress": "10.1.2.99",
  "IPProtocol": "TCP",
  "portRange": "80-80",
  "target": "projects/PROJECT_ID/regions/us-west1/targetHttpProxies/l7-xlb-proxy",
  "loadBalancingScheme": "EXTERNAL_MANAGED",
  "network": "projects/PROJECT_ID/global/networks/lb-network",
  "networkTier": "STANDARD",
}

Collegare il dominio al bilanciatore del carico

Dopo aver creato il bilanciatore del carico, annota l'indirizzo IP associato al 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 certificato SSL, devi aggiungere un record A per ciascuno, il tutto puntando all'indirizzo IP del bilanciatore del carico. Ad esempio, per creare record A per www.example.com e example.com:

NAME                  TYPE     DATA
www                   A        30.90.80.100
@                     A        30.90.80.100

Se utilizzi Google Domains, visita la pagina della guida di Google Domains per ulteriori informazioni.

Testa il bilanciatore del carico

Ora che il servizio di bilanciamento del carico è in esecuzione, puoi inviare il traffico alla regola di forwarding e osservare il traffico che viene distribuito in istanze diverse.

Console

  1. In Google Cloud Console, vai alla pagina Bilanciamento del carico.

    Vai a Bilanciamento del carico

  2. Seleziona il bilanciatore del carico appena creato.
  3. Nella sezione Backend, verifica che le VM siano in stato integro. La colonna Integri deve essere compilata, a indicare che entrambe le VM sono in stato integro (2/2). In caso contrario, prova prima a ricaricare la pagina. La console di Google Cloud potrebbe richiedere alcuni istanti per indicare che le VM sono in stato integro. Se i backend non risultano integri dopo alcuni minuti, rivedi la configurazione del firewall e il tag di rete assegnato alle VM di backend.
  4. Dopo che la console di Google Cloud mostra che le istanze di backend sono in stato integro, puoi testare il bilanciatore del carico utilizzando un browser web andando a https://IP_ADDRESS (o http://IP_ADDRESS). Sostituisci IP_ADDRESS con l'indirizzo IP del bilanciatore del carico.
  5. Se hai utilizzato un certificato autofirmato per testare HTTPS, il tuo browser visualizza un avviso. Devi indicare esplicitamente al browser di accettare un certificato autofirmato.
  6. Il tuo browser dovrebbe visualizzare una pagina con contenuti che mostrano il nome dell'istanza che ha pubblicato la pagina, insieme alla zona (ad esempio, Page served from: lb-backend-example-xxxx). Se il browser non mostra questa pagina, rivedi le impostazioni di configurazione in questa guida.

gcloud

Prendi nota dell'indirizzo IPv4 riservato:

gcloud beta compute addresses describe ADDRESS_NAME \
    --format="get(address)" \
    --region="us-west1"

Puoi testare il tuo bilanciatore del carico tramite un browser web andando all'indirizzo https://IP_ADDRESS (o http://IP_ADDRESS). Sostituisci IP_ADDRESS con l'indirizzo IP del bilanciatore del carico.

Se hai utilizzato un certificato autofirmato per testare HTTPS, il tuo browser visualizza un avviso. Devi indicare esplicitamente al browser di accettare un certificato autofirmato.

Il tuo browser dovrebbe eseguire il rendering di una pagina con informazioni minime sull'istanza di backend. Se il tuo browser non esegue il rendering di questa pagina, rivedi le impostazioni di configurazione in questa guida.

Opzioni di configurazione aggiuntive

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

Abilita affinità sessione

Queste procedure mostrano come aggiornare un servizio di backend per il bilanciatore del carico HTTP(S) esterno di esempio a livello di regione in modo che il servizio di backend utilizzi l'affinità cookie generata, l'affinità campo di intestazione o l'affinità cookie HTTP.

Quando l'affinità cookie generata è abilitata, il bilanciatore del carico invia un cookie alla prima richiesta. Per ogni richiesta successiva con lo stesso cookie, il bilanciatore del carico indirizza la richiesta alla stessa VM o endpoint di backend. Per i bilanciatori del carico HTTP(S) esterni a livello di regione, il cookie è denominato GCILB.

Quando è abilitata l'affinità dei campi di intestazione, il bilanciatore del carico instrada le richieste a VM o endpoint di backend in un NEG in base al valore dell'intestazione HTTP denominata nel flag --custom-request-header. L'affinità campo del titolo è 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 VM o endpoint di backend in un NEG, in base a un cookie HTTP denominato nel 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. L'affinità cookie HTTP è 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 cookie HTTP.

Console

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

  1. In Google Cloud Console, vai alla pagina Bilanciamento del carico.

    Vai a Bilanciamento del carico

  2. Seleziona il bilanciatore del carico appena creato.

  3. Fai clic su Backend.

  4. Fai clic su l7-xlb-backend-service (il nome del servizio di backend che hai creato per questo esempio) e fai clic su Modifica.

  5. Nella pagina Dettagli del servizio di backend, fai clic su Configurazione avanzata.

  6. Per Affinità sessione, seleziona dal menu il tipo di affinità sessione che preferisci.

  7. Fai clic su Aggiorna.

gcloud

Utilizza i seguenti comandi gcloud per aggiornare il servizio di backend l7-xlb-backend-service a diversi tipi di affinità sessione:

gcloud compute backend-services update l7-xlb-backend-service \
    --session-affinity=[GENERATED_COOKIE | HEADER_FIELD | HTTP_COOKIE | CLIENT_IP]
    --region=us-west1

API

Per impostare l'affinità sessione, effettua una richiesta PATCH al metodo regionBackendServices/patch.

PATCH https://compute.googleapis.com/compute/v1/projects/[PROJECT_ID]/regions/us-west1/regionBackendServices/l7-xlb-backend-service
{
  "sessionAffinity": ["GENERATED_COOKIE" | "HEADER_FIELD" | "HTTP_COOKIE" | "CLIENT_IP" ]
}

Passaggi successivi