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

Questo documento mostra due configurazioni di esempio per la configurazione di un bilanciatore del carico delle applicazioni interno in un ambiente VPC condiviso:

  • Il primo esempio crea tutti i componenti e i backend del bilanciatore del carico in un progetto di servizio.
  • Il secondo esempio crea la mappa URL e i componenti frontend del bilanciatore del carico in un progetto di servizio, mentre il servizio di backend vengono creati in un progetto di servizio diverso. Questo tipo di implementazione, in cui la mappa URL fa riferimento a un servizio di backend in un altro progetto, è chiamato Riferimento a servizi tra progetti.

Entrambi gli esempi richiedono la stessa configurazione iniziale per concedere autorizzazioni e configurano VPC condiviso prima di poter iniziare a creare il carico bilanciatori del carico e bilanciatori del carico.

Queste non sono le uniche configurazioni del VPC condiviso supportate dei bilanciatori del carico delle applicazioni interni. Per altre architetture VPC condivise valide, consulta Architetture VPC condivise.

Se non vuoi utilizzare una rete VPC condivisa, consulta Configurare un bilanciatore del carico delle applicazioni interno.

Prima di iniziare

  1. Leggi la panoramica sulla rete VPC condivisa.
  2. Leggi la panoramica del bilanciatore del carico delle applicazioni interno, inclusa la sezione Architetture VPC condivise.

Autorizzazioni obbligatorie

La configurazione di un bilanciatore del carico in una rete VPC condivisa richiede alcune operazioni di configurazione e provisioning iniziali da parte di un amministratore. Dopo la configurazione iniziale, del progetto di servizio può eseguire una delle seguenti operazioni:

  • Esegui il deployment di tutti i componenti e dei backend del bilanciatore del carico in un progetto di servizio.
  • Esegui il deployment dei componenti di backend del bilanciatore del carico (servizio di backend e backend) in progetti di servizio a cui è possibile fare riferimento da una mappa URL in un altro servizio o progetto host.

Questa sezione riassume le autorizzazioni necessarie per seguire la guida per configurare un bilanciatore del carico su una rete VPC condiviso.

Configura rete VPC condivisa

I ruoli seguenti sono obbligatori per le attività seguenti:

  1. Eseguire attività amministrative una tantum come l'impostazione VPC condiviso e abilitazione di un progetto host.
  2. Esegui attività amministrative che devono essere ripetute ogni volta che vuoi inizializzare un nuovo progetto di servizio. Sono inclusi il collegamento del progetto di servizio, il provisioning e la configurazione delle risorse di rete e la concessione dell'accesso all'amministratore del progetto di servizio.

Queste attività devono essere eseguite nel progetto host VPC condiviso. Me consiglia all'Amministratore del VPC condiviso di essere anche il proprietario Progetto host VPC condiviso. In questo modo vengono concessi automaticamente i ruoli Network Admin e Security Admin.

Attività Ruolo richiesto
Configura un VPC condiviso, abilita il progetto host e concedi l'accesso a amministratori progetti di servizio Amministratore VPC condiviso
Crea subnet nel progetto host VPC condiviso e concedi l'accesso agli amministratori dei progetti di servizio Amministratore di rete
Aggiungi e rimuovi regole firewall Amministratore sicurezza

Una volta eseguito il provisioning delle subnet, il proprietario del progetto host deve concedere Ruolo Utente di rete nel progetto host per chiunque (in genere il progetto di servizio amministratori, sviluppatori o account di servizio) che devono utilizzare questi Google Cloud.

Attività Ruolo richiesto
Utilizza le reti e le subnet VPC appartenenti al progetto host Utente di rete

Questo ruolo può essere concesso a livello di progetto o per singole subnet. Ti consigliamo di concedere il ruolo alle singole subnet. La concessione del ruolo in il progetto dà accesso a tutte le subnet attuali e future nel rete VPC del progetto host.

Esegui il deployment del bilanciatore del carico e dei backend

Gli amministratori del progetto di servizio devono avere i seguenti ruoli nel progetto di servizio per creare risorse e backend di bilanciamento del carico. Queste autorizzazioni vengono concesse automaticamente al proprietario o all'editor del progetto di servizio.

Ruoli concessi nel progetto di servizio
Attività Ruolo richiesto
Crea componenti del bilanciatore del carico Amministratore rete
Creazione delle istanze Amministratore istanza
Creare e modificare i certificati SSL Amministratore sicurezza

Prerequisiti

In questa sezione, devi eseguire i seguenti passaggi:

  1. Configura la rete e le subnet nel progetto host.
  2. Configura la VPC condivisa nel progetto host.

I passaggi descritti in questa sezione non devono essere eseguiti ogni volta che vuoi creare un nuovo bilanciatore del carico. Tuttavia, prima di procedere con la creazione del bilanciatore del carico, devi assicurarti di avere accesso alle risorse descritte qui.

Configura la rete e le subnet nel progetto host

È necessaria una rete VPC condiviso con due subnet: una per il frontend e i backend del bilanciatore del carico e una per i proxy del bilanciatore del carico.

Questo esempio utilizza le reti, la regione e le subnet seguenti:

  • Rete. La rete è denominata lb-network.

  • Subnet per il frontend e i backend del bilanciatore del carico. Una subnet chiamata lb-frontend-and-backend-subnet nella regione us-west1 utilizza 10.1.2.0/24 per il suo intervallo IP principale.

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

Configura la subnet per il frontend e i backend del bilanciatore del carico

Non è necessario eseguire questo passaggio ogni volta che vuoi creare un nuovo con il bilanciatore del carico di rete passthrough esterno regionale. Devi solo assicurarti che il progetto di servizio abbia accesso a una subnet nella rete VPC condivisa (oltre alla subnet solo proxy).

Tutti i passaggi di questa sezione devono essere eseguiti nel progetto host.

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:

    1. Imposta Modalità di creazione subnet su Personalizzata.

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

      • 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
}

Configura la subnet solo proxy

La subnet solo proxy viene utilizzata da tutti i bilanciatori del carico basati su Envoy a livello di regione nella regione us-west1, nella rete VPC lb-network. Può esserci un solo una subnet solo proxy attiva per regione, per rete.

Non eseguire questo passaggio se nella regione us-west1 di questa rete è già presente una subnet solo proxy riservata.

Tutti i passaggi in questa sezione devono essere eseguiti nel progetto host.

Console

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

    Vai alle reti VPC

  2. Fai clic sul nome della rete VPC condivisa: 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

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
}

Concede agli amministratori del progetto di servizio l'accesso alla subnet di backend

Gli amministratori dei progetti di servizio richiedono l'accesso alla subnet lb-frontend-and-backend-subnet per poter eseguire il provisioning dei backend del bilanciatore del carico.

Un amministratore della rete VPC condivisa deve concedere l'accesso alla subnet di backend del servizio amministratori di progetto (o sviluppatori che eseguono il deployment di risorse e backend che utilizzano la subnet). Per istruzioni, vedi Amministratori progetti di servizio per alcune subnet.

Configura le regole firewall nel progetto host

In questo esempio vengono utilizzate le seguenti regole firewall:
  • fw-allow-health-check. Una regola in entrata, applicabile alle istanze con bilanciamento del carico, che consente tutto il traffico TCP da Google Cloud sistemi di controllo dell'integrità in 130.211.0.0/22 e 35.191.0.0/16. Questo esempio utilizza il tag di destinazione load-balanced-backend per identificare le istanze a cui deve essere applicato.
  • fw-allow-proxies. Una regola in entrata, applicabile alle istanze che vengono con bilanciamento del carico, che consente il traffico TCP sulle porte 80, 443 e 8080 da dai proxy gestiti del bilanciatore del carico. Questo esempio utilizza il tag target load-balanced-backend per identificare le istanze a cui deve essere applicato.
  • fw-allow-ssh. Una regola in entrata, applicabile alle istanze sottoposte a bilanciamento del carico, che consente la connettività SSH in entrata sulla porta TCP 22 da qualsiasi indirizzo. Puoi scegliere un intervallo IP di origine più restrittivo personalizzata. Ad esempio, puoi specificare solo gli intervalli IP del sistema da cui avvii le sessioni SSH. Questo esempio utilizza il target Tag allow-ssh per identificare le macchine virtuali (VM) a cui si applica una regola firewall.
Senza queste regole firewall, lo stato di rifiuto predefinito La regola in entrata blocca i blocchi in entrata alle istanze di backend.

Tutti i passaggi di questa sezione devono essere eseguiti nel progetto host.

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 solo ai protocolli e alle porte corrispondenti a quelli utilizzati dal controllo di integrità. Se utilizzi tcp:80 per il protocollo e la porta, Google Cloud può utilizzare HTTP sulla porta 80 per contattare le tue VM, ma non può utilizzare HTTPS sulla porta 443 per contattarle.

  3. Fai clic su Crea.
  4. Fai clic su Crea regola firewall per creare la regola per consentire i 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 per consentire i 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 più ristretto di porte per soddisfare le tue esigenze.

    gcloud compute firewall-rules create fw-allow-health-check \
   --network=lb-network \
   --action=allow \
   --direction=ingress \
   --source-ranges=130.211.0.0/22,35.191.0.0/16 \
   --target-tags=load-balanced-backend \
   --rules=tcp

  2. Crea la regola firewall fw-allow-proxies per consentire al traffico proveniente dalla subnet solo proxy di Envoy di 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 la connettività SSH alle VM con il tag di rete allow-ssh. Se ometti source-ranges, Google Cloud interpreta la regola come qualsiasi origine.

    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 al traffico proveniente dalla subnet solo proxy di Envoy di 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"]
}

Configura la VPC condivisa nel progetto host

Questo passaggio implica l'abilitazione di un progetto host del VPC condiviso, condividendo le subnet il progetto host e il collegamento dei progetti di servizio al progetto host, i progetti di servizio possono usare la rete VPC condiviso. Per configurare la VPC condivisa nel progetto host, consulta le seguenti pagine:

Il resto di queste istruzioni presuppone che tu abbia già configurato il VPC condiviso. Ciò include la configurazione dei criteri IAM per organizzazione e designare dei progetti host e di servizio.

Non procedere finché non hai configurato il VPC condiviso e abilitato i progetti host e di servizio.

Dopo aver completato i passaggi definiti in questa sezione sui prerequisiti, puoi procedere con una delle seguenti configurazioni:

Configura un bilanciatore del carico nel progetto di servizio

Questo esempio crea un bilanciatore del carico delle applicazioni interno in cui tutti i componenti di bilanciamento del carico (regola di inoltro, proxy di destinazione, mappa URL e servizio di backend) e i backend vengono creati nel progetto di servizio.

Le risorse di rete dell'Application Load Balancer interno, come la subnet solo proxy e la subnet per le istanze di backend, vengono create nel progetto host. La le regole firewall per le istanze di backend vengono create anche nel progetto host.

Figura 1. Bilanciatore del carico delle applicazioni interno su VPC condiviso
Figura 1. Bilanciatore del carico delle applicazioni interno su VPC condiviso

Questa sezione mostra come configurare il bilanciatore del carico e i backend. Questi passaggi deve essere eseguita dall'amministratore del progetto di servizio (o da uno sviluppatore operare all'interno del progetto di servizio) e non richiedono l'intervento del amministratore del progetto host. I passaggi di questa sezione sono molto simili a i passaggi standard per l'impostazione del carico delle applicazioni interno.

L'esempio in questa pagina imposta esplicitamente un indirizzo IP interno riservato per la regola di forwarding del bilanciatore del carico delle applicazioni interno, anziché consentire un indirizzo IP interno temporaneo da allocare. Come best practice, ti consigliamo di prenotare gli indirizzi IP per le regole di inoltro.

Crea il backend del gruppo di istanze gestite

Questa sezione mostra come creare un modello e un gruppo di istanze gestite. La un gruppo di istanze gestite fornisce istanze VM che eseguono i server di backend di un un bilanciatore del carico delle applicazioni interno di esempio. Il traffico dai client viene bilanciato verso dai server di backend. A scopo dimostrativo, i backend gestiscono i propri nomi host.

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 e poi 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 Gruppi di istanze gestite stateless o stateful.
    3. In Nome, inserisci l7-ilb-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-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:

      • Per la 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 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 con il comando 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 il comando 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. Crea 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
  }
}

Configura il bilanciatore del carico

Questa sezione mostra come creare le risorse interne del bilanciatore del carico delle applicazioni:

  • Controllo di integrità HTTP
  • Servizio di backend con un gruppo di istanze gestite come backend
  • Una mappa URL
  • Certificato SSL (richiesto solo per HTTPS)
  • Proxy di destinazione
  • Regola di forwarding

Disponibilità proxy

A seconda del numero di progetti di servizio che utilizzano la stessa rete VPC condivisa, potresti raggiungere quote o limiti più rapidamente rispetto al modello di deployment della rete in cui ogni progetto Google Cloud ospita la propria rete.

Ad esempio, a volte le regioni di Google Cloud non dispongono di proxy sufficienti per un nuovo bilanciatore del carico delle applicazioni interno. In questo caso, la console Google Cloud fornisce un messaggio di avviso sulla disponibilità del proxy durante la creazione del bilanciatore del carico. Per risolvere il problema, puoi procedere in uno dei seguenti modi:

  • Attendi che il problema di capacità venga risolto.

  • Contatta il team di vendita Google Cloud per aumentare questi limiti.

Console

Passare al contesto del 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 finestra Seleziona da visualizzata, seleziona il progetto di servizio 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. 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 Interno e fai clic su 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. Per Regione, seleziona us-west1.

  3. Per Rete, seleziona lb-network (da Progetto: HOST_PROJECT_ID).

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

  4. Tieni aperta la finestra per continuare.

Configura il backend

  1. Fai clic su Configurazione backend.
  2. Nel 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 i 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 sia l'unico servizio di backend per qualsiasi host e percorso senza corrispondenza.

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 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 e poi su Crea indirizzo IP.
  7. Nel riquadro Prenota un indirizzo IP interno statico, fornisci i seguenti dettagli:
    1. In Nome, inserisci ip-address-shared-vpc.
    2. Per Indirizzo IP statico, fai clic su Fammi scegliere. In Indirizzo IP personalizzato, inserisci 10.1.2.99.
    3. (Facoltativo) Se vuoi condividere questo indirizzo IP con diversi frontend, imposta Finalità su Condiviso.
  8. Fai clic su Fine.

Per HTTPS:

Se utilizzi HTTPS tra il client e il bilanciatore del carico, hai bisogno di 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 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 i seguenti dettagli:
    1. In Nome, inserisci ip-address-shared-vpc.
    2. Per Indirizzo IP statico, fai clic su Fammi scegliere. In Indirizzo IP personalizzato, inserisci 10.1.2.99.
    3. (Facoltativo) Se vuoi condividere questo indirizzo IP con diversi frontend, imposta Finalità su Condiviso.
  8. Fai clic sull'elenco Certificato.
    1. Se hai già una risorsa del certificato SSL con gestione indipendente che vuoi utilizzare come certificato SSL principale, selezionala dal menu.
    2. In caso contrario, 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 o 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 il comando 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. I certificati gestiti da Google 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 inoltro.

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

Testa il bilanciatore del carico

Per testare il bilanciatore del carico, crea prima una VM client di esempio. Quindi stabilisci un una sessione SSH con la VM e inviare il traffico da questa VM al bilanciatore del carico.

Crea un'istanza VM di test

I client possono trovarsi nel progetto host o in qualsiasi servizio connesso progetto. In questo esempio, verifichi il funzionamento del bilanciatore del carico eseguendo il deployment di una VM client in un progetto di servizio. Il client deve utilizzare lo stesso Rete VPC condiviso e trovarsi nella stessa regione del bilanciatore del carico.

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

Invia traffico al bilanciatore del carico

Utilizza SSH per connetterti all'istanza appena creata e verifica che i servizi HTTP(S) sui backend siano raggiungibili tramite l'indirizzo IP della regola di inoltro del bilanciatore del carico delle applicazioni interno e che il traffico venga bilanciato sulle istanze di backend.

  1. Connettiti all'istanza client con SSH.

    gcloud compute ssh client-vm \
   --zone=us-west1-a

  2. Verifica che l'indirizzo IP stia pubblicando il nome host. Sostituisci LB_IP_ADDRESS con l'indirizzo IP del bilanciatore del carico.

    curl LB_IP_ADDRESS

    Per i test HTTPS, sostituisci curl con quanto segue:

    curl -k -s 'https://LB_IP_ADDRESS:443'

    Il flag -k fa sì che curl salti la convalida del certificato.

Configura un bilanciatore del carico con un servizio di backend tra progetti

L'esempio precedente in questa pagina mostra come configurare un deployment VPC condiviso in cui tutti i componenti del bilanciatore del carico e i relativi backend vengono creati nel progetto di servizio.

I bilanciatori del carico delle applicazioni interni consentono anche di configurare un VPC condiviso deployment in cui una mappa URL in un progetto host o di servizio può fare riferimento al backend (e backend) situati in più progetti di servizio in Ambienti VPC condivisi. Questo sistema è noto come riferimento ai servizi tra progetti.

Puoi usare i passaggi di questa sezione come riferimento per configurare le combinazioni supportate elencate qui:

  • Regola di forwarding, proxy di destinazione e mappa di URL nel progetto host e nel backend in un progetto di servizio
  • Regola di forwarding, proxy di destinazione e mappa di URL in un progetto di servizio e servizio di backend in un altro progetto di servizio

I riferimenti ai servizi tra progetti possono essere utilizzati con gruppi di istanze, serverless NEG o qualsiasi altro tipo di backend supportato. Se utilizzi NEG serverless, devi creare una VM nella rete VPC in cui intendi creare il frontend del bilanciatore del carico. Per un esempio, vedi Crea un'istanza VM in una subnet specifica in Configurare un bilanciatore del carico delle applicazioni interno con Cloud Run.

Requisiti di configurazione

Questo esempio configura un bilanciatore del carico di esempio con frontend e backend in due diversi progetti di servizio.

Se non l'hai già fatto, devi completare tutti i passaggi preliminari per configurare la VPC condivisa e la rete, le subnet e le regole firewall richieste per questo esempio. Per le istruzioni, consulta quanto segue:

Figura 2. Frontend e backend del bilanciatore del carico in progetti di servizi diversi
Figura 2. Frontend e backend del bilanciatore del carico in progetti di servizio diversi

Crea i backend e il servizio di backend nel progetto di servizio B

Tutti i passaggi in questa sezione devono essere eseguiti nel progetto di servizio B.

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 devi modificare il 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 e poi 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. Per Gestione, inserisci il seguente script 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 maggiori informazioni consulta le informazioni sui MIG stateless o stateful.
    3. Inserisci un Nome per il gruppo di istanze: cross-ref-ig-backend.
    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 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:

      • Per la 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 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. Crea un servizio di backend regionale. 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 disponi dell'autorizzazione per impostare i criteri di controllo dell'accesso per i servizi di backend in questo progetto, puoi comunque creare il servizio di backend ora e un utente autorizzato può eseguire questo passaggio in un secondo momento come descritto nella sezione Concedere all'amministratore del bilanciatore del carico le autorizzazioni per utilizzare il servizio di backend. In questa sezione viene inoltre descritto come concedere l'accesso a tutti i servizi di backend di questo progetto, 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 con 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 del progetto di servizio B, in cui vengono creati i backend del bilanciatore del carico e il servizio di backend.
    • HOST_PROJECT_ID: l'ID progetto per Progetto host VPC condiviso.

  2. Crea un gruppo di istanze gestite nella zona con il comando 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 istanze 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. Crea 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
  }
}

Crea il frontend del bilanciatore del carico e la mappa URL nel progetto di servizio A

Tutti i passaggi in questa sezione devono essere eseguiti nel progetto di servizio A.

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 Interno e fai clic su 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 viene visualizzato l'avviso La subnet solo proxy è obbligatoria nella rete VPC condiviso, verifica che l'amministratore del progetto host abbia creato proxy-only-subnet nella regione us-west1 nella rete VPC condivisa lb-network. La creazione del bilanciatore del carico va a buon fine anche se non disponi dell'autorizzazione per visualizzare la subnet solo proxy in questa pagina.

  4. Tieni aperta la finestra per continuare.

Configura il backend

  1. Fai clic su Configurazione backend.
  2. Fai clic su Servizi di backend tra progetti.
  3. In ID progetto, inserisci l'ID progetto per il progetto di servizio B.
  4. Dall'elenco Seleziona i servizi di backend, seleziona i servizi di backend del progetto di servizi B che vuoi utilizzare. Per questo esempio, inserisci cross-ref-backend-service.
  5. Fai clic su OK.

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, vedi Configurare la gestione del traffico.

Configura il frontend

Affinché il riferimento ai servizi tra progetti funzioni, il frontend deve utilizzare la stessa rete (lb-network) del progetto host VPC condiviso utilizzata per creare il servizio di backend.

Per HTTP:

  1. Fai clic su Configurazione frontend.
  2. Inserisci un nome per la regola di inoltro: 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 e poi su Crea indirizzo IP.
  7. Nel riquadro Prenota un indirizzo IP interno statico, fornisci i seguenti dettagli:
    1. In Nome, inserisci cross-ref-ip-address.
    2. Per Indirizzo IP statico, fai clic su Fammi scegliere. In Indirizzo IP personalizzato, inserisci 10.1.2.98.
    3. (Facoltativo) Se vuoi condividere questo indirizzo IP con diversi frontend, imposta Finalità su Condiviso.
  8. Fai clic su Fine.

Per HTTPS:

Se utilizzi HTTPS tra il client e il bilanciatore del carico, hai bisogno di 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 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 i seguenti dettagli:
    1. In Nome, inserisci cross-ref-ip-address.
    2. Per Indirizzo IP statico, fai clic su Fammi scegliere. In Indirizzo 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 dalla 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 o 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 seguendo i passaggi descritti in Testare il bilanciatore del carico.

gcloud

  1. (Facoltativo) Prima di creare un bilanciatore del carico con servizi di backend con 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 servizi 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 della mappa URL.
    • BACKEND_SERVICE_NAME: il nome del servizio di backend creato nel progetto di servizi 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 il 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 del file del certificato SSL locale 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 il comando 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 inoltro. 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 della regola di inoltro 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 della regola di inoltro 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.

Concedi all'amministratore del bilanciatore del carico le autorizzazioni per utilizzare il servizio di backend

Se vuoi che i bilanciatori del carico facciano riferimento ai servizi di backend in un altro servizio progetti, l'amministratore del bilanciatore del carico deve avere compute.backendServices.use autorizzazione. Per concedere questa autorizzazione, puoi utilizzare il ruolo IAM predefinito chiamato Utente dei servizi bilanciatore del carico Compute (roles/compute.loadBalancerServiceUser). Questo ruolo deve essere concesso dall'amministratore del progetto di servizio e può essere applicato a livello di progetto o a livello di singolo servizio di backend.

Questo passaggio non è obbligatorio se hai già concesso le autorizzazioni richieste a livello di servizio di backend durante la creazione del backend . Puoi saltare questa sezione o continuare a leggere per scoprire come concedere l'accesso a tutti i servizi di backend in questo progetto in modo da non dover concedere l'accesso ogni volta che crei un nuovo servizio di backend.

In questo esempio, un amministratore del progetto di servizio del progetto di servizio B deve eseguire uno uno dei seguenti comandi per concedere l'autorizzazione compute.backendServices.use a un amministratore del bilanciatore del carico dal progetto di servizio A. Questa operazione può essere eseguita in a livello di progetto (per tutti i servizi di backend nel progetto) o per servizio di backend.

Console

Autorizzazioni a livello di progetto

Per concedere le autorizzazioni a tutti i servizi di backend nel tuo progetto:

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

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

    Vai a IAM

  2. Seleziona il progetto.

  3. Fai clic su Concedi accesso.

  4. Nel campo Nuovi amministratori, inserisci l'indirizzo email dell'amministratore o un altro identificatore.

  5. Nell'elenco Seleziona un ruolo, seleziona Utente servizi bilanciatori del carico Compute.

  6. (Facoltativo) Aggiungi una condizione al ruolo.

  7. Fai clic su Salva.

Autorizzazioni a livello di risorsa per i singoli servizi di backend

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

Per completare questo passaggio, devi disporre dell'autorizzazione compute.regionBackendServices.setIamPolicy.

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

    Vai a Backend

  2. Dall'elenco dei backend, seleziona il servizio di backend che vuoi concedere l'accesso e fare clic su Autorizzazioni.

  3. Fai clic su Aggiungi entità.

  4. Nel campo Nuove entità, inserisci l'indirizzo email dell'entità oppure da un altro identificatore.

  5. Nell'elenco Seleziona un ruolo, seleziona il Bilanciatore del carico Compute Utente dei servizi.

  6. Fai clic su Salva.

gcloud

Autorizzazioni a livello di progetto

Per concedere le autorizzazioni a tutti i servizi di backend nel tuo progetto:

Per completare questo passaggio, sono necessarie le autorizzazioni compute.regionBackendServices.setIamPolicy e resourcemanager.projects.setIamPolicy. 

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

Per completare questo passaggio, devi disporre dell'autorizzazione compute.regionBackendServices.setIamPolicy. 

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.

Per vedere le mappe di URL che fanno riferimento a un particolare servizio di backend del VPC condiviso, segui questi passaggi:

gcloud

Per visualizzare le risorse che fanno riferimento a un servizio di backend del VPC condiviso regionale, esegui il seguente comando:

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

Sostituisci quanto segue:

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

Nell'output del comando, esamina il campo usedBy, che mostra le risorse che fanno riferimento al servizio di backend, come mostrato nell'esempio seguente:

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

Passaggi successivi