Esempi di risposte automatiche sul controllo dei costi

Architettura di riferimento di esempio

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

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

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

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

Nota: le notifiche relative al budget vengono inviate all'argomento Pub/Sub più volte volte al giorno con lo stato corrente del budget e delle soglie. Le notifiche continueranno a essere inviate anche dopo che tutte le soglie sono state superato.

Configurare le notifiche relative al budget

Il primo passaggio consiste nell'abilitare un argomento Pub/Sub per il tuo budget. Questo aspetto è descritto in dettaglio in Gestire le notifiche di avviso di budget programmatico.

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

• Argomento Pub/Sub: queste sono le notifiche configurate endpoint per il budget.
• ID budget: si tratta di un ID univoco del budget incluso in tutte le notifiche. Puoi individuare l'ID budget nel tuo budget in Gestisci notifiche. L'ID verrà visualizzato dopo che avrai selezionato Collega un Pub/Sub a questo budget.

Ascoltare le notifiche

Il passo successivo è ascoltare le notifiche iscrivendoti al tuo Pub/Sub. Se non hai un abbonato, Pub/Sub eliminerà i messaggi pubblicati e non puoi recuperarli in seguito.

Sebbene esistano molti modi per abbonarsi all'argomento, per questi esempi utilizzeremo gli attivatori delle funzioni Cloud Run.

Crea una funzione Cloud Run

Per creare una nuova funzione Cloud Run:

1. Nella console Google Cloud, vai alla pagina Funzioni Cloud Run.

   Vai alla pagina delle funzioni di Cloud Run

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

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 della funzione.

Descrizione della funzione Cloud Run

Per indicare alla funzione Cloud Run cosa vuoi che faccia con notifica, puoi scrivere il codice utilizzando l'editor in linea o caricare un file. Per informazioni dettagliate sulle notifiche che riceverà il codice, vedi Formato delle notifiche.

Ad esempio, una funzione potrebbe registrare le notifiche Pub/Sub ricevute, e dati quando vengono attivati da una notifica relativa al budget. Per saperne di più, vedi Trigger Pub/Sub.

Visualizzare gli eventi delle funzioni Cloud Run

Dopo aver salvato la funzione Cloud Run, puoi fare clic su VISUALIZZA LOG per visualizzare le notifiche relative al budget registrate. Vengono visualizzati i log delle chiamate della funzione.

Testa la funzione Cloud Run

Le notifiche vengono inviate a Pub/Sub e gli abbonati ricevono messaggi. Per testare una notifica di esempio e assicurarti che la funzione funziona 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 dei messaggi come l'ID account di fatturazione. Visualizza la formato di notifica documentazione per ulteriori informazioni.

Inviare notifiche a Slack

L'email non è sempre il modo migliore per rimanere aggiornati sui costi del cloud in particolare se il budget è critico e non richiede tempi di elaborazione. Con 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 la fatturazione Cloud pubblica una notifica relativa al budget, una funzione Cloud Run utilizza un bot per pubblicare un messaggio in un canale Slack dello spazio di lavoro del bot.

Configurare un canale Slack e le autorizzazioni

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

Scrivere una funzione Cloud Run

1. Crea una nuova funzione seguendo i passaggi descritti in Creare una funzione Cloud Run. Assicurati che l'attivatore sia impostato sullo stesso argomento Pub/Sub impostato per l'utilizzo del 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": "^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

   Copia quanto segue in requirements.txt:

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

3. Scrivi codice o utilizza l'esempio riportato di seguito per pubblicare notifiche sul budget in un canale di chat di 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 Testa la funzione Cloud Run 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 project, disabilitando la fatturazione Cloud. La disattivazione della fatturazione in un progetto comporta l'interruzione di tutti i servizi Google Cloud al suo interno, inclusi i servizi di livello gratuito.

Avviso: questo esempio rimuove la fatturazione cloud dal progetto, arrestando tutte le risorse. Le risorse potrebbero non arrestarsi in modo corretto e potrebbero essere eliminate in modo irreversibile. Non è previsto alcun recupero graduale se disattivi la fatturazione Cloud.
Puoi riattivare la fatturazione Cloud, ma non è garantito il recupero del servizio ed è necessaria 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 che lavorano in ambienti sandbox. In questi casi, vuoi interrompere la spesa e potresti essere disposto a chiudere tutti i servizi e l'utilizzo di Google Cloud quando viene raggiunto il limite di budget.

Nota: si verifica un ritardo tra l'addebito dei costi e la ricezione notifiche relative al budget. I prodotti Google Cloud segnalano i dati sull'utilizzo e di costo a processi di fatturazione Cloud a intervalli variabili, per cui potresti incorrere costi aggiuntivi per l'utilizzo non ancora arrivati nel momento in cui tutti i servizi vengono interrotti.
Seguire i passaggi descritti in questo esempio di limite non garantisce che non spenderai più del tuo budget.
Consiglio: se hai un limite di fondi fisso, imposta il budget massimo sotto i fondi disponibili per tenere conto dei ritardi nella fatturazione.

Nel nostro esempio, utilizziamo acme-backend-dev come progetto non di produzione per cui 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 Run deve chiamare l'API Cloud Billing per disattivare la fatturazione Cloud per un progetto.

• Configura un budget per monitorare i costi del progetto e attivare le notifiche relative al budget.

Scrivi una funzione Cloud Run

A questo punto devi configurare la funzione Cloud Run per chiamare la funzione l'API Cloud Billing. In questo modo, la funzione Cloud Run può disattivare la fatturazione Cloud per il nostro progetto di esempio acme-backend-dev.

1. Crea una nuova funzione seguendo la procedura descritta in Crea una funzione Cloud Run. Assicurati che il trigger sia impostato sullo stesso argomento Pub/Sub che il tuo budget è impostato per utilizzare.

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": "^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

   Copia quanto segue in requirements.txt:

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

3. Copia il codice seguente nella funzione Cloud Run.

4. Imposta la funzione da eseguire su "stopBilling" (Node) o "stop_billing" (Python).

5. A seconda del runtime, GOOGLE_CLOUD_PROJECT potrebbe essere impostata automaticamente. Esamina l'elenco di variabili di ambiente impostate automaticamente e determinare se è necessario impostare manualmente GOOGLE_CLOUD_PROJECT al progetto per a cui vuoi limitare (disabilitare) la 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 funzione Cloud Run. A seconda delle tue esigenze, puoi modificare il codice all'interno della funzione Cloud Run 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 Run viene eseguita come Un account di servizio creato automaticamente. Per fare in modo che l'account di servizio possa disabilitare la fatturazione, devi concedere le autorizzazioni corrette, ad esempio Amministratore fatturazione.

Nota: anziché concedere autorizzazioni di amministratore fatturazione complete all'account di servizio, potresti volere crea un ruolo personalizzato che concede meno autorizzazioni. Per comprendere le autorizzazioni richieste, consulta il autorizzazioni necessarie per disabilitare la fatturazione per un progetto.

Per identificare l'account di servizio corretto, visualizza la funzione Cloud Run i dettagli. L'account di servizio è elencato nella parte inferiore della 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. 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 al suo interno verranno disattivate, inclusa la funzione Cloud Run se si trova nello stesso progetto.

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

Controllare selettivamente l'utilizzo

Il capping (la disattivazione) della fatturazione Cloud come descritto nell'esempio precedente è binario e terminale. Il progetto è abilitato o disattivata. Quando è disabilitato, tutti i servizi vengono arrestati e tutte le risorse vengono e verrà poi eliminato.

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

Puoi scrivere norme con tutte le sfumature che vuoi. Tuttavia, per il nostro esempio, il progetto esegue ricerche con una serie di macchine virtuali Compute Engine e memorizza i risultati in Cloud Storage. Questo esempio di funzione Cloud Run interromperà tutte le istanze Compute Engine, ma non influirà sui risultati archiviati dopo il superamento del budget.

Scrivere una funzione Cloud Run

1. Crea una nuova funzione seguendo i passaggi descritti in Creare una funzione Cloud Run. Assicurati che l'attivatore sia impostato sullo stesso argomento Pub/Sub impostato per l'utilizzo del budget.

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

3. Copia il codice seguente nella funzione Cloud Run.

4. Imposta la funzione da eseguire su "limitUse" (Nodo) o "limit_use" (Python).

5. A seconda del runtime, GCP_PROJECT potrebbe essere impostata automaticamente. Esamina l'elenco delle variabili di ambiente impostate automaticamente e determina se devi impostare manualmente la variabile GCP_PROJECT per il progetto che esegue le VM.

6. Imposta il parametro ZONE. Questa è la zona in cui le istanze interrotto per questo campione.

Nota: questo esempio di codice arresta solo le istanze in una singola zona del progetto. A seconda delle tue esigenze, puoi modificare il codice all'interno della funzione Cloud Run 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 Run viene eseguita come un account di servizio creato automaticamente. Per controllare l'utilizzo, devi concedere l'account di servizio autorizzazioni a qualsiasi servizio nel progetto che deve apportare modifiche.
   Nota: la best practice per la sicurezza è di grantire il privilegio minimo specifico per i servizi che gestirà. Qui è utile il ruolo Amministratore istanze Compute (v1). Tuttavia, per maggiore sicurezza, ti consigliamo di configurare e utilizzare un ruolo personalizzato che conceda meno autorizzazioni di un ruolo di amministratore.
2. Per identificare l'account di servizio corretto, visualizza i dettagli del tuo nella funzione Cloud Run. L'account di servizio è riportato in fondo alla .
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, la Compute Engine virtuale vengono arrestate.

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