Cloud Run-Worker-Pools mit CREMA auf Grundlage des Pub/Sub-Warteschlangenvolumens automatisch skalieren

1. Einführung

Übersicht

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

Lerninhalte

In diesem Codelab werden Sie:

Erstellen Sie ein Pub/Sub-Thema und ein Abo für dieses Thema und senden Sie Nachrichten an dieses Thema.
Stellen Sie einen Cloud Run-Worker-Pool (Consumer) bereit, der Nachrichten von Pub/Sub empfängt.
Stellen Sie das CREMA-Projekt auf GitHub als Cloud Run-Dienst bereit, um Ihren Worker-Pool automatisch anhand der Anzahl der Nachrichten im Pub/Sub-Abo zu skalieren.
Testen Sie die Autoscaling-Konfiguration, indem Sie die Last mit einem lokal ausgeführten Python-Skript generieren.

2. Umgebungsvariablen konfigurieren

Da in diesem Codelab viele Umgebungsvariablen verwendet werden, empfehlen wir,

set -u

Dadurch werden Sie gewarnt, wenn Sie versuchen, eine Umgebungsvariable zu verwenden, die noch nicht festgelegt wurde. Führen Sie set +u aus, um diese Einstellung rückgängig zu machen.

Ändern Sie zuerst die folgende Variable in Ihre Projekt-ID.

export PROJECT_ID=<YOUR_PROJECT_ID>

und legen Sie es dann als Projekt für dieses Codelab fest.

gcloud config set project $PROJECT_ID

Legen Sie als Nächstes die in diesem Codelab verwendeten Umgebungsvariablen fest.

export REGION=us-central1
export TOPIC_ID=crema-pubsub-topic
export SUBSCRIPTION_ID=crema-pubsub-sub
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

Verzeichnis für dieses Codelab erstellen

mkdir crema-pubsub-codelab
cd crema-pubsub-codelab

APIs aktivieren

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

Prüfen Sie, ob Sie die neueste Version von gcloud verwenden.

gcloud components update

3. Pub/Sub einrichten

Erstellen Sie das Thema und das Pull-Abo, das von Ihrem Worker-Pool verarbeitet wird. Bash

Erstellen Sie das Thema.

gcloud pubsub topics create $TOPIC_ID

Erstellen Sie das Abo.

gcloud pubsub subscriptions create $SUBSCRIPTION_ID --topic=$TOPIC_ID

4. IAM und Dienstkonten

Es wird empfohlen, für jede Cloud Run-Ressource ein Dienstkonto zu erstellen. In diesem Codelab erstellen Sie Folgendes:

Consumer-SA: Identität für den Worker-Pool, der Pub/Sub-Nachrichten verarbeitet.
CREMA SA: Identität für den CREMA-Autoscaler-Dienst.

Dienstkonten erstellen

Erstellen Sie das Dienstkonto des Worker-Pool-Consumers:

gcloud iam service-accounts create $CONSUMER_SA_NAME \
  --display-name="PubSub Consumer Service Account"

Erstellen Sie das CREMA-Dienstkonto für den Worker-Pool:

gcloud iam service-accounts create $CREMA_SA_NAME \
  --display-name="CREMA Autoscaler Service Account"

Berechtigungen für das Consumer-Dienstkonto erteilen

Gewähren Sie der Dienstkonto-Identität des Worker-Pool-Consumers Berechtigungen, um 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"

CREMA SA Berechtigungen erteilen

CREMA benötigt Berechtigungen zum Lesen von Parametern, zum Skalieren des Worker-Pools und zum Überwachen von Pub/Sub-Messwerten.

Auf Parameter Manager zugreifen (Config Reader):

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

Worker-Pool skalieren (Cloud Run Developer):

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

Pub/Sub überwachen:

Weisen Sie die Rolle „Monitoring-Betrachter“ zu.

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

Fügen Sie dem Abo für den CREMA-Dienst SA eine Richtlinie hinzu, um sie aufzurufen.

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

Das CREMA-Dienstkonto benötigt außerdem die Rolle „Dienstkontonutzer“, die zum Ändern der Anzahl von Instanzen erforderlich ist:

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

5. Berechtigungen des Dienstkontos prüfen

Bevor Sie mit dem Codelab fortfahren, prüfen Sie, ob die CREMA-Dienst-SA die richtigen Rollen auf Projektebene hat.

gcloud projects get-iam-policy $PROJECT_ID \
  --flatten="bindings[].members" \
  --format="table(bindings.role)" \
  --filter="bindings.members:serviceAccount:$CREMA_SA_NAME@$PROJECT_ID.iam.gserviceaccount.com"

Das sollte zu Folgendem führen:

roles/monitoring.viewer
roles/parametermanager.parameterViewer
roles/run.developer

Prüfen Sie, ob für das Pub/Sub-Abo eine Richtlinie vorhanden ist, die es dem CREMA-Dienstkonto erlaubt, es aufzurufen.

gcloud pubsub subscriptions get-iam-policy $SUBSCRIPTION_ID \
  --flatten="bindings[].members" \
  --filter="bindings.members:serviceAccount:$CREMA_SA_NAME@$PROJECT_ID.iam.gserviceaccount.com" \
  --format="table(bindings.role)"

Sollte zu Folgendem führen

roles/pubsub.viewer

und prüfen Sie, ob das CREMA-Dienstkonto die Rolle „Dienstkontonutzer“ hat.

gcloud iam service-accounts get-iam-policy \
  $CONSUMER_SA_NAME@$PROJECT_ID.iam.gserviceaccount.com \
  --flatten="bindings[].members" \
  --filter="bindings.members:serviceAccount:$CREMA_SA_NAME@$PROJECT_ID.iam.gserviceaccount.com"

Das sollte zu Folgendem führen:

bindings:
  members: serviceAccount:crema-service-account@<PROJECT_ID>.iam.gserviceaccount.com
  role: roles/iam.serviceAccountUser

Das Dienstkonto des Worker-Pool-Consumers hat die Pub/Sub-Abonnentenrolle.

gcloud pubsub subscriptions get-iam-policy $SUBSCRIPTION_ID \
  --flatten="bindings[].members" \
  --filter="bindings.members:serviceAccount:$CONSUMER_SA_NAME@$PROJECT_ID.iam.gserviceaccount.com" \
  --format="table(bindings.role)"

Sollte zu Folgendem führen

ROLE
roles/pubsub.subscriber

6. Consumer-Worker-Pool erstellen und bereitstellen

Erstellen Sie ein Verzeichnis für Ihren Verbrauchercode und rufen Sie es auf.

mkdir consumer
cd consumer

consumer.py-Datei erstellen

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}")

Dockerfile erstellen

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

Consumer-Worker-Pool bereitstellen

In diesem Codelab wird empfohlen, den Worker-Pool mit 0 Instanzen bereitzustellen, damit Sie sehen können, wie CREMA den Worker-Pool skaliert, wenn die Pub/Sub-Nachrichten im Abo erkannt werden.

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

7. CREMA konfigurieren

Wechseln Sie zurück zum Stammverzeichnis Ihres Projekts.

cd ..

Konfigurationsdatei erstellen Erstellen Sie eine Datei mit dem Namen crema-config.yaml.

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_PLACEHOLDER/locations/REGION_PLACEHOLDER/workerpools/CONSUMER_WORKER_POOL_NAME_PLACEHOLDER
        triggers:
          - type: gcp-pubsub
            metadata:
              subscriptionName: "SUBSCRIPTION_ID_PLACEHOLDER"
              # Target number of undelivered messages per worker instance
              value: "10"
              mode: "SubscriptionSize"
            authenticationRef:
              name: adc-trigger-auth

Variablen ersetzen

sed -i "s/PROJECT_ID_PLACEHOLDER/$PROJECT_ID/g" crema-config.yaml
sed -i "s/REGION_PLACEHOLDER/$REGION/g" crema-config.yaml
sed -i "s/CONSUMER_WORKER_POOL_NAME_PLACEHOLDER/$CONSUMER_WORKER_POOL_NAME/g" crema-config.yaml
sed -i "s/SUBSCRIPTION_ID_PLACEHOLDER/$SUBSCRIPTION_ID/g" crema-config.yaml

Prüfen Sie, ob Ihre crema-config.yaml korrekt ist.

if grep -q "_PLACEHOLDER" crema-config.yaml; then
  echo "❌ ERROR: Validations failed. '_PLACEHOLDER' was found in crema-config.yaml."
  echo "Please check your environment variables and run the 'sed' commands again."
else
  echo "✅ Config check passed: No placeholders found."
fi

In Parameter Manager hochladen

Zusätzliche Umgebungsvariablen für Parameter Manager festlegen

export PARAMETER_ID=crema-config
export PARAMETER_REGION=global
export PARAMETER_VERSION=1

Parameterressource erstellen

gcloud parametermanager parameters create $PARAMETER_ID \
  --location=$PARAMETER_REGION \
  --parameter-format=YAML

Parameterversion 1 erstellen

gcloud parametermanager parameters versions create $PARAMETER_VERSION \
  --parameter=crema-config \
  --project=$PROJECT_ID \
  --location=$PARAMETER_REGION \
  --payload-data-from-file=crema-config.yaml

Prüfen, ob der Parameter erfolgreich hinzugefügt wurde

gcloud parametermanager parameters versions list \
  --parameter=$PARAMETER_ID \
  --location=$PARAMETER_REGION

Die Ausgabe sollte etwa so aussehen:

projects/<YOUR_PROJECT_ID>/locations/global/parameters/crema-config/versions/1

8. CREMA-Dienst bereitstellen

In diesem Abschnitt stellen Sie den CREMA-Autoscaler-Dienst bereit. Sie verwenden das öffentlich verfügbare Bild.

Umgebungsvariablen für CREMA festlegen

CREMA_CONFIG_PARAM_VERSION=projects/$PROJECT_ID/locations/$PARAMETER_REGION/parameters/$PARAMETER_ID/versions/$PARAMETER_VERSION

Pfad des Versionsnamens prüfen

echo $CREMA_CONFIG_PARAM_VERSION

Es sollte so aussehen:

projects/<YOUR_PROJECT>/locations/global/parameters/crema-config/versions/1

Umgebungsvariable für das CREMA-Image festlegen

IMAGE=us-central1-docker.pkg.dev/cloud-run-oss-images/crema-v1/autoscaler:1.0

und den CREMA-Dienst bereitstellen

Das Basis-Image ist erforderlich.

gcloud beta run deploy $CREMA_SERVICE_NAME \
  --image=$IMAGE \
  --region=${REGION} \
  --service-account="${CREMA_SA_NAME}@${PROJECT_ID}.iam.gserviceaccount.com" \
  --no-allow-unauthenticated \
  --no-cpu-throttling \
  --labels=created-by=crema \
  --base-image=us-central1-docker.pkg.dev/serverless-runtimes/google-24/runtimes/java25 \
  --set-env-vars="CREMA_CONFIG=${CREMA_CONFIG_PARAM_VERSION},OUTPUT_SCALER_METRICS=True,ENABLE_CLOUD_LOGGING=True"

9. Lasttests

Skript erstellen, das Nachrichten im Pub/Sub-Thema veröffentlicht

touch load-pubsub.sh

Fügen Sie der Datei load-pubsub.sh 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."

Lasttest ausführen

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

Warten Sie 3 bis 4 Minuten, bis die Skalierung abgeschlossen ist. Sehen Sie sich die CREMA-Logs an, um zu sehen, wie Instanzen basierend auf der neuen „authenticationRef“-Konfiguration empfohlen werden.

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

Verarbeitung überwachen: Sehen Sie sich die Consumer-Logs an, um zu sehen, wie sie hochgefahren werden.

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

Sie sollten Logs wie die folgenden sehen:

Done job-100

10. Fehlerbehebung

Zuerst müssen Sie feststellen, ob das Problem mit der CREMA-Dienstkonfiguration oder mit der PubSub-Nutzerkonfiguration zusammenhängt.

Setzen Sie den Autoscaler für den PubSub-Consumer auf 1 statt auf 0. Wenn sofort mit der Verarbeitung von Pub/Sub-Nachrichten begonnen wird, liegt ein Problem mit der CREMA vor. Wenn die Pub/Sub-Nachrichten nicht verarbeitet werden, liegt ein Problem mit dem Pub/Sub-Consumer vor.

11. Glückwunsch!

Herzlichen Glückwunsch zum Abschluss des Codelabs!

Wir empfehlen, die Cloud Run-Dokumentation zu lesen.

Behandelte Themen

Hier erfahren Sie, wie Sie ein Pub/Sub-Thema und ein Abo erstellen und Nachrichten in dieses Thema übertragen.
Informationen zum Bereitstellen eines Cloud Run-Worker-Pools (Consumer), der Nachrichten von Pub/Sub empfängt.
So stellen Sie das CREMA-Projekt auf GitHub als Cloud Run-Dienst bereit, um Ihren Worker-Pool automatisch an die Anzahl der Nachrichten im Pub/Sub-Abo anzupassen.
So testen Sie Ihre Autoscaling-Konfiguration, indem Sie die Last durch Ausführen eines Python-Scripts lokal generieren.

12. Bereinigen

Wenn Sie vermeiden möchten, dass Ihrem Google Cloud-Konto Gebühren für die in diesem Codelab verwendeten Ressourcen entstehen, können Sie entweder die Ressourcen löschen, die Sie in diesem Codelab erstellt haben, oder das gesamte Projekt löschen.

In diesem Codelab verwendete Ressourcen löschen

Cloud Run-CREMA-Dienst löschen

gcloud run services delete $CREMA_SERVICE_NAME --region=$REGION --quiet

Cloud Run-Worker-Pool-Consumer löschen

gcloud beta run worker-pools delete $CONSUMER_WORKER_POOL_NAME --region=$REGION --quiet

Pub/Sub-Abo und -Thema löschen

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

Parameter Manager-Konfiguration löschen

Version im Parameter löschen

gcloud parametermanager parameters versions delete $PARAMETER_VERSION \
  --parameter=$PARAMETER_ID \
  --location=$PARAMETER_REGION \
  --quiet

Leeren Parameter löschen

gcloud parametermanager parameters delete $PARAMETER_ID \
  --location=$PARAMETER_REGION \
  --quiet

Dienstkonten löschen

gcloud iam service-accounts delete "$CREMA_SA_NAME@$PROJECT_ID.iam.gserviceaccount.com" --quiet
gcloud iam service-accounts delete "$CONSUMER_SA_NAME@$PROJECT_ID.iam.gserviceaccount.com" --quiet

Oder das gesamte Projekt löschen

Wenn Sie das gesamte Projekt löschen möchten, rufen Sie Ressourcen verwalten auf, wählen Sie das Projekt aus, das Sie in Schritt 2 erstellt haben, und klicken Sie auf „Löschen“. Wenn Sie das Projekt löschen, müssen Sie das Projekt in Ihrem Cloud SDK ändern. Sie können die Liste aller verfügbaren Projekte mit gcloud projects list aufrufen.