Autoscaler les pools de nœuds de calcul en fonction du volume de la file d'attente Pub/Sub

Ce tutoriel explique comment déployer un pool de nœuds de calcul Cloud Run pour traiter les messages Pub/Sub et comment effectuer le scaling automatique de vos instances de consommateur en fonction de la profondeur de la file d'attente à l'aide de l'autoscaling des métriques externes Cloud Run (CREMA).

Objectifs

Au cours de ce tutoriel, vous allez :

Créez un sujet et un abonnement Pub/Sub pour envoyer des messages au sujet.
Déployez un pool de nœuds de calcul Cloud Run qui consomme des messages Pub/Sub.
Déployez le service CREMA d'autoscaler pour mettre à l'échelle votre pool de nœuds de calcul.
Testez votre service d'autoscaling en exécutant un script Python localement pour générer de la charge.

Coûts

Dans ce document, vous utilisez les composants facturables suivants de Google Cloud :

Pour obtenir une estimation des coûts en fonction de votre utilisation prévue, utilisez le simulateur de coût.

Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai sans frais.

Avant de commencer

Connectez-vous à votre compte Google Cloud . Si vous débutez sur Google Cloud, créez un compte pour évaluer les performances de nos produits en conditions réelles. Les nouveaux clients bénéficient également de 300 $de crédits sans frais pour exécuter, tester et déployer des charges de travail.

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.

Activez les API Cloud Run, Parameter Manager, Artifact Registry, Pub/Sub et Cloud Build.
Rôles requis pour activer les API
Pour activer les API, vous avez besoin du rôle IAM Administrateur Service Usage (roles/serviceusage.serviceUsageAdmin), qui contient l'autorisation serviceusage.services.enable. Découvrez comment attribuer des rôles.
Activer les API

Installez et initialisez la gcloud CLI.
Mettez à jour les composants :
```
gcloud components update
```
Ce tutoriel utilise plusieurs variables d'environnement. Pour améliorer le débogage, exécutez la commande suivante afin de générer une erreur lorsque vous faites référence à des variables d'environnement locales non définies :
```
set -u
```

Définissez les variables de configuration suivantes pour CREMA, utilisées dans ce tutoriel :

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

Remplacez PROJECT_ID par l'ID de votre projet Google Cloud .

Définissez l'ID de votre projet en exécutant la commande suivante :
```
gcloud config set project $PROJECT_ID
```
Les frais de votre service de scaling Cloud Run dépendent de la fréquence à laquelle vous déclenchez le scaling. Pour en savoir plus, estimez les coûts avec le simulateur de coût.

Rôles requis

Pour obtenir les autorisations nécessaires pour suivre le tutoriel, demandez à votre administrateur de vous accorder les rôles IAM suivants sur votre projet :

Administrateur de dépôts Artifact Registry (roles/artifactregistry.repoAdmin)
Éditeur Cloud Build (roles/cloudbuild.builds.editor)
Administrateur Cloud Run (roles/run.admin)
Créer des comptes de service (roles/iam.serviceAccountCreator)
Administrateur Pub/Sub (roles/pubsub.admin)
Utilisateur du compte de service (roles/iam.serviceAccountUser)
Consommateur Service Usage (roles/serviceusage.serviceUsageConsumer)
Administrateur Parameter Manager (roles/parametermanager.admin)

Pour en savoir plus sur l'attribution de rôles, consultez Gérer l'accès aux projets, aux dossiers et aux organisations.

Vous pouvez également obtenir les autorisations requises via des rôles personnalisés ou d'autres rôles prédéfinis.

Créer un sujet et un abonnement Pub/Sub

Pour autoscaler votre nœud de calcul, créez un abonnement pull pour votre application consommateur en procédant comme suit :

Créez un sujet Pub/Sub qui représente un flux de messages :
```
gcloud pubsub topics create $TOPIC_ID
```
Créez un abonnement pull pour consommer les messages de votre sujet Pub/Sub :
```
gcloud pubsub subscriptions create $SUBSCRIPTION_ID --topic=$TOPIC_ID
```

Créer des comptes de service personnalisés

Ce tutoriel nécessite les deux comptes de service suivants avec les autorisations minimales requises pour utiliser les ressources provisionnées :

Compte de service consommateur : identité du pool de nœuds de calcul consommateur qui traite les messages. Exécutez la commande suivante pour créer le compte de service consommateur :
```
gcloud iam service-accounts create $CONSUMER_SA_NAME \
  --display-name="Pub/Sub consumer service account"
```
Compte de service CREMA : identité de l'autoscaler. Exécutez la commande suivante pour créer le compte de service CREMA :
```
gcloud iam service-accounts create $CREMA_SA_NAME \
  --display-name="CREMA service account"
```

Accorder des autorisations supplémentaires à vos comptes de service personnalisés

Pour mettre à l'échelle le pool de nœuds de calcul, accordez les autorisations suivantes sur les comptes de service personnalisés :

Accordez à votre compte de service CREMA l'autorisation de lire les paramètres dans Parameter Manager :

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

Accordez à votre compte de service CREMA l'autorisation de mettre à l'échelle le pool de nœuds de calcul :

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

Attribuez le rôle d'utilisateur de compte de service à votre compte de service CREMA :

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

Autorisez votre compte de service CREMA à afficher les métriques :

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

Autorisez votre compte de service CREMA à écrire des métriques :

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

Accordez à votre compte de service CREMA l'autorisation d'afficher les messages Pub/Sub :

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

Accordez à votre compte de service consommateur l'autorisation d'extraire des messages de l'abonnement :

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

Déployer un pool de nœuds de calcul Cloud Run

Pour déployer un pool de nœuds de calcul qui consomme des messages provenant d'abonnements Pub/Sub, procédez comme suit :

Créez un dossier nommé consumer et accédez-y :
```
mkdir consumer
cd consumer
```

Créez un fichier nommé worker.py et ajoutez le code suivant :

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

Créez un fichier Dockerfile et ajoutez le code suivant :

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

Déployez le pool de nœuds de calcul consommateur avec 0 instance pour que CREMA puisse évoluer à la hausse :

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

Déployer le service CREMA de l'autoscaler

Une fois le pool de nœuds de calcul déployé pour consommer les messages de Pub/Sub, configurez l'autoscaler CREMA pour provisionner des instances de nœuds de calcul en fonction du volume de messages.

Configurer l'autoscaler

Ce tutoriel utilise le gestionnaire de paramètres pour stocker le fichier de configuration YAML de CREMA.

Créez un paramètre dans le Gestionnaire de paramètres pour stocker les versions de paramètres pour CREMA :

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

Accédez au répertoire racine de votre projet en exécutant la commande suivante :
```
cd
```

Dans votre répertoire racine, créez un fichier YAML, my-crema-config.yaml, pour définir la configuration de l'autoscaler :

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

Remplacez PROJECT_ID par l'ID du projet Google Cloud .

Importez votre fichier YAML local en tant que nouvelle version de paramètre :

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

Exécutez la commande suivante pour vérifier que votre paramètre a bien été ajouté :
```
gcloud parametermanager parameters versions list \
--parameter=$PARAMETER_ID \
--location=$PARAMETER_REGION
```
Le chemin du paramètre devrait s'afficher, par exemple projects/PROJECT_ID/locations/global/parameters/crema-config/versions/1.

Déployer le service pour mettre à l'échelle vos charges de travail

Pour déployer le service afin de mettre à l'échelle votre pool de nœuds de calcul, exécutez la commande suivante avec une image de conteneur prédéfinie :

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"

Tester votre service d'autoscaling

Testez votre service CREMA en créant un script qui génère 100 messages et les envoie à la file d'attente Pub/Sub :

Dans votre répertoire racine, créez un fichier nommé load-pubsub.sh et ajoutez le code suivant :

#!/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."

Exécutez le test de charge :

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

Cette commande génère et envoie 100 messages à l'abonnement Pub/Sub.

Surveillance du scaling

Une fois le script load-pubsub.sh terminé, attendez trois à quatre minutes avant de consulter les journaux du service my-crema-service. Le service d'autoscaling CREMA augmente le nombre d'instances de nœuds de calcul du consommateur à partir de 0.

Les journaux suivants devraient s'afficher :

Chaque message de journal est associé au composant qui l'a émis.

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

Vous pouvez également exécuter la commande suivante pour vérifier que le service CREMA recommande des instances en fonction de la profondeur de la file d'attente :

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

Pour afficher les journaux des consommateurs qui utilisent les messages, exécutez la commande suivante :

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

Vous devriez voir des journaux au format Done job-100.

Effectuer un nettoyage

Pour éviter des frais supplémentaires sur votre compte Google Cloud , supprimez toutes les ressources que vous avez déployées avec ce tutoriel.

Supprimer le projet

Si vous avez créé un projet pour ce tutoriel, supprimez-le. Si vous avez utilisé un projet existant et que vous devez le conserver sans les modifications que vous avez ajoutées dans ce tutoriel, supprimez les ressources que vous avez créées pour le tutoriel.

Le moyen le plus simple d'empêcher la facturation est de supprimer le projet que vous avez créé pour ce tutoriel.

Pour supprimer le projet :

Attention : La suppression d'un projet aura les effets suivants :

Tout le contenu du projet est supprimé. Si vous avez utilisé un projet existant pour les tâches décrites dans ce document et que vous le supprimez, vous supprimerez également tout autre travail effectué dans le projet.
Les ID de projets personnalisés sont perdus. Lorsque vous avez créé ce projet, vous avez peut-être créé un ID de projet personnalisé que vous souhaitez utiliser à l'avenir. Pour conserver les URL qui utilisent l'ID de projet, telle qu'une URL appspot.com, supprimez les ressources sélectionnées dans le projet au lieu de supprimer l'ensemble du projet.

Si vous envisagez d'explorer plusieurs architectures, tutoriels et guides de démarrage rapide, réutiliser des projets peut vous aider à ne pas dépasser les limites de quotas des projets.

Dans la console Google Cloud , accédez à la page Gérer les ressources.
Accéder à la page "Gérer les ressources"
Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer.
Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.

Supprimer les ressources du tutoriel

Supprimez le service Cloud Run que vous avez déployé dans ce tutoriel. Les services Cloud Run n'entraînent des coûts que lorsqu'ils reçoivent des requêtes.

Pour supprimer votre service Cloud Run, exécutez la commande suivante :
```
gcloud run services delete SERVICE-NAME
```
Remplacez SERVICE-NAME par le nom du service.

Vous pouvez également supprimer des services Cloud Run à partir de la consoleGoogle Cloud .
Supprimez la configuration régionale par défaut gcloud que vous avez ajoutée lors de la configuration du tutoriel :
```
 gcloud config unset run/region
```
Supprimez la configuration du projet :
```
 gcloud config unset project
```

Supprimez les ressources Pub/Sub :

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

Supprimez les autres ressources Google Cloud créées dans ce tutoriel :

Étapes suivantes

Pour obtenir un guide détaillé de ce tutoriel, consultez l'atelier de programmation Autoscaler les pools de nœuds de calcul Cloud Run en fonction du volume de la file d'attente Pub/Sub à l'aide de CREMA.
En savoir plus sur les pools de nœuds de calcul Cloud Run
Découvrez d'autres démonstrations, tutoriels et exemples concernant Cloud Run.
Configurez d'autres scalers KEDA avec CREMA.