Como usar pipelines sem servidor com o Active Assist

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 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 Google Cloud tecnologias sem servidor 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 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.

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 um projeto Google Cloud de amostra com recursos e recomendações do Active Assist, execute o pipeline para processar essas recomendações depois de fazer as mudanças necessárias 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 Google Cloud , acesse a página do 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 do Google Cloud atual, 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 do Google Cloud atual, 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 Google Cloud atual, insira o número do projeto. O número do projeto está na página de boas-vindas do console.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 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 Google Cloud existente, atribua permissões do IAM às 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 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 doGoogle 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