Exemplos de respostas automatizadas de controle de custos

Exemplo de arquitetura de referência

Figura 1: ilustra um exemplo de uso de alertas de orçamento para automatizar respostas de controle de custos usando o Pub/Sub para notificações programáticas e as funções do Cloud Run para automatizar uma resposta.

Se você quer economizar e precisa controlar seu ambiente de acordo com o orçamento, use as notificações programáticas de orçamento para automatizar a resposta de controle de custos com base na notificação de orçamento.

As notificações de orçamento usam tópicos do Pub/Sub para fornecer um status em tempo real do orçamento do Cloud Billing, usando a escalonabilidade, a flexibilidade e a confiabilidade do middleware empresarial orientado a mensagens para a nuvem.

Nesta página, você verá exemplos e instruções detalhadas sobre como usar as notificações de orçamento com as funções do Cloud Run para automatizar o gerenciamento de custos.

Observação: as notificações de orçamento são enviadas ao tópico do Pub/Sub várias vezes por dia com o status atual do orçamento e dos limites mínimos. As notificações continuarão a ser enviadas mesmo depois que todos os limites forem excedidos.

Configurar notificações de orçamento

A primeira etapa é ativar um tópico do Pub/Sub para seu orçamento. Isso é descrito em detalhes em Gerenciar notificações com alertas de orçamento programático.

Depois de ativar as notificações de orçamento, observe o seguinte:

• Tópico do Pub/Sub: é o endpoint de notificações configurado para o orçamento.
• ID do orçamento: é um ID exclusivo do orçamento, incluso em todas as notificações. Para localizar esse ID, acesse Gerenciar notificações no orçamento e selecione Conectar um tópico do Pub/Sub a este orçamento.

Detectar suas notificações

O próximo passo é assinar seu tópico do Pub/Sub para detectar as notificações. Se você não tiver um tópico assinado, o Pub/Sub descartará as mensagens publicadas e não será possível recuperá-las depois.

Há muitas maneiras de assinar o tópico, mas usaremos os gatilhos da função do Cloud Run nestes exemplos.

Criar uma função do Cloud Run

Para criar uma nova função do Cloud Run:

1. No console do Google Cloud, acesse a página das funções do Cloud Run.

   Acessar a página de funções do Cloud Run

2. Clique em CRIAR FUNÇÃO e atribua a ela um nome que seja significativo para seu orçamento.

3. Em Gatilho, selecione Tópico do Pub/Sub.

4. Selecione o tópico que você configurou no seu orçamento.

5. Forneça o código-fonte e as dependências que a função executará.

6. Defina a Função a ser executada com o nome correto da função.

Descrever sua função do Cloud Run

Para informar à função do Cloud Run o que você quer fazer com a notificação, escreva o código usando a edição in-line ou faça upload de um arquivo. Para detalhes sobre as notificações que seu código receberá, consulte Formato de notificação.

Por exemplo, uma função pode registrar notificações, atributos e dados do Pub/Sub recebidos quando for acionada por uma notificação de orçamento. Para saber mais, consulte Gatilhos do Pub/Sub.

Conferir os eventos da função do Cloud Run

Depois de salvar a função do Cloud Run, clique em VER REGISTROS para visualizar as notificações de orçamento registradas. Isso mostra os registros das suas invocações de função.

Testar a função do Cloud Run

As notificações são enviadas ao Pub/Sub e os assinantes recebem as mensagens. Para testar uma notificação de amostra e verificar se sua função está operando como esperado, publique uma mensagem no Pub/Sub usando este objeto como o corpo da mensagem:

{
    "budgetDisplayName": "name-of-budget",
    "alertThresholdExceeded": 1.0,
    "costAmount": 100.01,
    "costIntervalStart": "2019-01-01T00:00:00Z",
    "budgetAmount": 100.00,
    "budgetAmountType": "SPECIFIED_AMOUNT",
    "currencyCode": "USD"
}

Você também pode adicionar atributos de mensagem, como o ID da conta de faturamento. Consulte a documentação completa do formato de notificação para ver mais informações.

Enviar notificações para o Slack

O e-mail nem sempre é a melhor maneira de se manter atualizado sobre seus custos na nuvem, principalmente se o orçamento for crítico e sensível ao tempo. Com as notificações, você pode encaminhar suas mensagens de orçamento para outras mídias.

Neste exemplo, descrevemos como encaminhar notificações de orçamento para o Slack. Dessa maneira, toda vez que o Faturamento do Cloud publicar uma notificação de orçamento, uma função do Cloud Run usará um bot para postar uma mensagem em um canal do Slack no espaço de trabalho desse bot.

Configurar um canal e permissões do Slack

A primeira etapa é criar seu espaço de trabalho no Slack e os tokens de usuário do bot que são usados para chamar a API Slack. É possível gerenciar os tokens da API em https://api.slack.com/apps. Para instruções detalhadas, consulte Usuários de bot no site do Slack.

Gravar uma função do Cloud Run

1. Para criar uma nova função, siga as etapas em Criar uma função do Cloud Run. Verifique se o gatilho está definido como o mesmo tópico do Pub/Sub que o orçamento está configurado para usar.

2. Adicionar dependências:

   Node.js

   Copie o seguinte para o 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 <[e-mail]>",
     "license": "Apache-2.0",
     "dependencies": {
       "@google-cloud/billing": "^4.0.0",
       "@google-cloud/compute": "^4.0.0",
       "google-auth-library": "^9.0.0",
       "googleapis": "^140.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 para o requirements.txt:

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

3. Escreva o código ou use o exemplo abaixo para postar notificações de orçamento em um canal de chat do Slack usando a API Slack.

4. Verifique se os seguintes parâmetros postMessage da API Slack estão configurados corretamente:

   • Token de acesso do OAuth do usuário de bot
   • Nome do canal

Exemplo de código:

Node.js

const slack = require('slack');

// TODO(developer) replace these with your own values
const BOT_ACCESS_TOKEN =
  process.env.BOT_ACCESS_TOKEN || 'xxxx-111111111111-abcdefghidklmnopq';
const CHANNEL = process.env.SLACK_CHANNEL || 'general';

exports.notifySlack = async pubsubEvent => {
  const pubsubAttrs = pubsubEvent.attributes;
  const pubsubData = Buffer.from(pubsubEvent.data, 'base64').toString();
  const budgetNotificationText = `${JSON.stringify(
    pubsubAttrs
  )}, ${pubsubData}`;

  await slack.chat.postMessage({
    token: BOT_ACCESS_TOKEN,
    channel: CHANNEL,
    text: budgetNotificationText,
  });

  return 'Slack notification sent successfully';
};

Python

import base64
import json
import os

import slack
from slack.errors import SlackApiError

# See https://api.slack.com/docs/token-types#bot for more info
BOT_ACCESS_TOKEN = "xxxx-111111111111-abcdefghidklmnopq"
CHANNEL = "C0XXXXXX"

slack_client = slack.WebClient(token=BOT_ACCESS_TOKEN)


def notify_slack(data, context):
    pubsub_message = data

    # For more information, see
    # https://cloud.google.com/billing/docs/how-to/budgets-programmatic-notifications#notification_format
    try:
        notification_attr = json.dumps(pubsub_message["attributes"])
    except KeyError:
        notification_attr = "No attributes passed in"

    try:
        notification_data = base64.b64decode(data["data"]).decode("utf-8")
    except KeyError:
        notification_data = "No data passed in"

    # This is just a quick dump of the budget data (or an empty string)
    # You can modify and format the message to meet your needs
    budget_notification_text = f"{notification_attr}, {notification_data}"

    try:
        slack_client.api_call(
            "chat.postMessage",
            json={"channel": CHANNEL, "text": budget_notification_text},
        )
    except SlackApiError:
        print("Error posting to Slack")

Agora você pode testar a função do Cloud Run para ver uma mensagem exibida no Slack.

Limitar (desativar) o faturamento para interromper o uso

Veja neste exemplo como limitar custos e interromper o uso de um projeto desativando o Cloud Billing. Desativar o faturamento em um projeto fará com que todos os serviços do Google Cloud no projeto sejam encerrados, incluindo os serviços de nível gratuito.

Aviso: este exemplo removemos o Faturamento do Cloud do projeto, encerrando todos os recursos. Talvez os recursos sejam encerrados com erro, o que impossibilita a recuperação deles. Não haverá recuperação se você desativar o Faturamento do Cloud.
É possível reativar o Faturamento do Cloud, mas não há garantia de recuperação de serviço e a configuração manual é obrigatória.

Por que desativar o faturamento?

Talvez seja útil limitar os custos caso haja um limite absoluto do dinheiro que se pode gastar no Google Cloud. Isso é comum para estudantes, pesquisadores ou desenvolvedores que trabalham em ambientes de sandbox. Nesses casos, convém interromper os gastos e encerrar todos os seus serviços e o uso do Google Cloud quando seu limite de orçamento é atingido.

Observação: há um atraso entre a geração de custos e o recebimento das notificações de orçamento. Como os produtos do Google Cloud informam dados de uso e custo aos processos do Cloud Billing em intervalos variados, é possível que haja custos extras pelo uso que não chegou no momento em que todos os serviços foram interrompidos.
Seguir as etapas neste exemplo de limitação não garante que você não gastará além do orçamento.
Recomendação: se você tiver um limite de fundos fixos, defina seu orçamento máximo abaixo dos fundos disponíveis para compensar atrasos no faturamento.

No nosso exemplo, usamos acme-backend-dev como projeto de não produção em que é seguro desativar o Faturamento do Cloud.

Antes de começar a trabalhar com este exemplo, verifique se você fez o seguinte:

• Ative a API Cloud Billing. A função do Cloud Run precisa chamar a API Cloud Billing para desativar o Cloud Billing em um projeto.

• Configurar um orçamento para monitorar os custos do projeto e ativar as notificações de orçamento.

Gravar uma função do Cloud Run

Em seguida, você precisará configurar a função do Cloud Run para chamar a API Cloud Billing. Isso permite que a função do Cloud Run desative o Cloud Billing para nosso projeto de exemplo acme-backend-dev.

1. Para criar uma nova função, siga as etapas em Criar uma função do Cloud Run. Verifique se o gatilho está definido como o mesmo tópico do Pub/Sub que o orçamento está configurado para usar.

2. Adicione as seguintes dependências:

   Node.js

   Copie o seguinte para o 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 <[e-mail]>",
     "license": "Apache-2.0",
     "dependencies": {
       "@google-cloud/billing": "^4.0.0",
       "@google-cloud/compute": "^4.0.0",
       "google-auth-library": "^9.0.0",
       "googleapis": "^140.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 para o requirements.txt:

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

3. Copie o código abaixo na função do Cloud Run.

4. Defina a função a ser executada para "stopBilling" (Node) ou "stop_billing" (Python).

5. Dependendo do ambiente de execução, a variável de ambiente GOOGLE_CLOUD_PROJECT pode ser definida automaticamente. Revise a lista de variáveis de ambiente definidas automaticamente e determine se você precisa definir manualmente a variável GOOGLE_CLOUD_PROJECT para o projeto para o qual quer limitar (desativar) o Cloud Billing.

Observação: se a variável de ambiente for definida automaticamente, a conta do Cloud Billing será removida do projeto em que a função do Cloud Run estiver em execução. É possível alterar o código dentro da função do Cloud Run para especificar um projeto diferente, dependendo das suas necessidades.

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

import base64
import json
import os

from googleapiclient import discovery

PROJECT_ID = os.getenv("GCP_PROJECT")
PROJECT_NAME = f"projects/{PROJECT_ID}"
def stop_billing(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

    if PROJECT_ID is None:
        print("No project specified with environment variable")
        return

    billing = discovery.build(
        "cloudbilling",
        "v1",
        cache_discovery=False,
    )

    projects = billing.projects()

    billing_enabled = __is_billing_enabled(PROJECT_NAME, projects)

    if billing_enabled:
        __disable_billing_for_project(PROJECT_NAME, projects)
    else:
        print("Billing already disabled")


def __is_billing_enabled(project_name, projects):
    """
    Determine whether billing is enabled for a project
    @param {string} project_name Name of project to check if billing is enabled
    @return {bool} Whether project has billing enabled or not
    """
    try:
        res = projects.getBillingInfo(name=project_name).execute()
        return res["billingEnabled"]
    except KeyError:
        # If billingEnabled isn't part of the return, billing is not enabled
        return False
    except Exception:
        print(
            "Unable to determine if billing is enabled on specified project, assuming billing is enabled"
        )
        return True


def __disable_billing_for_project(project_name, projects):
    """
    Disable billing for a project by removing its billing account
    @param {string} project_name Name of project disable billing on
    """
    body = {"billingAccountName": ""}  # Disable billing
    try:
        res = projects.updateBillingInfo(name=project_name, body=body).execute()
        print(f"Billing disabled: {json.dumps(res)}")
    except Exception:
        print("Failed to disable billing, possibly check permissions")

Configurar permissões da conta de serviço

Sua função do Cloud Run é executada como uma conta de serviço criada automaticamente. Para que essa conta de serviço possas desativar o faturamento, será preciso conceder a ela as permissões corretas, como Administrador de faturamento.

Observação: em vez de conceder permissões completas de administrador de faturamento à conta de serviço, convém criar um papel personalizado que concede menos permissões. Para entender as permissões necessárias, revise as permissões necessárias para desativar o faturamento de um projeto.

Para identificar a conta de serviço correta, visualize os detalhes da sua função do Cloud Run listada na parte inferior da página.

Gerencie permissões de administrador de faturamento na página "Faturamento" no Console do Google Cloud.

Para conceder privilégios de administrador da conta de faturamento à de serviço, selecione o nome dessa conta.

Validar se o Faturamento do Cloud está desativado

Quando o orçamento enviar uma notificação, o projeto especificado terá mais uma Conta de faturamento do Cloud. Se você quiser testar a função, publique uma mensagem de exemplo com a mensagem de teste acima. O projeto não estará mais visível na conta do Cloud Billing e os recursos no projeto serão desativados, incluindo a função do Cloud Run, se ela estiver no mesmo projeto.

É possível reativar manualmente o Cloud Billing para seu projeto no Console do Google Cloud.

Controlar o uso de forma seletiva

Limitar (desativar) o Faturamento do Cloud conforme descrito no exemplo anterior é um processo binário e definitivo. Isso significa que seu projeto ou está ativado, ou está desativado. Quando desativado, todos os serviços são interrompidos e todos os recursos são excluídos.

Se você precisar de uma resposta com mais detalhes, controle seletivamente os recursos. Por exemplo, caso queira interromper alguns recursos do Compute Engine, mas deixar o Cloud Storage intacto, você tem como controlar seletivamente o uso. Isso reduz seu custo por hora sem desativar completamente seu ambiente.

É possível escrever uma política com o detalhamento que você quiser. No entanto, para nosso exemplo, nosso projeto está realizando pesquisas com várias máquinas virtuais do Compute Engine e está armazenando resultados no Cloud Storage. Neste exemplo de função do Cloud Run, todas as instâncias do Compute Engine serão encerradas, mas isso não afetará nossos resultados armazenados depois que o orçamento for excedido.

Gravar uma função do Cloud Run

1. Para criar uma nova função, siga as etapas em Criar uma função do Cloud Run. Verifique se o gatilho está definido como o mesmo tópico do Pub/Sub que o orçamento está configurado para usar.

2. Certifique-se de ter adicionado as dependências descritas em Limitar (desativar) o faturamento para interromper o uso.

3. Copie o código abaixo na função do Cloud Run.

4. Defina a função para ser executada como "limitUse" (Node.js) ou "limit_use" (Python).

5. Dependendo do ambiente de execução, a variável de ambiente GCP_PROJECT pode ser definida automaticamente. Revise a lista de variáveis de ambiente definidas automaticamente e determine se você precisa definir manualmente a variável GCP_PROJECT para o projeto que executa as máquinas virtuais.

6. Defina o parâmetro ZONE. Trata-se da zona em que as instâncias serão interrompidas para este exemplo.

Observação: este código de exemplo só interrompe instâncias em uma única zona. Dependendo de suas necessidades, é possível alterar o código dentro da função do Cloud Run para lidar com outros projetos e zonas.

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}")

Configurar permissões da conta de serviço

1. Sua função do Cloud Run é executada como uma conta de serviço criada automaticamente. Para controlar o uso, você precisa conceder à conta de serviço permissões aos serviços do projeto em que ela fará alterações.
   Observação: a prática recomendada de segurança é conceder o menor privilégio específico aos serviços que serão gerenciados. O papel Administrador da instância do Compute (v1) funcionará nesta situação. No entanto, para maior segurança, convém configurar e usar um papel personalizado que conceda menos permissões do que um papel de administrador.
2. Para identificar a conta de serviço correta, visualize os detalhes da sua função do Cloud Run, listada na parte inferior da página.
3. No Console do Google Cloud, acesse a página IAM para definir as permissões apropriadas.
   Acessar a página "IAM"
    
   

Confirmar que as instâncias foram interrompidas

Quando o orçamento envia uma notificação, as máquinas virtuais do Compute Engine são interrompidas.

Para testar a função, publique uma mensagem de exemplo com a mensagem de teste acima. Para confirmar que a função foi executada com êxito, verifique as máquinas virtuais do Compute Engine no Console do Google Cloud.