Usar pipelines sem servidor com o Active Assist

Este documento destina-se a arquitetos empresariais e programadores de software que querem criar um pipeline de automatização para usar o Active Assist na respetiva organização. Google Cloud Faz parte de uma série que aborda padrões de arquitetura que as empresas podem usar para otimizar a respetiva presença na nuvem em grande escala através do Active Assist. A série é composta pelas seguintes partes:

Este tutorial mostra como usar Google Cloud tecnologias sem servidor para criar um pipeline de automatização para obter e processar recomendações do Active Assist. Baseia as recomendações nas regras empresariais definidas pela sua empresa. O pipeline de automatização que configurar neste tutorial ajuda a trabalhar com o Active Assist em grande escala, mantendo um processo de revisão e acionamento liderado pela equipa. Esta abordagem é útil quando a sua empresa quer dimensionar a utilização do portefólio do Active Assist, mas manter o controlo do processo de revisão e acionamento nas equipas. Oferece uma alternativa à utilização de um pipeline de integração contínua e entrega contínua (CI/CD).

A arquitetura demonstrada neste tutorial é genérica e pode expandi-la para funcionar com outros produtos sem servidor. O tutorial pressupõe que tem conhecimentos das seguintes Google Cloud tecnologias:

Para concluir este tutorial, tem de ter uma conta do Slack ou uma ferramenta de processamento de notificações ou pedidos semelhante. A ferramenta tem de estar configurada no seu computador e pronta a usar.

Arquitetura

Uma vez que a arquitetura demonstrada neste tutorial é modular, pode adaptar o componente de notificações para corresponder aos requisitos da sua empresa. Este tutorial demonstra como gerar notificações e enviá-las para o Slack. Também pode optar por enviar notificações para o Pub/Sub ou qualquer outra ferramenta de processamento de notificações ou pedidos.

O diagrama de arquitetura seguinte mostra os componentes que usa neste tutorial:

Pipeline sem servidor.

A arquitetura tem os seguintes componentes:

  • Um serviço do Cloud Run que um agendador aciona a intervalos fixos. O serviço invoca as APIs Recommender lendo os metadados (IDs dos projetos e tipos de recomendadores) que estão definidos e armazenados numa coleção do Firestore.
  • Um tópico do Pub/Sub para o qual as recomendações do Active Assist são enviadas e no qual são processadas.
  • Um segundo serviço do Cloud Run que analisa as recomendações do Active Assist. Este serviço determina como as recomendações são processadas com base nas regras empresariais definidas pela sua empresa e armazenadas numa coleção do Firestore.
  • Duas coleções do Firestore para armazenar os metadados da empresa e as regras empresariais. As coleções do Firestore funcionam da seguinte forma:
    • A primeira recolha armazena os metadados da empresa relevantes para obter recomendações do Active Assist. Neste tutorial, os atributos recommendation type, Google Cloud project IDs e locations são usados como metadados da empresa. Estes atributos são usados pelo serviço recommendation-collectorCloud Run para determinar que tipos de recomendações são obtidos.
    • A segunda coleção armazena regras empresariais que são aplicadas quando as recomendações são processadas.

Objetivos

  • Crie um serviço do Cloud Run de exemplo para obter recomendações do Active Assist para um projeto de exemplo e enviá-las para um tópico do Pub/Sub.
  • Crie duas coleções do Firestore para armazenar metadados de amostra e regras empresariais, respetivamente.
  • Crie um segundo serviço do Cloud Run para processar recomendações de acordo com as regras empresariais de exemplo que definir neste tutorial.
  • Crie um canal do Slack para o qual o serviço do Cloud Run envia recomendações de exemplo do Active Assist.
  • Teste o pipeline completo com exemplos de recomendações do Active Assist.

Custos

Neste documento, usa os seguintes componentes faturáveis do Google Cloud:

Para gerar uma estimativa de custos com base na sua utilização prevista, use a calculadora de preços.

Os novos Google Cloud utilizadores podem ser elegíveis para uma avaliação gratuita.

Quando terminar as tarefas descritas neste documento, pode evitar a faturação contínua eliminando os recursos que criou. Para mais informações, consulte o artigo Limpe.

Antes de começar

  1. In the Google Cloud console, go to the project selector page.

    Go to project selector

  2. 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.
  3. Tome nota do Google Cloud ID do projeto do gestor de recomendações projeto. Precisa deste ID na secção seguinte sobre a configuração do ambiente.

  4. Enable the Cloud Build, Firestore, App Engine,Pub/Sub, Cloud Run, Cloud Scheduler, and Cloud Source Repositories APIs.

    Roles required to enable APIs

    To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

    Enable the APIs

    Usa as credenciais da aplicação predefinidas para este tutorial. Se lhe for pedido que crie credenciais na página Adicione credenciais ao seu projeto, clique em Cancelar.

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

  6. Crie o seguinte:
    • Um exemplo de um canal do Slack.
    • Uma app Slack de exemplo e um webhook de entrada para receber notificações geradas por um motor denominado recommendation-rules-engine. Configura o motor mais tarde neste tutorial.
    Para mais informações, consulte os artigos Crie um canal do Slack e Envio de mensagens através de webhooks de entrada.

    Depois de criar uma app Slack e um URL de webhook de entrada, anote o URL, pois vai precisar dele mais tarde neste tutorial.

Criar o pipeline sem servidor

Nesta secção, cria os componentes de que precisa para criar o pipeline sem servidor. A plataforma gera recomendações do Active Assist com base nos padrões de utilização e nas métricas do sistema. Consoante as recomendações geradas, cada categoria de recomendações pode usar um período predefinido diferente do passado para analisar os dados de utilização e as métricas.

Se tiver um projeto Google Cloud de exemplo com recursos existentes e recomendações do Active Assist, pode executar o pipeline para processar essas recomendações depois de fazer as alterações adequadas ao exemplo de código fornecido.

Crie as coleções do Firestore

Nesta secção, cria duas coleções do Firestore. A primeira, a coleção activeassist-metadata, armazena os metadados da empresa relevantes para obter recomendações do Active Assist. A segunda, a coleção activeassist-business-rules, armazena as regras empresariais que são aplicadas quando o pipeline processa recomendações.

Quando as recomendações do Active Assist são analisadas, com base nas regras empresariais na coleção do Firestore, é gerada e enviada uma notificação ou a recomendação é aplicada automaticamente ao recurso relevante. Google Cloud

Crie a coleção activeassist-metadata

  1. Na Google Cloud consola, aceda à página do Firestore.

    Abrir Firestore

  2. Crie uma base de dados do Firestore se ainda não tiver uma. Em alternativa, se já tiver uma base de dados do Firestore, avance para o passo seguinte.

    Crie a base de dados:

    1. Clique em Selecionar modo nativo para ativar o Firestore.
    2. Selecione uma localização da região perto da região onde os seus serviços do Cloud Run são executados.
    3. Clique em Criar base de dados. Demora alguns momentos a concluir a configuração.

  3. Na página do Firestore, clique em Iniciar recolha.

  4. No campo ID da coleção, introduza o seguinte: activeassist-metadata.

  5. Preencha os campos conforme mostrado na tabela seguinte. Para adicionar o campo seguinte, clique em Adicionar campo.

    Nome do campo Tipo de campo Valor do campo Nota
    project string Stub-Project-ID Este tutorial usa um marcador para o valor do campo. Se quiser usar recomendações de um projeto existente, introduza o ID do projeto. Google Cloud
    locations array global Algumas recomendações podem ser específicas da região ou da zona, como recomendações de redimensionamento de VMs. Outras recomendações são globais, por exemplo, recomendações da IAM.
    recommenderType string google.iam.policy.Recommender Não aplicável.

  6. Quando os campos estiverem preenchidos, clique em Guardar.

Crie a coleção activeassist-business-rules

  1. Clique em Iniciar recolha.

  2. No campo ID da coleção, introduza o seguinte: activeassist-business-rules

    Preencha o documento conforme mostrado na tabela seguinte. Para adicionar o campo seguinte, clique em Adicionar campo.

    Nome do campo Tipo de campo Valor do campo Nota
    action string Notify Se definir o valor como Apply, o serviço aplica a recomendação e remove a função não usada.
    projectId string Stub-Project-ID Este tutorial usa uma recomendação de teste. Se quiser usar recomendações de um projeto Google Cloud existente, introduza o ID do projeto.
    projectNumber string 999999999 Este tutorial usa uma recomendação de teste.

    Se estiver a usar uma recomendação de um projeto Google Cloud existente, introduza o número do projeto. Pode encontrar o número do projeto na Google Cloud página de boas-vindas da consola
    recommenderType string google.iam.policy.Recommender Não aplicável.
    recommenderSubtype string REMOVE_ROLE Não aplicável.
    slackWebhookURL string Introduza o URL do webhook do Slack que gerou num passo anterior. O URL é semelhante ao seguinte:

    https://hooks.slack.com/services/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

    Este tutorial mostra como criar uma regra para determinar se uma recomendação é aplicada automaticamente ou se é gerada uma notificação e enviada para uma plataforma como o Slack. Para saber como uma recomendação pode ser aplicada automaticamente com base na avaliação de regras empresariais de exemplo que configurou, consulte o repositório associado.

  3. Quando o documento estiver preenchido, clique em Guardar.

Criar um serviço do Cloud Run agendado

Nesta secção, cria um serviço do Cloud Run agendado denominado recommendation-collector que invoca a API Recommender e obtém recomendações ativas. A API Recommender do Identity and Access Management é usada neste tutorial como a API Recommender. O serviço lê os metadados da coleção do activeassist-metadata Firestore que criou para determinar que recomendações obter.

  1. Clique em Abrir no Cloud Shell para abrir o Cloud Shell para o projeto do gestor de recomendações.

    Abrir no Cloud Shell

    Quando o Cloud Shell é aberto, os seguintes comandos são executados:

    Quando a caixa de diálogo Abrir no Cloud Shell for apresentada, selecione Confiar e, de seguida, clique em Confirmar.

  2. Defina o ID do projeto e o número do projeto do projeto do Gestor de recomendações atual como variáveis:

    export RECO_MGR_PROJECT=PROJECT_ID
gcloud config set project $RECO_MGR_PROJECT
export RECO_MGR_PROJECT_NUMBER=$(gcloud projects describe $DEVSHELL_PROJECT_ID --format='value(projectNumber)')

    Substitua PROJECT_ID pelo ID do seu projeto. Depois de introduzir os comandos, clique em Autorizar quando lhe for pedido.

  3. Defina a variável para a região de implementação:

    export REGION=us-central1

    Embora este tutorial use a região us-central1, pode usar qualquer região onde o Cloud Run esteja disponível.

  4. Crie uma variável de ambiente para a sua imagem do Docker:

    export RECOMMENDER_IMAGE=gcr.io/$RECO_MGR_PROJECT/recommendation-collector:1.0

  5. Crie a imagem de Docker e carregue-a para o Container Registry:

     gcloud builds submit --tag $RECOMMENDER_IMAGE

  6. Crie uma conta de serviço para o serviço recommendation-collector interagir com outros serviços na pipeline: Google Cloud 

    gcloud iam service-accounts create recommendation-collector-sa \
  --description "Service Account that the recommendation-collector service uses to invoke other Google Cloud services" \
  --display-name "recommendation-collector-sa" \
  --project $RECO_MGR_PROJECT

    É uma boa prática conceder autorizações detalhadas aos seus serviços do Cloud Run atribuindo funções predefinidas à conta de serviço. Para saber mais, consulte o artigo Identidade do serviço.

  7. Conceda à conta de serviço do serviço recommendation-collector acesso ao Firestore e à API Recommender:

    gcloud projects add-iam-policy-binding $RECO_MGR_PROJECT \
  --member serviceAccount:recommendation-collector-sa@$RECO_MGR_PROJECT.iam.gserviceaccount.com \
  --role roles/datastore.user
gcloud projects add-iam-policy-binding $RECO_MGR_PROJECT \
  --member serviceAccount:recommendation-collector-sa@$RECO_MGR_PROJECT.iam.gserviceaccount.com \
  --role roles/pubsub.publisher

  8. Se estiver a executar este tutorial com o exemplo stub fornecido no repositório que clonou, avance para o passo seguinte.

    Se estiver a criar o pipeline neste tutorial com recomendações geradas para um projeto existente, tem de atribuir autorizações da IAM às contas de serviço que criou para executar os dois serviços do Cloud Run. Google Cloud

    Defina uma variável de ambiente, TEST_PROJECT_ID, com o ID do projeto para o qual executa este pipeline antes de executar os comandos:

    export TEST_PROJECT_ID=TEST_PROJECT_ID
gcloud projects add-iam-policy-binding $TEST_PROJECT_ID \
  --member serviceAccount:recommendation-collector-sa@$RECO_MGR_PROJECT.iam.gserviceaccount.com \
  --role roles/recommender.iamAdmin
gcloud projects add-iam-policy-binding $TEST_PROJECT_ID \
  --member serviceAccount:recommendation-collector-sa@$RECO_MGR_PROJECT.iam.gserviceaccount.com \
  --role roles/serviceusage.serviceUsageConsumer
gcloud services enable recommender.googleapis.com --project $TEST_PROJECT_ID

    Certifique-se de que o ID do projeto que usa corresponde ao que introduziu ao criar as coleções do Firestore.

  9. Para este tutorial, implementa o serviço com uma variável de ambiente denominada STUB_RECOMMENDATIONS. Esta variável permite-lhe usar um stub para testar o pipeline.

    Implemente o serviço do Cloud Run:

    gcloud run deploy recommendation-collector \
  --image=$RECOMMENDER_IMAGE \
  --no-allow-unauthenticated \
  --region $REGION \
  --platform managed \
  --service-account recommendation-collector-sa@$RECO_MGR_PROJECT.iam.gserviceaccount.com \
  --set-env-vars="STUB_RECOMMENDATIONS=true" \
  --project $RECO_MGR_PROJECT \

    Aceite todos os comandos do sistema.

    Se quiser executar o pipeline com recomendações do Active Assist geradas para um projeto, remova a seguinte linha do comando antes de o implementar: Google Cloud 

    --set-env-vars="STUB_RECOMMENDATIONS=true"

Configure uma tarefa do Cloud Scheduler para executar o recommender-collector service

  1. No Cloud Shell, crie uma conta de serviço para que os trabalhos do Cloud Scheduler usem para executar o serviço recommendation-collector:

    gcloud iam service-accounts create recommender-scheduler-sa \
  --description "Service Account used by Cloud Scheduler to invoke the recommender-parser service" \
  --display-name "recommender-scheduler-sa" \
  --project $RECO_MGR_PROJECT

  2. Atribua à conta de serviço a função run/invoker para lhe permitir invocar o serviço do Cloud Run:

    gcloud run services add-iam-policy-binding recommendation-collector \
  --member=serviceAccount:recommender-scheduler-sa@$RECO_MGR_PROJECT.iam.gserviceaccount.com \
  --role=roles/run.invoker \
  --region=$REGION \
  --platform=managed

  3. Obtenha o recommendation-collector URL do serviço:

    export RECOMMENDER_SERVICE_URI=`gcloud run services describe recommendation-collector \
  --platform managed \
  --project $RECO_MGR_PROJECT \
  --region $REGION \
  --format="value(status.url)"`/run

  4. Crie uma tarefa do Cloud Scheduler denominada recommender-iam-scheduler:

    gcloud scheduler jobs create http recommender-iam-scheduler \
  --project $RECO_MGR_PROJECT \
  --time-zone "America/Los_Angeles" \
  --schedule="0 */3 * * *" \
  --uri=$RECOMMENDER_SERVICE_URI \
  --description="Scheduler job to invoke recommendation pipeline" \
  --oidc-service-account-email="recommender-scheduler-sa@$RECO_MGR_PROJECT.iam.gserviceaccount.com" \
  --headers="Content-Type=application/json" \
  --http-method="POST"

    Defina o fuso horário para corresponder à sua localização. O formato do valor do fuso horário baseia-se na base de dados tz.

    Para mais informações, consulte gcloud scheduler jobs create http.

    A tarefa do Cloud Scheduler invoca a rota /run para o serviço recommendation-collector.

    A definição da flag --schedule="0 */3 * * *" executa a tarefa do agendador a cada três horas. Pode alterar esta definição de acordo com os seus requisitos. Para mais informações, consulte o artigo Configurar programações de tarefas cron.

Crie o motor de regras de recomendações para processar recomendações

Nesta secção, cria um segundo serviço do Cloud Run denominado recommendation-rules-engine para processar as recomendações que o serviço recommendation-collector recolhe. O serviço recommendation-rules-engine é invocado pelo Pub/Sub quando são enviadas novas recomendações para o tópico activeassist-recommendations.

Este serviço analisa as recomendações com base nas regras empresariais que definiu na recolha activeassist-business-rules.

  1. No Cloud Shell, abra o diretório recommendation-rules-engine:

    cd ../recommendation-rules-engine

  2. Crie uma variável de ambiente para a sua imagem do Docker:

    export RULES_ENGINE_IMAGE=gcr.io/$RECO_MGR_PROJECT/recommendation-rules-engine:1.0

  3. Crie a imagem de Docker e carregue-a para o Container Registry:

    gcloud builds submit --tag $RULES_ENGINE_IMAGE

  4. Crie uma conta de serviço para o serviço recommendation-rules-engine interagir com outros serviços Google Cloud no pipeline:

    gcloud iam service-accounts create recommendation-rules-sa \
 --description "Service Account that recommendation-rules-engine uses to invoke other Google Cloud services" \
 --display-name "recommendation-rules-sa" \
 --project $RECO_MGR_PROJECT

  5. Conceda à conta de serviço do serviço recommendation-rules-engine acesso ao Firestore:

    gcloud projects add-iam-policy-binding $RECO_MGR_PROJECT \
  --member serviceAccount:recommendation-rules-sa@$RECO_MGR_PROJECT.iam.gserviceaccount.com \
  --role roles/datastore.user

    Se estiver a usar os stubs fornecidos para este tutorial, avance para o passo seguinte.

    Se estiver a testar o pipeline com recomendações geradas para um Google Cloud projeto em vez dos stubs fornecidos para este tutorial, execute os seguintes comandos para permitir que a conta de serviço do motor de regras aceda ao seu projeto:

    gcloud projects add-iam-policy-binding $TEST_PROJECT_ID \
  --member serviceAccount:recommendation-rules-sa@$RECO_MGR_PROJECT.iam.gserviceaccount.com \
  --role roles/serviceusage.serviceUsageConsumer
gcloud projects add-iam-policy-binding $TEST_PROJECT_ID \
  --member serviceAccount:recommendation-rules-sa@$RECO_MGR_PROJECT.iam.gserviceaccount.com \
  --role roles/recommender.iamAdmin
gcloud projects add-iam-policy-binding $TEST_PROJECT_ID \
  --member serviceAccount:recommendation-rules-sa@$RECO_MGR_PROJECT.iam.gserviceaccount.com \
  --role roles/resourcemanager.projectIamAdmin

  6. Implemente o serviço do Cloud Run:

    gcloud run deploy recommendation-rules-engine \
  --image=$RULES_ENGINE_IMAGE \
  --no-allow-unauthenticated \
  --region $REGION \
  --platform managed \
  --service-account recommendation-rules-sa@$RECO_MGR_PROJECT.iam.gserviceaccount.com \
  --project $RECO_MGR_PROJECT

    Aceite todos os comandos do sistema.

  7. Obtenha o URL recommendation-rules-engine:

    export RECOMMENDER_SERVICE_RULES_URI=`gcloud run services describe recommendation-rules-engine \
  --platform managed \
  --project $RECO_MGR_PROJECT \
  --region $REGION \
  --format="value(status.url)"`/process

    O URL que obtém neste passo é invocado quando novas recomendações ficam disponíveis através do tópico do Pub/Sub que cria no passo seguinte.

Crie um tópico Pub/Sub para recomendações ativas

Nesta secção, cria um tópico do Pub/Sub para as recomendações do Active Assist que o serviço recommender-collector obtém invocando a API Recommender.

  1. No Cloud Shell, crie um tópico do Pub/Sub:

    gcloud pubsub topics create activeassist-recommendations

  2. Crie uma conta de serviço para o Pub/Sub usar para invocar o serviço do Cloud Run:recommendation-rules-engine

    gcloud iam service-accounts create recommendation-engine-sub-sa \
  --description "Service Account used by Pub/Sub to push recommendations to the recommendation-rules-engine service" \
  --display-name "recommendation-engine-sub-sa" \
  --project $RECO_MGR_PROJECT

  3. A conta de serviço do Pub/Sub tem de estar associada às funções de que precisa para publicar mensagens e invocar o serviço recommendation-rules-engine:

    gcloud projects add-iam-policy-binding $RECO_MGR_PROJECT \
  --member serviceAccount:recommendation-engine-sub-sa@$RECO_MGR_PROJECT.iam.gserviceaccount.com \
  --role roles/run.invoker \
  --project $RECO_MGR_PROJECT

Crie uma subscrição para o tópico Pub/Sub

  1. Crie uma subscrição para o serviço recommendation-rules-engine:

    # grant Pub/Sub the permission to create tokens
PUBSUB_SERVICE_ACCOUNT="service-$RECO_MGR_PROJECT_NUMBER@gcp-sa-pubsub.iam.gserviceaccount.com"
gcloud projects add-iam-policy-binding $RECO_MGR_PROJECT \
  --member="serviceAccount:$PUBSUB_SERVICE_ACCOUNT"\
  --role='roles/iam.serviceAccountTokenCreator'
# configure the subscription push identity
gcloud pubsub subscriptions create active-assist-recommendations-for-rules-engine \
  --topic=activeassist-recommendations \
  --topic-project=$RECO_MGR_PROJECT \
  --push-auth-service-account=recommendation-engine-sub-sa@$RECO_MGR_PROJECT.iam.gserviceaccount.com \
  --ack-deadline=60 \
  --push-endpoint=$RECOMMENDER_SERVICE_RULES_URI

  2. Permita que a conta de serviço do recommendation-engine-sub-sa que criou invoque o serviço recommendation-rules-engine:

    gcloud run services add-iam-policy-binding recommendation-rules-engine \
  --member=serviceAccount:recommendation-engine-sub-sa@$RECO_MGR_PROJECT.iam.gserviceaccount.com \
  --role=roles/run.invoker \
  --region=$REGION \
  --platform=managed

Executar testes ponto a ponto com stubs

As recomendações do Active Assist são geradas pela plataforma com base nos padrões de utilização e nas métricas do sistema. Cada categoria de recomendações pode usar um período de tempo predefinido diferente no passado para analisar os dados de utilização e as métricas com base nas recomendações geradas. Por exemplo, as recomendações da IAM são geradas pela plataforma com base nos padrões de utilização dos últimos 90 dias.

Para testar o pipeline ponto a ponto, o repositório que clonou para este tutorial fornece recomendações de exemplo (simulações) que usa para executar o pipeline ponto a ponto.

Nesta secção, faz o seguinte:

  • Inspeccione as recomendações de substituição.
  • Invocar o pipeline manualmente.
  • Verifique se é gerada uma notificação e enviada para o canal do Slack que criou.

  1. Reveja as recomendações de exemplo fornecidas no repositório:

    cat ../recommendation-collector/stub.json

    Este ficheiro fornece uma recomendação de exemplo com uma ação REMOVE para uma função de exemplo denominada roles/gkehub.connect.

  2. Execute o seguinte comando para que o Cloud Scheduler execute a tarefa imediatamente, em vez de esperar pela próxima execução agendada:

    gcloud scheduler jobs run recommender-iam-scheduler

  3. Na página da consola do Cloud Scheduler, na coluna Resultado para a tarefa, verifique se o resultado é Êxito.recommender-iam-scheduler

    Para ver uma vista detalhada dos passos que cada um dos serviços executa, também pode ver os registos do serviço do Cloud Run para o serviço recommendation-collector e o serviço recommendation-rules-engine.

  4. Quando o pipeline ponto a ponto sem servidor que cria neste tutorial é executado com êxito, gera uma notificação do Slack que contém detalhes da associação de funções recomendada para remover. Segue-se um exemplo da notificação que recebe:

    Project xxxxxxxx\
**Impact**: SECURITY\
This role has not been used during the observation window.\
**Role**: roles/gkehub.connect\
**Member**:
serviceAccount:sample-sa@recommendation-sample.iam.gserviceaccount.com\
**Action**: remove

Limpar

Para evitar incorrer em custos na sua conta do Google Cloud pelos recursos usados neste tutorial, elimine o projeto que contém os recursos ou mantenha o projeto e elimine os recursos individuais.

  • In the Google Cloud console, go to the Manage resources page.

    Go to Manage resources

  • In the project list, select the project that you want to delete, and then click Delete.
  • In the dialog, type the project ID, and then click Shut down to delete the project.

    • O que se segue?