Ergebnisbenachrichtigungen einrichten

>

Aktivieren Sie die Benachrichtigungsfunktion die Security Command Center API. Benachrichtigungen senden Informationen an ein Pub/Sub-Thema, um innerhalb von Minuten aktuelle und neue Ergebnisse bereitzustellen. Da das Security Command Center auf Organisationsebene funktioniert, enthalten die Benachrichtigungen der Security Command Center API alle im Dashboard von Security Command Center angezeigten Ergebnisdetails.

Sie können Pub/Sub-Benachrichtigungen des Security Command Center direkt mit Cloud Functions-Aktionen verbinden. Beispiel: Sicherheitsfunktionen, die bei Reaktion, Anreicherung und Problembehebung helfen, finden Sie in der Beispiel-App für Benachrichtigungen der Security Command Center-Tools.

Hinweis

  • Sie benötigen die IAM-Rolle Security Center Admin, um Security Command Center API-Benachrichtigungen zu aktivieren.
  • Für den Zugriff auf das Security Command Center-Dashboard benötigen Sie die IAM-Rolle Security Center Admin Viewer.
  • Um dem Benachrichtigungsdienstkonto oder dem gcloud-Tool-Konto geeignete Rollen zuzuweisen, benötigen Sie die IAM-Rolle Organisationsadministrator.

Hier erhalten Sie weitere Informationen zu den Security Command Center-Rollen.

Security Command Center API-Benachrichtigungen einrichten

Aktivieren Sie zum Einrichten von Benachrichtigungen der Security Command Center API.

Security Command Center API aktivieren

So aktivieren Sie das Security Command Center API:

  1. Wechseln Sie in der Cloud Console zur Seite API-Bibliothek.
    Zur Seite API-Bibliothek
  2. Wählen Sie das Projekt aus, für das Sie die Benachrichtigungs-API aktivieren möchten.
  3. Geben Sie im Feld Suchen Security Command Center ein und klicken Sie dann in den Suchergebnissen auf Security Command Center.
  4. Klicken Sie auf der angezeigten API-Seite auf Aktivieren.

Die Security Command Center API ist jetzt für Ihr Projekt aktiviert. Als Nächstes verwenden Sie das gcloud-Tool oder die Clientbibliotheken, um ein Pub/Sub-Thema zu abonnieren und Berechtigungen einzurichten.

Pub/Sub-Thema einrichten

In diesem Schritt erstellen und abonnieren Sie das Pub/Sub-Thema, an das Sie Benachrichtigungen senden möchten. Wenn Sie die API nicht programmatisch aufrufen müssen, werden die Befehle des gcloud-Tools empfohlen, da die Einrichtung einfacher ist.

gcloud

So richten Sie die Benachrichtigungsfunktion der Security Command Center API mit dem gcloud-Tool ein:

  1. Pub/Sub-Thema und -Abo einrichten.
  2. Kontoberechtigungen für das gcloud-Tool einrichten.

Schritt 1: Pub/Sub einrichten

So richten Sie ein Pub/Sub-Thema ein und abonnieren es:

  1. Gehen Sie zur Google Cloud Console.
    Google Cloud Console aufrufen
  2. Wählen Sie das Projekt aus, für das Sie die Security Command Center API aktiviert haben.
  3. Klicken Sie auf Cloud Shell aktivieren.

  4. Erstellen Sie ein neues Thema oder verwenden Sie ein vorhandenes Thema. So erstellen Sie ein neues Thema:

       gcloud pubsub topics create topic-id

  5. Legen Sie Umgebungsvariablen fest:

    1. Legen Sie die Themen-ID fest:

        export TOPIC_ID=topic-id

  6. Erstellen Sie ein Abo für das Thema:

       gcloud pubsub subscriptions create subscription-id --topic topic-id

Weitere Informationen zum Einrichten von Pub/Sub finden Sie unter Themen und Abos verwalten. Als Nächstes richten Sie Berechtigungen für Ihr Konto ein.

Schritt 2: Kontoberechtigungen für das gcloud-Tool einrichten

Zum Erstellen einer NotificationConfig benötigen Sie für das Konto des Tools gcloud folgende IAM-Rollen (Identity and Access Management).

  • roles/securitycenter.admin oder roles/securitycenter.notificationConfigEditor
  • roles/pubsub.admin des Pub/Sub-Themas, das Benachrichtigungen erhält

So erteilen Sie diese Berechtigungen:

  1. Gehen Sie zur Google Cloud Console.
    Google Cloud Console aufrufen
  2. Wählen Sie das Projekt aus, für das Sie die Security Command Center API aktiviert haben.

  3. Klicken Sie auf Cloud Shell aktivieren.

    1. Geben Sie den Namen Ihrer Organisation ein:

        export ORGANIZATION_ID=organization-id

    2. Bestimmen Sie die Projekt-ID für das Projekt, zu dem das Pub/Sub-Thema gehört:

        export PUBSUB_PROJECT=project-id

    3. Bestimmen Sie das von Ihnen verwendete gcloud-Toolkonto:

        export GCLOUD_ACCOUNT=your-username@email.com

    4. Legen Sie die Themen-ID fest oder verwenden Sie das Themenset aus Schritt 1.

        export TOPIC_ID=topic-id

    5. Gewähren Sie dem gcloud-Tool-Konto eine Pub/Sub-Rolle mit der Berechtigung pubsub.topics.setIamPolicy:

        gcloud pubsub topics add-iam-policy-binding \
    projects/$PUBSUB_PROJECT/topics/$TOPIC_ID \
    --member="user:$GCLOUD_ACCOUNT" \
    --role='roles/pubsub.admin'

    6. Weisen Sie dem gcloud-Tool eine Rolle für die Organisation zu, die alle Berechtigungen vom Typ securitycenter.notification enthält, z. B. roles/securitycenter.notificationConfigEditor oder roles/securitycenter.admin.

        gcloud organizations add-iam-policy-binding $ORGANIZATION_ID \
    --member="user:$GCLOUD_ACCOUNT" \
    --role='role-name'

Als Nächstes erstellen Sie eine NotificationConfig.

Clientbibliotheken

So richten Sie die Benachrichtigungsfunktion der Security Command Center API mithilfe der Clientbibliotheken ein:

  1. Dienstkonto einrichten.
  2. API-Clientbibliotheken herunterladen.
  3. Entwicklungsumgebung einrichten.
  4. Pub/Sub-Thema und -Abo einrichten.

Schritt 1: Dienstkonto einrichten

Das Benachrichtigungsfeature der Security Command Center API verwendet ein Dienstkonto mit den entsprechenden Berechtigungen zum Konfigurieren von Benachrichtigungen. Dieses Dienstkonto wird nur für die anfängliche Einrichtung einer Konfiguration verwendet und kann später verwendet werden, um weitere Benachrichtigungskonfigurationen zu erstellen. Dieses Dienstkonto ist unabhängig von dem Dienstkonto, das beim Einrichten des Security Command Center für Sie erstellt wurde.

So erstellen Sie ein Dienstkonto:

  1. Gehen Sie zur Google Cloud Console.
    Google Cloud Console aufrufen
  2. Wählen Sie das Projekt aus, für das Sie die Security Command Center API aktiviert haben.
  3. Klicken Sie auf Cloud Shell aktivieren.

  4. Legen Sie Umgebungsvariablen fest:

    1. Geben Sie den Namen Ihrer Organisation ein:

        export ORGANIZATION_ID=organization-id

    2. Legen Sie die Projekt-ID für das Projekt fest, in dem Sie das Benachrichtigungs-API aktivieren möchten:

        export PROJECT_ID=project-id

    3. Legen Sie die benutzerdefinierte ID fest, die Sie für das neue Dienstkonto verwenden möchten, z. B. scc-notifications. Der Name des Dienstkontos muss zwischen 6 und 30 Zeichen lang sein, mit einem Buchstaben beginnen und darf nur alphanumerische Zeichen in Kleinschreibung sowie Bindestriche enthalten:

        export SERVICE_ACCOUNT=custom-id

    4. Legen Sie den Pfad fest, unter dem der Dienstkontoschlüssel gespeichert werden soll, z. B. export KEY_LOCATION=/home/$USER/mykeys/$SERVICE_ACCOUNT.json:

        export KEY_LOCATION=full-key-location-path
  # This is used by client libraries to find the key
  export GOOGLE_APPLICATION_CREDENTIALS=$KEY_LOCATION

  5. Erstellen Sie ein Ihrer Projekt-ID zugeordnetes Dienstkonto:

       gcloud iam service-accounts create $SERVICE_ACCOUNT  --display-name \
    "Service Account for [USER]"  --project $PROJECT_ID

  6. Erstellen Sie einen Schlüssel zur Verknüpfung mit dem Dienstkonto. Der Schlüssel wird beim Erstellen einer NotificationConfig verwendet und dauerhaft unter dem KEY_LOCATION gespeichert, den Sie in den vorherigen Schritten angegeben haben.

       gcloud iam service-accounts keys create $KEY_LOCATION  --iam-account \
    $SERVICE_ACCOUNT@$PROJECT_ID.iam.gserviceaccount.com

  7. Gewähren Sie dem Dienstkonto eine Rolle für die Organisation, die alle securitycenter.notification-Berechtigungen enthält, z. B. roles/securitycenter.notificationConfigEditor oder roles/securitycenter.admin.

       gcloud beta organizations add-iam-policy-binding $ORGANIZATION_ID \
     --member="serviceAccount:$SERVICE_ACCOUNT@$PROJECT_ID.iam.gserviceaccount.com" \
     --role='role-name'

Das Dienstkonto ist nun für die Verwendung mit Benachrichtigungen eingerichtet. Der Dienstkontoschlüssel wird unter der von Ihnen angegebenen KEY_LOCATION gespeichert. Weitere Informationen zu Dienstkonten finden Sie unter Dienstkontoschlüssel erstellen und verwalten.

Schritt 2: Entwicklungsumgebung einrichten

Sie können das gcloud-Tool verwenden, um Benachrichtigungen der Security Command Center API zu verwenden, oder die Clientbibliotheken herunterladen und Ihre Entwicklungsumgebung für die Sprache Ihrer Wahl einrichten.

Python

  1. Optional: Bevor Sie die Python-Bibliothek installieren, empfehlen wir Ihnen, mit Virtualenv eine isolierte Python-Umgebung zu erstellen.

     virtualenv your-env
 source your-env/bin/activate

  2. Installieren Sie pip, um die Installation der Python-Bibliothek zu verwalten.

  3. Führen Sie folgende Befehle aus, um die Python-Bibliothek zu installieren:

     pip install google-cloud-securitycenter

Java

Wenn Sie die Java-Bibliothek von Security Command Center als Abhängigkeit in Ihr Projekt aufnehmen möchten, wählen Sie ein Artefakt aus dem Maven-Repository aus. Benachrichtigungen sind in der Bibliothek ab Version 0.119.0 der Bibliothek enthalten.

Wenn Sie Intellij verwenden, legen Sie für die Umgebungsvariable GOOGLE_APPLICATION_CREDENTIALS den absoluten Pfad des Dienstkontoschlüssels für Benachrichtigungen fest, den Sie in den vorherigen Schritten heruntergeladen haben:

  1. Klicken Sie in Intellij auf Ausführen > Konfigurationen bearbeiten.

  2. Bestimmen Sie folgende Variable unter Anwendung > Run_Configuration_For_Sample > Umgebungsvariablen:

      GOOGLE_APPLICATION_CREDENTIALS=absolute-path-to-service-account-key

Go

Führen Sie den folgenden Befehl aus, um API Go-Abhängigkeiten zu installieren:

So laden Sie die Go-Bibliothek herunter:

  go get -u cloud.google.com/go/securitycenter/apiv1

Node.js

Verwenden Sie im Projektordner npm, um alle erforderlichen Abhängigkeiten der Benachrichtigungs-API zu installieren:

  npm install --save @google-cloud/security-center/

Schritt 3: Pub/Sub einrichten

Wenn Sie Benachrichtigungen an Pub/Sub senden möchten, abonnieren Sie ein Pub/Sub-Thema und weisen Sie dem Benachrichtigungsdienstkonto eine IAM-Rolle mit der Berechtigung pubsub.topics.setIamPolicy zu:

  1. Erstellen Sie ein neues Thema oder verwenden Sie ein vorhandenes Thema. So erstellen Sie ein neues Thema:

       gcloud pubsub topics create topic-id

  2. Legen Sie Umgebungsvariablen fest:

    1. Legen Sie die Themen-ID fest:

        export TOPIC_ID=topic-id

    2. Legen Sie die Projekt-ID für das Projekt fest, in dem Sie die Benachrichtigungs-API aktiviert haben:

        export CONSUMER_PROJECT=project-id

    3. Legen Sie die E-Mail-Adresse des Dienstkontos fest, das Sie in den vorherigen Schritten erstellt haben:

        export SERVICE_ACCOUNT_EMAIL=service-account-name@$CONSUMER_PROJECT.iam.gserviceaccount.com

  3. Erstellen Sie ein Abo für das Thema:

       gcloud pubsub subscriptions create subscription-id --topic topic-id

  4. Gewähren Sie dem Benachrichtigungsdienstkonto eine Rolle mit dem Berechtigungs-pubsub.topics.setIamPolicy:

       gcloud pubsub topics add-iam-policy-binding \
     projects/$CONSUMER_PROJECT/topics/$TOPIC_ID \
     --member="serviceAccount:$SERVICE_ACCOUNT_EMAIL" \
     --role='roles/pubsub.admin'

Weitere Informationen zum Einrichten von Pub/Sub finden Sie unter Themen und Abos verwalten. Im nächsten Schritt schließen Sie die Einrichtung ab, indem Sie eine NotificationConfig erstellen.

NotificationConfig erstellen

Beachten Sie vor dem Erstellen eines NotificationConfig Folgendes:

  • Jede Organisation kann maximal eine begrenzte Anzahl von NotificationConfig-Dateien haben. Weitere Informationen finden Sie unter Kontingente und Beschränkungen.
  • Sie benötigen die IAM-Rolle Organisationsadministrator, um dem Benachrichtigungsdienstkonto oder dem gcloud-Toolkonto die entsprechenden Rollen zuzuweisen.

Das Feld NotificationConfig enthält ein Feld filter, das Benachrichtigungen auf nützliche Ereignisse beschränkt. In diesem Feld werden alle Filter akzeptiert, die in der Methode findings.list der Security Command Center API verfügbar sind.

So weisen Sie dem Konto mithilfe des gcloud-Befehlszeilentools die IAM-Rolle Sicherheitscenter-Benachrichtigungskonfigurationsbearbeiter zu:

  1. Legen Sie Umgebungsvariablen fest:

    1. Geben Sie den Namen Ihrer Organisation ein:

        export ORGANIZATION_ID=organization-id

    2. Geben Sie die E-Mail-Adresse des Dienstkontos an, das Sie beim Einrichten von Benachrichtigungen erstellt haben, oder das Konto, das Sie zum Ausführen von gcloud-Toolbefehlen verwenden:

      • Legen Sie die E-Mail-Adresse für das Konto fest, mit dem gcloud-Tool-Befehle ausgeführt werden:

        export EMAIL=your-username@email.com

      • Oder legen Sie die E-Mail-Adresse des Dienstkontos fest:

        export EMAIL=service-account-name@$CONSUMER_PROJECT.iam.gserviceaccount.com

  2. Weisen Sie dem Dienstkonto oder dem Konto, das Sie mit gcloud-Toolbefehlen verwendet haben, die erforderliche Rolle zu:

    • Weisen Sie die Rolle dem Konto zu, mit dem die Befehle des gcloud-Tools ausgeführt werden:

         gcloud organizations add-iam-policy-binding \
     $ORGANIZATION_ID \
     --member="user:$EMAIL" \
     --role='roles/securitycenter.notificationConfigEditor'
     ```

    • Oder weisen Sie dem Dienstkonto die Rolle zu:

         gcloud organizations add-iam-policy-binding \
     $ORGANIZATION_ID \
     --member="serviceAccount:$EMAIL" \
     --role='roles/securitycenter.notificationConfigEditor'
     ```

Nachdem Sie dem Dienstkonto oder dem gcloud-Toolkonto Berechtigungen erteilt haben, erstellen Sie NotificationConfig mit der gewünschten Programmiersprache oder Plattform:

gcloud

  # The numeric ID of the organization
  ORGANIZATION_ID=organization-id

  # The topic to which the notifications are published
  PUBSUB_TOPIC="projects/project-id/topics/topic-id"

  # The description for the NotificationConfig
  DESCRIPTION="Notifies for active findings"

  # Filters for active findings
  FILTER="state=\"ACTIVE\""

  gcloud scc notifications create notification-name \
    --organization "$ORGANIZATION_ID" \
    --description "$DESCRIPTION" \
    --pubsub-topic $PUBSUB_TOPIC \
    --filter "$FILTER"

Python

from google.cloud import securitycenter as securitycenter

client = securitycenter.SecurityCenterClient()

# TODO: organization_id = "your-org-id"
# TODO: notification_config_id = "your-config-id"
# TODO: pubsub_topic = "projects/{your-project-id}/topics/{your-topic-ic}"
# Ensure this ServiceAccount has the "pubsub.topics.setIamPolicy" permission on the new topic.

org_name = "organizations/{org_id}".format(org_id=organization_id)

created_notification_config = client.create_notification_config(
    org_name,
    notification_config_id,
    {
        "description": "Notification for active findings",
        "pubsub_topic": pubsub_topic,
        "streaming_config": {"filter": 'state = "ACTIVE"'},
    },
)

print(created_notification_config)

Java

import com.google.cloud.securitycenter.v1.CreateNotificationConfigRequest;
import com.google.cloud.securitycenter.v1.NotificationConfig;
import com.google.cloud.securitycenter.v1.NotificationConfig.StreamingConfig;
import com.google.cloud.securitycenter.v1.SecurityCenterClient;
import java.io.IOException;
  public static NotificationConfig createNotificationConfig(
      String organizationId, String notificationConfigId, String projectId, String topicName)
      throws IOException {
    // String organizationId = "{your-org-id}";
    // String notificationConfigId = {"your-unique-id"};
    // String projectId = "{your-project}"";
    // String topicName = "{your-topic}";

    String orgName = String.format("organizations/%s", organizationId);

    // Ensure this ServiceAccount has the "pubsub.topics.setIamPolicy" permission on the topic.
    String pubsubTopic = String.format("projects/%s/topics/%s", projectId, topicName);

    try (SecurityCenterClient client = SecurityCenterClient.create()) {
      CreateNotificationConfigRequest request =
          CreateNotificationConfigRequest.newBuilder()
              .setParent(orgName)
              .setConfigId(notificationConfigId)
              .setNotificationConfig(
                  NotificationConfig.newBuilder()
                      .setDescription("Java notification config")
                      .setPubsubTopic(pubsubTopic)
                      .setStreamingConfig(
                          StreamingConfig.newBuilder().setFilter("state = \"ACTIVE\"").build())
                      .build())
              .build();

      NotificationConfig response = client.createNotificationConfig(request);
      System.out.println(String.format("Notification config was created: %s", response));
      return response;
    }
  }

Go

import (
	"context"
	"fmt"
	"io"

	securitycenter "cloud.google.com/go/securitycenter/apiv1"
	securitycenterpb "google.golang.org/genproto/googleapis/cloud/securitycenter/v1"
)

func createNotificationConfig(w io.Writer, orgID string, pubsubTopic string, notificationConfigID string) error {
	// orgID := "your-org-id"
	// pubsubTopic := "projects/{your-project}/topics/{your-topic}"
	// notificationConfigID := "your-config-id"

	ctx := context.Background()
	client, err := securitycenter.NewClient(ctx)

	if err != nil {
		return fmt.Errorf("securitycenter.NewClient: %v", err)
	}
	defer client.Close()

	req := &securitycenterpb.CreateNotificationConfigRequest{
		Parent:   fmt.Sprintf("organizations/%s", orgID),
		ConfigId: notificationConfigID,
		NotificationConfig: &securitycenterpb.NotificationConfig{
			Description: "Go sample config",
			PubsubTopic: pubsubTopic,
			NotifyConfig: &securitycenterpb.NotificationConfig_StreamingConfig_{
				StreamingConfig: &securitycenterpb.NotificationConfig_StreamingConfig{
					Filter: `state = "ACTIVE"`,
				},
			},
		},
	}

	notificationConfig, err := client.CreateNotificationConfig(ctx, req)
	if err != nil {
		return fmt.Errorf("Failed to create notification config: %v", err)
	}
	fmt.Fprintln(w, "New NotificationConfig created: ", notificationConfig)

	return nil
}

Node.js

// npm install @google-cloud/security-center/
const {SecurityCenterClient} = require('@google-cloud/security-center');

const client = new SecurityCenterClient();

// organizationId = "your-org-id";
// configId = "your-config-name";
// pubsubTopic = "projects/{your-project}/topics/{your-topic}";
// Ensure this Service Account has the "pubsub.topics.setIamPolicy" permission on this topic.

const orgName = client.organizationPath(organizationId);

async function createNotificationConfig() {
  const [response] = await client.createNotificationConfig({
    parent: orgName,
    configId: configId,
    notificationConfig: {
      description: 'Sample config for node.js',
      pubsubTopic: pubsubTopic,
      streamingConfig: {filter: 'state = "ACTIVE"'},
    },
  });
  console.log('Notification config creation succeeded: ', response);
}

createNotificationConfig();

PHP

use Google\Cloud\SecurityCenter\V1\SecurityCenterClient;
use Google\Cloud\SecurityCenter\V1\NotificationConfig;
use Google\Cloud\SecurityCenter\V1\NotificationConfig\StreamingConfig;

/** Uncomment and populate these variables in your code */
// $organizationId = "{your-org-id}";
// $notificationConfigId = {"your-unique-id"};
// $projectId = "{your-project}"";
// $topicName = "{your-topic}";

$securityCenterClient = new SecurityCenterClient();
$organizationName = $securityCenterClient::organizationName($organizationId);
$pubsubTopic = $securityCenterClient::topicName($projectId, $topicName);

$streamingConfig = (new StreamingConfig())->setFilter("state = \"ACTIVE\"");
$notificationConfig = (new NotificationConfig())
    ->setDescription('A sample notification config')
    ->setPubsubTopic($pubsubTopic)
    ->setStreamingConfig($streamingConfig);

$response = $securityCenterClient->createNotificationConfig(
    $organizationName,
    $notificationConfigId,
    $notificationConfig
);
printf('Notification config was created: %s' . PHP_EOL, $response->getName());

Ruby

require "google/cloud/security_center"

# Your organization id. e.g. for "organizations/123", this would be "123".
# org_id = "YOUR_ORGANZATION_ID"

# Your notification config id. e.g. for
# "organizations/123/notificationConfigs/my-config" this would be "my-config".
# config_id = "YOUR_CONFIG_ID"

# The PubSub topic where notifications will be published.
# pubsub_topic = "YOUR_TOPIC"

client = Google::Cloud::SecurityCenter.security_center

org_path = client.organization_path organization: org_id

notification_config = {
  description:      "Sample config for Ruby",
  pubsub_topic:     pubsub_topic,
  streaming_config: { filter: 'state = "ACTIVE"' }
}

response = client.create_notification_config(
  parent:              org_path,
  config_id:           config_id,
  notification_config: notification_config
)
puts "Created notification config #{config_id}: #{response}."

C#


using Google.Api.Gax.ResourceNames;
using Google.Cloud.SecurityCenter.V1;
using System;

///<summary> Create NotificationConfig Snippet. </summary>
public class CreateNotificationConfigSnippets
{
    public static NotificationConfig CreateNotificationConfig(
        string organizationId, string notificationConfigId, string projectId, string topicName)
    {
        OrganizationName orgName = new OrganizationName(organizationId);
        TopicName pubsubTopic = new TopicName(projectId, topicName);

        SecurityCenterClient client = SecurityCenterClient.Create();
        CreateNotificationConfigRequest request = new CreateNotificationConfigRequest
        {
            ParentAsOrganizationName = orgName,
            ConfigId = notificationConfigId,
            NotificationConfig = new NotificationConfig
            {
                Description = ".Net notification config",
                PubsubTopicAsTopicName = pubsubTopic,
                StreamingConfig = new NotificationConfig.Types.StreamingConfig { Filter = "state = \"ACTIVE\"" }
            }
        };

        NotificationConfig response = client.CreateNotificationConfig(request);
        Console.WriteLine($"Notification config was created: {response}");
        return response;
    }
}

Benachrichtigungen werden jetzt in dem von Ihnen angegebenen Pub/Sub-Thema veröffentlicht. Zum Veröffentlichen von Benachrichtigungen verwendet Security Command Center ein Dienstkonto auf Organisationsebene im Format service-org-organization-id@gcp-sa-scc-notification.iam.gserviceaccount.com mit der Rolle securitycenter.notificationServiceAgent. Diese Dienstkontorolle auf Organisationsebene ist erforderlich, damit Benachrichtigungen funktionieren.

In den vorherigen Schritten haben Sie entweder ein Dienstkonto für Benachrichtigungen auf Projektebene im Format service-account-id@project-id.iam.gserviceaccount.com erstellt oder ein Nutzerkonto mit dem gcloud-Tool verwendet. Sie können die Berechtigungen, die Sie diesem Konto gewährt haben, optional widerrufen. Weitere Informationen finden Sie in der IAM-Dokumentation unter Zugriff auf Ressourcen erteilen, ändern und entziehen.

Nächste Schritte