Um die Suche zu vereinfachen und die Dokumentation zu verbessern, teilen wir die Dokumentation der 1. Generation und der 2. Generation in separate Gruppen ein.

Anleitung zum Cloud-Audit-Logging (2. Generation)

In dieser Anleitung wird gezeigt, wie Sie eine ereignisgesteuerte Cloud Functions-Funktion mit einem Cloud-Audit-Log-Trigger schreiben, bereitstellen und auslösen.

Eine der einzigartigen Funktionen von Cloud Functions (2. Generation) ist, dass die Funktionen durch Einträge von Cloud-Audit-Logs ausgelöst werden können. Viele Google Cloud-Produkte schreiben in Cloud-Audit-Logs, wenn wichtige produktspezifische Aktionen auftreten. Diese Logeinträge können die Ausführung von Cloud Functions in Echtzeit auslösen, sodass Nutzer automatisch verarbeiten und/oder darauf reagieren können.

Diese Logs werden von vielen verschiedenen Ereignissen in Google Cloud generiert und decken die meisten Google Cloud-Produkte ab. Daher können Sie in Cloud-Audit-Logs Trigger erstellen, die auf die meisten Statusänderungen in Google Cloud reagieren.

In dieser Anleitung erfahren Sie, wie Sie mithilfe von Cloud-Audit-Logs neu erstellte Compute Engine-Instanzen mit dem Namen der Entität (Person oder Dienstkonto) versehen, die sie erstellt hat.

Wenn Sie Cloud-Audit-Logs noch nicht kennen und weitere Informationen erhalten möchten, lesen Sie die Dokumentation zu Cloud-Audit-Logs.

Lernziele

Schreiben Sie eine ereignisgesteuerten Cloud Functions-Funktion, die beim Erstellen einer Compute Engine-VM-Instanz ein Cloud-Audit-Logereignis empfängt.
Lösen Sie die Funktion durch Erstellen einer Compute Engine-VM-Instanz aus. Anschließend wird die Instanz mit dem Namen der Entität (Person oder Dienstkonto) gekennzeichnet, die sie erstellt hat.

Kosten

In diesem Dokument verwenden Sie die folgenden kostenpflichtigen Komponenten von Google Cloud:

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

Weitere Informationen finden Sie unter Cloud Functions-Preise.

Mit dem Preisrechner können Sie eine Kostenschätzung für Ihre voraussichtliche Nutzung vornehmen. Neuen Google Cloud-Nutzern steht möglicherweise eine kostenlose Testversion zur Verfügung.

Vorbereitung

Melden Sie sich bei Ihrem Google Cloud-Konto an. Wenn Sie mit Google Cloud noch nicht vertraut sind, erstellen Sie ein Konto, um die Leistungsfähigkeit unserer Produkte in der Praxis sehen und bewerten zu können. Neukunden erhalten außerdem ein Guthaben von 300 $, um Arbeitslasten auszuführen, zu testen und bereitzustellen.

Wählen Sie in der Google Cloud Console auf der Seite der Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie eines.

Zur Projektauswahl

Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein.

Cloud Functions, Cloud Run, Cloud Build, Artifact Registry, Eventarc, Logging, Compute Engine, and Pub/Sub APIs aktivieren.

Aktivieren Sie die APIs

Wählen Sie in der Google Cloud Console auf der Seite der Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie eines.

Zur Projektauswahl

Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein.

Cloud Functions, Cloud Run, Cloud Build, Artifact Registry, Eventarc, Logging, Compute Engine, and Pub/Sub APIs aktivieren.

Aktivieren Sie die APIs

Installieren und initialisieren Sie das Cloud SDK.
Aktualisieren Sie die gcloud-Komponenten:

gcloud components update

Benötigen Sie eine Eingabeaufforderung? Dazu steht die Google Cloud Shell zur Verfügung. Google Cloud Shell ist eine Befehlszeilenumgebung, in der das Google Cloud SDK bereits enthalten ist und daher nicht installiert werden muss. Das Google Cloud SDK ist außerdem auf den virtuellen Maschinen von Google Compute Engine vorinstalliert.

Bereiten Sie die Entwicklungsumgebung vor.

Node.js

Einrichtungsleitfaden für Node.js aufrufen

Python

Einrichtungsleitfaden für Python aufrufen

Go

Zum Einrichtungsleitfaden für Go

Java

Einrichtungsleitfaden für Java aufrufen

Vorbereitung

Öffnen Sie in der Google Cloud Console die Seite IAM und Verwaltung > Audit-Logs:

Zur Seite "IAM & Verwaltung > Audit-Logs"
Aktivieren Sie die Cloud-Audit-Logs Administratorlesevorgänge, Datenlesevorgänge und Datenschreibvorgänge für die Compute Engine API:
Prüfen Sie, ob das Compute Engine-Dienstkonto die Rolle Editor hat. Dieses Dienstkonto wird als Dienstidentität für Cloud Functions verwendet:

Zur Seite „IAM & Verwaltung > IAM“

Suchen Sie in der Tabelle nach dem Eintrag PROJECT_NUMBER-compute@developer.gserviceaccount.com und sehen Sie sich die Spalte Roles an. Wenn die Spalte Editor enthält, können Sie die folgenden Schritte überspringen. Andernfalls fahren Sie mit den nächsten Schritten fort und weisen dem Dienstkonto die erforderlichen Rollen zu.

Weisen Sie dem Compute Engine-Dienstkonto des Projekts die Rolle eventarc.eventReceiver zu:

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

Weisen Sie dem Compute Engine-Dienstkonto des Projekts die Rolle run.invoker zu, damit der Pub/Sub-Trigger die Funktion ausführen kann:

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

Weisen Sie dem Compute Engine-Dienstkonto des Projekts die Rolle compute.instanceAdmin zu, damit der Funktionscode die erforderlichen Berechtigungen zum Abrufen von VM-Instanzen und zum Festlegen von Labels für sie hat:

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

Anwendung vorbereiten

Klonen Sie das Repository der Beispiel-App auf Ihren lokalen Computer:
Node.js
```
git clone https://github.com/GoogleCloudPlatform/nodejs-docs-samples.git
```
Sie können auch das Beispiel als ZIP-Datei herunterladen und extrahieren.
Python
```
git clone https://github.com/GoogleCloudPlatform/python-docs-samples.git
```
Sie können auch das Beispiel als ZIP-Datei herunterladen und extrahieren.
Einfach loslegen (Go)
```
git clone https://github.com/GoogleCloudPlatform/golang-samples.git
```
Sie können auch das Beispiel als ZIP-Datei herunterladen und extrahieren.
Java
```
git clone https://github.com/GoogleCloudPlatform/java-docs-samples.git
```
Sie können auch das Beispiel als ZIP-Datei herunterladen und extrahieren.

Wechseln Sie in das Verzeichnis, das den Cloud Functions-Beispielcode für den Zugriff auf Cloud-Audit-Logs enthält:

Node.js

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

Python

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

Einfach loslegen (Go)

cd golang-samples/functions/functionsv2/label_gce_instance/

Java

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

Sehen Sie sich den Beispielcode an:

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

Einfach loslegen (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()));
      }
    }
  }
}

Funktion bereitstellen

Führen Sie diesen Befehl in dem Verzeichnis mit dem Beispielcode (oder im Fall von Java die Datei pom.xml) aus, um die Funktion mit einem Cloud-Audit-Logs-Trigger bereitzustellen:

// LINT.IfChange(nodejs_version) // LINT.ThenChange(:nodejs_version_console_text) // LINT.IfChange(nodejs_version_console_text) // LINT.ThenChange(:nodejs_version) // LINT.IfChange(nodejs_version) // LINT.ThenChange(: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"

Verwenden Sie das Flag --runtime, um die Laufzeit-ID einer unterstützten Node.js-Version anzugeben und die Funktion auszuführen.

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"

Verwenden Sie das Flag --runtime, um die Laufzeit-ID einer unterstützten Python-Version anzugeben und die Funktion auszuführen.

Einfach loslegen (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"

Verwenden Sie das Flag --runtime, um die Laufzeit-ID einer unterstützten Go-Version anzugeben und die Funktion auszuführen.

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"

Verwenden Sie das Flag --runtime, um die Laufzeit-ID einer unterstützten Java-Version anzugeben und die Funktion auszuführen.

Der obige Bereitstellungsbefehl gibt die folgenden Ereignisfilterparameter an, die der VM-Erstellung entsprechen:

type: Der Ereignistyp von Cloud-Audit-Logs (google.cloud.audit.log.v1.written).
serviceName: Der Name des Google Cloud-Dienstes, der den Logeintrag generiert hat, in diesem Fall compute.googleapis.com.
methodName: Der Name der API-Methode, die den Logeintrag generiert hat, in diesem Fall v1.compute.instances.insert.

Funktion auslösen

Sobald die Funktion bereitgestellt ist, können Sie prüfen, ob sie funktioniert:

Erstellen Sie eine Compute Engine-VM-Instanz:
```
gcloud compute instances create YOUR_INSTANCE_NAME --zone YOUR_ZONE
```
Alternativ können Sie die Google Cloud Console aufrufen und auf VM erstellen klicken.
Führen Sie den folgenden Befehl aus, um zu prüfen, ob die Instanz entsprechend beschriftet ist:
```
gcloud compute instances describe YOUR_INSTANCE_NAME \
    --zone YOUR_ZONE \
    --format 'value(labels)'
```
Sie sollten ein Label mit dem Format creator=YOURNAMEYOUR_DOMAIN sehen.

Bereinigen

Damit Ihrem Google Cloud-Konto die in dieser Anleitung verwendeten Ressourcen nicht in Rechnung gestellt werden, löschen Sie entweder das Projekt, das die Ressourcen enthält, oder Sie behalten das Projekt und löschen die einzelnen Ressourcen.

Projekt löschen

Am einfachsten vermeiden Sie weitere Kosten, wenn Sie das zum Ausführen der Anleitung erstellte Projekt löschen.

So löschen Sie das Projekt:

Achtung: Das Löschen von Projekten hat folgende Auswirkungen:

Alle Inhalte des Projekts werden gelöscht. Wenn Sie für die Aufgaben in diesem Dokument ein bereits bestehendes Projekt verwendet haben und dieses löschen, werden auch alle anderen im Rahmen des Projekts erstellten Daten gelöscht.
Benutzerdefinierte Projekt-IDs gehen verloren. Beim Erstellen dieses Projekts haben Sie möglicherweise eine benutzerdefinierte Projekt-ID erstellt, die Sie weiterhin verwenden möchten. Damit die URLs, die die Projekt-ID nutzen, z. B. eine appspot.com-URL, erhalten bleiben, sollten Sie ausgewählte Ressourcen innerhalb des Projekts löschen, statt das gesamte Projekt.

Wenn Sie mehrere Architekturen, Anleitungen und Kurzanleitungen durcharbeiten möchten, können Sie die Überschreitung von Projektkontingenten verhindern, indem Sie Projekte wiederverwenden.

Wechseln Sie in der Google Cloud Console zur Seite Ressourcen verwalten.
Zur Seite „Ressourcen verwalten“
Wählen Sie in der Projektliste das Projekt aus, das Sie löschen möchten, und klicken Sie dann auf Löschen.
Geben Sie im Dialogfeld die Projekt-ID ein und klicken Sie auf Shut down (Beenden), um das Projekt zu löschen.

Cloud Functions-Funktion löschen

Durch das Löschen von Cloud Functions-Funktionen werden keine in Cloud Storage gespeicherten Ressourcen entfernt.

Führen Sie den folgenden Befehl aus, um die in dieser Anleitung erstellte Cloud Functions-Funktion zu löschen:

Node.js

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

Python

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

Einfach loslegen (Go)

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

Java

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

Sie können Cloud Functions-Funktionen auch über die Google Cloud Console löschen.

Compute Engine-VM-Instanz löschen

Führen Sie den folgenden Befehl aus, um die in dieser Anleitung erstellte Compute Engine-VM-Instanz zu löschen:

gcloud compute instances delete YOUR_INSTANCE_NAME --zone YOUR_ZONE