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

Console

1. Nella console Google Cloud, 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 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 nella regione 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. Invia una richiesta POST al metodo networks.insert, sostituendo PROJECT_ID con l'ID del tuo progetto.

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks
   {
    "routingConfig": {
      "routingMode": "REGIONAL"
    },
    "name": "lb-network",
    "autoCreateSubnetworks": false
   }
   

2. Invia una richiesta POST al metodo subnetworks.insert, sostituendo PROJECT_ID con l'ID del tuo 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",
   }
   

Console

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

Se vuoi creare subito la subnet solo proxy:

1. Nella console Google Cloud, 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 regione.

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

8. Fai clic su 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 del 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 l'ID del tuo 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"
}

Console

1. Nella console Google Cloud, vai alla pagina Criteri 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 di porta.
       Come best practice, limita questa regola solo ai protocolli e alle porte che corrispondono a quelli utilizzati dal controllo dell'integrità. Se utilizzi tcp:80 per il protocollo e la porta, Google Cloud può utilizzare HTTP sulla porta 80 per contattare le VM, ma non può utilizzare HTTPS sulla porta 443 per contattarle.

3. Fai clic su Crea.

4. Fai clic su Crea regola firewall per creare la regola che consente 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 e inserisci 80, 443, 8080 per i numeri di porta.

5. Fai clic su 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 proveniente dai probe del controllo di integrità. Tuttavia, puoi configurare un insieme più ristretto di porte in base alle tue esigenze.

   gcloud compute firewall-rules create fw-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 ai proxy del bilanciatore del carico delle applicazioni esterno regionale di connettersi ai tuoi backend. Imposta source-ranges sugli intervalli allocati 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 inviando 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 del proxy per il metodo firewalls.insert, sostituendo PROJECT_ID con l'ID del tuo progetto.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls
{
  "name": "fw-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"
}

Console

1. Creare un modello di istanza. Nella console Google Cloud, 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 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.
   4. Fai clic su Opzioni avanzate.
   5. Fai clic su Networking e configura i seguenti campi:
      1. In Tag di rete, inserisci load-balanced-backend.
      2. In Interfacce di rete, seleziona quanto segue:
         • Rete: lb-network
         • Subnet: backend-subnet

   6. Fai clic su Gestione. Inserisci lo script che segue nel campo Script di avvio.

      #! /bin/bash
      apt-get update
      apt-get install apache2 -y
      a2ensite default-ssl
      a2enmod ssl
      vm_hostname="$(curl -H "Metadata-Flavor:Google" \
      http://metadata.google.internal/computeMetadata/v1/instance/name)"
      echo "Page served from: $vm_hostname" | \
      tee /var/www/html/index.html
      systemctl restart apache2
      

   7. Fai clic su 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 Gruppi di istanze gestite stateless o stateful.
   3. In Nome, inserisci l7-xlb-backend-example.
   4. In 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 Crea.

gcloud

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

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-12"
    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\napt-get update\napt-get install apache2 -y\na2ensite default-ssl\na2enmod ssl\nvm_hostname=\"$(curl -H \"Metadata-Flavor:Google\" \\\nhttp://metadata.google.internal/computeMetadata/v1/instance/name)\"\necho \"Page served from: $vm_hostname\" | \\\ntee /var/www/html/index.html\nsystemctl 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-12"
          },
          "autoDelete":true
        }
      ]
    }
   }
   

2. Crea un gruppo di istanze gestite in ogni zona con il metodo instanceGroupManagers.insert sostituendo PROJECT_ID con l'ID del tuo progetto.

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/{zone}/instanceGroupManagers
   {
    "name": "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
   }
   

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

4. Fai clic su Specifica il mapping dei nomi delle porte.

5. Fai clic su Aggiungi elemento.

6. Come nome della porta, inserisci http. Per il 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.

Console

1. Nella console Google Cloud, vai alla pagina Prenotare un indirizzo statico.

   Vai a Prenota un indirizzo statico

2. Scegli un nome per il nuovo indirizzo.

3. In Network Service Tier (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. In Tipo, seleziona Regionale.

6. In Regione, seleziona us-west1.

7. Lascia l'opzione Associato a impostata su Nessuna. 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: la regione in cui vuoi prenotare questo indirizzo. Deve essere la stessa regione del bilanciatore del carico. Tutti gli indirizzi IP regionali 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 Terraform, consulta Comandi Terraform di base.

API

Per creare un indirizzo IPv4 regionale, chiama il metodo addresses.insert regionale:

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

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 carichi di lavoro regionali e fai clic su Avanti.
6. Fai clic su Configura.

Configurazione di base

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

Riservazione di una subnet solo proxy

Per un bilanciatore del carico delle applicazioni esterno regionale, riserva una subnet solo proxy:

1. Fai clic su Riserva subnet.
2. In Nome, inserisci proxy-only-subnet.
3. In Intervallo di indirizzi IP, inserisci 10.129.0.0/23.
4. Fai clic su Aggiungi.

Configura il frontend

Per HTTP:

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

Per HTTPS:

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. Imposta Network Service Tier su Standard.
5. Assicurati che Porta sia impostata su 443.
6. Seleziona l'indirizzo IP che hai creato in Prenotazione dell'indirizzo IP del bilanciatore del carico.
7. Nell'elenco Certificato:
   1. Se hai già una risorsa certificato SSL con gestione indipendente di Compute Engine, 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
         • Chiave privata
      3. Fai clic su Crea.
8. (Facoltativo) Per aggiungere certificati oltre al certificato SSL principale:
   1. Fai clic su Aggiungi certificato.
   2. Se hai già un certificato, selezionalo dall'elenco Certificates (Certificati).
   3. (Facoltativo) Fai clic su Crea un nuovo certificato e segui le istruzioni riportate nel passaggio precedente.

9. Seleziona un criterio SSL dall'elenco Criterio SSL. Facoltativamente, per creare un criterio SSL, procedi nel seguente modo:

   1. Nell'elenco Criteri SSL, seleziona Crea un criterio.
   2. Inserisci un nome per il criterio SSL.
   3. Seleziona una versione TLS minima. Il valore predefinito è TLS 1.0.
   4. Seleziona uno dei profili gestiti da Google preconfigurati o un profilo Personalizzato che ti consente di selezionare le funzionalità SSL singolarmente. 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 di Google Cloud.

10. 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 Numeri di porta su 80.
   3. Imposta Modalità di bilanciamento su Utilizzo.
   4. Fai clic su Fine.
8. Nell'elenco Controllo di integrità, fai clic su Crea un controllo di integrità.
   1. Imposta Nome su l7-xlb-basic-check.
   2. Imposta Protocollo su HTTP.
   3. Imposta Porta su 80.
   4. Fai clic su Salva.
9. Fai clic su Crea.

Configurare le regole di routing

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

Esamina la configurazione

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 dell'API REST che verrà utilizzata per creare il bilanciatore del carico.
4. 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 i 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:

   Puoi creare certificati Compute Engine o Certificate Manager. Utilizza uno dei seguenti metodi per creare certificati utilizzando Certificate Manager:

   • Certificati autogestiti a livello di regione. Per informazioni su come creare e utilizzare i certificati autogestiti a livello di regione, consulta la sezione Eseguire il deployment di un certificato autogestito a livello di regione. Le mappe dei certificati non sono supportate.

   • Certificati gestiti da Google a livello di regione. Le mappe dei certificati non sono supportate.

     Gestore certificati supporta i seguenti tipi di certificati gestiti da Google a livello di regione:

     • Certificati gestiti a livello di regione da Google con autorizzazione DNS per progetto. Per ulteriori informazioni, consulta Eseguire il deployment di un certificato gestito da Google a livello di regione.
     • Certificati (privati) gestiti da Google a livello di regione con Certificate Authority Service. Per ulteriori informazioni, consulta Eseguire il deployment di un certificato gestito da Google a livello di regione con il servizio CA.

   Dopo aver creato i certificati, allegali direttamente al proxy di destinazione.

   1. Assegna i percorsi 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
      

   • 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 Terraform, consulta Comandi Terraform di base.

API

Crea il controllo di integrità inviando una richiesta POST al metodo regionHealthChecks.insert, sostituendo PROJECT_ID con l'ID del tuo 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 regionale inviando una richiesta POST al metodo regionBackendServices.insert, sostituendo PROJECT_ID con il tuo 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 del tuo 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 del tuo 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 del tuo 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",
}

Console

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

   Vai a Bilanciamento del carico

2. Seleziona il 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 in stato di integrità (2/2). In caso contrario, prova prima a ricaricare la 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 essere operativi dopo alcuni minuti, controlla la configurazione del firewall e il tag di rete assegnato alle VM di backend.
4. Dopo che la console Google Cloud indica che le istanze di backend sono in stato attivo, 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.
5. Se hai utilizzato un certificato autofirmato per testare HTTPS, il browser visualizza un avviso. Devi indicare esplicitamente al browser di accettare un certificato autofirmato.
6. 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

Prendi nota dell'indirizzo IPv4 riservato:

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

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

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

Il browser dovrebbe visualizzare una pagina con informazioni minime sull'istanza di backend. Se il browser non visualizza questa pagina, controlla le impostazioni di configurazione riportate in questa guida.

Console

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

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

   Vai a Bilanciamento del carico

2. Seleziona il bilanciatore del carico che hai 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 poi su Modifica.

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

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

7. Fai clic su Aggiorna.

gcloud

Utilizza i seguenti comandi 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, invia una richiesta PATCH al metodo regionBackendServices/patch.

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