Crea un servizio con bilanciamento del carico

Questo tutorial mostra come, in qualità di produttore di servizi, puoi creare un semplice servizio che utilizza un bilanciatore del carico di rete passthrough interno. Per impostazione predefinita, un bilanciatore del carico di rete passthrough interno è disponibile solo dall'interno della rete VPC che lo ospita.

Questo tutorial è rivolto ad architetti cloud, architetti di rete, amministratori di rete e amministratori IT.

Obiettivi

Configura il networking per le risorse del producer di servizi
Crea risorse VM per il backend del bilanciatore del carico
Configura i componenti del bilanciatore del carico
Testa l'accesso al bilanciatore del carico

Costi

In questo documento vengono utilizzati i seguenti componenti fatturabili di Google Cloud:

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il Calcolatore prezzi.

I nuovi utenti di Google Cloud potrebbero avere diritto a una prova senza costi.

Al termine delle attività descritte in questo documento, puoi evitare l'addebito di ulteriori costi eliminando le risorse che hai creato. Per saperne di più, consulta Esegui la pulizia.

Prima di iniziare

Crea o seleziona un progetto da utilizzare per le risorse producer di servizi. Questo progetto viene chiamato PRODUCER_PROJECT nei tutorial successivi

In the Google Cloud console, go to the project selector page.

Go to project selector
Select or create a Google Cloud project.
Roles required to select or create a project
- Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
- Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.
Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

Enable the Compute Engine API.
Roles required to enable APIs
To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.
Enable the API

Make sure that you have the following role or roles on the project: Compute Engine > Compute Network Admin, Compute Engine > Compute Security Admin, Compute Engine > Compute Instance Admin
Check for the roles
1. In the Google Cloud console, go to the IAM page.
  Go to IAM
2. Select the project.
3. In the Principal column, find all rows that identify you or a group that you're included in. To learn which groups you're included in, contact your administrator.
4. For all rows that specify or include you, check the Role column to see whether the list of roles includes the required roles.
Grant the roles
1. In the Google Cloud console, go to the IAM page.
  Vai a IAM
2. Seleziona il progetto.
3. Fai clic su Concedi l'accesso.
4. Nel campo Nuove entità, inserisci il tuo identificatore dell'utente. In genere si tratta dell'indirizzo email di un Account Google.
5. Fai clic su Seleziona un ruolo, quindi cerca il ruolo.
6. Per concedere altri ruoli, fai clic su Aggiungi un altro ruolo e aggiungi ogni ruolo successivo.
7. Fai clic su Salva.

Configura il networking

Le sezioni seguenti spiegano come creare una rete, una subnet e regole firewall per il servizio.

Configura una rete e una subnet

Per creare la rete di servizio e la subnet per il bilanciatore del carico, completa i passaggi nelle sezioni seguenti.

Console

Nella console Google Cloud , vai alla pagina Reti VPC.

Vai a Reti VPC
Fai clic su Crea rete VPC.
In Nome, inserisci service-network.
In Modalità di creazione subnet, seleziona Personalizzata.
Nella sezione Nuova subnet, inserisci le seguenti informazioni.
1. In Nome, inserisci service-subnet.
2. In Regione, seleziona la regione che vuoi utilizzare.
3. In Tipo di stack IP, seleziona IPv4 (stack singolo).
4. In Intervallo IPv4, inserisci 10.10.10.0/24.
5. Fai clic su Fine.
Fai clic su Crea.

gcloud

Crea una rete VPC in modalità personalizzata:

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

Nella rete service-network, crea una subnet.

gcloud compute networks subnets create service-subnet \
    --network=service-network \
    --range=10.10.10.0/24 \
    --region=REGION

Sostituisci REGION con la regione che vuoi utilizzare.

Configura le regole firewall

Crea regole firewall per consentire il seguente traffico:

fw-allow-subnet: consente al traffico proveniente da 10.10.10.0/24 di raggiungere altre risorse in 10.10.10.0/24.
fw-allow-ssh: consente al traffico SSH da 0.0.0.0/0 di raggiungere le VM che hanno il tag di rete allow-ssh.
fw-allow-healthcheck: consente al traffico dei sistemi di controllo di integrità Google Clouddi raggiungere le VM con il tag di rete allow-healthcheck.

Console

Nella console Google Cloud , vai alla pagina Policy del firewall.

Vai a Criteri firewall
Per consentire il traffico nella subnet, fai clic su Crea regola firewall e utilizza le seguenti impostazioni:
- In Nome, inserisci fw-allow-subnet.
- In Rete, seleziona service-network.
- In Priorità, inserisci 1000.
- Per Direzione del traffico, seleziona In entrata.
- In Azione in caso di corrispondenza, seleziona Consenti.
- In Destinazioni, seleziona Tutte le istanze nella rete.
- In Filtro di origine, seleziona Intervalli IPv4.
- In Intervalli IPv4 di origine, inserisci 10.10.10.0/24.
- In Protocolli e porte, seleziona Consenti tutto.
Fai clic su Crea.
Per consentire le connessioni SSH in entrata, fai clic su Crea regola firewall e utilizza le seguenti impostazioni:
- In Nome, inserisci fw-allow-ssh.
- In Rete, seleziona service-network.
- In Priorità, inserisci 1000.
- Per Direzione del traffico, seleziona In entrata.
- In Azione in caso di corrispondenza, seleziona Consenti.
- In Destinazioni, seleziona Tag di destinazione specificati.
- In Tag di destinazione, inserisci allow-ssh.
- In Filtro di origine, seleziona Intervalli IPv4.
- In Intervalli IPv4 di origine, inserisci 0.0.0.0/0.
- In Protocolli e porte, seleziona Protocolli e porte specificati, seleziona la casella di controllo TCP. In Porte, inserisci 22.
Fai clic su Crea.
Per consentire i controlli di integrità Google Cloud , fai clic su Crea regola firewall e utilizza le seguenti impostazioni:
- In Nome, inserisci fw-allow-healthcheck.
- In Rete, seleziona service-network.
- In Priorità, inserisci 1000.
- Per Direzione del traffico, seleziona In entrata.
- In Azione in caso di corrispondenza, seleziona Consenti.
- In Destinazioni, seleziona Tag di destinazione specificati.
- In Tag di destinazione, inserisci allow-healthcheck.
- In Filtro di origine, seleziona Intervalli IPv4.
- In Intervalli IPv4 di origine, inserisci 130.211.0.0/22 e 35.191.0.0/16.
- In Protocolli e porte, seleziona Consenti tutto.
Fai clic su Crea.

gcloud

Crea la regola firewall fw-allow-subnet per consentire la comunicazione dall'interno della subnet:

gcloud compute firewall-rules create fw-allow-subnet \
    --network=service-network \
    --action=allow \
    --direction=ingress \
    --source-ranges=10.10.10.0/24 \
    --rules=tcp,udp,icmp

Crea la regola firewall fw-allow-ssh per consentire la connettività SSH alle VM con il tag di rete allow-ssh.

gcloud compute firewall-rules create fw-allow-ssh \
    --network=service-network \
    --action=allow \
    --direction=ingress \
    --source-ranges=0.0.0.0/0 \
    --target-tags=allow-ssh \
    --rules=tcp:22

Crea la regola fw-allow-healthcheck per consentire i controlli di integrità Google Cloud.

gcloud compute firewall-rules create fw-allow-healthcheck \
    --network=service-network \
    --action=allow \
    --direction=ingress \
    --target-tags=allow-healthcheck \
    --source-ranges=130.211.0.0/22,35.191.0.0/16 \
    --rules=tcp,udp,icmp

Crea risorse VM per il backend del bilanciatore del carico

Crea le VM e il gruppo di istanze da utilizzare con il bilanciatore del carico.

Crea VM di backend

Il servizio che stai creando viene eseguito su due VM per una maggiore disponibilità: vm-1 e vm-2. Le VM si trovano nella stessa zona, ma in un ambiente di produzione, ti consigliamo di utilizzare più zone.

Oltre a creare le VM, questi passaggi consentono di:

Configura le VM in modo che utilizzino i tag di rete che hai configurato come destinazioni nelle regole firewall e un tag di rete aggiuntivo (allow-nat) che verrà utilizzato in un secondo momento.
Installa, configura e avvia il servizio Apache.

Console

Nella console Google Cloud , vai alla pagina Istanze VM.

Vai a Istanze VM
Fai clic su Crea istanza.
In Nome, inserisci vm-1.
Per Regione e Zona, seleziona una regione e una zona all'interno di quella regione.
Nel menu di navigazione, vai a Sistema operativo e spazio di archiviazione.
Nel riquadro Sistema operativo e spazio di archiviazione, assicurati che sia selezionata l'opzione Debian GNU/Linux 12 (bookworm) per il disco di avvio. Se devi selezionare un'altra immagine, fai clic su Cambia.
Nel menu di navigazione, vai a Networking.
In Tag di rete, inserisci allow-ssh, allow-healthcheck e allow-nat.
In Interfacce di rete, seleziona quanto segue:
- In Rete, seleziona service-network.
- In Subnet, seleziona service-subnet.
- In Tipo di stack IP, seleziona IPv4 (stack singolo).
- Per Indirizzo IPv4 interno principale, seleziona Temporaneo (automatico).
- Per Indirizzo IPv4 esterno, seleziona Temporaneo.
Nel menu di navigazione, vai ad Avanzate.

Nella sezione Automazione, nel campo Script di avvio, inserisci il seguente script.


#! /bin/bash
if [ -f /etc/startup_script_completed ]; then
exit 0
fi
apt-get update
apt-get install apache2 -y
a2ensite default-ssl
a2enmod ssl
file_ports="/etc/apache2/ports.conf"
file_http_site="/etc/apache2/sites-available/000-default.conf"
file_https_site="/etc/apache2/sites-available/default-ssl.conf"
http_listen_prts="Listen 80\nListen 8008\nListen 8080\nListen 8088"
http_vh_prts="*:80 *:8008 *:8080 *:8088"
https_listen_prts="Listen 443\nListen 8443"
https_vh_prts="*:443 *:8443"
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
prt_conf="$(cat "$file_ports")"
prt_conf_2="$(echo "$prt_conf" | sed "s|Listen 80|${http_listen_prts}|")"
prt_conf="$(echo "$prt_conf_2" | sed "s|Listen 443|${https_listen_prts}|")"
echo "$prt_conf" | tee "$file_ports"
http_site_conf="$(cat "$file_http_site")"
http_site_conf_2="$(echo "$http_site_conf" | sed "s|*:80|${http_vh_prts}|")"
echo "$http_site_conf_2" | tee "$file_http_site"
https_site_conf="$(cat "$file_https_site")"
https_site_conf_2="$(echo "$https_site_conf" | sed "s|_default_:443|${https_vh_prts}|")"
echo "$https_site_conf_2" | tee "$file_https_site"
systemctl restart apache2
touch /etc/startup_script_completed

Fai clic su Crea.
Ripeti questi passaggi per creare un'altra VM denominata vm-2 nella stessa regione e zona di vm-1.

gcloud

Crea due VM eseguendo i seguenti comandi:

gcloud compute instances create vm-1 \
    --zone=ZONE \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --tags=allow-ssh,allow-healthcheck,allow-nat \
    --subnet=service-subnet \
    --metadata=startup-script='#! /bin/bash
if [ -f /etc/startup_script_completed ]; then
exit 0
fi
apt-get update
apt-get install apache2 -y
a2ensite default-ssl
a2enmod ssl
file_ports="/etc/apache2/ports.conf"
file_http_site="/etc/apache2/sites-available/000-default.conf"
file_https_site="/etc/apache2/sites-available/default-ssl.conf"
http_listen_prts="Listen 80\nListen 8008\nListen 8080\nListen 8088"
http_vh_prts="*:80 *:8008 *:8080 *:8088"
https_listen_prts="Listen 443\nListen 8443"
https_vh_prts="*:443 *:8443"
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
prt_conf="$(cat "$file_ports")"
prt_conf_2="$(echo "$prt_conf" | sed "s|Listen 80|${http_listen_prts}|")"
prt_conf="$(echo "$prt_conf_2" | sed "s|Listen 443|${https_listen_prts}|")"
echo "$prt_conf" | tee "$file_ports"
http_site_conf="$(cat "$file_http_site")"
http_site_conf_2="$(echo "$http_site_conf" | sed "s|*:80|${http_vh_prts}|")"
echo "$http_site_conf_2" | tee "$file_http_site"
https_site_conf="$(cat "$file_https_site")"
https_site_conf_2="$(echo "$https_site_conf" | sed "s|_default_:443|${https_vh_prts}|")"
echo "$https_site_conf_2" | tee "$file_https_site"
systemctl restart apache2
touch /etc/startup_script_completed'

gcloud compute instances create vm-2 \
    --zone=ZONE \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --tags=allow-ssh,allow-healthcheck,allow-nati \
    --subnet=service-subnet \
    --metadata=startup-script='#! /bin/bash
if [ -f /etc/startup_script_completed ]; then
exit 0
fi
apt-get update
apt-get install apache2 -y
a2ensite default-ssl
a2enmod ssl
file_ports="/etc/apache2/ports.conf"
file_http_site="/etc/apache2/sites-available/000-default.conf"
file_https_site="/etc/apache2/sites-available/default-ssl.conf"
http_listen_prts="Listen 80\nListen 8008\nListen 8080\nListen 8088"
http_vh_prts="*:80 *:8008 *:8080 *:8088"
https_listen_prts="Listen 443\nListen 8443"
https_vh_prts="*:443 *:8443"
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
prt_conf="$(cat "$file_ports")"
prt_conf_2="$(echo "$prt_conf" | sed "s|Listen 80|${http_listen_prts}|")"
prt_conf="$(echo "$prt_conf_2" | sed "s|Listen 443|${https_listen_prts}|")"
echo "$prt_conf" | tee "$file_ports"
http_site_conf="$(cat "$file_http_site")"
http_site_conf_2="$(echo "$http_site_conf" | sed "s|*:80|${http_vh_prts}|")"
echo "$http_site_conf_2" | tee "$file_http_site"
https_site_conf="$(cat "$file_https_site")"
https_site_conf_2="$(echo "$https_site_conf" | sed "s|_default_:443|${https_vh_prts}|")"
echo "$https_site_conf_2" | tee "$file_https_site"
systemctl restart apache2
touch /etc/startup_script_completed'

Sostituisci ZONE con la zona che vuoi utilizzare.

Crea un gruppo di istanze

Per utilizzare le VM in un backend del bilanciatore del carico, devi aggiungerle a un gruppo di istanze.

Console

Nella console Google Cloud , vai alla pagina Gruppi di istanze.

Vai a Gruppi di istanze
Fai clic su Crea gruppo di istanze.
Nel riquadro di navigazione, fai clic su Nuovo gruppo di istanze non gestite.
In Nome, inserisci ig-1.
Nella sezione Località, seleziona la stessa regione e la stessa zona delle tue VM.
In Rete, seleziona service-network.
In Subnet, seleziona service-subnet.
Nella sezione Istanze VM, aggiungi vm-1 e vm-2 al gruppo di istanze.
Fai clic su Crea.

gcloud

Crea un gruppo di istanze non gestito:
```
gcloud compute instance-groups unmanaged create ig-1 \
    --zone=ZONE
```
Sostituisci ZONE con la zona che contiene le VM.

Aggiungi le VM al gruppo di istanze:

gcloud compute instance-groups unmanaged add-instances ig-1 \
    --zone=ZONE \
    --instances=vm-1,vm-2

Configura i componenti del bilanciatore del carico

Configura tutti i componenti del bilanciatore del carico di rete passthrough interno a partire dal controllo di integrità e dal servizio di backend, fino ai componenti frontend:

Controllo di integrità. Utilizzi un controllo di integrità HTTP che verifica la presenza di un codice di stato HTTP 200 OK.
Servizio di backend. Poiché devi trasmettere il traffico HTTP attraverso il bilanciatore del carico interno, devi utilizzare TCP, anziché UDP.
Regola di forwarding. Crea una singola regola di forwarding interno, service-rule.
Indirizzo IP interno. Specifichi un indirizzo IP interno, 10.10.10.99, quando crei la regola di forwarding.

Console

Avvia la configurazione

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

Vai a Bilanciamento del carico
Fai clic su Crea bilanciatore del carico.
In Tipo di bilanciatore del carico, seleziona Bilanciatore del carico di rete (TCP/UDP/SSL) e fai clic su Avanti.
Per Proxy o passthrough, seleziona Bilanciatore del carico passthrough e fai clic su Avanti.
In Pubblico o interno, seleziona Interno e fai clic su Avanti.
Fai clic su Configura.

Configurazione di base

Nella pagina Crea bilanciatore del carico di rete passthrough interno, inserisci le seguenti informazioni:

In Nome bilanciatore del carico, inserisci service-lb.
In Regione, seleziona la stessa regione delle tue VM.
In Rete, seleziona service-network.

Configura i backend

Fai clic su Configurazione backend.
Nell'elenco Controllo di integrità, fai clic su Crea un controllo di integrità e inserisci le seguenti informazioni:
- In Nome, inserisci hc-http-80.
- In Protocollo, seleziona HTTP.
- In Porta, inserisci 80.
- Per Protocollo proxy, seleziona NONE.
- In Percorso richiesta, inserisci /.
Fai clic su Crea.
Nella sezione Nuovo backend di Backend, seleziona IPv4 (stack singolo).
In Gruppo di istanze, seleziona il gruppo di istanze ig-1 e fai clic su Fine.
Verifica che sia presente un segno di spunta blu accanto a Configurazione backend prima di continuare.

Configura il frontend

Fai clic su Configurazione frontend.
Nella sezione Nuovi IP e porta frontend, segui questi passaggi:
1. In Nome, inserisci service-rule.
2. In Subnet, seleziona service-subnet.
3. Nella sezione Scopo IP interno, nell'elenco Indirizzo IP, seleziona Crea indirizzo IP e inserisci le seguenti informazioni:
  - In Nome, inserisci service-rule-ip.
  - In Versione IP, seleziona IPv4.
  - In Indirizzo IP statico, seleziona Scelta manuale.
  - In Indirizzo IP personalizzato, inserisci 10.10.10.99.
4. Fai clic su Prenota.
5. In Porte, seleziona Singola, quindi in Numeri di porta inserisci 80.
6. Fai clic su Fine.
7. Verifica che sia presente un segno di spunta blu accanto a Configurazione frontend prima di continuare.

Esamina la configurazione

Fai clic su Esamina e finalizza.
Rivedi le impostazioni di configurazione del bilanciatore del carico.
Fai clic su Crea.

gcloud

Crea un nuovo controllo di integrità HTTP regionale per testare la connettività HTTP alle VM sulla porta 80.
```
gcloud compute health-checks create http hc-http-80 \
    --region=REGION \
    --port=80
```
Sostituisci REGION con la stessa regione delle VM di backend.

Crea il servizio di backend per il traffico HTTP:

gcloud compute backend-services create service-lb \
    --load-balancing-scheme=internal \
    --protocol=tcp \
    --region=REGION \
    --health-checks=hc-http-80 \
    --health-checks-region=REGION

Sostituisci REGION con la stessa regione delle VM di backend.

Aggiungi il gruppo di istanze al servizio di backend:
```
gcloud compute backend-services add-backend service-lb \
    --region=REGION \
    --instance-group=ig-1 \
    --instance-group-zone=ZONE
```
Sostituisci quanto segue:
- REGION: la stessa regione delle VM di backend.
- ZONE: la stessa zona delle VM di backend.

Crea una regola di forwarding per il servizio di backend:

gcloud compute forwarding-rules create service-rule \
    --region=REGION \
    --load-balancing-scheme=internal \
    --network=service-network \
    --subnet=service-subnet \
    --address=10.10.10.99 \
    --ip-protocol=TCP \
    --ports=80 \
    --backend-service=service-lb \
    --backend-service-region=REGION

Sostituisci REGION con la stessa regione delle VM di backend.

Testa l'accesso al bilanciatore del carico

Per verificare che il bilanciatore del carico funzioni, crea una VM di test e invia una richiesta da questa al bilanciatore del carico.

Crea una VM client per i test

Crea una VM client nella stessa regione delle VM di backend (server).

Console

Nella console Google Cloud , vai alla pagina Istanze VM.

Vai a Istanze VM
Fai clic su Crea istanza.
In Nome, inserisci producer-test.
Per Regione, seleziona la stessa regione delle VM di backend.
In Zona, seleziona una zona in quella regione.
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:
  - In Rete, seleziona service-network.
  - In Subnet, seleziona service-subnet.
Fai clic su Crea.

gcloud

gcloud compute instances create producer-test \
    --zone=ZONE \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --tags=allow-ssh \
    --subnet=service-subnet

Sostituisci ZONE con una zona che si trova nella stessa regione delle VM di backend.

Testa la connettività

Questo test contatta il bilanciatore del carico da una VM client. Il comportamento previsto è che il traffico venga distribuito tra le VM di backend del bilanciatore del carico.

Connettiti all'istanza VM client.
```
gcloud compute ssh producer-test --zone=ZONE
```
Sostituisci ZONE con la zona della VM client.
Invia una richiesta web al bilanciatore del carico utilizzando curl per contattare il relativo indirizzo IP. Ripeti la richiesta per vedere che le risposte provengono da diverse VM di backend. Il nome della VM che genera la risposta viene visualizzato nel testo della risposta HTML a causa dei contenuti di /var/www/html/index.html su ogni VM di backend. Ad esempio, le risposte previste sono simili a Page served from: vm-1 e Page served from: vm-2.
```
curl -s http://10.10.10.99
```

Passaggi successivi

Rendi il servizio accessibile da altre reti VPC

Crea un servizio con bilanciamento del carico Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Obiettivi

Costi

Prima di iniziare

Check for the roles

Grant the roles

Configura il networking

Configura una rete e una subnet

Console

gcloud

Configura le regole firewall

Console

gcloud

Crea risorse VM per il backend del bilanciatore del carico

Crea VM di backend

Console

gcloud

Crea un gruppo di istanze

Console

gcloud

Configura i componenti del bilanciatore del carico

Console

Avvia la configurazione

Configurazione di base

Configura i backend

Configura il frontend

Esamina la configurazione

gcloud

Testa l'accesso al bilanciatore del carico

Crea una VM client per i test

Console

gcloud

Testa la connettività

Passaggi successivi

Crea un servizio con bilanciamento del carico