Google verwendet KI-Technologie, um Inhalte in Ihre bevorzugte Sprache zu übersetzen. KI-Übersetzungen können Fehler enthalten.

Worker-Pools mit externen Messwerten automatisch skalieren

Auf dieser Seite wird beschrieben, wie Sie Cloud Run-Worker-Pools mithilfe von externen ereignisgesteuerten Messwerten automatisch skalieren. Das Cloud Run External Metrics Autoscaling (CREMA) ermöglicht diese Funktionalität, indem es Kubernetes-basiertes ereignisgesteuertes Autoscaling (KEDA) nutzt, um Arbeitslasten basierend auf externen Ereignisquellen zu skalieren.

Informationen zu unterstützten Scalern und zur Kompatibilität mit Cloud Run finden Sie unter Cloud Run External Metrics Autoscaling (CREMA) in der GitHub-Dokumentation zu Google Cloud .

Autoscaling-Dienst

Wenn Sie Worker-Pools automatisch skalieren möchten, stellen Sie den CREMA-Autoscaling-Dienst in Cloud Run bereit. Dieser Dienst führt die folgenden Aktionen aus:

Fragt externe Ereignisquellen wie Apache Kafka-Themen oder GitHub Runner Scaler ab.
Berechnet die erforderliche Anzahl von Instanzen anhand Ihrer YAML-Konfiguration.
Aktualisiert die Instanzanzahl des Worker-Pools automatisch.

Hinweis

Prüfen Sie, ob Sie ein neues Projekt für Cloud Run eingerichtet haben, wie auf der Seite Einrichtung beschrieben.

Aktivieren Sie die APIs für Artifact Registry, Cloud Build, Cloud Run Admin API, Secret Manager und Parameter Manager:

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

Konfigurieren Sie eine ereignisgesteuerte oder anfragebasierte Arbeitslast, z. B. GitHub Runners oder Apache Kafka. In der CREMA-Kompatibilitätsliste in der GitHub-Dokumentation von Google Cloud können Sie prüfen, ob Ihre Arbeitslastquelle unterstützt wird.
Mit dem Preisrechner können Sie die Kosten schätzen. Für den Cloud Run-Skalierungsdienst fallen Gebühren an, die davon abhängen, wie oft Sie die Skalierung auslösen.

Erforderliche Rollen

Bitten Sie Ihren Administrator, Ihnen die folgenden IAM-Rollen für das Projekt zuzuweisen, um die Berechtigungen zu erhalten, die Sie zum automatischen Skalieren Ihres Worker-Pools benötigen:

Repository-Administrator für Artifact Registry (roles/artifactregistry.repoAdmin)
Cloud Build-Bearbeiter (roles/cloudbuild.builds.editor)
Cloud Run-Administrator (roles/run.admin)
Dienstkonten erstellen (roles/iam.serviceAccountCreator)
Secret Manager-Administrator (roles/secretmanager.admin)
Service Account User (roles/iam.serviceAccountUser)
Service Usage Consumer (roles/serviceusage.serviceUsageConsumer)
Storage-Administrator (roles/storage.admin)
Parameter Manager-Administrator (roles/parametermanager.admin)

Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff auf Projekte, Ordner und Organisationen verwalten.

Sie können die erforderlichen Berechtigungen auch über benutzerdefinierte Rollen oder andere vordefinierte Rollen erhalten.

Benutzerdefiniertes Dienstkonto erstellen

Erstellen Sie ein benutzerdefiniertes Dienstkonto mit den erforderlichen Mindestberechtigungen, um die für Ihre Arbeitslast erforderlichen bereitgestellten Ressourcen zu verwenden. So richten Sie das Dienstkonto ein:

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

Ersetzen Sie CREMA_SERVICE_ACCOUNT durch einen Namen für Ihr benutzerdefiniertes Dienstkonto, z. B. crema-service-account. Mit diesem Befehl wird ein Dienstkonto im Format crema-service-account@example-project.iam.gserviceaccount.com erstellt.

CREMA-Konfigurationsdatei erstellen

Erstellen Sie eine YAML-Konfigurationsdatei im Stammverzeichnis, um die Skalierungslogik zu definieren. In dieser Datei wird der CREMA-Dienst angewiesen, welche externen Quellen überwacht werden sollen, wie die Authentifizierung bei den Ressourcen erfolgt und welche Worker-Pools skaliert werden sollen.

YAML-Beispiel

Das folgende Beispiel zeigt die Konfigurationsdatei zum Skalieren eines Cloud Run-Worker-Pools (example-workerpool) mithilfe der GitHub Runner-Messwerte. Es wird ein Secret Manager-Secret mit dem Namen github_runner_token verwendet, um sich bei GitHub zu authentifizieren und die Messwerte zu lesen.

  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

Die YAML-Konfiguration verwendet die folgenden allgemeinen Parameter:

triggerAuthentications: Bestimmt, wie CREMA den externen Dienst authentifiziert, z. B. mit einem in Secret Manager gespeicherten Token.
scaledObjects: Definiert die Zuordnung zwischen Ihrem Cloud Run-Worker-Pool und der externen Messwertressource. Dieser Parameter umfasst:
- scaleTargetRef: die Cloud Run-Dienste oder Worker-Pools, die skaliert werden sollen.
- triggers: Der spezifische externe Messwert, der für die Skalierung verwendet wird. Wenn für Ihre externe Messwertquelle eine Authentifizierung erforderlich ist, legen Sie im Feld authenticationRef eines der TriggerAuthentications-Objekte für Anmeldedaten fest.
pollingInterval: Steuert das Intervall (in Sekunden), in dem CREMA seine Messwerte aktualisiert. Wenn Sie diesen Parameter weglassen, führt CREMA keine automatischen Abfragen durch. Sie müssen dann manuell eine Skalierungsprüfung über eine POST-Anfrage an den Dienst auslösen.

Weitere Informationen zum Definieren grundlegender und erweiterter Konfigurationsmesswerte finden Sie in der Konfigurationsreferenz in der GitHub-Dokumentation zu Google Cloud .

Eine vollständige Liste der Konfigurationsdefinitionen für Ihre kompatiblen Scaler finden Sie in der KEDA-Dokumentation unter Scaler.

CREMA-Konfiguration in Parameter Manager speichern

So speichern Sie Parameterversionen für Ihren CREMA-Autoscaling-Dienst:

Erstellen Sie einen Parameter im Parameter Manager:
```
gcloud parametermanager parameters create PARAMETER_ID --location=global  --parameter-format=YAML
```
Ersetzen Sie PARAMETER_ID durch den Namen Ihres Parameters.
Laden Sie Ihre lokale YAML-Datei als neue Parameterversion hoch:
```
gcloud parametermanager parameters versions create PARAMETER_VERSION \
  --location=global \
  --parameter=PARAMETER_ID \
  --payload-data-from-file=LOCAL_YAML_CONFIG_FILE
```
Ersetzen Sie Folgendes:
- PARAMETER_VERSION: Die ID, die Sie der Parameterversion zuweisen möchten, z. B. 1.
- LOCAL_YAML_CONFIG_FILE: der Pfad zu Ihrer YAML-Konfigurationsdatei.

Weitere Informationen finden Sie unter Parameter erstellen.

Ihrem CREMA-Dienstkonto zusätzliche Berechtigungen gewähren

Wenn Sie den in Ihrer YAML-Konfiguration angegebenen Worker-Pool skalieren möchten, weisen Sie dem benutzerdefinierten Dienstkonto die folgenden Berechtigungen zu:

Gewähren Sie Ihrem CREMA-Dienstkonto die Berechtigung zum Lesen aus dem Parameter Manager:
```
gcloud projects add-iam-policy-binding PROJECT_ID \
  --member="serviceAccount:CREMA_SERVICE_ACCOUNT_NAME \
  --role="roles/parametermanager.parameterViewer"
```
Ersetzen Sie Folgendes:
- PROJECT_ID: die ID Ihres Projekts in Google Cloud .
- CREMA_SERVICE_ACCOUNT_NAME: der Name Ihres CREMA-Dienstkontos.
Weisen Sie Ihrem CREMA-Dienstkonto die Rolle roles/run.developer für den Worker-Pool zu. So kann der CREMA-Dienst die Anzahl der Instanzen in Ihrem Worker-Pool als Reaktion auf sich ändernde Messwerte anpassen:
```
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"
```
Ersetzen Sie Folgendes:
- WORKER_POOL_NAME: der Name des Worker-Pools.
- WORKER_POOL_REGION: die Region Ihres Worker-Pools.

Gewähren Sie Ihrem CREMA-Dienstkonto die Berechtigung zum Schreiben von Messwerten:

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

Weisen Sie Ihrem CREMA-Dienstkonto die Rolle „Dienstkontonutzer“ zu:

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

Dienst bereitstellen, um Arbeitslasten zu skalieren

Führen Sie den folgenden Befehl mit einem vordefinierten Container-Image aus, um den Dienst bereitzustellen und den Worker-Pool zu skalieren:

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"

Ersetzen Sie Folgendes:

SERVICE_NAME: der Name Ihres Autoscaling-Dienstes.
SERVICE_REGION: die Region Ihres Dienstes.
CREMA_SERVICE_ACCOUNT_NAME: der Name Ihres CREMA-Dienstkontos.
PROJECT_ID: die ID Ihres Projekts in Google Cloud .
PARAMETER_REGION, PARAMETER_ID und PARAMETER_VERSION: Werte, die Sie im Parameter Manager gespeichert haben.

Sie können Ihren CREMA-Dienst auch mit einem benutzerdefinierten Container-Image bereitstellen, das Sie mit Cloud Build aus dem Quellcode erstellen.

CREMA-Dienst testen

Wenn Sie prüfen möchten, ob der Autoscaling-Dienst ordnungsgemäß funktioniert, rufen Sie den Tab Logs des Cloud Run-Dienstes auf.

In den Logs Ihres Dienstes sollten jedes Mal, wenn die Messwerte aktualisiert werden, die folgenden Logs angezeigt werden:

Jeder Logeintrag ist mit der Komponente gekennzeichnet, von der er ausgegeben wurde.

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