Per semplificare le ricerche e migliorare l'esperienza di documentazione, suddivideremo la documentazione di 1ª generazione e 2ª generazione in set separati.

Questa pagina è stata tradotta dall'API Cloud Translation.

Tutorial su Cloud Audit Logging (2ª generazione)

Questo tutorial illustra la scrittura, il deployment e l'attivazione di una funzione Cloud Functions basata su eventi con un trigger di Cloud Audit Logs.

Una delle caratteristiche uniche di Cloud Functions (2nd gen) è che consente l'attivazione delle funzioni dalle voci Cloud Audit Logs. Molti prodotti Google Cloud scrivono in Cloud Audit Logs quando si verificano importanti azioni all'interno del prodotto. Queste voci di log possono attivare l'esecuzione di Cloud Functions in tempo reale, il che consente agli utenti di elaborarle e/o intervenire automaticamente.

Questi log sono generati da molti eventi diversi in Google Cloud e coprono la maggior parte dei prodotti Google Cloud. Pertanto, i trigger di Cloud Audit Logs consentono di creare funzioni in grado di reagire alla maggior parte delle modifiche di stato in Google Cloud.

Questo tutorial mostrerà come utilizzare i trigger di Cloud Audit Logs per etichettare le istanze Compute Engine appena create con il nome dell'entità (persona o account di servizio) che le ha create.

Se non hai mai utilizzato Cloud Audit Logs e vuoi saperne di più, consulta la documentazione di Cloud Audit Logs.

Obiettivi

Scrivi una funzione Cloud Functions basata su eventi che riceva un evento Cloud Audit Logs quando viene creata un'istanza VM di Compute Engine.
Per attivare la funzione, crea un'istanza VM di Compute Engine. L'istanza verrà etichettata con il nome dell'entità (persona o account di servizio) che l'ha creata.

Costi

In questo documento vengono utilizzati i seguenti componenti fatturabili di Google Cloud:

Cloud Functions
Cloud Build
Pub/Sub
Artifact Registry
Eventarc
Cloud Logging
Compute Engine

For details, see Cloud Functions pricing.

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi utenti di Google Cloud possono essere idonei a una prova senza costi aggiuntivi.

Prima di iniziare

Accedi al tuo account Google Cloud. Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.

Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.

Vai al selettore progetti

Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

Abilita le API Cloud Functions, Cloud Run, Cloud Build, Artifact Registry, Eventarc, Logging, Compute Engine, and Pub/Sub.

Abilita le API

Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.

Vai al selettore progetti

Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

Abilita le API Cloud Functions, Cloud Run, Cloud Build, Artifact Registry, Eventarc, Logging, Compute Engine, and Pub/Sub.

Abilita le API

Installa e inizializza Cloud SDK.
Aggiorna gcloud componenti:

gcloud components update

Hai bisogno di un prompt dei comandi? Puoi utilizzare Google Cloud Shell. Google Cloud Shell è un ambiente a riga di comando che include già Google Cloud SDK, quindi non è necessario installarlo. Google Cloud SDK è anche preinstallato sulle macchine virtuali di Google Compute Engine.

Preparare l'ambiente di sviluppo.

Node.js

Vai alla guida alla configurazione di Node.js

Python

Vai alla guida alla configurazione di Python

Go

Vai alla guida alla configurazione di Go

Java

Vai alla guida alla configurazione di Java

Prerequisiti

Apri la pagina IAM e amministrazione > Audit log nella console Google Cloud:

Vai alla pagina IAM e amministrazione > Audit log
Abilita i tipi di log di Lettura amministratore, Lettura dati e Scrittura dati di Cloud Audit Logs per l'API Compute Engine:
Verifica se l'account di servizio Compute Engine ha il ruolo Editor. Questo account di servizio verrà utilizzato come identità di servizio per Cloud Functions.

Vai alla pagina IAM e amministrazione > IAM

Trova la voce PROJECT_NUMBER-compute@developer.gserviceaccount.com nella tabella ed esamina la colonna Roles. Se la colonna contiene Editor, puoi saltare i seguenti passaggi. In caso contrario, vai ai passaggi successivi e assegna i ruoli necessari all'account di servizio.

Concedi il ruolo eventarc.eventReceiver all'account di servizio Compute Engine del progetto:

PROJECT_ID=$(gcloud config get-value project)
PROJECT_NUMBER=$(gcloud projects list --filter="project_id:$PROJECT_ID" --format='value(project_number)')

# Allow service account token creation
gcloud projects add-iam-policy-binding $PROJECT_ID \
 --member serviceAccount:$PROJECT_NUMBER-compute@developer.gserviceaccount.com \
 --role roles/eventarc.eventReceiver

Concedi il ruolo run.invoker all'account di servizio Compute Engine del progetto in modo che il trigger Pub/Sub possa eseguire la funzione:

PROJECT_ID=$(gcloud config get-value project)
PROJECT_NUMBER=$(gcloud projects list --filter="project_id:$PROJECT_ID" --format='value(project_number)')

# Allow service account token creation
gcloud projects add-iam-policy-binding $PROJECT_ID \
 --member serviceAccount:$PROJECT_NUMBER-compute@developer.gserviceaccount.com \
 --role roles/run.invoker

Concedi il ruolo compute.instanceAdmin all'account di servizio Compute Engine del progetto in modo che il codice della funzione disponga delle autorizzazioni necessarie per recuperare le istanze VM e impostarvi le etichette:

PROJECT_ID=$(gcloud config get-value project)
PROJECT_NUMBER=$(gcloud projects list --filter="project_id:$PROJECT_ID" --format='value(project_number)')

# Allow service account token creation
gcloud projects add-iam-policy-binding $PROJECT_ID \
 --member serviceAccount:$PROJECT_NUMBER-compute@developer.gserviceaccount.com \
 --role roles/compute.instanceAdmin

Preparazione dell'applicazione

Clona il repository dell'app di esempio sulla tua macchina locale:
Node.js
```
git clone https://github.com/GoogleCloudPlatform/nodejs-docs-samples.git
```
In alternativa, puoi scaricare l'esempio come file ZIP ed estrarlo.
Python
```
git clone https://github.com/GoogleCloudPlatform/python-docs-samples.git
```
In alternativa, puoi scaricare l'esempio come file ZIP ed estrarlo.
Go
```
git clone https://github.com/GoogleCloudPlatform/golang-samples.git
```
In alternativa, puoi scaricare l'esempio come file ZIP ed estrarlo.
Java
```
git clone https://github.com/GoogleCloudPlatform/java-docs-samples.git
```
In alternativa, puoi scaricare l'esempio come file ZIP ed estrarlo.

Passa alla directory che contiene il codice campione di Cloud Functions per accedere a Cloud Audit Logs:

Node.js

cd nodejs-docs-samples/functions/v2/autoLabelInstance/

Python

cd python-docs-samples/functions/v2/label_gce_instance/

Go

cd golang-samples/functions/functionsv2/label_gce_instance/

Java

cd java-docs-samples/functions/v2/label-compute-instance/

Dai un'occhiata al codice campione:

Node.js

const functions = require('@google-cloud/functions-framework');

const compute = require('@google-cloud/compute');
const instancesClient = new compute.InstancesClient();

// Register a CloudEvent callback with the Functions Framework that labels
// newly-created GCE instances with the entity (person or service account)
// that created them.
functions.cloudEvent('autoLabelInstance', async cloudEvent => {
  // Extract parameters from the CloudEvent + Cloud Audit Log data
  const payload = cloudEvent.data && cloudEvent.data.protoPayload;
  const authInfo = payload && payload.authenticationInfo;
  let creator = authInfo && authInfo.principalEmail;

  // Get relevant VM instance details from the CloudEvent's `subject` property
  // Example value:
  //   compute.googleapis.com/projects/<PROJECT>/zones/<ZONE>/instances/<INSTANCE>
  const params = cloudEvent.subject && cloudEvent.subject.split('/');

  // Validate data
  if (!creator || !params || params.length !== 7) {
    throw new Error('Invalid event structure');
  }

  // Format the 'creator' parameter to match GCE label validation requirements
  creator = creator.toLowerCase().replace(/\W/g, '_');

  // Get the newly-created VM instance's label fingerprint
  // This is required by the Compute Engine API to prevent duplicate labels
  const getInstanceRequest = {
    project: params[2],
    zone: params[4],
    instance: params[6],
  };
  const [instance] = await instancesClient.get(getInstanceRequest);

  // Label the instance with its creator
  const setLabelsRequest = Object.assign(
    {
      instancesSetLabelsRequestResource: {
        labels: {creator},
        labelFingerprint: instance.labelFingerprint,
      },
    },
    getInstanceRequest
  );

  return instancesClient.setLabels(setLabelsRequest);
});

Python

import re

from google.api_core.exceptions import GoogleAPIError
from google.cloud import compute_v1
from google.cloud.compute_v1.types import compute

instances_client = compute_v1.InstancesClient()


# CloudEvent function that labels newly-created GCE instances
# with the entity (user or service account) that created them.
#
# @param {object} cloudevent A CloudEvent containing the Cloud Audit Log entry.
# @param {object} cloudevent.data.protoPayload The Cloud Audit Log entry.
def label_gce_instance(cloudevent):
    # Extract parameters from the CloudEvent + Cloud Audit Log data
    payload = cloudevent.data.get("protoPayload", dict())
    auth_info = payload.get("authenticationInfo", dict())
    creator = auth_info.get("principalEmail")

    # Get relevant VM instance details from the cloudevent's `subject` property
    # Example value:
    #   compute.googleapis.com/projects/<PROJECT_ID>/zones/<ZONE_ID>/instances/<INSTANCE_NAME>
    instance_params = cloudevent["subject"].split("/")

    # Validate data
    if not creator or not instance_params or len(instance_params) != 7:
        # This is not something retries will fix, so don't throw an Exception
        # (Thrown exceptions trigger retries *if* you enable retries in GCF.)
        print("ERROR: Invalid `principalEmail` and/or CloudEvent `subject`.")
        return

    instance_project = instance_params[2]
    instance_zone = instance_params[4]
    instance_name = instance_params[6]

    # Format the 'creator' parameter to match GCE label validation requirements
    creator = re.sub("\\W", "_", creator.lower())

    # Get the newly-created VM instance's label fingerprint
    # This is required by the Compute Engine API to prevent duplicate labels
    instance = instances_client.get(
        project=instance_project, zone=instance_zone, instance=instance_name
    )

    # Construct API call to label the VM instance with its creator
    request_init = {
        "project": instance_project,
        "zone": instance_zone,
        "instance": instance_name,
    }
    request_init[
        "instances_set_labels_request_resource"
    ] = compute.InstancesSetLabelsRequest(
        label_fingerprint=instance.label_fingerprint, labels={"creator": creator}
    )
    request = compute.SetLabelsInstanceRequest(request_init)

    # Perform instance-labeling API call
    try:
        instances_client.set_labels_unary(request)
        print(f"Labelled VM instance {instance_name} with creator: {creator}")
    except GoogleAPIError as e:
        # Swallowing the exception means failed invocations WON'T be retried
        print("Label operation failed", e)

        # Uncomment the line below to retry failed invocations.
        # (You'll also have to enable retries in Cloud Functions itself.)
        # raise e

    return

Go


// Package helloworld provides a set of Cloud Functions samples.
package helloworld

import (
	"context"
	"fmt"
	"log"
	"regexp"
	"strings"

	compute "cloud.google.com/go/compute/apiv1"
	"github.com/GoogleCloudPlatform/functions-framework-go/functions"
	"github.com/cloudevents/sdk-go/v2/event"
	computepb "google.golang.org/genproto/googleapis/cloud/compute/v1"
	"google.golang.org/protobuf/proto"
)

// AuditLogEntry represents a LogEntry as described at
// https://cloud.google.com/logging/docs/reference/v2/rest/v2/LogEntry
type AuditLogEntry struct {
	ProtoPayload *AuditLogProtoPayload `json:"protoPayload"`
}

// AuditLogProtoPayload represents AuditLog within the LogEntry.protoPayload
// See https://cloud.google.com/logging/docs/reference/audit/auditlog/rest/Shared.Types/AuditLog
type AuditLogProtoPayload struct {
	MethodName         string                 `json:"methodName"`
	ResourceName       string                 `json:"resourceName"`
	AuthenticationInfo map[string]interface{} `json:"authenticationInfo"`
}

var client *compute.InstancesClient

func init() {
	// Create an Instances Client
	var err error
	client, err = compute.NewInstancesRESTClient(context.Background())
	if err != nil {
		log.Fatalf("Failed to create instances client: %s", err)
	}

	functions.CloudEvent("label-gce-instance", labelGceInstance)
}

// Cloud Function that receives GCE instance creation Audit Logs, and adds a
// `creator` label to the instance.
func labelGceInstance(ctx context.Context, ev event.Event) error {
	// Extract parameters from the Cloud Event and Cloud Audit Log data
	logentry := &AuditLogEntry{}
	if err := ev.DataAs(logentry); err != nil {
		err = fmt.Errorf("event.DataAs() : %w", err)
		log.Printf("Error parsing proto payload: %s", err)
		return err
	}
	payload := logentry.ProtoPayload
	creator, ok := payload.AuthenticationInfo["principalEmail"]
	if !ok {
		err := fmt.Errorf("principalEmail not found in cloud event payload: %v", payload)
		log.Printf("creator email not found: %s", err)
		return err
	}

	// Get relevant VM instance details from the event's `subject` property
	// Subject format:
	// compute.googleapis.com/projects/<PROJECT>/zones/<ZONE>/instances/<INSTANCE>
	paths := strings.Split(ev.Subject(), "/")
	if len(paths) < 6 {
		return fmt.Errorf("invalid event subject: %s", ev.Subject())
	}
	project := paths[2]
	zone := paths[4]
	instance := paths[6]

	// Sanitize the `creator` label value to match GCE label requirements
	// See https://cloud.google.com/compute/docs/labeling-resources#requirements
	labelSanitizer := regexp.MustCompile("[^a-z0-9_-]+")
	creatorstring := labelSanitizer.ReplaceAllString(strings.ToLower(creator.(string)), "_")

	// Get the newly-created VM instance's label fingerprint
	// This is a requirement of the Compute Engine API and avoids duplicate labels
	inst, err := client.Get(ctx, &computepb.GetInstanceRequest{
		Project:  project,
		Zone:     zone,
		Instance: instance,
	})
	if err != nil {
		err = fmt.Errorf("could not retrieve GCE instance: %s", err)
		log.Print(err)
		return err
	}
	if v, ok := inst.Labels["creator"]; ok {
		// Instance already has a creator label.
		log.Printf("instance %s already labeled with creator: %s", instance, v)
		return nil
	}

	// Add the creator label to the instance
	op, err := client.SetLabels(ctx, &computepb.SetLabelsInstanceRequest{
		Project:  project,
		Zone:     zone,
		Instance: instance,
		InstancesSetLabelsRequestResource: &computepb.InstancesSetLabelsRequest{
			LabelFingerprint: proto.String(inst.GetLabelFingerprint()),
			Labels: map[string]string{
				"creator": creatorstring,
			},
		},
	})
	if err != nil {
		log.Fatalf("Could not label GCE instance: %s", err)
	}
	log.Printf("Creator label added to %s in operation %v", instance, op)
	return nil
}

Java

import com.google.cloud.compute.v1.GetInstanceRequest;
import com.google.cloud.compute.v1.Instance;
import com.google.cloud.compute.v1.InstancesClient;
import com.google.cloud.compute.v1.InstancesSetLabelsRequest;
import com.google.cloud.compute.v1.SetLabelsInstanceRequest;
import com.google.cloud.functions.CloudEventsFunction;
import com.google.gson.Gson;
import com.google.gson.JsonObject;
import com.google.gson.JsonSyntaxException;
import io.cloudevents.CloudEvent;
import java.nio.charset.StandardCharsets;
import java.util.logging.Logger;

public class AutoLabelInstance implements CloudEventsFunction {
  private static final Logger logger = Logger.getLogger(AutoLabelInstance.class.getName());

  @Override
  public void accept(CloudEvent event) throws Exception {
    // Extract CloudEvent data
    if (event.getData() != null) {
      String cloudEventData = new String(event.getData().toBytes(), StandardCharsets.UTF_8);

      // Convert data to JSON
      JsonObject eventData;
      try {
        Gson gson = new Gson();
        eventData = gson.fromJson(cloudEventData, JsonObject.class);
      } catch (JsonSyntaxException error) {
        throw new RuntimeException("CloudEvent data is not valid JSON: " + error.getMessage());
      }

      // Extract the Cloud Audit Logging entry from the data's protoPayload
      JsonObject payload = eventData.getAsJsonObject("protoPayload");
      JsonObject auth = payload.getAsJsonObject("authenticationInfo");

      // Extract the email address of the authenticated user
      // (or service account on behalf of third party principal) making the request
      String creator = auth.get("principalEmail").getAsString();
      if (creator == null) {
        throw new RuntimeException("`principalEmail` not found in protoPayload.");
      }
      // Format the 'creator' parameter to match GCE label validation requirements
      creator = creator.toLowerCase().replaceAll("\\W", "-");

      // Get relevant VM instance details from the CloudEvent `subject` property
      // Example: compute.googleapis.com/projects/<PROJECT>/zones/<ZONE>/instances/<INSTANCE>
      String subject = event.getSubject();
      if (subject == null || subject == "") {
        throw new RuntimeException("Missing CloudEvent `subject`.");
      }
      String[] params = subject.split("/");

      // Validate data
      if (params.length < 7) {
        throw new RuntimeException("Can not parse resource from CloudEvent `subject`: " + subject);
      }
      String project = params[2];
      String zone = params[4];
      String instanceName = params[6];

      // Instantiate the Compute Instances client
      try (InstancesClient instancesClient = InstancesClient.create()) {
        // Get the newly-created VM instance's label fingerprint
        // This is required by the Compute Engine API to prevent duplicate labels
        GetInstanceRequest getInstanceRequest =
            GetInstanceRequest.newBuilder()
                .setInstance(instanceName)
                .setProject(project)
                .setZone(zone)
                .build();
        Instance instance = instancesClient.get(getInstanceRequest);
        String fingerPrint = instance.getLabelFingerprint();

        // Label the instance with its creator
        SetLabelsInstanceRequest setLabelRequest =
            SetLabelsInstanceRequest.newBuilder()
                .setInstance(instanceName)
                .setProject(project)
                .setZone(zone)
                .setInstancesSetLabelsRequestResource(
                    InstancesSetLabelsRequest.newBuilder()
                        .putLabels("creator", creator)
                        .setLabelFingerprint(fingerPrint)
                        .build())
                .build();

        instancesClient.setLabelsAsync(setLabelRequest);
        logger.info(
            String.format(
                "Adding label, \"{'creator': '%s'}\", to instance, \"%s\".",
                creator, instanceName));
      } catch (Exception error) {
        throw new RuntimeException(
            String.format(
                "Error trying to label VM instance, %s: %s", instanceName, error.toString()));
      }
    }
  }
}

Deployment della funzione

Per eseguire il deployment della funzione con un trigger di Cloud Audit Logs, esegui questo comando nella directory che contiene il codice campione (o, nel caso di Java, il file pom.xml):

// LINT.IfChange(nodejs_version) // LINT.QuindiChange(:nodejs_version_console_text) // LINT.IfChange(nodejs_version_console_text) // LINT.thenChange(:nodejs_version)

Node.js

gcloud functions deploy nodejs-cal-function \
--gen2 \
--runtime=nodejs20 \
--region=REGION \
--source=. \
--entry-point=autoLabelInstance \
--trigger-location=REGION \
--trigger-event-filters="type=google.cloud.audit.log.v1.written" \
--trigger-event-filters="serviceName=compute.googleapis.com" \
--trigger-event-filters="methodName=v1.compute.instances.insert"

Utilizza il flag --runtime per specificare l'ID runtime di una versione di Node.js supportata per eseguire la funzione.

Python

gcloud functions deploy python-cal-function \
--gen2 \
--runtime=python312 \
--region=REGION \
--source=. \
--entry-point=label_gce_instance \
--trigger-location=REGION \
--trigger-event-filters="type=google.cloud.audit.log.v1.written" \
--trigger-event-filters="serviceName=compute.googleapis.com" \
--trigger-event-filters="methodName=v1.compute.instances.insert"

Utilizza il flag --runtime per specificare l'ID runtime di una versione Python supportata per eseguire la funzione.

Go

gcloud functions deploy go-cal-function \
--gen2 \
--runtime=go121 \
--region=REGION \
--source=. \
--entry-point=label-gce-instance \
--trigger-location=REGION \
--trigger-event-filters="type=google.cloud.audit.log.v1.written" \
--trigger-event-filters="serviceName=compute.googleapis.com" \
--trigger-event-filters="methodName=v1.compute.instances.insert"

Utilizza il flag --runtime per specificare l'ID runtime di una versione Go supportata per eseguire la funzione.

Java

gcloud functions deploy java-cal-function \
--gen2 \
--runtime=java17 \
--region=REGION \
--source=. \
--entry-point=functions.AutoLabelInstance \
--memory=512MB \
--trigger-location=REGION \
--trigger-event-filters="type=google.cloud.audit.log.v1.written" \
--trigger-event-filters="serviceName=compute.googleapis.com" \
--trigger-event-filters="methodName=v1.compute.instances.insert"

Utilizza il flag --runtime per specificare l'ID runtime di una versione Java supportata per eseguire la funzione.

Il comando deployment sopra specifica i seguenti parametri di filtro di eventi che corrispondono alla creazione della VM:

type: il tipo di evento Cloud Audit Logs (google.cloud.audit.log.v1.written).
serviceName: il nome del servizio Google Cloud che ha generato la voce di log, in questo caso compute.googleapis.com.
methodName: il nome del metodo API che ha generato la voce di log, in questo caso v1.compute.instances.insert.

Attivazione della funzione

Una volta eseguito il deployment della funzione, puoi confermare che funzioni:

Crea un'istanza VM di Compute Engine:
```
gcloud compute instances create YOUR_INSTANCE_NAME --zone YOUR_ZONE
```
In alternativa, vai alla console Google Cloud e fai clic su Crea una VM.
Esegui questo comando per verificare che l'istanza sia stata etichettata correttamente:
```
gcloud compute instances describe YOUR_INSTANCE_NAME \
    --zone YOUR_ZONE \
    --format 'value(labels)'
```
Dovresti vedere un'etichetta con il formato creator=YOURNAMEYOUR_DOMAIN.

Esegui la pulizia

Per evitare che al tuo Account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, elimina il progetto che contiene le risorse oppure mantieni il progetto ed elimina le singole risorse.

Elimina il progetto

Il modo più semplice per eliminare la fatturazione è eliminare il progetto che hai creato per il tutorial.

Per eliminare il progetto:

Attenzione: l'eliminazione di un progetto ha i seguenti effetti:

L'intero contenuto del progetto viene eliminato. Se hai utilizzato un progetto esistente per le attività in questo documento, quando lo elimini elimini anche qualsiasi altro lavoro svolto nel progetto.
Gli ID progetto personalizzati non sono più disponibili. Quando hai creato questo progetto, potresti aver creato un ID progetto personalizzato che vuoi utilizzare in futuro. Per conservare gli URL che utilizzano l'ID progetto, ad esempio un URL appspot.com, elimina le risorse selezionate all'interno del progetto anziché eliminare l'intero progetto.

Se intendi esplorare più architetture, tutorial o guide rapide, puoi riutilizzare i progetti ed evitare così di superare i limiti di quota.

Nella console Google Cloud, vai alla pagina Gestisci risorse.
Vai a Gestisci risorse
Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.
Nella finestra di dialogo, digita l'ID del progetto e fai clic su Chiudi per eliminare il progetto.

Eliminazione della Cloud Function

L'eliminazione di Cloud Functions non rimuove le risorse archiviate in Cloud Storage.

Per eliminare la Cloud Function creata in questo tutorial, esegui questo comando:

Node.js

gcloud functions delete nodejs-cal-function --gen2 --region REGION

Python

gcloud functions delete python-cal-function --gen2 --region REGION

Go

gcloud functions delete go-cal-function --gen2 --region REGION

Java

gcloud functions delete java-cal-function --gen2 --region REGION

Puoi anche eliminare Cloud Functions dalla console Google Cloud.

Eliminazione dell'istanza VM di Compute Engine

Per eliminare l'istanza VM di Compute Engine creata in questo tutorial, esegui questo comando:

gcloud compute instances delete YOUR_INSTANCE_NAME --zone YOUR_ZONE