Projetar e implantar soluções de SaaS

O Application Design Center e o App Lifecycle Manager permitem padronizar e escalonar a entrega de SaaS multilocatário sem configurar manualmente a infraestrutura para cada cliente. Você monta módulos reutilizáveis do Terraform em modelos de aplicativos compostos no App Design Center e, em seguida, empacota esses modelos em ofertas de SaaS gerenciadas no App Lifecycle Manager.

Neste tutorial, você vai provisionar ambientes de locatário isolados e automatizar atualizações e lançamentos progressivos. Este fluxo de trabalho foi projetado para engenheiros de plataforma, arquitetos corporativos e operadores de DevOps.

Objetivos

  • Prepare um repositório do GitHub que contenha módulos do Terraform do Cloud Run e do Cloud Storage.
  • Vincule seu repositório do GitHub ao Google Cloud usando o Developer Connect.
  • Importe os módulos do Terraform para criar e catalogar modelos de componentes no App Design Center.
  • Crie um modelo de aplicativo composto que inclua os modelos de componente.
  • Empacote o modelo e implante um ambiente de cliente no App Lifecycle Manager.
  • Automatize lançamentos progressivos nos ambientes dos clientes.

Custos

Neste documento, você vai usar os seguintes componentes faturáveis do Google Cloud:

Para gerar uma estimativa de custo baseada na sua projeção de uso, use a calculadora de preços.

Novos usuários do Google Cloud podem estar qualificados para um teste sem custo financeiro.

Ao concluir as tarefas descritas neste documento, é possível evitar o faturamento contínuo excluindo os recursos criados. Para mais informações, consulte Limpeza.

Antes de começar

  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. Verifique se você tem os seguintes papéis do Identity and Access Management (IAM) no projeto:
    • Administrador do Application Design Center (roles/designcenter.admin) e Administrador do Service Usage (roles/serviceusage.serviceUsageAdmin) para realizar a configuração.
    • Administrador de gerenciamento de serviços SaaS (roles/saasservicemgmt.admin)
    • Administrador do Developer Connect (roles/developerconnect.admin)
    • Administrador do IAM do projeto (roles/resourcemanager.projectIamAdmin) ou Administrador de segurança (roles/iam.securityAdmin) para criar contas de serviço e conceder papéis do IAM.
    • Administrador do Cloud Run (roles/run.admin)
    • Administrador do Storage (roles/storage.admin)
    • Administrador da conta de serviço (roles/iam.serviceAccountAdmin)
  5. Instale a Google Cloud CLI e inicialize-a:
    gcloud init
    Verifique se os componentes beta estão instalados:
    gcloud components install beta
  6. Conclua a configuração do Application Design Center no seu projeto usando um limite de gerenciamento de aplicativos de projeto único. A configuração ativa o gerenciamento de aplicativos, provisiona um bucket de armazenamento para o Terraform e cria o espaço default-space e o catálogo default-catalog.
  7. Instale o Git na máquina local.
  8. Verifique se você tem uma conta do GitHub com permissões para criar repositórios e gerar tokens de acesso pessoal.

Configurar o ambiente e o repositório de origem

Para configurar o ambiente para este tutorial, especifique os valores das variáveis e configure o repositório do GitHub.

Especificar variáveis do tutorial

Defina variáveis neste tutorial e no terminal de comando.

  1. Defina as seguintes variáveis para atualizar os comandos neste tutorial:

    Variável Descrição Valor
    PROJECT_ID O ID do projeto do Google Cloud . PROJECT_ID
    REGION Região de implantação para recursos do App Design Center, Developer Connect, ofertas do App Lifecycle Manager e infraestrutura de locatário us-central1
  2. No terminal de comando, configure o projeto ativo do Google Cloud :

    gcloud config set project PROJECT_ID
    
  3. Recupere o número do projeto do Google Cloud e armazene-o em uma variável de ambiente:

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

Criar arquivos de configuração do Terraform

Criar definições modulares do Terraform para o Cloud Run e o Cloud Storage. Depois, você vai importar esses módulos para o App Design Center e empacotá-los em componentes arquitetônicos reutilizáveis.

  1. Crie uma estrutura de diretório local para seus módulos do Terraform:

    mkdir -p adc-alm-starter/infra/cloud-run
    mkdir -p adc-alm-starter/infra/cloud-storage
    cd adc-alm-starter
    
  2. Em infra/cloud-run/main.tf, crie a definição do módulo do 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. Em infra/cloud-run/metadata.yaml, crie a definição de metadados do 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. Em infra/cloud-storage/main.tf, crie a definição do módulo do 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. Em infra/cloud-storage/metadata.yaml, crie a definição de metadados do 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.
    

Enviar o Terraform para o GitHub

Confirme as configurações do Terraform em um repositório do GitHub e conecte o repositório ao Google Cloud pelo Developer Connect. A conexão dá à Central de Design de Aplicativos acesso seguro para importar revisões de infraestrutura diretamente do controle de origem.

  1. Em um navegador da Web, crie um novo repositório do GitHub chamado adc-alm-starter.

  2. Crie um token de acesso pessoal detalhado no GitHub para autenticar o comando git push. Selecione o repositório adc-alm-starter e conceda as permissões Conteúdo: ler e gravar.

  3. No terminal de comando, inicialize o Git no diretório adc-alm-starter, faça commit dos arquivos e envie para o 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 a autenticação for solicitada, insira seu nome de usuário do GitHub e o token de acesso pessoal.

  4. No console do Google Cloud , acesse a página Developer Connect:

    Acessar o Developer Connect

  5. Crie uma conexão na região us-central1 para sua conta do GitHub e vincule seu repositório. Para instruções detalhadas, consulte Conectar-se ao GitHub.

  6. Identifique o ID da conexão e o ID do link do repositório Git do repositório vinculado e atualize as seguintes variáveis:

    • CONNECTION_ID: o identificador da conexão do Developer Connect.
    • GIT_REPO_LINK_ID: o identificador do repositório Git vinculado.

Criar modelos no App Design Center

Para projetar sua infraestrutura do Google Cloud , importe módulos do Terraform para o App Design Center como modelos de componentes. Em seguida, crie um modelo de aplicativo composto que inclua os componentes.

Verificar seu espaço e catálogo

Se você concluiu a configuração do App Design Center no console do Google Cloud , seu espaço e catálogo padrão foram criados automaticamente.

Se você concluiu a configuração com a CLI gcloud, faça o seguinte:

  1. Verifique se default-space existe na sua região:

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

    Substitua default-space pelo ID do espaço do App Design Center.

  2. Se o espaço não existir, crie o espaço e o 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"
    

    Substitua default-catalog pelo ID do catálogo.

Criar modelos de componentes

Os modelos de componente transformam módulos individuais do Terraform em elementos básicos que podem ser adicionados a modelos de aplicativos de vários serviços.

Crie modelos de componentes com base nos módulos do Terraform no repositório Git:

  1. Crie um modelo de catálogo para o 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
    

    Substitua cloud-run-component pelo identificador do modelo de componente do Cloud Run.

  2. Crie um modelo de catálogo para o 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
    

    Substitua cloud-storage-component pelo identificador do modelo de componente do Cloud Storage.

  3. Crie uma revisão de modelo importando o módulo do Terraform do Cloud Run do repositório 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"
    

    Substitua:

    • CONNECTION_ID: o ID da conexão do Developer Connect.
    • GIT_REPO_LINK_ID: o ID do link do repositório Git vinculado.
  4. Crie uma revisão de modelo importando o módulo do Terraform do Cloud Storage do repositório 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"
    

    Substitua:

    • CONNECTION_ID: o ID da conexão do Developer Connect.
    • GIT_REPO_LINK_ID: o ID do link do repositório Git vinculado.
  5. Liste os modelos compartilhados no seu espaço para recuperar os IDs deles:

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

    Na resposta ao comando, observe o segmento SHARED_TEMPLATE_ID do campo name (projects/PROJECT_ID/locations/us-central1/spaces/default-space/sharedTemplates/SHARED_TEMPLATE_ID) para cloud-run-component e cloud-storage-component.

Criar um modelo de aplicativo composto

Combine os modelos de componente em um modelo de aplicativo composto e configure as conexões de parâmetro. O App Lifecycle Manager usa modelos compostos para gerenciar a topologia do aplicativo como uma oferta de SaaS. Especifique as saídas e entradas para garantir que o serviço do Cloud Run receba automaticamente o nome do bucket e as permissões do IAM necessárias para acessar o Cloud Storage.

  1. Criar um modelo de aplicativo composto:

    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
    

    Substitua run-storage-app pelo identificador do modelo de aplicativo composto.

  2. Adicione o componente do Cloud Run ao modelo de aplicativo:

    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"
    

    Substitua RUN_SHARED_TEMPLATE_ID pelo ID do modelo compartilhado do cloud-run-component que você recuperou.

  3. Adicione o componente do Cloud Storage ao modelo do aplicativo:

    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"
    

    Substitua STORAGE_SHARED_TEMPLATE_ID pelo ID do modelo compartilhado do cloud-storage-component que você recuperou.

  4. Crie uma conexão do serviço do Cloud Run com o bucket do Cloud Storage. Isso vincula a saída do bucket à variável de ambiente do serviço e concede acesso do IAM à conta de serviço:

    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. Confirme o modelo de aplicativo para gerar uma revisão de modelo imutável:

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

    A resposta ao comando confirma o identificador de revisão gerado (como r-1), que você vai referenciar ao criar sua oferta de SaaS no App Lifecycle Manager.


Implantar ambientes de clientes com o App Lifecycle Manager

Use o App Lifecycle Manager para transformar seu modelo de aplicativo em um produto implantável e provisionar ambientes dedicados para cada cliente.

Empacotar o modelo de aplicativo

Registre a revisão do modelo no App Lifecycle Manager para criar uma oferta de SaaS implantável:

  1. Crie a oferta de SaaS em 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"
    

    Substitua saas-run-storage pelo identificador da oferta de SaaS.

  2. Liste os lançamentos gerados para recuperar o ID de lançamento, o tipo de unidade e as variáveis de entrada:

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

    O App Lifecycle Manager cria e empacota o blueprint do modelo composto de forma assíncrona. Se a lista estiver vazia, aguarde alguns minutos e execute o comando novamente.

    O comando gera as seguintes informações:

    • O campo name (por exemplo, projects/PROJECT_ID/locations/us-central1/releases/r-r-1-06c6a0). O segmento final é o RELEASE_ID (como r-r-1-06c6a0).
    • O campo unitKind (por exemplo, projects/PROJECT_ID/locations/us-central1/unitKinds/u-native-components-e97e0c). O segmento final é o UNIT_KIND_ID (como u-native-components-e97e0c).

Criar uma conta de serviço de implantação

Crie uma conta de serviço que conceda ao App Lifecycle Manager permissão para provisionar recursos em seu nome:

  1. Crie a conta de serviço de atuação:

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

    Substitua tenant-actuation-sa pelo nome da conta de serviço de atuação.

  2. Crie o e-mail da conta de serviço e recupere a identidade do agente de serviço do 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. Conceda à conta de serviço de atuação os papéis necessários para criar e gerenciar a infraestrutura do locatário:

    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. Conceda aos agentes de serviço do App Lifecycle Manager e do Infra Manager permissão para personificar a conta de serviço de atuação:

    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
    

Implantar um ambiente para um cliente

Crie um ambiente de cliente e acione a implantação da infraestrutura dedicada:

  1. Crie um ambiente Unit que represente um locatário de cliente isolado usando o tipo de unidade gerado:

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

    Substitua tenant-1 pelo identificador da unidade de locação.

  2. Acione uma operação de unidade para provisionar a infraestrutura do locatário:

    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. Descreva a operação da unidade para monitorar o status de provisionamento até que ele chegue a SUCCEEDED:

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

Automatizar atualizações em ambientes de clientes

Use as distribuições para implantar com segurança as atualizações de aplicativos em todos os ambientes do cliente.

Escolher uma estratégia de atualização

Defina como as atualizações são entregues aos ambientes do cliente, como implantar tudo de uma vez ou em fases:

  1. Crie um RolloutKind para definir a estratégia de orquestração das suas 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"
    

    Substitua progressive-rollout pelo identificador do tipo de lançamento.

Implantar e acompanhar a atualização

Inicie o lançamento e monitore o progresso até que a implantação seja concluída:

  1. Acione o lançamento para implantar a versão em todas as unidades de locatário qualificadas:

    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"
    

    Substitua rollout-v1 pelo identificador do lançamento.

  2. Descreva o lançamento para inspecionar a execução ativa e verificar se o status chega a SUCCEEDED:

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

    A saída do lançamento confirma que as unidades de locatário foram atualizadas para a revisão do modelo de destino.

Limpar

Para evitar cobranças na sua conta do Google Cloud pelos recursos usados no tutorial, exclua o projeto que os contém ou mantenha o projeto e exclua os recursos individuais.

Excluir o projeto

Excluir um projeto do Google Cloud :

gcloud projects delete PROJECT_ID

Excluir recursos individuais

Se você implantou os recursos do tutorial em um projeto atual, exclua os recursos individuais na ordem inversa de dependência para evitar cobranças inesperadas:

  1. Desprovisione a infraestrutura do ambiente do cliente e aguarde a conclusão:

    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. Exclua o ambiente do cliente do App Lifecycle Manager:

    gcloud beta app-lifecycle-manager units delete "tenant-1" \
        --location="us-central1" \
        --quiet
    
  3. Exclua os recursos de lançamento e versão do App Lifecycle Manager na ordem inversa de dependência:

    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. Exclua o modelo de aplicativo, as entradas do catálogo e o espaço do 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. Exclua o link e a conexão do repositório Git do 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. Exclua a conta de serviço de atuação:

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

A seguir