Google utiliza tecnología de IA para traducir contenido a tu idioma preferido. Las traducciones realizadas con IA pueden contener errores.

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

En esta página, se describe cómo ajustar la escala automáticamente de 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 de Kubernetes (KEDA) para escalar las cargas de trabajo en función de las fuentes de eventos externas.

Para conocer los escaladores compatibles 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 de los grupos de trabajadores de forma automática, implementa el servicio de escalador automático de CREMA en Cloud Run. Este servicio realiza las siguientes acciones:

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

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 ejecutores de GitHub 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 GitHub de Google Cloud .
Revisa la calculadora de precios para estimar los costos. Se aplican cargos por el servicio de escalamiento de Cloud Run en función de 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 la 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 necesarios para usar los recursos aprovisionados que requiere 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 escalamiento, crea un archivo de configuración YAML en tu directorio raíz. Este archivo le indica al servicio de CREMA qué fuentes externas debe supervisar, 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) con las métricas de GitHub Runner. Usa un Secret de Secret Manager llamado github_runner_token para autenticarse con 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, como usar 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: los servicios de Cloud Run o los grupos de trabajadores que se escalarán.
- triggers: Es la métrica externa específica que se usa para el escalamiento. Si tu fuente de métricas externa requiere autenticación, configura 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 realiza sondeos 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 tus escaladores compatibles, consulta Escaladores en la documentación de KEDA.

Almacena tu configuración de CREMA en Parameter Manager

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

Crea un parámetro en Parameter Manager:

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 al 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 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 las métricas cambiantes:
```
WORKER_POOL_NAME=WORKER_POOL_NAME
WORKER_POOL_REGION=WORKER_POOL_REGION
gcloud 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: Es el nombre del grupo de trabajadores.
- WORKER_POOL_REGION: Es 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 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 Parameter Manager.

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

Prueba tu servicio de CREMA

Para verificar que el servicio de ajuste de escala automático funcione correctamente, revisa 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 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.