Autoscaler les pools de nœuds de calcul en fonction des métriques Prometheus

Ce tutoriel explique comment effectuer l'autoscaling de vos pools de nœuds de calcul Cloud Run en fonction des métriques Prometheus à l'aide de l'autoscaling des métriques externes Cloud Run (CREMA).

Le service d'autoscaling CREMA effectue un calcul basé sur un ratio à l'aide des données de Prometheus. Le service d'autoscaling ajuste dynamiquement le nombre d'instances pour s'assurer que votre pool de nœuds de calcul dispose de la bonne quantité de ressources pour la charge de travail actuelle. CREMA calcule l'utilisation du processeur de votre pool de nœuds de calcul sur une période spécifique et la compare au seuil configuré pour ajuster les instances.

Objectifs

Au cours de ce tutoriel, vous allez :

Coûts

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

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

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

  2. Verify that billing is enabled for your Google Cloud project.

  3. Activez les API Cloud Run, Parameter Manager, Artifact Registry, Cloud Build et Cloud Monitoring.

    Rôles requis pour activer les API

    Pour activer les API, vous devez disposer de l'autorisation serviceusage.services.enable. Si vous avez créé le projet, vous disposez probablement déjà de cette autorisation via le rôle Propriétaire (roles/owner). Sinon, vous pouvez obtenir cette autorisation via le rôle Administrateur Service Usage (roles/serviceusage.serviceUsageAdmin). Découvrez comment attribuer des rôles.

    Activer les API

  4. Installez et initialisez gcloud CLI.
  5. Mettez à jour les composants : 
    gcloud components update
  6. Définissez les variables de configuration suivantes pour CREMA utilisées dans ce tutoriel : 
    export PROJECT_ID=PROJECT_ID
export REGION=us-central1
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.
  7. Définissez l'ID de votre projet en exécutant la commande suivante : 
    gcloud config set project $PROJECT_ID
  8. 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 à l'aide du 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 :

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 avec des rôles personnalisés ou d'autres rôles prédéfinis.

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 qui exécute une charge de travail en arrière-plan. Exécutez la commande suivante pour créer le compte de service consommateur :

    gcloud iam service-accounts create $CONSUMER_SA_NAME \
  --display-name="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 :

  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." \
  --role="roles/parametermanager.parameterViewer"

  2. 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." \
  --role="roles/run.developer"

  3. Attribuez à 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." \
  --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." \
   --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." \
   --role="roles/monitoring.metricWriter"

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

Déployez un pool de nœuds de calcul avec 0 instance pour que CREMA puisse effectuer un scaling à la hausse :

gcloud run worker-pools deploy $CONSUMER_WORKER_POOL_NAME \
  --image us-docker.pkg.dev/cloudrun/container/worker-pool:latest \
  --instances 0 \
  --region $REGION \
  --memory 4G \
  --cpu 4 \
  --service-account="$CONSUMER_SA_NAME@$PROJECT_ID."

Déployer le service d'autoscaling CREMA

Déployez le service CREMA pour effectuer l'autoscaling de votre pool de nœuds de calcul en fonction des métriques Prometheus.

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. Dans votre répertoire racine, créez un fichier YAML, my-crema-config.yaml, pour définir la configuration de l'autoscaler. Définissez le seuil d'autoscaling sur 50% d'utilisation du processeur :

    apiVersion: crema/v1
kind: CremaConfig
spec:
  pollingInterval: 30
  triggerAuthentications:
    - metadata:
        name: google-crema-auth
      spec:
        podIdentity:
          provider: gcp
  scaledObjects:
    - spec:
        scaleTargetRef:
          name: projects/PROJECT_ID/locations/us-central1/workerPools/worker-pool-consumer
        minReplicaCount: 1
        maxReplicaCount: 20
        triggers:
          - type: prometheus
            metadata:
              serverAddress: https://monitoring.googleapis.com/v1/projects/PROJECT_ID/location/global/prometheus
              threshold: "0.5"
              query: |
                histogram_quantile(
                  0.50,
                  sum by (le) (
                    increase(
                      run_googleapis_com:container_cpu_utilizations_bucket{
                        monitored_resource="cloud_run_worker_pool",
                        worker_pool_name="worker-pool-consumer",
                        location="us-central1",
                        project_id="PROJECT_ID"
                      }[2m]
                    )
                  )
                )
            authenticationRef:
              name: google-crema-auth
        advanced:
          horizontalPodAutoscalerConfig:
            behavior:
              scaleDown:
                stabilizationWindowSeconds: 300

    Remplacez PROJECT_ID par l'ID du Google Cloud projet.

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

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

Pour vérifier que votre service d'autoscaling fonctionne correctement, consultez l'onglet Journaux du service Cloud Run. Le service d'autoscaling CREMA met à l'échelle les instances de nœuds de calcul consommateur à partir de 0.

Vous devriez voir les journaux suivants dans les journaux de votre service chaque fois que les métriques sont actualisées :

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

Cloud Run attribue un libellé à chaque message de journalisation avec le composant qui l'a émis.

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 le tutoriel.

Le moyen le plus simple d'éviter la facturation consiste à supprimer le projet que vous avez créé pour le tutoriel.

Pour supprimer le projet :

  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 celui 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 du service.

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

  2. Supprimez la configuration de région par défaut gcloud 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 autres Google Cloud ressources créées dans ce tutoriel :

Étape suivante