Cette page a été traduite par l'API Cloud Translation.

Désactiver l'utilisation de la facturation avec les notifications

Ce document explique comment désactiver automatiquement la facturation d'un projet lorsque vos coûts atteignent ou dépassent le budget du projet. Lorsque vous désactivez la facturation d'un projet, vous résiliez tous les services Google Cloud du projet, y compris les services du niveau Gratuit. Pour obtenir une réponse plus nuancée aux notifications de budget, consultez Contrôler l'utilisation des ressources avec les notifications.

Vous pouvez vouloir limiter les coûts si vous avez un montant maximal que vous pouvez dépenser sur Google Cloud. Dans de telles circonstances, il est important de bloquer les dépenses, voire d'arrêter tous les services Google Cloud et leur utilisation dès lors que le seuil budgétaire est atteint. Désactiver la facturation sur votre projet est un moyen efficace d'arrêter d'engendrer des coûts dans ce projet.

Limites

Il existe un délai entre le moment où les coûts sont engagés et celui où les notifications de budget sont reçues. Par conséquent, des coûts supplémentaires peuvent vous être facturés pour une utilisation n'ayant pas encore été faite au moment où tous les services sont arrêtés. Le fait de suivre les étapes présentées dans cet exemple n'est en aucun cas une garantie que les dépenses ne dépasseront pas le seuil budgétaire. Si vos fonds sont limités, définissez votre budget maximal en dessous de vos fonds disponibles afin de tenir compte des délais de facturation.
Vous ne pouvez pas désactiver la facturation pour un projet associé à un compte de facturation verrouillé. Pour en savoir plus sur le verrouillage et le déverrouillage des projets, consultez Sécuriser l'association entre un projet et son compte de facturation.

Avant de commencer

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

Activer l'API Cloud Billing
Créer un budget limité à un seul projet
Configurer des notifications de budget automatisées

Configurer une fonction Cloud Run

Pour désactiver Cloud Billing pour un projet, créez une fonction Cloud Run et configurez-la pour qu'elle appelle l'API Cloud Billing.

Suivez les étapes décrites dans Créer une fonction Cloud Run. Assurez-vous que le type de déclencheur est défini sur le même sujet Pub/Sub que celui que votre budget utilisera.

Ajoutez les dépendances suivantes :

Node.js

Copiez ce qui suit 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": ">=16.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 <anassri@google.com>",
  "license": "Apache-2.0",
  "dependencies": {
    "@google-cloud/billing": "^4.0.0",
    "@google-cloud/compute": "^4.0.0",
    "google-auth-library": "^9.0.0",
    "googleapis": "^143.0.0",
    "slack": "^11.0.1"
  },
  "devDependencies": {
    "@google-cloud/functions-framework": "^3.0.0",
    "c8": "^10.0.0",
    "gaxios": "^6.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 ce qui suit dans votre fichier requirements.txt :

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

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 billing = new CloudBillingClient();

exports.stopBilling = 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})`;
  }

  if (!PROJECT_ID) {
    return 'No project specified';
  }

  const billingEnabled = await _isBillingEnabled(PROJECT_NAME);
  if (billingEnabled) {
    return _disableBillingForProject(PROJECT_NAME);
  } else {
    return 'Billing already disabled';
  }
};

/**
 * Determine whether billing is enabled for a project
 * @param {string} projectName Name of project to check if billing is enabled
 * @return {bool} Whether project has billing enabled or not
 */
const _isBillingEnabled = async projectName => {
  try {
    const [res] = await billing.getProjectBillingInfo({name: projectName});
    return res.billingEnabled;
  } catch (e) {
    console.log(
      'Unable to determine if billing is enabled on specified project, assuming billing is enabled'
    );
    return true;
  }
};

/**
 * Disable billing for a project by removing its billing account
 * @param {string} projectName Name of project disable billing on
 * @return {string} Text containing response from disabling billing
 */
const _disableBillingForProject = async projectName => {
  const [res] = await billing.updateProjectBillingInfo({
    name: projectName,
    resource: {billingAccountName: ''}, // Disable billing
  });
  return `Billing disabled: ${JSON.stringify(res)}`;
};

Python

# WARNING: The following action, if not in simulation mode, will disable billing
# for the project, potentially stopping all services and causing outages.
# Ensure thorough testing and understanding before enabling live deactivation.

import base64
import json
import os
import urllib.request

from cloudevents.http.event import CloudEvent
import functions_framework

from google.api_core import exceptions
from google.cloud import billing_v1
from google.cloud import logging

billing_client = billing_v1.CloudBillingClient()


def get_project_id() -> str:
    """Retrieves the Google Cloud Project ID.

    This function first attempts to get the project ID from the
    `GOOGLE_CLOUD_PROJECT` environment variable. If the environment
    variable is not set or is None, it then attempts to retrieve the
    project ID from the Google Cloud metadata server.

    Returns:
        str: The Google Cloud Project ID.

    Raises:
        ValueError: If the project ID cannot be determined either from
                    the environment variable or the metadata server.
    """

    # Read the environment variable, usually set manually
    project_id = os.getenv("GOOGLE_CLOUD_PROJECT")
    if project_id is not None:
        return project_id

    # Otherwise, get the `project-id`` from the Metadata server
    url = "http://metadata.google.internal/computeMetadata/v1/project/project-id"
    req = urllib.request.Request(url)
    req.add_header("Metadata-Flavor", "Google")
    project_id = urllib.request.urlopen(req).read().decode()

    if project_id is None:
        raise ValueError("project-id metadata not found.")

    return project_id


@functions_framework.cloud_event
def stop_billing(cloud_event: CloudEvent) -> None:
    # TODO(developer): As stoping billing is a destructive action
    # for your project, change the following constant to False
    # after you validate with a test budget.
    SIMULATE_DEACTIVATION = True

    PROJECT_ID = get_project_id()
    PROJECT_NAME = f"projects/{PROJECT_ID}"

    event_data = base64.b64decode(
        cloud_event.data["message"]["data"]
    ).decode("utf-8")

    event_dict = json.loads(event_data)
    cost_amount = event_dict["costAmount"]
    budget_amount = event_dict["budgetAmount"]
    print(f"Cost: {cost_amount} Budget: {budget_amount}")

    if cost_amount <= budget_amount:
        print("No action required. Current cost is within budget.")
        return

    print(f"Disabling billing for project '{PROJECT_NAME}'...")

    is_billing_enabled = _is_billing_enabled(PROJECT_NAME)

    if is_billing_enabled:
        _disable_billing_for_project(
            PROJECT_NAME,
            SIMULATE_DEACTIVATION
        )
    else:
        print("Billing is already disabled.")


def _is_billing_enabled(project_name: str) -> bool:
    """Determine whether billing is enabled for a project.

    Args:
        project_name: Name of project to check if billing is enabled.

    Returns:
        Whether project has billing enabled or not.
    """
    try:
        print(f"Getting billing info for project '{project_name}'...")
        response = billing_client.get_project_billing_info(name=project_name)

        return response.billing_enabled
    except Exception as e:
        print(f'Error getting billing info: {e}')
        print(
            "Unable to determine if billing is enabled on specified project, "
            "assuming billing is enabled."
        )

        return True


def _disable_billing_for_project(
    project_name: str,
    simulate_deactivation: bool,
) -> None:
    """Disable billing for a project by removing its billing account.

    Args:
        project_name: Name of project to disable billing.
        simulate_deactivation:
            If True, it won't actually disable billing.
            Useful to validate with test budgets.
    """

    # Log this operation in Cloud Logging
    logging_client = logging.Client()
    logger = logging_client.logger(name="disable-billing")

    if simulate_deactivation:
        entry_text = "Billing disabled. (Simulated)"
        print(entry_text)
        logger.log_text(entry_text, severity="CRITICAL")
        return

    # Find more information about `updateBillingInfo` API method here:
    # https://cloud.google.com/billing/docs/reference/rest/v1/projects/updateBillingInfo
    try:
        # To disable billing set the `billing_account_name` field to empty
        project_billing_info = billing_v1.ProjectBillingInfo(
            billing_account_name=""
        )

        response = billing_client.update_project_billing_info(
            name=project_name,
            project_billing_info=project_billing_info
        )

        entry_text = f"Billing disabled: {response}"
        print(entry_text)
        logger.log_text(entry_text, severity="CRITICAL")
    except exceptions.PermissionDenied:
        print("Failed to disable billing, check permissions.")

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

Node.js
Définissez le champ Point d'entrée sur stopBilling.

Python
Définissez le champ Point d'entrée sur stop_billing.
Consultez la liste des variables d'environnement définies automatiquement pour déterminer si vous devez définir manuellement la variable GOOGLE_CLOUD_PROJECT sur le projet pour lequel vous souhaitez désactiver Cloud Billing.

Remarque : Si la variable d'environnement est définie automatiquement, le compte Cloud Billing est supprimé du projet dans lequel cette fonction Cloud Run s'exécute. Selon vos besoins, vous pouvez modifier le code dans la fonction Cloud Run pour spécifier un autre projet.
Cliquez sur DÉPLOYER.

Configurer les autorisations du compte de service

Votre fonction Cloud Run s'exécute en tant que compte de service automatiquement créé. Pour désactiver la facturation, vous devez accorder au compte de service des autorisations sur tous les services du projet qu'il doit modifier. Pour ce faire, procédez comme suit :

Pour identifier le bon compte de service, consultez les informations de la fonction Cloud Run. Le compte de service est répertorié au bas de la page.
Accédez à la page IAM de la console Google Cloud pour définir les autorisations appropriées.

Accéder à la page IAM
Pour modifier les autorisations du compte de facturation, dans la console Google Cloud , accédez à la page Gestion des comptes de la facturation, ajoutez le compte de service en tant que principal sur le compte de facturation Cloud et définissez les autorisations appropriées pour le compte de facturation.

Accéder à la page "Gestion des comptes" dans Cloud Billing

Découvrez comment configurer les autorisations pour les comptes de facturation Cloud.

Tester la désactivation de Cloud Billing

Lorsque le budget envoie une notification, le projet spécifié n'a plus de compte de facturation Cloud associé. Pour vous assurer que votre fonction fonctionne comme prévu, suivez les étapes décrites dans Tester une fonction Cloud Run.

Si l'opération réussit, le projet n'est plus visible sous le compte Cloud Billing et les ressources du projet sont désactivées, y compris la fonction Cloud Run si elle se trouve dans ce projet.

Pour continuer à utiliser les ressources Google Cloud dans le projet, dans la consoleGoogle Cloud , réactivez manuellement Cloud Billing pour votre projet.

Étapes suivantes

Réactiver Cloud Billing pour votre projet

Consultez d'autres exemples de notifications programmatiques pour découvrir comment effectuer les opérations suivantes :

Désactiver l'utilisation de la facturation avec les notifications Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Limites

Avant de commencer

Configurer une fonction Cloud Run

Node.js

Python

Node.js

Python

Node.js

Python

Configurer les autorisations du compte de service

Tester la désactivation de Cloud Billing

Étapes suivantes

Désactiver l'utilisation de la facturation avec les notifications