Monitorare le risorse di infrastruttura utilizzando un'applicazione globale di App Hub

Console

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

   Vai a Reti VPC

2. Fai clic su Crea rete VPC.
3. Nel campo Nome, inserisci lb-network.
4. Imposta Modalità di creazione subnet su Personalizzata.

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

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

   • Regione: us-west1

   • Intervallo di indirizzi IP: 10.1.2.0/24

6. Fai clic su Fine.

7. Fai clic su Crea.

gcloud

1. Imposta il progetto come Service Project 1:

     gcloud config set project SERVICE_PROJECT_1_ID

2. Crea una rete VPC con il comando gcloud compute networks create:

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

3. Crea una subnet nella rete lb-network nella regione us-west1:

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

Console

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

   Vai a Reti VPC

2. Fai clic sul nome della rete VPC condiviso: lb-network.
3. Fai clic sulla scheda Subnet e poi su Aggiungi subnet.
4. Nel riquadro Aggiungi una subnet, nel campo Nome, inserisci proxy-only-subnet.
5. Nell'elenco Regione, seleziona us-west1.
6. Imposta Scopo su Proxy gestito a livello di regione.
7. Nel campo 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

Console

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

   Vai a Criteri firewall

2. Fai clic su Crea regola firewall per creare la regola che consente i controlli di integrità 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 e 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 di integrità. Se utilizzi tcp:80 per il protocollo e la porta, Google Cloud può utilizzare HTTP sulla porta 80 per contattare le tue VM, ma non può utilizzare HTTPS sulla porta 443 per contattarle.

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

gcloud

1. Crea la regola firewall fw-allow-health-check per consentire i controlli di integritàGoogle Cloud . Questo esempio consente tutto il traffico TCP dai prober di controllo di integrità. Tuttavia, puoi configurare un insieme più ristretto di porte per soddisfare le tue esigenze.

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

2. Crea la regola firewall fw-allow-proxies per consentire al traffico dalla subnet solo proxy di Envoy di raggiungere i backend:

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

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

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

Console

1. Configura VPC condiviso.

2. Nella console Google Cloud , vai alla pagina VPC condiviso.

   Vai a VPC condiviso

3. Accedi come amministratore del VPC condiviso.

4. Seleziona il progetto di servizio dal selettore di progetti.

5. Vai a Rete VPC >Indirizzi IP.

6. Nella pagina Indirizzi IP, fai clic su Prenota indirizzo IP statico interno.

7. Nel campo Nome, inserisci l7-ilb-ip-address come nome dell'indirizzo IP.

8. Nell'elenco Versione IP, seleziona IPv4.

9. In Rete, seleziona lb-network.

10. Negli elenchi Subnet, seleziona lb-frontend-and-backend-subnet.

11. Fai clic su Prenota.

gcloud

1. Se non l'hai ancora fatto, esegui l'autenticazione in Google Cloud CLI come amministratore del progetto di servizio VPC condiviso.

   gcloud auth login SERVICE_PROJECT_ADMIN
   

   Sostituisci SERVICE_PROJECT_ADMIN con il nome dell'amministratore del progetto di servizio VPC condiviso. Questi valori devono avere il formato nomeutente@tuodominio, ad esempio 222larabrown@gmail.com.

2. Utilizza il comando compute addresses create per prenotare un indirizzo IP:

   
   gcloud compute addresses create l7-ilb-ip-address \
       --project SERVICE_PROJECT_1_ID \
       --subnet=lb-frontend-and-backend-subnet \
       --region=us-west1 \
       --ip-version=IPV4
   

Ulteriori dettagli sulla creazione di indirizzi IP sono pubblicati nella documentazione dell'SDK.

Console

1. Creare un modello di istanza. Nella console Google Cloud , vai alla pagina Modelli di istanza.

   Vai a Modelli di istanza

   1. Fai clic su Crea modello istanza.
   2. Inserisci un nome per il modello di istanza: tutorial-ig-template-sp2.
   3. Nella sezione Località, seleziona Regionale (consigliato) e us-west1(Oregon) come Regione.
   4. Nella sezione Configurazione macchina, seleziona N2 come serie.
   5. 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. Se devi modificare il disco di avvio, fai clic su Cambia.
      1. In Sistema operativo, seleziona Debian.
      2. Per Versione, seleziona una delle immagini Debian disponibili, ad esempio Debian GNU/Linux 12 (bookworm).
      3. Fai clic su Seleziona.
   6. Fai clic su Opzioni avanzate e poi su Networking.
   7. Inserisci i seguenti Tag di rete: allow-ssh,load-balanced-backend.
   8. Nella sezione Interfacce di rete, seleziona Reti condivise con me (dal progetto host: SERVICE_PROJECT_1_ID).
   9. Seleziona la subnet lb-frontend-and-backend-subnet dalla rete lb-network.
   10. Fai clic su Gestione. Per Gestione, inserisci il seguente script nel campo Script di avvio.

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

   11. Fai clic su Crea.

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

   Vai a Gruppi di istanze

   1. Fai clic su Crea gruppo di istanze.
   2. Scegli Nuovo gruppo di istanze gestite (stateless). Per saperne di più, consulta MIG stateless o stateful.
   3. Inserisci un nome per il gruppo di istanze: tutorial-sp2-mig-a.
   4. In Modello di istanza, seleziona tutorial-ig-template-sp2.
   5. Per Località, seleziona Zona singola.
   6. In Regione, seleziona us-west1.

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

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

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

   8. Fai clic su Crea.

3. Crea un servizio di backend regionale. Nell'ambito di questo passaggio, creeremo anche il controllo di integrità e aggiungeremo i backend al servizio di backend. Nella console Google Cloud , vai alla pagina Backend.

   Vai a Backend

   1. Fai clic su Crea servizio di backend.
   2. Nella finestra di dialogo Crea servizio di backend, fai clic su Crea accanto a Servizio di backend regionale.
   3. Inserisci un Nome per il servizio di backend: tutorial-backend-service-sp2.
   4. In Regione, seleziona us-west1.
   5. In Tipo di bilanciatore del carico, seleziona Bilanciatore del carico delle applicazioni interno regionale (INTERNAL_MANAGED).
   6. Imposta Tipo di backend su Gruppo di istanze.
   7. Nella sezione Backend, imposta i seguenti campi:
      1. Imposta Gruppo di istanze su tutorial-sp2-mig-a.
      2. Inserisci i Numeri di porta: 80.
      3. Imposta Modalità di bilanciamento su Utilizzo.
      4. Fai clic su Fine.
   8. Nella sezione Controllo di integrità, fai clic su Crea un controllo di integrità e imposta i seguenti campi:
      1. Nome: tutorial-regional-health-check
      2. Protocollo: HTTP
      3. Porta: 80
      4. Fai clic su Salva.
   9. Fai clic su Continua.
   10. Fai clic su Crea.

4. Ripeti i passaggi precedenti e crea un gruppo di istanze gestite, tutorial-sp2-mig-b e aggiungilo al servizio di backend, tutorial-backend-service-sp2.

gcloud

1. Seleziona il progetto di servizio che hai creato:

   gcloud config set project SERVICE_PROJECT_2_ID

2. Crea un modello di istanza VM, tutorial-ig-template-sp2 con un server HTTP:

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

   Sostituisci quanto segue:

   • SERVICE_PROJECT_1_ID: l'ID progetto del progetto host VPC condiviso.
   • SERVICE_PROJECT_2_ID: l'ID progetto del progetto di servizio in cui vengono creati i backend e il servizio di backend del bilanciatore del carico.

3. Crea un gruppo di istanze gestite, tutorial-sp2-mig-a nella regione:

   gcloud compute instance-groups managed create tutorial-sp2-mig-a \
       --region=us-west1 \
       --size=2 \
       --template=tutorial-ig-template-sp2 \
       --project=SERVICE_PROJECT_2_ID
   

4. Definisci il controllo di integrità HTTP, tutorial-regional-health-check:

   gcloud compute health-checks create http tutorial-regional-health-check \
     --region=us-west1 \
     --use-serving-port \
     --project=SERVICE_PROJECT_2_ID
   

5. Definisci il servizio di backend, tutorial-backend-service-sp2:

   gcloud compute backend-services create tutorial-backend-service-sp2 \
     --load-balancing-scheme=INTERNAL_MANAGED \
     --protocol=HTTP \
     --health-checks=tutorial-regional-health-check \
     --health-checks-region=us-west1 \
     --region=us-west1 \
     --project=SERVICE_PROJECT_2_ID
   

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

   gcloud compute backend-services add-backend tutorial-backend-service-sp2 \
     --balancing-mode=UTILIZATION \
     --instance-group=tutorial-sp2-mig-a \
     --instance-group-region=us-west1 \
     --region=us-west1 \
     --project=SERVICE_PROJECT_2_ID
   

7. Crea un altro gruppo di istanze gestite, tutorial-sp2-mig-b nella regione:

   gcloud compute instance-groups managed create tutorial-sp2-mig-b \
       --region=us-west1 \
       --size=2 \
       --template=tutorial-ig-template-sp2 \
       --project=SERVICE_PROJECT_2_ID
   

8. Aggiungi backend al servizio di backend:

   gcloud compute backend-services add-backend tutorial-backend-service-sp2 \
     --balancing-mode=UTILIZATION \
     --instance-group=tutorial-sp2-mig-b \
     --instance-group-region=us-west1 \
     --region=us-west1 \
     --project=SERVICE_PROJECT_2_ID
   

Console

1. Creare un modello di istanza. Nella console Google Cloud , vai alla pagina Modelli di istanza.

   Vai a Modelli di istanza

   1. Fai clic su Crea modello istanza.
   2. Inserisci un nome per il modello di istanza: tutorial-ig-template-sp3.
   3. Nella sezione Località, seleziona Regionale (consigliato) e us-west1(Oregon) come Regione.
   4. Nella sezione Configurazione macchina, seleziona N2 come serie.
   5. 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. Se devi modificare il disco di avvio, fai clic su Cambia.
      1. In Sistema operativo, seleziona Debian.
      2. Per Versione, seleziona una delle immagini Debian disponibili, ad esempio Debian GNU/Linux 12 (bookworm).
      3. Fai clic su Seleziona.
   6. Fai clic su Opzioni avanzate e poi su Networking.
   7. Inserisci i seguenti Tag di rete: allow-ssh,load-balanced-backend.
   8. Nella sezione Interfacce di rete, seleziona Reti condivise con me (dal progetto host: SERVICE_PROJECT_1_ID).
   9. Seleziona la subnet lb-frontend-and-backend-subnet dalla rete lb-network.
   10. Fai clic su Gestione. Per Gestione, inserisci il seguente script nel campo Script di avvio.

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

   11. Fai clic su Crea.

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

   Vai a Gruppi di istanze

   1. Fai clic su Crea gruppo di istanze.
   2. Scegli Nuovo gruppo di istanze gestite (stateless). Per saperne di più, consulta MIG stateless o stateful.
   3. Inserisci un nome per il gruppo di istanze: tutorial-sp3-mig-a.
   4. In Modello di istanza, seleziona tutorial-ig-template-sp3.
   5. Per Località, seleziona Zona singola.
   6. In Regione, seleziona us-west1.

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

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

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

   8. Fai clic su Crea.

3. Crea un servizio di backend regionale. Nell'ambito di questo passaggio, creeremo anche il controllo di integrità e aggiungeremo i backend al servizio di backend. Nella console Google Cloud , vai alla pagina Backend.

   Vai a Backend

   1. Fai clic su Crea servizio di backend.
   2. Nella finestra di dialogo Crea servizio di backend, fai clic su Crea accanto a Servizio di backend regionale.
   3. Inserisci un Nome per il servizio di backend: tutorial-backend-service-sp3.
   4. In Regione, seleziona us-west1.
   5. In Tipo di bilanciatore del carico, seleziona Bilanciatore del carico delle applicazioni interno regionale (INTERNAL_MANAGED).
   6. Imposta Tipo di backend su Gruppo di istanze.
   7. Nella sezione Backend, imposta i seguenti campi:
      1. Imposta Gruppo di istanze su tutorial-sp3-mig-a.
      2. Inserisci i Numeri di porta: 80.
      3. Imposta Modalità di bilanciamento su Utilizzo.
      4. Fai clic su Fine.
   8. Nella sezione Controllo di integrità, fai clic su Crea un controllo di integrità e imposta i seguenti campi:
      1. Nome: tutorial-regional-health-check
      2. Protocollo: HTTP
      3. Porta: 80
      4. Fai clic su Salva.
   9. Fai clic su Continua.
   10. Fai clic su Crea.

4. Ripeti i passaggi precedenti e crea un gruppo di istanze gestite, tutorial-sp3-mig-b e aggiungilo al servizio di backend, tutorial-backend-service-sp3.

gcloud

1. Seleziona il progetto di servizio che hai creato:

   gcloud config set project SERVICE_PROJECT_3_ID

2. Crea un modello di istanza VM, tutorial-ig-template-sp3 con un server HTTP:

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

   Sostituisci quanto segue:

   • SERVICE_PROJECT_1_ID: l'ID progetto del progetto host VPC condiviso.
   • SERVICE_PROJECT_3_ID: l'ID progetto per il progetto di servizio, in cui vengono creati i backend e il servizio di backend del bilanciatore del carico.

3. Crea un gruppo di istanze gestite, tutorial-sp3-mig-a nella regione:

   gcloud compute instance-groups managed create tutorial-sp3-mig-a \
       --region=us-west1 \
       --size=2 \
       --template=tutorial-ig-template-sp3 \
       --project=SERVICE_PROJECT_3_ID
   

4. Definisci il controllo di integrità HTTP, tutorial-regional-health-check:

   gcloud compute health-checks create http tutorial-regional-health-check \
     --region=us-west1 \
     --use-serving-port \
     --project=SERVICE_PROJECT_3_ID
   

5. Definisci il servizio di backend, tutorial-backend-service-sp3:

   gcloud compute backend-services create tutorial-backend-service-sp3 \
     --load-balancing-scheme=INTERNAL_MANAGED \
     --protocol=HTTP \
     --health-checks=tutorial-regional-health-check \
     --health-checks-region=us-west1 \
     --region=us-west1 \
     --project=SERVICE_PROJECT_3_ID
   

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

   gcloud compute backend-services add-backend tutorial-backend-service-sp3 \
     --balancing-mode=UTILIZATION \
     --instance-group=tutorial-sp3-mig-a \
     --instance-group-region=us-west1 \
     --region=us-west1 \
     --project=SERVICE_PROJECT_3_ID
   

7. Crea un altro gruppo di istanze gestite, tutorial-sp3-mig-b nella regione:

   gcloud compute instance-groups managed create tutorial-sp3-mig-b \
       --region=us-west1 \
       --size=2 \
       --template=tutorial-ig-template-sp3 \
       --project=SERVICE_PROJECT_3_ID
   

8. Aggiungi backend al servizio di backend:

   gcloud compute backend-services add-backend tutorial-backend-service-sp3 \
     --balancing-mode=UTILIZATION \
     --instance-group=tutorial-sp3-mig-b \
     --instance-group-region=us-west1 \
     --region=us-west1 \
     --project=SERVICE_PROJECT_3_ID
   

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

Configurazione di base

1. Inserisci un Nome per il bilanciatore del carico, tutorial-url-maps.
2. Nell'elenco Regione, seleziona us-west1.

3. Nell'elenco Rete, seleziona lb-network (da Progetto: SERVICE_PROJECT_1_ID).

   Se visualizzi l'avviso La subnet solo proxy è obbligatoria nella rete VPC condiviso, conferma che l'amministratore del progetto host abbia creato proxy-only-subnet nella regione us-west1 nella rete VPC condiviso lb-network. La creazione del bilanciatore del carico va a buon fine anche se non hai l'autorizzazione per visualizzare la subnet solo proxy in questa pagina.

4. Tieni aperta la finestra per continuare.

Configura il backend

1. Fai clic su Configurazione backend.
2. Fai clic su Servizi di backend tra progetti.
3. Nel campo ID progetto, inserisci l'ID progetto per il progetto di servizio 2.
4. Nel campo Nome servizio di backend, inserisci il nome del servizio di backend del progetto di servizio 2 che vuoi utilizzare. Per questo esempio, è tutorial-backend-service-sp2.
5. Fai clic su Aggiungi servizio di backend.
6. Nel campo ID progetto, inserisci l'ID progetto per il progetto di servizio 3.
7. Nel campo Nome servizio di backend, inserisci il nome del servizio di backend del progetto di servizio 3 che vuoi utilizzare. Per questo esempio, è tutorial-backend-service-sp3.
8. Fai clic su Aggiungi servizio di backend.

Configura le regole di routing

1. Fai clic su Regole di routing.
2. Nella sezione Regole host e percorso, nel campo Host 2, inserisci *.
3. Nel campo Paths 2 (Percorsi 2), inserisci /*.
4. Nell'elenco a discesa Backend 2, seleziona tutorial-backend-service-sp2.
5. Fai clic su Aggiungi regola host e percorso.
6. Nel campo Host 3, inserisci tutorial-host.
7. Nel campo Paths 3 (Percorsi 3), inserisci /*.

8. Nell'elenco a discesa Backend 3, seleziona tutorial-backend-service-sp3.

9. Cerca il segno di spunta blu a sinistra di Regole host e percorso e fai clic sul pulsante Aggiorna.

   Per informazioni sulla gestione del traffico, vedi Configurare la gestione del traffico.

Configura il frontend

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

1. Fai clic su Configurazione frontend.
2. Inserisci un nome per la regola di forwarding: l7-ilb-forwarding-rule.
3. Imposta Protocollo su HTTP.
4. Imposta Subnet su lb-frontend-and-backend-subnet. Non selezionare la subnet solo proxy per il frontend anche se è un'opzione nell'elenco.
5. Imposta Porta su 80.
6. Nel campo Indirizzo IP, mantieni l'opzione predefinita Temporaneo (automatico).
7. Fai clic su Fine.

Rivedi e finalizza la configurazione

• Fai clic su Crea.

gcloud

1. Seleziona il progetto di servizio che hai creato:

   gcloud config set project SERVICE_PROJECT_1_ID

2. Crea la mappa URL, tutorial-url-maps e imposta il servizio predefinito sul servizio di backend creato nel progetto di servizio 1:

   gcloud compute url-maps create tutorial-url-maps \
       --default-service=projects/SERVICE_PROJECT_2_ID/regions/us-west1/backendServices/tutorial-backend-service-sp2 \
       --region=us-west1 \
       --project=SERVICE_PROJECT_1_ID
   

   Sostituisci quanto segue:

   • SERVICE_PROJECT_2_ID: l'ID progetto per Service Project 2, in cui vengono creati i backend del bilanciatore del carico e il servizio di backend.
   • SERVICE_PROJECT_1_ID: l'ID progetto per Service Project 1, in cui viene creato il frontend del bilanciatore del carico.

3. Crea il proxy di destinazione tutorial-http-proxy:

   gcloud compute target-http-proxies create tutorial-http-proxy \
     --url-map=tutorial-url-maps \
     --url-map-region=us-west1 \
     --region=us-west1 \
     --project=SERVICE_PROJECT_1_ID
   

4. Crea la regola di forwarding l7-ilb-forwarding-rule per gestire il traffico HTTP. Affinché il riferimento ai servizi tra progetti funzioni, la regola di forwarding deve utilizzare la stessa rete (lb-network) del progetto host VPC condiviso utilizzata per creare il servizio di backend.

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

5. Per inviare traffico al servizio di backend, collega la mappa URL al servizio di backend. Per ulteriori informazioni, vedi Utilizzare le mappe degli URL.

   1. Collega il servizio di backend tutorial-backend-service-sp2 nel progetto di servizio 2 alla mappa URL tutorial-url-maps e al nome del matcher di percorso tutorial-path-matcher-sp2:

      gcloud compute url-maps add-path-matcher tutorial-url-maps \
         --path-matcher-name=tutorial-path-matcher-sp2 \
         --default-service=projects/SERVICE_PROJECT_2_ID/regions/us-west1/backendServices/tutorial-backend-service-sp2 \
         --region=us-west1
      

   2. Collega il servizio di backend, tutorial-backend-service-sp3 nel progetto di servizio 3, alla mappa URL, tutorial-url-maps, e al nome del matcher di percorso, tutorial-path-matcher-sp3. Aggiungi una nuova regola host, tutorial-host con gli host specificati in modo che il matcher di percorso sia associato alla nuova regola host

      gcloud compute url-maps add-path-matcher tutorial-url-maps \
        --path-matcher-name=tutorial-path-matcher-sp3 \
        --default-service=projects/SERVICE_PROJECT_3_ID/regions/us-west1/backendServices/tutorial-backend-service-sp3 \
        --region=us-west1 \
        --new-hosts=tutorial-host
      

Console

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

   Vai a Istanze VM

2. Fai clic su Crea istanza.

3. Nel campo Nome, inserisci client-vm.

4. Imposta Zona su us-west1-b.

5. Fai clic su Opzioni avanzate e poi su Networking.

6. Inserisci i seguenti Tag di rete: allow-ssh,load-balanced-backend.

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

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

9. Fai clic su Crea.

gcloud

Crea un'istanza VM di test.

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

Console

1. Nella console Google Cloud , vai alla pagina di selezione del progetto.

   Vai al selettore dei progetti

2. Seleziona il progetto host di App Hub.

3. Nella console Google Cloud vai alla pagina IAM.

   Vai a IAM

4. Fai clic su person_addConcedi l'accesso. Si apre il riquadro Concedi l'accesso.

5. Nel campo Nuove entità, inserisci l'indirizzo email della persona che amministrerà App Hub, ovvero il ruolo Amministratore App Hub nel progetto host di App Hub.

6. Fai clic su Seleziona un ruolo e nel campo Filtro inserisci App Hub.

7. Seleziona il ruolo Amministratore App Hub e fai clic su Salva.

8. In ciascuno dei progetti di servizio App Hub, concedi lo stesso utente il ruolo Amministratore App Hub.

gcloud

1. Per concedere i ruoli alle persone che utilizzeranno App Hub, ripeti il seguente comando sostituendo i ruoli IAM, se necessario. Per ulteriori informazioni, consulta Ruoli e autorizzazioni di App Hub.

   gcloud projects add-iam-policy-binding HOST_PROJECT_ID \
       --member='user:HOST_PROJECT_ADMIN' \
       --role='roles/apphub.admin'

   Sostituisci HOST_PROJECT_ADMIN con l'utente che ha il ruolo di amministratore App Hub nel progetto host App Hub. Questo valore ha il formato username@yourdomain, ad esempio 222larabrown@gmail.com.

2. Concedi il ruolo Amministratore App Hub nel progetto di servizio alle persone che amministrano App Hub. Per aggiungere progetti di servizio al progetto host, devono disporre del ruolo di amministratore di App Hub. Per ogni progetto di servizio è necessaria almeno una persona con questo ruolo.

   gcloud projects add-iam-policy-binding SERVICE_PROJECT_ID \
      --member='user:HOST_PROJECT_ADMIN' \
      --role='roles/apphub.admin'

   Sostituisci SERVICE_PROJECT_ID con l'ID dei progetti di servizio.

Console

1. Nella Google Cloud console, vai alla pagina Impostazioni di App Hub.

   Vai alle impostazioni

2. Nella pagina Impostazioni, fai clic su Allega progetti.

3. Nel riquadro che si apre, cerca i progetti nell'elenco visualizzato e seleziona le caselle di controllo per i progetti che vuoi aggiungere come progetti di servizio.

4. Fai clic su Seleziona. La tabella Progetti di servizio collegati mostra i progetti di servizio selezionati.

5. Fai clic su Chiudi.

gcloud

1. Collega i progetti di servizio 1, 2 e 3 al progetto host App Hub.

   gcloud apphub service-projects add SERVICE_PROJECT_1_ID \
     --project=HOST_PROJECT_ID
   

   gcloud apphub service-projects add SERVICE_PROJECT_2_ID \
     --project=HOST_PROJECT_ID
   

   gcloud apphub service-projects add SERVICE_PROJECT_3_ID \
     --project=HOST_PROJECT_ID
   

2. Conferma di aver collegato i progetti di servizio App Hub al progetto host App Hub:

   gcloud apphub service-projects list --project=HOST_PROJECT_ID
   

Console

1. Assicurati di trovarti nel progetto host di App Hub.

2. Nella console Google Cloud , vai alla pagina Applicazioni di App Hub.

   Vai a Applicazioni

3. Fai clic su Crea applicazione.

4. Nella pagina Crea applicazione, seleziona Globale nel riquadro Scegli la regione e il nome dell'applicazione.

5. Nel campo Nome applicazione, inserisci tutorial-application. Questo nome è un identificatore univoco ed è immutabile dopo la creazione dell'applicazione.

6. Inserisci un Nome visualizzato, Tutorial e fai clic su Continua. Si tratta di un nome intuitivo che puoi aggiornare. Per ulteriori informazioni, vedi Aggiornare un'applicazione esistente.

7. Nel riquadro Aggiungi attributi, seleziona Alta dall'elenco Criticità. La criticità indica quanto un'applicazione, un servizio o un workload è fondamentale per le tue operazioni aziendali.

8. Nel campo Ambiente, per indicare la fase del ciclo di vita del software, seleziona Produzione.

9. Fai clic su Continua.

10. Nel riquadro Aggiungi proprietari, aggiungi i seguenti dettagli per Proprietari sviluppatori, Proprietari operatori e Proprietari dell'attività. Tieni presente che devi inserire l'indirizzo email del proprietario se aggiungi un nome visualizzato.

    1. Inserisci un nome visualizzato del proprietario.
    2. Inserisci l'indirizzo email del proprietario. Questo valore deve avere il formato username@yourdomain, ad esempio 222larabrown@gmail.com.

11. Ripeti questi passaggi per ogni sviluppatore, operatore e proprietario dell'attività.

12. Fai clic su Crea.

La nuova applicazione viene creata ed è elencata nella pagina Applicazioni. Tieni presente che solo la regola di forwarding, la mappa URL, il servizio di backend e il gruppo di istanze gestite (MIG) diventano disponibili come risorse individuate nell'applicazione App Hub. Per maggiori informazioni, consulta la sezione Concetti e modello di dati.

gcloud

1. Seleziona il progetto host di App Hub che hai creato:

   gcloud config set project HOST_PROJECT_ID

2. Crea una nuova applicazione denominata tutorial-application nella regione global e assegnale un nome visualizzato, Tutorial. Il nome dell'applicazione, tutorial-application è un identificatore univoco e non può essere modificato dopo la creazione dell'applicazione. Il nome visualizzato,Tutorial è un nome facile da usare che puoi aggiornare. Per ulteriori informazioni, vedi Aggiornare un'applicazione esistente.

   gcloud apphub applications create tutorial-application \
       --display-name='Tutorial' \
       --scope-type=GLOBAL \
       --project=HOST_PROJECT_ID \
       --location=global
   

3. Elenca le applicazioni nel progetto host App Hub:

   gcloud apphub applications list \
       --project=HOST_PROJECT_ID \
       --location=global
   

   Vedi un output simile al seguente:

   ID                    DISPLAY_NAME  CREATE_TIME
   tutorial-application  Tutorial      2023-10-31T18:33:48
   

4. Aggiorna la tua applicazione con gli attributi criticality-type, environment-type e proprietario:

   gcloud apphub applications update tutorial-application \
     --criticality-type='HIGH' \
     --environment-type='PRODUCTION' \
     --developer-owners=display-name=DISPLAY-NAME-DEVELOPER,email=EMAIL-DEVELOPER \
     --operator-owners=display-name=DISPLAY-NAME-OPERATOR,email=EMAIL-OPERATOR \
     --business-owners=display-name=DISPLAY-NAME-BUSINESS,email=EMAIL-BUSINESS \
     --project=HOST_PROJECT_ID \
     --location=global
   

   Sostituisci quanto segue:

   • DISPLAY-NAME-DEVELOPER, DISPLAY-NAME-OPERATOR e DISPLAY-NAME-BUSINESS: nomi visualizzati dello sviluppatore, dell'operatore e dei proprietari dell'attività, rispettivamente.
   • EMAIL-NAME-DEVELOPER, EMAIL-NAME-OPERATOR e EMAIL-NAME-BUSINESS: indirizzi email rispettivamente dello sviluppatore, dell'operatore e dei proprietari dell'attività. Questi valori devono avere il formato username@yourdomain, ad esempio, 222larabrown@gmail.com.

   Note:

   • criticality-type: indica la criticità di un'applicazione, di un servizio o di un workload per le operazioni aziendali.
   • environment-type: indica le fasi del ciclo di vita del software.

5. Recupera i dettagli dell'applicazione che hai creato:

   gcloud apphub applications describe tutorial-application \
     --project=HOST_PROJECT_ID \
     --location=global
   

   Il comando restituisce informazioni in formato YAML, simili alle seguenti:

   attributes:
   businessOwners:
   – displayName: [DISPLAY-NAME-BUSINESS]
     email: [EMAIL-BUSINESS]
   criticality:
     type: HIGH
   developerOwners:
   – displayName: [DISPLAY-NAME-DEVELOPER]
     email: [EMAIL-DEVELOPER]
   environment:
     type: PRODUCTION
   operatorOwners:
   – displayName: [DISPLAY-NAME-OPERATOR]
     email: [EMAIL-OPERATOR]
   createTime: '2023-10-31T18:33:48.199394108Z'
   displayName: Tutorial
   name: projects/HOST_PROJECT_ID/locations/global/applications/tutorial-application
   scope:
     type: REGIONAL
   state: ACTIVE
   uid: 9d991a9d-5d8a-4c0d-b5fd-85e39fb58c73
   updateTime: '2023-10-31T18:33:48.343303819Z'
   

Console

1. Nella console Google Cloud , vai alla pagina Applicazioni di App Hub.

   Vai a Applicazioni

2. Fai clic sul nome dell'applicazione, Tutorial. Viene visualizzata la scheda Servizi e workload con un elenco di servizi e workload registrati che si trovano nei progetti di servizio App Hub.

3. Registra un servizio:

   1. Nella scheda Servizi e workload, fai clic su Registra servizio/workload.
   2. Nella pagina Registra servizio o carico di lavoro, nel riquadro Seleziona risorsa, fai clic su Sfoglia per selezionare il servizio o il carico di lavoro come Risorsa.
   3. Nel riquadro Seleziona risorsa, scegli il Nome del servizio, tutorial-backend-service-sp2, e fai clic su Seleziona.
   4. Nel riquadro Seleziona risorsa, inserisci il Nome della risorsa, tutorial-service-backend-sp2.
   5. Inserisci un Nome visualizzato, Backend service (SP2) e fai clic su Continua.
   6. Nel riquadro Aggiungi attributi, nell'elenco Criticità, per indicare l'importanza dell'applicazione, seleziona Alta.
   7. Nel campo Ambiente, per indicare la fase del ciclo di vita del software, seleziona Produzione.
   8. Fai clic su Continua.
   9. Nel riquadro Aggiungi proprietari, aggiungi i seguenti dettagli in base alle esigenze per Proprietari sviluppatori, Proprietari operatori e Proprietari dell'attività. Tieni presente che devi inserire l'indirizzo email del proprietario se aggiungi un nome visualizzato.
      1. Inserisci un nome visualizzato del proprietario.
      2. Inserisci l'indirizzo email del proprietario. Questo valore deve avere il formato username@yourdomain, ad esempio 222larabrown@gmail.com.
   10. Ripeti questi passaggi per ogni sviluppatore, operatore e proprietario dell'attività.
   11. Fai clic su Register (Registrati).

   Nella scheda Servizi e carichi di lavoro, nella sezione Servizi e carichi di lavoro registrati, puoi visualizzare il nuovo servizio aggiunto.

4. Ripeti i passaggi precedenti per registrare gli altri servizi come tutorial-service-backend-sp3, tutorial-service-forwarding-rule e tutorial-service-url-map, rispettivamente.
5. Registra un workload ripetendo i passaggi precedenti per registrare un servizio con le seguenti eccezioni:
   1. Nel riquadro Registra servizio o workload, nella sezione Scegli servizio o workload, seleziona il Nome del workload, tutorial-sp2-mig-a, e fai clic su Continua.
   2. Nel riquadro Seleziona risorsa, inserisci il Nome della risorsa, tutorial-workload-sp2-mig-a.
   3. Inserisci un Nome visualizzato, Instance group - A (SP2) e fai clic su Continua.
6. Ripeti i passaggi precedenti per registrare gli altri workload come tutorial-workload-sp2-mig-a, tutorial-workload-sp2-mig-b, tutorial-workload-sp3-mig-a e tutorial-workload-sp3-mig-b, rispettivamente.

gcloud

1. Aggiungi una persona con autorizzazioni Editor di App Hub:

   gcloud projects add-iam-policy-binding HOST_PROJECT_ID \
     --member='user:APP_HUB_EDITOR' \
     --role='roles/apphub.editor'
   

   Sostituisci APP_HUB_EDITOR con l'utente che ha il ruolo Editor App Hub nel progetto host App Hub. Questo valore ha il formato username@yourdomain, ad esempio, 222larabrown@gmail.com.

2. Elenca tutti i servizi rilevati nel progetto host App Hub. Questo comando restituisce i servizi che possono essere registrati in un'applicazione.

   gcloud apphub discovered-services list \
       --project=HOST_PROJECT_ID \
       --location=us-west1
   

   Vedi un output simile al seguente:

   ID                             SERVICE_REFERENCE                                                                                                                      SERVICE_PROPERTIES
   BACKEND_SERVICE_SP2_ID      {'uri': '//compute.googleapis.com/projects/[SERVICE_PROJECT_2_NUMBER]/regions/us-west1/backendServices/tutorial-backend-service-sp2'}  {'gcpProject': 'projects/SERVICE_PROJECT_2_ID', 'location': 'us-west1'}
   BACKEND_SERVICE_SP3_ID      {'uri': '//compute.googleapis.com/projects/[SERVICE_PROJECT_3_NUMBER]/regions/us-west1/backendServices/tutorial-backend-service-sp3'}  {'gcpProject': 'projects/SERVICE_PROJECT_3_ID', 'location': 'us-west1'}
   FORWARDING_RULE_SERVICE_ID  {'uri': '//compute.googleapis.com/projects/[SERVICE_PROJECT_1_NUMBER]/regions/us-west1/forwardingRules/l7-ilb-forwarding-rule'}        {'gcpProject': 'projects/SERVICE_PROJECT_1_ID', 'location': 'us-west1'}
   URL_MAP_SERVICE_ID          {'uri': '//compute.googleapis.com/projects/[SERVICE_PROJECT_1_NUMBER]/regions/us-west1/urlMaps/tutorial-url-maps'}                     {'gcpProject': 'projects/SERVICE_PROJECT_1_ID', 'location': 'us-west1'}
   

   Copia i servizi ID, ad esempio BACKEND_SERVICE_SP2_ID dall'output da utilizzare nel passaggio successivo.

3. Registra i servizi del passaggio precedente nella tua applicazione. Copia gli ID servizio dal campo di output del passaggio precedente.

   gcloud apphub applications services create tutorial-service-backend-sp2 \
       --discovered-service='projects/HOST_PROJECT_ID/locations/us-west1/discoveredServices/BACKEND_SERVICE_SP2_ID' \
       --display-name='Backend service (SP2)' \
       --criticality-type='HIGH' \
       --environment-type='PRODUCTION' \
       --application=tutorial-application \
       --project=HOST_PROJECT_ID \
       --location=global
   

   gcloud apphub applications services create tutorial-service-backend-sp3 \
       --discovered-service='projects/HOST_PROJECT_ID/locations/us-west1/discoveredServices/BACKEND_SERVICE_SP3_ID' \
       --display-name='Backend service (SP3)' \
       --criticality-type='HIGH' \
       --environment-type='PRODUCTION' \
       --application=tutorial-application \
       --project=HOST_PROJECT_ID \
       --location=global
   

   gcloud apphub applications services create tutorial-service-forwarding-rule \
       --discovered-service='projects/HOST_PROJECT_ID/locations/us-west1/discoveredServices/FORWARDING_RULE_SERVICE_ID' \
       --display-name='Forwarding rule' \
       --criticality-type='HIGH' \
       --environment-type='PRODUCTION' \
       --application=tutorial-application \
       --project=HOST_PROJECT_ID \
       --location=global
   

   gcloud apphub applications services create tutorial-service-url-map \
       --discovered-service='projects/HOST_PROJECT_ID/locations/us-west1/discoveredServices/URL_MAP_SERVICE_ID' \
       --display-name='URL map' \
       --criticality-type='HIGH' \
       --environment-type='PRODUCTION' \
       --application=tutorial-application \
       --project=HOST_PROJECT_ID \
       --location=global
   

   Sostituisci quanto segue:

   • BACKEND_SERVICE_SP2_ID: il servizio ID del servizio di backend del progetto di servizio 2 che vuoi registrare.
   • BACKEND_SERVICE_SP3_ID: il servizio ID del servizio di backend del progetto di servizio 3 che vuoi registrare.
   • FORWARDING_RULE_SERVICE_ID: il servizio ID della regola di forwarding del progetto di servizio 1 che vuoi registrare.
   • URL_MAP_SERVICE_ID: il servizio ID della mappa URL del progetto di servizio 1 che vuoi registrare.

4. Elenca tutti i servizi registrati nell'applicazione:

   gcloud apphub applications services list \
       --application=tutorial-application \
       --project=HOST_PROJECT_ID \
       --location=global
   

   Vedi un output simile al seguente:

   ID                               DISPLAY_NAME      SERVICE_REFERENCE                                                                                                                       CREATE_TIME
   tutorial-service-backend-sp2     Backend service   {'uri': '//compute.googleapis.com/projects/[SERVICE_PROJECT_2_NUMBER]/regions/us-west1/backendServices/tutorial-backend-service-sp2'}   2024-02-13T00:31:45
   tutorial-service-backend-sp3     Backend service   {'uri': '//compute.googleapis.com/projects/[SERVICE_PROJECT_3_NUMBER]/regions/us-west1/backendServices/tutorial-backend-service-sp3'}   2024-02-13T00:31:45
   tutorial-service-forwarding-rule Forwarding rule   {'uri': '//compute.googleapis.com/projects/[SERVICE_PROJECT_1_NUMBER]/regions/us-west1/forwardingRules/l7-ilb-forwarding-rule'}         2024-02-13T00:31:45
   tutorial-service-url-map         URL map           {'uri': '//compute.googleapis.com/projects/[SERVICE_PROJECT_1_NUMBER]/regions/us-west1/urlMaps/tutorial-url-maps'}                      2024-02-13T00:31:45
   

   I servizi registrati, ma separati, sono indicati da un valore vuoto nel campo SERVICE_REFERENCE. Per ulteriori informazioni sugli stati di registrazione, consulta le proprietà e gli attributi di App Hub.

5. Elenca tutti i workload rilevati nel progetto host di App Hub. Questo comando restituisce i workload disponibili per la registrazione a un'applicazione.

   gcloud apphub discovered-workloads list \
       --project=HOST_PROJECT_ID \
       --location=global
   

   Vedi un output simile al seguente:

   ID                            WORKLOAD_REFERENCE                                                                                                          WORKLOAD_PROPERTIES
   INSTANCE_GROUP_SP3_A_ID    {'uri': '//compute.googleapis.com/projects/[SERVICE_PROJECT_3_NUMBER]/zones/us-west1-a/instanceGroups/tutorial-sp3-mig-a'}  {'gcpProject': 'projects/SERVICE_PROJECT_3_ID', 'location': 'us-west1'}
   INSTANCE_GROUP_SP3_B_ID    {'uri': '//compute.googleapis.com/projects/[SERVICE_PROJECT_3_NUMBER]/zones/us-west1-a/instanceGroups/tutorial-sp3-mig-b'}  {'gcpProject': 'projects/SERVICE_PROJECT_3_ID', 'location': 'us-west1'}
   INSTANCE_GROUP_SP2_A_ID    {'uri': '//compute.googleapis.com/projects/[SERVICE_PROJECT_2_NUMBER]/zones/us-west1-a/instanceGroups/tutorial-sp2-mig-a'}  {'gcpProject': 'projects/SERVICE_PROJECT_2_ID', 'location': 'us-west1'}
   INSTANCE_GROUP_SP2_B_ID    {'uri': '//compute.googleapis.com/projects/[SERVICE_PROJECT_2_NUMBER]/zones/us-west1-a/instanceGroups/tutorial-sp2-mig-b'}  {'gcpProject': 'projects/SERVICE_PROJECT_2_ID', 'location': 'us-west1'}
   

   Copia l'ID workload dall'output da utilizzare nel passaggio successivo.

6. Registra i workload del passaggio precedente nella tua applicazione. Copia l'ID carico di lavoro dal campo di output del passaggio precedente.

   gcloud apphub applications workloads create tutorial-workload-sp3-mig-a \
       --discovered-workload='projects/HOST_PROJECT_ID/locations/us-west1/discoveredWorkloads/INSTANCE_GROUP_SP3_A_ID' \
       --display-name='Workload instance group (SP3-A)' \
       --application=tutorial-application \
       --project=HOST_PROJECT_ID \
       --location=global
   

   gcloud apphub applications workloads create tutorial-workload-sp3-mig-b \
       --discovered-workload='projects/HOST_PROJECT_ID/locations/us-west1/discoveredWorkloads/INSTANCE_GROUP_SP3_B_ID' \
       --display-name='Workload instance group (SP3-B)' \
       --application=tutorial-application \
       --project=HOST_PROJECT_ID \
       --location=global
   

   gcloud apphub applications workloads create tutorial-workload-sp2-mig-a \
       --discovered-workload='projects/HOST_PROJECT_ID/locations/us-west1/discoveredWorkloads/INSTANCE_GROUP_SP2_A_ID' \
       --display-name='Workload instance group (SP2-A)' \
       --application=tutorial-application \
       --project=HOST_PROJECT_ID \
       --location=global
   

   gcloud apphub applications workloads create tutorial-workload-sp2-mig-b \
       --discovered-workload='projects/HOST_PROJECT_ID/locations/us-west1/discoveredWorkloads/INSTANCE_GROUP_SP2_B_ID' \
       --display-name='Workload instance group (SP2-B)' \
       --application=tutorial-application \
       --project=HOST_PROJECT_ID \
       --location=global
   

   Sostituisci quanto segue:

   • INSTANCE_GROUP_SP3_A_ID, INSTANCE_GROUP_SP3_B_ID: i workload ID dei gruppi di istanze gestite del progetto di servizio 3 che vuoi registrare.
   • INSTANCE_GROUP_SP2_A_ID, INSTANCE_GROUP_SP2_B_ID: i ID dei gruppi di istanze gestite del progetto di servizio 2 che vuoi registrare.

7. Elenca tutti i carichi di lavoro registrati nell'applicazione:

   gcloud apphub applications workloads list \
       --application=tutorial-application \
       --project=HOST_PROJECT_ID \
       --location=global
   

   Vedi un output simile al seguente:

   ID                              DISPLAY_NAME                      SERVICE_REFERENCE                                                                                                            CREATE_TIME
   tutorial-workload-sp3-mig-a     Workload instance group (SP3-A)   {'uri': '//compute.googleapis.com/projects/[SERVICE_PROJECT_3_NUMBER]/zones/us-west1-a/instanceGroups/tutorial-sp3-mig-a'}   2024-02-13T00:31:45
   tutorial-workload-sp3-mig-b     Workload instance group (SP3-B)   {'uri': '//compute.googleapis.com/projects/[SERVICE_PROJECT_3_NUMBER]/zones/us-west1-a/instanceGroups/tutorial-sp3-mig-b'}   2024-02-13T00:31:45
   tutorial-workload-sp2-mig-a     Workload instance group (SP2-A)   {'uri': '//compute.googleapis.com/projects/[SERVICE_PROJECT_2_NUMBER]/zones/us-west1-a/instanceGroups/tutorial-sp2-mig-a'}   2024-02-13T00:31:45
   tutorial-workload-sp2-mig-b     Workload instance group (SP2-B)   {'uri': '//compute.googleapis.com/projects/[SERVICE_PROJECT_2_NUMBER]/zones/us-west1-a/instanceGroups/tutorial-sp2-mig-b'}   2024-02-13T00:31:45
   

   I workload registrati, ma separati, sono indicati da un valore vuoto nel campo WORKLOAD_REFERENCE. Per ulteriori informazioni sugli stati di registrazione, consulta le proprietà e gli attributi di App Hub.