Esempi di risposte automatiche sul controllo dei costi

Esempio di architettura di riferimento

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

Se sei consapevole dei costi e hai bisogno di controllare l'ambiente rispetto al budget, puoi utilizzare le notifiche relative al budget programmatiche per automatizzare la risposta al controllo dei costi in base alla notifica relativa al budget.

Le notifiche relative al 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 relative al 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 operazione è descritta in dettaglio in Gestire le notifiche di avviso relativo al budget programmatico.

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

• Argomento Pub/Sub: si tratta dell'endpoint di notifica configurato per il budget.
• ID budget: si tratta di un ID univoco per il budget, incluso in tutte le notifiche. Puoi individuare l'ID budget nel tuo budget in Gestisci notifiche. L'ID viene visualizzato dopo che hai selezionato Connetti un argomento Pub/Sub a questo budget.

Ascoltare le notifiche

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

Sebbene esistano molti modi per iscriversi all'argomento, per questi esempi utilizzeremo i trigger di funzione 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 l'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 della funzione.

Descrizione della Cloud Function

Per comunicare alla funzione Cloud Function cosa vuoi che faccia con la notifica, puoi scrivere il codice utilizzando l'editor in linea o caricare un file. Per maggiori dettagli sulle notifiche che riceverà il codice, consulta Formato delle notifiche.

Ad esempio, una funzione potrebbe registrare le notifiche Pub/Sub ricevute, gli attributi e i dati quando viene attivata da una notifica relativa al budget. Per saperne di più, consulta la pagina Trigger di Pub/Sub.

Visualizzare gli eventi della Cloud Function

Dopo aver salvato la Cloud Function, puoi fare clic su VISUALIZZA LOG per visualizzare le notifiche relative al budget registrate. Mostra i log delle chiamate alla funzione.

Testa la 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 delle notifiche.

Invia notifiche a Slack

L'email non è sempre il modo migliore per rimanere al passo con i costi del cloud, in particolare se il tuo budget è essenziale e richiede tempi di elaborazione. Con le notifiche puoi inoltrare i messaggi relativi al budget ad altri mezzi.

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

Configurazione di un canale Slack e delle autorizzazioni

Il primo passaggio consiste nel creare la tua area di lavoro Slack e i token utente bot utilizzati per chiamare l'API Slack. I token API possono essere gestiti all'indirizzo https://api.slack.com/apps. Per istruzioni dettagliate, consulta la pagina relativa agli utenti bot sul sito di 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 per cui è impostato il budget.

2. Aggiungi dipendenze:

   Node.js

   Copia quanto segue in 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 in requirements.txt:

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

3. Scrivi il codice o utilizza l'esempio riportato di seguito per pubblicare notifiche relative al 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.

Limita (disattiva) la fatturazione per interrompere l'utilizzo

Questo esempio mostra come limitare i costi e interrompere l'utilizzo per un progetto disabilitando la fatturazione Cloud. La disabilitazione della fatturazione in un progetto comporterà la terminazione 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 ed essere eliminate in modo irreversibile. Se disabiliti la fatturazione Cloud, non è previsto alcun recupero controllato.
Puoi riabilitare la fatturazione Cloud, ma non garantisce il recupero del servizio ed è richiesta la configurazione manuale.

Perché disattivare la fatturazione?

Potresti limitare i costi perché hai un limite fisso alla quantità di denaro che puoi spendere su Google Cloud. È un comportamento 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 relative al budget. I prodotti Google Cloud segnalano i dati sull'utilizzo e di costo ai processi di fatturazione Cloud a intervalli diversi, per cui potrebbero essere addebitati costi aggiuntivi per l'utilizzo che non sono arrivati al momento dell'arresto di tutti i servizi.
Seguire la procedura indicata in questo esempio di quota limite non garantisce che non spenderai più del budget a disposizione.
Consiglio: se hai un limite di fondi fisso, imposta un budget massimo 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 modo sicuro.

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

• Abilita l'API Cloud Billing. La funzione Cloud Functions deve chiamare l'API Cloud Billing per disabilitare la 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. In questo modo la Cloud Function può 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 per cui è impostato il budget.

2. Aggiungi le seguenti dipendenze:

   Node.js

   Copia quanto segue in 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 in requirements.txt:

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

3. Copia il codice seguente nella Cloud Function.

4. Imposta la funzione da eseguire 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 di variabili di ambiente impostate automaticamente e determina se è necessario impostare manualmente la variabile GOOGLE_CLOUD_PROJECT sul progetto per cui vuoi limitare (disabilitare) la fatturazione Cloud.

Nota: se la variabile di ambiente viene impostata automaticamente, l'account di fatturazione Cloud verrà rimosso dal progetto in cui è in esecuzione questa Cloud Function. A seconda delle tue 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 concedergli le autorizzazioni corrette, ad esempio Amministratore fatturazione.

Nota: anziché concedere autorizzazioni Amministratore fatturazione complete all'account di servizio, è consigliabile creare un ruolo personalizzato che conceda meno autorizzazioni. Per comprendere le autorizzazioni richieste, esamina 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 di 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. Se vuoi 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 riattivare manualmente la fatturazione Cloud per il tuo progetto nella console Google Cloud.

Controllo selettivo dell'utilizzo

La limitazione (disattivazione) della fatturazione Cloud come descritto nell'esempio precedente è binario e terminale. Il tuo progetto è abilitato o disabilitato. Quando è disabilitato, tutti i servizi vengono arrestati e tutte le risorse vengono alla fine eliminate.

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

Puoi scrivere norme personalizzate nel modo che preferisci. Tuttavia, per il nostro esempio, il nostro progetto sta eseguendo ricerche con una serie di macchine virtuali Compute Engine e sta archiviando i risultati in Cloud Storage. Questo esempio di funzione Cloud Functions causerà l'arresto di tutte le istanze di Compute Engine, ma non influirà sui nostri 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 per cui è impostato il budget.

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

3. Copia il codice seguente nella Cloud Function.

4. Imposta la funzione da eseguire 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 di variabili di ambiente impostate automaticamente e determina se devi 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 arresta solo le istanze in una singola zona nel progetto specificato. A seconda delle 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 nel 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 maggiore sicurezza, ti consigliamo di 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.