Desativar o uso do faturamento com notificações

Este documento explica como desativar automaticamente o faturamento em um projeto quando os custos atingem ou excedem o orçamento do projeto. Quando você desativa o faturamento em um projeto, todos os serviços do Google Cloud projeto são encerrados, incluindo os serviços do nível gratuito. Para uma resposta mais detalhada às notificações de orçamento, consulte Controlar o uso de recursos com notificações.

Talvez seja útil limitar os custos devido a um valor máximo de dinheiro que pode ser gasto no Google Cloud. Nesses casos, quando o limite de orçamento é atingido, talvez seja melhor encerrar todos os seus serviços e o uso do Google Cloud para evitar custos. Desativar o faturamento no seu projeto é um método eficiente para evitar custos nele.

Limitações

  • Há um atraso entre a geração de custos e o recebimento das notificações de orçamento. Por isso, é possível que você tenha custos extras pelo uso que não foi identificado no momento em que todos os serviços foram interrompidos. Seguir as etapas neste exemplo não garante que você não gastará além do orçamento. Se você tiver uma quantidade limitada de fundos, defina seu orçamento máximo abaixo dos fundos disponíveis para compensar atrasos no faturamento.

  • Não é possível desativar o faturamento em um projeto bloqueado para uma conta de faturamento. Para saber mais sobre como bloquear e desbloquear projetos, consulte Proteger a vinculação entre um projeto e a conta de faturamento dele.

Antes de começar

Antes de começar, conclua as seguintes tarefas:

  1. Ative a API Cloud Billing.
  2. Criar um orçamento com escopo para um único projeto
  3. Configurar notificações de orçamento programático

Configurar uma função do Cloud Run

Para desativar o Cloud Billing em um projeto, crie uma função do Cloud Run e configure-a para chamar a API Cloud Billing.

  1. Conclua as etapas em Criar uma função do Cloud Run. Verifique se o Tipo de gatilho está definido como o mesmo tópico do Pub/Sub que o orçamento vai usar.

  2. Adicione as seguintes dependências:

    Node.js

    Copie o seguinte no arquivo 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

    Copie o seguinte no arquivo requirements.txt:

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

  3. Copie o código a seguir na função do 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.")

  4. Defina o Ponto de entrada como a função correta a ser executada:

    Node.js

    Defina o Ponto de entrada como stopBilling.

    Python

    Defina o Ponto de entrada como stop_billing.

  5. Revise a lista de variáveis de ambiente definidas automaticamente para determinar se você precisa definir manualmente a variável GOOGLE_CLOUD_PROJECT para o projeto em que quer desativar o Cloud Billing.

  6. Clique em IMPLANTAR.

Configurar permissões da conta de serviço

Sua função do Cloud Run é executada como uma conta de serviço criada automaticamente. Para desativar o faturamento, conceda à conta de serviço permissões para todos os serviços do projeto que ela precisa modificar seguindo estas etapas:

  1. Identifique a conta de serviço correta visualizando os detalhes da sua função do Cloud Run. listada na parte de baixo da página.

  2. Acesse a página IAM no Google Cloud console para definir as permissões apropriadas.

    Acessar a página do IAM

  3. Para modificar as permissões da conta de faturamento, no console Google Cloud , acesse a página Gerenciamento da conta do Cloud Billing, adicione a conta de serviço como um principal na conta do Cloud Billing e defina as permissões apropriadas da conta de faturamento.

    Acesse a página "Gerenciamento da conta" no Cloud Billing

Saiba como configurar permissões para contas do Cloud Billing.

Testar se o Cloud Billing está desativado

Quando o orçamento enviar uma notificação, o projeto especificado não terá mais uma conta do Cloud Billing associada a ele. Para garantir que a função funcione como esperado, siga as etapas em Testar uma função do Cloud Run.

Se a operação for bem-sucedida, o projeto não vai mais aparecer na conta do Cloud Billing e os recursos dele serão desativados, incluindo a função do Cloud Run, se ela estiver no mesmo projeto.

Para continuar usando os recursos do Google Cloud no projeto, no console doGoogle Cloud , reative manualmente o Cloud Billing para seu projeto.

A seguir

Confira outros exemplos de notificações programáticas para saber como fazer o seguinte: