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. Cloud Run External Metrics Autoscaling (CREMA) ermöglicht diese Funktion, indem Kubernetes-basiertes ereignisgesteuertes Autoscaling (KEDA) verwendet wird, um Arbeitslasten basierend auf externen Ereignisquellen zu skalieren.

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

Autoscaler-Dienst

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

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

Hinweise

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

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

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 wie GitHub Runners oder Apache Kafka. Ob Ihre Workload-Quelle unterstützt wird, können Sie in der CREMA-Kompatibilitätsliste in der Google Cloud GitHub-Dokumentation nachsehen.
Mit dem Preisrechner können Sie die Kosten schätzen. Die Kosten für Ihren Cloud Run-Skalierungsdienst richten sich danach, 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 für die Verwendung bereitgestellter Ressourcen, die für Ihre Arbeitslast erforderlich sind. 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 in Ihrem Stammverzeichnis, um die Skalierungslogik zu definieren. Diese Datei weist den CREMA-Dienst an, 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) mit den GitHub Runner-Messwerten. Zur Authentifizierung bei GitHub zum Lesen der Messwerte wird ein Secret Manager-Secret mit dem Namen github_runner_token verwendet.

  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

In der YAML-Konfiguration werden die folgenden Parameter auf oberster Ebene verwendet:

triggerAuthentications: Gibt an, 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 das Skalieren verwendet wird. Wenn für Ihre externe Messwertquelle eine Authentifizierung erforderlich ist, legen Sie das Feld authenticationRef fest, um eines der TriggerAuthentications-Objekte für Anmeldedaten anzugeben.
pollingInterval: Steuert das Intervall (in Sekunden), in dem CREMA seine Messwerte aktualisiert. Wenn Sie diesen Parameter weglassen, wird CREMA nicht automatisch abgefragt und Sie müssen eine Skalierungsprüfung manuell mit einer POST-Anfrage an den Dienst auslösen.

Weitere Informationen zum Definieren von grundlegenden und erweiterten Konfigurationsmesswerten 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 Scalers.

CREMA-Konfiguration in Parameter Manager speichern

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

So 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 des 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.

Zusätzliche Berechtigungen für Ihr CREMA-Dienstkonto erteilen

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

Gewähren Sie Ihrem CREMA-Dienstkonto die Berechtigung zum Lesen aus 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 Ihres Worker-Pools als Reaktion auf sich ändernde Messwerte anpassen:
```
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"
```
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 vorgefertigten Container-Image aus, um den Dienst bereitzustellen und den Worker-Pool zu skalieren:

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"

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

Um zu prüfen, ob der Autoscaling-Dienst richtig funktioniert, sehen Sie sich den Tab Logs des Cloud Run-Dienstes an.

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

Jede Lognachricht ist mit der Komponente gekennzeichnet, die sie ausgegeben hat.

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