Diseña e implementa ofertas de SaaS

Application Design Center y App Lifecycle Manager te permiten estandarizar y escalar la entrega de SaaS multiusuario sin configurar manualmente la infraestructura para cada cliente. Ensamblas módulos de Terraform reutilizables en plantillas de aplicaciones compuestas en App Design Center y, luego, empaquetas esas plantillas en ofertas de SaaS administradas en App Lifecycle Manager.

En este instructivo, aprovisionarás entornos de usuario aislados y automatizarás las actualizaciones y los lanzamientos progresivos. Este flujo de trabajo está diseñado para ingenieros de plataformas, arquitectos empresariales y operadores de DevOps.

Objetivos

  • Prepara un repositorio de GitHub que contenga módulos de Terraform de Cloud Run y Cloud Storage.
  • Vincula tu repositorio de GitHub a Google Cloud con Developer Connect.
  • Importa los módulos de Terraform para crear y catalogar plantillas de componentes en App Design Center.
  • Diseña una plantilla de aplicación compuesta que incluya tus plantillas de componentes.
  • Empaqueta tu plantilla e implementa un entorno de cliente en App Lifecycle Manager.
  • Automatiza los lanzamientos progresivos en los entornos de tus clientes.

Costos

En este documento, usarás los siguientes componentes facturables de Google Cloud:

Para generar una estimación de costos en función del uso previsto, usa la calculadora de precios.

Es posible que los usuarios de Google Cloud nuevos cumplan con los requisitos para acceder a una prueba gratuita.

Cuando completes las tareas que se describen en este documento, podrás borrar los recursos que creaste para evitar que se te siga facturando. Para obtener más información, consulta Realiza una limpieza.

Antes de comenzar

  1. 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

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

  3. 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

  4. Asegúrate de tener los siguientes roles de Identity and Access Management (IAM) en tu proyecto:
    • Administrador de Application Design Center (roles/designcenter.admin) y Administrador de Service Usage (roles/serviceusage.serviceUsageAdmin) para realizar la configuración.
    • Administrador de administración de servicios de SaaS (roles/saasservicemgmt.admin)
    • Administrador de Developer Connect (roles/developerconnect.admin)
    • Administrador de IAM del proyecto (roles/resourcemanager.projectIamAdmin) o Administrador de seguridad (roles/iam.securityAdmin) para crear cuentas de servicio y otorgar roles de IAM.
    • Administrador de Cloud Run (roles/run.admin)
    • Administrador de almacenamiento (roles/storage.admin)
    • Administrador de cuentas de servicio (roles/iam.serviceAccountAdmin)
  5. Instala Google Cloud CLI y, luego, inicialízala:
    gcloud init
    Asegúrate de tener instalados los componentes de beta:
    gcloud components install beta
  6. Completa la configuración de Application Design Center en tu proyecto con un límite de administración de aplicaciones de un solo proyecto. La configuración habilita la administración de aplicaciones, aprovisiona un bucket de almacenamiento para Terraform y crea el espacio de default-space y el catálogo de default-catalog.
  7. Instala Git en tu máquina local.
  8. Asegúrate de tener una cuenta de GitHub con permisos para crear repositorios y generar tokens de acceso personal.

Configura el entorno y el repositorio de origen

Para configurar tu entorno para este instructivo, especifica los valores de las variables y configura tu repositorio de GitHub.

Especifica las variables del instructivo

Establece variables en este instructivo y en tu terminal de comandos.

  1. Establece las siguientes variables para actualizar los comandos de este instructivo:

    Variable Descripción Valor
    PROJECT_ID El ID de tu proyecto de Google Cloud PROJECT_ID
    REGION Región de Deployment para los recursos de App Design Center, Developer Connect, las ofertas de App Lifecycle Manager y la infraestructura de usuarios us-central1
  2. En la terminal de comandos, configura el proyecto activo de Google Cloud :

    gcloud config set project PROJECT_ID
    
  3. Recupera el número de proyecto de Google Cloud y almacénalo en una variable de entorno:

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

Crea archivos de configuración de Terraform

Crear definiciones modulares de Terraform para Cloud Run y Cloud Storage Más adelante, importarás estos módulos a App Design Center para empaquetarlos en componentes de arquitectura reutilizables.

  1. Crea una estructura de directorios local para tus módulos de Terraform:

    mkdir -p adc-alm-starter/infra/cloud-run
    mkdir -p adc-alm-starter/infra/cloud-storage
    cd adc-alm-starter
    
  2. En infra/cloud-run/main.tf, crea la definición del módulo de 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. En infra/cloud-run/metadata.yaml, crea la definición de metadatos del módulo:

    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. En infra/cloud-storage/main.tf, crea la definición del módulo de 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. En infra/cloud-storage/metadata.yaml, crea la definición de metadatos del módulo:

    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.
    

Envía Terraform a GitHub

Confirma tus parámetros de configuración de Terraform en un repositorio de GitHub y conéctalo a Google Cloud a través de Developer Connect. La conexión le otorga al Centro de diseño de aplicaciones acceso seguro para importar revisiones de infraestructura directamente desde el control de código fuente.

  1. En un navegador web, crea un repositorio de GitHub nuevo llamado adc-alm-starter.

  2. Crea un token de acceso personal detallado en GitHub para autenticar tu comando git push. Selecciona el repositorio adc-alm-starter y otorga permisos de Contenido: Lectura y escritura.

  3. En la terminal de comandos, inicializa Git en el directorio adc-alm-starter, confirma los archivos y envíalos a 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
    

    Cuando se te solicite la autenticación, ingresa tu nombre de usuario de GitHub y tu token de acceso personal.

  4. En la consola de Google Cloud , ve a la página Developer Connect:

    Ir a Developer Connect

  5. Crea una conexión en la región us-central1 para tu cuenta de GitHub y vincula tu repositorio. Para obtener instrucciones detalladas, consulta Conéctate a GitHub.

  6. Identifica el ID de conexión y el ID de vinculación del repositorio de Git para el repositorio vinculado y actualiza las siguientes variables:

    • CONNECTION_ID: Es el identificador de conexión de Developer Connect.
    • GIT_REPO_LINK_ID: Es el identificador del repositorio de Git vinculado.

Crea plantillas en App Design Center

Para diseñar tu infraestructura de Google Cloud , importa módulos de Terraform a App Design Center como plantillas de componentes. Luego, crea una plantilla de aplicación compuesta que incluya los componentes.

Verifica tu espacio y catálogo

Si completaste la configuración de App Design Center en la consola de Google Cloud , se crearon automáticamente tu espacio y catálogo predeterminados.

Si completaste la configuración con gcloud CLI, haz lo siguiente:

  1. Verifica que default-space exista en tu región:

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

    Reemplaza default-space por el ID de espacio de App Design Center.

  2. Si el espacio no existe, crea el espacio y el catálogo:

    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"
    

    Reemplaza default-catalog por el ID de tu catálogo.

Crea plantillas de componentes

Las plantillas de componentes convierten los módulos individuales de Terraform en bloques de compilación que puedes agregar a las plantillas de aplicaciones de varios servicios.

Crea plantillas de componentes basadas en los módulos de Terraform de tu repositorio de Git:

  1. Crea una plantilla de catálogo para 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
    

    Reemplaza cloud-run-component por el identificador de la plantilla de componente de Cloud Run.

  2. Crea una plantilla de catálogo para 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
    

    Reemplaza cloud-storage-component por el identificador de la plantilla de componente de Cloud Storage.

  3. Crea una revisión de plantilla importando el módulo de Terraform de Cloud Run desde tu repositorio de 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"
    

    Reemplaza lo siguiente:

    • CONNECTION_ID: Es el ID de conexión de Developer Connect.
    • GIT_REPO_LINK_ID: Es el ID de vinculación del repositorio de Git vinculado.
  4. Crea una revisión de plantilla importando el módulo de Terraform de Cloud Storage desde tu repositorio de 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"
    

    Reemplaza lo siguiente:

    • CONNECTION_ID: Es el ID de conexión de Developer Connect.
    • GIT_REPO_LINK_ID: Es el ID de vinculación del repositorio de Git vinculado.
  5. Enumera las plantillas compartidas en tu espacio para recuperar sus IDs de plantilla compartida:

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

    En el resultado del comando, observa el segmento SHARED_TEMPLATE_ID del campo name (projects/PROJECT_ID/locations/us-central1/spaces/default-space/sharedTemplates/SHARED_TEMPLATE_ID) para cloud-run-component y cloud-storage-component.

Crea una plantilla de aplicación compuesta

Combina tus plantillas de componentes en una plantilla de aplicación compuesta y configura las conexiones de parámetros. App Lifecycle Manager usa plantillas compuestas para administrar la topología de tu aplicación como una oferta de SaaS. Especifica las entradas y salidas para asegurarte de que el servicio de Cloud Run reciba automáticamente el nombre del bucket y los permisos de IAM necesarios para acceder a Cloud Storage.

  1. Crea una plantilla de aplicación compuesta:

    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
    

    Reemplaza run-storage-app por el identificador de la plantilla de aplicación compuesta.

  2. Agrega el componente de Cloud Run a la plantilla de la aplicación:

    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"
    

    Reemplaza RUN_SHARED_TEMPLATE_ID por el ID de la plantilla compartida de cloud-run-component que recuperaste.

  3. Agrega el componente de Cloud Storage a la plantilla de la aplicación:

    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"
    

    Reemplaza STORAGE_SHARED_TEMPLATE_ID por el ID de la plantilla compartida de cloud-storage-component que recuperaste.

  4. Crea una conexión del servicio de Cloud Run al bucket de Cloud Storage. Esto vincula el resultado del bucket a la variable de entorno del servicio y otorga acceso de IAM a la cuenta de servicio:

    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. Confirma la plantilla de la aplicación para generar una revisión de plantilla inmutable:

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

    El resultado del comando confirma el identificador de revisión generado (como r-1), al que harás referencia cuando crees tu oferta de SaaS en App Lifecycle Manager.


Implementa entornos de clientes con App Lifecycle Manager

Usa App Lifecycle Manager para convertir tu plantilla de aplicación en un producto implementable y aprovisionar entornos dedicados para cada cliente.

Empaqueta la plantilla de aplicación

Registra la revisión de tu plantilla con App Lifecycle Manager para crear una oferta de SaaS que se pueda implementar:

  1. Crea la oferta de SaaS en 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"
    

    Reemplaza saas-run-storage por el identificador de tu oferta de SaaS.

  2. Enumera los lanzamientos generados para recuperar el ID de lanzamiento, el tipo de unidad y las variables de entrada:

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

    App Lifecycle Manager compila y empaqueta el esquema de la plantilla compuesta de forma asíncrona. Si la lista está vacía, espera unos minutos y vuelve a ejecutar el comando.

    El comando genera el siguiente resultado:

    • El campo name (por ejemplo, projects/PROJECT_ID/locations/us-central1/releases/r-r-1-06c6a0). El segmento final es tu RELEASE_ID (como r-r-1-06c6a0).
    • El campo unitKind (por ejemplo, projects/PROJECT_ID/locations/us-central1/unitKinds/u-native-components-e97e0c). El segmento final es tu UNIT_KIND_ID (como u-native-components-e97e0c).

Crea una cuenta de servicio de implementación

Crea una cuenta de servicio que otorgue permiso a App Lifecycle Manager para aprovisionar recursos en tu nombre:

  1. Crea la cuenta de servicio de ejecución de acciones:

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

    Reemplaza tenant-actuation-sa por el nombre de tu cuenta de servicio de ejecución de acciones.

  2. Crea el correo electrónico de la cuenta de servicio y recupera la identidad del agente de servicio de App Lifecycle Manager:

    ACTUATION_SA="tenant-actuation-sa@PROJECT_ID."
    ALM_P4SA="service-${PROJECT_NUM}@gcp-sa-saasservicemgmt."
    INFRA_MANAGER_P4SA="service-${PROJECT_NUM}@gcp-sa-config."
    
  3. Otorga a la cuenta de servicio de actuación los roles necesarios para crear y administrar la infraestructura de los usuarios:

    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. Otorga permiso a los agentes de servicio de App Lifecycle Manager y de Infra Manager para que actúen en nombre de la cuenta de servicio de ejecución de acciones:

    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
    

Implementa un entorno para un cliente

Crea un entorno de cliente y activa la implementación de su infraestructura dedicada:

  1. Crea un entorno Unit que represente un usuario de cliente aislado con el tipo de unidad generado:

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

    Reemplaza tenant-1 por el identificador de tu unidad de usuario.

  2. Activa una operación de unidad para aprovisionar la infraestructura del usuario:

    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. Describe la operación de la unidad para supervisar el estado de aprovisionamiento hasta que alcance SUCCEEDED:

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

Automatiza las actualizaciones en los entornos de los clientes

Usa lanzamientos para implementar actualizaciones de aplicaciones de forma segura en todos los entornos de tus clientes.

Elige una estrategia de actualización

Define cómo se entregan las actualizaciones a los entornos de los clientes, como la implementación de todas a la vez o por fases:

  1. Crea un RolloutKind para definir la estrategia de organización de tus unidades:

    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"
    

    Reemplaza progressive-rollout por el identificador del tipo de lanzamiento.

Implementa y haz un seguimiento de la actualización

Inicia el lanzamiento y supervisa su progreso hasta que se complete la implementación:

  1. Activa el lanzamiento para implementar tu versión en las unidades de usuario aptas:

    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"
    

    Reemplaza rollout-v1 por el identificador de tu lanzamiento.

  2. Describe el lanzamiento para inspeccionar la ejecución activa y verificar que el estado llegue a SUCCEEDED:

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

    El resultado del lanzamiento confirma que tus unidades de usuario se actualizaron a la revisión de la plantilla de destino.

Realiza una limpieza

Para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos usados en este instructivo, borra el proyecto que contiene los recursos o conserva el proyecto y borra los recursos individuales.

Borra el proyecto

Borra un proyecto de Google Cloud :

gcloud projects delete PROJECT_ID

Borra los recursos individuales

Si implementaste los recursos del instructivo en un proyecto existente, borra los recursos individuales en orden de dependencia inverso para evitar una facturación inesperada:

  1. Anula el aprovisionamiento de la infraestructura del entorno del cliente y espera a que se complete:

    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. Borra el entorno de cliente de App Lifecycle Manager:

    gcloud beta app-lifecycle-manager units delete "tenant-1" \
        --location="us-central1" \
        --quiet
    
  3. Borra los recursos de lanzamiento y actualización de App Lifecycle Manager en orden inverso de dependencia:

    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. Borra la plantilla de aplicación, las entradas del catálogo y el espacio de 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. Borra el vínculo y la conexión del repositorio de Git de Developer Connect:

    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. Borra la cuenta de servicio de ejecución de acciones:

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

¿Qué sigue?