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

Questo documento fornisce istruzioni per configurare un bilanciatore del carico delle applicazioni interno regionale per i servizi in esecuzione sulle VM di Compute Engine.

Per configurare il bilanciamento del carico per i servizi in esecuzione nei pod Google Kubernetes Engine (GKE), consulta Bilanciamento del carico nativo dei container con NEG autonomi e la sezione Collegare un bilanciatore del carico delle applicazioni interno regionale ai NEG autonomi.

Per configurare il bilanciamento del carico per accedere alle API e ai servizi Google utilizzando Private Service Connect, consulta Configurazione di Private Service Connect con i controlli di servizio HTTP(S) consumer.

La configurazione dei bilanciatori del carico delle applicazioni interni è composta da due parti:

• Esegui le attività preliminari, ad esempio assicurati che gli account richiesti dispongano delle autorizzazioni corrette e prepara la rete Virtual Private Cloud (VPC).
• Configura le risorse del bilanciatore del carico.

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

• Panoramica del bilanciatore del carico delle applicazioni interno, inclusa la sezione Limitazioni
• Panoramica delle regole firewall VPC

Autorizzazioni

Per seguire questa guida, devi essere in grado di creare istanze e modificare una rete in un progetto. Devi essere un proprietario o un editor del progetto oppure devi disporre di tutti i seguenti ruoli IAM di Compute Engine.

Attività	Ruolo richiesto
Crea reti, subnet e componenti del bilanciatore del carico	Amministratore rete Compute
Aggiungere e rimuovere regole firewall	Amministratore sicurezza Compute
Creazione delle istanze	Amministratore istanze Compute

Per ulteriori informazioni, consulta le seguenti guide:

• Controllo dell'accesso
• Condizioni IAM

Panoramica della configurazione

Puoi configurare un bilanciatore del carico delle applicazioni interno come descritto nel seguente flusso di configurazione di alto livello. I passaggi numerati si riferiscono ai numeri nel diagramma.

Componenti numerati del bilanciatore del carico delle applicazioni interno (fai clic per ingrandire).

Come mostrato nel diagramma, questo esempio crea un bilanciatore del carico delle applicazioni interno in una rete VPC nella regione us-west1, con un servizio di backend e due gruppi di backend.

Il diagramma mostra quanto segue:

1. Una rete VPC con due subnet:

   1. Una subnet viene utilizzata per i backend (gruppi di istanze) e la regola di forwarding. Il suo intervallo di indirizzi IP principale è 10.1.2.0/24.

   2. Una subnet è una subnet solo proxy nella regione us-west1. Devi creare una subnet solo proxy in ogni regione di una rete VPC in cui utilizzi bilanciatori del carico delle applicazioni interni. La subnet solo proxy della regione è condivisa tra tutti i bilanciatori del carico delle applicazioni interni della regione. Gli indirizzi di origine dei pacchetti inviati dal bilanciatore del carico delle applicazioni interno ai backend del tuo servizio vengono allocati dalla subnet solo proxy. In questo esempio, la subnet solo proxy per la regione ha un intervallo di indirizzi IP principale di 10.129.0.0/23, che è la dimensione consigliata della subnet. Per ulteriori informazioni, consulta Subnet solo proxy.

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

3. Istanze VM di Compute Engine di backend.

4. Gruppi di istanze gestite o non gestite per i deployment di VM Compute Engine.

   In ogni zona puoi avere una combinazione di tipi di gruppi di backend in base ai requisiti di implementazione.

   Nota: questa configurazione mostra come bilanciare le richieste solo per i backend dei gruppi di istanze VM. Per scoprire come bilanciare le richieste ai pod GKE, consulta GKE Ingress per il bilanciamento del carico HTTP(S).

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

6. Un servizio di backend regionale che monitora l'utilizzo e l'integrità dei backend.

7. Una mappa URL a livello di regione che analizza l'URL di una richiesta e inoltra le richieste a servizi di backend specifici in base all'host e al percorso dell'URL della richiesta.

8. Un proxy HTTP o HTTPS di destinazione regionale, che riceve una richiesta dall'utente e la inoltra alla mappa URL. Per HTTPS, configura una risorsa del certificato SSL regionale. Il proxy di destinazione utilizza il certificato SSL per decriptare il traffico SSL se configuri il bilanciamento del carico HTTPS. Il proxy di destinazione può inoltrare il traffico alle tue istanze utilizzando HTTP o HTTPS.

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

   L'indirizzo IP interno associato alla regola di forwarding può provenire da qualsiasi subnet nella stessa rete e nella stessa regione. Tieni presente le seguenti condizioni:

   • L'indirizzo IP può (ma non deve) provenire dalla stessa subnet dei gruppi di istanza di backend.
   • L'indirizzo IP non deve provenire da una subnet solo proxy riservata con il flag --purpose impostato su REGIONAL_MANAGED_PROXY.
   • Se vuoi condividere l'indirizzo IP interno con più regole di inoltro, imposta il flag --purpose dell'indirizzo IP su SHARED_LOADBALANCER_VIP.

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

Configura la rete e le subnet

È necessaria una rete VPC con due subnet: una per i backend del bilanciatore del carico e l'altra per i proxy del bilanciatore del carico. Un bilanciatore del carico delle applicazioni interno è regionale. Il traffico all'interno della rete VPC viene indirizzato al bilanciatore del carico se la sorgente del traffico si trova in una subnet nella stessa regione del bilanciatore del carico.

Questo esempio utilizza la seguente rete VPC, regione e subnet:

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

• Subnet per i backend. Una subnet denominata backend-subnet nella regione us-west1 utilizza 10.1.2.0/24 per 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.

Per dimostrare l'accesso globale, questo esempio crea anche una seconda VM client di test in una regione e una subnet diverse:

• Regione: europe-west1
• Subnet: europe-subnet, con intervallo di indirizzi IP principale 10.3.4.0/24

Nota: puoi modificare il nome della rete, della regione e dei parametri per le subnet. Tuttavia, i passaggi successivi di questa guida utilizzano i parametri di rete, regione e subnet descritti qui.

Configura la rete e le subnet

Console

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

   Vai a Reti VPC

2. Fai clic su Crea rete VPC.

3. In Nome, inserisci lb-network.

4. Nella sezione Subnet, imposta Modalità di creazione subnet su Personalizzata.

5. Crea una subnet per i backend del bilanciatore del carico. Nella sezione Nuova subnet, inserisci le seguenti informazioni:

   • Nome: backend-subnet
   • Regione: us-west1
   • Intervallo di indirizzi IP: 10.1.2.0/24

6. Fai clic su Fine.

7. Fai clic su Aggiungi subnet.

8. Crea una subnet per dimostrare l'accesso globale. Nella sezione Nuova subnet, inserisci le seguenti informazioni:

   • Nome: europe-subnet
   • Regione: europe-west1
   • Intervallo di indirizzi IP: 10.3.4.0/24

9. Fai clic su Fine.

10. Fai clic su Crea.

gcloud

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

   gcloud compute networks create lb-network --subnet-mode=custom
   

2. Crea una subnet nella rete lb-network nella regione us-west1 con il comando gcloud compute networks subnets create:

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

3. Crea una subnet nella rete lb-network nella regione europe-west1 con il comando gcloud compute networks subnets create:

   gcloud compute networks subnets create europe-subnet \
       --network=lb-network \
       --range=10.3.4.0/24 \
       --region=europe-west1
   

API

Invia una richiesta POST al metodo networks.insert. Sostituisci PROJECT_ID con l'ID del tuo progetto.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks

{
 "routingConfig": {
   "routingMode": "REGIONAL"
 },
 "name": "lb-network",
 "autoCreateSubnetworks": false
}

Invia una richiesta POST al metodo subnetworks.insert. Sostituisci PROJECT_ID con l'ID del tuo progetto.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks

{
 "name": "backend-subnet",
 "network": "projects/PROJECT_ID/global/networks/lb-network",
 "ipCidrRange": "10.1.2.0/24",
 "region": "projects/PROJECT_ID/regions/us-west1",
}

Invia una richiesta POST al metodo subnetworks.insert. Sostituisci PROJECT_ID con l'ID del tuo progetto.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/europe-west1/subnetworks

{
 "name": "europe-subnet",
 "network": "projects/PROJECT_ID/global/networks/lb-network",
 "ipCidrRange": "10.3.4.0/24",
 "region": "projects/PROJECT_ID/regions/europe-west1",
}

Configura la subnet solo proxy

Questa subnet solo proxy è destinata a tutti i bilanciatori del carico basati su Envoy a livello di regione nella regione us-west1 del lb-network.

Importante: non tentare di assegnare indirizzi della subnet solo proxy ai backend o alla regola di forwarding del bilanciatore del carico. Assegna l'indirizzo IP della regola di forwarding e gli indirizzi IP dell'istanza di backend da un intervallo (o intervalli) di subnet diverso, non da questo. Google Cloud riserva questo intervallo di sottoreti per i proxy gestiti da Google Cloud.

Console

Se utilizzi la console Google Cloud, puoi attendere e creare la sottorete solo proxy più tardi nella pagina Bilanciamento del carico.

Se vuoi creare subito la subnet solo proxy:

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

   Vai a Reti VPC

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

3. Fai clic su Aggiungi subnet.

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

5. In Regione, seleziona us-west1.

6. Imposta Finalità su Proxy gestito a livello di regione.

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

8. Fai clic su Aggiungi.

gcloud

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

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

API

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

POST https://compute.googleapis.com/compute/projects/PROJECT_ID/regions/us-west1/subnetworks

{
  "name": "proxy-only-subnet",
  "ipCidrRange": "10.129.0.0/23",
  "network": "projects/PROJECT_ID/global/networks/lb-network",
  "region": "projects/PROJECT_ID/regions/us-west1",
  "purpose": "REGIONAL_MANAGED_PROXY",
  "role": "ACTIVE"
}

Configurazione delle regole del firewall

Questo esempio utilizza le seguenti regole firewall:

• 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 per questa regola. Ad esempio, puoi specificare solo gli intervalli IP del sistema da cui avvii le sessioni SSH. Questo esempio utilizza il tag di destinazione allow-ssh per identificare le VM a cui si applica la regola firewall.

• fw-allow-health-check. Una regola in entrata, applicabile alle istanze bilanciate in base al carico, che consente tutto il traffico TCP dai sistemi di controllo di integrità di Google Cloud (in 130.211.0.0/22 e 35.191.0.0/16). Questo esempio utilizza il tag target load-balanced-backend per identificare le VM a cui si applica la regola firewall.

• fw-allow-proxies. Una regola di ingresso, applicabile alle istanze su cui viene eseguito il bilanciamento del carico, che consente il traffico TCP sulle porte 80, 443 e 8080 dai proxy gestiti del bilanciatore del carico delle applicazioni interno. Questo esempio utilizza il tag di destinazioneload-balanced-backend per identificare le VM a cui si applica la regola firewall.

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

I tag target definiscono le istanze di backend. Senza i tag target, le regole del firewall si applicano a tutte le istanze di backend nella rete VPC. Quando crei le VM di backend, assicurati di includere i tag target specificati, come mostrato in Creare un gruppo di istanze gestite.

Console

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

   Vai a Policy del firewall

2. Fai clic su Crea regola firewall per creare la regola per consentire le connessioni SSH in entrata:

   • 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 la casella di controllo TCP, quindi inserisci 22 per il numero di porta.

3. Fai clic su Crea.

4. Fai clic su Crea regola firewall una seconda volta per creare la regola per consentire i controlli di integrità di Google Cloud:

   • Nome: fw-allow-health-check
   • Rete: lb-network
   • Direzione del traffico: in entrata
   • Azione in caso di corrispondenza: Consenti
   • Target: tag di destinazione specificati
   • Tag di destinazione: load-balanced-backend
   • Filtro di origine: intervalli IPv4
   • Intervalli IPv4 di origine: 130.211.0.0/22 e 35.191.0.0/16
   • Protocolli e porte:
     • Scegli Protocolli e porte specificati.
     • Seleziona la casella di controllo TCP, quindi inserisci 80 per il numero di porta.
       Come best practice, limita questa regola solo ai protocolli e alle porte che corrispondono a quelli utilizzati dal controllo dell'integrità. Se utilizzi tcp:80 per il protocollo e la porta, Google Cloud può utilizzare HTTP sulla porta 80 per contattare le VM, ma non può utilizzare HTTPS sulla porta 443 per contattarle.

5. Fai clic su Crea.

6. Fai clic su Crea regola firewall una terza volta per creare la regola che consenta ai server proxy del bilanciatore del carico di connettere i backend:

   • Nome: fw-allow-proxies
   • Rete: lb-network
   • Direzione del traffico: in entrata
   • Azione in caso di corrispondenza: Consenti
   • Target: tag di destinazione specificati
   • Tag di destinazione: load-balanced-backend
   • Filtro di origine: intervalli IPv4
   • Intervalli IPv4 di origine: 10.129.0.0/23
   • Protocolli e porte:
     • Scegli Protocolli e porte specificati.
     • Seleziona la casella di controllo TCP e inserisci 80, 443, 8080 per i numeri di porta.

7. Fai clic su Crea.

gcloud

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

2. Crea la regola fw-allow-health-check per consentire i controlli di integrità di Google Cloud. Questo esempio consente tutto il traffico TCP proveniente dai probe del controllo di integrità. Tuttavia, puoi configurare un insieme più ristretto di porte in base alle tue esigenze.

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

3. Crea la regola fw-allow-proxies per consentire ai proxy dell'Application Load Balancer interno di connettersi ai tuoi backend. Imposta source-ranges sugli intervalli allocati della subnet solo proxy, ad esempio 10.129.0.0/23.

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

API

Crea la regola firewall fw-allow-ssh inviando una richiesta POST al metodo firewalls.insert, sostituendo PROJECT_ID con il tuo ID progetto.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls

{
 "name": "fw-allow-ssh",
 "network": "projects/PROJECT_ID/global/networks/lb-network",
 "sourceRanges": [
   "0.0.0.0/0"
 ],
 "targetTags": [
   "allow-ssh"
 ],
 "allowed": [
  {
    "IPProtocol": "tcp",
    "ports": [
      "22"
    ]
  }
 ],
"direction": "INGRESS"
}

Crea la regola firewall fw-allow-health-check inviando una richiesta POST al metodo firewalls.insert, sostituendo PROJECT_ID con il tuo ID progetto.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls

{
 "name": "fw-allow-health-check",
 "network": "projects/PROJECT_ID/global/networks/lb-network",
 "sourceRanges": [
   "130.211.0.0/22",
   "35.191.0.0/16"
 ],
 "targetTags": [
   "load-balanced-backend"
 ],
 "allowed": [
   {
     "IPProtocol": "tcp"
   }
 ],
 "direction": "INGRESS"
}

Crea la regola firewall fw-allow-proxies per consentire il traffico TCP all'interno della subnet del proxy per il metodo firewalls.insert, sostituendo PROJECT_ID con l'ID del tuo progetto.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls

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

Prenota l'indirizzo IP del bilanciatore del carico

Per impostazione predefinita, viene utilizzato un indirizzo IP per ogni regola di forwarding. Puoi prenotare un indirizzo IP condiviso, che ti consente di utilizzare lo stesso indirizzo IP con più regole di inoltro. Tuttavia, se vuoi pubblicare il bilanciatore del carico utilizzando Private Service Connect, non utilizzare un indirizzo IP condiviso per la regola di forwarding.

Per l'indirizzo IP della regola di forwarding, utilizza backend-subnet. Se provi a utilizzare la sottorete solo proxy, la creazione regola di forwarding non va a buon fine.

Console

Puoi prenotare un indirizzo IP interno autonomo utilizzando la console Google Cloud.

1. Vai alla pagina Reti VPC.

   Vai a Reti VPC

2. Fai clic sulla rete utilizzata per configurare la connettività ibrida tra gli ambienti.
3. Fai clic su Indirizzi IP interni statici e poi su Prenota indirizzo statico.
4. In Nome, inserisci l7-ilb-ip-address.
5. Per Subnet, seleziona backend-subnet.
6. Se vuoi specificare l'indirizzo IP da prenotare, in Indirizzo IP statico seleziona Scelta manuale e poi inserisci un Indirizzo IP personalizzato. In caso contrario, il sistema assegna automaticamente un indirizzo IP nella subnet.
7. Se vuoi utilizzare questo indirizzo IP con più regole di inoltro, in Finalità, scegli Condiviso.
8. Fai clic su Prenota per completare la procedura.

gcloud

1. Utilizzando gcloud CLI, esegui il comando compute addresses create:

   gcloud compute addresses create l7-ilb-ip-address \
     --region=us-west1 \
     --subnet=backend-subnet
   

   Se vuoi utilizzare lo stesso indirizzo IP con più regole di inoltro, specifica --purpose=SHARED_LOADBALANCER_VIP.

2. Utilizza il comando compute addresses describe per visualizzare l'indirizzo IP assegnato:

   gcloud compute addresses describe l7-ilb-ip-address \
     --region=us-west1
   

Crea un backend di un gruppo di istanze VM gestite

Questa sezione mostra come creare un modello di gruppo di istanze e un gruppo di istanze gestite. Il gruppo di istanze gestite fornisce istanze VM che eseguono i server di backend di un bilanciatore del carico delle applicazioni interno regionale di esempio. Per il gruppo di istanze, puoi definire un servizio HTTP e mappare un nome di porta alla porta pertinente. Il servizio di backend del bilanciatore del carico inoltra il traffico alle porte denominate. Il traffico proveniente dai client viene bilanciato sui 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 disponibili solo su Debian, come apt-get.
   4. Fai clic su Opzioni avanzate.
   5. Fai clic su Networking e configura i seguenti campi:
      1. In Tag di rete, inserisci allow-ssh e load-balanced-backend.
      2. In Interfacce di rete, seleziona quanto segue:
         • Rete: lb-network
         • Subnet: backend-subnet

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

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

   7. Fai clic su Crea.

2. Creare un gruppo di istanze gestite. Nella console Google Cloud, vai alla pagina Gruppi di istanze.

   Vai a Gruppi di istanze

   1. Fai clic su Crea gruppo di istanze.
   2. Seleziona Nuovo gruppo di istanze gestite (stateless). Per ulteriori informazioni, consulta Gruppi di istanze gestite stateless o stateful.
   3. In Nome, inserisci l7-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 in 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 dell'interfaccia utente puoi configurare il gruppo di istanze in modo da aggiungere o rimuovere automaticamente le istanze in base all'utilizzo della CPU delle istanze.

   9. Fai clic su Crea.

gcloud

Le istruzioni gcloud in questa guida presuppongono che tu stia utilizzando Cloud Shell o un altro ambiente con bash installato.

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

   gcloud compute instance-templates create l7-ilb-backend-template \
   --region=us-west1 \
   --network=lb-network \
   --subnet=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'
   

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
   

API

Crea il modello di istanza con il metodo instanceTemplates.insert sostituendo PROJECT_ID con l'ID del tuo progetto.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/instanceTemplates
{
  "name":"l7-ilb-backend-template",
  "properties":{
     "machineType":"e2-standard-2",
     "tags":{
       "items":[
         "allow-ssh",
         "load-balanced-backend"
       ]
     },
     "metadata":{
        "kind":"compute#metadata",
        "items":[
          {
            "key":"startup-script",
            "value":"#! /bin/bash\napt-get update\napt-get install
            apache2 -y\na2ensite default-ssl\na2enmod ssl\n
            vm_hostname=\"$(curl -H \"Metadata-Flavor:Google\"
            \\\nhttp://metadata.google.internal/computeMetadata/v1/instance/name)\"\n
            echo \"Page served from: $vm_hostname\" | \\\ntee
            /var/www/html/index.html\nsystemctl restart apache2"
          }
        ]
     },
     "networkInterfaces":[
       {
         "network":"projects/PROJECT_ID/global/networks/lb-network",
         "subnetwork":"regions/us-west1/subnetworks/backend-subnet",
         "accessConfigs":[
           {
             "type":"ONE_TO_ONE_NAT"
           }
         ]
       }
     ],
     "disks":[
       {
         "index":0,
         "boot":true,
         "initializeParams":{
           "sourceImage":"projects/debian-cloud/global/images/family/debian-12"
         },
         "autoDelete":true
       }
     ]
  }
}

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

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

Configura il bilanciatore del carico

Questo esempio mostra come creare le seguenti risorse Application Load Balancer interne regionali:

• Controllo di integrità HTTP
• Servizio di backend con un gruppo di istanze gestite come backend
• Una mappa URL
  • Assicurati di fare riferimento a una mappa di URL regionale se è definita una regione per il proxy HTTP(S) di destinazione. Una mappa URL a livello di regione instrada le richieste a un servizio di backend regionale in base alle regole che definisci per l'host e il percorso di un URL in entrata. Una mappa di URL regionale può essere richiamata da una regola proxy di destinazione regionale solo nella stessa regione.
• Certificato SSL (per HTTPS)
• Proxy di destinazione
• Regola di forwarding

Disponibilità del proxy

A volte le regioni Google Cloud non dispongono di una capacità proxy sufficiente per un nuovo bilanciatore del carico. 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 eseguire una delle seguenti operazioni:

• Seleziona una regione diversa per il bilanciatore del carico. Questa può essere un'opzione pratica se hai backend in un'altra regione.
• Seleziona una rete VPC che abbia già una subnet solo proxy allocata.

• Attendi che il problema di capacità venga risolto.

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. In Deployment tra regioni o in una regione singola, seleziona Ideale per workload regionali e fai clic su Avanti.
6. Fai clic su Configura.

Configurazione di base

1. In Nome del bilanciatore del carico, inserisci l7-ilb-map.
2. In Regione, seleziona us-west1.
3. In Rete, seleziona lb-network.

Riserva una subnet solo proxy

Nota: se hai già prenotato una subnet solo proxy, come indicato nella configurazione di preparazione, il pulsante Prenota una subnet non viene visualizzato, quindi devi saltare questa sezione e continuare con i passaggi per configurare il servizio di backend.

Riserva una subnet solo proxy:

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

Configura il servizio di backend

1. Fai clic su Configurazione backend.
2. Dal menu Crea o seleziona servizi di backend, seleziona Crea un servizio di backend.
3. Imposta il nome del servizio di backend su l7-ilb-backend-service.
4. Imposta Tipo di backend su Gruppo 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. Nell'elenco Controllo di integrità, fai clic su Crea un controllo di integrità con i seguenti parametri:
   1. Nome: l7-ilb-basic-check
   2. Protocollo: HTTP
   3. Porta: 80
   4. Fai clic su Salva.
7. Fai clic su Crea.

Configura la mappa URL

1. Fai clic su Regole host e percorso.

2. In Modalità, seleziona Regola semplice per host e percorso.

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

Configura il frontend

Per HTTP:

1. Fai clic su Configurazione frontend.
2. Imposta il nome della regola di forwarding su l7-ilb-forwarding-rule.
3. Imposta Protocollo su HTTP.
4. Imposta Subnet su backend-subnet.
5. Imposta Porta su 80.
6. Nell'elenco Indirizzo IP, seleziona l7-ilb-ip-address.
7. Fai clic su Fine.

Per HTTPS:

1. Fai clic su Configurazione frontend.
2. Imposta il nome della regola di forwarding su l7-ilb-forwarding-rule.
3. Imposta Protocollo su HTTPS (includes HTTP/2).
4. Imposta Subnet su backend-subnet.
5. Assicurati che Porta sia impostata su 443 per consentire il traffico HTTPS.
6. Nell'elenco Indirizzo IP, seleziona l7-ilb-ip-address.
7. Fai clic sull'elenco a discesa Certificato.
   1. Se hai già una risorsa del certificato SSL con gestione indipendente da utilizzare come certificato SSL principale, selezionala dall'elenco.
   2. In caso contrario, seleziona Crea un nuovo certificato.
      1. Imposta il nome del certificato su l7-ilb-cert.
      2. Carica i file in formato PEM nei campi appropriati:
         • Certificato di chiave pubblica
         • Catena di certificati
         • Chiave privata
      3. Fai clic su Crea.
8. Per aggiungere risorse del certificato oltre alla 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.

9. Seleziona un criterio SSL dall'elenco Criterio SSL. Facoltativamente, per creare un criterio SSL, segui questi passaggi:

   1. Nell'elenco Criterio SSL, seleziona Crea un criterio.
   2. Inserisci un nome per il criterio SSL.
   3. Seleziona una versione TLS minima. Il valore predefinito è TLS 1.0.
   4. Seleziona uno dei profili gestiti da Google preconfigurati o un profilo Personalizzato che ti consente di selezionare le funzionalità SSL singolarmente. Vengono visualizzate le sezioni Funzionalità abilitate e Funzionalità disattivate.
   5. Fai clic su Salva.

   Se non hai creato criteri SSL, viene applicato un criterio SSL predefinito di Google Cloud.

10. Fai clic su Fine.

Rivedi la configurazione

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

gcloud

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

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

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
   

3. Aggiungi i 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
   

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
   

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
   

   Per HTTPS:

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

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

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

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

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

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

   Assegna i percorsi file ai nomi delle variabili.

   export LB_CERT=path to PEM-formatted file
   

   export LB_PRIVATE_KEY=path to PEM-formatted file
   

   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 il comando 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
   

   • Crea la regola di forwarding.

     Per le reti personalizzate, devi fare riferimento alla subnet nella regola di inoltro. Tieni presente che si tratta della subnet della VM, non della subnet del proxy.

     Per HTTP:

     Utilizza 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=lb-network \
       --subnet=backend-subnet \
       --address=l7-ilb-ip-address \
       --ports=80 \
       --region=us-west1 \
       --target-http-proxy=l7-ilb-proxy \
       --target-http-proxy-region=us-west1
     

     Per HTTPS:

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

     gcloud compute forwarding-rules create l7-ilb-forwarding-rule \
       --load-balancing-scheme=INTERNAL_MANAGED \
       --network=lb-network \
       --subnet=backend-subnet \
       --address=l7-ilb-ip-address \
       --ports=443 \
       --region=us-west1 \
       --target-https-proxy=l7-ilb-proxy \
       --target-https-proxy-region=us-west1
     

API

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

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/{region}/healthChecks

{
"name": "l7-ilb-basic-check",
"type": "HTTP",
"httpHealthCheck": {
  "portSpecification": "USE_SERVING_PORT"
}
}

Crea il servizio di backend regionale inviando una richiesta POST al metodo regionBackendServices.insert, sostituendo PROJECT_ID con il tuo ID progetto.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices

{
"name": "l7-ilb-backend-service",
"backends": [
  {
    "group": "projects/PROJECT_ID/zones/us-west1-a/instanceGroups/l7-ilb-backend-example",
    "balancingMode": "UTILIZATION"
  }
],
"healthChecks": [
  "projects/PROJECT_ID/regions/us-west1/healthChecks/l7-ilb-basic-check"
],
"loadBalancingScheme": "INTERNAL_MANAGED"
}

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

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/urlMaps

{
"name": "l7-ilb-map",
"defaultService": "projects/PROJECT_ID/regions/us-west1/backendServices/l7-ilb-backend-service"
}

Per HTTP:

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

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/targetHttpProxy

{
"name": "l7-ilb-proxy",
"urlMap": "projects/PROJECT_ID/global/urlMaps/l7-ilb-map",
"region": "us-west1"
}

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

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules

{
"name": "l7-ilb-forwarding-rule",
"IPAddress": "IP_ADDRESS",
"IPProtocol": "TCP",
"portRange": "80-80",
"target": "projects/PROJECT_ID/regions/us-west1/targetHttpProxies/l7-ilb-proxy",
"loadBalancingScheme": "INTERNAL_MANAGED",
"subnetwork": "projects/PROJECT_ID/regions/us-west1/subnetworks/backend-subnet",
"network": "projects/PROJECT_ID/global/networks/lb-network",
"networkTier": "PREMIUM"
}

Per HTTPS:

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

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

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

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

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

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

Leggi i file del certificato e della chiave privata, quindi crea il certificato SSL. L'esempio seguente mostra come eseguire questa operazione con Python.

from pathlib import Path
from pprint import pprint
from typing import Union

from googleapiclient import discovery


def create_regional_certificate(
    project_id: str,
    region: str,
    certificate_file: Union[str, Path],
    private_key_file: Union[str, Path],
    certificate_name: str,
    description: str = "Certificate created from a code sample.",
) -> dict:
    """
    Create a regional SSL self-signed certificate within your Google Cloud project.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        region: name of the region you want to use.
        certificate_file: path to the file with the certificate you want to create in your project.
        private_key_file: path to the private key you used to sign the certificate with.
        certificate_name: name for the certificate once it's created in your project.
        description: description of the certificate.

        Returns:
        Dictionary with information about the new regional SSL self-signed certificate.
    """
    service = discovery.build("compute", "v1")

    # Read the cert into memory
    with open(certificate_file) as f:
        _temp_cert = f.read()

    # Read the private_key into memory
    with open(private_key_file) as f:
        _temp_key = f.read()

    # Now that the certificate and private key are in memory, you can create the
    # certificate resource
    ssl_certificate_body = {
        "name": certificate_name,
        "description": description,
        "certificate": _temp_cert,
        "privateKey": _temp_key,
    }
    request = service.regionSslCertificates().insert(
        project=project_id, region=region, body=ssl_certificate_body
    )
    response = request.execute()
    pprint(response)

    return response

Crea il proxy HTTPS di destinazione inviando una richiesta POST al metodo regionTargetHttpsProxies.insert sostituendo PROJECT_ID con l'ID del tuo progetto.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/regionTargetHttpsProxy

{
"name": "l7-ilb-proxy",
"urlMap": "projects/PROJECT_ID/regions/us-west1/urlMaps/l7-ilb-map",
"sslCertificates": /projects/PROJECT_ID/regions/us-west1/sslCertificates/SSL_CERT_NAME
}

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

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules

{
"name": "l7-ilb-forwarding-rule",
"IPAddress": "IP_ADDRESS",
"IPProtocol": "TCP",
"portRange": "80-80",
"target": "projects/PROJECT_ID/regions/us-west1/targetHttpsProxies/l7-ilb-proxy",
"loadBalancingScheme": "INTERNAL_MANAGED",
"subnetwork": "projects/PROJECT_ID/regions/us-west1/subnetworks/backend-subnet",
"network": "projects/PROJECT_ID/global/networks/lb-network",
"networkTier": "PREMIUM",
}

Testa il bilanciatore del carico

Per testare il bilanciatore del carico, crea una VM client. Quindi, stabilisci una sessione SSH con la VM e invia il traffico dalla VM al bilanciatore del carico.

Crea un'istanza VM per testare la connettività

Console

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

   Vai a Istanze VM

2. Fai clic su Crea istanza.

3. Imposta Nome su l7-ilb-client-us-west1-a.

4. Imposta Zona su us-west1-a.

5. Fai clic su Opzioni avanzate.

6. Fai clic su Networking e configura i seguenti campi:

   1. In Tag di rete, inserisci allow-ssh.
   2. In Interfacce di rete, seleziona quanto segue:
      1. Rete: lb-network
      2. Subnet: backend-subnet

7. Fai clic su Crea.

gcloud

gcloud compute instances create l7-ilb-client-us-west1-a \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --network=lb-network \
    --subnet=backend-subnet \
    --zone=us-west1-a \
    --tags=allow-ssh

Invia traffico al bilanciatore del carico

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

Connettiti tramite SSH a ogni istanza client

gcloud compute ssh l7-ilb-client-us-west1-a \
    --zone=us-west1-a

Ottieni l'indirizzo IP del bilanciatore del carico

Utilizza il comando gcloud compute addresses describe per visualizzare l'indirizzo IP assegnato:

gcloud compute addresses describe l7-ilb-ip-address \
    --region=us-west1

Verifica che l'indirizzo IP stia pubblicando il nome host

Sostituisci IP_ADDRESS con l'indirizzo IP del bilanciatore del carico.

curl IP_ADDRESS

Per i test HTTPS, sostituisci curl con:

curl -k -s 'https://test.example.com:443' --connect-to test.example.com:443:IP_ADDRESS:443

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

Esegui 100 richieste e verifica che siano bilanciate in base al carico

Sostituisci IP_ADDRESS con l'indirizzo IP del bilanciatore del carico.

Per HTTP:

{
  RESULTS=
  for i in {1..100}
  do
      RESULTS="$RESULTS:$(curl --silent IP_ADDRESS)"
  done
  echo "***"
  echo "*** Results of load-balancing: "
  echo "***"
  echo "$RESULTS" | tr ':' '\n' | grep -Ev "^$" | sort | uniq -c
  echo
}

Per HTTPS:

{
  RESULTS=
  for i in {1..100}
  do
      RESULTS="$RESULTS:$(curl -k -s 'https://test.example.com:443' --connect-to test.example.com:443:IP_ADDRESS:443)"
  done
  echo "***"
  echo "*** Results of load-balancing: "
  echo "***"
  echo "$RESULTS" | tr ':' '\n' | grep -Ev "^$" | sort | uniq -c
  echo
}

Opzioni di configurazione aggiuntive

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

Abilita accesso globale

Puoi attivare l'accesso globale per il bilanciatore del carico delle applicazioni interno regionale e il bilanciatore del carico di rete proxy interno regionale in modo che siano accessibili ai client in tutte le regioni. I backend del bilanciatore del carico di esempio devono essere ancora collocati in una regione (us-west1).

Bilanciatore del carico delle applicazioni interno regionale con accesso globale (fai clic per ingrandire).

Non puoi modificare una regola di forwarding regionale esistente per attivare l'accesso globale. A questo scopo, devi creare una nuova regola di forwarding ed eliminare la precedente. Inoltre, una volta creata una regola di forwarding con l'accesso globale abilitato, non può essere modificata. Per disattivare l'accesso globale, devi creare una nuova regola di forwarding per l'accesso regionale ed eliminare la regola di forwarding per l'accesso globale precedente.

Per configurare l'accesso globale, apporta le seguenti modifiche alla configurazione.

Console

Crea una nuova regola di forwarding per il bilanciatore del carico:

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

   Vai a Bilanciamento del carico

2. Nella colonna Nome, fai clic sul bilanciatore del carico.

3. Fai clic su Configurazione frontend.

4. Fai clic su Aggiungi IP e porta frontend.

5. Inserisci il nome e i dettagli della sottorete per la nuova regola di forwarding.

6. In Subnet, seleziona backend-subnet.

7. In Indirizzo IP, puoi selezionare lo stesso indirizzo IP di una regola di forwarding esistente, prenotare un nuovo indirizzo IP o utilizzare un indirizzo IP temporaneo. La condivisione dello stesso indirizzo IP tra più regole di inoltro è possibile solo se imposti il flag --purpose SHARED_LOADBALANCER_VIP per l'indirizzo IP durante la creazione.

8. In Numero porta, inserisci 110.

9. Per Accesso globale, seleziona Attiva.

10. Fai clic su Fine.

11. Fai clic su Aggiorna.

gcloud

1. Crea una nuova regola di forwarding per il bilanciatore del carico con il flag --allow-global-access.

   Per HTTP:

   gcloud compute forwarding-rules create l7-ilb-forwarding-rule-global-access \
     --load-balancing-scheme=INTERNAL_MANAGED \
     --network=lb-network \
     --subnet=backend-subnet \
     --address=10.1.2.99 \
     --ports=80 \
     --region=us-west1 \
     --target-http-proxy=l7-ilb-proxy \
     --target-http-proxy-region=us-west1 \
     --allow-global-access
   

   Per HTTPS:

   gcloud compute forwarding-rules create l7-ilb-forwarding-rule-global-access \
     --load-balancing-scheme=INTERNAL_MANAGED \
     --network=lb-network \
     --subnet=backend-subnet \
     --address=10.1.2.99 \
     --ports=443 \
     --region=us-west1 \
     --target-https-proxy=l7-ilb-proxy \
     --target-https-proxy-region=us-west1 \
     --allow-global-access
   

2. Puoi utilizzare il comando gcloud compute forwarding-rules describe per determinare se per una regola di forwarding è attivato l'accesso globale. Ad esempio:

   gcloud compute forwarding-rules describe l7-ilb-forwarding-rule-global-access \
     --region=us-west1 \
     --format="get(name,region,allowGlobalAccess)"
   

   Quando l'accesso globale è abilitato, la parola True viene visualizzata nell'output dopo il nome e la regione della regola di forwarding.

Crea una VM client per testare l'accesso globale

Console

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

   Vai a Istanze VM

2. Fai clic su Crea istanza.

3. Imposta Nome su europe-client-vm.

4. Imposta Zona su europe-west1-b.

5. Fai clic su Opzioni avanzate.

6. Fai clic su Networking e configura i seguenti campi:

   1. In Tag di rete, inserisci allow-ssh.
   2. In Interfacce di rete, seleziona quanto segue:
      • Rete: lb-network
      • Subnet: europe-subnet

7. Fai clic su Crea.

gcloud

Crea una VM client nella zona europe-west1-b.

gcloud compute instances create europe-client-vm \
    --zone=europe-west1-b \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --tags=allow-ssh \
    --subnet=europe-subnet

Connettiti alla VM client e testa la connettività

1. Utilizza ssh per connetterti all'istanza client.

   gcloud compute ssh europe-client-vm \
       --zone=europe-west1-b
   

2. Testa le connessioni al bilanciatore del carico come hai fatto da vm-client nella regione us-west1.

   curl http://10.1.2.99
   

Attivare l'affinità sessione

Queste procedure mostrano come aggiornare un servizio di backend per l'esempio bilanciatore del carico delle applicazioni interno a livello di regione o bilanciatore del carico delle applicazioni interno tra regioni in modo che il servizio di backend utilizzi l'affinità cookie generato, l'affinità del campo dell'intestazione o l'affinità del cookie HTTP.

Quando l'affinità cookie generato è attiva, il bilanciatore del carico emette un cookie alla prima richiesta. Per ogni richiesta successiva con lo stesso cookie, il bilanciatore del carico indirizza la richiesta alla stessa istanza o allo stesso endpoint della macchina virtuale (VM) di backend. In questo esempio, il cookie si chiama GCILB.

Quando l'affinità del campo dell'intestazione è abilitata, il bilanciatore del carico instrada le richieste alle VM o agli endpoint di backend in un gruppo di endpoint di rete (NEG) in base al valore dell'intestazione HTTP denominata nel flag --custom-request-header. L'affinità del campo dell'intestazione è valida solo se il criterio di località del bilanciamento del carico è RING_HASH o MAGLEV e l'hash coerente del servizio di backend specifica il nome dell'intestazione HTTP.

Quando l'affinità dei cookie HTTP è attivata, il bilanciatore del carico instrada le richieste alle VM o agli endpoint di backend in un NEG in base a un cookie HTTP denominato nel flag HTTP_COOKIE con il flag facoltativo --affinity-cookie-ttl. Se il client non fornisce il cookie nella richiesta HTTP, il proxy lo genera e lo restituisce al client in un'intestazione Set-Cookie. L'affinità del cookie HTTP è valida solo se il criterio di località del bilanciamento del carico è RING_HASH o MAGLEV e l'hash coerente del servizio di backend specifica il cookie HTTP.

Console

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

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

   Vai a Bilanciamento del carico

2. Fai clic su Backend.
3. Fai clic su l7-ilb-backend-service (il nome del servizio di backend che hai creato per questo esempio) e poi su Modifica.
4. Nella pagina Dettagli del servizio di backend, fai clic su Configurazione avanzata.
5. In Affinità sessione, seleziona il tipo di affinità sessione che preferisci.
6. Fai clic su Aggiorna.

gcloud

Utilizza i seguenti comandi Google Cloud CLI per aggiornare il servizio di backend a diversi tipi di affinità sessione:

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

API

Per impostare l'affinità sessione, invia una richiesta "PATCH" al metodo backendServices/patch.

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

Limitare i client che possono inviare traffico al bilanciatore del carico

Nota: questa sezione spiega come limitare l'accesso dei client al bilanciatore del carico delle applicazioni interno regionale utilizzando le regole firewall. Puoi anche utilizzare Google Cloud Armor per limitare l'accesso dei client al bilanciatore del carico. Per maggiori informazioni, consulta la panoramica dei criteri di sicurezza nella documentazione di Google Cloud Armor.

Puoi impedire ai client di connettersi a un VIP regola di forwarding del bilanciatore del carico delle applicazioni interno configurando regole firewall in uscita su questi client. Imposta queste regole firewall su VM client specifiche in base agli account di servizio o ai tag.

Non puoi utilizzare le regole firewall per limitare il traffico in entrata a VIP di regola di forwarding del bilanciatore del carico delle applicazioni interno specifici. In genere, qualsiasi client nella stessa rete VPC e nella stessa regione del VIP della regola di forwarding può inviare traffico al VIP della regola di forwarding.

Inoltre, tutte le richieste ai backend provengono da proxy che utilizzano indirizzi IP nell'intervallo della subnet solo proxy. Non è possibile creare regole firewall che consentano o neghino il traffico in entrata su questi backend in base alla regola di forwarding VIP utilizzata da un client.

Di seguito sono riportati alcuni esempi di come utilizzare le regole del firewall in uscita per limitare il traffico all'indirizzo VIP della regola di forwarding del bilanciatore del carico.

Console

Per identificare le VM client, tagga le VM specifiche che vuoi limitare. Questi tag vengono utilizzati per associare le regole firewall alle VM client con tag. Aggiungi il tag al campo TARGET_TAG nei passaggi che seguono.

Per configurare questa opzione, utilizza una singola regola firewall o più regole.

Singola regola firewall in uscita

Puoi configurare una regola di uscita del firewall per negare tutto il traffico in uscita dalle VM client taggate all'IP virtuale di un bilanciatore del carico.

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

   Vai a Regole firewall

2. Fai clic su Crea regola firewall per creare la regola che impedisce il traffico in uscita dalle VM client taggate all'IP virtuale di un bilanciatore del carico.

   • Nome: fr-deny-access
   • Rete: lb-network
   • Priorità: 100
   • Direzione del traffico: in uscita
   • Azione in caso di corrispondenza: Nega
   • Target: tag di destinazione specificati
   • Tag di destinazione: TARGET_TAG
   • Filtro destinazione: intervalli IP
   • Intervalli IP di destinazione: 10.1.2.99
   • Protocolli e porte:
     • Scegli Protocolli e porte specificati.
     • Seleziona la casella di controllo tcp, quindi inserisci 80 per il numero di porta.

3. Fai clic su Crea.

Più regole firewall in uscita

Un approccio più scalabile prevede l'impostazione di due regole. Una regola predefinita di bassa priorità che impedisce a tutti i client di accedere al VIP del bilanciatore del carico. Una seconda regola con priorità più alta che consente a un sottoinsieme di client taggati di accedere al VIP del bilanciatore del carico. Solo le VM con tag possono accedere al VIP.

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

   Vai a Regole firewall

2. Fai clic su Crea regola firewall per creare la regola con priorità inferiore per negare l'accesso per impostazione predefinita:

   • Nome: fr-deny-all-access-low-priority
   • Rete: lb-network
   • Priorità: 200
   • Direzione del traffico: in uscita
   • Azione in caso di corrispondenza: Nega
   • Target: tag di destinazione specificati
   • Tag di destinazione: TARGET_TAG
   • Filtro destinazione: intervalli IP
   • Intervalli IP di destinazione: 10.1.2.99
   • Protocolli e porte:
     • Scegli Protocolli e porte specificati.
     • Seleziona la casella di controllo TCP, quindi inserisci 80 per il numero di porta.

3. Fai clic su Crea.

4. Fai clic su Crea regola firewall per creare la regola con priorità più elevata per consentire il traffico da determinate istanze con tag.

   • Nome: fr-allow-some-access-high-priority
   • Rete: lb-network
   • Priorità: 100
   • Direzione del traffico: in uscita
   • Azione in caso di corrispondenza: Consenti
   • Target: tag di destinazione specificati
   • Tag di destinazione: TARGET_TAG
   • Filtro destinazione: intervalli IP
   • Intervalli IP di destinazione: 10.1.2.99
   • Protocolli e porte:
     • Scegli Protocolli e porte specificati.
     • Seleziona la casella di controllo TCP, quindi inserisci 80 per il numero di porta.

5. Fai clic su Crea.

gcloud

Per identificare le VM client, tagga le VM specifiche che vuoi limitare. Aggiungi il tag al campo TARGET_TAG seguendo questi passaggi.

Per configurare questa opzione, utilizza una singola regola firewall o più regole.

Singola regola firewall in uscita

Puoi configurare una regola di uscita del firewall per negare tutto il traffico in uscita dalle VM client taggate all'IP virtuale di un bilanciatore del carico.

gcloud compute firewall-rules create fr-deny-access \
  --network=lb-network \
  --action=deny \
  --direction=egress \
  --rules=tcp \
  --priority=100 \
  --destination-ranges=10.1.2.99 \
  --target-tags=TARGET_TAG

Più regole firewall in uscita

Un approccio più scalabile prevede l'impostazione di due regole: una regola predefinita con priorità bassa che impedisce a tutti i client di accedere al VIP del bilanciatore del carico e una seconda regola con priorità più alta che consente a un sottoinsieme di client taggati di accedere al VIP del bilanciatore del carico. Solo le VM taggate possono accedere al VIP.

1. Crea la regola di priorità inferiore:

   gcloud compute firewall-rules create fr-deny-all-access-low-priority \
     --network=lb-network \
     --action=deny \
     --direction=egress \
     --rules=tcp \
     --priority=200 \
     --destination-ranges=10.1.2.99
   

2. Crea la regola con priorità più alta:

   gcloud compute firewall-rules create fr-allow-some-access-high-priority \
     --network=lb-network \
     --action=allow \
     --direction=egress \
     --rules=tcp \
     --priority=100 \
     --destination-ranges=10.1.2.99 \
     --target-tags=TARGET_TAG
   

Per utilizzare gli account di servizio anziché i tag per controllare l'accesso, utilizza l'opzione --target-service-accounts anziché il flag --target-tags quando crei le regole firewall.

Scala l'accesso limitato ai backend del bilanciatore del carico delle applicazioni interno in base alle subnet

Gestire regole firewall separate o aggiungere nuovi indirizzi IP bilanciati in base al carico alle regole esistenti, come descritto nella sezione precedente, diventa sconveniente con l'aumento del numero di regole di inoltro. Un modo per evitarlo è allocare gli indirizzi IP regola di forwarding da una subnet riservata. Il traffico proveniente da istanze o account di servizio con tag può essere consentito o bloccato utilizzando la sottorete riservata come intervallo di destinazione per le regole del firewall. In questo modo puoi controllare in modo efficace l'accesso a un gruppo di VIP regola di forwarding senza dover gestire le regole di uscita del firewall per VIP.

Di seguito sono riportati i passaggi di alto livello per la configurazione, supponendo che tu crei tutte le altre risorse del bilanciatore del carico richieste separatamente.

gcloud

1. Crea una subnet regionale che verrà utilizzata per allocare indirizzi IP bilanciati in base al carico per le regole di inoltro:

   gcloud compute networks subnets create l7-ilb-restricted-subnet \
     --network=lb-network \
     --region=us-west1 \
     --range=10.127.0.0/24
   

2. Crea una regola di forwarding che prende un indirizzo dalla subrete. L'esempio seguente utilizza l'indirizzo 10.127.0.1 della sottorete creata nel passaggio precedente.

   gcloud compute forwarding-rules create l7-ilb-forwarding-rule-restricted \
     --load-balancing-scheme=INTERNAL_MANAGED \
     --network=lb-network \
     --subnet=l7-ilb-restricted-subnet \
     --address=10.127.0.1 \
     --ports=80 \
     --region=us-west1 \
     --target-http-proxy=l7-ilb-proxy \
     --target-http-proxy-region=us-west1
   

3. Crea una regola firewall per limitare il traffico destinato agli indirizzi IP dell'intervallo nella subnet della regola di forwarding (l7-ilb-restricted-subnet):

   gcloud compute firewall-rules create restrict-traffic-to-subnet \
     --network=lb-network \
     --action=deny \
     --direction=egress \
     --rules=tcp:80 \
     --priority=100 \
     --destination-ranges=10.127.0.0/24 \
     --target-tags=TARGET_TAG
   

Configurare i sottoinsiemi di backend

Anteprima

Questo prodotto o funzionalità è soggetto ai "Termini delle Offerte pre-GA" nella sezione Termini generali del servizio dei Termini specifici del servizio. I prodotti e le funzionalità pre-GA sono disponibili "così come sono" e potrebbero avere un supporto limitato. Per saperne di più, consulta le descrizioni della fase di lancio.

La sottosezione del backend migliora le prestazioni e la scalabilità assegnando un sottoinsieme di backend a ciascuna istanza proxy. Se abilitato per un servizio di backend, la sottoimpostazione backend regola il numero di backend utilizzati da ogni istanza proxy come segue:

• Man mano che aumenta il numero di istanze proxy che partecipano al bilanciatore del carico, le dimensioni del sottoinsieme diminuiscono.

• Quando il numero totale di backend in una rete supera la capacità di una singola istanza proxy, le dimensioni del sottoinsieme vengono ridotte automaticamente per ogni servizio in cui è abilitato il sottoinsieme di backend.

Nota: nell'API REST, l'impostazione subsetting.subsetSize è disponibile solo per Cloud Service Mesh. Questa impostazione non è disponibile per il bilanciatore del carico delle applicazioni interno regionale.

Questo esempio mostra come creare risorse Application Load Balancer interne regionali e attivare il sottoinsieme di backend:

1. Utilizza la configurazione di esempio per creare un servizio di backend regionale l7-ilb-backend-service.

2. Attiva la sottoimpostazione del backend specificando il flag --subsetting-policy come CONSISTENT_HASH_SUBSETTING. Imposta lo schema di bilanciamento del carico su INTERNAL_MANAGED.

   gcloud

   Utilizza il seguente comando gcloud per aggiornare l7-ilb-backend-service con il sottoinsieme di backend:

   gcloud beta compute backend-services update l7-ilb-backend-service \
      --region=us-west1 \
      --subsetting-policy=CONSISTENT_HASH_SUBSETTING
   

   API

   Invia una richiesta PATCH al metodo regionBackendServices/patch.

   PATCH https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/regions/us-west1/backendServices/l7-ilb-backend-service
   
   {
    "subsetting":
   {
    "policy": CONSISTENT_HASH_SUBSETTING
   }
   }
   

Puoi anche perfezionare il bilanciamento del carico del backend impostando il criterio localityLbPolicy. Per ulteriori informazioni, consulta le norme sul traffico.

Utilizzare lo stesso indirizzo IP tra più regole di inoltro interne

Affinché più regole di inoltro interno condividano lo stesso indirizzo IP interno, devi prenotare l'indirizzo IP e impostare il relativo flag --purpose su SHARED_LOADBALANCER_VIP.

gcloud

gcloud compute addresses create SHARED_IP_ADDRESS_NAME \
    --region=REGION \
    --subnet=SUBNET_NAME \
    --purpose=SHARED_LOADBALANCER_VIP

Se devi reindirizzare il traffico HTTP a HTTPS, puoi creare due regole di forwarding che utilizzano un indirizzo IP comune. Per ulteriori informazioni, consulta Configurare il reindirizzamento da HTTP a HTTPS per i bilanciatori del carico delle applicazioni interni.

Aggiorna il timeout keepalive HTTP del client

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

Per aggiornare il timeout keepalive HTTP del client, segui le istruzioni riportate di seguito.

Console

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

   Vai a Bilanciamento del carico.

2. Fai clic sul nome del bilanciatore del carico da modificare.
3. Fai clic su Modifica.
4. Fai clic su Configurazione frontend.
5. Espandi Funzionalità avanzate. In Timeout keepalive HTTP, inserisci un valore di timeout.
6. Fai clic su Aggiorna.
7. Per rivedere le modifiche, fai clic su Rivedi e finalizza e poi su Aggiorna.

gcloud

Per un bilanciatore del carico HTTP, aggiorna il proxy HTTP di destinazione utilizzando il comando gcloud compute target-http-proxies update.

      gcloud compute target-http-proxies update TARGET_HTTP_PROXY_NAME \
         --http-keep-alive-timeout-sec=HTTP_KEEP_ALIVE_TIMEOUT_SEC \
         --region=REGION
      

Per un bilanciatore del carico HTTPS, aggiorna il proxy HTTPS di destinazione utilizzando il comando gcloud compute target-https-proxies update.

      gcloud compute target-https-proxies update TARGET_HTTP_PROXY_NAME \
         --http-keep-alive-timeout-sec=HTTP_KEEP_ALIVE_TIMEOUT_SEC \
         --region REGION
      

Sostituisci quanto segue:

• TARGET_HTTP_PROXY_NAME: il nome del proxy HTTP di destinazione.
• TARGET_HTTPS_PROXY_NAME: il nome del proxy HTTPS di destinazione.
• HTTP_KEEP_ALIVE_TIMEOUT_SEC: il valore del timeout keepalive HTTP da 5 a 600 secondi.

Passaggi successivi

• Convertire il bilanciatore del carico delle applicazioni in IPv6
• Panoramica del bilanciatore del carico delle applicazioni interno regionale
• Subnet solo proxy per i bilanciatori del carico basati su Envoy
• Utilizzare i certificati SSL con gestione indipendente
• Pulisci la configurazione del bilanciatore del carico