Contrôler l'utilisation des ressources avec des notifications

Ce document explique comment utiliser les notifications budgétaires pour contrôler de manière sélective l'utilisation des ressources.

Lorsque vous désactivez la facturation sur un projet, tous les services s'arrêtent et toutes les ressources sont supprimées. Si vous avez besoin d'une réponse plus nuancée, vous pouvez contrôler les ressources de manière sélective. Par exemple, vous pouvez arrêter certaines ressources Compute Engine tout en laissant les ressources Cloud Storage intactes. L'arrêt de certaines ressources seulement réduit vos coûts sans désactiver complètement votre environnement.

Dans l'exemple suivant, le projet effectue des recherches sur plusieurs machines virtuelles (VM) Compute Engine et stocke les résultats dans des buckets Cloud Storage. En utilisant les notifications de budget comme déclencheur, une fois le budget dépassé, cette fonction Cloud Run arrête toutes les instances Compute Engine, mais n'affecte pas les résultats stockés.

Avant de commencer

Avant de commencer, vous devez effectuer les tâches suivantes :

1. Activez l'API Cloud Billing.
2. Créer un budget
3. Configurer des notifications de budget automatisées

Configurer une fonction Cloud Run

1. Suivez la procédure décrite dans Créer une fonction Cloud Run. Assurez-vous de définir le type de déclencheur sur le même sujet Pub/Sub que celui que votre budget utilisera.

2. Ajoutez les dépendances suivantes :

   Node.js

   Copiez le code suivant dans votre fichier package.json :

   {
     "name": "cloud-functions-billing",
     "private": "true",
     "version": "0.0.1",
     "description": "Examples of integrating Cloud Functions with billing",
     "main": "index.js",
     "engines": {
       "node": ">=20.0.0"
     },
     "scripts": {
       "compute-test": "c8 mocha -p -j 2 test/periodic.test.js --timeout=600000",
       "test": "c8 mocha -p -j 2 test/index.test.js --timeout=5000 --exit"
     },
     "author": "Ace Nassri <[e-mail]>",
     "license": "Apache-2.0",
     "dependencies": {
       "@google-cloud/billing": "^5.0.0",
       "@google-cloud/compute": "^6.0.0",
       "@slack/web-api": "^8.0.0",
       "google-auth-library": "^9.0.0",
       "googleapis": "^143.0.0"
     },
     "devDependencies": {
       "@google-cloud/functions-framework": "^5.0.0",
       "c8": "^12.0.0",
       "gaxios": "^7.0.0",
       "mocha": "^10.0.0",
       "promise-retry": "^2.0.0",
       "proxyquire": "^2.1.0",
       "sinon": "^18.0.0",
       "wait-port": "^1.0.4"
     }
   }
   

   Python

   Copiez le code suivant dans votre fichier requirements.txt :

   slackclient==2.9.4
   google-api-python-client==2.131.0
   

3. Copiez le code suivant dans votre fonction Cloud Run :

   Node.js

   const {CloudBillingClient} = require('@google-cloud/billing');
   const {InstancesClient} = require('@google-cloud/compute');
   
   const PROJECT_ID = process.env.GOOGLE_CLOUD_PROJECT;
   const PROJECT_NAME = `projects/${PROJECT_ID}`;
   const instancesClient = new InstancesClient();
   const ZONE = 'us-central1-a';
   
   exports.limitUse = async pubsubEvent => {
     const pubsubData = JSON.parse(
       Buffer.from(pubsubEvent.data, 'base64').toString()
     );
     if (pubsubData.costAmount <= pubsubData.budgetAmount) {
       return `No action necessary. (Current cost: ${pubsubData.costAmount})`;
     }
   
     const instanceNames = await _listRunningInstances(PROJECT_ID, ZONE);
     if (!instanceNames.length) {
       return 'No running instances were found.';
     }
   
     await _stopInstances(PROJECT_ID, ZONE, instanceNames);
     return `${instanceNames.length} instance(s) stopped successfully.`;
   };
   
   /**
    * @return {Promise} Array of names of running instances
    */
   const _listRunningInstances = async (projectId, zone) => {
     const [instances] = await instancesClient.list({
       project: projectId,
       zone: zone,
     });
     return instances
       .filter(item => item.status === 'RUNNING')
       .map(item => item.name);
   };
   
   /**
    * @param {Array} instanceNames Names of instance to stop
    * @return {Promise} Response from stopping instances
    */
   const _stopInstances = async (projectId, zone, instanceNames) => {
     await Promise.all(
       instanceNames.map(instanceName => {
         return instancesClient
           .stop({
             project: projectId,
             zone: zone,
             instance: instanceName,
           })
           .then(() => {
             console.log(`Instance stopped successfully: ${instanceName}`);
           });
       })
     );
   };

   Python

   import base64
   import json
   import os
   from googleapiclient import discovery
   PROJECT_ID = os.getenv("GCP_PROJECT")
   PROJECT_NAME = f"projects/{PROJECT_ID}"
   ZONE = "us-west1-b"
   
   
   def limit_use(data, context):
       pubsub_data = base64.b64decode(data["data"]).decode("utf-8")
       pubsub_json = json.loads(pubsub_data)
       cost_amount = pubsub_json["costAmount"]
       budget_amount = pubsub_json["budgetAmount"]
       if cost_amount <= budget_amount:
           print(f"No action necessary. (Current cost: {cost_amount})")
           return
   
       compute = discovery.build(
           "compute",
           "v1",
           cache_discovery=False,
       )
       instances = compute.instances()
   
       instance_names = __list_running_instances(PROJECT_ID, ZONE, instances)
       __stop_instances(PROJECT_ID, ZONE, instance_names, instances)
   
   
   def __list_running_instances(project_id, zone, instances):
       """
       @param {string} project_id ID of project that contains instances to stop
       @param {string} zone Zone that contains instances to stop
       @return {Promise} Array of names of running instances
       """
       res = instances.list(project=project_id, zone=zone).execute()
   
       if "items" not in res:
           return []
   
       items = res["items"]
       running_names = [i["name"] for i in items if i["status"] == "RUNNING"]
       return running_names
   
   
   def __stop_instances(project_id, zone, instance_names, instances):
       """
       @param {string} project_id ID of project that contains instances to stop
       @param {string} zone Zone that contains instances to stop
       @param {Array} instance_names Names of instance to stop
       @return {Promise} Response from stopping instances
       """
       if not len(instance_names):
           print("No running instances were found.")
           return
   
       for name in instance_names:
           instances.stop(project=project_id, zone=zone, instance=name).execute()
           print(f"Instance stopped successfully: {name}")
   
   

4. Définissez le point d'entrée sur la fonction à exécuter :

   Node.js

   Définissez le champ Point d'entrée sur limitUse.

   Python

   Définissez le champ Point d'entrée sur limit_use.

5. Consultez la liste des variables d'environnement définies automatiquement et déterminez si vous devez définir manuellement la variable GCP_PROJECT sur le projet exécutant les machines virtuelles.

6. Définissez le paramètre ZONE. Ce paramètre correspond à la zone dans laquelle les instances sont arrêtées lorsque le budget est dépassé.

   Remarque : Cet exemple de code n'arrête que les instances d'une seule zone du projet spécifié. Selon vos besoins, vous pouvez modifier le code dans la fonction Cloud Run pour qu'il gère d'autres projets et zones.

7. Cliquez sur DÉPLOYER.

Configurer les autorisations du compte de service

Votre fonction Cloud Run s'exécute en tant que compte de service créé automatiquement. Pour contrôler l'utilisation, vous devez accorder au compte de service des autorisations sur tous les services du projet qu'il doit modifier en procédant comme suit :

1. Identifiez le bon compte de service en consultant les informations de votre fonction Cloud Run. Le compte de service est répertorié au bas de la page.

2. Accédez à la page IAM dans la console Google Cloud pour définir les autorisations appropriées.

   Accéder à la page IAM

Remarque : Nous vous recommandons d'accorder les autorisations minimales requises pour les services gérés par la fonction. Le rôle Administrateur d'instances Compute (v1) vous accordera les autorisations appropriées. Toutefois, pour plus de sécurité, vous pouvez créer un rôle personnalisé qui n'accorde que les autorisations nécessaires.

Vérifier que les instances sont arrêtées

Pour vous assurer que votre fonction fonctionne comme prévu, suivez les étapes de la section Tester une fonction Cloud Run.

Si l'opération réussit, vos VM Compute Engine dans la console Google Cloud sont arrêtées.

Étapes suivantes

Consultez d'autres exemples de notifications automatisées pour apprendre à effectuer les opérations suivantes :

• Écouter les notifications
• Désactiver l'utilisation de la facturation avec des notifications
• Envoyer des notifications à Slack