Esempi di risposte automatiche sul controllo dei costi

Esempio di architettura di riferimento

Figura 1: illustra un esempio di utilizzo degli avvisi relativi al budget per automatizzare le risposte al controllo dei costi mediante Pub/Sub per le notifiche programmatiche e Cloud Functions per automatizzare una risposta.

Se sei attento ai costi e devi controllare il tuo ambiente in relazione al tuo budget, puoi utilizzare le notifiche del budget programmatiche per automatizzare la risposta al controllo dei costi in base alla notifica del budget.

Le notifiche di budget utilizzano gli argomenti Pub/Sub per fornire uno stato in tempo reale del budget di fatturazione Cloud, sfruttando la scalabilità, la flessibilità e l'affidabilità del middleware aziendale orientato ai messaggi per il cloud.

Questa pagina contiene esempi e istruzioni dettagliate su come utilizzare le notifiche di budget con Cloud Functions per automatizzare la gestione dei costi.

Nota: le notifiche relative al budget vengono inviate all'argomento Pub/Sub più volte al giorno con lo stato attuale del budget e delle soglie. Le notifiche continueranno a essere inviate anche dopo il superamento di tutte le soglie.

Configurare le notifiche relative al budget

Il primo passaggio consiste nell'abilitare un argomento Pub/Sub per il tuo budget. Questa procedura è descritta in dettaglio nella pagina Gestire le notifiche di avviso relative al budget programmatico.

Dopo aver attivato le notifiche relative al budget, tieni presente quanto segue:

• Argomento Pub/Sub: si tratta dell'endpoint di notifiche configurato per il budget.
• ID budget: è un ID univoco per il tuo budget che viene incluso in tutte le notifiche. Puoi trovare l'ID del budget nel tuo budget in Gestisci notifiche. L'ID viene visualizzato dopo aver selezionato Collega un argomento Pub/Sub a questo budget.

Ascoltare le notifiche

Il passaggio successivo consiste nell'ascoltare le notifiche iscrivendoti al tuo argomento Pub/Sub. Se non hai un sottoscrittore, Pub/Sub eliminerà i messaggi pubblicati e non potrai recuperarli in un secondo momento.

Anche se puoi sottoscrivere un abbonamento al tuo argomento, per questi esempi utilizzeremo i trigger di funzioni Cloud Functions.

Crea una funzione Cloud

Per creare una nuova Cloud Function:

1. Nella console Google Cloud, vai alla pagina Cloud Functions.

   Vai alla pagina Cloud Functions

2. Fai clic su CREA FUNZIONE e assegna alla funzione un nome significativo per il tuo budget.

3. In Trigger, seleziona Argomento Pub/Sub.

4. Seleziona l'argomento che hai configurato nel tuo budget.

5. Fornisci il codice sorgente e le dipendenze per l'esecuzione della funzione.

6. Assicurati di impostare la funzione da eseguire sul nome corretto.

Descrivi la tua Cloud Function

Per indicare alla Cloud Function l'operazione da eseguire con la notifica, puoi scrivere il codice utilizzando l'editor in linea o caricare un file. Per maggiori dettagli sulle notifiche che riceverà il tuo codice, vedi Formato delle notifiche.

Ad esempio, una funzione potrebbe registrare notifiche, attributi e dati Pub/Sub ricevuti quando viene attivata da una notifica del budget. Per saperne di più, consulta Trigger Pub/Sub.

Visualizza gli eventi della Cloud Function

Dopo aver salvato la Cloud Function, puoi fare clic su VISUALIZZA I LOG per visualizzare le notifiche relative al budget registrate. Qui sono mostrati i log delle chiamate delle funzioni.

Testa la tua Cloud Function

Le notifiche vengono inviate a Pub/Sub e i sottoscrittori ricevono i messaggi. Per testare una notifica di esempio e assicurarti che la funzione funzioni come previsto, pubblica un messaggio in Pub/Sub utilizzando questo oggetto come corpo del messaggio:

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

Puoi anche aggiungere attributi del messaggio come l'ID account di fatturazione. Per ulteriori informazioni, consulta la documentazione completa sul formato di notifica.

Invia notifiche a Slack

L'email non è sempre il modo migliore per rimanere al passo con i costi del cloud, in particolare se il budget è fondamentale e le tempistiche sono necessarie. Con le notifiche puoi inoltrare i messaggi relativi al budget ad altri mezzi.

In questo esempio viene descritto come inoltrare le notifiche di budget a Slack. In questo modo, ogni volta che la fatturazione Cloud pubblica una notifica del budget, una Cloud Function utilizza un bot per pubblicare un messaggio in un canale Slack dell'area di lavoro del bot.

Configurare un canale Slack e le autorizzazioni

Il primo passaggio consiste nel creare l'area di lavoro Slack e i token utente del bot utilizzati per chiamare l'API Slack. I token API possono essere gestiti all'indirizzo https://api.slack.com/apps. Per istruzioni dettagliate, vedi Utenti bot sul sito Slack.

Scrivi una Cloud Function

1. Crea una nuova funzione seguendo i passaggi descritti in Creare una funzione Cloud Functions. Assicurati che il trigger sia impostato sullo stesso argomento Pub/Sub che è impostato per utilizzare il tuo budget.

2. Aggiungi dipendenze:

   Node.js

   Copia quanto segue su 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": "^126.0.0",
       "slack": "^11.0.1"
     },
     "devDependencies": {
       "@google-cloud/functions-framework": "^3.0.0",
       "c8": "^8.0.0",
       "gaxios": "^6.0.0",
       "mocha": "^10.0.0",
       "promise-retry": "^2.0.0",
       "proxyquire": "^2.1.0",
       "sinon": "^16.0.0",
       "wait-port": "^1.0.4"
     }
   }
   

   Python

   Copia quanto segue su requirements.txt:

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

3. Scrivi il codice o utilizza l'esempio seguente per pubblicare notifiche di budget in un canale di chat Slack utilizzando l'API Slack.

4. Assicurati che i seguenti parametri postMessage dell'API Slack siano impostati correttamente:

   • Token di accesso OAuth dell'utente del bot
   • Nome canale

Esempio di codice:

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

Ora puoi testare la funzione Cloud Functions per visualizzare un messaggio in Slack.

Limitare (disabilitare) la fatturazione per interrompere l'utilizzo

Questo esempio mostra come limitare i costi e interrompere l'utilizzo per un progetto disattivando la fatturazione Cloud. La disabilitazione della fatturazione in un progetto comporterà l'interruzione di tutti i servizi Google Cloud nel progetto, inclusi i servizi di livello gratuito.

Avviso: questo esempio rimuove la fatturazione Cloud dal progetto, arrestando tutte le risorse. Le risorse potrebbero non essere arrestate automaticamente e potrebbero essere eliminate definitivamente. Se disabiliti fatturazione Cloud, non verrà eseguito il ripristino controllato.
Puoi riabilitare la fatturazione Cloud, ma non vi è alcuna garanzia di ripristino del servizio ed è richiesta la configurazione manuale.

Perché disattivare la fatturazione?

Potresti limitare i costi perché hai un limite fisso di quanto puoi spendere su Google Cloud. Ciò è tipico di studenti, ricercatori o sviluppatori che lavorano in ambienti sandbox. In questi casi, vuoi interrompere la spesa e potresti voler arrestare tutti i servizi e l'utilizzo di Google Cloud quando viene raggiunto il limite del budget.

Nota: si verifica un ritardo tra l'addebito dei costi e la ricezione delle notifiche del budget. I prodotti Google Cloud segnalano i dati di utilizzo e di costo ai processi di fatturazione Cloud a intervalli variabili, quindi potresti incorrere in costi aggiuntivi per un utilizzo che non è arrivato nel momento in cui tutti i servizi vengono interrotti.
Seguire i passaggi in questo esempio di quota limite non garantisce che non spenderai più del tuo budget.
Consiglio: se hai un limite di fondi rigidi, imposta il budget massimo su un importo inferiore ai fondi disponibili per tenere conto dei ritardi nella fatturazione.

Nel nostro esempio, utilizziamo acme-backend-dev come progetto non di produzione per il quale la fatturazione Cloud può essere disabilitata in sicurezza.

Prima di iniziare a lavorare con questo esempio, assicurati di aver eseguito le seguenti operazioni:

• Abilitare l'API Cloud Billing. La tua funzione Cloud Functions deve chiamare l'API Cloud Billing per disabilitare fatturazione Cloud per un progetto.

• Imposta un budget per monitorare i costi del progetto e abilitare le notifiche relative al budget.

Scrivi una Cloud Function

Poi devi configurare la Cloud Function per chiamare l'API Cloud Billing. Consente alla funzione Cloud Function di disabilitare la fatturazione Cloud per il nostro progetto di esempio acme-backend-dev.

1. Crea una nuova funzione seguendo i passaggi descritti in Creare una funzione Cloud Functions. Assicurati che il trigger sia impostato sullo stesso argomento Pub/Sub che è impostato per utilizzare il tuo budget.

2. Aggiungi le seguenti dipendenze:

   Node.js

   Copia quanto segue su 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": "^126.0.0",
       "slack": "^11.0.1"
     },
     "devDependencies": {
       "@google-cloud/functions-framework": "^3.0.0",
       "c8": "^8.0.0",
       "gaxios": "^6.0.0",
       "mocha": "^10.0.0",
       "promise-retry": "^2.0.0",
       "proxyquire": "^2.1.0",
       "sinon": "^16.0.0",
       "wait-port": "^1.0.4"
     }
   }
   

   Python

   Copia quanto segue su requirements.txt:

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

3. Copia il codice seguente nella Cloud Function.

4. Imposta la funzione per l'esecuzione su "stopBilling" (Node) o "stop_billing" (Python).

5. A seconda del runtime, la variabile di ambiente GOOGLE_CLOUD_PROJECT potrebbe essere impostata automaticamente. Esamina l'elenco delle variabili di ambiente impostate automaticamente e determina se devi impostare manualmente la variabile GOOGLE_CLOUD_PROJECT sul progetto a cui vuoi limitare (disabilitare) Fatturazione Cloud.

Nota: se la variabile di ambiente viene impostata automaticamente, l'account di fatturazione Cloud verrà rimosso nel progetto in cui è in esecuzione questa Cloud Function. A seconda delle esigenze, puoi modificare il codice all'interno della Cloud Function per specificare un progetto diverso.

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

Configura le autorizzazioni degli account di servizio

La funzione Cloud Functions viene eseguita come account di servizio creato automaticamente. Per consentire all'account di servizio di disabilitare la fatturazione, devi concedere le autorizzazioni corrette, ad esempio Amministratore fatturazione.

Nota: anziché concedere autorizzazioni Amministratore fatturazione complete all'account di servizio, ti consigliamo di creare un ruolo personalizzato che conceda meno autorizzazioni. Per comprendere le autorizzazioni richieste, rivedi le autorizzazioni necessarie per disabilitare la fatturazione per un progetto.

Per identificare l'account di servizio corretto, visualizza i dettagli della funzione Cloud Function. L'account di servizio è elencato in fondo alla pagina.

Puoi gestire le autorizzazioni di Amministratore della fatturazione nella pagina Fatturazione della console Google Cloud.

Per concedere i privilegi Amministratore account di fatturazione all'account di servizio, seleziona il nome dell'account di servizio.

Verifica che la fatturazione Cloud sia disabilitata

Quando il budget invia una notifica, il progetto specificato non avrà più un account di fatturazione Cloud. Per testare la funzione, pubblica un messaggio di esempio con il messaggio di test riportato sopra. Il progetto non sarà più visibile nell'account di fatturazione Cloud e le risorse del progetto sono disabilitate, inclusa la Cloud Function se si trova nello stesso progetto.

Puoi riabilitare manualmente la fatturazione Cloud per il tuo progetto nella console Google Cloud.

Controllare selettivamente l'utilizzo

Il limite (disattivazione) della fatturazione Cloud come descritto nell'esempio precedente è un sistema binario e terminale. Il progetto è abilitato o disabilitato. Quando è disabilitato, tutti i servizi vengono arrestati e tutte le risorse vengono eventualmente eliminate.

Se hai bisogno di una risposta più articolata, puoi controllare selettivamente le risorse. Ad esempio, se vuoi arrestare alcune risorse Compute Engine senza lasciare intatto Cloud Storage, puoi controllare selettivamente l'utilizzo. In questo modo si riduce il costo orario senza disabilitare completamente il tuo ambiente.

Puoi scrivere le norme con le sfumature che preferisci. Tuttavia, nel nostro esempio, il nostro progetto sta eseguendo una ricerca con un certo numero di macchine virtuali di Compute Engine e archivia i risultati in Cloud Storage. Questo esempio di funzione Cloud Functions arresta tutte le istanze di Compute Engine, ma non influirà sui risultati archiviati dopo il superamento del budget.

Scrivi una Cloud Function

1. Crea una nuova funzione seguendo i passaggi descritti in Creare una funzione Cloud Functions. Assicurati che il trigger sia impostato sullo stesso argomento Pub/Sub che è impostato per utilizzare il tuo budget.

2. Assicurati di aver aggiunto le dipendenze descritte in Limitare la fatturazione (disabilitazione) per interrompere l'utilizzo.

3. Copia il codice seguente nella Cloud Function.

4. Imposta la funzione in modo che venga eseguita su "limitUse" (Node) o "limit_use" (Python).

5. A seconda del runtime, la variabile di ambiente GCP_PROJECT potrebbe essere impostata automaticamente. Esamina l'elenco delle variabili di ambiente impostate automaticamente e determina se è necessario impostare manualmente la variabile GCP_PROJECT sul progetto che esegue le macchine virtuali.

6. Imposta il parametro ZONE. Questa è la zona in cui le istanze verranno arrestate per questo esempio.

Nota: questo esempio di codice ferma solo le istanze in una singola zona nel progetto specificato. A seconda delle tue esigenze, puoi modificare il codice all'interno della Cloud Function per gestire altri progetti e zone.

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

Configura le autorizzazioni degli account di servizio

1. La funzione Cloud Functions viene eseguita come account di servizio creato automaticamente. Per controllare l'utilizzo, devi concedere all'account di servizio le autorizzazioni per tutti i servizi del progetto che devono apportare modifiche.
   Nota: la best practice per la sicurezza prevede di concedere il privilegio minimo specifico per i servizi che gestirà. Qui funzionerà il ruolo Amministratore istanze Compute (v1). Tuttavia, per una maggiore sicurezza, potrebbe essere opportuno configurare e utilizzare un ruolo personalizzato che concede meno autorizzazioni rispetto a un ruolo Amministratore.
2. Per identificare l'account di servizio corretto, visualizza i dettagli della Cloud Function. L'account di servizio è elencato in fondo alla pagina.
3. Nella console Google Cloud, vai alla pagina IAM per impostare le autorizzazioni appropriate.
   Vai alla pagina IAM
    
   

Verifica che le istanze siano arrestate

Quando il budget invia una notifica, le macchine virtuali di Compute Engine vengono arrestate.

Per testare la funzione, pubblica un messaggio di esempio con il messaggio di test riportato sopra. Per verificare che la funzione sia stata eseguita correttamente, controlla le macchine virtuali di Compute Engine nella console Google Cloud.