Configura un bilanciatore del carico delle applicazioni interno con un VPC condiviso

Console

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

   Vai alle reti VPC

2. Fai clic su Crea rete VPC.
3. In Nome, inserisci lb-network.

4. Nella sezione Subnet:

   1. Imposta Modalità di creazione subnet su Personalizzata.

   2. Nella sezione Nuova subnet, inserisci le informazioni seguenti:

      • Nome: lb-frontend-and-backend-subnet

      • Regione: us-west1

      • Intervallo di indirizzi IP: 10.1.2.0/24

   3. Fai clic su Fine.

5. Fai clic su Crea.

gcloud

1. Crea una rete VPC 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:

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

Terraform

1. Crea una rete VPC:

   # Shared VPC network
   resource "google_compute_network" "lb_network" {
     name                    = "lb-network"
     provider                = google-beta
     project                 = "my-host-project-id"
     auto_create_subnetworks = false
   }

2. Crea una subnet nella regione us-west1:

   # Shared VPC network - backend subnet
   resource "google_compute_subnetwork" "lb_frontend_and_backend_subnet" {
     name          = "lb-frontend-and-backend-subnet"
     provider      = google-beta
     project       = "my-host-project-id"
     region        = "us-west1"
     ip_cidr_range = "10.1.2.0/24"
     role          = "ACTIVE"
     network       = google_compute_network.lb_network.id
   }

Console

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

   Vai alle reti VPC

2. Fai clic sul nome della rete VPC condiviso: lb-network.
3. Fai clic su Aggiungi subnet.
4. In Nome, inserisci proxy-only-subnet.
5. In Regione, seleziona us-west1.
6. Imposta Purpose su Regional Managed Proxy (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

Crea la subnet solo proxy:

# Shared VPC network - proxy-only subnet
resource "google_compute_subnetwork" "proxy_only_subnet" {
  name          = "proxy-only-subnet"
  provider      = google-beta
  project       = "my-host-project-id"
  region        = "us-west1"
  ip_cidr_range = "10.129.0.0/23"
  role          = "ACTIVE"
  purpose       = "REGIONAL_MANAGED_PROXY"
  network       = google_compute_network.lb_network.id
}

Console

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

   Vai a Criteri firewall

2. Fai clic su Crea regola firewall per creare la regola che consente 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 TCP e inserisci 80 per il numero di porta.

  Come best practice, limita questa regola ai soli protocolli e porte che corrispondano a quelli usati dal controllo di integrità. Se utilizzi tcp:80 per il protocollo e la porta, Google Cloud può utilizzare HTTP sulla porta 80 per contattare le VM, ma non può utilizzare HTTPS sulla porta 443 contattarli.

3. Fai clic su Crea.
4. Fai clic su Crea regola firewall per creare la regola che consente Controlli di integrità di Google Cloud:
• 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 TCP e inserisci 80, 443, 8080 per i numeri di porta.
5. Fai clic su Crea.
6. Fai clic su Crea regola firewall per creare la regola che consente Controlli di integrità di Google Cloud:
• Nome: fw-allow-ssh
• Rete: lb-network
• Direzione del traffico: In entrata
• Azione in caso di corrispondenza: Consenti
• Target: Tag di destinazione specificati
• Tag di destinazione: allow-ssh
• Filtro di origine: Intervalli IPv4
• Intervalli IPv4 di origine: 0.0.0.0/0
• Protocolli e porte:
  .
  • Scegli Protocolli e porte specificati.
  • Seleziona TCP e inserisci 22 per il numero di porta.
7. Fai clic su Crea.

gcloud

1. Crea la regola firewall fw-allow-health-check per consentire Controlli di integrità di Google Cloud. Questo esempio consente tutto il traffico TCP dai probe del controllo di integrità. Tuttavia, puoi configurare un insieme di porte in modo da 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 firewall fw-allow-proxies per consentire il traffico dalla subnet solo proxy Envoy per raggiungere i tuoi backend.

   gcloud compute firewall-rules create fw-allow-proxies \
      --network=lb-network \
      --action=allow \
      --direction=ingress \
      --source-ranges=10.129.0.0/23 \
      --target-tags=load-balanced-backend \
      --rules=tcp:80,tcp:443,tcp:8080
   

3. Crea la regola firewall fw-allow-ssh per consentire l'accesso tramite SSH connettività alle VM con il tag di rete allow-ssh. Se ometti source-ranges, Google Cloud interpreta la regola nel significato che Fonte.

   gcloud compute firewall-rules create fw-allow-ssh \
      --network=lb-network \
      --action=allow \
      --direction=ingress \
      --target-tags=allow-ssh \
      --rules=tcp:22
   

Terraform

1. Crea una regola firewall per consentire i controlli di integrità di Google Cloud.

   resource "google_compute_firewall" "fw_allow_health_check" {
     name          = "fw-allow-health-check"
     provider      = google-beta
     project       = "my-host-project-id"
     direction     = "INGRESS"
     network       = google_compute_network.lb_network.id
     source_ranges = ["130.211.0.0/22", "35.191.0.0/16"]
     allow {
       protocol = "tcp"
     }
     target_tags = ["load-balanced-backend"]
   }

2. Crea una regola firewall per consentire il traffico dalla subnet solo proxy Envoy per raggiungere i tuoi backend.

   resource "google_compute_firewall" "fw_allow_proxies" {
     name          = "fw-allow-proxies"
     provider      = google-beta
     project       = "my-host-project-id"
     direction     = "INGRESS"
     network       = google_compute_network.lb_network.id
     source_ranges = ["10.129.0.0/23"]
     allow {
       protocol = "tcp"
       ports    = ["80", "443", "8080"]
     }
     target_tags = ["load-balanced-backend"]
   }

3. Crea una regola firewall per consentire la connettività SSH alle VM con la rete tag allow-ssh.

   resource "google_compute_firewall" "fw_allow_ssh" {
     name          = "fw-allow-ssh"
     provider      = google-beta
     project       = "my-host-project-id"
     direction     = "INGRESS"
     network       = google_compute_network.lb_network.id
     source_ranges = ["0.0.0.0/0"]
     allow {
       protocol = "tcp"
       ports    = ["22"]
     }
     target_tags = ["allow-ssh"]
   }

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-ilb-backend-template.
   3. Assicurati che il disco di avvio sia impostato su un'immagine Debian, ad esempio Debian GNU/Linux 12 (bookworm). Queste istruzioni utilizzano comandi sono disponibili solo su Debian, come apt-get. Se hai bisogno di modificare Su Disco di avvio, fai clic su Cambia.
      1. In Sistema operativo, seleziona Debian.
      2. Per Versione, seleziona una delle immagini Debian disponibili, come come Debian GNU/Linux 12 (bookworm).
      3. Fai clic su Seleziona.
   4. Fai clic su Opzioni avanzate, quindi su Networking.
   5. Inserisci il seguente valore per Rete tag: allow-ssh,load-balanced-backend.
   6. Nella sezione Interfacce di rete, seleziona Reti condivise con me (dal progetto host: HOST_PROJECT_ID).
   7. Seleziona la subnet lb-frontend-and-backend-subnet dalla Rete lb-network.
   8. Fai clic su Gestione. In Gestione, inserisci quanto 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
       

   9. 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. Scegli Nuovo gruppo di istanze gestite (stateless). Per ulteriori informazioni consulta le informazioni sui MIG stateless o stateful.
   3. In Nome, inserisci l7-ilb-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-ilb-backend-template.

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

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

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

      Se vuoi, nella sezione Scalabilità automatica della UI puoi configurare il gruppo di istanze per aggiungere o rimuovere automaticamente di Compute Engine in base all'utilizzo della CPU dell'istanza.

   9. Fai clic su Crea.

gcloud

Le istruzioni per gcloud in questa guida presuppongono che l'utilizzo di Cloud Shell o un altro ambiente con bash installato.

1. Crea un modello di istanza VM con un server HTTP gcloud compute instance-templates create .

   gcloud compute instance-templates create l7-ilb-backend-template \
   --region=us-west1 \
   --network=projects/HOST_PROJECT_ID/global/networks/lb-network \
   --subnet=projects/HOST_PROJECT_ID/regions/us-west1/subnetworks/lb-frontend-and-backend-subnet \
   --tags=allow-ssh,load-balanced-backend \
   --image-family=debian-12 \
   --image-project=debian-cloud \
   --metadata=startup-script='#! /bin/bash
   apt-get update
   apt-get install apache2 -y
   a2ensite default-ssl
   a2enmod ssl
   vm_hostname="$(curl -H "Metadata-Flavor:Google" \
   http://metadata.google.internal/computeMetadata/v1/instance/name)"
   echo "Page served from: $vm_hostname" | \
   tee /var/www/html/index.html
   systemctl restart apache2' \
   --project=SERVICE_PROJECT_ID
   

2. Crea un gruppo di istanze gestite nella zona con gcloud compute instance-groups managed create .

   gcloud compute instance-groups managed create l7-ilb-backend-example \
       --zone=us-west1-a \
       --size=2 \
       --template=l7-ilb-backend-template \
       --project=SERVICE_PROJECT_ID
   

Terraform

1. Creare un modello di istanza VM.

   # Instance template
   resource "google_compute_instance_template" "default" {
     name     = "l7-ilb-backend-template"
     provider = google-beta
     project  = "my-service-project-id"
     region   = "us-west1"
     # For machine type, using small. For more options check https://cloud.google.com/compute/docs/machine-types
     machine_type = "e2-small"
     tags         = ["allow-ssh", "load-balanced-backend"]
     network_interface {
       network    = google_compute_network.lb_network.id
       subnetwork = google_compute_subnetwork.lb_frontend_and_backend_subnet.id
       access_config {
         # add external ip to fetch packages like apache2, ssl
       }
     }
     disk {
       source_image = "debian-cloud/debian-12"
       auto_delete  = true
       boot         = true
     }
   
     # install apache2 and serve a simple web page
     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://metadata.google.internal/computeMetadata/v1/instance/name)"
       sudo echo "Page served from: $vm_hostname" | \
       tee /var/www/html/index.html
       sudo systemctl restart apache2
       EOF
     }
   }

2. Creare un gruppo di istanze gestite.

   Per HTTP:

   # MIG
   resource "google_compute_instance_group_manager" "default" {
     name               = "l7-ilb-backend-example"
     provider           = google-beta
     project            = "my-service-project-id"
     zone               = "us-west1-a"
     base_instance_name = "vm"
     target_size        = 2
     version {
       instance_template = google_compute_instance_template.default.id
       name              = "primary"
     }
     named_port {
       name = "http"
       port = 80
     }
   }

   Per HTTPS:

   # MIG
   resource "google_compute_instance_group_manager" "default" {
     name               = "l7-ilb-backend-example"
     provider           = google-beta
     project            = "my-service-project-id"
     zone               = "us-west1-a"
     base_instance_name = "vm"
     target_size        = 2
     version {
       instance_template = google_compute_instance_template.default.id
       name              = "primary"
     }
     named_port {
       name = "https"
       port = 443
     }
   }

Console

Passa al progetto di servizio

1. Nella console Google Cloud, vai alla pagina Dashboard.

   Vai alla dashboard

2. Fai clic sull'elenco Seleziona da nella parte superiore della pagina. Nella Seleziona da visualizzata, seleziona il progetto di servizio in cui in cui vuoi creare il bilanciatore del carico.

Avvia la configurazione

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

   Vai a Bilanciamento del carico

2. Fai clic su Crea bilanciatore del carico.
3. Per Tipo di bilanciatore del carico, seleziona Bilanciatore del carico delle applicazioni (HTTP/HTTPS) e fai clic su Avanti.
4. Per Pubblico o interno, seleziona Interno e fai clic Avanti.
5. Per Deployment tra più regioni o in una singola regione, seleziona Ideale per regionali e fai clic su Avanti.
6. Fai clic su Configura.

Configurazione di base

1. In Nome del bilanciatore del carico, inserisci l7-ilb-shared-vpc.
2. In corrispondenza di Regione, seleziona us-west1.

3. In corrispondenza di Rete, seleziona lb-network (da Progetto: HOST_PROJECT_ID).

   Se vedi una Subnet solo proxy obbligatoria nella VPC condiviso condivisa avviso, conferma che l'amministratore del progetto host abbia creato proxy-only-subnet nella regione us-west1 in lb-network rete VPC condiviso. Creazione del bilanciatore del carico riuscita anche se non hai l'autorizzazione per visualizzare la subnet solo proxy in questa pagina.

4. Tieni la finestra aperta per continuare.

Configura il 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-ilb-backend-service.
4. Imposta il Tipo di backend su Gruppi di istanze.
5. Nella sezione Nuovo backend:
   .
   1. Imposta Gruppo di istanze su l7-ilb-backend-example.
   2. Imposta Numeri di porta su 80.
   3. Imposta Modalità di bilanciamento su Utilizzo.
   4. Fai clic su Fine.
6. Nella sezione Controllo di integrità, scegli Crea un controllo di integrità con il seguenti parametri:
   .
   1. Nome: l7-ilb-basic-check
   2. Protocollo: HTTP
   3. Porta: 80
7. Fai clic su Salva e continua.
8. Fai clic su Crea.

Configura le regole di routing

• Fai clic su Regole di routing. Assicurati che l7-ilb-backend-service è l'unico servizio di backend per qualsiasi host senza corrispondenza del tuo percorso di apprendimento.

Per informazioni sulla gestione del traffico, consulta Configurazione del traffico. dei modelli.

Configura il frontend

Per HTTP:

1. Fai clic su Configurazione frontend.
2. Imposta il Nome su l7-ilb-forwarding-rule.
3. Imposta il Protocollo su HTTP.
4. Imposta Subnet su lb-frontend-and-backend-subnet. Non selezionare la subnet solo proxy per il frontend, anche se è un'opzione dell'elenco.
5. Imposta Porta su 80.
6. Fai clic sul menu Indirizzo IP, quindi su Crea indirizzo IP.
7. Nel riquadro Prenota un indirizzo IP interno statico, fornisci il parametro seguenti dettagli:
   .
   1. In Nome, inserisci ip-address-shared-vpc.
   2. Per Indirizzo IP statico, fai clic su Fammi scegliere. Per l'IP personalizzato , inserisci 10.1.2.99.
   3. (Facoltativo) Se vuoi condividere questo indirizzo IP con frontend, per impostare Scopo su Condiviso.
8. 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, vedi Certificati SSL. Gestita da Google I certificati non sono attualmente supportati con i bilanciatori del carico delle applicazioni interni.

1. Fai clic su Configurazione frontend.
2. Nel campo Nome, inserisci l7-ilb-forwarding-rule.
3. Nel campo Protocollo, seleziona HTTPS (includes HTTP/2).
4. Imposta Subnet su lb-frontend-and-backend-subnet. Non selezionare la subnet solo proxy per il frontend, anche se è un'opzione dell'elenco.
5. Assicurati che la Porta sia impostata su 443 per consentire il traffico HTTPS.
6. Fai clic sul menu Indirizzo IP, quindi su Crea indirizzo IP.
7. Nel riquadro Prenota un indirizzo IP interno statico, fornisci il parametro seguenti dettagli:
   .
   1. In Nome, inserisci ip-address-shared-vpc.
   2. Per Indirizzo IP statico, fai clic su Fammi scegliere. Per l'IP personalizzato , inserisci 10.1.2.99.
   3. (Facoltativo) Se vuoi condividere questo indirizzo IP con frontend, per impostare Scopo su Condiviso.
8. Fai clic sull'elenco Certificato.
   1. Se disponi già di un SSL autogestito risorsa di certificazione che desideri utilizzare come certificato SSL principale, selezionalo o dal menu Fogli Google.
   2. Altrimenti, seleziona Crea un nuovo certificato.
      1. Inserisci il Nome di l7-ilb-cert.
      2. Nei campi appropriati, carica i file in formato PEM:
         • Certificato di chiave pubblica
         • Catena di certificati
         • Chiave privata
      3. Fai clic su Crea.
9. Per aggiungere risorse di certificato oltre a la risorsa del certificato SSL principale:
   1. Fai clic su Aggiungi certificato.
   2. Seleziona un certificato dall'elenco Certificati oppure fai clic su Crea un nuovo certificato e segui le istruzioni precedenti.
10. Fai clic su Fine.

Rivedi e finalizza la configurazione

• Fai clic su Crea.

gcloud

1. Definisci il controllo di integrità HTTP con gcloud compute health-checks create http .

   gcloud compute health-checks create http l7-ilb-basic-check \
      --region=us-west1 \
      --use-serving-port \
      --project=SERVICE_PROJECT_ID
   

2. Definisci il servizio di backend con il comando gcloud compute backend-services create.

   gcloud compute backend-services create l7-ilb-backend-service \
     --load-balancing-scheme=INTERNAL_MANAGED \
     --protocol=HTTP \
     --health-checks=l7-ilb-basic-check \
     --health-checks-region=us-west1 \
     --region=us-west1 \
     --project=SERVICE_PROJECT_ID
   

3. Aggiungi backend al servizio di backend con il comando gcloud compute backend-services add-backend.

   gcloud compute backend-services add-backend l7-ilb-backend-service \
     --balancing-mode=UTILIZATION \
     --instance-group=l7-ilb-backend-example \
     --instance-group-zone=us-west1-a \
     --region=us-west1 \
     --project=SERVICE_PROJECT_ID
   

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

   gcloud compute url-maps create l7-ilb-map \
     --default-service=l7-ilb-backend-service \
     --region=us-west1 \
     --project=SERVICE_PROJECT_ID
   

5. Crea il proxy di destinazione.

   Per HTTP:

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

   gcloud compute target-http-proxies create l7-ilb-proxy \
     --url-map=l7-ilb-map \
     --url-map-region=us-west1 \
     --region=us-west1 \
     --project=SERVICE_PROJECT_ID
   

   Per HTTPS:

   Per informazioni su come creare risorse dei certificati SSL, vedi Certificati SSL. Gestita da Google I certificati non sono attualmente supportati con i bilanciatori del carico delle applicazioni interni.

   Assegna i percorsi dei file a nomi delle variabili.

   export LB_CERT=path to PEM-formatted file
   

   export LB_PRIVATE_KEY=path to PEM-formatted file
   

   Crea un certificato SSL a livello di regione utilizzando il comando gcloud compute ssl-certificates create.

   gcloud compute ssl-certificates create l7-ilb-cert \
     --certificate=$LB_CERT \
     --private-key=$LB_PRIVATE_KEY \
     --region=us-west1
   

   Utilizza il certificato SSL a livello di regione per creare un proxy di destinazione con gcloud compute target-https-proxies create .

   gcloud compute target-https-proxies create l7-ilb-proxy \
     --url-map=l7-ilb-map \
     --region=us-west1 \
     --ssl-certificates=l7-ilb-cert \
     --project=SERVICE_PROJECT_ID
   

6. Crea la regola di forwarding.

   Per le reti personalizzate, devi fare riferimento alla subnet nella regola di forwarding.

   Per l'indirizzo IP della regola di forwarding, utilizza lb-frontend-and-backend-subnet. Se provi Per utilizzare una subnet solo proxy, la creazione della regola di forwarding non riesce.

   Per HTTP:

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

   gcloud compute forwarding-rules create l7-ilb-forwarding-rule \
     --load-balancing-scheme=INTERNAL_MANAGED \
     --network=projects/HOST_PROJECT_ID/global/networks/lb-network \
     --subnet=projects/HOST_PROJECT_ID/regions/us-west1/subnetworks/lb-frontend-and-backend-subnet \
     --address=IP_ADDRESS_NAME \
     --ports=80 \
     --region=us-west1 \
     --target-http-proxy=l7-ilb-proxy \
     --target-http-proxy-region=us-west1 \
     --project=SERVICE_PROJECT_ID
   

   Per HTTPS:

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

   gcloud compute forwarding-rules create l7-ilb-forwarding-rule \
     --load-balancing-scheme=INTERNAL_MANAGED \
     --network=projects/HOST_PROJECT_ID/global/networks/lb-network \
     --subnet=projects/HOST_PROJECT_ID/regions/us-west1/subnetworks/lb-frontend-and-backend-subnet \
     --address=IP_ADDRESS_NAME \
     --ports=443 \
     --region=us-west1 \
     --target-https-proxy=l7-ilb-proxy \
     --target-https-proxy-region=us-west1 \
     --project=SERVICE_PROJECT_ID
   

Terraform

1. Definisci il controllo di integrità HTTP.

   Per HTTP:

   # health check
   resource "google_compute_health_check" "default" {
     name               = "l7-ilb-basic-check"
     provider           = google-beta
     project            = "my-service-project-id"
     timeout_sec        = 1
     check_interval_sec = 1
     http_health_check {
       port = "80"
     }
   }

   Per HTTPS:

   # health check
   resource "google_compute_health_check" "default" {
     name               = "l7-ilb-basic-check"
     provider           = google-beta
     project            = "my-service-project-id"
     timeout_sec        = 1
     check_interval_sec = 1
     https_health_check {
       port = "443"
     }
   }

2. Definisci il servizio di backend.

   # backend service
   resource "google_compute_region_backend_service" "default" {
     name                  = "l7-ilb-backend-service"
     provider              = google-beta
     project               = "my-service-project-id"
     region                = "us-west1"
     protocol              = "HTTP"
     load_balancing_scheme = "INTERNAL_MANAGED"
     timeout_sec           = 10
     health_checks         = [google_compute_health_check.default.id]
     backend {
       group           = google_compute_instance_group_manager.default.instance_group
       balancing_mode  = "UTILIZATION"
       capacity_scaler = 1.0
     }
   }

3. Crea la mappa URL.

   # URL map
   resource "google_compute_region_url_map" "default" {
     name            = "l7-ilb-map"
     provider        = google-beta
     project         = "my-service-project-id"
     region          = "us-west1"
     default_service = google_compute_region_backend_service.default.id
   }

4. Crea il proxy di destinazione.

   Per HTTP:

   # HTTP target proxy
   resource "google_compute_region_target_http_proxy" "default" {
     name     = "l7-ilb-proxy"
     provider = google-beta
     project  = "my-service-project-id"
     region   = "us-west1"
     url_map  = google_compute_region_url_map.default.id
   }

   Per HTTPS: Crea un certificato SSL a livello di regione

   Per informazioni su come creare risorse dei certificati SSL, vedi Certificati SSL. Gestita da Google I certificati non sono attualmente supportati con i bilanciatori del carico delle applicazioni interni.

   # Use self-signed SSL certificate
   resource "google_compute_region_ssl_certificate" "default" {
     name        = "l7-ilb-cert"
     provider    = google-beta
     project     = "my-service-project-id"
     region      = "us-west1"
     private_key = file("sample-private.key") # path to PEM-formatted file
     certificate = file("sample-server.cert") # path to PEM-formatted file
   }

   Utilizza il certificato SSL a livello di regione per creare un proxy di destinazione

   # HTTPS target proxy
   resource "google_compute_region_target_https_proxy" "default" {
     name             = "l7-ilb-proxy"
     provider         = google-beta
     project          = "my-service-project-id"
     region           = "us-west1"
     url_map          = google_compute_region_url_map.default.id
     ssl_certificates = [google_compute_region_ssl_certificate.default.id]
   }

5. Crea la regola di forwarding.

   Per le reti personalizzate, devi fare riferimento alla subnet nella regola di forwarding.

   Per HTTP:

   # Forwarding rule
   resource "google_compute_forwarding_rule" "default" {
     name                  = "l7-ilb-forwarding-rule"
     provider              = google-beta
     project               = "my-service-project-id"
     region                = "us-west1"
     ip_protocol           = "TCP"
     port_range            = "80"
     load_balancing_scheme = "INTERNAL_MANAGED"
     target                = google_compute_region_target_http_proxy.default.id
     network               = google_compute_network.lb_network.id
     subnetwork            = google_compute_subnetwork.lb_frontend_and_backend_subnet.id
     network_tier          = "PREMIUM"
     depends_on            = [google_compute_subnetwork.lb_frontend_and_backend_subnet]
   }

   Per HTTPS:

   # Forwarding rule
   resource "google_compute_forwarding_rule" "default" {
     name                  = "l7-ilb-forwarding-rule"
     provider              = google-beta
     project               = "my-service-project-id"
     region                = "us-west1"
     ip_protocol           = "TCP"
     port_range            = "443"
     load_balancing_scheme = "INTERNAL_MANAGED"
     target                = google_compute_region_target_https_proxy.default.id
     network               = google_compute_network.lb_network.id
     subnetwork            = google_compute_subnetwork.lb_frontend_and_backend_subnet.id
     network_tier          = "PREMIUM"
     depends_on            = [google_compute_subnetwork.lb_frontend_and_backend_subnet]
   }

Console

1. Nella console Google Cloud, vai alla pagina Istanze VM.

   Vai a Istanze VM

2. Fai clic su Crea istanza.

3. Imposta il Nome su client-vm.

4. Imposta Zone su us-west1-a.

5. Fai clic su Opzioni avanzate, quindi su Networking.

6. Inserisci il seguente valore per Rete tag: allow-ssh,load-balanced-backend.

7. Nella sezione Interfacce di rete, seleziona Reti condivise con me (dal progetto host: HOST_PROJECT_ID).

8. Seleziona la subnet lb-frontend-and-backend-subnet dalla Rete lb-network.

9. Fai clic su Crea.

gcloud

Creare un'istanza VM di test.

gcloud compute instances create client-vm \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --subnet=projects/HOST_PROJECT_ID/regions/us-west1/subnetworks/lb-frontend-and-backend-subnet \
    --zone=us-west1-a \
    --tags=allow-ssh \
    --project=SERVICE_PROJECT_ID

Terraform

Creare un'istanza VM di test.

resource "google_compute_instance" "vm_test" {
  name         = "client-vm"
  provider     = google-beta
  project      = "my-service-project-id"
  zone         = "us-west1-a"
  machine_type = "e2-small"
  tags         = ["allow-ssh"]
  network_interface {
    network    = google_compute_network.lb_network.id
    subnetwork = google_compute_subnetwork.lb_frontend_and_backend_subnet.id
  }
  boot_disk {
    initialize_params {
      image = "debian-cloud/debian-12"
    }
  }
  lifecycle {
    ignore_changes = [
      metadata["ssh-keys"]
    ]
  }
}

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. Inserisci un Nome per il modello di istanza: cross-ref-backend-template.
   3. Assicurati che il disco di avvio sia impostato su un'immagine Debian, ad esempio Debian GNU/Linux 12 (bookworm). Queste istruzioni utilizzano comandi sono disponibili solo su Debian, come apt-get. Se hai bisogno di modificare Su Disco di avvio, fai clic su Cambia.
      1. In Sistema operativo, seleziona Debian.
      2. Per Versione, seleziona una delle immagini Debian disponibili, come come Debian GNU/Linux 12 (bookworm).
      3. Fai clic su Seleziona.
   4. Fai clic su Opzioni avanzate, quindi su Networking.
   5. Inserisci il seguente valore per Rete tag: allow-ssh,load-balanced-backend.
   6. Nella sezione Interfacce di rete, seleziona Reti condivise con me (dal progetto host: HOST_PROJECT_ID).
   7. Seleziona la subnet lb-frontend-and-backend-subnet dalla Rete lb-network.
   8. Fai clic su Gestione. In Gestione, inserisci quanto 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
      

   9. 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. Scegli Nuovo gruppo di istanze gestite (stateless). Per ulteriori informazioni consulta le informazioni sui MIG stateless o stateful.
   3. Inserisci un Nome per il gruppo di istanze: cross-ref-ig-backend.
   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 cross-ref-backend-template.

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

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

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

      Se vuoi, nella sezione Scalabilità automatica della UI puoi configurare il gruppo di istanze per aggiungere o rimuovere automaticamente di Compute Engine in base all'utilizzo della CPU dell'istanza.

   9. Fai clic su Crea.

3. Creare un servizio di backend a livello di regione. In questo passaggio, creare il controllo di integrità e aggiungere backend al servizio di backend. Nella console Google Cloud, vai alla pagina Backend.

   Vai a Backend

   1. Fai clic su Crea servizio di backend a livello di regione.
   2. Inserisci un Nome per il servizio di backend: cross-ref-backend-service.
   3. In Regione, seleziona us-west1.
   4. Per Tipo di bilanciatore del carico, seleziona Bilanciatore del carico delle applicazioni interno regionale (INTERNAL_MANAGED).
   5. Imposta Tipo di backend su Gruppi di istanze.
   6. Nella sezione Backend, imposta Rete su lb-network.
   7. Fai clic su Aggiungi backend e imposta i seguenti campi:
      .
      1. Imposta Gruppo di istanze su cross-ref-ig-backend.
      2. Inserisci Numeri di porta: 80.
      3. Imposta Modalità di bilanciamento su Utilizzo.
      4. Fai clic su Fine.
   8. Nella sezione Controllo di integrità, scegli Crea un controllo di integrità con il seguenti parametri:
      .
      1. Nome: cross-ref-http-health-check
      2. Protocollo: HTTP
      3. Porta: 80
      4. Fai clic su Salva.
   9. Fai clic su Continua.

   10. (Facoltativo) Nella sezione Aggiungi autorizzazioni, inserisci il Entità IAM (in genere un indirizzo email) di Load Amministratori dei bilanciatori di altri progetti in modo che possano utilizzare questo backend per i bilanciatori del carico nei propri progetti. Senza non puoi utilizzare i riferimenti ai servizi tra progetti.

       Se non hai l'autorizzazione per impostare i criteri di controllo dell'accesso per di backend in questo progetto, puoi comunque creare il backend ora e un utente autorizzato potrà eseguire questo passaggio in un secondo momento descritto nella sezione Concedere le autorizzazioni al bilanciatore del carico. Amministratore per l'utilizzo del servizio di backend. Anche quella sezione descrive come concedere l'accesso a tutti i servizi di backend in questo in modo da non dover concedere l'accesso ogni volta che crei un nuovo servizio di backend.

   11. Fai clic su Crea.

gcloud

1. Crea un modello di istanza VM con un server HTTP utilizzando il comando gcloud compute instance-templates create.

   gcloud compute instance-templates create BACKEND_IG_TEMPLATE \
       --region=us-west1 \
       --network=projects/HOST_PROJECT_ID/global/networks/lb-network \
       --subnet=projects/HOST_PROJECT_ID/regions/us-west1/subnetworks/lb-frontend-and-backend-subnet \
       --tags=allow-ssh,load-balanced-backend \
       --image-family=debian-12 \
       --image-project=debian-cloud \
       --metadata=startup-script='#! /bin/bash
       apt-get update
       apt-get install apache2 -y
       a2ensite default-ssl
       a2enmod ssl
       vm_hostname="$(curl -H "Metadata-Flavor:Google" \
       http://metadata.google.internal/computeMetadata/v1/instance/name)"
       echo "Page served from: $vm_hostname" | \
       tee /var/www/html/index.html
       systemctl restart apache2' \
       --project=SERVICE_PROJECT_B_ID
   

   Sostituisci quanto segue:

   • BACKEND_IG_TEMPLATE: il nome del modello di gruppo di istanze.
   • SERVICE_PROJECT_B_ID: l'ID progetto per il progetto di servizio B, in cui i backend del bilanciatore del carico è in corso la creazione del servizio.
   • HOST_PROJECT_ID: l'ID progetto per Progetto host VPC condiviso.

2. Crea un gruppo di istanze gestite nella zona con gcloud compute instance-groups managed create .

   gcloud compute instance-groups managed create BACKEND_MIG \
       --zone=us-west1-a \
       --size=2 \
       --template=BACKEND_IG_TEMPLATE \
       --project=SERVICE_PROJECT_B_ID
   

   Sostituisci quanto segue:

   • BACKEND_MIG: il nome del gruppo di istanza di backend.

3. Definisci il controllo di integrità HTTP con gcloud compute health-checks create http .

   gcloud compute health-checks create http HTTP_HEALTH_CHECK_NAME \
     --region=us-west1 \
     --use-serving-port \
     --project=SERVICE_PROJECT_B_ID
   

   Sostituisci quanto segue:

   • HTTP_HEALTH_CHECK_NAME: il nome del Controllo di integrità HTTP.

4. Definisci il servizio di backend con il comando gcloud compute backend-services create.

   gcloud compute backend-services create BACKEND_SERVICE_NAME \
     --load-balancing-scheme=INTERNAL_MANAGED \
     --protocol=HTTP \
     --health-checks=HTTP_HEALTH_CHECK_NAME \
     --health-checks-region=us-west1 \
     --region=us-west1 \
     --project=SERVICE_PROJECT_B_ID
   

   Sostituisci quanto segue:

   • BACKEND_SERVICE_NAME: il nome del creato nel progetto di servizio B.

5. Aggiungi backend al servizio di backend con gcloud compute backend-services add-backend .

   gcloud compute backend-services add-backend BACKEND_SERVICE_NAME \
     --balancing-mode=UTILIZATION \
     --instance-group=BACKEND_MIG \
     --instance-group-zone=us-west1-a \
     --region=us-west1 \
     --project=SERVICE_PROJECT_B_ID
   

Terraform

1. Creare un modello di istanza.

   # Instance template
   resource "google_compute_instance_template" "default" {
     name     = "l7-ilb-backend-template"
     provider = google-beta
     project  = "my-service-project-b-id"
     region   = "us-west1"
     # For machine type, using small. For more options check https://cloud.google.com/compute/docs/machine-types
     machine_type = "e2-small"
     tags         = ["allow-ssh", "load-balanced-backend"]
     network_interface {
       network    = google_compute_network.lb_network.id
       subnetwork = google_compute_subnetwork.lb_frontend_and_backend_subnet.id
       access_config {
         # add external ip to fetch packages like apache2, ssl
       }
     }
     disk {
       source_image = "debian-cloud/debian-12"
       auto_delete  = true
       boot         = true
     }
   
     # install apache2 and serve a simple web page
     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://metadata.google.internal/computeMetadata/v1/instance/name)"
       sudo echo "Page served from: $vm_hostname" | \
       tee /var/www/html/index.html
       sudo systemctl restart apache2
       EOF
     }
   }

2. Creare un gruppo di istanze gestite.

   Per HTTP

   # MIG
   resource "google_compute_instance_group_manager" "default" {
     name               = "l7-ilb-backend-example"
     provider           = google-beta
     project            = "my-service-project-b-id"
     zone               = "us-west1-a"
     base_instance_name = "vm"
     target_size        = 2
     version {
       instance_template = google_compute_instance_template.default.id
       name              = "primary"
     }
     named_port {
       name = "http"
       port = 80
     }
   }

   Per HTTPS

   # MIG
   resource "google_compute_instance_group_manager" "default" {
     name               = "l7-ilb-backend-example"
     provider           = google-beta
     project            = "my-service-project-b-id"
     zone               = "us-west1-a"
     base_instance_name = "vm"
     target_size        = 2
     version {
       instance_template = google_compute_instance_template.default.id
       name              = "primary"
     }
     named_port {
       name = "https"
       port = 443
     }
   }

3. Creare un controllo di integrità per il backend.

   Per HTTP

   # health check
   resource "google_compute_health_check" "default" {
     name               = "l7-ilb-basic-check"
     provider           = google-beta
     project            = "my-service-project-b-id"
     timeout_sec        = 1
     check_interval_sec = 1
     http_health_check {
       port = "80"
     }
   }

   Per HTTPS

   # health check
   resource "google_compute_health_check" "default" {
     name               = "l7-ilb-basic-check"
     provider           = google-beta
     project            = "my-service-project-b-id"
     timeout_sec        = 1
     check_interval_sec = 1
     https_health_check {
       port = "443"
     }
   }

4. Creare un servizio di backend a livello di regione.

   # backend service
   resource "google_compute_region_backend_service" "default" {
     name                  = "l7-ilb-backend-service"
     provider              = google-beta
     project               = "my-service-project-b-id"
     region                = "us-west1"
     protocol              = "HTTP"
     load_balancing_scheme = "INTERNAL_MANAGED"
     timeout_sec           = 10
     health_checks         = [google_compute_health_check.default.id]
     backend {
       group           = google_compute_instance_group_manager.default.instance_group
       balancing_mode  = "UTILIZATION"
       capacity_scaler = 1.0
     }
   }

Console

Avvia la configurazione

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

   Vai a Bilanciamento del carico

2. Fai clic su Crea bilanciatore del carico.
3. Per Tipo di bilanciatore del carico, seleziona Bilanciatore del carico delle applicazioni (HTTP/HTTPS) e fai clic su Avanti.
4. Per Pubblico o interno, seleziona Interno e fai clic Avanti.
5. Per Deployment tra più regioni o in una singola regione, seleziona Ideale per regionali e fai clic su Avanti.
6. Fai clic su Configura.

Configurazione di base

1. Inserisci un Nome per il bilanciatore del carico.
2. In corrispondenza di Regione, seleziona us-west1.

3. In corrispondenza di Rete, seleziona lb-network (da Progetto: HOST_PROJECT_NAME).

   Se vedi una Subnet solo proxy obbligatoria nella VPC condiviso condivisa avviso, conferma che l'amministratore del progetto host abbia creato proxy-only-subnet nella regione us-west1 in lb-network rete VPC condiviso. Creazione del bilanciatore del carico riuscita anche se non hai l'autorizzazione per visualizzare la subnet solo proxy in questa pagina.

4. Tieni la finestra aperta per continuare.

Configura il backend

1. Fai clic su Configurazione backend.
2. Fai clic su Servizi di backend tra progetti.
3. Per ID progetto, inserisci il progetto ID per il progetto di servizio B.
4. In Nome servizio di backend, inserisci il nome del servizio di backend da il progetto di servizio B che vuoi utilizzare. Per questo esempio, cross-ref-backend-service.
5. Fai clic su Aggiungi servizio di backend.

Configura le regole di routing

• Fai clic su Regole di routing. Assicurati che il servizio cross-ref-backend-service è l'unico servizio di backend per qualsiasi host senza corrispondenza del tuo percorso di apprendimento.

Per informazioni sulla gestione del traffico, consulta Configurazione del traffico. dei modelli.

Configura il frontend

Affinché i riferimenti ai servizi tra progetti funzionino, il frontend deve utilizzare Sulla stessa rete (lb-network) del progetto host del VPC condiviso utilizzato per creare il servizio di backend.

Per HTTP:

1. Fai clic su Configurazione frontend.
2. Inserisci un nome per la regola di forwarding: cross-ref-http-forwarding-rule.
3. Imposta il Protocollo su HTTP.
4. Imposta Subnet su lb-frontend-and-backend-subnet. Non selezionare la subnet solo proxy per il frontend, anche se è un'opzione dell'elenco.
5. Imposta Porta su 80.
6. Fai clic sul menu Indirizzo IP, quindi su Crea indirizzo IP.
7. Nel riquadro Prenota un indirizzo IP interno statico, fornisci il parametro seguenti dettagli:
   .
   1. In Nome, inserisci cross-ref-ip-address.
   2. Per Indirizzo IP statico, fai clic su Fammi scegliere. Per l'IP personalizzato , inserisci 10.1.2.98.
   3. (Facoltativo) Se vuoi condividere questo indirizzo IP con frontend, per impostare Scopo su Condiviso.
8. 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, vedi Certificati SSL. Gestita da Google I certificati non sono attualmente supportati con i bilanciatori del carico delle applicazioni interni.

1. Fai clic su Configurazione frontend.
2. Inserisci un nome per la regola di forwarding: cross-ref-https-forwarding-rule.
3. Nel campo Protocollo, seleziona HTTPS (includes HTTP/2).
4. Imposta Subnet su lb-frontend-and-backend-subnet. Non selezionare la subnet solo proxy per il frontend, anche se è un'opzione dell'elenco.
5. Assicurati che la Porta sia impostata su 443 per consentire il traffico HTTPS.
6. Fai clic sul menu Indirizzo IP, quindi su Crea indirizzo IP.
7. Nel riquadro Prenota un indirizzo IP interno statico, fornisci il parametro seguenti dettagli:
   .
   1. In Nome, inserisci cross-ref-ip-address.
   2. Per Indirizzo IP statico, fai clic su Fammi scegliere. Per l'IP personalizzato , inserisci 10.1.2.98.
   3. (Facoltativo) Se vuoi condividere questo indirizzo IP con frontend, per impostare Scopo su Condiviso.
8. Fai clic sull'elenco Certificato.
   1. Se disponi già di un SSL autogestito risorsa di certificato che desideri utilizzare come certificato SSL principale, selezionalo o dal menu Fogli Google.
   2. Altrimenti, seleziona Crea un nuovo certificato.
      1. Inserisci un nome per il certificato SSL.
      2. Nei campi appropriati, carica i file in formato PEM:
         • Certificato di chiave pubblica
         • Catena di certificati
         • Chiave privata
      3. Fai clic su Crea.
9. Per aggiungere risorse di certificato oltre a la risorsa del certificato SSL principale:
   1. Fai clic su Aggiungi certificato.
   2. Seleziona un certificato dall'elenco Certificati oppure fai clic su Crea un nuovo certificato e segui le istruzioni precedenti.
10. Fai clic su Fine.

Rivedi e finalizza la configurazione

• Fai clic su Crea.

Testa il bilanciatore del carico

Dopo aver creato il bilanciatore del carico, testalo utilizzando i passaggi descritti in Testare il bilanciatore del carico.

gcloud

1. (Facoltativo) Prima di creare un bilanciatore del carico con servizi di backend di riferimenti incrociati, scopri se è possibile fare riferimento ai servizi di backend a cui vuoi fare riferimento utilizzando una mappa URL:

   gcloud compute backend-services list-usable \
       --region=us-west1 \
       --project=SERVICE_PROJECT_B_ID
   

2. Crea la mappa URL e imposta il servizio predefinito sul servizio di backend creato nel progetto di servizio B.

   gcloud compute url-maps create URL_MAP_NAME \
       --default-service=projects/SERVICE_PROJECT_B_ID/regions/us-west1/backendServices/BACKEND_SERVICE_NAME \
       --region=us-west1 \
       --project=SERVICE_PROJECT_A_ID
   

   Sostituisci quanto segue:

   • URL_MAP_NAME: il nome del Mappa URL.
   • BACKEND_SERVICE_NAME: il nome del creato nel progetto di servizio B.
   • SERVICE_PROJECT_B_ID: l'ID progetto per il progetto di servizio B, in cui i backend del bilanciatore del carico viene creato un servizio.
   • SERVICE_PROJECT_A_ID: l'ID progetto per progetto di servizio A, in cui viene creato il frontend del bilanciatore del carico.

   La creazione della mappa URL non riesce se non disponi del compute.backendServices.use per il servizio di backend in progetto di servizio B.

3. Crea il proxy di destinazione.

   Per HTTP:

   gcloud compute target-http-proxies create HTTP_TARGET_PROXY_NAME \
     --url-map=URL_MAP_NAME \
     --url-map-region=us-west1 \
     --region=us-west1 \
     --project=SERVICE_PROJECT_A_ID
   

   Sostituisci quanto segue:

   • HTTP_TARGET_PROXY_NAME: il nome del proxy HTTP di destinazione.

   Per HTTPS:

   Crea un certificato SSL a livello di regione utilizzando il comando gcloud compute ssl-certificates create.

   gcloud compute ssl-certificates create SSL_CERTIFICATE_NAME \
     --certificate=PATH_TO_CERTIFICATE \
     --private-key=PATH_TO_PRIVATE_KEY \
     --region=us-west1 \
     --project=SERVICE_PROJECT_A_ID
   

   Sostituisci quanto segue:

   • SSL_CERTIFICATE_NAME: il nome del Risorsa del certificato SSL.
   • PATH_TO_CERTIFICATE: il percorso File del certificato SSL in formato PEM.
   • PATH_TO_PRIVATE_KEY: il percorso Chiave privata del certificato SSL in formato PEM.

   Utilizza il certificato SSL a livello di regione per creare un proxy di destinazione con gcloud compute target-https-proxies create .

   gcloud compute target-https-proxies create HTTPS_TARGET_PROXY_NAME \
     --url-map=URL_MAP_NAME \
     --region=us-west1 \
     --ssl-certificates=SSL_CERTIFICATE_NAME \
     --project=SERVICE_PROJECT_A_ID
   

   Sostituisci quanto segue:

   • HTTPS_TARGET_PROXY_NAME: il nome del proxy HTTPS di destinazione.

4. Crea la regola di forwarding. Per i servizi tra progetti che fanno riferimento funziona, la regola di forwarding deve utilizzare la stessa rete (lb-network) da il progetto host del VPC condiviso utilizzato per creare il backend completamente gestito di Google Cloud.

   Per HTTP:

   gcloud compute forwarding-rules create HTTP_FORWARDING_RULE_NAME \
     --load-balancing-scheme=INTERNAL_MANAGED \
     --network=projects/HOST_PROJECT_ID/global/networks/lb-network \
     --subnet=projects/HOST_PROJECT_ID/regions/us-west1/subnetworks/lb-frontend-and-backend-subnet \
     --address=IP_ADDRESS_CROSS_REF \
     --ports=80 \
     --region=us-west1 \
     --target-http-proxy=HTTP_TARGET_PROXY_NAME \
     --target-http-proxy-region=us-west1 \
     --project=SERVICE_PROJECT_A_ID
   

   Sostituisci quanto segue:

   • HTTP_FORWARDING_RULE_NAME: il nome del di una regola di forwarding utilizzata per gestire il traffico HTTP.

   Per HTTPS:

   gcloud compute forwarding-rules create HTTPS_FORWARDING_RULE_NAME \
     --load-balancing-scheme=INTERNAL_MANAGED \
     --network=projects/HOST_PROJECT_ID/global/networks/lb-network \
     --subnet=projects/HOST_PROJECT_ID/regions/us-west1/subnetworks/lb-frontend-and-backend-subnet \
     --address=IP_ADDRESS_CROSS_REF \
     --ports=443 \
     --region=us-west1 \
     --target-https-proxy=HTTPS_TARGET_PROXY_NAME \
     --target-https-proxy-region=us-west1 \
     --project=SERVICE_PROJECT_A_ID
   

   Sostituisci quanto segue:

   • HTTPS_FORWARDING_RULE_NAME: il nome del di una regola di forwarding utilizzata per gestire il traffico HTTPS.

5. Per testare il bilanciatore del carico, segui i passaggi descritti in Testare il carico Google Cloud.

Terraform

1. Crea la mappa URL.

   # URL map
   resource "google_compute_region_url_map" "default" {
     name            = "l7-ilb-map"
     provider        = google-beta
     project         = "my-service-project-a-id"
     region          = "us-west1"
     default_service = google_compute_region_backend_service.default.id
   }

2. Crea il proxy di destinazione.

   Per HTTP

   # HTTP target proxy
   resource "google_compute_region_target_http_proxy" "default" {
     name     = "l7-ilb-proxy"
     provider = google-beta
     project  = "my-service-project-a-id"
     region   = "us-west1"
     url_map  = google_compute_region_url_map.default.id
   }

   Per HTTPS

   Crea un certificato SSL a livello di regione

   # Use self-signed SSL certificate
   resource "google_compute_region_ssl_certificate" "default" {
     name        = "l7-ilb-cert"
     provider    = google-beta
     project     = "my-service-project-a-id"
     region      = "us-west1"
     private_key = file("sample-private.key") # path to PEM-formatted file
     certificate = file("sample-server.cert") # path to PEM-formatted file
   }

   Utilizza il certificato SSL a livello di regione per creare un proxy di destinazione

   # HTTPS target proxy
   resource "google_compute_region_target_https_proxy" "default" {
     name             = "l7-ilb-proxy"
     provider         = google-beta
     project          = "my-service-project-a-id"
     region           = "us-west1"
     url_map          = google_compute_region_url_map.default.id
     ssl_certificates = [google_compute_region_ssl_certificate.default.id]
   }

3. Crea la regola di forwarding.

   Per HTTP

   # Forwarding rule
   resource "google_compute_forwarding_rule" "default" {
     name                  = "l7-ilb-forwarding-rule"
     provider              = google-beta
     project               = "my-service-project-a-id"
     region                = "us-west1"
     ip_protocol           = "TCP"
     port_range            = "80"
     load_balancing_scheme = "INTERNAL_MANAGED"
     target                = google_compute_region_target_http_proxy.default.id
     network               = google_compute_network.lb_network.id
     subnetwork            = google_compute_subnetwork.lb_frontend_and_backend_subnet.id
     network_tier          = "PREMIUM"
     depends_on            = [google_compute_subnetwork.lb_frontend_and_backend_subnet]
   }

   Per HTTPS

   # Forwarding rule
   resource "google_compute_forwarding_rule" "default" {
     name                  = "l7-ilb-forwarding-rule"
     provider              = google-beta
     project               = "my-service-project-a-id"
     region                = "us-west1"
     ip_protocol           = "TCP"
     port_range            = "443"
     load_balancing_scheme = "INTERNAL_MANAGED"
     target                = google_compute_region_target_https_proxy.default.id
     network               = google_compute_network.lb_network.id
     subnetwork            = google_compute_subnetwork.lb_frontend_and_backend_subnet.id
     network_tier          = "PREMIUM"
     depends_on            = [google_compute_subnetwork.lb_frontend_and_backend_subnet]
   }

4. Per testare il bilanciatore del carico, segui i passaggi descritti in Testare il carico Google Cloud.

Console

Autorizzazioni a livello di progetto

Per concedere le autorizzazioni a tutti i servizi di backend in: del progetto.

Sono necessari compute.regionBackendServices.setIamPolicy e resourcemanager.projects.setIamPolicy autorizzazioni per completare questo passaggio.

1. Nella console Google Cloud, vai a Bilanciamento del carico condiviso servizi.

   Vai a Bilanciamento del carico condiviso

2. Nella sezione Tutte le autorizzazioni del servizio di backend (a livello di progetto autorizzazioni), seleziona il tuo progetto.

3. Se il riquadro delle autorizzazioni non è visibile, fai clic su Mostra autorizzazioni . A destra si apre il riquadro Autorizzazioni a livello di progetto.

4. Fai clic su person_add Aggiungi entità.

5. In Nuove entità, inserisci l'indirizzo email o un altro tipo identificativo dell'utente.

6. In Ruolo, seleziona Utente dei servizi del bilanciatore del carico Compute Ruolo nell'elenco a discesa.

7. (Facoltativo) Aggiungi una condizione al ruolo.

8. Fai clic su Salva.

Autorizzazioni a livello di risorsa per singoli servizi di backend

Per concedere le autorizzazioni al singolo backend, segui questi passaggi dei servizi nel tuo progetto.

Devi disporre dell'autorizzazione compute.regionBackendServices.setIamPolicy per completa questo passaggio.

1. Nella console Google Cloud, vai a Bilanciamento del carico condiviso servizi.

   Vai a Bilanciamento del carico condiviso

2. Nella sezione Autorizzazioni per i singoli servizio di backend (a livello di risorsa) autorizzazioni), seleziona il servizio di backend che vuoi concedere a cui accedono.

3. Fai clic su person_add Aggiungi entità.

4. In Nuove entità, inserisci l'indirizzo email o un altro tipo identificativo dell'utente.

5. In Ruolo, seleziona Utente dei servizi del bilanciatore del carico Compute Ruolo nell'elenco a discesa.

6. Fai clic su Salva.

gcloud

Autorizzazioni a livello di progetto

Per concedere le autorizzazioni a tutti i servizi di backend in: del progetto.

Sono necessari compute.regionBackendServices.setIamPolicy e resourcemanager.projects.setIamPolicy autorizzazioni per completare questo passaggio.

gcloud projects add-iam-policy-binding SERVICE_PROJECT_B_ID \
    --member="user:LOAD_BALANCER_ADMIN" \
    --role="roles/compute.loadBalancerServiceUser"

Autorizzazioni a livello di risorsa per singoli servizi di backend

A livello di servizio di backend, gli amministratori dei progetti di servizio possono utilizzare uno dei due seguenti comandi per concedere il ruolo Utente dei servizi del bilanciatore del carico Compute (roles/compute.loadBalancerServiceUser).

Devi disporre dell'autorizzazione compute.regionBackendServices.setIamPolicy per completa questo passaggio.

gcloud projects add-iam-policy-binding SERVICE_PROJECT_B_ID \
    --member="user:LOAD_BALANCER_ADMIN" \
    --role="roles/compute.loadBalancerServiceUser" \
    --condition='expression=resource.name=="projects/SERVICE_PROJECT_B_ID/regions/us-west1/backend-services/BACKEND_SERVICE_NAME",title=Shared VPC condition'

o

gcloud compute backend-services add-iam-policy-binding BACKEND_SERVICE_NAME \
    --member="user:LOAD_BALANCER_ADMIN" \
    --role="roles/compute.loadBalancerServiceUser" \
    --project=SERVICE_PROJECT_B_ID \
    --region=us-west1

Per utilizzare questi comandi, sostituisci LOAD_BALANCER_ADMIN con il principal dell'utente, per esempio, test-user@gmail.com.

Puoi anche configurare le autorizzazioni IAM in modo che vengano applicate solo a un sottoinsieme di servizi di backend regionali mediante condizioni specificando gli attributi della condizione.

gcloud

Per vedere le risorse che fanno riferimento a servizio di backend del VPC condiviso regionale, esegui questo comando:

gcloud compute backend-services describe BACKEND_SERVICE_NAME \
    --region REGION

Sostituisci quanto segue:

• BACKEND_SERVICE_NAME: il nome del caricamento servizio di backend del bilanciatore
• REGION: la regione del bilanciatore del carico

Nell'output comando, esamina il campo usedBy, che mostra la che fanno riferimento al servizio di backend, come illustrato esempio:

id: '123456789'
kind: compute#backendService
loadBalancingScheme: INTERNAL_MANAGED
...
usedBy:
-   reference: https://www.googleapis.com/compute/v1/projects/my-project/region/us-central1/urlMaps/my-url-map