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


App Hub ti consente di gestire e visualizzare le risorse di infrastruttura da Google Cloud tramite le applicazioni App Hub. Per creare queste applicazioni App Hub, devi avere un progetto host App Hub a cui puoi collegare progetti di servizio contenenti risorse Google Cloud .

Questo tutorial mostra come configurare un'applicazione App Hub globale per più progetti e visualizzare le risorse dell'applicazione. Utilizzando più progetti di servizio, puoi configurare un bilanciatore del carico delle applicazioni interno in un ambiente VPC condiviso. Poi, in un'applicazione globale nel progetto host App Hub, registri e monitori tutte le risorse di infrastruttura dei progetti di servizio come servizi e workload di App Hub.

Questo tutorial è rivolto a chi configura e amministra App Hub. Dovresti avere una certa esperienza con Cloud Load Balancing.

Obiettivi

  • Configura un'applicazione Global App Hub contenente risorse su più progetti.
  • Monitora le risorse tramite le metriche di sistema per l'applicazione.

Costi

Per una stima del costo delle risorse Google Cloud utilizzate dalla soluzione di VM gestite con bilanciamento del carico, consulta la stima precalcolata nel Calcolatore prezzi di .

Utilizza la stima come punto di partenza per calcolare il costo del deployment. Puoi modificare la stima in base alle modifiche di configurazione che prevedi di apportare alle risorse utilizzate nella soluzione.

La stima precalcolata si basa su ipotesi relative a determinati fattori, tra cui:

  • Le località Google Cloud in cui vengono implementate le risorse.
  • La durata dell'utilizzo delle risorse.

Per ulteriori informazioni sui costi di App Hub, consulta la pagina Prezzi.

Prima di iniziare

Prima di configurare questo tutorial, decidi i ruoli e le autorizzazioni per i tuoi progetti, quindi crea quattro progetti Google Cloud . Uno di questi progetti è il progetto host di App Hub e gli altri tre sono progetti di servizio di App Hub.

Ruoli e autorizzazioni richiesti

Se sei il creator del progetto, ti viene concesso il ruolo di proprietario di base (roles/owner). Per impostazione predefinita, questo ruolo IAM include le autorizzazioni necessarie per l'accesso completo alla maggior parte delle risorse di Google Cloud.

Se non sei il creator del progetto, le autorizzazioni richieste devono essere concesse al principale appropriato. Ad esempio, un'entità può essere un Account Google (per gli utenti finali) o un account di servizio (per le applicazioni e i carichi di lavoro).

Per ottenere le autorizzazioni necessarie per gestire l'accesso a un progetto, a una cartella o a un'organizzazione, chiedi all'amministratore di concederti i seguenti ruoli IAM per la risorsa per cui vuoi gestire l'accesso (progetto, cartella o organizzazione):

Per saperne di più sulla concessione dei ruoli, consulta Gestire l'accesso a progetti, cartelle e organizzazioni.

Potresti anche riuscire a ottenere le autorizzazioni richieste tramite i ruoli personalizzati o altri ruoli predefiniti.

Creare progetti di servizi e host di App Hub

Console

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

    Vai al selettore dei progetti

  2. Seleziona o crea un progetto Google Cloud da utilizzare come progetto di hosting di App Hub.

  3. Enable the App Hub, Compute Engine, Service Management, and Service Usage APIs.

    Enable the APIs

  4. Nella stessa cartella del progetto host App Hub, crea tre nuovi progetti Google Cloud . Questi sono i progetti di servizio App Hub per il progetto host App Hub.

  5. Assicurati che la fatturazione sia attivata per tutti i tuoi progetti Google Cloud .

  6. Enable the App Hub, Compute Engine, Service Management, and Service Usage APIs.

    Enable the APIs

gcloud

  1. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

  2. Assicurati che sia installata la versione più recente di Google Cloud CLI. Esegui il seguente comando da Cloud Shell:

      gcloud components update

  3. Crea o seleziona un nuovo progetto,HOST_PROJECT_ID, da utilizzare come progetto host per App Hub.

    • Crea un progetto Google Cloud :

      gcloud projects create HOST_PROJECT_ID
    • Seleziona il progetto Google Cloud che hai creato:

      gcloud config set project HOST_PROJECT_ID
  4. Assicurati che la fatturazione sia attivata per tutti i tuoi progetti Google Cloud .

  5. Abilita le API App Hub, Compute Engine, Service Management e Service Usage:

    gcloud services enable apphub.googleapis.com \
       compute.googleapis.com \
       servicemanagement.googleapis.com \
       serviceusage.googleapis.com
  6. Crea tre nuovi progetti Google Cloud da utilizzare come progetti di servizio App Hub per il progetto host App Hub.

    1. Crea un progetto di servizio:

      gcloud projects create SERVICE_PROJECT_1_ID

      Sostituisci SERVICE_PROJECT_1_ID con l'ID del progetto di servizio 1.

    2. Seleziona il progetto di servizio che hai creato:

      gcloud config set project SERVICE_PROJECT_1_ID
    3. Abilita le API Compute Engine, Service Management e Service Usage:

      gcloud services enable compute.googleapis.com \
        servicemanagement.googleapis.com \
        serviceusage.googleapis.com
    4. Imposta la variabile di configurazione utilizzata in questo tutorial:

      export SERVICE_PROJECT_1_NUMBER= $(gcloud projects describe $(gcloud config get-value project) --format='value(projectNumber)')
    5. Ripeti il passaggio precedente per creare SERVICE_PROJECT_2_ID e SERVICE_PROJECT_3_ID, abilitare le API e impostare la variabile di configurazione.

Prepara l'ambiente

Se hai già configurato un bilanciatore del carico delle applicazioni interno in un ambiente VPC condiviso in più progetti, vai alla sezione Concedere autorizzazioni IAM di questo documento.

In caso contrario, per configurare un bilanciatore del carico delle applicazioni interno in un ambiente VPC condiviso:

Carichi di lavoro e servizi di App Hub con un bilanciatore del carico e un gruppo di istanze gestite.
Figura 1. Carichi di lavoro e servizi App Hub con un bilanciatore del carico e gruppi di istanze gestite in un VPC condiviso.
  1. Nel progetto di servizio 1, configura una rete VPC condiviso e due subnet.
  2. Nel progetto di servizio 2, crea il servizio di backend del bilanciatore del carico con due gruppi di istanze gestite come backend.
  3. Nel progetto di servizi 3, crea un altro servizio di backend del bilanciatore del carico con due gruppi di istanze gestite come backend.
  4. Nel progetto di servizio 1, crea i componenti frontend e la mappa URL del bilanciatore del carico.

Di seguito è riportato il flusso di elaborazione delle richieste della topologia di cui viene eseguito il deployment dalla soluzione di VM gestite con bilanciamento del carico.

  1. Dalla rete VPC condiviso, la VM client invia una richiesta HTTP al bilanciatore del carico delle applicazioni interno nel progetto di servizio 1.

  2. Il bilanciatore del carico utilizza le informazioni nella mappa URL e nei servizi di backend per instradare la richiesta ai backend del gruppo di istanze gestite.

Configura la rete e le subnet nel progetto host VPC condiviso

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

Questo esempio utilizza la seguente rete, regione e subnet:

  • Rete. La rete si chiama lb-network.

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

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

In questo tutorial, designa il progetto di servizio 1 come progetto host VPC condiviso. Tutti i passaggi di questa sezione devono essere eseguiti nel progetto di servizio 1.

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

Questo passaggio non deve essere eseguito ogni volta che vuoi creare un nuovo bilanciatore del carico. Devi solo assicurarti che i progetti di servizio abbiano accesso a una subnet nella rete VPC condiviso (oltre alla subnet solo proxy).

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 Progetto di servizio 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
    

Configura la subnet solo proxy

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

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

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 sottorete, inserisci proxy-only-subnet nel campo Nome.
  5. Nell'elenco Regione, seleziona us-west1.
  6. Imposta Finalità 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

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

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

Un amministratore VPC condiviso deve concedere l'accesso alla subnet di backend agli amministratori dei progetti di servizio (o agli sviluppatori che eseguono il deployment di risorse e backend che utilizzano la subnet). Per le istruzioni, consulta Amministratori dei progetti di servizio per alcune subnet.

Configura le regole del firewall nel progetto di servizio 1

Questo esempio utilizza le seguenti regole firewall:

  • fw-allow-health-check. Una regola in entrata, applicabile alle istanze bilanciate in base al carico, che consente tutto il traffico TCP proveniente dai sistemi di controllo di integrità di Google Cloudin 130.211.0.0/22 e 35.191.0.0/16. Questo esempio utilizza il tag di destinazione load-balanced-backend per identificare le istanze a cui deve essere applicato.

  • fw-allow-proxies. Una regola di ingresso, applicabile alle istanze bilanciate in base al carico, che consente il traffico TCP sulle porte 80, 443 e 8080 dai proxy gestiti del bilanciatore del carico. Questo esempio utilizza il tag target load-balanced-backend per identificare le istanze a cui deve essere applicato.

  • fw-allow-ssh. Una regola in entrata, applicabile alle istanze sottoposte a bilanciamento del carico, che consente la connettività SSH in entrata sulla porta TCP 22 da qualsiasi indirizzo. Puoi scegliere un intervallo IP di origine più restrittivo per questa regola. Ad esempio, puoi specificare solo gli intervalli IP del sistema da cui avvii le sessioni SSH. Questo esempio utilizza il tag di destinazione allow-ssh per identificare le macchine virtuali (VM) a cui si applica la regola firewall.

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

Console

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

    Vai a Policy del firewall

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

  3. Fai clic su Crea.
  4. Fai clic su Crea regola firewall per creare la regola per consentire i controlli di integrità di Google Cloud :
    • Nome: fw-allow-proxies
    • Rete: lb-network
    • Direzione del traffico: In entrata
    • Azione in caso di corrispondenza: Consenti
    • Target: Tag di destinazione specificati
    • Tag di destinazione: load-balanced-backend
    • Filtro di origine: Intervalli IPv4
    • Intervalli IPv4 di origine: 10.129.0.0/23
    • Protocolli e porte:
      • Scegli Protocolli e porte specificati.
      • Seleziona 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 per consentire i controlli di integrità di Google Cloud :
    • Nome: fw-allow-ssh
    • Rete: lb-network
    • Direzione del traffico: In entrata
    • Azione in caso di corrispondenza: Consenti
    • Target: Tag di destinazione specificati
    • Tag di destinazione: allow-ssh
    • Filtro di origine: Intervalli IPv4
    • Intervalli IPv4 di origine: 0.0.0.0/0
    • Protocolli e porte:
      • Scegli Protocolli e porte specificati.
      • Seleziona 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à diGoogle Cloud . Questo esempio consente tutto il traffico TCP proveniente dai probe del controllo di integrità. Tuttavia, puoi configurare un insieme più ristretto di porte per soddisfare le tue esigenze.

    gcloud compute firewall-rules create fw-allow-health-check \
       --network=lb-network \
       --action=allow \
       --direction=ingress \
       --source-ranges=130.211.0.0/22,35.191.0.0/16 \
       --target-tags=load-balanced-backend \
       --rules=tcp
    
  2. Crea la regola firewall fw-allow-proxies per consentire al traffico proveniente dalla subnet solo proxy di Envoy di raggiungere i tuoi backend:

    gcloud compute firewall-rules create fw-allow-proxies \
       --network=lb-network \
       --action=allow \
       --direction=ingress \
       --source-ranges=10.129.0.0/23 \
       --target-tags=load-balanced-backend \
       --rules=tcp:80,tcp:443,tcp:8080
    
  3. Crea la regola firewall fw-allow-ssh per consentire la connettività SSH alle VM con il tag di rete allow-ssh:

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

Prenota un indirizzo IPv4 interno statico

Gli amministratori dei progetti di servizio possono prenotare un indirizzo IPv4 o IPv6 interno in una subnet di una rete VPC condiviso. L'oggetto di configurazione dell'indirizzo IP viene creato nel progetto di servizio, mentre il relativo valore proviene dall'intervallo di indirizzi IPv4 disponibili nella subnet condivisa scelta.

Per prenotare un indirizzo IP interno autonomo nel progetto di servizio, completa i seguenti passaggi.

Console

  1. Configura la rete VPC condivisa.
  2. Nella console Google Cloud , vai alla pagina VPC condivisa.

    Vai a Rete VPC condivisa

  3. Accedi come amministratore VPC condiviso.

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

  5. Vai a Rete VPC >Indirizzi IP.

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

  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 utente@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 per la creazione di indirizzi IP sono pubblicati nella documentazione dell'SDK.

Configura il VPC condiviso nel progetto di servizio 1

Per configurare il VPC condiviso nel progetto di servizio 1, designa il progetto di servizio 1 come progetto host VPC condiviso e i progetti di servizio 2 e 3 come progetti di servizio VPC condiviso. Più avanti in questo tutorial, quando crei i backend MIG nei progetti di servizio 2 e 3, potrai utilizzare la stessa rete VPC e le stesse subnet create in precedenza nel progetto di servizio 1.

  1. Attiva un progetto host.
  2. Collega un progetto di servizio.
  3. Concedi il ruolo Utente di rete Compute (roles/compute.networkUser) ai progetti di servizio 2 e 3:

    Console

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

      Vai a IAM

    2. Fai clic su Concedi accesso. Viene visualizzato il riquadro Concedi l'accesso.

    3. Nel campo Nuove entità, inserisci SERVICE_PROJECT_2_NUMBER@cloudservices.gserviceaccount.com.

      Tieni presente che puoi ottenere i numeri dei progetti di servizio dalla dashboard del progetto:

      Vai alla Dashboard

    4. Fai clic su Seleziona un ruolo e nel campo Filtro, inserisci Compute Network User.

    5. Seleziona il ruolo Utente rete Compute e fai clic su Salva.

    6. Ripeti i passaggi precedenti per concedere il ruolo Compute Network User al progetto di servizio 3 (SERVICE_PROJECT_3_NUMBER@cloudservices.gserviceaccount.com).

    gcloud

    1. Nel progetto di servizio 1, concedi il ruolo Utente di rete Compute al progetto di servizio 2.

      gcloud projects add-iam-policy-binding SERVICE_PROJECT_1_ID \
       --member='serviceAccount:SERVICE_PROJECT_2_NUMBER@cloudservices.gserviceaccount.com' \
       --role='roles/compute.networkUser'
      

      Sostituisci SERVICE_PROJECT_2_NUMBER con il numero del progetto del progetto di servizio 2.

    2. Nel progetto di servizio 1, concedi il ruolo Utente di rete Compute al progetto di servizio 3.

      gcloud projects add-iam-policy-binding SERVICE_PROJECT_1_ID \
       --member='serviceAccount::SERVICE_PROJECT_3_NUMBER@cloudservices.gserviceaccount.com' \
       --role='roles/compute.networkUser'
      

      Sostituisci SERVICE_PROJECT_3_NUMBER con il numero del progetto del progetto di servizio 3.

Crea un servizio di backend e MIG nel progetto di servizi 2

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

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 che sono disponibili solo su Debian, ad esempio apt-get. Se devi cambiare 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, selezionare 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 ulteriori informazioni, consulta Gruppi di istanze gestite 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. In Località, seleziona Zona singola.
    6. In Regione, seleziona us-west1.
    7. Specifica il numero di istanze da 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 a livello di regione (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 del progetto host VPC condiviso.
    • SERVICE_PROJECT_2_ID: l'ID progetto del progetto di servizio in cui vengono creati i backend del bilanciatore del carico e il servizio di backend.
  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 i 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 i 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
    

Crea un servizio di backend e MIG nel progetto di servizi 3

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

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 che sono disponibili solo su Debian, ad esempio apt-get. Se devi cambiare 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, selezionare 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 ulteriori informazioni, consulta Gruppi di istanze gestite 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. In Località, seleziona Zona singola.
    6. In Regione, seleziona us-west1.
    7. Specifica il numero di istanze da 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 a livello di regione (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 del progetto host VPC condiviso.
    • SERVICE_PROJECT_3_ID: l'ID progetto del progetto di servizio in cui vengono creati i backend del bilanciatore del carico e il servizio di backend.
  3. Crea un gruppo di istanze gestitetutorial-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 i 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 i 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
    

Crea la mappa URL e regola di forwarding nel progetto di servizio 1

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

Console

Avvia la configurazione

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

    Vai a Bilanciamento del carico

  2. Fai clic su Crea bilanciatore del carico.
  3. In Tipo di bilanciatore del carico, seleziona Bilanciatore del carico delle applicazioni (HTTP/HTTPS) e fai clic su Avanti.
  4. In Pubblico o interno, seleziona Interno e fai clic su Avanti.
  5. In Deployment tra regioni o in una regione singola, seleziona Ideale per workload regionali e fai clic su Avanti.
  6. Fai clic su Configura.

Configurazione di base

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

  4. Tieni aperta la finestra per continuare.

Configura il backend

  1. Fai clic su Configurazione backend.
  2. Fai clic su Servizi di backend tra progetti.
  3. 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, si tratta di 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. In questo esempio, si tratta di 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, inserisci * nel campo Host 2.
  3. Nel campo 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 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 sottorete 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 Ephemeral (Automatic) (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 il progetto di servizio 2, in cui vengono creati i backend del bilanciatore del carico e il servizio di backend.
    • SERVICE_PROJECT_1_ID: l'ID progetto per il progetto di servizio 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 inoltro 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, consulta Utilizzare le mappe di URL.

    1. Collega il servizio di backend tutorial-backend-service-sp2 nel progetto di servizio 2 con la mappa URL tutorial-url-maps e il nome del corrispettivo 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 con la mappa di URL tutorial-url-maps e il nome del corrispettivo del percorso tutorial-path-matcher-sp3. Aggiungi una nuova regola host, tutorial-host con gli host specificati in modo che il matcher dei percorsi 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
      

Testa il bilanciatore del carico

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

Crea un'istanza VM di test

I client possono trovarsi nel progetto host VPC condiviso o in qualsiasi progetto di servizio collegato. In questo esempio, verifichi il funzionamento del bilanciatore del carico eseguendo il deployment di una VM client nel progetto di servizio 1 designato come progetto host VPC condiviso. Il client deve utilizzare la stessa rete VPC condiviso e trovarsi nella stessa regione del bilanciatore del carico.

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

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, selezionare 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

Invia traffico al bilanciatore del carico

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

  1. Recupera il valore dell'indirizzo IP del bilanciatore del carico:

    gcloud compute addresses list --filter="name=( 'l7-ilb-ip-address')"
    

    Viene visualizzato un output simile al seguente:

    NAME: l7-ilb-ip-address
    ADDRESS/RANGE: 10.1.2.2
    TYPE: INTERNAL
    PURPOSE: GCE_ENDPOINT
    NETWORK:
    REGION: us-west1
    SUBNET: lb-frontend-and-backend-subnet
    STATUS: IN_USE
    

    Copia il servizio ADDRESS/RANGE, ad esempio 10.1.2.2, dall'output da utilizzare nei passaggi successivi.

  2. Connettiti all'istanza client con SSH:

    gcloud compute ssh client-vm \
       --zone=us-west1-b \
       --project=SERVICE_PROJECT_2_ID
    
  3. Verifica che l'indirizzo IP del bilanciatore del carico gestisca il relativo nome host:

    1. Verifica che l'indirizzo IP stia pubblicando il nome host nel progetto di servizio 2:

      curl 10.1.2.2
      

      Viene visualizzato un output simile al seguente:

      Page served from: tutorial-sp2-mig-a-10xk
      

    2. Verifica che l'indirizzo IP stia pubblicando il nome host nel progetto di servizio 3:

      curl -H "Host: tutorial-host" 10.1.2.2
      

      Viene visualizzato un output simile al seguente:

      Page served from: tutorial-sp3-mig-a-3d5h
      

Concedi autorizzazioni IAM

Fornisci i ruoli e le autorizzazioni IAM appropriati ai progetti di servizio e host di App Hub.

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 Concedi accesso. Viene visualizzato 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 ogni progetto di servizio App Hub, concedi lo stesso ruolo di amministratore di App Hub allo stesso utente.

gcloud

  1. Per concedere i ruoli alle persone che utilizzeranno App Hub, ripeti il seguente comando sostituendo i ruoli IAM, come richiesto. 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 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 di App Hub nel progetto di servizio alle persone che amministrano App Hub. Deve disporre del ruolo di amministratore di App Hub per aggiungere progetti di servizio al progetto host. 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.

Collega i progetti di servizio

I progetti di servizio sono progetti Google Cloud che contengono risorse di infrastruttura che puoi registrare a un'applicazione App Hub. Per maggiori informazioni, consulta Progetti di servizi. Collega i progetti di servizio su cui hai disegnato le risorse al progetto host App Hub.

Console

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

    Vai alle impostazioni

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

  3. Nel riquadro visualizzato, cerca i progetti nell'elenco visualizzato e seleziona le caselle di controllo per i progetti da aggiungere come progetti di servizi.

  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. Verifica di aver collegato i progetti di servizio App Hub al progetto host App Hub:

    gcloud apphub service-projects list --project=HOST_PROJECT_ID
    

Dopo aver collegato il progetto di servizio al progetto host di App Hub, puoi visualizzare tutte le risorse Google Cloud dal progetto di servizio collegato come servizi e carichi di lavoro di App Hub rilevati. Per ulteriori informazioni su come visualizzare questi servizi e carichi di lavoro rilevati, consulta Visualizzare applicazioni, servizi e carichi di lavoro esistenti.

Crea un'applicazione

Crea un'applicazione che fungerà da contenitore dei tuoi servizi e workload. Quando crei un'applicazione, puoi assegnare proprietà immutabili come un tipo di ambito o una posizione da cui vuoi registrare risorse e attributi variabili come criticità e ambiente. Puoi utilizzare gli attributi variabili per filtrare le applicazioni. Per ulteriori informazioni, consulta Proprietà e attributi.

In questo tutorial, crei un'applicazione globale per aiutarti a gestire le risorse globali e regionali in un'unica applicazione. Se vuoi raggruppare le tue risorse di una regione specifica, puoi creare un'applicazione regionale e registrarle. Per ulteriori informazioni su come creare un'applicazione regionale, consulta Configurare App Hub.

Console

  1. Assicurati di essere nel progetto host di App Hub.
  2. Nella console Google Cloud , vai alla pagina Applications (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, consulta Aggiornare un'applicazione esistente.

  7. Nel riquadro Aggiungi attributi, seleziona Alta dall'elenco Criticità. La criticità indica quanto sono fondamentali un'applicazione, un servizio o un workload per le 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 attività. Tieni presente che devi inserire l'indirizzo email del proprietario se aggiungi un nome visualizzato.

    1. Inserisci il nome visualizzato di un 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 Applications (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 rilevate nell'applicazione App Hub. Per ulteriori informazioni, consulta 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. Questo nome dell'applicazione,tutorial-application è un identificatore univoco e non può essere modificato dopo la creazione dell'applicazione. Il nome visualizzatoTutorial è un nome facile da usare che puoi aggiornare. Per ulteriori informazioni, consulta 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 di App Hub:

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

    Viene visualizzato un output simile al seguente:

    ID                    DISPLAY_NAME  CREATE_TIME
    tutorial-application  Tutorial      2023-10-31T18:33:48
    
  4. Aggiorna l'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 rispettivamente dello sviluppatore, dell'operatore e dei proprietari dell'attività.
    • 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 quanto è critica un'applicazione, un servizio o un carico di lavoro per le operazioni aziendali.
    • environment-type: indica le fasi del ciclo di vita del software.
  5. Visualizza 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'
    

Registra servizi e workload

La registrazione di servizi e carichi di lavoro li aggiunge a un'applicazione che ti consente di monitorare le risorse aggiunte.

Console

  1. Nella console Google Cloud , vai alla pagina Applications (App Hub).

    Vai a Applicazioni

  2. Fai clic sul nome della tua applicazione, Tutorial. La scheda Servizi e carichi di lavoro mostra un elenco di servizi e carichi di lavoro registrati nei progetti di servizi 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 come richiesto per Proprietari sviluppatori, Proprietari operatori e Proprietari attività. Tieni presente che devi inserire l'indirizzo email del proprietario se aggiungi un nome visualizzato.
      1. Inserisci il nome visualizzato di un 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 Registrati.

    Nella scheda Servizi e carichi di lavoro, nella sezione Servizi e carichi di lavoro registrati, puoi vedere 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 carichi di lavoro 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 di editor dell'hub di app:

    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 di App Hub nel progetto dell'host di 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 a un'applicazione.

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

    Viene visualizzato 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 IDdel servizio, 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 servizi 3 che vuoi registrare.
    • FORWARDING_RULE_SERVICE_ID: il servizio ID della regola di forwarding del progetto di servizi 1 che vuoi registrare.
    • URL_MAP_SERVICE_ID: il servizio ID della mappa di 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
    

    Viene visualizzato 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 scollegati, sono indicati da un valore vuoto nel SERVICE_REFERENCE. Per ulteriori informazioni sugli stati di registrazione, consulta le proprietà e gli attributi di App Hub.

  5. Elenca tutti i carichi di lavoro rilevati nel progetto host di App Hub. Questo comando restituisce i workload che possono essere registrati in un'applicazione.

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

    Viene visualizzato 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 del carico di lavoro dall'output da utilizzare nel passaggio successivo.

  6. Registra i carichi di lavoro del passaggio precedente nella tua applicazione. Copia l'ID del 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 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
    

    Viene visualizzato 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 carichi di lavoro registrati, ma scollegati, sono indicati da un valore vuoto nel WORKLOAD_REFERENCE campo. Per ulteriori informazioni sugli stati di registrazione, consulta le proprietà e gli attributi di App Hub.

Visualizza tutti i servizi e i workload

Puoi visualizzare i dettagli dei servizi e dei workload dai progetti di servizio associati al progetto host App Hub.

  1. Nella console Google Cloud , vai alla pagina Servizi e carichi di lavoro dell'App Hub.

    Vai a Servizi e carichi di lavoro

    Vengono visualizzati tutti i servizi e i carichi di lavoro dei progetti di servizio App Hub collegati.

  2. Nell'elenco Regione, seleziona globale. Il carico di lavoro Gruppo di istanze di carico di lavoro viene visualizzato con dettagli come Tipo di App Hub, Criticità e Registrato a.

  3. Per filtrare i servizi o i workload in base allo stato:

    1. Nel campo Filtro, seleziona filtri come Stato registrazione.
    2. Fai clic su Registrato. Viene visualizzato un elenco di servizi e carichi di lavoro registrati all'applicazione.

Visualizza le metriche delle applicazioni

Puoi visualizzare le metriche di sistema per le applicazioni create nel progetto host di App Hub. Queste metriche corrispondono ai segnali finali: traffico, errori, latenza e saturazione che aiutano a monitorare le prestazioni e lo stato dell'applicazione.

  1. Nella console Google Cloud , vai alla pagina Applications (App Hub).

    Vai a Applicazioni

  2. Fai clic sul nome dell'applicazione, Tutorial.

    La scheda Servizi e workload viene visualizzata con i metadati dei servizi e dei workload registrati nella tua applicazione.

  3. Per visualizzare le metriche di sistema dei servizi e dei carichi di lavoro registrati, fai clic su Metriche.

Esegui la pulizia

Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, elimina il progetto che contiene le risorse oppure mantieni il progetto ed elimina le singole risorse.

Elimina le risorse di App Hub

Console

  1. Nella console Google Cloud , vai alla pagina Applications (App Hub).

    Vai a Applicazioni

  2. Fai clic sul nome di un'applicazione, Tutorial.

  3. Nella scheda Servizi e carichi di lavoro, fai clic sul nome di un servizio nella sezione Servizi e carichi di lavoro registrati.

  4. Nella pagina Servizi e carichi di lavoro, fai clic su Disregistra.

    Un avviso indica che il servizio non è registrato.

  5. Nella scheda Servizi e workload, fai clic sul nome di un workload nella sezione Servizi e workload registrati.

  6. Nella scheda Dettagli, fai clic su Disregistrazione.

    Un avviso indica che il carico di lavoro non è registrato.

  7. Vai alla pagina Applicazioni di App Hub.

    Vai a Applicazioni

  8. Fai clic sul nome di un'applicazione.

  9. Nella pagina tutorial-application, fai clic su Elimina.

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

    Vai alle impostazioni

  11. Nella pagina Impostazioni, seleziona la casella di controllo per il progetto di servizio da rimuovere dal progetto host App Hub.

  12. Fai clic su Scollega progetti.

gcloud

  1. Elenca i servizi registrati nell'applicazione:

    gcloud apphub applications services list \
      --application=tutorial-application --project=HOST_PROJECT_ID \
      --location=global
    
  2. Annullare la registrazione dei servizi dall'applicazione:

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

    Sostituisci SERVICE_NAME con il nome del servizio. I servizi ora sono servizi rilevati che possono essere registrati nell'applicazione.

  3. Elenca i workload registrati nell'applicazione:

    gcloud apphub applications workloads list \
      --application=tutorial-application --project=HOST_PROJECT_ID \
      --location=global
    
  4. Annullare la registrazione del carico di lavoro dall'applicazione:

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

    Sostituisci WORKLOAD_NAME con il nome del carico di lavoro. Il carico di lavoro ora è un carico di lavoro rilevato che può essere registrato nell'applicazione.

  5. Elimina l'applicazione:

    gcloud apphub applications delete tutorial-application \
      --project=HOST_PROJECT_ID \
      --location=global
    
  6. Rimuovi i progetti di servizio dal progetto host App Hub:

    gcloud apphub service-projects remove SERVICE_PROJECT_ID \
      --project=HOST_PROJECT_ID
    

    Sostituisci SERVICE_PROJECT_ID con gli ID progetto dei progetti di servizio 1, 2 e 3.

Elimina il deployment

Quando la soluzione non ti serve più, elimina tutte le risorse per evitare che la fatturazione continui per le risorse che hai creato in questa soluzione.

Per ulteriori informazioni, consulta ripulire la configurazione del bilanciatore del carico.

Elimina il progetto

Console

  1. Nella console Google Cloud , vai alla pagina Gestisci risorse.

    Vai a Gestisci risorse

  2. Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.
  3. Nella finestra di dialogo, digita l'ID progetto e fai clic su Chiudi per eliminare il progetto.

gcloud

Elimina un progetto Google Cloud :

gcloud projects delete PROJECT_ID

Sostituisci PROJECT_ID con gli ID progetto di hosting o di servizio.

Passaggi successivi