Worker-Pools automatisch auf Grundlage des Pub/Sub-Warteschlangenvolumens skalieren

In dieser Anleitung erfahren Sie, wie Sie einen Cloud Run-Worker-Pool bereitstellen, um Pub/Sub-Nachrichten zu verarbeiten, und wie Sie Ihre Consumer- Instanzen mit Cloud Run External Metrics Autoscaling (CREMA) automatisch basierend auf der Warteschlangentiefe skalieren.

Ziele

In dieser Anleitung wird Folgendes beschrieben:

Ein Pub/Sub-Thema und -Abo erstellen, um Nachrichten an das Thema zu senden.
Einen Cloud Run-Worker-Pool bereitstellen, der Nachrichten von Pub/Sub verarbeitet.
Den Autoscaler-Dienst CREMA bereitstellen, um Ihren Worker-Pool zu skalieren.
Testen Sie Ihren Autoscaling-Dienst, indem Sie ein Python-Skript lokal ausführen , um Last zu generieren.

Kosten

In diesem Dokument verwenden Sie die folgenden kostenpflichtigen Komponenten von Google Cloud:

Mit dem Preisrechner können Sie eine Kostenschätzung für Ihre voraussichtliche Nutzung vornehmen. Verwenden Sie den Preisrechner.

Neuen Nutzern von Google Cloud steht möglicherweise eine kostenlose Testversion zur Verfügung.

Hinweis

Melden Sie sich in Ihrem Google Cloud Konto an. Wenn Sie noch kein Konto bei Google Cloudhaben, erstellen Sie ein Konto, um die Leistungsfähigkeit unserer Produkte in der Praxis sehen und bewerten zu können. Neukunden erhalten außerdem ein Guthaben von 300 $, um Arbeitslasten auszuführen, zu testen und bereitzustellen.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Roles required to select or create a project

Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Roles required to select or create a project

Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

Aktivieren Sie die Cloud Run-, Parameter Manager-, Artifact Registry-, Pub/Sub- und Cloud Build APIs.
Erforderliche Rollen zum Aktivieren von APIs
Zum Aktivieren von APIs benötigen Sie die IAM-Rolle „Service Usage-Administrator“ (roles/serviceusage.serviceUsageAdmin), die die Berechtigung serviceusage.services.enable enthält. Weitere Informationen zum Zuweisen von Rollen.
APIs aktivieren

Installieren und initialisieren Sie die gcloud CLI.
Aktualisieren Sie die Komponenten:
```
gcloud components update
```
In dieser Anleitung werden mehrere Umgebungsvariablen verwendet. Zur besseren Fehlerbehebung führen Sie den folgenden Befehl aus, um einen Fehler zu generieren, wenn Sie auf nicht festgelegte lokale Umgebungsvariablen verweisen:
```
set -u
```

Legen Sie die folgenden Konfigurationsvariablen für CREMA fest, die in dieser Anleitung verwendet werden:

export PROJECT_ID=PROJECT_ID
export REGION=us-central1
export TOPIC_ID=crema-pubsub-topic
export SUBSCRIPTION_ID=crema-subscription
export CREMA_SA_NAME=crema-service-account
export CONSUMER_SA_NAME=consumer-service-account
export CONSUMER_WORKER_POOL_NAME=worker-pool-consumer
export CREMA_SERVICE_NAME=my-crema-service

Ersetzen Sie PROJECT_ID durch die ID Ihres Google Cloud Projekts.

Legen Sie Ihre Projekt-ID mit dem folgenden Befehl fest:
```
gcloud config set project $PROJECT_ID
```
Für den Cloud Run-Skalierungsdienst fallen Kosten an, je nachdem, wie oft Sie die Skalierung auslösen. Weitere Informationen finden Sie im Preisrechner.

Erforderliche Rollen

Bitten Sie Ihren Administrator, Ihnen die folgenden IAM-Rollen für Ihr Projekt zuzuweisen, um die Berechtigungen zu erhalten, die Sie zum Ausführen der Anleitung 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)
Pub/Sub-Administrator (roles/pubsub.admin)
Dienstkontonutzer (roles/iam.serviceAccountUser)
Service Usage-Nutzer (roles/serviceusage.serviceUsageConsumer)
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.

Pub/Sub-Thema und -Abo erstellen

Wenn Sie den Worker automatisch skalieren möchten, erstellen Sie mit den folgenden Schritten ein Pull-Abo für Ihre Consumer-Anwendung:

Erstellen Sie ein Pub/Sub-Thema, das einen Feed von Nachrichten darstellt:
```
gcloud pubsub topics create $TOPIC_ID
```
Erstellen Sie ein Pull-Abo, um Nachrichten aus dem Pub/Sub-Thema zu verarbeiten:
```
gcloud pubsub subscriptions create $SUBSCRIPTION_ID --topic=$TOPIC_ID
```

Benutzerdefinierte Dienstkonten erstellen

Für diese Anleitung sind die folgenden beiden Dienstkonten mit den Mindestberechtigungen erforderlich, die für die Verwendung der bereitgestellten Ressourcen erforderlich sind:

Consumer-Dienstkonto: Identität für den Consumer-Worker-Pool, der Nachrichten verarbeitet. Führen Sie den folgenden Befehl aus, um das Consumer-Dienstkonto zu erstellen:
```
gcloud iam service-accounts create $CONSUMER_SA_NAME \
  --display-name="Pub/Sub consumer service account"
```
CREMA-Dienstkonto: Identität für den Autoscaler. Führen Sie den folgenden Befehl aus, um das CREMA-Dienstkonto zu erstellen:
```
gcloud iam service-accounts create $CREMA_SA_NAME \
  --display-name="CREMA service account"
```

Benutzerdefinierten Dienstkonten zusätzliche Berechtigungen gewähren

Um den Worker-Pool zu skalieren, gewähren Sie den benutzerdefinierten Dienstkonten die folgenden Berechtigungen:

Gewähren Sie dem CREMA-Dienstkonto die Berechtigung, aus dem Parameter Manager zu lesen:

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:$CREMA_SA_NAME@$PROJECT_ID.iam.gserviceaccount.com" \
  --role="roles/parametermanager.parameterViewer"

Gewähren Sie dem CREMA-Dienstkonto die Berechtigung, den Worker-Pool zu skalieren:

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:$CREMA_SA_NAME@$PROJECT_ID.iam.gserviceaccount.com" \
  --role="roles/run.developer"

Gewähren Sie dem CREMA-Dienstkonto die Rolle „Dienstkontonutzer“:

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:$CREMA_SA_NAME@$PROJECT_ID.iam.gserviceaccount.com" \
  --role="roles/iam.serviceAccountUser"

Gewähren Sie dem CREMA-Dienstkonto die Berechtigung, Messwerte aufzurufen:

 gcloud projects add-iam-policy-binding $PROJECT_ID \
   --member="serviceAccount:$CREMA_SA_NAME@$PROJECT_ID.iam.gserviceaccount.com" \
   --role="roles/monitoring.viewer"

Gewähren Sie dem CREMA-Dienstkonto die Berechtigung, Messwerte zu schreiben:

 gcloud projects add-iam-policy-binding $PROJECT_ID \
   --member="serviceAccount:$CREMA_SA_NAME@$PROJECT_ID.iam.gserviceaccount.com" \
   --role="roles/monitoring.metricWriter"

Gewähren Sie dem CREMA-Dienstkonto die Berechtigung, Pub/Sub-Nachrichten aufzurufen:

gcloud pubsub subscriptions add-iam-policy-binding $SUBSCRIPTION_ID \
  --member="serviceAccount:$CREMA_SA_NAME@$PROJECT_ID.iam.gserviceaccount.com" \
  --role="roles/pubsub.viewer"

Gewähren Sie dem Consumer-Dienstkonto die Berechtigung, Nachrichten aus dem Abo abzurufen:

gcloud pubsub subscriptions add-iam-policy-binding $SUBSCRIPTION_ID \
  --member="serviceAccount:$CONSUMER_SA_NAME@$PROJECT_ID.iam.gserviceaccount.com" \
  --role="roles/pubsub.subscriber"

Cloud Run-Worker-Pool bereitstellen

So stellen Sie einen Worker-Pool bereit, der Nachrichten aus Pub/Sub-Abos verarbeitet:

Erstellen Sie einen Ordner mit dem Namen consumer und wechseln Sie in das Verzeichnis:
```
mkdir consumer
cd consumer
```

Erstellen Sie eine Datei mit dem Namen worker.py und fügen Sie den folgenden Code hinzu:

import os
import time
from google.cloud import pubsub_v1
from concurrent.futures import TimeoutError

# Configuration
PROJECT_ID = os.environ.get('PROJECT_ID')
SUBSCRIPTION_ID = os.environ.get('SUBSCRIPTION_ID')

subscription_path = f"projects/{PROJECT_ID}/subscriptions/{SUBSCRIPTION_ID}"

print(f"Worker Pool instance starting. Watching {subscription_path}...")

subscriber = pubsub_v1.SubscriberClient()

def callback(message):
    try:
        data = message.data.decode("utf-8")
        print(f"Processing job: {data}")
        time.sleep(5)  # Simulate work
        print(f"Done {data}")
        message.ack()
    except Exception as e:
        print(f"Error processing message: {e}")
        message.nack()

streaming_pull_future = subscriber.subscribe(subscription_path, callback=callback)
print(f"Listening for messages on {subscription_path}...")

# Wrap subscriber in a 'with' block to automatically call close() when done.
with subscriber:
    try:
        # When `timeout` is not set, result() will block indefinitely,
        # unless an exception is encountered first.
        streaming_pull_future.result()
    except TimeoutError:
        streaming_pull_future.cancel()  # Trigger the shutdown.
        streaming_pull_future.result()  # Block until the shutdown is complete.
    except Exception as e:
        print(f"Streaming pull failed: {e}")

Erstellen Sie eine Dockerfile und fügen Sie den folgenden Code hinzu:

FROM python:3.12-slim
RUN pip install google-cloud-pubsub
COPY worker.py .
CMD ["python", "-u", "worker.py"]

Stellen Sie den Consumer-Worker-Pool mit 0 Instanzen bereit, damit CREMA ihn hochskalieren kann:

gcloud beta run worker-pools deploy $CONSUMER_WORKER_POOL_NAME \
  --source . \
  --region $REGION \
  --service-account="$CONSUMER_SA_NAME@$PROJECT_ID.iam.gserviceaccount.com" \
  --instances=0 \
  --set-env-vars PROJECT_ID=$PROJECT_ID,SUBSCRIPTION_ID=$SUBSCRIPTION_ID

Autoscaler-Dienst CREMA bereitstellen

Nachdem Sie den Worker-Pool bereitgestellt haben, um Nachrichten von Pub/Sub zu verarbeiten, konfigurieren Sie den CREMA-Autoscaler, um Worker-Instanzen basierend auf dem Nachrichtenvolumen bereitzustellen.

Autoscaler konfigurieren

In dieser Anleitung wird der Parameter Manager verwendet, um die YAML-Konfigurationsdatei für CREMA zu speichern.

Erstellen Sie einen Parameter im Parameter Manager, um Parameterversionen für CREMA zu speichern:

PARAMETER_ID=crema-config
PARAMETER_REGION=global
gcloud parametermanager parameters create $PARAMETER_ID --location=$PARAMETER_REGION --parameter-format=YAML

Wechseln Sie mit dem folgenden Befehl zum Stammverzeichnis Ihres Projekts:
```
cd
```

Erstellen Sie im Stammverzeichnis eine YAML-Datei (my-crema-config.yaml), um die Autoscaler-Konfiguration zu definieren:

apiVersion: crema/v1
kind: CremaConfig
spec:
  pollingInterval: 30
  triggerAuthentications:
    - metadata:
        name: adc-trigger-auth
      spec:
        podIdentity:
          provider: gcp
  scaledObjects:
    - spec:
        scaleTargetRef:
          name: projects/PROJECT_ID/locations/us-central1/workerpools/worker-pool-consumer
        triggers:
          - type: gcp-pubsub
            metadata:
              subscriptionName: "crema-subscription"
              # Target number of undelivered messages per worker instance
              value: "10"
              mode: "SubscriptionSize"
            authenticationRef:
              name: adc-trigger-auth

Ersetzen Sie PROJECT_ID durch die Google Cloud Projekt-ID.

Laden Sie die lokale YAML-Datei als neue Parameterversion hoch:

LOCAL_YAML_CONFIG_FILE=my-crema-config.yaml
PARAMETER_VERSION=1

gcloud parametermanager parameters versions create $PARAMETER_VERSION \
  --location=$PARAMETER_REGION \
  --parameter=$PARAMETER_ID \
  --payload-data-from-file=$LOCAL_YAML_CONFIG_FILE

Führen Sie den folgenden Befehl aus, um zu prüfen, ob das Hinzufügen des Parameters erfolgreich war:
```
gcloud parametermanager parameters versions list \
--parameter=$PARAMETER_ID \
--location=$PARAMETER_REGION
```
Der Parameterpfad sollte angezeigt werden, z. B. projects/PROJECT_ID/locations/global/parameters/crema-config/versions/1.

Dienst bereitstellen, um Arbeitslasten zu skalieren

Führen Sie den folgenden Befehl mit einem vorgefertigten Container-Image aus, um den Dienst bereitzustellen, mit dem Sie den Worker-Pool skalieren können:

CREMA_CONFIG_PARAM_VERSION=projects/$PROJECT_ID/locations/$PARAMETER_REGION/parameters/$PARAMETER_ID/versions/$PARAMETER_VERSION
IMAGE=us-central1-docker.pkg.dev/cloud-run-oss-images/crema-v1/autoscaler:1.0

gcloud beta run deploy $CREMA_SERVICE_NAME \
  --image=${IMAGE} \
  --region=${REGION} \
  --service-account="${CREMA_SA_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=${CREMA_CONFIG_PARAM_VERSION},OUTPUT_SCALER_METRICS=True"

Autoscaling-Dienst testen

Testen Sie den CREMA-Dienst, indem Sie ein Skript erstellen, das 100 Nachrichten generiert und an die Pub/Sub-Warteschlange sendet:

Erstellen Sie im Stammverzeichnis eine Datei mit dem Namen load-pubsub.sh und fügen Sie den folgenden Code hinzu:

#!/bin/bash

TOPIC_ID=${TOPIC_ID}
PROJECT_ID=${PROJECT_ID}
NUM_MESSAGES=100

echo "Publishing $NUM_MESSAGES messages to topic $TOPIC_ID..."

for i in $(seq 1 $NUM_MESSAGES); do
  gcloud pubsub topics publish $TOPIC_ID --message="job-$i" --project=$PROJECT_ID &
  if (( $i % 10 == 0 )); then
    wait
    echo "Published $i messages..."
  fi
done
wait
echo "Done. All messages published."

Führen Sie den Lasttest aus:

chmod +x load-pubsub.sh
./load-pubsub.sh

Mit diesem Befehl werden 100 Nachrichten generiert und an das Pub/Sub-Abo gesendet.

Skalierung überwachen

Warten Sie nach Abschluss des load-pubsub.sh Skripts drei bis vier Minuten, bevor Sie die Logs für den Dienst my-crema-service prüfen. Der CREMA-Autoscaler-Dienst skaliert die Consumer-Worker-Instanzen von 0 hoch.

Die folgenden Logs sollten angezeigt werden:

Jede Logmeldung 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 ...

Alternativ können Sie den folgenden Befehl ausführen, um zu prüfen, ob der CREMA-Dienst Instanzen basierend auf der Warteschlangentiefe empfiehlt:

gcloud logging read "resource.type=cloud_run_revision AND resource.labels.service_name=$CREMA_SERVICE_NAME AND textPayload:SCALER" \
  --limit=20 \
  --format="value(textPayload)" \
  --freshness=5m

Führen Sie den folgenden Befehl aus, um die Consumer-Logs anzuzeigen, die Nachrichten verarbeiten:

gcloud beta run worker-pools logs tail $CONSUMER_WORKER_POOL_NAME --region=$REGION

Es sollten Logs im Format Done job-100 angezeigt werden.

Bereinigen

Damit Ihrem Google Cloud Konto keine zusätzlichen Kosten entstehen, löschen Sie alle Ressourcen , die Sie mit dieser Anleitung bereitgestellt haben.

Projekt löschen

Wenn Sie ein neues Projekt für diese Anleitung erstellt haben, löschen Sie das Projekt. Wenn Sie ein vorhandenes Projekt verwendet haben und es ohne die Änderungen beibehalten möchten, die Sie in dieser Anleitung vorgenommen haben, löschen Sie die für die Anleitung erstellten Ressourcen.

Am einfachsten vermeiden Sie weitere Kosten, wenn Sie das zum Ausführen der Anleitung erstellte Projekt löschen.

So löschen Sie das Projekt:

Achtung: Das Löschen von Projekten hat folgende Auswirkungen:

Alle Inhalte des Projekts werden gelöscht. Wenn Sie für die Aufgaben in diesem Dokument ein bereits bestehendes Projekt verwendet haben und dieses löschen, werden auch alle anderen im Rahmen des Projekts erstellten Daten gelöscht.
Benutzerdefinierte Projekt-IDs gehen verloren. Beim Erstellen dieses Projekts haben Sie möglicherweise eine benutzerdefinierte Projekt-ID erstellt, die Sie weiterhin verwenden möchten. Damit die URLs, die die Projekt-ID nutzen, z. B. eine appspot.com-URL, erhalten bleiben, sollten Sie ausgewählte Ressourcen innerhalb des Projekts löschen, statt das gesamte Projekt.

Wenn Sie mehrere Architekturen, Anleitungen und Kurzanleitungen durcharbeiten möchten, können Sie die Überschreitung von Projektkontingenten verhindern, indem Sie Projekte wiederverwenden.

Wechseln Sie in der Google Cloud -Console zur Seite Ressourcen verwalten.
Zur Seite „Ressourcen verwalten“
Wählen Sie in der Projektliste das Projekt aus, das Sie löschen möchten, und klicken Sie dann auf Löschen.
Geben Sie im Dialogfeld die Projekt-ID ein und klicken Sie auf Shut down (Beenden), um das Projekt zu löschen.

Anleitungsressourcen löschen

Löschen Sie den Cloud Run-Dienst, den Sie in dieser Anleitung bereitgestellt haben. Für Cloud Run-Dienste fallen erst Kosten an, wenn sie Anfragen erhalten.

Führen Sie den folgenden Befehl aus, um den Cloud Run-Dienst zu löschen:
```
gcloud run services delete SERVICE-NAME
```
Ersetzen Sie SERVICE-NAME durch den Namen Ihres Dienstes.

Sie können Cloud Run-Dienste auch über die Google Cloud Console löschen.
Entfernen Sie die Konfiguration der Standardregion gcloud, die Sie während der Einrichtung für die Anleitung hinzugefügt haben:
```
 gcloud config unset run/region
```
Entfernen Sie die Projektkonfiguration:
```
 gcloud config unset project
```

Löschen Sie die Pub/Sub-Ressourcen:

gcloud pubsub subscriptions delete $SUBSCRIPTION_ID
gcloud pubsub topics delete $TOPIC_ID

Löschen Sie andere Google Cloud Ressourcen, die in dieser Anleitung erstellt wurden:
- Cloud Run-Worker-Pool löschen
- Container-Image des Worker-Pools löschen aus Artifact Registry
- CREMA-Dienst löschen
- Dienstkonten löschen
- Parameter im Parameter Manager löschen

Nächste Schritte

Eine detaillierte Anleitung zu diesem Tutorial finden Sie im Codelab Cloud Run-Worker-Pools basierend auf dem Pub/Sub-Warteschlangenvolumen mit CREMA automatisch skalieren.
Weitere Informationen zu Cloud Run-Worker-Pools.
Weitere Cloud Run-Demos, Anleitungen und Beispiele entdecken
Andere KEDA-Autoscaler mit CREMA konfigurieren