Configura il bilanciamento del carico HTTP(S) interno con i backend dei gruppi di istanze VM

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

Questo documento fornisce istruzioni per la configurazione del bilanciamento del carico HTTP(S) interno per i servizi eseguiti sulle VM di Compute Engine.

Per configurare il bilanciamento del carico per i servizi in esecuzione nei pod GKE, consulta la sezione Collegare un bilanciatore del carico nativo del container con NEG autonomi e la sezione Collegare un bilanciatore del carico HTTP(S) interno a 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 controlli di servizio HTTP(S) consumer.

La configurazione del bilanciamento del carico HTTP(S) interno è composta da due parti:

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

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

Autorizzazioni

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

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

Per saperne di più, consulta le seguenti guide:

Panoramica della configurazione

Puoi configurare il bilanciamento del carico HTTP(S) interno come descritto nel seguente flusso di configurazione di alto livello. I passaggi numerati si riferiscono ai numeri nel diagramma.

Componenti numerati del bilanciamento del carico HTTP(S) interno (fai clic per ingrandire)
Componenti numerati del bilanciamento del carico HTTP(S) interno (fai clic per ingrandire)

Come mostrato nel diagramma, in questo esempio viene creato un bilanciatore del carico HTTP(S) 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 NEG) e per la regola di forwarding. Il suo intervallo di indirizzi IP principali è 10.1.2.0/24.

    2. Una subnet è una subnet solo proxy nell'area geografica us-west1. Devi creare una subnet solo proxy in ogni area geografica di una rete VPC in cui utilizzi bilanciatori del carico HTTP(S) interni. La subnet solo proxy della regione è condivisa tra tutti i bilanciatori del carico HTTP(S) interni nella regione. Gli indirizzi di origine dei pacchetti inviati dal bilanciatore del carico HTTP(S) 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 principali di 10.129.0.0/23, che è la dimensione della subnet consigliata. Per scoprire di più, consulta Subnet solo proxy.

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

  3. Istanze di backend. Questo diagramma di esempio mostra i seguenti deployment di backend:

    1. VM di Compute Engine
    2. Backend Google Kubernetes Engine (GKE) aggiunti a gruppi di endpoint di rete autonomi (NEG)
  4. Gruppi di istanze e NEG:

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

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

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

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

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

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

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

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

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

Configura la rete e le subnet

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

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

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

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

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

Per dimostrare l'accesso globale, in questo esempio viene creata anche una seconda VM client di test in un'area geografica e una subnet diverse:

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

Configura la rete e le subnet

Console

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

    Vai a Reti VPC

  2. Fai clic su Crea rete VPC.

  3. In Nome, inserisci lb-network.

  4. Nella sezione Subnet, imposta la modalità di creazione delle 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 nell'area geografica us-west1 con il comando gcloud compute networks subnets create:

    gcloud compute networks subnets create backend-subnet \
        --network=lb-network \
        --range=10.1.2.0/24 \
        --region=us-west1
    
  3. Crea una subnet nella rete lb-network nell'area geografica 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 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 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 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 è per tutti i bilanciatori del carico basati su Envoy a livello di area geografica nell'area geografica us-west1 di lb-network.

Console

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

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

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

    Vai a Reti VPC

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

  3. Fai clic su Aggiungi subnet.

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

  5. In Regione, seleziona us-west1.

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

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

  8. Fai clic su Add (Aggiungi).

gcloud

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

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

API

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

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

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

Configurazione delle regole del firewall

In questo esempio vengono utilizzate le seguenti regole firewall:

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

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

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

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

Console

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

    Vai a Regole firewall

  2. Fai clic su Crea regola firewall per creare la regola per consentire 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 della 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 della porta.
        Come best practice, limita questa regola solo ai protocolli e alle porte che corrispondono a quelli utilizzati dal controllo di integrità. Se utilizzi tcp:80 per il protocollo e la porta, Google Cloud può utilizzare HTTP sulla porta 80 per contattare le tue VM, ma non può utilizzare HTTPS sulla porta 443 per contattarli.
  5. Fai clic su Crea.

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

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

gcloud

  1. Crea la regola firewall fw-allow-ssh per consentire la connettività SSH alle VM con tag di rete allow-ssh. Quando ometti source-ranges, Google Cloud interpreta la regola in modo da indicare 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 da probe di controllo di integrità; tuttavia, puoi configurare un insieme di porte più ristrette per soddisfare le tue esigenze.

    gcloud compute firewall-rules create fw-allow-health-check \
        --network=lb-network \
        --action=allow \
        --direction=ingress \
        --source-ranges=130.211.0.0/22,35.191.0.0/16 \
        --target-tags=load-balanced-backend \
        --rules=tcp
    
  3. Crea la regola fw-allow-proxies per consentire ai proxy del bilanciatore del carico HTTP(S) 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 effettuando una richiesta POST al metodo firewalls.insert, sostituendo PROJECT_ID con il tuo ID progetto.

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

{
 "name": "fw-allow-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 effettuando una richiesta POST al metodo firewalls.insert, sostituendo PROJECT_ID con il tuo ID progetto.

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

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

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

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

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

Configurare il bilanciamento del carico HTTP(S) interno con un servizio basato su VM

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

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

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

Creare un gruppo di istanze gestite

Questa sezione mostra come creare un modello e un gruppo di istanze gestite. Il gruppo di istanze gestite fornisce istanze VM che eseguono i server di backend di un bilanciatore del carico HTTP(S) interno di esempio. Per il tuo gruppo di istanze, puoi definire un servizio HTTP e mappare il nome di una 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 in base al carico dei server di backend. A scopo dimostrativo, i backend gestiscono i propri nomi host.

Console

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

    Vai a Modelli di istanza

    1. Fai clic su Crea modello istanza.
    2. In Nome, inserisci l7-ilb-backend-template.
    3. Assicurati che il disco di avvio sia impostato su un'immagine Debian, ad esempio Debian GNU/Linux 10 (buster). 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 seguente nel campo Script di avvio.

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

  2. Creare un gruppo di istanze gestite. In Google Cloud Console, vai alla pagina Gruppi di istanze.

    Vai a Gruppi di istanze

    1. Fai clic su Crea gruppo di istanze.
    2. Seleziona Nuovo gruppo di istanze gestite (stateless). Per ulteriori informazioni, consulta la sezione MIG stateless o stateful.
    3. In Nome, inserisci l7-ilb-backend-example.
    4. Per Località, seleziona Zona singola.
    5. In Regione, seleziona us-west1.
    6. In Zona, seleziona us-west1-a.
    7. In Modello di istanza, seleziona l7-ilb-backend-template.
    8. Specifica il numero di istanze che vuoi creare nel gruppo.

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

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

      Facoltativamente, 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 dell'istanza.

    9. Fai clic su Crea.

gcloud

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

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

    gcloud compute instance-templates create `l7-ilb-backend-template` \
    --region=us-west1 \
    --network=lb-network \
    --subnet=backend-subnet \
    --tags=allow-ssh,load-balanced-backend \
    --image-family=debian-10 \
    --image-project=debian-cloud \
    --metadata=startup-script='#! /bin/bash
      sudo apt-get update
      sudo apt-get install apache2 -y
      sudo a2ensite default-ssl
      sudo a2enmod ssl
      vm_hostname="$(curl -H "Metadata-Flavor:Google" \
      http://metadata.google.internal/computeMetadata/v1/instance/name)"
      sudo echo "Page served from: $vm_hostname" | \
      tee /var/www/html/index.html
      sudo systemctl restart apache2'
    
  2. Crea un gruppo di istanze gestite nella zona con il comando gcloud compute instance-groups managed create.

    gcloud compute instance-groups managed create l7-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 il tuo ID 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\nsudo apt-get update\nsudo apt-get install
            apache2 -y\nsudo a2ensite default-ssl\nsudo a2enmod ssl\n
            vm_hostname=\"$(curl -H \"Metadata-Flavor:Google\"
            \\\nhttp://169.254.169.254/computeMetadata/v1/instance/name)\"\n
            sudo echo \"Page served from: $vm_hostname\" | \\\ntee
            /var/www/html/index.html\nsudo systemctl restart apache2"
          }
        ]
     },
     "networkInterfaces":[
       {
         "network":"projects/PROJECT_ID/global/networks/lb-network",
         "subnetwork":"regions/us-west1/subnetworks/backend-subnet",
         "accessConfigs":[
           {
             "type":"ONE_TO_ONE_NAT"
           }
         ]
       }
     ],
     "disks":[
       {
         "index":0,
         "boot":true,
         "initializeParams":{
           "sourceImage":"projects/debian-cloud/global/images/family/debian-10"
         },
         "autoDelete":true
       }
     ]
  }
}

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

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/{zone}/instanceGroupManagers
{
  "name": "l7-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 interne del bilanciatore del carico HTTP(S):

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

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

Disponibilità del proxy

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

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

Console

Seleziona un tipo di bilanciatore del carico

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

    Vai a Bilanciamento del carico

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

  3. Nella sezione Per Internet o solo interno, seleziona Solo tra le mie VM. Questa impostazione significa che il bilanciatore del carico è interno.

  4. Fai clic su Continua.

Prepara il bilanciatore del carico

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

Prenota una subnet solo proxy

Per il bilanciamento del carico HTTP(S) interno, prenota una subnet proxy:

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

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 Trasferisci numeri su 80.
    3. Imposta Modalità di equilibrio su Utilizzo.
    4. Fai clic su Fine.
  6. Nel menu a discesa 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 Semplice regola host e percorso.

  3. Assicurati che l7-ilb-backend-service sia l'unico servizio di backend per qualsiasi host senza corrispondenza e qualsiasi percorso senza corrispondenza.

Per informazioni sulla gestione del traffico, consulta Configurazione della 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 la subnet su backend-subnet.
  5. Imposta il campo Porta su 80.
  6. Nel menu a discesa Indirizzo IP, seleziona Crea indirizzo IP e inserisci i seguenti valori:
    1. Nome: l7-ilb-ip
    2. Indirizzo IP statico: Scelta manuale
    3. Indirizzo IP personalizzato: 10.1.2.99
    4. Fai clic su Prenota.
  7. Fai clic su Fine.

Per HTTPS:

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

  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 la porta sia impostata su 443 per consentire il traffico HTTPS.
  6. Nel menu a discesa Indirizzo IP, seleziona Crea indirizzo IP e inserisci i seguenti valori:
    1. Nome: l7-ilb-ip
    2. Indirizzo IP statico: Scelta manuale
    3. Indirizzo IP personalizzato: 10.1.2.99
    4. Fai clic su Prenota.
  7. Fai clic sul menu a discesa Certificato.
    1. Se hai già una risorsa SSL con gestione indipendente che vuoi utilizzare come certificato SSL principale, selezionala dall'elenco.
    2. In alternativa, seleziona Crea un nuovo certificato.
      1. Imposta il nome del certificato su 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.
  8. Per aggiungere risorse dei certificati oltre alla 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 riportate sopra.
  9. Seleziona un criterio SSL dall'elenco dei criteri SSL. Se non hai creato criteri SSL, viene applicato un criterio SSL predefinito di GCP.
  10. Fai clic su Fine.

Rivedi la configurazione

Controlla il bilanciatore del carico per assicurarti che sia configurato come previsto, quindi fai clic su Crea.

gcloud

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

    gcloud compute health-checks create http l7-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 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:

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

    Assegna i percorsi dei file ai nomi delle variabili.

    export LB_CERT=path to PEM-formatted file
    
    export LB_PRIVATE_KEY=path to PEM-formatted file
    

    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
    
  6. Crea la regola di forwarding.

    Per le reti personalizzate, devi fare riferimento alla subnet nella regola di forwarding. Tieni presente che questa è la subnet della VM, non la 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=10.1.2.99 \
      --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=10.1.2.99 \
      --ports=443 \
      --region=us-west1 \
      --target-https-proxy=l7-ilb-proxy \
      --target-https-proxy-region=us-west1
    

API

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

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

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

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

POST https://compute.googleapis.com/compute/v1/projects/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 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 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 progetto.

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

{
"name": "l7-ilb-forwarding-rule",
"IPAddress": "10.1.2.99",
"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:

Leggere i file del certificato e della chiave privata, quindi creare il certificato SSL. L'esempio seguente mostra come fare con Python.

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."
) -> None:
    """
    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.
    """
    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)

Crea il proxy HTTPS di destinazione inviando una richiesta POST al metodo regionTargetHttpsProxies.insert, sostituendo PROJECT_ID con l'ID 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 progetto.

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

{
"name": "l7-ilb-forwarding-rule",
"IPAddress": "10.1.2.99",
"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

Creare un'istanza VM per testare la connettività

Console

  1. In Google Cloud Console, vai alla pagina Istanze VM.

    Vai alle istanze VM

  2. Fai clic su Crea istanza.

  3. Imposta il 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-10 \
    --image-project=debian-cloud \
    --network=lb-network \
    --subnet=backend-subnet \
    --zone=us-west1-a \
    --tags=allow-ssh

Inviare traffico al bilanciatore del carico

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

Connettiti tramite SSH a ogni istanza client

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

Verifica che l'IP stia gestendo il suo nome host

curl 10.1.2.99

Per il test HTTPS, sostituisci curl con:

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

Il flag -k fa sì che curl non ignori la convalida dei certificati.

Esegui 100 richieste e verifica che siano bilanciate del carico

Per HTTP:

{
  RESULTS=
  for i in {1..100}
  do
      RESULTS="$RESULTS:$(curl --silent 10.1.2.99)"
  done
  echo "***"
  echo "*** Results of load-balancing to 10.1.2.99: "
  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:10.1.2.99:443)"
  done
  echo "***"
  echo "*** Results of load-balancing to 10.1.2.99: "
  echo "***"
  echo "$RESULTS" | tr ':' '\n' | grep -Ev "^$" | sort | uniq -c
  echo
}

Opzioni di configurazione aggiuntive

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

Abilita accesso globale

Puoi abilitare l'accesso globale per il tuo bilanciatore del carico in modo da renderlo accessibile ai client in tutte le aree geografiche. I backend del tuo bilanciatore del carico di esempio devono comunque trovarsi in una regione (us-west1).

Bilanciatore del carico HTTP(S) interno con accesso globale (fai clic per ingrandire)
Bilanciatore del carico HTTP(S) interno con accesso globale (fai clic per ingrandire)

Non puoi modificare una regola di forwarding a livello di regione esistente per abilitare l'accesso globale. A questo scopo, devi creare una nuova regola di forwarding. Inoltre, dopo aver creato una regola di forwarding con l'accesso globale abilitato, non può essere modificata. Per disabilitare l'accesso globale, devi creare una nuova regola di forwarding per l'accesso a livello di regione ed eliminare la regola di forwarding per l'accesso globale precedente.

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

Console

Non puoi utilizzare Google Cloud Console per abilitare l'accesso globale. Usa l'interfaccia a riga di comando gcloud o l'API REST.

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 una regola di forwarding ha un accesso globale abilitato. Ad esempio:

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

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

Creare una VM client per testare l'accesso globale

Console

  1. In Google Cloud Console, vai alla pagina Istanze VM.

    Vai alle istanze VM

  2. Fai clic su Crea istanza.

  3. Imposta il 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-10 \
    --image-project=debian-cloud \
    --tags=allow-ssh \
    --subnet=europe-subnet

Connettiti al client VM 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
    

Abilita affinità sessione

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

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

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

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

Console

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

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

    Vai a Bilanciamento del carico

  2. 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 fai clic su Modifica.

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

  5. In Affinità sessione, seleziona dal menu il tipo di affinità sessione che preferisci.

  6. Fai clic su Aggiorna.

gcloud

Utilizza i seguenti comandi gcloud per aggiornare il servizio di backend l7-ilb-backend-service 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, effettua una richiesta PATCH al metodo regionBackendServices/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" ]
}

Limita i client che possono inviare traffico al bilanciatore del carico

Puoi impedire ai client di comunicare con un VIP della regola di forwarding per il bilanciatore del carico HTTP(S) interno configurando le 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 specifici delle regole di forwarding per il bilanciatore del carico HTTP(S) interno. Qualsiasi client sulla stessa rete VPC e nella stessa area geografica del VIP della regola di forwarding può in genere inviare traffico alla VIP della regola di forwarding.

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

Ecco alcuni esempi di come utilizzare le regole firewall in uscita per limitare il traffico al VIP per la regola di forwarding del bilanciatore del carico.

Console

Per identificare le VM client, devi codificare le VM specifiche che vuoi limitare. Questi tag vengono utilizzati per associare le regole firewall alle VM client taggate. Poi aggiungi il tag nel campo TARGET_TAG in questi passaggi.

Usa una sola regola firewall o più regole per configurarlo.

Singola regola firewall in uscita

Puoi configurare una regola in uscita dal firewall per rifiutare tutto il traffico in uscita dalle VM client taggate al VIP di un bilanciatore del carico.

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

    Vai a Regole firewall

  2. Fai clic su Crea regola firewall per creare la regola per negare il traffico in uscita dalle VM client taggate al VIP di un bilanciatore del carico.

    • Nome: fr-deny-access
    • Rete: lb-network
    • Priorità: 100
    • Direzione del traffico: in uscita
    • Azione in caso di corrispondenza: rifiuta
    • Target: tag di destinazione specificati
    • Tag di destinazione: TARGET_TAG
    • Filtro di 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 della porta.
  3. Fai clic su Crea.

Più regole firewall in uscita

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

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

    Vai a Regole firewall

  2. Fai clic su Crea regola firewall per creare la regola 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: rifiuta
    • Target: tag di destinazione specificati
    • Tag di destinazione: TARGET_TAG
    • Filtro di 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 della 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 taggate.

    • 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 di 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 della porta.
  5. Fai clic su Crea.

gcloud

Per identificare le VM client, devi codificare le VM specifiche che vuoi limitare. Poi aggiungi il tag nel campo TARGET_TAG in questi passaggi.

Usa una sola regola firewall o più regole per configurarlo.

Singola regola firewall in uscita

Puoi configurare una regola in uscita dal firewall per rifiutare tutto il traffico in uscita dalle VM client taggate al VIP 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 richiede l'impostazione di due regole. Una regola predefinita a bassa priorità che impedisce a tutti i client di accedere al VIP del bilanciatore del carico. Una seconda regola con priorità più elevata consente a un sottoinsieme di client tag di accedere al VIP del bilanciatore del carico. Solo le VM taggate potranno accedere al VIP.

  1. Crea la regola con 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ù elevata:

    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, è sufficiente utilizzare il flag --target-service-accounts anziché il flag --target-tags durante la creazione delle regole firewall.

Scala l'accesso limitato ai backend del bilanciatore del carico HTTP(S) interno in base alle subnet

Mantenere regole firewall separate o aggiungere nuovi IP con bilanciamento del carico alle regole esistenti come descritto nella sezione precedente diventa scomodo quando il numero di regole di forwarding aumenta. Un modo per evitare questo problema è allocare gli indirizzi IP delle regole di forwarding da una subnet riservata. Quindi il traffico da istanze con tag o account di servizio può essere consentito o bloccato utilizzando la subnet riservata come intervallo di destinazione per le regole firewall. Questo consente di controllare in modo efficace l'accesso a un gruppo di VIP con regole di forwarding senza dover gestire le regole in uscita del firewall per VIP.

Ecco i passaggi generali per configurare questa opzione, supponendo che creerai tutte le altre risorse del bilanciatore del carico richieste separatamente.

gcloud

  1. Crea una subnet a livello di area geografica che verrà utilizzata per allocare gli indirizzi IP con bilanciamento del carico per le regole di forwarding:

    gcloud compute networks subnets create l7-ilb-restricted-subnet \
      --network=lb-network \
      --region=us-west1 \
      --range=10.127.0.0/24
    
  2. Creare una regola di forwarding che prende un indirizzo dalla subnet appena allocata. Per questo esempio, abbiamo selezionato 10.127.0.1 dalla subnet 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 delle regole 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
    

Configura impostazione secondaria del backend

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

  • Man mano che il numero di istanze proxy che partecipano al bilanciatore del carico, la dimensione del sottoinsieme diminuisce.

  • 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 per cui è abilitato l'impostazione secondaria del backend.

Questo esempio mostra come creare le risorse interne del bilanciatore del carico HTTP(S) e abilitare l'impostazione secondaria per i backend:

  1. Utilizza l'esempio di configurazione per creare un servizio di backend a livello di regione l7-ilb-backend-service.
  2. Abilita l'impostazione secondaria per il backend specificando --subsetting-policy come CONSISTENT_HASH_SUBSETTING. Lo schema di bilanciamento del carico è INTERNAL_MANAGED.

    gcloud

    Utilizza il comando gcloud seguente per aggiornare l7-ilb-backend-service con l'impostazione secondaria del backend:

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

    API

    Esegui 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 scoprire di più, consulta le norme sul traffico.

Utilizzare un indirizzo IP comune tra più regole di forwarding interno

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

gcloud

gcloud compute addresses create IP_ADDRESS_NAME \
    --region=us-west1 \
    --subnet=backend-subnet \
    --purpose=SHARED_LOADBALANCER_VIP

Se devi reindirizzare il traffico HTTP a HTTPS, puoi creare due regole di forwarding con un indirizzo IP comune. Per ulteriori informazioni, consulta la pagina relativa alla configurazione del reindirizzamento da HTTP a HTTPS per i bilanciatori del carico HTTP(S) interni.

Passaggi successivi