Como usar pipelines sem servidor com o Active Assist

Last reviewed 2021-06-09 UTC

Este documento é destinado a arquitetos corporativos e desenvolvedores de software que querem criar um pipeline de automação para usar o Active Assist na organização do Google Cloud. Ele faz parte de uma série que discute os padrões arquitetônicos que as empresas podem usar para otimizar a abrangência na nuvem em escala usando o Active Assist. A série consiste nas partes a seguir:

Neste tutorial, mostramos como usar as tecnologias sem servidor do Google Cloud para criar um pipeline de automação para recuperar e processar recomendações do Active Assist. As recomendações das regras de negócios definidas pela sua empresa são baseadas nas recomendações. O pipeline de automação configurado neste tutorial ajuda você a trabalhar com o Active Assist em escala enquanto mantém um processo de revisão e atuação conduzido pela equipe. Essa abordagem é útil quando sua empresa quer escalonar o uso do portfólio do Active Assist, mas manter o controle do processo de revisão e atuação nas equipes. Ele oferece uma alternativa ao uso de um pipeline de integração e entrega contínuas (CI/CD).

A arquitetura demonstrada neste tutorial é genérica e pode ser estendida para trabalhar com outros produtos sem servidor. Neste tutorial, presumimos que você esteja familiarizado com as seguintes tecnologias do Google Cloud:

Para concluir este tutorial, você precisa ter uma conta do Slack ou uma ferramenta semelhante de notificação ou processamento de tíquetes. A ferramenta precisa estar configurada na máquina e pronta para uso.

Arquitetura

Como a arquitetura demonstrada neste tutorial é modular, é possível adaptar o componente de notificações para atender aos requisitos da sua empresa. Neste tutorial, você aprenderá como gerar notificações e enviá-las ao Slack. Também é possível enviar notificações ao Pub/Sub ou qualquer outra ferramenta de processamento de tíquete ou notificação.

O diagrama de arquitetura a seguir mostra os componentes que serão usados neste tutorial:

Pipeline sem servidor.

A arquitetura tem os seguintes componentes:

  • Um serviço do Cloud Run que um programador aciona em intervalos fixos. O serviço invoca as APIs do Recommender lendo os metadados (IDs de projeto e tipos de recomendador) definidos e mantidos em uma coleção do Firestore.
  • Um tópico do Pub/Sub em que as recomendações do Active Assist são enviadas e processadas.
  • Um segundo serviço do Cloud Run que analisa as recomendações do Active Assist. Esse serviço determina como as recomendações são processadas com base nas regras de negócios definidas por sua empresa e armazenadas em uma coleção do Firestore.
  • duas coleções do Firestore para armazenar os metadados e as regras de negócios. As coleções do Firestore operam da seguinte maneira:
    • A primeira coleção armazena os metadados comerciais relevantes para recuperar as recomendações do Active Assist. Neste tutorial, os atributos recommendation type, Google Cloud project IDs e locations são usados como metadados comerciais. Esses atributos são usados pelo serviço recommendation-collector do Cloud Run para determinar quais tipos de recomendação são buscados.
    • A segunda coleção armazena regras de negócios que são aplicadas quando as recomendações são processadas.

Objetivos

  • Criar um serviço de amostra do Cloud Run para recuperar recomendações do Active Assist para um projeto de amostra e enviá-las para um tópico do Pub/Sub.
  • Crie duas coleções do Firestore para armazenar metadados de amostra e regras de negócios, respectivamente.
  • Crie um segundo serviço do Cloud Run para processar recomendações de acordo com as regras de negócios de amostra definidas neste tutorial.
  • Crie um canal do Slack para o qual o serviço do Cloud Run envia amostras de recomendações do Active Assist.
  • Teste o pipeline completo com amostras de recomendações do Active Assist.

Custos

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

Para gerar uma estimativa de custo baseada na projeção de uso deste tutorial, use a calculadora de preços. Novos usuários do Google Cloud podem estar qualificados para uma avaliação gratuita.

Ao concluir as tarefas descritas neste documento, é possível evitar o faturamento contínuo excluindo os recursos criados. Saiba mais em Limpeza.

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.

  3. Anote o ID do projeto do Google Cloud no gerenciador de recomendações. Esse ID será necessário na próxima seção, em que você vai configurar seu ambiente.

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

    Enable the APIs

    Você usa as credenciais padrão do aplicativo para isso. Se for solicitado que você crie credenciais na página Adicionar credenciais ao seu projeto, clique em Cancelar.

  5. Make sure that billing is enabled for your Google Cloud project.

  6. Crie o seguinte:
    • Um exemplo de canal do Slack.
    • Um aplicativo Slack de amostra e um webhook de entrada para receber notificações geradas por um mecanismo chamado recommendation-rules-engine. Você irá configurar o mecanismo posteriormente neste tutorial.
    Para mais informações, consulte Criar um canal do Slack e Como enviar mensagens usando webhooks de entrada.

    Ao criar um aplicativo do Slack e um URL de webhook de entrada, anote o URL porque ele será necessário posteriormente neste tutorial.

Como criar o pipeline sem servidor

Nesta seção, você criará os componentes necessários para criar o pipeline sem servidor. A plataforma gera recomendações do Active Assist com base em padrões de uso e métricas do sistema. Dependendo das recomendações geradas, cada categoria de recomendação pode usar um período padrão diferente do passado para analisar os dados e as métricas de uso.

Se você tiver uma amostra de projeto do Google Cloud que tenha recursos e recomendações do Active Assist, execute o pipeline para processar essas recomendações depois de fazer as alterações apropriadas no código de amostra fornecido.

Criar as coleções do Firestore

Nesta seção, você cria duas coleções do Firestore. A primeira coleção de activeassist-metadata armazena os metadados comerciais relevantes para recuperar recomendações do Active Assist. A segunda, a coleção activeassist-business-rules, armazena as regras de negócios que são aplicadas quando o pipeline processa as recomendações.

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

Criar a coleção activeassist-metadata

  1. No Console do Google Cloud, acesse a página Firestore.

    Abrir o Firestore

  2. Crie um banco de dados do Firestore, se você ainda não tiver um. Como alternativa, se você já tiver um banco de dados do Firestore, pule para a próxima etapa.

    Crie o banco de dados:

    1. Clique em Selecionar modo nativo para ativar o Firestore.
    2. Selecione um local de região próximo à região em que os serviços do Cloud Run são executados.
    3. Clique em Criar banco de dados. A configuração leva alguns instantes.

  3. Na página do Firestore, clique em Iniciar coleção.

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

  5. Preencha os campos conforme mostrado na tabela a seguir. Para adicionar o próximo campo, clique em Adicionar campo.

    Nome do campo Tipo de campo Valor do campo Observação
    project string Stub-Project-ID Este tutorial usa um stub para o valor do campo. Se você quiser usar recomendações de um projeto atual do Google Cloud, insira o ID do projeto.
    locations array global Algumas recomendações podem ser específicas da região ou da zona, como recomendações de redimensionamento de VM. Outras recomendações são globais, por exemplo, recomendações do IAM.
    recommenderType string google.iam.policy.Recommender Não relevante.

  6. Quando os campos forem preenchidos, clique em Salvar.

Criar a coleção activeassist-business-rules

  1. Clique em Iniciar coleção.

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

    Preencha o documento conforme mostrado na tabela a seguir. Para adicionar o próximo campo, clique em Adicionar campo.

    Nome do campo Tipo de campo Valor do campo Observação
    action string Notify Definir o valor como Apply faz com que o serviço aplique a recomendação e remova o papel não utilizado.
    projectId string Stub-Project-ID Neste tutorial, usamos uma recomendação de stub. Se você quiser usar recomendações de um projeto atual do Google Cloud, insira o ID do projeto.
    projectNumber string 999999999 Neste tutorial, usamos uma recomendação de stub.

    Se você estiver usando uma recomendação de um projeto atual do Google Cloud, insira o número do projeto. O número do projeto está na página de boas-vindas do console do Google Cloud.
    recommenderType string google.iam.policy.Recommender Não relevante.
    recommenderSubtype string REMOVE_ROLE Não relevante.
    slackWebhookURL string Digite o URL do webhook do Slack que você gerou em uma etapa anterior. O URL é semelhante a este:

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

    Neste tutorial, mostramos como criar uma regra para determinar se uma recomendação é aplicada automaticamente ou se uma notificação é gerada e enviada para uma plataforma como o Slack. Para saber como uma recomendação pode ser aplicada automaticamente com base na avaliação das regras de negócios de amostra que você configurou, consulte o repositório associado.

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

Como criar um serviço programado do Cloud Run

Nesta seção, você cria um serviço programado do Cloud Run chamado recommendation-collector que invoca a API Recommender e recupera recomendações ativas. A API Recommender do Identity and Access Management é usada neste tutorial como a API Recommender. O serviço lê metadados da coleção activeassist-metadata do Firestore que você criou para determinar quais recomendações recuperar.

  1. Clique em Abrir no Cloud Shell para abrir o Cloud Shell no projeto do gerenciador 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 exibida, selecione Confiar e clique em Confirmar.

  2. Defina o ID e o número do projeto do gerenciador 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 pela ID do seu projeto. Depois de inserir os comandos, clique em Autorizar quando for solicitado.

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

    export REGION=us-central1

    Neste tutorial, usamos a região us-central1, mas é possível usar qualquer região em que o Cloud Run esteja disponível.

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

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

  5. Crie a imagem do Docker e faça upload dela para o Container Registry:

     gcloud builds submit --tag $RECOMMENDER_IMAGE

  6. Crie uma conta de serviço para que o serviço recommendation-collector interaja com outros serviços do Google Cloud no pipeline:

    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

    Recomendamos conceder permissões granulares aos serviços do Cloud Run atribuindo papéis predefinidos à conta de serviço. Para saber mais, consulte Identidade do serviço.

  7. Conceda à conta de serviço o acesso recommendation-collector 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 você estiver executando este tutorial usando a amostra stub fornecida no repositório que você clonou, pule para a próxima etapa.

    Se você estiver criando o pipeline neste tutorial usando recomendações geradas para um projeto existente do Google Cloud, deverá atribuir permissões do IAM para as contas de serviço criadas para executar os dois serviços do Cloud Run.

    Defina uma variável de ambiente TEST_PROJECT_ID com o ID do projeto em que você executa esse 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

    Verifique se o ID do projeto que você usa corresponde ao que você inseriu ao criar as coleções do Firestore.

  9. Neste tutorial, você implantará o serviço com uma variável de ambiente chamada STUB_RECOMMENDATIONS. Essa variável permite usar um stub para testar o pipeline.

    Implante 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 todas as solicitações do sistema.

    Se você quiser executar o pipeline usando as recomendações do Active Assist geradas para um projeto do Google Cloud, remova a seguinte linha do comando antes de implantá-lo:

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

Configurar um job do Cloud Scheduler para executar o recommender-collector service

  1. No Cloud Shell, crie uma conta de serviço para que os jobs do Cloud Scheduler usem 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 o papel run/invoker para permitir que ela invoque 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. Consiga o URL do serviço recommendation-collector:

    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 um job do Cloud Scheduler chamado 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 é baseado no banco de dados tz.

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

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

    Definir a sinalização --schedule="0 */3 * * *" executa o job do Scheduler a cada três horas. É possível alterar essa configuração de acordo com seus requisitos. Para mais informações, consulte Como configurar programações de cron jobs.

Criar o mecanismo de regras de recomendação para processar as recomendações

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

Esse serviço analisa recomendações com base nas regras de negócios definidas na coleção 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 imagem do Docker:

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

  3. Crie a imagem do Docker e faça upload dela para o Container Registry:

    gcloud builds submit --tag $RULES_ENGINE_IMAGE

  4. Crie uma conta de serviço para que o serviço recommendation-rules-engine interaja com outros serviços do 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 o acesso recommendation-rules-engine 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 você estiver usando os stubs fornecidos neste tutorial, prossiga para a próxima etapa.

    Se você estiver testando o pipeline usando recomendações geradas para um projeto do Google Cloud em vez dos stubs fornecidos para este tutorial, execute os comandos a seguir para permitir que a conta de serviço do mecanismo de regras acesse 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. Implante 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 todas as solicitações do sistema.

  7. Consiga 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 recuperado nesta etapa é invocado quando novas recomendações são disponibilizadas pelo tópico do Pub/Sub que você criar na próxima etapa.

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

Nesta seção, você cria um tópico do Pub/Sub para as recomendações do Active Assist que o serviço recommender-collector recupera 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 recommendation-rules-engine do Cloud Run:

    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 precisa estar associada aos papéis necessários 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

Criar uma assinatura para o tópico do Pub/Sub

  1. Crie uma assinatura 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 recommendation-engine-sub-sa criada para invocar 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

Como executar testes completos usando stubs

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

Para testar o pipeline de ponta a ponta, o repositório clonado para este tutorial fornece exemplos de recomendações (stubs) que você usa para executar o pipeline de ponta a ponta.

Nesta seção, você realizará as ações a seguir:

  • Inspecione as recomendações de stub.
  • Invoque o pipeline manualmente.
  • Verifique se uma notificação foi gerada e enviada ao canal do Slack que você criou.

  1. Revise as recomendações de amostra fornecidas no repositório:

    cat ../recommendation-collector/stub.json

    Esse arquivo fornece um exemplo de recomendação com uma ação REMOVE para um papel de amostra chamado roles/gkehub.connect.

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

    gcloud scheduler jobs run recommender-iam-scheduler

  3. Na página do console do Cloud Scheduler, na coluna Resultado do job recommender-iam-scheduler, verifique se o resultado é Sucesso

    Para uma visão detalhada das etapas que cada um dos serviços executa, também é possível ver os registros de serviço do Cloud Run para os serviços recommendation-collector e recommendation-rules-engine. serviço.

  4. Quando o pipeline completo sem servidor criado neste tutorial é executado com êxito, ele gera uma notificação do Slack que contém detalhes da vinculação de papel recomendada para você remover. Veja a seguir um exemplo da notificação que você 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

Limpeza

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.

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

    • A seguir