Progetta ed esegui il deployment di offerte SaaS

Application Design Center e App Lifecycle Manager ti consentono di standardizzare e scalare la distribuzione SaaS multi-tenant senza configurare manualmente l'infrastruttura per ogni cliente. Puoi assemblare moduli Terraform riutilizzabili in modelli di applicazioni compositi in App Design Center, quindi pacchettizzare questi modelli in offerte SaaS gestite in App Lifecycle Manager.

In questo tutorial eseguirai il provisioning di ambienti tenant isolati e automatizzerai gli aggiornamenti e i rollout progressivi. Questo workflow è progettato per platform engineer, enterprise architect e operatori DevOps.

Obiettivi

  • Preparare un repository GitHub contenente i moduli Terraform di Cloud Run e Cloud Storage.
  • Collega il tuo repository GitHub a Google Cloud utilizzando Developer Connect.
  • Importa i moduli Terraform per creare e catalogare i template dei componenti in App Design Center.
  • Progetta un template di applicazione composita che includa i template dei componenti.
  • Pacchettizza il template ed esegui il deployment di un ambiente cliente in App Lifecycle Manager.
  • Automatizza le implementazioni progressive negli ambienti dei tuoi clienti.

Costi

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

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

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

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

Prima di iniziare

  1. Accedi al tuo account Google Cloud . Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti senza costi per l'esecuzione, il test e il deployment di workload.
  2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  3. Verify that billing is enabled for your Google Cloud project.

  4. Enable the Developer Connect, Secret Manager, App Lifecycle Manager, Infrastructure Manager, and Cloud Run APIs, if any are not already enabled.

    Roles required to enable APIs

    To enable APIs, you need the serviceusage.services.enable permission. If you created the project, then you likely already have this permission through the Owner role (roles/owner). Otherwise, you can get this permission through the Service Usage Admin role (roles/serviceusage.serviceUsageAdmin). Learn how to grant roles.

    Enable the APIs

  5. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  6. Verify that billing is enabled for your Google Cloud project.

  7. Enable the Developer Connect, Secret Manager, App Lifecycle Manager, Infrastructure Manager, and Cloud Run APIs, if any are not already enabled.

    Roles required to enable APIs

    To enable APIs, you need the serviceusage.services.enable permission. If you created the project, then you likely already have this permission through the Owner role (roles/owner). Otherwise, you can get this permission through the Service Usage Admin role (roles/serviceusage.serviceUsageAdmin). Learn how to grant roles.

    Enable the APIs

  8. Assicurati di disporre dei seguenti ruoli IAM (Identity and Access Management) nel tuo progetto:
    • Application Design Center Admin (roles/designcenter.admin) e Amministratore Service Usage (roles/serviceusage.serviceUsageAdmin) per eseguire la configurazione.
    • SaaS Service Management Admin (roles/saasservicemgmt.admin)
    • Developer Connect Admin (roles/developerconnect.admin)
    • Project IAM Admin (roles/resourcemanager.projectIamAdmin) o Security Admin (roles/iam.securityAdmin) per creare service account e concedere ruoli IAM.
    • Cloud Run Admin (roles/run.admin)
    • Storage Admin (roles/storage.admin)
    • Service Account Admin (roles/iam.serviceAccountAdmin)
  9. Installa Google Cloud CLI, quindi inizializzala:
    gcloud init
    Assicurati di aver installato i componenti beta:
    gcloud components install beta
  10. Completa la configurazione di Application Design Center sul tuo progetto utilizzando un confine di gestione delle applicazioni per un singolo progetto. La configurazione abilita la gestione delle applicazioni, esegue il provisioning di un bucket di archiviazione per Terraform e crea lo spazio default-space e il catalogo default-catalog.
  11. Installa Git sulla tua macchina locale.
  12. Assicurati di avere un account GitHub con le autorizzazioni per creare repository e generare token di accesso personale.

Configura l'ambiente e il repository di origine

Per configurare l'ambiente per questo tutorial, specifica i valori delle variabili e configura il repository GitHub.

Specifica le variabili del tutorial

Imposta le variabili in questo tutorial e nel terminale dei comandi.

  1. Imposta le seguenti variabili per aggiornare i comandi in questo tutorial:

    Variabile Descrizione Valore
    PROJECT_ID Il tuo ID progetto Google Cloud PROJECT_ID
    REGION Regione di deployment per le risorse di App Design Center, Developer Connect, le offerte di App Lifecycle Manager e l'infrastruttura tenant us-central1
  2. Nel terminale, configura il progetto Google Cloud attivo:

    gcloud config set project PROJECT_ID
    
  3. Recupera il numero di progetto Google Cloud e memorizzalo in una variabile di ambiente:

    PROJECT_NUM=$(gcloud projects describe PROJECT_ID --format="value(projectNumber)")
    

Crea file di configurazione Terraform

Creare definizioni Terraform modulari per Cloud Run e Cloud Storage. In seguito, importerai questi moduli in App Design Center per pacchettizzarli in componenti di architettura riutilizzabili.

  1. Crea una struttura di directory locale per i moduli Terraform:

    mkdir -p adc-alm-starter/infra/cloud-run
    mkdir -p adc-alm-starter/infra/cloud-storage
    cd adc-alm-starter
    
  2. In infra/cloud-run/main.tf, crea la definizione del modulo Cloud Run:

    terraform {
      required_version = ">= 1.5.0"
      required_providers {
        google = {
          source  = "hashicorp/google"
          version = ">= 5.0.0"
        }
      }
    }
    
    variable "project_id" {
      type        = string
      description = "The Google Cloud project ID."
    }
    
    variable "region" {
      type        = string
      description = "The deployment region."
      default     = "us-central1"
    }
    
    variable "service_name" {
      type        = string
      description = "Name of the Cloud Run service."
      default     = "sample-app"
    }
    
    variable "bucket_name" {
      type        = string
      description = "Name of the Cloud Storage bucket to connect."
      default     = ""
    }
    
    resource "google_service_account" "app_sa" {
      account_id   = "${var.service_name}-sa"
      display_name = "Service Account for ${var.service_name}"
      project      = var.project_id
    }
    
    resource "google_cloud_run_v2_service" "app_service" {
      name                = var.service_name
      location            = var.region
      project             = var.project_id
      deletion_protection = false
    
      template {
        service_account = google_service_account.app_sa.email
        containers {
          image = "us-docker.pkg.dev/cloudrun/container/hello"
          env {
            name  = "STORAGE_BUCKET"
            value = var.bucket_name
          }
          resources {
            limits = {
              cpu    = "1"
              memory = "512Mi"
            }
          }
        }
      }
    }
    
    output "service_url" {
      description = "URL of the deployed Cloud Run service."
      value       = google_cloud_run_v2_service.app_service.uri
    }
    
    output "service_account_email" {
      description = "Email of the Cloud Run service account."
      value       = google_service_account.app_sa.email
    }
    
  3. In infra/cloud-run/metadata.yaml, crea la definizione dei metadati del modulo:

    apiVersion: blueprints.cloud.google.com/v1alpha1
    kind: BlueprintMetadata
    metadata:
      name: cloud-run-component
    spec:
      info:
        title: Cloud Run Component
        version: 0.1.0
        actuationTool:
          flavor: Terraform
          version: ">= 1.5.0"
      interfaces:
        variables:
          - name: project_id
            description: The Google Cloud project ID.
            varType: string
            required: true
          - name: region
            description: The deployment region.
            varType: string
            defaultValue: us-central1
          - name: service_name
            description: Name of the Cloud Run service.
            varType: string
            defaultValue: sample-app
          - name: bucket_name
            description: Name of the Cloud Storage bucket to connect.
            varType: string
            defaultValue: ""
        outputs:
          - name: service_url
            description: URL of the deployed Cloud Run service.
          - name: service_account_email
            description: Email of the Cloud Run service account.
    
  4. In infra/cloud-storage/main.tf, crea la definizione del modulo Cloud Storage:

    terraform {
      required_version = ">= 1.5.0"
      required_providers {
        google = {
          source  = "hashicorp/google"
          version = ">= 5.0.0"
        }
        random = {
          source  = "hashicorp/random"
          version = ">= 3.5.0"
        }
      }
    }
    
    variable "project_id" {
      type        = string
      description = "The Google Cloud project ID."
    }
    
    variable "region" {
      type        = string
      description = "The deployment region."
      default     = "us-central1"
    }
    
    variable "bucket_name_prefix" {
      type        = string
      description = "Prefix for the Cloud Storage bucket."
      default     = "app-data"
    }
    
    variable "writer_service_account" {
      type        = string
      description = "Service account email granted objectAdmin permissions."
      default     = ""
    }
    
    resource "random_id" "bucket_suffix" {
      byte_length = 4
    }
    
    resource "google_storage_bucket" "bucket" {
      name                        = "${var.bucket_name_prefix}-${random_id.bucket_suffix.hex}"
      location                    = var.region
      project                     = var.project_id
      uniform_bucket_level_access = true
      force_destroy               = true
    }
    
    resource "google_storage_bucket_iam_member" "writer_grant" {
      count  = var.writer_service_account != "" ? 1 : 0
      bucket = google_storage_bucket.bucket.name
      role   = "roles/storage.objectAdmin"
      member = "serviceAccount:${var.writer_service_account}"
    }
    
    output "bucket_name" {
      description = "Name of the created storage bucket."
      value       = google_storage_bucket.bucket.name
    }
    
  5. In infra/cloud-storage/metadata.yaml, crea la definizione dei metadati del modulo:

    apiVersion: blueprints.cloud.google.com/v1alpha1
    kind: BlueprintMetadata
    metadata:
      name: cloud-storage-component
    spec:
      info:
        title: Cloud Storage Component
        version: 0.1.0
        actuationTool:
          flavor: Terraform
          version: ">= 1.5.0"
      interfaces:
        variables:
          - name: project_id
            description: The Google Cloud project ID.
            varType: string
            required: true
          - name: region
            description: The deployment region.
            varType: string
            defaultValue: us-central1
          - name: bucket_name_prefix
            description: Prefix for the Cloud Storage bucket.
            varType: string
            defaultValue: app-data
          - name: writer_service_account
            description: Service account email granted objectAdmin permissions.
            varType: string
            defaultValue: ""
        outputs:
          - name: bucket_name
            description: Name of the created storage bucket.
    

Esegui il push di Terraform su GitHub

Esegui il commit delle configurazioni Terraform in un repository GitHub e connetti il repository a Google Cloud tramite Developer Connect. La connessione consente ad App Design Center di accedere in modo sicuro per importare le revisioni dell'infrastruttura direttamente dal controllo del codice sorgente.

  1. In un browser web, crea un nuovo repository GitHub denominato adc-alm-starter.

  2. Crea un token di accesso personale granulare in GitHub per autenticare il comando git push. Seleziona il repository adc-alm-starter e concedi le autorizzazioni Contenuti: lettura e scrittura.

  3. Nel terminale dei comandi, inizializza Git nella directory adc-alm-starter, esegui il commit dei file ed esegui il push su GitHub:

    cd adc-alm-starter
    git init
    git add infra/
    git commit -m "feat: initialize Cloud Run and Cloud Storage modules"
    git branch -M main
    git remote add origin https://github.com/GITHUB_USER_OR_ORG/adc-alm-starter.git
    git push -u origin main
    

    Quando ti viene richiesta l'autenticazione, inserisci il tuo nome utente GitHub e il token di accesso personale.

  4. Nella console Google Cloud , vai alla pagina Developer Connect:

    Vai a Developer Connect

  5. Crea una connessione nella regione us-central1 per il tuo account GitHub e collega il repository. Per istruzioni dettagliate, consulta Connettiti a GitHub.

  6. Identifica l'ID connessione e l'ID link al repository Git per il repository collegato e aggiorna le seguenti variabili:

    • CONNECTION_ID: l'identificatore della connessione Developer Connect.
    • GIT_REPO_LINK_ID: l'identificatore del repository Git collegato.

Crea template in App Design Center

Per progettare la tua infrastruttura Google Cloud , importa i moduli Terraform in App Design Center come modelli di componenti. Poi crea un template di applicazione composita che includa i componenti.

Verifica lo spazio e il catalogo

Se hai completato la configurazione di App Design Center nella console Google Cloud , lo spazio e il catalogo predefiniti sono stati creati automaticamente.

Se hai completato la configurazione con gcloud CLI, segui questi passaggi:

  1. Verifica che default-space esista nella tua regione:

    gcloud design-center spaces describe "default-space" \
        --location="us-central1"
    

    Sostituisci default-space con l'ID spazio di App Design Center.

  2. Se lo spazio non esiste, crea lo spazio e il catalogo:

    gcloud design-center spaces create "default-space" \
        --location="us-central1" \
        --display-name="Default Space"
    
    gcloud design-center spaces catalogs create "default-catalog" \
        --space="default-space" \
        --location="us-central1" \
        --display-name="Default Catalog"
    

    Sostituisci default-catalog con l'ID del catalogo.

Crea modelli di componenti

I template dei componenti trasformano i singoli moduli Terraform in componenti di base che puoi aggiungere ai template delle applicazioni multiservizio.

Crea i template dei componenti in base ai moduli Terraform nel tuo repository Git:

  1. Crea un template di catalogo per Cloud Run:

    gcloud design-center spaces catalogs templates create "cloud-run-component" \
        --space="default-space" \
        --catalog="default-catalog" \
        --location="us-central1" \
        --display-name="Cloud Run Component" \
        --template-category=component-template
    

    Sostituisci cloud-run-component con l'identificatore del template del componente Cloud Run.

  2. Crea un template di catalogo per Cloud Storage:

    gcloud design-center spaces catalogs templates create "cloud-storage-component" \
        --space="default-space" \
        --catalog="default-catalog" \
        --location="us-central1" \
        --display-name="Cloud Storage Component" \
        --template-category=component-template
    

    Sostituisci cloud-storage-component con l'identificatore del template del componente Cloud Storage.

  3. Crea una revisione del template importando il modulo Terraform di Cloud Run dal tuo repository Git:

    gcloud design-center spaces catalogs templates revisions create r-1 \
        --template="cloud-run-component" \
        --catalog="default-catalog" \
        --space="default-space" \
        --location="us-central1" \
        --developer-connect-repo="projects/PROJECT_ID/locations/us-central1/connections/CONNECTION_ID/gitRepositoryLinks/GIT_REPO_LINK_ID" \
        --developer-connect-repo-dir="infra/cloud-run" \
        --developer-connect-repo-ref="refs/heads/main"
    

    Sostituisci quanto segue:

    • CONNECTION_ID: l'ID connessione di Developer Connect.
    • GIT_REPO_LINK_ID: l'ID collegamento del repository Git collegato.
  4. Crea una revisione del template importando il modulo Terraform di Cloud Storage dal tuo repository Git:

    gcloud design-center spaces catalogs templates revisions create r-1 \
        --template="cloud-storage-component" \
        --catalog="default-catalog" \
        --space="default-space" \
        --location="us-central1" \
        --developer-connect-repo="projects/PROJECT_ID/locations/us-central1/connections/CONNECTION_ID/gitRepositoryLinks/GIT_REPO_LINK_ID" \
        --developer-connect-repo-dir="infra/cloud-storage" \
        --developer-connect-repo-ref="refs/heads/main"
    

    Sostituisci quanto segue:

    • CONNECTION_ID: l'ID connessione di Developer Connect.
    • GIT_REPO_LINK_ID: l'ID collegamento del repository Git collegato.
  5. Elenca i modelli condivisi nel tuo spazio per recuperare i relativi ID:

    gcloud design-center spaces shared-templates list \
        --space="default-space" \
        --location="us-central1"
    

    Nell'output comando, prendi nota del segmento SHARED_TEMPLATE_ID dal campo name (projects/PROJECT_ID/locations/us-central1/spaces/default-space/sharedTemplates/SHARED_TEMPLATE_ID) per cloud-run-component e cloud-storage-component.

Crea un modello di applicazione composita

Combina i modelli di componenti in un modello di applicazione composita e configura le connessioni dei parametri. App Lifecycle Manager utilizza modelli compositi per gestire la topologia dell'applicazione come offerta SaaS. Specifica gli output e gli input per assicurarti che il servizio Cloud Run riceva automaticamente il nome del bucket e le autorizzazioni IAM necessarie per accedere a Cloud Storage.

  1. Crea un modello di applicazione composita:

    gcloud design-center spaces application-templates create "run-storage-app" \
        --space="default-space" \
        --location="us-central1" \
        --display-name="Cloud Run and Storage Multi-Tenant Application" \
        --composition-type=composite
    

    Sostituisci run-storage-app con l'identificatore del modello di applicazione composita.

  2. Aggiungi il componente Cloud Run al template dell'applicazione:

    gcloud design-center spaces application-templates components create cloud-run-comp \
        --application-template="run-storage-app" \
        --space="default-space" \
        --location="us-central1" \
        --shared-template-revision-uri="projects/PROJECT_ID/locations/us-central1/spaces/default-space/sharedTemplates/RUN_SHARED_TEMPLATE_ID/revisions/r-1"
    

    Sostituisci RUN_SHARED_TEMPLATE_ID con l'ID del modello condiviso cloud-run-component che hai recuperato.

  3. Aggiungi il componente Cloud Storage al modello di applicazione:

    gcloud design-center spaces application-templates components create cloud-storage-comp \
        --application-template="run-storage-app" \
        --space="default-space" \
        --location="us-central1" \
        --shared-template-revision-uri="projects/PROJECT_ID/locations/us-central1/spaces/default-space/sharedTemplates/STORAGE_SHARED_TEMPLATE_ID/revisions/r-1"
    

    Sostituisci STORAGE_SHARED_TEMPLATE_ID con l'ID del modello condiviso cloud-storage-component che hai recuperato.

  4. Crea una connessione dal servizio Cloud Run al bucket Cloud Storage. In questo modo, l'output del bucket viene collegato alla variabile di ambiente del servizio e al account di servizio viene concesso l'accesso IAM:

    gcloud design-center spaces application-templates components connections create run-to-storage \
        --component=cloud-run-comp \
        --application-template="run-storage-app" \
        --space="default-space" \
        --location="us-central1" \
        --destination-component-uri="projects/PROJECT_ID/locations/us-central1/spaces/default-space/applicationTemplates/run-storage-app/components/cloud-storage-comp" \
        --source-component-parameters='[{"key": "bucket_name", "value": "module.cloud-storage-comp.bucket_name"}]' \
        --destination-component-parameters='[{"key": "writer_service_account", "value": "module.cloud-run-comp.service_account_email"}]'
    
  5. Esegui il commit del template di applicazione per generare una revisione del template immutabile:

    gcloud design-center spaces application-templates commit "run-storage-app" \
        --space="default-space" \
        --location="us-central1"
    

    L'output comando conferma l'identificatore della revisione generato (ad esempio r-1), a cui farai riferimento quando crei la tua offerta SaaS in App Lifecycle Manager.


Esegui il deployment degli ambienti dei clienti con App Lifecycle Manager

Utilizza App Lifecycle Manager per trasformare il template dell'applicazione in un prodotto di cui è possibile eseguire il deployment e per eseguire il provisioning di ambienti dedicati per ogni cliente.

Crea il pacchetto del modello di applicazione

Registra la revisione del modello con App Lifecycle Manager per creare un'offerta SaaS di cui è possibile eseguire il deployment:

  1. Crea l'offerta SaaS in us-central1:

    gcloud beta app-lifecycle-manager saas create "saas-run-storage" \
        --location="us-central1" \
        --locations=name="us-central1" \
        --application-template="projects/PROJECT_ID/locations/us-central1/spaces/default-space/applicationTemplates/run-storage-app" \
        --application-template-revision="projects/PROJECT_ID/locations/us-central1/spaces/default-space/applicationTemplates/run-storage-app/revisions/r-1"
    

    Sostituisci saas-run-storage con l'identificatore dell'offerta SaaS.

  2. Elenca le release generate per recuperare l'ID release, il tipo di unità e le variabili di input:

    gcloud beta app-lifecycle-manager releases list \
        --location="us-central1"
    

    App Lifecycle Manager crea e pacchettizza il blueprint del template composito in modo asincrono. Se l'elenco è vuoto, attendi qualche minuto ed esegui di nuovo il comando.

    Il comando restituisce le seguenti informazioni:

    • Il campo name (ad esempio projects/PROJECT_ID/locations/us-central1/releases/r-r-1-06c6a0). Il segmento finale è il tuo RELEASE_ID (ad esempio r-r-1-06c6a0).
    • Il campo unitKind (ad esempio projects/PROJECT_ID/locations/us-central1/unitKinds/u-native-components-e97e0c). Il segmento finale è il tuo UNIT_KIND_ID (ad esempio u-native-components-e97e0c).

Crea un account di servizio di deployment

Crea un account di servizio che conceda ad App Lifecycle Manager l'autorizzazione per eseguire il provisioning delle risorse per tuo conto:

  1. Crea il account di servizio di attivazione:

    gcloud iam service-accounts create "tenant-actuation-sa" \
        --display-name="Tenant Actuation Service Account"
    

    Sostituisci tenant-actuation-sa con il nome del tuo account di servizio di attuazione.

  2. Crea l'indirizzo email del account di servizio e recupera l'identità dell'agente di servizio App Lifecycle Manager:

    ACTUATION_SA="tenant-actuation-sa@PROJECT_ID.iam.gserviceaccount.com"
    ALM_P4SA="service-${PROJECT_NUM}@gcp-sa-saasservicemgmt.iam.gserviceaccount.com"
    INFRA_MANAGER_P4SA="service-${PROJECT_NUM}@gcp-sa-config.iam.gserviceaccount.com"
    
  3. Concedi al account di servizio di attuazione i ruoli necessari per creare e gestire l'infrastruttura tenant:

    gcloud projects add-iam-policy-binding "PROJECT_ID" \
        --member="serviceAccount:${ACTUATION_SA}" \
        --role="roles/run.admin" \
        --condition=None
    
    gcloud projects add-iam-policy-binding "PROJECT_ID" \
        --member="serviceAccount:${ACTUATION_SA}" \
        --role="roles/storage.admin" \
        --condition=None
    
    gcloud projects add-iam-policy-binding "PROJECT_ID" \
        --member="serviceAccount:${ACTUATION_SA}" \
        --role="roles/iam.serviceAccountAdmin" \
        --condition=None
    
    gcloud projects add-iam-policy-binding "PROJECT_ID" \
        --member="serviceAccount:${ACTUATION_SA}" \
        --role="roles/iam.serviceAccountUser" \
        --condition=None
    
    gcloud projects add-iam-policy-binding "PROJECT_ID" \
        --member="serviceAccount:${ACTUATION_SA}" \
        --role="roles/config.admin" \
        --condition=None
    
  4. Concedi agli agenti di servizio App Lifecycle Manager e Infra Manager l'autorizzazione a impersonare il account di servizio di attivazione:

    gcloud iam service-accounts add-iam-policy-binding "${ACTUATION_SA}" \
        --member="serviceAccount:${ALM_P4SA}" \
        --role="roles/iam.serviceAccountUser" \
        --condition=None
    
    gcloud iam service-accounts add-iam-policy-binding "${ACTUATION_SA}" \
        --member="serviceAccount:${ALM_P4SA}" \
        --role="roles/iam.serviceAccountTokenCreator" \
        --condition=None
    
    gcloud iam service-accounts add-iam-policy-binding "${ACTUATION_SA}" \
        --member="serviceAccount:${INFRA_MANAGER_P4SA}" \
        --role="roles/iam.serviceAccountUser" \
        --condition=None
    

Esegui il deployment di un ambiente per un cliente

Crea un ambiente cliente e attiva il deployment della sua infrastruttura dedicata:

  1. Crea un ambiente Unit che rappresenti un tenant cliente isolato utilizzando il tipo di unità generato:

    gcloud beta app-lifecycle-manager units create "tenant-1" \
        --location="us-central1" \
        --unit-kind="UNIT_KIND_ID"
    

    Sostituisci tenant-1 con l'identificatore dell'unità di tenancy.

  2. Attiva un'operazione unità per eseguire il provisioning dell'infrastruttura del tenant:

    gcloud beta app-lifecycle-manager unit-operations create provision-tenant-1 \
        --location="us-central1" \
        --unit="projects/PROJECT_ID/locations/us-central1/units/tenant-1" \
        --provision \
        --provision-release="RELEASE_ID" \
        --provision-input-variables=variable=project_id,value="PROJECT_ID",type=string \
        --provision-input-variables=variable=project_number,value="${PROJECT_NUM}",type=string \
        --provision-input-variables=variable=actuation_sa,value="${ACTUATION_SA}",type=string \
        --provision-input-variables=variable=cloud-run-comp_project_id,value="PROJECT_ID",type=string \
        --provision-input-variables=variable=cloud-run-comp_region,value="us-central1",type=string \
        --provision-input-variables=variable=cloud-storage-comp_project_id,value="PROJECT_ID",type=string \
        --provision-input-variables=variable=cloud-storage-comp_region,value="us-central1",type=string
    
  3. Descrivi l'operazione dell'unità per monitorare lo stato del provisioning fino a raggiungere SUCCEEDED:

    gcloud beta app-lifecycle-manager unit-operations describe provision-tenant-1 \
        --location="us-central1"
    

Automatizza gli aggiornamenti negli ambienti dei clienti

Utilizza i rollout per eseguire in sicurezza il deployment degli aggiornamenti delle applicazioni in tutti gli ambienti dei tuoi clienti.

Scegli una strategia di aggiornamento

Definisci il modo in cui gli aggiornamenti vengono distribuiti negli ambienti dei clienti, ad esempio eseguendo il deployment tutto in una volta o in fasi:

  1. Crea un RolloutKind per definire la strategia di orchestrazione per le tue unità:

    gcloud beta app-lifecycle-manager rollout-kinds create "progressive-rollout" \
        --location="us-central1" \
        --unit-kind="projects/PROJECT_ID/locations/us-central1/unitKinds/UNIT_KIND_ID" \
        --rollout-orchestration-strategy="Google.Cloud.Simple.AllAtOnce"
    

    Sostituisci progressive-rollout con l'identificatore del tipo di implementazione.

Esegui il deployment e monitora l'aggiornamento

Avvia l'implementazione e monitorane l'avanzamento fino al completamento del deployment:

  1. Attiva l'implementazione per eseguire il deployment della release in tutte le unità di tenancy idonee:

    gcloud beta app-lifecycle-manager rollouts create "rollout-v1" \
        --location="us-central1" \
        --rollout-kind="projects/PROJECT_ID/locations/us-central1/rolloutKinds/progressive-rollout" \
        --release="projects/PROJECT_ID/locations/us-central1/releases/RELEASE_ID"
    

    Sostituisci rollout-v1 con l'identificatore dell'implementazione.

  2. Descrivi l'implementazione per ispezionare l'esecuzione attiva e verificare che lo stato raggiunga SUCCEEDED:

    gcloud beta app-lifecycle-manager rollouts describe "rollout-v1" \
        --location="us-central1"
    

    L'output del rilascio conferma che le unità di tenancy sono state aggiornate alla revisione del template di destinazione.

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 il progetto

Elimina un progetto Google Cloud :

gcloud projects delete PROJECT_ID

Elimina singole risorse

Se hai eseguito il deployment delle risorse del tutorial in un progetto esistente, elimina le singole risorse in ordine di dipendenza inverso per evitare addebiti imprevisti:

  1. Esegui il deprovisioning dell'infrastruttura dell'ambiente del cliente e attendi il completamento:

    gcloud beta app-lifecycle-manager unit-operations create deprovision-tenant-1 \
        --location="us-central1" \
        --unit="projects/PROJECT_ID/locations/us-central1/units/tenant-1" \
        --deprovision
    
    gcloud beta app-lifecycle-manager unit-operations describe deprovision-tenant-1 \
        --location="us-central1"
    
  2. Elimina l'ambiente cliente di App Lifecycle Manager:

    gcloud beta app-lifecycle-manager units delete "tenant-1" \
        --location="us-central1" \
        --quiet
    
  3. Elimina le risorse di implementazione e release di App Lifecycle Manager in ordine inverso di dipendenza:

    gcloud beta app-lifecycle-manager rollouts delete "rollout-v1" \
        --location="us-central1" \
        --quiet
    
    gcloud beta app-lifecycle-manager rollout-kinds delete "progressive-rollout" \
        --location="us-central1" \
        --quiet
    
    gcloud beta app-lifecycle-manager releases delete "RELEASE_ID" \
        --location="us-central1" \
        --quiet
    
    gcloud beta app-lifecycle-manager unit-kinds delete "UNIT_KIND_ID" \
        --location="us-central1" \
        --quiet
    
    gcloud beta app-lifecycle-manager saas delete "saas-run-storage" \
        --location="us-central1" \
        --quiet
    
  4. Elimina il template dell'applicazione, le voci del catalogo e lo spazio di App Design Center:

    gcloud design-center spaces application-templates delete "run-storage-app" \
        --space="default-space" \
        --location="us-central1" \
        --force \
        --quiet
    
    gcloud design-center spaces catalogs templates delete "cloud-run-component" \
        --space="default-space" \
        --catalog="default-catalog" \
        --location="us-central1" \
        --force \
        --quiet
    
    gcloud design-center spaces catalogs templates delete "cloud-storage-component" \
        --space="default-space" \
        --catalog="default-catalog" \
        --location="us-central1" \
        --force \
        --quiet
    
    gcloud design-center spaces delete "default-space" \
        --location="us-central1" \
        --force \
        --quiet
    
  5. Elimina il link al repository Git di Developer Connect e la connessione:

    gcloud developer-connect connections git-repository-links delete "GIT_REPO_LINK_ID" \
        --connection="CONNECTION_ID" \
        --location="us-central1" \
        --quiet
    
    gcloud developer-connect connections delete "CONNECTION_ID" \
        --location="us-central1" \
        --quiet
    
  6. Elimina il account di servizio di attivazione:

    gcloud iam service-accounts delete "${ACTUATION_SA}" \
        --quiet
    

Passaggi successivi