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 faire évoluer automatiquement 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éer un sujet et un abonnement Pub/Sub pour envoyer des messages au sujet.
• Déployer un pool de nœuds de calcul Cloud Run qui consomme des messages à partir de Pub/Sub.
• Déployer le service d'autoscaling CREMA pour faire évoluer votre pool de nœuds de calcul.
• Tester votre service d'autoscaling en exécutant un script Python localement pour générer une charge.

Coûts

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

• Artifact Registry
• Cloud Build
• Cloud Run
• Pub/Sub

Obtenez 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 Google Cloud compte. 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.

Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

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.

Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

Go to project selector

Verify that billing is enabled for your Google Cloud project.

1. 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 d'utilisation du service (roles/serviceusage.serviceUsageAdmin), qui contient l'autorisation serviceusage.services.enable. Découvrez comment attribuer des rôles.

   Activer les API

2. Installez et initialisez gcloud CLI.
3. Mettez à jour les composants :

   gcloud components update

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

5. 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 Google Cloud projet.
6. Définissez l'ID de votre projet en exécutant la commande suivante :

   gcloud config set project $PROJECT_ID

7. Vous êtes facturé pour votre service de scaling Cloud Run en fonction 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 attribuer 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.

Remarque : Les rôles de base IAM peuvent également contenir des autorisations permettant de suivre le tutoriel. Les rôles de base ne doivent pas être attribués dans un environnement de production, mais ils peuvent l'être dans un environnement de développement ou de test.

Créer un sujet et un abonnement Pub/Sub

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

1. Créez un sujet Pub/Sub qui représente un flux de messages :

   gcloud pubsub topics create $TOPIC_ID
   

2. Créez un abonnement pull pour consommer des messages à partir 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 faire évoluer le pool de nœuds de calcul, accordez les autorisations suivantes sur les comptes de service personnalisés :

1. Accordez à votre compte de service CREMA l'autorisation de lire à partir de Parameter Manager :

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

2. Accordez à votre compte de service CREMA l'autorisation de faire évoluer 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"
   

3. Accordez à votre compte de service CREMA le rôle d'utilisateur de compte de service :

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

4. Accordez à votre compte de service CREMA l'autorisation d'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"
   

5. Accordez à votre compte de service CREMA l'autorisation d'é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"
   

6. 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"
   

7. 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 à partir d'abonnements Pub/Sub, procédez comme suit :

1. Créez un dossier nommé consumer et accédez-y :

   mkdir consumer
   cd consumer
   

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

3. 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"]
   

4. Déployez le pool de nœuds de calcul consommateur avec 0 instance pour que CREMA puisse le faire évoluer :

   gcloud 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 d'autoscaling CREMA

Une fois que vous avez déployé le pool de nœuds de calcul pour consommer des messages à partir 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 Parameter Manager pour stocker le fichier de configuration YAML pour CREMA.

1. Créez un paramètre dans Parameter Manager 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
   

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

   cd
   

3. 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 Google Cloud projet.

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

5. Exécutez la commande suivante pour vérifier que l'ajout de votre paramètre a réussi :

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

   Vous devriez voir le chemin d'accès au paramètre, tel que projects/PROJECT_ID/locations/global/parameters/crema-config/versions/1.

Déployer le service pour faire évoluer vos charges de travail

Pour déployer le service afin de faire évoluer 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 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 :

1. 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."
   

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

Surveiller le scaling

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

Vous devriez voir les journaux suivants :

Chaque message de journal est libellé avec le 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 de consommateur qui consomment des messages, exécutez la commande suivante :

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

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

Libérer de l'espace

Pour éviter des frais supplémentaires sur votre Google Cloud compte, 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 ce 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.

1. Dans la Google Cloud console, accédez à la page Gérer les ressources.

   Accéder à la page "Gérer les ressources"

2. Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer.
3. Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez Arrêter pour supprimer le projet.

Supprimer les ressources du tutoriel

1. Supprimez le service Cloud Run que vous avez déployé dans ce tutoriel. Les services Cloud Run n'entraînent pas de coûts tant qu'ils ne reçoivent pas de 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 de votre service.

   Vous pouvez également supprimer des services Cloud Run à partir de la Google Cloud console.

2. Supprimez la configuration régionale gcloud par défaut que vous avez ajoutée lors de la configuration du tutoriel :

    gcloud config unset run/region
   

3. Supprimez la configuration du projet :

    gcloud config unset project
   

4. Supprimez les ressources Pub/Sub :

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

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

   • Supprimer le pool de nœuds de calcul Cloud Run
   • Supprimer l'image de conteneur du pool de nœuds de calcul d'Artifact Registry
   • Supprimer le service CREMA
   • Supprimer les comptes de service
   • Supprimer les paramètres dans Parameter Manager

Étape suivante

• Pour obtenir une présentation détaillée de ce tutoriel, consultez l'atelier de programmation Faire évoluer automatiquement 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.