Autoescalar 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 mediante métricas externas basadas en eventos. El autoescalado de métricas externas de Cloud Run (CREMA) habilita esta función aprovechando el autoescalado basado en eventos de Kubernetes (KEDA) para escalar cargas de trabajo en función de fuentes de eventos externas.

Para ver los escaladores compatibles y la compatibilidad con Cloud Run, consulta Escalado automático de métricas externas de Cloud Run (CREMA) en la Google Cloud documentación de GitHub.

Acerca del servicio de ajuste automático de escala

Para autoescalar grupos de trabajadores, despliega el servicio de autoescalado de CREMA en Cloud Run. Este servicio realiza las siguientes acciones:

Consulta fuentes de eventos externas, como temas de Apache Kafka o GitHub Runner Scaler.
Calcula el número de instancias necesarias en función de tu configuración YAML.
Actualiza automáticamente el número de instancias del grupo de trabajadores.

Antes de empezar

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

Habilita las APIs 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 admite la fuente de tu carga de trabajo, consulta la lista de compatibilidad de CREMA en la Google Cloud documentación de GitHub.
Consulta la calculadora de precios para estimar los costes. Se te cobrará por el servicio de escalado de Cloud Run en función de la frecuencia con la que actives el escalado.

Roles obligatorios

Para obtener los permisos que necesitas para escalar automáticamente tu grupo de trabajadores, pide a tu administrador que te conceda los siguientes roles de gestión de identidades y accesos 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)
Crear cuentas de servicio (roles/iam.serviceAccountCreator)
Administrador de Secret Manager (roles/secretmanager.admin)
Usuario de cuenta de servicio (roles/iam.serviceAccountUser)
Consumidor de uso del servicio (roles/serviceusage.serviceUsageConsumer)
Administrador de almacenamiento (roles/storage.admin)
Administrador de gestor de parámetros (roles/parametermanager.admin)

Para obtener más información sobre cómo conceder roles, consulta el artículo Gestionar acceso a proyectos, carpetas y organizaciones.

También puedes conseguir los permisos necesarios a través de roles personalizados u otros roles predefinidos.

Crear una cuenta de servicio personalizada

Crea una cuenta de servicio personalizada con los permisos mínimos necesarios para usar los recursos aprovisionados que requiera tu carga de trabajo. Para configurar la cuenta de servicio, sigue estos pasos:

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

Sustituye CREMA_SERVICE_ACCOUNT por el nombre de tu cuenta de servicio personalizada; por ejemplo, crema-service-account. Este comando crea una cuenta de servicio con el formato crema-service-account@example-project.iam.gserviceaccount.com.

Crear el archivo de configuración de CREMA

Para definir la lógica de escalado, crea un archivo de configuración YAML en el directorio raíz. Este archivo indica al servicio CREMA qué fuentes externas debe monitorizar, cómo autenticarse con los recursos y qué grupos de trabajadores debe 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) mediante 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 autentica CREMA el servicio externo, por ejemplo, mediante 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 externo. Este parámetro incluye lo siguiente:
- scaleTargetRef: los servicios de Cloud Run o los grupos de trabajadores que se van a escalar.
- triggers: la métrica externa específica que se usa para el escalado. Si tu fuente de métricas externa requiere autenticación, define el campo authenticationRef para especificar uno de los objetos TriggerAuthentications de las credenciales.
pollingInterval: controla el intervalo (en segundos) en el que CREMA actualiza sus métricas. Si omite este parámetro, CREMA no sondea automáticamente y debe activar una comprobación de escalado manualmente mediante 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 ver la lista completa de definiciones de configuración de los escaladores compatibles, consulta Escaladores en la documentación de KEDA.

Almacenar la configuración de CREMA en Gestor de parámetros

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

Para crear un parámetro en el Gestor de parámetros, siga estos pasos:
```
gcloud parametermanager parameters create PARAMETER_ID --location=global  --parameter-format=YAML
```
Sustituye PARAMETER_ID por el nombre del parámetro.
Sube tu archivo YAML local como una nueva versión de parámetro:
```
gcloud parametermanager parameters versions create PARAMETER_VERSION \
  --location=global \
  --parameter=PARAMETER_ID \
  --payload-data-from-file=LOCAL_YAML_CONFIG_FILE
```
Haz los cambios siguientes:
- PARAMETER_VERSION: el ID que quiere asignar a la versión del parámetro (por ejemplo, 1).
- LOCAL_YAML_CONFIG_FILE: la ruta al archivo de configuración YAML.

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

Conceder permisos adicionales a tu cuenta de servicio de CREMA

Para escalar el grupo de trabajadores que has especificado en tu configuración YAML, concede los siguientes permisos a la cuenta de servicio personalizada:

Concede a tu cuenta de servicio de CREMA permiso para leer en el gestor de parámetros:
```
gcloud projects add-iam-policy-binding PROJECT_ID \
  --member="serviceAccount:CREMA_SERVICE_ACCOUNT_NAME \
  --role="roles/parametermanager.parameterViewer"
```
Haz los cambios siguientes:
- PROJECT_ID: el ID de tu proyecto de Google Cloud .
- CREMA_SERVICE_ACCOUNT_NAME: nombre de tu cuenta de servicio de CREMA.
Asigna el rol roles/run.developer a tu cuenta de servicio de CREMA en el grupo de trabajadores. De esta forma, el servicio CREMA puede modificar el número 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"
```
Haz los cambios siguientes:
- WORKER_POOL_NAME: el nombre del grupo de trabajadores.
- WORKER_POOL_REGION: la región de tu grupo de trabajadores.

Concede permiso de escritura de métricas a tu cuenta de servicio de CREMA:

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

Asigna el rol de usuario de cuenta de servicio a tu cuenta de servicio de CREMA:

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

Desplegar el servicio para escalar las cargas de trabajo

Para desplegar el servicio y escalar tu grupo de trabajadores, ejecuta el siguiente comando con una imagen de contenedor prediseñada:

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-22/runtimes/java21 \
  --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"

Haz los cambios siguientes:

SERVICE_NAME: el nombre del servicio de escalado automático.
SERVICE_REGION: la región de tu servicio.
CREMA_SERVICE_ACCOUNT_NAME: nombre de tu cuenta de servicio de CREMA.
PROJECT_ID: el ID de tu proyecto de Google Cloud .
PARAMETER_REGION, PARAMETER_ID y PARAMETER_VERSION: valores que has almacenado en el Gestor de parámetros.

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

Probar el servicio CREMA

Para comprobar que el servicio de escalado automático funciona 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 se etiqueta con el componente que lo ha emitido.

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

Siguientes pasos

Consulta cómo usar runners de GitHub autohospedados en grupos de trabajadores para ejecutar los flujos de trabajo definidos en tu repositorio de GitHub y escalar tu grupo de trabajadores con CREMA.
Consulta más información sobre los grupos de trabajadores de Cloud Run.