Google utilizza la tecnologia AI per tradurre i contenuti nella tua lingua preferita. Le traduzioni generate dall'AI potrebbero contenere errori.

Scalabilità automatica dei pool di worker con metriche esterne

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

Per gli scaler supportati e la compatibilità con Cloud Run, consulta Cloud Run External Metrics Autoscaling (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 del gestore della scalabilità automatica CREMA in Cloud Run. Questo servizio esegue le seguenti azioni:

Esegue il polling di origini di eventi esterne, come gli 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, API 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, come GitHub Runner 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. Ti verranno addebitati i costi per il servizio di scalabilità di Cloud Run in base alla frequenza con cui attivi la scalabilità.

Ruoli obbligatori

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

Artifact Registry Repository Administrator (roles/artifactregistry.repoAdmin)
Cloud Build Editor (roles/cloudbuild.builds.editor)
Cloud Run Admin (roles/run.admin)
Create Service Accounts (roles/iam.serviceAccountCreator)
Secret Manager Admin (roles/secretmanager.admin)
Utente Service Account (roles/iam.serviceAccountUser)
Service Usage Consumer (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 root. Questo file indica al servizio CREMA quali origini esterne monitorare, come autenticarsi 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 l'autenticazione 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 della 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 delle metriche esterne 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 sue metriche. Se ometti questo parametro, CREMA non esegue il polling automaticamente e devi attivare manualmente un controllo della scalabilità utilizzando una richiesta POST al servizio.

Per saperne di più sulla definizione delle metriche di configurazione di base e avanzate, consulta il riferimento alla configurazione nella documentazione di Google Cloud GitHub.

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

Archivia la configurazione CREMA in Parameter Manager

Per archiviare le versioni dei parametri per il servizio di scalabilità automatica CREMA, segui questi passaggi:

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 si desidera assegnare alla versione del parametro, ad esempio, 1.
- LOCAL_YAML_CONFIG_FILE: il percorso del file di configurazione YAML.

Per saperne di più, consulta Crea un parametro.

Concedi autorizzazioni aggiuntive al tuo account di servizio CREMA

Per scalare il pool di worker specificato nella configurazione YAML, concedi le seguenti autorizzazioni al 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 progetto Google Cloud .
- 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. In questo modo, il servizio CREMA può modificare il numero di istanze del pool di worker in risposta alle metriche in evoluzione:
```
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"
```
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 per scrivere le metriche:

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

Concedi al tuo service account 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 workload

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

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"

Sostituisci quanto segue:

SERVICE_NAME: il nome del servizio del gestore 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 progetto Google Cloud .
PARAMETER_REGION, PARAMETER_ID e PARAMETER_VERSION: valori che hai archiviato in Parameter Manager.

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

Testa il servizio CREMA

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

Ogni volta che le metriche vengono aggiornate, dovresti visualizzare i seguenti log nei log del servizio:

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