Ajusta automáticamente la escala de los grupos de trabajadores con métricas externas

En esta página, se describe cómo escalar automáticamente los grupos de trabajadores de Cloud Run con métricas externas basadas en eventos. El ajuste de escala automático de métricas externas de Cloud Run (CREMA) habilita esta funcionalidad aprovechando el ajuste de escala automático basado en eventos y en Kubernetes (KEDA) para escalar cargas de trabajo en función de fuentes de eventos externas.

Para conocer los factores de ajuste admitidos y la compatibilidad con Cloud Run, consulta Cloud Run External Metrics Autoscaling (CREMA) en la documentación de Google Cloud GitHub.

Acerca del servicio de escalador automático

Para ajustar la escala automáticamente de los grupos de trabajadores, implementa el servicio de ajuste de escala automático de CREMA en Cloud Run. Este servicio realiza las siguientes acciones:

Sondea fuentes de eventos externos, como temas de Apache Kafka o GitHub Runner Scaler.
Calcula la cantidad de instancias requeridas según tu configuración de YAML.
Actualiza automáticamente el recuento de instancias del grupo de trabajadores.

Antes de comenzar

Asegúrate de haber configurado un proyecto nuevo para Cloud Run, como se describe en la página de configuración.

Habilita las APIs de Artifact Registry, Cloud Build, Cloud Run Admin, Secret Manager y Parameter Manager:

gcloud services enable artifactregistry.googleapis.com \
    cloudbuild.googleapis.com \
    run.googleapis.com \
    secretmanager.googleapis.com \
    parametermanager.googleapis.com

Configura una carga de trabajo basada en eventos o solicitudes, como GitHub Runners o Apache Kafka. Para verificar que se admita la fuente de tu carga de trabajo, consulta la lista de compatibilidad de CREMA en la documentación de Google Cloud GitHub.
Revisa la calculadora de precios para estimar los costos. Incurres en cargos por tu servicio de Cloud Run Scaling según la frecuencia con la que activas el escalamiento.

Roles obligatorios

Para obtener los permisos que necesitas para escalar automáticamente tu grupo de trabajadores, pídele a tu administrador que te otorgue los siguientes roles de IAM en tu proyecto:

Administrador del repositorio de Artifact Registry (roles/artifactregistry.repoAdmin)
Editor de Cloud Build (roles/cloudbuild.builds.editor)
Administrador de Cloud Run (roles/run.admin)
Crea cuentas de servicio (roles/iam.serviceAccountCreator)
Administrador de Secret Manager (roles/secretmanager.admin)
Usuario de cuenta de servicio (roles/iam.serviceAccountUser)
Consumidor de Service Usage (roles/serviceusage.serviceUsageConsumer)
Administrador de almacenamiento (roles/storage.admin)
Administrador de Parameter Manager (roles/parametermanager.admin)

Para obtener más información sobre cómo otorgar roles, consulta Administra el acceso a proyectos, carpetas y organizaciones.

También puedes obtener los permisos necesarios a través de roles personalizados o cualquier otro rol predefinido.

Crea una cuenta de servicio personalizada

Crea una cuenta de servicio personalizada con los permisos mínimos requeridos para usar los recursos aprovisionados necesarios para tu carga de trabajo. Para configurar la cuenta de servicio, haz lo siguiente:

gcloud iam service-accounts create CREMA_SERVICE_ACCOUNT \
  --display-name="CREMA Service Account"

Reemplaza CREMA_SERVICE_ACCOUNT por un nombre para tu cuenta de servicio personalizada, por ejemplo, crema-service-account. Este comando crea una cuenta de servicio que sigue el formato crema-service-account@example-project.iam.gserviceaccount.com.

Crea el archivo de configuración de CREMA

Para definir tu lógica de ajuste de escala, crea un archivo de configuración YAML en tu directorio raíz. Este archivo le indica al servicio de CREMA qué fuentes externas supervisar, cómo autenticarse con los recursos y qué grupos de trabajadores escalar.

Ejemplo de YAML

En el siguiente ejemplo, se muestra el archivo de configuración para escalar un grupo de trabajadores de Cloud Run (example-workerpool) con las métricas de GitHub Runner. Usa un secreto de Secret Manager llamado github_runner_token para autenticarse en GitHub y leer las métricas.

  apiVersion: crema/v1
  kind: CremaConfig
  metadata:
    name: gh-demo
  spec:
    triggerAuthentications:
      - metadata:
          name: github-trigger-auth
        spec:
          gcpSecretManager:
            secrets:
              - parameter: personalAccessToken
                id: github_runner_token
                version: latest
    scaledObjects:
      - spec:
          scaleTargetRef:
            name: projects/example-project/locations/us-central1/workerpools/example-workerpool
          triggers:
            - type: github-runner
              name: example-runner
              metadata:
                owner: repo-owner
                runnerScope: repo
                repos: repo-name
                targetWorkflowQueueLength: 1
              authenticationRef:
                name: github-trigger-auth
          advanced:
            horizontalPodAutoscalerConfig:
              behavior:
                scaleDown:
                  stabilizationWindowSeconds: 10
                  policies:
                    - type: Pods
                      value: 100
                      periodSeconds: 10
                scaleUp:
                  stabilizationWindowSeconds: 10
                  policies:
                    - type: Pods
                      value: 2
                      periodSeconds: 10
        pollingInterval: 10

La configuración de YAML usa los siguientes parámetros de alto nivel:

triggerAuthentications: Determina cómo CREMA autentica el servicio externo, por ejemplo, con un token almacenado en Secret Manager.
scaledObjects: Define la asignación entre tu grupo de trabajadores de Cloud Run y el recurso de métrica externa. Este parámetro incluye lo siguiente:
- scaleTargetRef: Son los servicios de Cloud Run o los grupos de trabajadores que se deben escalar.
- triggers: Es la métrica externa específica que se usa para el ajuste. Si tu fuente de métricas externa requiere autenticación, establece el campo authenticationRef para especificar uno de los objetos TriggerAuthentications para las credenciales.
pollingInterval: Controla el intervalo (en segundos) en el que CREMA actualiza sus métricas. Si omites este parámetro, CREMA no sondea automáticamente y debes activar una verificación de escalamiento de forma manual con una solicitud POST al servicio.

Para obtener más información sobre cómo definir métricas de configuración básicas y avanzadas, consulta la referencia de configuración en la documentación de Google Cloud GitHub.

Para obtener la lista completa de definiciones de configuración de los escaladores compatibles, consulta Scalers en la documentación de KEDA.

Almacena tu configuración de CREMA en el Administrador de parámetros

Para almacenar versiones de parámetros para tu servicio de ajuste de escala automático de CREMA, sigue estos pasos:

Crea un parámetro en el Administrador de parámetros:

gcloud parametermanager parameters create PARAMETER_ID --location=global  --parameter-format=YAML

Reemplaza PARAMETER_ID por el nombre de tu parámetro.

Sube tu archivo YAML local como una nueva versión del parámetro:
```
gcloud parametermanager parameters versions create PARAMETER_VERSION \
  --location=global \
  --parameter=PARAMETER_ID \
  --payload-data-from-file=LOCAL_YAML_CONFIG_FILE
```
Reemplaza lo siguiente:
- PARAMETER_VERSION: Es el ID que deseas asignar a la versión del parámetro, por ejemplo, 1.
- LOCAL_YAML_CONFIG_FILE: Es la ruta de acceso a tu archivo de configuración YAML.

Para obtener más información, consulta Crea un parámetro.

Otorga permisos adicionales a tu cuenta de servicio de CREMA

Para escalar el grupo de trabajadores que especificaste en tu configuración de YAML, otorga los siguientes permisos en la cuenta de servicio personalizada:

Otorga permiso a tu cuenta de servicio de CREMA para leer desde Parameter Manager:
```
gcloud projects add-iam-policy-binding PROJECT_ID \
  --member="serviceAccount:CREMA_SERVICE_ACCOUNT_NAME \
  --role="roles/parametermanager.parameterViewer"
```
Reemplaza lo siguiente:
- PROJECT_ID: Es el ID de tu proyecto de Google Cloud .
- CREMA_SERVICE_ACCOUNT_NAME: Es el nombre de tu cuenta de servicio de CREMA.
Otorga a tu cuenta de servicio de CREMA el rol de roles/run.developer en el grupo de trabajadores. Esto permite que el servicio de CREMA modifique el recuento de instancias de tu grupo de trabajadores en respuesta a los cambios en las métricas:
```
WORKER_POOL_NAME=WORKER_POOL_NAME
WORKER_POOL_REGION=WORKER_POOL_REGION
gcloud beta run worker-pools add-iam-policy-binding $WORKER_POOL_NAME \
  --region=$WORKER_POOL_REGION \
  --member="serviceAccount:CREMA_SERVICE_ACCOUNT_NAME" \
  --role="roles/run.developer"
```
Reemplaza lo siguiente:
- WORKER_POOL_NAME: El nombre del grupo de trabajadores
- WORKER_POOL_REGION: La región de tu grupo de trabajadores.

Otorga permiso a tu cuenta de servicio de CREMA para escribir métricas:

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

Otorga a tu cuenta de servicio de CREMA el rol de usuario de la cuenta de servicio:

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

Implementa el servicio para escalar tus cargas de trabajo

Para implementar el servicio y escalar tu grupo de trabajadores, ejecuta el siguiente comando con una imagen de contenedor compilada previamente:

gcloud beta run deploy SERVICE_NAME\
  --image=us-central1-docker.pkg.dev/cloud-run-oss-images/crema-v1/autoscaler:1.0 \
  --region=SERVICE_REGION \
  --service-account="CREMA_SERVICE_ACCOUNT_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=projects/PROJECT_ID/locations/PARAMETER_REGION/parameters/PARAMETER_ID/versions/PARAMETER_VERSION,OUTPUT_SCALER_METRICS=True"

Reemplaza lo siguiente:

SERVICE_NAME: Es el nombre de tu servicio de escalador automático.
SERVICE_REGION: La región de tu servicio.
CREMA_SERVICE_ACCOUNT_NAME: Es el nombre de tu cuenta de servicio de CREMA.
PROJECT_ID: Es el ID de tu proyecto de Google Cloud .
PARAMETER_REGION, PARAMETER_ID y PARAMETER_VERSION: Son los valores que almacenaste en el Administrador de parámetros.

También puedes implementar tu servicio de CREMA con una imagen de contenedor personalizada que compiles a partir del código fuente con Cloud Build.

Prueba tu servicio de CREMA

Para verificar que tu servicio de ajuste de escala automático funcione correctamente, consulta la pestaña Registros del servicio de Cloud Run.

Deberías ver los siguientes registros en los registros de tu servicio cada vez que se actualicen las métricas:

Cada mensaje de registro está etiquetado con el componente que lo emitió.

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

¿Qué sigue?

Aprende a usar ejecutores de GitHub autoalojados en grupos de trabajadores para ejecutar los flujos de trabajo definidos en tu repositorio de GitHub y escalar tu grupo de trabajadores con CREMA.
Obtén más información sobre los grupos de trabajadores de Cloud Run.