Scalabilità automatica dei pool di worker con metriche esterne

Questa pagina descrive come scalare automaticamente i pool di worker Cloud Run utilizzando metriche basate su eventi esterni. La scalabilità automatica delle metriche esterne di Cloud Run (CREMA) attiva questa funzionalità sfruttando la scalabilità automatica basata su eventi di Kubernetes (KEDA) per scalare i carichi di lavoro in base a origini eventi esterne.

Per gli scalatori supportati e la compatibilità con Cloud Run, consulta Scalabilità automatica delle metriche esterne di Cloud Run (CREMA) nella documentazione di Google Cloud GitHub.

Informazioni sul servizio di scalabilità automatica

Per scalare automaticamente i pool di worker, esegui il deployment del servizio di scalabilità automatica CREMA su Cloud Run. Questo servizio esegue le seguenti azioni:

Esegue il polling di origini eventi esterne, come argomenti Apache Kafka o GitHub Runner Scaler.
Calcola il numero di istanze richiesto in base alla configurazione YAML.
Aggiorna automaticamente il numero di istanze del pool di worker.

Prima di iniziare

Assicurati di aver configurato un nuovo progetto per Cloud Run, come descritto nella pagina di configurazione.

Abilita le API Artifact Registry, Cloud Build, Cloud Run Admin, Secret Manager e Parameter Manager:

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

Configura un workload basato su eventi o richieste, ad esempio GitHub Runners o Apache Kafka. Per verificare che l'origine del workload sia supportata, consulta l'elenco di compatibilità di CREMA nella documentazione di Google Cloud GitHub.
Consulta il Calcolatore prezzi per stimare i costi. I costi del servizio di scalabilità di Cloud Run vengono addebitati in base alla frequenza con cui attivi lo scaling.

Ruoli obbligatori

Per ottenere le autorizzazioni necessarie per scalare automaticamente il pool di worker, chiedi all'amministratore di concederti i seguenti ruoli IAM sul progetto:

Amministratore repository Artifact Registry (roles/artifactregistry.repoAdmin)
Editor Cloud Build (roles/cloudbuild.builds.editor)
Cloud Run Admin (roles/run.admin)
Crea service account (roles/iam.serviceAccountCreator)
Amministratore Secret Manager (roles/secretmanager.admin)
Utente Service Account (roles/iam.serviceAccountUser)
Consumer Service Usage (roles/serviceusage.serviceUsageConsumer)
Storage Admin (roles/storage.admin)
Parameter Manager Admin (roles/parametermanager.admin)

Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

Potresti anche riuscire a ottenere le autorizzazioni richieste tramite i ruoli personalizzati o altri ruoli predefiniti.

Crea un account di servizio personalizzato

Crea un account di servizio personalizzato con le autorizzazioni minime richieste per utilizzare le risorse di cui è stato eseguito il provisioning necessarie per il tuo workload. Per configurare il account di servizio:

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

Sostituisci CREMA_SERVICE_ACCOUNT con un nome per il tuo account di servizio personalizzato, ad esempio crema-service-account. Questo comando crea un account di servizio che segue il formato crema-service-account@example-project.iam.gserviceaccount.com.

Crea il file di configurazione CREMA

Per definire la logica di scalabilità, crea un file di configurazione YAML nella directory radice. Questo file indica al servizio CREMA quali origini esterne monitorare, come eseguire l'autenticazione con le risorse e quali pool di worker scalare.

Esempio YAML

L'esempio seguente mostra il file di configurazione per scalare un pool di worker Cloud Run (example-workerpool) utilizzando le metriche di GitHub Runner. Utilizza un secret di Secret Manager denominato github_runner_token per autenticarsi con GitHub per la lettura delle metriche.

  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 configurazione YAML utilizza i seguenti parametri di alto livello:

triggerAuthentications: determina il modo in cui CREMA autentica il servizio esterno, ad esempio utilizzando un token archiviato in Secret Manager.
scaledObjects: definisce la mappatura tra il pool di worker Cloud Run e la risorsa metrica esterna. Questo parametro include:
- scaleTargetRef: i servizi Cloud Run o i pool di worker da scalare.
- triggers: la metrica esterna specifica utilizzata per la scalabilità. Se l'origine metrica esterna richiede l'autenticazione, imposta il campo authenticationRef per specificare uno degli oggetti TriggerAuthentications per le credenziali.
pollingInterval: controlla l'intervallo (in secondi) in cui CREMA aggiorna le metriche. Se ometti questo parametro, CREMA non esegue il polling automaticamente e devi attivare manualmente un controllo di scalabilità utilizzando una richiesta POST al servizio.

Per ulteriori informazioni sulla definizione delle metriche di configurazione di base e avanzata, consulta la Guida di riferimento alla configurazione nella documentazione di Google Cloud GitHub.

Per l'elenco completo delle definizioni di configurazione per gli scalatori compatibili, consulta Scalatori nella documentazione di KEDA.

Archivia la configurazione CREMA in Parameter Manager

Per archiviare le versioni dei parametri per il servizio di scalabilità automatica CREMA:

Crea un parametro in Parameter Manager:

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

Sostituisci PARAMETER_ID con il nome del parametro.

Carica il file YAML locale come nuova versione del parametro:
```
gcloud parametermanager parameters versions create PARAMETER_VERSION \
  --location=global \
  --parameter=PARAMETER_ID \
  --payload-data-from-file=LOCAL_YAML_CONFIG_FILE
```
Sostituisci quanto segue:
- PARAMETER_VERSION: l'ID che vuoi assegnare alla versione del parametro, ad esempio 1.
- LOCAL_YAML_CONFIG_FILE: il percorso del file di configurazione YAML.

Per saperne di più, consulta Creare un parametro.

Concedi autorizzazioni aggiuntive al account di servizio CREMA

Per scalare il pool di worker specificato nella configurazione YAML, concedi le seguenti autorizzazioni all'account di servizio personalizzato:

Concedi al tuo account di servizio CREMA l'autorizzazione di lettura da Parameter Manager:
```
gcloud projects add-iam-policy-binding PROJECT_ID \
  --member="serviceAccount:CREMA_SERVICE_ACCOUNT_NAME \
  --role="roles/parametermanager.parameterViewer"
```
Sostituisci quanto segue:
- PROJECT_ID: l'ID del tuo Google Cloud progetto.
- CREMA_SERVICE_ACCOUNT_NAME: il nome del tuo service account CREMA.
Concedi al tuo account di servizio CREMA il ruolo roles/run.developer nel pool di worker. Ciò consente al servizio CREMA di modificare il conteggio delle istanze del pool di worker in risposta alle metriche in evoluzione:
```
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"
```
Sostituisci quanto segue:
- WORKER_POOL_NAME: il nome del pool di worker.
- WORKER_POOL_REGION: la regione del pool di worker.

Concedi al account di servizio CREMA l'autorizzazione a scrivere metriche:

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

Concedi al tuo account di servizio CREMA il ruolo Utente account di servizio:

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

Esegui il deployment del servizio per scalare i carichi di lavoro

Per eseguire il deployment del servizio per scalare il pool di worker, esegui questo comando con un'immagine container predefinita:

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"

Sostituisci quanto segue:

SERVICE_NAME: il nome del servizio di gestione della scalabilità automatica.
SERVICE_REGION: la regione del servizio.
CREMA_SERVICE_ACCOUNT_NAME: il nome del tuo service account CREMA.
PROJECT_ID: l'ID del tuo Google Cloud progetto.
PARAMETER_REGION, PARAMETER_ID e PARAMETER_VERSION: valori memorizzati in Gestione parametri.

Puoi anche eseguire il deployment del servizio CREMA utilizzando un'immagine container personalizzata che crei dal codice sorgente con Cloud Build.

Testare il servizio CREMA

Per verificare che il servizio di scalabilità automatica funzioni correttamente, controlla la scheda Log del servizio Cloud Run.

Dovresti visualizzare i seguenti log nei log del servizio ogni volta che le metriche vengono aggiornate:

Ogni messaggio di log è etichettato con il componente che lo ha emesso.

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

Passaggi successivi

Scopri come utilizzare runner GitHub self-hosted nei pool di worker per eseguire i workflow definiti nel tuo repository GitHub e scalare il pool di worker con CREMA.
Scopri di più sui pool di worker Cloud Run.