Exemplos de notificação programática de orçamentos

Se você quer economizar e precisa controlar seu ambiente de acordo com o orçamento, use as notificações programáticas para automatizar as ações relacionadas a questões orçamentárias.

As notificações de orçamento usam notificações do Cloud Pub/Sub para fornecer o estado do orçamento em tempo real usando a escalonabilidade, a flexibilidade e a confiabilidade do middleware empresarial orientado a mensagens.

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

Configurar notificações de orçamento

O primeiro passo é ativar uma notificação do Cloud Pub/Sub para seu orçamento. Esta etapa é descrita em Gerenciar notificações.

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

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

Gerenciar notificações de faturamento no console do GCP

Detectar suas notificações

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

Há muitas maneiras de inscrever o tópico, mas usaremos nestes exemplos os acionadores do Cloud Functions.

Criar uma função do Google Cloud

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

  1. Acesse a página Cloud Functions no console do Google Cloud Platform. Crie uma nova função e atribua a ela um nome que seja significativo para o orçamento.
  2. Em Acionador, selecione Tópico do Cloud Pub/Sub.
  3. Selecione o tópico que você configurou no seu orçamento.
  4. Forneça o código-fonte e as dependências que a função executará.

Criar uma nova função no console do GCP

Descrever sua função do Google Cloud

Para informar à função do Google Cloud o que você quer fazer com a notificação, escreva o código usando o editor in-line ou faça upload de um arquivo. Para mais 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 Acionadores do Google Cloud Pub/Sub.

Visualizar seus eventos do Cloud Functions

Depois de salvar a função do Google Cloud, você pode clicar em VER REGISTROS para visualizar as notificações de orçamento registradas. Isso mostra os registros das suas chamadas de função.

Visualizar eventos do Cloud Functions no Console do GCP

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 as notificações de orçamento para o Slack. Dessa maneira, toda vez que o Cloud Billing publicar uma notificação de orçamento, uma função do Google Cloud 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 ver instruções detalhadas, consulte Usuários de bot no site do Slack.

Configurar notificações do Slack

Criar uma função do Google Cloud

  1. Para criar uma nova função, siga as etapas em Criar uma função do Cloud Functions.

  2. Adicionar dependências:

    Python

    Adicione slackclient==1.3.0 ao arquivo requirements.txt da sua função:
    slackclient==1.3.0

  3. Escreva o código para postar notificações de orçamento em um canal de bate-papo do Slack usando a API Slack.

  4. Defina os seguintes parâmetros postMessage da API Slack no código:

    • token de acesso do OAuth do usuário de bot
    • canal
    • texto

Exemplo:

Python

from slackclient import SlackClient

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

CHANNEL_ID = 'C0XXXXXX'

slack_client = SlackClient(BOT_ACCESS_TOKEN)

def notify_slack(data, context):
    pubsub_message = data

    notification_attrs = json.dumps(pubsub_message['attributes'])
    notification_data = base64.b64decode(data['data']).decode('utf-8')
    budget_notification_text = f'{notification_attrs}, {notification_data}'

    slack_client.api_call(
      'chat.postMessage',
      channel=CHANNEL_ID,
      text=budget_notification_text)

Limitar (desativar) o faturamento para interromper o uso

Veja, neste exemplo, como limitar os custos e interromper o uso de um projeto do Google Cloud desativando o faturamento. Isso fará com que todos os serviços do Google Cloud encerrem os recursos da camada não gratuita do projeto.

Você pode limitar os custos porque tem um limite rígido de quanto pode gastar no Google Cloud Platform. Isso é comum para estudantes, pesquisadores ou desenvolvedores que trabalham em ambientes de sandbox. Nesses casos, é possível interromper os gastos e encerrar todos os serviços e o uso do Google Cloud Platform quando o limite de orçamento for atingido.

No nosso exemplo, usamos acme-backend-dev como um projeto de não produção para o qual é possível desativar o faturamento com segurança.

Configurar o limite de orçamento no console do GCP

Antes de começar, é preciso configurar um orçamento para monitorar os custos do projeto e ativar as notificações de orçamento.

Gerenciar alertas de faturamento no console do GCP

Configurar permissões da conta de serviço

Sua função do Google Cloud é executada como uma conta de serviço criada automaticamente. Para que essa conta desative o faturamento, é preciso conceder a ela as permissões de administrador de faturamento.

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

Identificar a conta de serviço no console do GCP

É possível gerenciar as permissões de administrador de faturamento na página Faturamento do Console do Google Cloud Platform.

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

Gerenciar permissões no console do GCP

Gravar uma função do Google Cloud

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

  1. Para criar uma nova função, siga as etapas em Criar uma função do Cloud Functions.

  2. Adicione as seguintes dependências:

    Python

    Adicione oauth2client==4.1.3 e google-api-python-client==1.7.4 ao arquivo requirements.txt da sua função:
    oauth2client==4.1.3
    google-api-python-client==1.7.4
    

  3. Escreva o código para desativar o faturamento no projeto removendo-o da conta de faturamento.

  4. Defina o parâmetro PROJECT_NAME. Este é o projeto com o faturamento que você quer limitar (desativar).

Python

import base64
import json
import os
from googleapiclient import discovery
from oauth2client.client import GoogleCredentials

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

    billing = discovery.build(
        'cloudbilling',
        'v1',
        cache_discovery=False,
        credentials=GoogleCredentials.get_application_default()
    )

    projects = billing.projects()

    if __is_billing_enabled(PROJECT_NAME, projects):
        print(__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
    """
    res = projects.getBillingInfo(name=project_name).execute()
    return res['billingEnabled']

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
    @return {string} Text containing response from disabling billing
    """
    body = {'billingAccountName': ''}  # Disable billing
    res = projects.updateBillingInfo(name=project_name, body=body).execute()
    print(f'Billing disabled: {json.dumps(res)}')

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,
        credentials=GoogleCredentials.get_application_default()
    )
    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()

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

Verificar se o faturamento está desativado

Quando a função é acionada, você pode verificar se ela foi bem-sucedida. O projeto não estará mais visível na conta de faturamento e os recursos dele serão desativados.

Verificar se o faturamento está desativado

É possível reativar manualmente o faturamento do seu projeto no console do GCP.

Controlar o uso de forma seletiva

O limite (desativação do faturamento), conforme descrito no exemplo anterior, é binário e terminal. Isso significa que ou seu projeto está ativado ou 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, poderá controlar seletivamente os recursos. Por exemplo, se quiser interromper alguns recursos do Compute, mas não os do Storage, controle seletivamente o uso. Isso reduzirá seu custo por hora sem desativar completamente o ambiente.

Você pode escrever uma política com o detalhamento que quiser. No entanto, para esse exemplo, nosso projeto executa uma pesquisa com várias máquinas virtuais do Compute e armazena os resultados no Cloud Storage. Assim, todas as instâncias do Compute serão encerradas, mas os resultados armazenados depois que o orçamento for excedido não serão afetados.

Configurar permissões da conta de serviço

  1. Sua função do Google Cloud é 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.
  2. Para identificar a conta de serviço correta, veja os detalhes da sua função do Google Cloud Ela estará listada na parte inferior da página.
  3. Acesse a página de IAM do console do GCP para definir as permissões apropriadas.
     
    Gerenciar alertas de faturamento no console do GCP

Gravar uma função do Google Cloud

  1. Para criar uma nova função, siga as etapas em Criar uma função do Cloud Functions.

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

  3. Escreva o código para encerrar os recursos no projeto.

  4. Defina o parâmetro PROJECT_NAME. Este é o projeto que você quer configurar para o limite.

Python

import base64
import json
from googleapiclient import discovery
from oauth2client.client import GoogleCredentials

PROJECT_ID = os.getenv('GCP_PROJECT')
PROJECT_NAME = f'projects/{PROJECT_ID}'

Verificar se o faturamento está desativado

Para verificar se a função foi executada com sucesso, confirme se as máquinas virtuais do Compute foram interrompidas no Console do GCP.

Esta página foi útil? Conte sua opinião sobre: