Crea un'applicazione da risorse esistenti

Questa guida rapida mostra come organizzare i servizi esistenti in un'applicazione App Hub. Google Cloud Innanzitutto, devi eseguire il deployment di una configurazione di esempio, che utilizzerai poi per definire un'applicazione web globale registrando i suoi componenti come un'applicazione in App Hub.

Questo approccio è rivolto agli utenti che vogliono utilizzare la propria infrastruttura esistente per ottenere visibilità e controllo operativo raggruppando le risorse in applicazioni logiche.

Prima di iniziare

Prima di iniziare questa guida rapida, segui questi passaggi:

  1. Configura App Hub con una cartella abilitata per le app.

    Google Cloud

  2. Prendi nota dell'ID progetto del progetto di gestione da utilizzare in questo documento.

  3. Verifica che le seguenti API siano abilitate nel progetto di gestione. Quando configuri una cartella abilitata per le app, la maggior parte delle API necessarie per questa guida rapida vengono abilitate automaticamente.

    • API Compute Engine (compute.googleapis.com)
    • API Infrastructure Manager (config.googleapis.com)

    Abilita le API

Ruoli obbligatori

Per ottenere le autorizzazioni necessarie per abilitare le API richieste e creare un'applicazione di esempio dalle risorse esistenti, chiedi all'amministratore di concederti i seguenti ruoli IAM nel progetto di gestione:

Per ulteriori informazioni sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

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

Esegui il deployment delle risorse per l'applicazione

Devi prima eseguire il deployment di un insieme di risorse di esempio che utilizzerai in un secondo momento per definire un'applicazione globale in App Hub:

  • Un servizio Cloud Run che funge da backend dell'applicazione.
  • Un bilanciatore del carico delle applicazioni esterno globale che indirizza il traffico al servizio Cloud Run come regola di forwarding.

Per eseguire il deployment di queste risorse, segui questi passaggi:

gcloud

  1. Imposta le variabili di ambiente richieste:

    export PROJECT_ID="PROJECT_ID"
export REGION="REGION"

    Sostituisci quanto segue:

    • PROJECT_ID: l'ID del progetto di gestione.
    • REGION: la regione scelta per le risorse, ad esempio us-central1.

  2. Esegui il deployment di un servizio Cloud Run di esempio denominato hello-run:

    gcloud run deploy hello-run \
    --image=us-docker.pkg.dev/cloudrun/container/hello \
    --allow-unauthenticated \
    --region=${REGION} \
    --project=${PROJECT_ID}

  3. Crea il bilanciatore del carico delle applicazioni esterno globale. Questo processo prevede i seguenti passaggi:

    1. Crea un gruppo di endpoint di rete (NEG) serverless chiamato hello-run-neg:

      gcloud compute network-endpoint-groups create hello-run-neg \
    --region=${REGION} \
    --network-endpoint-type=serverless \
    --cloud-run-service=hello-run \
    --project=${PROJECT_ID}

      Il NEG funge da backend per il bilanciatore del carico e punta al servizio hello-run.

    2. Crea un servizio di backend per gestire la distribuzione del traffico al NEG:

      gcloud compute backend-services create hello-backend-service \
    --global \
    --load-balancing-scheme=EXTERNAL_MANAGED \
    --project=${PROJECT_ID}

    3. Aggiungi il NEG serverless come backend al servizio di backend:

      gcloud compute backend-services add-backend hello-backend-service \
    --global \
    --network-endpoint-group=hello-run-neg \
    --network-endpoint-group-region=${REGION} \
    --project=${PROJECT_ID}

    4. Crea una mappa URL per instradare le richieste in entrata al servizio di backend:

      gcloud compute url-maps create hello-url-map \
    --default-service=hello-backend-service \
    --project=${PROJECT_ID}

    5. Crea un proxy HTTP per ricevere le richieste e instradarle utilizzando la mappa URL:

      gcloud compute target-http-proxies create hello-http-proxy \
    --url-map=hello-url-map \
    --project=${PROJECT_ID}

    6. Crea una regola di forwarding globale:

      gcloud compute forwarding-rules create hello-forwarding-rule \
    --global \
    --load-balancing-scheme=EXTERNAL_MANAGED \
    --target-http-proxy=hello-http-proxy \
    --ports=80 \
    --project=${PROJECT_ID}

      Questa regola di forwarding fornisce un indirizzo IP pubblico e una porta per gestire le richieste utente in entrata e le indirizza al proxy.

Terraform

  1. Crea un file main.tf e aggiungi il seguente codice:

    # Provider configuration
provider "google" {
  project = "PROJECT_ID"
}

# Cloud Run service
resource "google_cloud_run_v2_service" "default" {
  name     = "hello-run"
  location = "REGION"
  template {
    containers {
      image = "us-docker.pkg.dev/cloudrun/container/hello"
    }
  }
}

# Allow unauthenticated access to the Cloud Run service
resource "google_cloud_run_v2_service_iam_member" "noauth" {
  project  = google_cloud_run_v2_service.default.project
  location = google_cloud_run_v2_service.default.location
  name     = google_cloud_run_v2_service.default.name
  role     = "roles/run.invoker"
  member   = "allUsers"
}

    Sostituisci quanto segue:

    • PROJECT_ID: l'ID del progetto di gestione.
    • REGION: la regione scelta per le risorse, ad esempio us-central1.

    Questo blocco definisce il Google Cloud provider e configura un servizio Cloud Run pubblico utilizzando un'immagine container hello-world di esempio. Include anche un binding della policy IAM per consentire le chiamate non autenticate, rendendo il servizio pubblicamente accessibile.

  2. Aggiungi il seguente codice al file main.tf per creare il bilanciatore del carico delle applicazioni esterno globale:

    # Serverless NEG for the Cloud Run service
resource "google_compute_region_network_endpoint_group" "serverless_neg" {
  name                  = "hello-run-neg"
  network_endpoint_type = "SERVERLESS"
  region                = "REGION"
  cloud_run {
    service = google_cloud_run_v2_service.default.name
  }
}

# Global external backend service
resource "google_compute_backend_service" "default" {
  name                            = "hello-backend-service"
  protocol                        = "HTTP"
  load_balancing_scheme           = "EXTERNAL_MANAGED"
  backend {
    group = google_compute_region_network_endpoint_group.serverless_neg.id
  }
}

# URL map to route requests to the backend service
resource "google_compute_url_map" "default" {
  name            = "hello-url-map"
  default_service = google_compute_backend_service.default.id
}

# HTTP proxy to route requests to the URL map
resource "google_compute_target_http_proxy" "default" {
  name    = "hello-http-proxy"
  url_map = google_compute_url_map.default.id
}

# Global forwarding rule to handle incoming requests
resource "google_compute_global_forwarding_rule" "default" {
  name       = "hello-forwarding-rule"
  target     = google_compute_target_http_proxy.default.id
  port_range = "80"
}

    Questo blocco definisce i seguenti componenti:

    • Un gruppo di endpoint di rete (NEG) serverless, che funge da backend per il bilanciatore del carico e punta al servizio Cloud Run.
    • Un servizio di backend che indirizza il traffico al NEG serverless.
    • Una mappa URL per instradare le richieste in entrata al servizio di backend.
    • Un proxy HTTP per ricevere le richieste e instradarle utilizzando la mappa URL.
    • Una regola di forwarding globale, che fornisce un indirizzo IP pubblico e una porta per gestire le richieste utente in entrata e le indirizza al proxy.

  3. Inizializza e applica la configurazione Terraform:

    terraform init
terraform apply

    Terraform esegue il deployment delle risorse nel tuo progetto.

Definisci l'applicazione in App Hub

Dopo aver eseguito il deployment delle risorse come regola di forwarding e servizio Cloud Run, segui questi passaggi per raggrupparle in un'applicazione in App Hub:

Console

  1. Vai alla pagina Applicazioni da App Hub:

    Vai a Applicazioni

  2. Fai clic su Crea applicazione.

  3. Seleziona Globale come località dell'applicazione.

  4. Inserisci my-global-app per il nome dell'applicazione e fai clic su Continua.

  5. (Facoltativo) Aggiungi un nome visualizzato, la criticità, l'ambiente e i proprietari.

  6. Fai clic su Crea.

  7. Nella scheda Servizi e workload, fai clic su Registra servizio/workload.

  8. Seleziona la regola di forwarding, assegnale il nome frontend-service e fai clic su Registra.

  9. Seleziona il servizio Cloud Run, chiamalo backend-service e fai clic su Registra.

gcloud

  1. Crea l'applicazione:

    gcloud apphub applications create my-global-app \
    --location=global \
    --display-name="My Global Application" \
    --project=${PROJECT_ID}

  2. Scopri gli ID della regola di forwarding e del servizio Cloud Run nella regione appropriata:

    gcloud apphub discovered-services list \
    --location=global \
    --project=${PROJECT_ID}

gcloud apphub discovered-services list \
    --location=${REGION} \
    --project=${PROJECT_ID}

    Prendi nota dell'ID della regola di forwarding e del servizio Cloud Run.

  3. Registra la regola di forwarding nell'applicazione globale:

    gcloud apphub applications services create frontend-service \
    --application=my-global-app \
    --discovered-service=projects/${PROJECT_ID}/locations/global/discoveredServices/FRONTEND_ID \
    --display-name="Frontend Service" \
    --location=global \
    --project=${PROJECT_ID}

    Sostituisci FRONTEND_ID con l'ID della regola di forwarding.

  4. Registra il servizio Cloud Run nell'applicazione globale:

    gcloud apphub applications services create backend-service \
    --application=my-global-app \
    --discovered-service=projects/${PROJECT_ID}/locations/${REGION}/discoveredServices/BACKEND_ID \
    --display-name="Backend Service" \
    --location=global \
    --project=${PROJECT_ID}

    Sostituisci BACKEND_ID con l'ID del servizio Cloud Run.

Terraform

  1. Crea un file application.tf e aggiungi il seguente codice:

    # Application
resource "google_apphub_application" "my_global_app" {
  project        = "PROJECT_ID"
  location       = "global"
  application_id = "my-global-app"
  display_name   = "My Global Web App"
  description    = "A sample global web application."
  scope {
    type = "GLOBAL"
  }
  attributes {
    criticality {
      type = "MEDIUM"
    }
    environment {
      type = "DEVELOPMENT"
    }
    business_owners {
      display_name = "Example Business Owner"
      email        = "business-owner@example.com"
    }
    developer_owners {
      display_name = "Example Developer"
      email        = "dev-owner@example.com"
    }
    operator_owners {
      display_name = "Example Operator"
      email        = "operator-owner@example.com"
    }
  }
}

    Questo blocco utilizza la risorsa google_apphub_application per creare un raggruppamento logico per i tuoi servizi e carichi di lavoro.

    Questo esempio crea un'applicazione globale e definisce gli attributi per la governance e la rilevabilità, come criticità, ambiente e proprietari. Puoi modificare questi valori per la configurazione di esempio.

  2. Aggiungi il seguente codice a application.tf per scoprire le risorse di cui è stato eseguito il deployment:

    # Discover the forwarding rule
data "google_apphub_discovered_service" "frontend_service" {
  location = "global"
  service_uri = "//compute.googleapis.com/${google_compute_global_forwarding_rule.default.id}"
}

# Discover the Cloud Run service
data "google_apphub_discovered_service" "backend_service" {
  location    = "REGION"
  service_uri = "//run.googleapis.com/${google_cloud_run_v2_service.default.id}"
}

    Le origini dati google_apphub_discovered_service trovano i nomi delle risorse della tua infrastruttura esistente in base ai relativi URI. Questo passaggio consente ad App Hub di identificare le risorse specifiche che vuoi registrare.

  3. Aggiungi il seguente codice a application.tf per registrare le risorse scoperte:

    # Register the forwarding rule as a service in the application
resource "google_apphub_service" "frontend" {
  project            = "PROJECT_ID"
  location           = "global"
  application_id     = google_apphub_application.my_global_app.application_id
  service_id         = "frontend-service"
  display_name       = "Frontend Service (LB)"
  discovered_service = data.google_apphub_discovered_service.frontend_service.name
}

# Register the Cloud Run service as a service in the application
resource "google_apphub_service" "backend" {
  project            = "PROJECT_ID"
  location           = "global"
  application_id     = google_apphub_application.my_global_app.application_id
  service_id         = "backend-service"
  display_name       = "Backend Service (Cloud Run)"
  discovered_service = data.google_apphub_discovered_service.backend_service.name
}

    Le risorse google_apphub_service registrano formalmente le risorse rilevate nella tua applicazione. Questo passaggio crea il collegamento tra la tua infrastruttura e l'applicazione che hai definito in App Hub.

  4. Inizializza e applica la configurazione Terraform:

    terraform init
terraform apply

    Terraform registra le risorse nella tua applicazione my-global-app in App Hub.

(Facoltativo) Monitorare la nuova applicazione

Dopo aver definito l'applicazione in App Hub, puoi utilizzare i serviziGoogle Cloud integrati per monitorarne l'integrità e le prestazioni:

Esegui la pulizia

Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questa pagina, segui questi passaggi.

  1. Annulla la registrazione di servizi e workload.
  2. Elimina l'applicazione globale.
  3. Se hai utilizzato Terraform per eseguire il deployment dell'applicazione, esegui terraform destroy nella directory contenente i file Terraform per eseguire il deprovisioning di tutte le risorse che hai creato.
  4. (Facoltativo) Se hai creato un nuovo progetto per questa guida rapida, elimina il progetto.

Passaggi successivi