Escalonar automaticamente pools de workers com base nas métricas do Prometheus

Este tutorial descreve como escalonar automaticamente os pools de workers do Cloud Run com base nas métricas do Prometheus usando o escalonamento automático de métricas externas do Cloud Run (CREMA).

O serviço de escalonamento automático do CREMA realiza um cálculo baseado em proporção usando dados do Prometheus. O serviço de escalonamento automático ajusta dinamicamente a contagem de instâncias para garantir que o pool de workers tenha a quantidade certa de recursos para a carga de trabalho atual. O CREMA calcula a utilização da CPU do pool de workers em um período específico e a compara com o limite configurado para ajustar as instâncias.

Objetivos

Com este tutorial, você vai:

• Implantar um pool de workers do Cloud Run para executar uma carga de trabalho em segundo plano que informa métricas de utilização ao Google Cloud serviço gerenciado para Prometheus.

• Implantar o serviço de escalonamento automático do CREMA para escalonar dinamicamente o pool de workers com base nas métricas do Prometheus.

• Teste o serviço do CREMA observando os registros de serviço e verificando as mudanças na contagem de instâncias no Google Cloud console.

Custos

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

• Cloud Build
• Artifact Registry
• Cloud Run
• Cloud Monitoring

Para gerar uma estimativa de custo baseada na 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.

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.
   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

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

3. Ative as APIs Cloud Run, Gerenciador de parâmetros, Artifact Registry, Cloud Build e Cloud Monitoring.

   Funções necessárias para ativar APIs

   Para ativar APIs, é necessário ter a permissão serviceusage.services.enable. Se você criou o projeto, provavelmente já tem essa permissão com o papel de proprietário (roles/owner). Caso contrário, você pode receber essa permissão com o papel de administrador de uso do serviço (roles/serviceusage.serviceUsageAdmin). Saiba como conceder papéis.

   Ativar as APIs

4. Instale e inicialize a CLI gcloud.
5. Atualize os componentes:

   gcloud components update

6. Defina as seguintes variáveis de configuração para o CREMA usado neste tutorial:

   export PROJECT_ID=PROJECT_ID
   export REGION=us-central1
   export CREMA_SA_NAME=crema-service-account
   export CONSUMER_SA_NAME=consumer-service-account
   export CONSUMER_WORKER_POOL_NAME=worker-pool-consumer
   export CREMA_SERVICE_NAME=my-crema-service

   Substitua PROJECT_ID pelo ID do seu Google Cloud projeto.
7. Defina o ID do projeto executando o seguinte comando:

   gcloud config set project $PROJECT_ID

8. Você incorre em cobranças pelo serviço de escalonamento do Cloud Run com base na frequência com que aciona o escalonamento. Para mais informações, estime os custos com a calculadora de preços.

Funções exigidas

Para conseguir as permissões que você precisa para concluir o tutorial, peça ao administrador para conceder a você os seguintes papéis do IAM no seu projeto:

• Administrador do repositório do Artifact Registry (roles/artifactregistry.repoAdmin)
• Editor do Cloud Build (roles/cloudbuild.builds.editor)
• Administrador do Cloud Run (roles/run.admin)
• Criar contas de serviço (roles/iam.serviceAccountCreator)
• Usuário da conta de serviço (roles/iam.serviceAccountUser)
• Consumidor do Service Usage (roles/serviceusage.serviceUsageConsumer)
• Gerenciador de parâmetros Admin (roles/parametermanager.admin)

Para mais informações sobre a concessão de papéis, consulte Gerenciar o acesso a projetos, pastas e organizações.

Também é possível conseguir as permissões necessárias com papéis personalizados ou outros papéis predefinidos.

Observação: os papéis básicos do IAM também podem conter permissões para concluir o tutorial. Não conceda papéis básicos em um ambiente de produção, mas é possível fazer isso em um ambiente de desenvolvimento ou de teste.

Criar contas de serviço personalizadas

Este tutorial exige as duas contas de serviço a seguir com as permissões mínimas necessárias para usar os recursos provisionados:

• Conta de serviço do consumidor: identidade do pool de workers que executa uma carga de trabalho em segundo plano. Execute o seguinte comando para criar a conta de serviço do consumidor:

  gcloud iam service-accounts create $CONSUMER_SA_NAME \
    --display-name="Consumer service account"
  

• Conta de serviço do CREMA: identidade do escalonador automático. Execute o seguinte comando para criar a conta de serviço do CREMA:

  gcloud iam service-accounts create $CREMA_SA_NAME \
    --display-name="CREMA service account"
  

Conceder outras permissões às contas de serviço personalizadas

Para escalonar o pool de workers, conceda as seguintes permissões nas contas de serviço personalizadas:

1. Conceda permissão à conta de serviço do CREMA para ler no Parameter Manager:

   gcloud projects add-iam-policy-binding $PROJECT_ID \
     --member="serviceAccount:$CREMA_SA_NAME@$PROJECT_ID." \
     --role="roles/parametermanager.parameterViewer"
   

2. Conceda à conta de serviço do CREMA a permissão para escalonar o pool de workers:

   gcloud projects add-iam-policy-binding $PROJECT_ID \
     --member="serviceAccount:$CREMA_SA_NAME@$PROJECT_ID." \
     --role="roles/run.developer"
   

3. Conceda à conta de serviço do CREMA o função do usuário da conta de serviço:

   gcloud projects add-iam-policy-binding $PROJECT_ID \
     --member="serviceAccount:$CREMA_SA_NAME@$PROJECT_ID." \
     --role="roles/iam.serviceAccountUser"
   

4. Conceda permissão à conta de serviço do CREMA para visualizar métricas:

    gcloud projects add-iam-policy-binding $PROJECT_ID \
      --member="serviceAccount:$CREMA_SA_NAME@$PROJECT_ID." \
      --role="roles/monitoring.viewer"
   

5. Conceda permissão à conta de serviço do CREMA para gravar métricas:

    gcloud projects add-iam-policy-binding $PROJECT_ID \
      --member="serviceAccount:$CREMA_SA_NAME@$PROJECT_ID." \
      --role="roles/monitoring.metricWriter"
   

Implantar um pool de workers do Cloud Run

Implante um pool de workers com 0 instâncias para o CREMA escalonar verticalmente:

gcloud run worker-pools deploy $CONSUMER_WORKER_POOL_NAME \
  --image us-docker.pkg.dev/cloudrun/container/worker-pool:latest \
  --instances 0 \
  --region $REGION \
  --memory 4G \
  --cpu 4 \
  --service-account="$CONSUMER_SA_NAME@$PROJECT_ID."

Implantar o serviço de escalonamento automático do CREMA

Implante o serviço do CREMA para escalonar automaticamente o pool de workers com base nas métricas do Prometheus.

Configurar o autoescalador

Este tutorial usa o Parameter Manager para armazenar o arquivo de configuração YAML do CREMA.

1. Crie um parâmetro no Parameter Manager para armazenar versões de parâmetros para o CREMA:

   PARAMETER_ID=crema-config
   PARAMETER_REGION=global
   gcloud parametermanager parameters create $PARAMETER_ID --location=$PARAMETER_REGION --parameter-format=YAML
   

2. No diretório raiz, crie um arquivo YAML, my-crema-config.yaml, para definir a configuração do escalonador automático. Defina o limite de escalonamento automático como 50% de utilização da CPU:

   apiVersion: crema/v1
   kind: CremaConfig
   spec:
     pollingInterval: 30
     triggerAuthentications:
       - metadata:
           name: google-crema-auth
         spec:
           podIdentity:
             provider: gcp
     scaledObjects:
       - spec:
           scaleTargetRef:
             name: projects/PROJECT_ID/locations/us-central1/workerPools/worker-pool-consumer
           minReplicaCount: 1
           maxReplicaCount: 20
           triggers:
             - type: prometheus
               metadata:
                 serverAddress: https://monitoring.googleapis.com/v1/projects/PROJECT_ID/location/global/prometheus
                 threshold: "0.5"
                 query: |
                   histogram_quantile(
                     0.50,
                     sum by (le) (
                       increase(
                         run_googleapis_com:container_cpu_utilizations_bucket{
                           monitored_resource="cloud_run_worker_pool",
                           worker_pool_name="worker-pool-consumer",
                           location="us-central1",
                           project_id="PROJECT_ID"
                         }[2m]
                       )
                     )
                   )
               authenticationRef:
                 name: google-crema-auth
           advanced:
             horizontalPodAutoscalerConfig:
               behavior:
                 scaleDown:
                   stabilizationWindowSeconds: 300
   

   Substitua PROJECT_ID pelo Google Cloud ID do projeto.

3. Faça upload do arquivo YAML local como uma nova versão do parâmetro:

   LOCAL_YAML_CONFIG_FILE=my-crema-config.yaml
   PARAMETER_VERSION=1
   
   gcloud parametermanager parameters versions create $PARAMETER_VERSION \
     --location=$PARAMETER_REGION \
     --parameter=$PARAMETER_ID \
     --payload-data-from-file=$LOCAL_YAML_CONFIG_FILE
   

4. Execute o seguinte comando para verificar se a adição do parâmetro foi bem-sucedida:

   gcloud parametermanager parameters versions list \
   --parameter=$PARAMETER_ID \
   --location=$PARAMETER_REGION
   

   Você verá o caminho do parâmetro, como projects/PROJECT_ID/locations/global/parameters/crema-config/versions/1.

Implantar o serviço para escalonar as cargas de trabalho

Para implantar o serviço para escalonar o pool de workers, execute o seguinte comando com uma imagem de contêiner pré-criada:

CREMA_CONFIG_PARAM_VERSION=projects/$PROJECT_ID/locations/$PARAMETER_REGION/parameters/$PARAMETER_ID/versions/$PARAMETER_VERSION
IMAGE=us-central1-docker.pkg.dev/cloud-run-oss-images/crema-v1/autoscaler:1.0

gcloud run deploy $CREMA_SERVICE_NAME \
  --image=${IMAGE} \
  --region=${REGION} \
  --service-account="${CREMA_SA_NAME}" \
  --no-allow-unauthenticated \
  --no-cpu-throttling \
  --base-image=us-central1-docker.pkg.dev/serverless-runtimes/google-24/runtimes/java25 \
  --labels=created-by=crema \
  --set-env-vars="CREMA_CONFIG=${CREMA_CONFIG_PARAM_VERSION},OUTPUT_SCALER_METRICS=True"

Testar o serviço de escalonamento automático

Para verificar se o serviço de escalonamento automático está funcionando corretamente, confira a guia Registros do serviço do Cloud Run. O serviço de escalonamento automático do CREMA escalona as instâncias de worker do consumidor de 0.

Você verá os seguintes registros nos registros do serviço sempre que as métricas forem atualizadas:

[INFO] [METRIC-PROVIDER] Starting metric collection cycle
[INFO] [METRIC-PROVIDER] Successfully fetched scaled object metrics ...
[INFO] [METRIC-PROVIDER] Sending scale request ...
[INFO] [SCALER] Received ScaleRequest ...
[INFO] [SCALER] Current instances ...
[INFO] [SCALER] Recommended instances ...

O Cloud Run rotula cada mensagem de registro com o componente que a emitiu.

Limpar

Para evitar cobranças extras na sua Google Cloud conta, exclua todos os recursos implantados com este tutorial.

Excluir o projeto

Se você criou um novo projeto para este tutorial, exclua-o. Se você usou um projeto atual e precisa mantê-lo sem as mudanças incluídas neste tutorial, exclua os recursos criados para o tutorial.

O jeito mais fácil de evitar cobranças é excluindo o projeto que você criou para o tutorial.

Para excluir o projeto:

Cuidado: excluir um projeto tem os seguintes efeitos:

• Tudo no projeto é excluído. Se você tiver usado um projeto atual para as tarefas neste documento, a exclusão dele incluirá a exclusão de quaisquer outros trabalhos feitos nele.
• Os IDs do projeto personalizados são perdidos. Ao criar o projeto, você pode ter criado um ID do projeto personalizado para ser usado no futuro. Para preservar os URLs que usam o ID do projeto, como um URL appspot.com, exclua recursos específicos do projeto, em vez de excluir o projeto inteiro.

Se você planeja explorar várias arquiteturas, tutoriais e guias de início rápido, a reutilização de projetos pode evitar que você exceda limites da cota.

1. No Google Cloud console, acesse a página Gerenciar recursos.

   Acessar "Gerenciar recursos"

2. Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir.
3. Na caixa de diálogo, digite o ID do projeto e clique em Desligar para excluir o projeto.

Excluir recursos do tutorial

1. Exclua o serviço do Cloud Run que você implantou neste tutorial. Os serviços do Cloud Run não geram custos até receberem solicitações.

   Para excluir o serviço do Cloud Run, execute o seguinte comando:

   gcloud run services delete SERVICE-NAME

   Substitua SERVICE-NAME pelo nome do serviço.

   Também é possível excluir os serviços do Cloud Run no Google Cloud console.

2. Remova a configuração da região padrão da gcloud que você adicionou durante a configuração do tutorial:

    gcloud config unset run/region
   

3. Remova a configuração do projeto:

    gcloud config unset project
   

4. Exclua outros Google Cloud recursos criados neste tutorial:

   • Excluir o pool de workers do Cloud Run
   • Excluir a imagem do contêiner do pool de workers do Artifact Registry
   • Excluir o serviço do CREMA
   • Excluir as contas de serviço
   • Excluir os parâmetros no Gerenciador de parâmetros

A seguir

• Saiba mais sobre os pools de workers do Cloud Run.
• Conheça outras demonstrações, tutoriais e amostras do Cloud Run.
• Configure outros escalonadores do KEDA com o CREMA.