Autoscaler des pools de nœuds de calcul avec des métriques externes

Preview — Cloud Run External Metrics Autoscaling (CREMA)

Cette fonctionnalité est soumise(s) aux "Conditions des offres de pré-DG" de la section "Conditions générales du service" des Conditions spécifiques du service. Les fonctionnalités de pré-DG sont disponibles "en l'état" et peuvent avoir une prise en charge limitée. Pour en savoir plus, consultez les descriptions des étapes de lancement.

Cette page explique comment effectuer l'autoscaling des pools de nœuds de calcul Cloud Run à l'aide de métriques externes axées sur les événements. L'autoscaling des métriques externes Cloud Run (CREMA) permet cette fonctionnalité en tirant parti de l'autoscaling basé sur les événements Kubernetes (KEDA) pour mettre à l'échelle les charges de travail en fonction de sources d'événements externes.

Pour connaître les scalers compatibles et la compatibilité avec Cloud Run, consultez Autoscaling des métriques externes Cloud Run (CREMA) dans la documentation GitHub de Google Cloud .

À propos du service Autoscaler

Pour effectuer l'autoscaling des pools de nœuds de calcul, déployez le service d'autoscaler CREMA sur Cloud Run. Ce service effectue les actions suivantes :

1. Interroge les sources d'événements externes, telles que les sujets Apache Kafka ou GitHub Runner Scaler.

2. Calcule le nombre d'instances requis en fonction de votre configuration YAML.

3. Met à jour automatiquement le nombre d'instances du pool de nœuds de calcul.

Avant de commencer

1. Assurez-vous d'avoir configuré un nouveau projet pour Cloud Run, comme décrit sur la page de configuration.

2. Activez les API Artifact Registry, Cloud Build, Cloud Run Admin, Secret Manager et Parameter Manager :

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

3. Configurez une charge de travail basée sur des événements ou des requêtes, comme GitHub Runners ou Apache Kafka. Pour vérifier que votre source de charge de travail est compatible, consultez la liste de compatibilité CREMA dans la documentation GitHub de Google Cloud .

4. Consultez le simulateur de coût pour estimer les coûts. Les frais de votre service de scaling Cloud Run dépendent de la fréquence à laquelle vous déclenchez le scaling.

Rôles requis

Pour obtenir les autorisations nécessaires pour autoscaler votre pool de nœuds de calcul, 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 Secret Manager (roles/secretmanager.admin)
• Utilisateur du compte de service (roles/iam.serviceAccountUser)
• Consommateur Service Usage (roles/serviceusage.serviceUsageConsumer)
• Administrateur de l'espace de stockage (roles/storage.admin)
• 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 avec 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 d'autoscaler votre pool de nœuds de calcul. Les rôles de base ne doivent pas être attribués dans un environnement de production, mais ils peuvent être attribués dans un environnement de développement ou de test.

Créer un compte de service personnalisé

Créez un compte de service personnalisé avec les autorisations minimales requises pour utiliser les ressources provisionnées nécessaires à votre charge de travail. Pour configurer le compte de service, procédez comme suit :

gcloud iam service-accounts create CREMA_SERVICE_ACCOUNT \
  --display-name="CREMA Service Account"

Remplacez CREMA_SERVICE_ACCOUNT par le nom de votre compte de service personnalisé, par exemple crema-service-account. Cette commande crée un compte de service au format [e-mail].

Créer le fichier de configuration CREMA

Pour définir votre logique de scaling, créez un fichier de configuration YAML dans votre répertoire racine. Ce fichier indique au service CREMA les sources externes à surveiller, comment s'authentifier auprès des ressources et quels pools de nœuds de calcul mettre à l'échelle.

Exemple YAML

L'exemple suivant montre le fichier de configuration permettant de mettre à l'échelle un pool de nœuds de calcul Cloud Run (example-workerpool) à l'aide des métriques GitHub Runner. Il utilise un secret Secret Manager nommé github_runner_token pour s'authentifier auprès de GitHub et lire les métriques.

  apiVersion: crema/v1
  kind: CremaConfig
  metadata:
    name: gh-demo
  spec:
    triggerAuthentications:
      - metadata:
          name: github-trigger-auth
        spec:
          gcpSecretManager:
            secrets:
              - parameter: personalAccessToken
                id: github_runner_token
                version: latest
    scaledObjects:
      - spec:
          scaleTargetRef:
            name: projects/example-project/locations/us-central1/workerpools/example-workerpool
          triggers:
            - type: github-runner
              name: example-runner
              metadata:
                owner: repo-owner
                runnerScope: repo
                repos: repo-name
                targetWorkflowQueueLength: 1
              authenticationRef:
                name: github-trigger-auth
          advanced:
            horizontalPodAutoscalerConfig:
              behavior:
                scaleDown:
                  stabilizationWindowSeconds: 10
                  policies:
                    - type: Pods
                      value: 100
                      periodSeconds: 10
                scaleUp:
                  stabilizationWindowSeconds: 10
                  policies:
                    - type: Pods
                      value: 2
                      periodSeconds: 10
        pollingInterval: 10

La configuration YAML utilise les paramètres généraux suivants :

• triggerAuthentications : détermine la façon dont CREMA authentifie le service externe, par exemple en utilisant un jeton stocké dans Secret Manager.

• scaledObjects : définit le mappage entre votre pool de nœuds de calcul Cloud Run et la ressource de métrique externe. Ce paramètre inclut :

  • scaleTargetRef : services Cloud Run ou pools de nœuds de calcul à mettre à l'échelle.

  • triggers : métrique externe spécifique utilisée pour le scaling. Si votre source de métriques externe nécessite une authentification, définissez le champ authenticationRef pour spécifier l'un des objets TriggerAuthentications pour les identifiants.

• pollingInterval : contrôle l'intervalle (en secondes) auquel CREMA actualise ses métriques. Si vous omettez ce paramètre, CREMA n'interroge pas automatiquement, et vous devez déclencher manuellement une vérification du scaling à l'aide d'une requête POST au service.

Pour en savoir plus sur la définition des métriques de configuration de base et avancées, consultez la référence de configuration dans la documentation GitHub Google Cloud .

Pour obtenir la liste complète des définitions de configuration de vos scaleurs compatibles, consultez Scaleurs dans la documentation KEDA.

Stocker votre configuration CREMA dans le Gestionnaire de paramètres

Pour stocker les versions des paramètres de votre service de scaling automatique CREMA, procédez comme suit :

1. Créez un paramètre dans le Gestionnaire de paramètres :

   gcloud parametermanager parameters create PARAMETER_ID --location=global  --parameter-format=YAML
   

   Remplacez PARAMETER_ID par le nom de votre paramètre.

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

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

   Remplacez les éléments suivants :

   • PARAMETER_VERSION : ID que vous souhaitez attribuer à la version du paramètre (par exemple, 1).
   • LOCAL_YAML_CONFIG_FILE : chemin d'accès à votre fichier de configuration YAML.

Pour en savoir plus, consultez Créer un paramètre.

Accorder des autorisations supplémentaires à votre compte de service CREMA

Pour mettre à l'échelle le pool de nœuds de calcul que vous avez spécifié dans votre configuration YAML, accordez les autorisations suivantes au compte de service personnalisé :

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

   Remplacez les éléments suivants :

   • PROJECT_ID : ID de votre projet Google Cloud .

   • CREMA_SERVICE_ACCOUNT_NAME : nom de votre compte de service CREMA.

2. Attribuez le rôle roles/run.developer à votre compte de service CREMA sur le pool de nœuds de calcul. Cela permet au service CREMA de modifier le nombre d'instances de votre pool de nœuds de calcul en fonction de l'évolution des métriques :

   WORKER_POOL_NAME=WORKER_POOL_NAME
   WORKER_POOL_REGION=WORKER_POOL_REGION
   gcloud beta run worker-pools add-iam-policy-binding $WORKER_POOL_NAME \
     --region=$WORKER_POOL_REGION \
     --member="serviceAccount:CREMA_SERVICE_ACCOUNT_NAME" \
     --role="roles/run.developer"
   

   Remplacez les éléments suivants :

   • WORKER_POOL_NAME : nom du pool de nœuds de calcul.
   • WORKER_POOL_REGION : région de votre pool de nœuds de calcul.

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

    gcloud projects add-iam-policy-binding PROJECT_ID \
      --member="serviceAccount:CREMA_SERVICE_ACCOUNT_NAME" \
      --role="roles/monitoring.metricWriter"
   

4. 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_SERVICE_ACCOUNT_NAME" \
     --role="roles/iam.serviceAccountUser"
   

Déployer le service pour faire évoluer 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 :

gcloud beta run deploy SERVICE_NAME\
  --image=us-central1-docker.pkg.dev/cloud-run-oss-images/crema-v1/autoscaler:1.0 \
  --region=SERVICE_REGION \
  --service-account="CREMA_SERVICE_ACCOUNT_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=projects/PROJECT_ID/locations/PARAMETER_REGION/parameters/PARAMETER_ID/versions/PARAMETER_VERSION,OUTPUT_SCALER_METRICS=True"

Remplacez les éléments suivants :

• SERVICE_NAME : nom de votre service Autoscaler.

• SERVICE_REGION : région de votre service.

• CREMA_SERVICE_ACCOUNT_NAME : nom de votre compte de service CREMA.

• PROJECT_ID : ID de votre projet Google Cloud .

• PARAMETER_REGION, PARAMETER_ID et PARAMETER_VERSION : valeurs que vous avez stockées dans le Gestionnaire de paramètres.

Vous pouvez également déployer votre service CREMA à l'aide d'une image de conteneur personnalisée que vous créez à partir du code source avec Cloud Build.

Tester votre service CREMA

Pour vérifier que votre service d'autoscaling fonctionne correctement, consultez l'onglet Journaux du service Cloud Run.

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

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

Étapes suivantes

• Découvrez comment utiliser des runners GitHub auto-hébergés sur des pools de nœuds de calcul pour exécuter les workflows définis dans votre dépôt GitHub et mettre à l'échelle votre pool de nœuds de calcul avec CREMA.

• En savoir plus sur les pools de nœuds de calcul Cloud Run