Mit Google Chat, Vertex AI und Apps Script auf Vorfälle reagieren

In diesem Tutorial erfahren Sie, wie Sie eine Google Chat-App erstellen, die in Echtzeit auf Vorfälle reagiert. Bei der Reaktion auf einen Vorfall erstellt und füllt die App einen Chat-Gruppenbereich, erleichtert die Behebung des Vorfalls durch Nachrichten, Slash-Befehle und Dialogfelder und verwendet KI, um die Reaktion auf den Vorfall in einem Google Docs-Dokument zusammenzufassen.

In dieser Anleitung werden Autorisierungsbereiche verwendet, die mit https://www.googleapis.com/auth/chat.app.* beginnen. Damit die Chat App diese Bereiche verwenden kann, müssen Sie eine einmalige Administratorgenehmigung einholen.

Ein Vorfall ist ein Ereignis, das sofortige Aufmerksamkeit eines Teams erfordert, um es zu beheben. Beispiele für Vorfälle:

  • In einer CRM-Plattform (Customer-Relationship-Management) wird ein zeitkritischer Fall erstellt, für den ein Serviceteam zusammenarbeiten muss, um eine Lösung zu finden.
  • Ein System geht offline und benachrichtigt eine Gruppe von Site Reliability Engineers (SREs), damit sie zusammenarbeiten können, um es wieder online zu bringen.
  • Ein Erdbeben mit hoher Magnitude ereignet sich und Einsatzkräfte müssen ihre Reaktion koordinieren.

In dieser Anleitung beginnt die Vorfallbenachrichtigung, wenn jemand den Vorfall durch Klicken auf eine Schaltfläche auf einer Webseite meldet. Auf der Webseite wird ein Vorfall simuliert, indem Nutzer aufgefordert werden, grundlegende Vorfallinformationen einzugeben: Titel, Beschreibung und E‑Mail-Adressen der Reaktionspersonen.

So sieht die Chat-App für die Vorfallverwaltung in Aktion aus:

  • Die Website, auf der ein Vorfall beginnt.
    Abbildung 1: Die Website, auf der Nutzer einen Vorfall melden können.
  • Benachrichtigung, dass der Chatbereich für den Vorfall erstellt wurde.
    Abbildung 2: Benachrichtigung, dass der Chatbereich für den Vorfall erstellt wurde.
  • Der Chatbereich für die Reaktion auf Vorfälle.
    Abbildung 3: Der Chat-Bereich für die Reaktion auf Vorfälle.
  • Den Vorfall mit einem Slash-Befehl beheben.
    Abbildung 4: Den Vorfall mit einem Slash-Befehl beheben.
  • Dialogfeld zur Behebung von Vorfällen.
    Abbildung 5. Dialogfeld zur Behebung von Vorfällen.
  • Google Docs-Dokument zur Behebung von Vorfällen, das im Gruppenbereich freigegeben wurde.
    Abbildung 6. Google Docs-Dokument zur Problembehebung, das im Gruppenbereich geteilt wurde.
  • Google-Dokument zur Behebung von Vorfällen im Zusammenhang mit KI-Zusammenfassungen.
    Abbildung 7. Das Google Docs-Dokument zur Behebung von Vorfällen mit KI-Zusammenfassungen.

Vorbereitung

Wenn Sie eine dieser Voraussetzungen für Ihre Organisation aktivieren müssen, bitten Sie Ihren Google Workspace-Administrator, sie zu aktivieren:

  • Ein Google Workspace-Konto für Unternehmen mit Zugriff auf Google Chat.
  • Die Verzeichnisfreigabe (Kontaktfreigabe) muss für Google Workspace aktiviert sein. Die Incident-App verwendet das Verzeichnis, um die Kontaktdaten der Einsatzkräfte wie Name und E-Mail-Adresse nachzuschlagen. Die Reaktionskräfte müssen Nutzer mit einem Google Chat-Konto in Ihrer Google Workspace-Organisation sein.

Ziele

  • Erstellen Sie eine Chat-App, die auf Vorfälle reagiert.
  • So können Sie Nutzern helfen, auf Vorfälle zu reagieren:
    • Arbeitsbereiche für die Reaktion auf Vorfälle erstellen.
    • Nachrichten mit Zusammenfassungen von Vorfällen und Reaktionen posten.
    • Zusammenarbeit mit interaktiven Chat-App-Funktionen unterstützen
  • Gespräche und Lösungen mit Vertex AI zusammenfassen

Architektur

Das folgende Diagramm zeigt die Architektur der Google Workspace- und Google Cloud-Ressourcen, die von der Google Chat-App für die Reaktion auf Vorfälle verwendet werden.

Architektur der Google Chat App für die Reaktion auf Vorfälle

Die Architektur zeigt, wie die Google Chat-App zur Reaktion auf Vorfälle einen Vorfall und eine Lösung verarbeitet.

  1. Ein Nutzer startet einen Vorfall über eine externe Website, die auf Apps Script gehostet wird.

  2. Die Website sendet eine asynchrone HTTP-Anfrage an die Google Chat-App, die ebenfalls in Apps Script gehostet wird.

  3. Die Google Chat App zur Reaktion bei Vorfällen verarbeitet die Anfrage:

    1. Der Apps Script Admin SDK-Dienst ruft Informationen zu Teammitgliedern ab, z. B. Nutzer-ID und E-Mail-Adresse.

    2. Mit einer Reihe von HTTP-Anfragen an die Chat API über den erweiterten Chat-Dienst von Apps Script erstellt die Google Chat-App zur Reaktion auf Vorfälle einen Chat-Gruppenbereich für Vorfälle, fügt Teammitglieder hinzu und sendet eine Nachricht an den Gruppenbereich.

  4. Teammitglieder besprechen den Vorfall im Chatbereich.

  5. Ein Teammitglied ruft einen Slash-Befehl auf, um eine Lösung für den Vorfall zu signalisieren.

    1. Ein HTTP-Aufruf der Chat API mit dem erweiterten Chat-Dienst von Apps Script listet alle Nachrichten des Chat-Gruppenbereichs auf.

    2. Vertex AI empfängt die aufgeführten Nachrichten und generiert eine Zusammenfassung.

    3. Der Apps Script-Dienst DocumentApp erstellt ein Google-Dokument und fügt dem Dokument die Zusammenfassung von Vertex AI hinzu.

    4. Die Google Chat-App für die Reaktion auf Vorfälle ruft die Chat API auf, um eine Nachricht mit einem Link zum Zusammenfassungsdokument in Google Docs zu senden.

Umgebung vorbereiten

In diesem Abschnitt wird beschrieben, wie Sie ein Google Cloud-Projekt für die Chat-App erstellen und konfigurieren.

Google Cloud-Projekt erstellen

Google Cloud Console

  1. Klicken Sie in der Google Cloud Console auf das Menü  > IAM & Verwaltung > Projekt erstellen.

    Zur Seite „Projekt erstellen“

  2. Geben Sie im Feld Projektname einen aussagekräftigen Namen für Ihr Projekt ein.

    Optional: Wenn Sie die Projekt-ID bearbeiten möchten, klicken Sie auf Bearbeiten. Die Projekt-ID kann nach dem Erstellen des Projekts nicht mehr geändert werden. Wählen Sie also eine ID aus, die während der gesamten Dauer des Projekts den Anforderungen entspricht.

  3. Klicken Sie im Feld Speicherort auf Durchsuchen, um mögliche Speicherorte für Ihr Projekt aufzurufen. Klicken Sie danach auf Auswählen.
  4. Klicken Sie auf Erstellen. In der Google Cloud Console wird die Seite „Dashboard“ aufgerufen und Ihr Projekt wird innerhalb weniger Minuten erstellt.

gcloud-CLI

Greifen Sie in einer der folgenden Entwicklungsumgebungen auf die Google Cloud CLI (gcloud) zu:

  • Cloud Shell: Aktivieren Sie Cloud Shell, um ein Onlineterminal mit der bereits eingerichteten gcloud CLI zu verwenden.
    Cloud Shell aktivieren
  • Lokale Shell: Zur Verwendung einer lokalen Entwicklungsumgebung müssen Sie die gcloud CLI installieren und initialisieren.
    Verwenden Sie zum Erstellen eines Cloud-Projekts den Befehl gcloud projects create: 
    gcloud projects create PROJECT_ID
     Ersetzen Sie PROJECT_ID durch die ID des Projekts, das Sie erstellen möchten.

Abrechnung für das Cloud-Projekt aktivieren

Google Cloud Console

  1. Rufen Sie in der Google Cloud Console die Seite Abrechnung auf. Klicken Sie auf das Menü > Abrechnung > Meine Projekte.

    Zur Abrechnung für meine Projekte

  2. Wählen Sie unter Organisation auswählen die Organisation aus, die mit Ihrem Google Cloud-Projekt verknüpft ist.
  3. Öffnen Sie in der Projektzeile das Menü Aktionen (), klicken Sie auf Abrechnung ändern und wählen Sie das Cloud Billing-Konto aus.
  4. Klicken Sie auf Konto festlegen.

gcloud-CLI

  1. Führen Sie folgenden Befehl aus, um verfügbare Rechnungskonten aufzulisten: 
    gcloud billing accounts list
  2. Rechnungskonto mit einem Google Cloud-Projekt verknüpfen: 
    gcloud billing projects link PROJECT_ID --billing-account=BILLING_ACCOUNT_ID

    Ersetzen Sie Folgendes:

    • PROJECT_ID ist die Projekt-ID für das Cloud-Projekt, für das Sie die Abrechnung aktivieren möchten.
    • BILLING_ACCOUNT_ID ist die Rechnungskonto-ID, die mit dem Google Cloud-Projekt verknüpft werden soll.

APIs aktivieren

Google Cloud Console

  1. Aktivieren Sie in der Google Cloud Console die Google Chat API, die Google Docs API, die Admin SDK API, das Google Workspace Marketplace SDK und die Vertex AI API.

    APIs aktivieren

  2. Bestätigen Sie, dass Sie die APIs im richtigen Cloud-Projekt aktivieren, und klicken Sie dann auf Weiter.

  3. Prüfen Sie, ob Sie die richtigen APIs aktivieren, und klicken Sie dann auf Aktivieren.

gcloud-CLI

  1. Legen Sie gegebenenfalls das aktuelle Cloud-Projekt auf das Projekt fest, das Sie mit dem gcloud config set project-Befehl erstellt haben:

    gcloud config set project PROJECT_ID

    Ersetzen Sie PROJECT_ID durch die Projekt-ID des von Ihnen erstellten Cloud-Projekts.

  2. Aktivieren Sie die Google Chat API, Google Docs API, Admin SDK API, Google Workspace Marketplace SDK und Vertex AI API mit dem Befehl gcloud services enable:

    gcloud services enable chat.googleapis.com docs.googleapis.com admin.googleapis.com aiplatform.googleapis.com appsmarket-component.googleapis.com

Authentifizierung und Autorisierung einrichten

Die Chat-App greift mit den Anmeldedaten der Chat-App auf die Google Chat API zu. Die App greift mit Nutzeranmeldedaten auf die Admin SDK API und die Google Docs API zu.

Nutzerauthentifizierung und ‑autorisierung einrichten

Durch die Authentifizierung und Autorisierung kann die Chat-App auf Ressourcen in Google Workspace und Google Cloud zugreifen, um eine Reaktion auf einen Vorfall zu verarbeiten. Insbesondere wird die Nutzerauthentifizierung verwendet, um die Google Docs API und die Admin SDK API aufzurufen.

In diesem Tutorial veröffentlichen Sie die App intern in Ihrer Workspace-Domain. Daher ist es in Ordnung, Platzhalterinformationen zu verwenden. Bevor Sie die App extern veröffentlichen, müssen Sie die Platzhalterinformationen auf dem Einwilligungsbildschirm durch echte Informationen ersetzen.

  1. Rufen Sie in der Google Cloud Console das Menü  > ;> Branding auf.

    Zu Branding

  2. Wenn Sie diebereits konfiguriert haben, können Sie die folgenden Einstellungen für den OAuth-Zustimmungsbildschirm unter Branding, Zielgruppe und Datenzugriff konfigurieren. Wenn Sie die Meldung noch nicht konfiguriert sehen, klicken Sie auf Jetzt starten:

    1. Geben Sie unter App-Informationen bei App-Name Incident Management ein.
    2. Wählen Sie unter E-Mail-Adresse für den Nutzer-Support Ihre E-Mail-Adresse oder eine geeignete Google-Gruppe aus.
    3. Klicken Sie auf Weiter.
    4. Wählen Sie unter Zielgruppe die Option Intern aus. Wenn Sie Intern nicht auswählen können, wählen Sie Extern aus.
    5. Klicken Sie auf Weiter.
    6. Geben Sie unter Kontaktdaten eine E-Mail-Adresse ein, unter der Sie über Änderungen an Ihrem Projekt benachrichtigt werden können.
    7. Klicken Sie auf Weiter.
    8. Sehen Sie sich unter Abschließen die Nutzerdatenrichtlinie für Google API-Dienste an. Wenn Sie damit einverstanden sind, wählen Sie Ich stimme der Nutzerdatenrichtlinie für Google API-Dienste zu aus.
    9. Klicken Sie auf Weiter.
    10. Klicken Sie auf Erstellen.
    11. Wenn Sie Extern als Nutzertyp ausgewählt haben, fügen Sie Testnutzer hinzu:
      1. Klicken Sie auf Zielgruppe.
      2. Klicken Sie unter Testnutzer auf Nutzer hinzufügen.
      3. Geben Sie Ihre E‑Mail-Adresse und die E‑Mail-Adressen aller anderen autorisierten Testnutzer ein und klicken Sie auf Speichern.

  3. Klicken Sie auf Data Access > Add or Remove Scopes (Datenzugriff > Bereiche hinzufügen oder entfernen). Es wird ein Bereich mit einer Liste der Bereiche für jede API angezeigt, die Sie in Ihrem Google Cloud-Projekt aktiviert haben.

    1. Fügen Sie unter Bereiche manuell hinzufügen die folgenden Bereiche ein:

      • https://www.googleapis.com/auth/documents
      • https://www.googleapis.com/auth/admin.directory.user.readonly
      • https://www.googleapis.com/auth/script.external_request
      • https://www.googleapis.com/auth/userinfo.email
      • https://www.googleapis.com/auth/cloud-platform

    2. Klicken Sie auf Zur Tabelle hinzufügen.

    3. Klicken Sie auf Aktualisieren.

    4. Nachdem Sie die für Ihre App erforderlichen Bereiche ausgewählt haben, klicken Sie auf der Seite Datenzugriff auf Speichern.

App-Authentifizierung und ‑Autorisierung einrichten

Die App-Authentifizierung wird verwendet, um die Google Chat API aufzurufen.

Dienstkonto in der Google Cloud Console erstellen

So erstellen Sie ein Dienstkonto:

Google Cloud Console

  1. Rufen Sie in der Google Cloud Console das Menü  > IAM & Verwaltung > Dienstkonten auf.

    Zur Seite „Dienstkonten“

  2. Klicken Sie auf Dienstkonto erstellen.
  3. Geben Sie die Dienstkontodetails ein und klicken Sie dann auf Erstellen und fortfahren.
  4. Optional: Weisen Sie Ihrem Dienstkonto Rollen zu, um Zugriff auf die Ressourcen Ihres Google Cloud-Projekts zu gewähren. Weitere Informationen finden Sie unter Zugriff auf Ressourcen erteilen, ändern und entziehen.
  5. Klicken Sie auf Weiter.
  6. Optional: Geben Sie Nutzer oder Gruppen ein, die dieses Dienstkonto verwalten und Aktionen damit ausführen können. Weitere Informationen finden Sie unter Identitätswechsel von Dienstkonten verwalten.
  7. Klicken Sie auf Fertig. Notieren Sie sich die E-Mail-Adresse des Dienstkontos.

gcloud-CLI

  1. Erstellen Sie das Dienstkonto: 
    gcloud iam service-accounts create SERVICE_ACCOUNT_NAME \
  --display-name="SERVICE_ACCOUNT_NAME"
  2. Optional: Weisen Sie Ihrem Dienstkonto Rollen zu, um Zugriff auf die Ressourcen Ihres Google Cloud-Projekts zu gewähren. Weitere Informationen finden Sie unter Zugriff auf Ressourcen erteilen, ändern und entziehen.

Das Dienstkonto wird auf der Seite mit den Dienstkonten angezeigt. Erstellen Sie als Nächstes einen privaten Schlüssel für das Dienstkonto.

Privaten Schlüssel erstellen

So erstellen und laden Sie einen privaten Schlüssel für das Dienstkonto herunter:

  1. Rufen Sie in der Google Cloud Console das Menü  > IAM & Verwaltung > Dienstkonten auf.

    Zur Seite „Dienstkonten“

  2. Wählen Sie Ihr Dienstkonto aus.
  3. Klicken Sie auf Schlüssel > Schlüssel hinzufügen > Neuen Schlüssel erstellen.
  4. Wählen Sie JSON aus und klicken Sie auf Erstellen.

    Ihr neues öffentliches/privates Schlüsselpaar wird generiert und als neue Datei auf Ihren Computer heruntergeladen. Speichern Sie die heruntergeladene JSON-Datei als credentials.json in Ihrem Arbeitsverzeichnis. Diese Datei ist die einzige Kopie dieses Schlüssels. Informationen dazu, wie Sie den Schlüssel sicher speichern, finden Sie unter Dienstkontoschlüssel verwalten.

  5. Klicken Sie auf Schließen.

Weitere Informationen zu Dienstkonten finden Sie in der Google Cloud IAM-Dokumentation unter Dienstkonten.

Mit Google Workspace Marketplace kompatiblen OAuth-Client erstellen

So erstellen Sie einen mit Google Workspace Marketplace kompatiblen OAuth-Client:

  1. Wechseln Sie in der Google Cloud Console zum Menü  > IAM & Verwaltung > Dienstkonten.

    Zur Seite „Dienstkonten“

  2. Klicken Sie auf das Dienstkonto, das Sie für Ihre Chat-App erstellt haben.

  3. Klicke auf Erweiterte Einstellungen.

  4. Klicken Sie auf Google Workspace Marketplace-kompatiblen OAuth-Client erstellen.

  5. Klicken Sie auf Weiter.

Eine Bestätigungsmeldung wird angezeigt, dass ein mit Google Workspace Marketplace kompatibler OAuth-Client erstellt wurde.

Chat-App erstellen und bereitstellen

Im folgenden Abschnitt kopieren und aktualisieren Sie ein gesamtes Apps Script-Projekt, das den gesamten erforderlichen Anwendungscode für Ihre Chat-App enthält. Sie müssen also nicht jede Datei einzeln kopieren und einfügen.

Einige Funktionen enthalten Unterstriche am Ende ihrer Namen, z. B. processSlashCommand_() aus ChatApp.gs. Der Unterstrich blendet die Funktion auf der Webseite zur Initialisierung von Vorfällen aus, wenn sie in einem Browser geöffnet ist. Weitere Informationen finden Sie unter Private Funktionen.

Apps Script unterstützt zwei Dateitypen: .gs-Skripts und .html-Dateien. Um diese Unterstützung zu nutzen, ist das clientseitige JavaScript der App in <script />-Tags und das CSS in <style />-Tags in einer HTML-Datei enthalten.

Optional können Sie sich das gesamte Projekt auf GitHub ansehen.

Auf GitHub ansehen

Hier finden Sie einen Überblick über die einzelnen Dateien:

Consts.gs

Definiert Konstanten, auf die in anderen Code-Dateien verwiesen wird, einschließlich Ihrer Cloud-Projekt-ID, der Vertex AI-Standort-ID, der Anmeldedaten der App für das Dienstkonto und der Slash-Befehls-ID zum Schließen eines Vorfalls.

Consts.gs-Code ansehen

apps-script/incident-response-app-auth/Consts.gs
const PROJECT_ID = 'replace-with-your-project-id';
const CLOSE_INCIDENT_COMMAND_ID = 1;
const APP_CREDENTIALS = 'replace-with-your-app-credentials';
const APP_CREDENTIALS_SCOPES = 'https://www.googleapis.com/auth/chat.bot https://www.googleapis.com/auth/chat.app.memberships https://www.googleapis.com/auth/chat.app.spaces.create';
const VERTEX_AI_LOCATION_ID = 'us-central1';
const MODEL_ID = 'gemini-1.5-flash-002';
ChatApp.gs

Verarbeitet Chat-Interaktionsereignisse, einschließlich Nachrichten, Infokartenklicks, Schrägstrichbefehle und Dialogfelder. Reagiert auf den Slash-Befehl /closeIncident, indem ein Dialogfeld geöffnet wird, in dem Details zur Vorfallsbehebung erfasst werden. Liest Nachrichten im Bereich, indem die Methode spaces.messages.list in der Chat API aufgerufen wird. Ruft Nutzer-IDs über den Admin SDK Directory-Dienst in Apps Script ab.

ChatApp.gs-Code ansehen

apps-script/incident-response-app-auth/ChatApp.gs
/**
 * Responds to a MESSAGE event in Google Chat.
 *
 * This app only responds to a slash command with the ID 1 ("/closeIncident").
 * It will respond to any other message with a simple "Hello" text message.
 *
 * @param {Object} event the event object from Google Chat
 */
function onMessage(event) {
  if (event.message.slashCommand) {
    return processSlashCommand_(event);
  }
  return { "text": "Hello from Incident Response app!" };
}

/**
 * Responds to a CARD_CLICKED event in Google Chat.
 *
 * This app only responds to one kind of dialog (Close Incident).
 *
 * @param {Object} event the event object from Google Chat
 */
function onCardClick(event) {
  if (event.isDialogEvent) {
    if (event.dialogEventType == 'SUBMIT_DIALOG') {
      return processSubmitDialog_(event);
    }
    return {
      actionResponse: {
        type: "DIALOG",
        dialogAction: {
          actionStatus: "OK"
        }
      }
    };
  }
}

/**
 * Responds to a MESSAGE event with a Slash command in Google Chat.
 *
 * This app only responds to a slash command with the ID 1 ("/closeIncident")
 * by returning a Dialog.
 *
 * @param {Object} event the event object from Google Chat
 */
function processSlashCommand_(event) {
  if (event.message.slashCommand.commandId != CLOSE_INCIDENT_COMMAND_ID) {
    return {
      "text": "Command not recognized. Use the command `/closeIncident` to close the incident managed by this space."
    };
  }
  const sections = [
    {
      header: "Close Incident",
      widgets: [
        {
          textInput: {
            label: "Please describe the incident resolution",
            type: "MULTIPLE_LINE",
            name: "description"
          }
        },
        {
          buttonList: {
            buttons: [
              {
                text: "Close Incident",
                onClick: {
                  action: {
                    function: "closeIncident"
                  }
                }
              }
            ]
          }
        }
      ]
    }
  ];
  return {
    actionResponse: {
      type: "DIALOG",
      dialogAction: {
        dialog: {
          body: {
            sections,
          }
        }
      }
    }
  };
}

/**
 * Responds to a CARD_CLICKED event with a Dialog submission in Google Chat.
 *
 * This app only responds to one kind of dialog (Close Incident).
 * It creates a Doc with a summary of the incident information and posts a message
 * to the space with a link to the Doc.
 *
 * @param {Object} event the event object from Google Chat
 */
function processSubmitDialog_(event) {
  const resolution = event.common.formInputs.description[""].stringInputs.value[0];
  const chatHistory = concatenateAllSpaceMessages_(event.space.name);
  const chatSummary = summarizeChatHistory_(chatHistory);
  const docUrl = createDoc_(event.space.displayName, resolution, chatHistory, chatSummary);
  return {
    actionResponse: {
      type: "NEW_MESSAGE",
    },
    text: `Incident closed with the following resolution: ${resolution}\n\nHere is the automatically generated post-mortem:\n${docUrl}`
  };
}

/**
 * Lists all the messages in the Chat space, then concatenate all of them into
 * a single text containing the full Chat history.
 *
 * For simplicity for this demo, it only fetches the first 100 messages.
 *
 * Messages with slash commands are filtered out, so the returned history will
 * contain only the conversations between users and not app command invocations.
 *
 * @return {string} a text containing all the messages in the space in the format:
 *          Sender's name: Message
 */
function concatenateAllSpaceMessages_(spaceName) {
  // Call Chat API method spaces.messages.list
  const response = Chat.Spaces.Messages.list(spaceName, { 'pageSize': 100 });
  const messages = response.messages;
  // Fetch the display names of the message senders and returns a text
  // concatenating all the messages.
  let userMap = new Map();
  return messages
    .filter(message => message.slashCommand === undefined)
    .map(message => `${getUserDisplayName_(userMap, message.sender.name)}: ${message.text}`)
    .join('\n');
}

/**
 * Obtains the display name of a user by using the Admin Directory API.
 *
 * The fetched display name is cached in the provided map, so we only call the API
 * once per user.
 *
 * If the user does not have a display name, then the full name is used.
 *
 * @param {Map} userMap a map containing the display names previously fetched
 * @param {string} userName the resource name of the user
 * @return {string} the user's display name
 */
function getUserDisplayName_(userMap, userName) {
  if (userMap.has(userName)) {
    return userMap.get(userName);
  }
  let displayName = 'Unknown User';
  try {
    const user = AdminDirectory.Users.get(
      userName.replace("users/", ""),
      { projection: 'BASIC', viewType: 'domain_public' });
    displayName = user.name.displayName ? user.name.displayName : user.name.fullName;
  } catch (e) {
    // Ignore error if the API call fails (for example, because it's an
    // out-of-domain user or Chat app)) and just use 'Unknown User'.
  }
  userMap.set(userName, displayName);
  return displayName;
}
ChatSpaceCreator.gs

Empfängt Formulardaten, die Nutzer auf der Webseite zur Initialisierung von Vorfällen eingeben, und verwendet sie, um einen Chatbereich einzurichten. Dazu wird der Bereich erstellt und mit Daten gefüllt. Anschließend wird eine Nachricht zum Vorfall gepostet.

ChatSpaceCreator.gs-Code ansehen

apps-script/incident-response-app-auth/ChatSpaceCreator.gs
/**
 * Handles an incident by creating a chat space, adding members, and posting a message.
 * All the actions are done using application credentials.
 *
 * @param {Object} formData - The data submitted by the user. It should contain the fields:
 *                           - title: The display name of the chat space.
 *                           - description: The description of the incident.
 *                           - users: A comma-separated string of user emails to be added to the space.
 * @return {string} The resource name of the new space.
 */
function handleIncident(formData) {
  const users = formData.users.trim().length > 0 ? formData.users.split(',') : [];
  const service = getService_();
  if (!service.hasAccess()) {
    console.error(service.getLastError());
    return;
   }
  const spaceName = createChatSpace_(formData.title, service);
  createHumanMembership_(spaceName, getUserEmail(), service);
  for (const user of users ){
    createHumanMembership_(spaceName, user, service);
  }
  createMessage_(spaceName, formData.description, service);
  return spaceName;
}
/**
 * Creates a chat space with application credentials.
 *
 * @param {string} displayName - The name of the chat space.
 * @param {object} service - The credentials of the service account.
 * @returns {string} The resource name of the new space.
*/
function createChatSpace_(displayName, service) {
  try {
    // For private apps, the alias can be used
    const my_customer_alias = "customers/my_customer";
    // Specify the space to create.
    const space = {
        displayName: displayName,
        spaceType: 'SPACE',                
        customer: my_customer_alias
    };
    // Call Chat API with a service account to create a message.
    const createdSpace = Chat.Spaces.create(
        space,
        {},
        // Authenticate with the service account token.
        {'Authorization': 'Bearer ' + service.getAccessToken()});
    return createdSpace.name;
  } catch (err) {
    // TODO (developer) - Handle exception.
    console.log('Failed to create space with error %s', err.message);
  }
}
/*
 * Creates a chat message with application credentials.
 *
 * @param {string} spaceName - The resource name of the space.
 * @param {string} message - The text to be posted.
 * @param {object} service - The credentials of the service account.
 * @return {string} the resource name of the new space.
 */
function createMessage_(spaceName, message, service) {
  try {
    // Call Chat API with a service account to create a message.
    const result = Chat.Spaces.Messages.create(
        {'text': message},
        spaceName,
        {},
        // Authenticate with the service account token.
        {'Authorization': 'Bearer ' + service.getAccessToken()});

  } catch (err) {
    // TODO (developer) - Handle exception.
    console.log('Failed to create message with error %s', err.message);
  }
}
/**
 * Creates a human membership in a chat space with application credentials.
 *
 * @param {string} spaceName - The resource name of the space.
 * @param {string} email - The email of the user to be added.
 * @param {object} service - The credentials of the service account.
 */
function createHumanMembership_(spaceName, email, service){
  try{
    const membership = {
      member: {
        name: 'users/'+email,
        // User type for the membership
        type: 'HUMAN'
      }
    };
    const result = Chat.Spaces.Members.create(
      membership,
      spaceName,
      {},
      {'Authorization': 'Bearer ' + service.getAccessToken()}
    );
  } catch (err){
    console.log('Failed to create membership with error %s', err.message)
  }

}

 /*
 * Creates a service for the service account.
 * @return {object}  - The credentials of the service account.
 */
function getService_() {
  return OAuth2.createService(APP_CREDENTIALS.client_email)
      .setTokenUrl('https://oauth2.googleapis.com/token')
      .setPrivateKey(APP_CREDENTIALS.private_key)
      .setIssuer(APP_CREDENTIALS.client_email)
      .setSubject(APP_CREDENTIALS.client_email)
      .setScope(APP_CREDENTIALS_SCOPES)
      .setPropertyStore(PropertiesService.getScriptProperties());
}
DocsApi.gs

Ruft die Google Docs API auf, um ein Google-Dokument im Google Drive eines Nutzers zu erstellen, und schreibt eine Zusammenfassung der Vorfallinformationen, die in VertexAiApi.gs erstellt wurden, in das Dokument.

DocsApi.gs-Code ansehen

apps-script/incident-response-app-auth/DocsApi.gs
/**
 * Creates a Doc in the user's Google Drive and writes a summary of the incident information to it.
 *
 * @param {string} title The title of the incident
 * @param {string} resolution Incident resolution described by the user
 * @param {string} chatHistory The whole Chat history be included in the document
 * @param {string} chatSummary A summary of the Chat conversation to be included in the document
 * @return {string} the URL of the created Doc
 */
function createDoc_(title, resolution, chatHistory, chatSummary) {
  let doc = DocumentApp.create(title);
  let body = doc.getBody();
  body.appendParagraph(`Post-Mortem: ${title}`).setHeading(DocumentApp.ParagraphHeading.TITLE);
  body.appendParagraph("Resolution").setHeading(DocumentApp.ParagraphHeading.HEADING1);
  body.appendParagraph(resolution);
  body.appendParagraph("Summary of the conversation").setHeading(DocumentApp.ParagraphHeading.HEADING1);
  body.appendParagraph(chatSummary);
  body.appendParagraph("Full Chat history").setHeading(DocumentApp.ParagraphHeading.HEADING1);
  body.appendParagraph(chatHistory);
  return doc.getUrl();
}
VertexAiApi.gs

Fasst die Unterhaltung im Chatbereich mithilfe der Vertex AI API zusammen. Diese Zusammenfassung wird in einem speziell erstellten Dokument in DocsAPI.gs veröffentlicht.

VertexAiApi.gs-Code ansehen

apps-script/incident-response-app-auth/VertexAiApi.gs
/**
 * Summarizes a Chat conversation using the Vertex AI text prediction API.
 *
 * @param {string} chatHistory The Chat history that will be summarized.
 * @return {string} The content from the text prediction response.
 */


function summarizeChatHistory_(chatHistory) {

  const API_ENDPOINT = `https://${VERTEX_AI_LOCATION_ID}-aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/${VERTEX_AI_LOCATION_ID}/publishers/google/models/${MODEL_ID}:generateContent`;
  const prompt = "Summarize the following conversation between Engineers resolving an incident"
      + " in a few sentences. Use only the information from the conversation.\n\n" + chatHistory;
  // Get the access token.
  const accessToken = ScriptApp.getOAuthToken();

  const headers = {
    'Authorization': 'Bearer ' + accessToken,
    'Content-Type': 'application/json',
  };
  const payload = {
    'contents': {
      'role': 'user',
      'parts' : [
        {
          'text': prompt
        }
      ]
    }
  }
  const options = {
    'method': 'post',
    'headers': headers,
    'payload': JSON.stringify(payload),
    'muteHttpExceptions': true,
  };
  try {
    const response = UrlFetchApp.fetch(API_ENDPOINT, options);
    const responseCode = response.getResponseCode();
    const responseText = response.getContentText();

    if (responseCode === 200) {
      const jsonResponse = JSON.parse(responseText);
      console.log(jsonResponse)
      if (jsonResponse.candidates && jsonResponse.candidates.length > 0) {
        return jsonResponse.candidates[0].content.parts[0].text; // Access the summarized text
      } else {
        return "No summary found in response.";
      }

    } else {
      console.error("Vertex AI API Error:", responseCode, responseText);
      return `Error: ${responseCode} - ${responseText}`;
    }
  } catch (e) {
    console.error("UrlFetchApp Error:", e);
    return "Error: " + e.toString();
  }
}
WebController.gs

Stellt die Website zur Initialisierung von Vorfällen bereit.

WebController.gs-Code ansehen

apps-script/incident-response-app-auth/WebController.gs
/**
 * Serves the web page from Index.html.
 */
function doGet() {
  return HtmlService
    .createTemplateFromFile('Index')
    .evaluate();
}

/**
 * Serves the web content from the specified filename.
 */
function include(filename) {
  return HtmlService
    .createHtmlOutputFromFile(filename)
    .getContent();
}

/**
 * Returns the email address of the user running the script.
 */
function getUserEmail() {
  return Session.getActiveUser().getEmail();
}
Index.html

Der HTML-Code der Website zur Initialisierung des Vorfalls.

Index.html-Code ansehen

apps-script/incident-response-app-auth/Index.html
<!DOCTYPE html>
<html>
  <head>
    <base target="_top">
    <link href='https://fonts.googleapis.com/css?family=Roboto' rel='stylesheet'>
    <?!= include('Stylesheet'); ?>
  </head>
  <body>
    <div class="container">
      <div class="content">
        <h1>Incident Manager</h1>
        <form id="incident-form" onsubmit="handleFormSubmit(this)">
          <div id="form">
            <p>
              <label for="title">Incident title</label><br/>
              <input type="text" name="title" id="title" />
            </p>
            <p>
              <label for="users">Incident responders</label><br/>
              <small>
                Please enter a comma-separated list of email addresses of the users
                that should be added to the space.
                Do not include <?= getUserEmail() ?> as it will be added automatically.
              </small><br/>
              <input type="text" name="users" id="users" />
            </p>
            <p>
              <label for="description">Initial message</label></br>
              <small>This message will be posted after the space is created.</small><br/>
              <textarea name="description" id="description"></textarea>
            </p>
            <p class="text-center">
              <input type="submit" value="CREATE CHAT SPACE" />
            </p>
          </div>
          <div id="output" class="hidden"></div>
          <div id="clear" class="hidden">
            <input type="reset" value="CREATE ANOTHER INCIDENT" onclick="onReset()" />
          </div>
        </form>
      </div>
    </div>
    <?!= include('JavaScript'); ?>
  </body>
</html>
JavaScript.html

Verarbeitet das Formularverhalten, einschließlich Übermittlungen, Fehlern und Löschvorgängen, für die Website zur Initialisierung von Vorfällen. Sie wird von der benutzerdefinierten Funktion include in WebController.gs in Index.html aufgenommen.

JavaScript.html-Code ansehen

apps-script/incident-response-app-auth/JavaScript.html
<script>
  var formDiv = document.getElementById('form');
  var outputDiv = document.getElementById('output');
  var clearDiv = document.getElementById('clear');

  function handleFormSubmit(formObject) {
    event.preventDefault();
    outputDiv.innerHTML = 'Please wait while we create the space...';
    hide(formDiv);
    show(outputDiv);
    google.script.run
      .withSuccessHandler(updateOutput)
      .withFailureHandler(onFailure)
      .handleIncident(formObject);
  }

  function updateOutput(response) {
    var spaceId = response.replace('spaces/', '');
    outputDiv.innerHTML =
      '<p>Space created!</p><p><a href="https://mail.google.com/chat/#chat/space/'
        + spaceId
        + '" target="_blank">Open space</a></p>';
    show(outputDiv);
    show(clearDiv);
  }

  function onFailure(error) {
    outputDiv.innerHTML = 'ERROR: ' + error.message;
    outputDiv.classList.add('error');
    show(outputDiv);
    show(clearDiv);
  }

  function onReset() {
    outputDiv.innerHTML = '';
    outputDiv.classList.remove('error');
    show(formDiv);
    hide(outputDiv);
    hide(clearDiv);
  }

  function hide(element) {
    element.classList.add('hidden');
  }

  function show(element) {
    element.classList.remove('hidden');
  }
</script>
Stylesheet.html

Das CSS für die Website zur Vorfallinitialisierung. Sie wird von der benutzerdefinierten Funktion include in WebController.gs in Index.html eingefügt.

Stylesheet.html-Code ansehen

apps-script/incident-response-app-auth/Stylesheet.html
<style>
  * {
    box-sizing: border-box;
  }
  body {
    font-family: Roboto, Arial, Helvetica, sans-serif;
  }
  div.container {
    display: flex;
    justify-content: center;
    align-items: center;
    position: absolute;
    top: 0; bottom: 0; left: 0; right: 0;
  }
  div.content {
    width: 80%;
    max-width: 1000px;
    padding: 1rem;
    border: 1px solid #999;
    border-radius: 0.25rem;
    box-shadow: 0 2px 2px 0 rgba(66, 66, 66, 0.08), 0 2px 4px 2px rgba(66, 66, 66, 0.16);
  }
  h1 {
    text-align: center;
    padding-bottom: 1rem;
    margin: 0 -1rem 1rem -1rem;
    border-bottom: 1px solid #999;
  }
 #output {
    text-align: center;
    min-height: 250px;
  }
  div#clear {
    text-align: center;
    padding-top: 1rem;
    margin: 1rem -1rem 0 -1rem;
    border-top: 1px solid #999;
  }
  input[type=text], textarea {
    width: 100%;
    padding: 1rem 0.5rem;
    margin: 0.5rem 0;
    border: 0;
    border-bottom: 1px solid #999;
    background-color: #f0f0f0;
  }
  textarea {
    height: 5rem;
  }
  small {
    color: #999;
  }
  input[type=submit], input[type=reset] {
    padding: 1rem;
    border: none;
    background-color: #6200ee;
    color: #fff;
    border-radius: 0.25rem;
    width: 25%;
  }
  .hidden {
    display: none;
  }
  .text-center {
    text-align: center;
  }
  .error {
    color: red;
  }
</style>

Cloud-Projektnummer und ‑ID ermitteln

  1. Rufen Sie in der Google Cloud Console Ihr Cloud-Projekt auf.

    Zur Google Cloud Console

  2. Klicken Sie auf „Einstellungen und Dienstprogramme“  > Projekteinstellungen.

  3. Notieren Sie sich die Werte in den Feldern Projektnummer und Projekt-ID. Sie verwenden sie in den folgenden Abschnitten.

Apps Script-Projekt erstellen

So erstellen Sie ein Apps Script-Projekt und verbinden es mit Ihrem Cloud-Projekt:

  1. Klicken Sie auf die folgende Schaltfläche, um das Apps Script-Projekt Mit Google Chat auf Vorfälle reagieren zu öffnen.
    Projekt öffnen
  2. Klicken Sie auf  Übersicht.
  3. Klicken Sie auf der Übersichtsseite auf Symbol zum Erstellen einer Kopie Kopie erstellen.

  4. Geben Sie Ihrer Kopie des Apps Script-Projekts einen Namen:

    1. Klicken Sie auf Kopie von „Auf Vorfälle mit Google Chat reagieren“.

    2. Geben Sie unter Projekttitel Incident Management Chat app ein.

    3. Klicken Sie auf Umbenennen.

  5. Rufen Sie in Ihrer Kopie des Apps Script-Projekts die Datei Consts.gs auf und ersetzen Sie YOUR_PROJECT_ID durch die ID Ihres Cloud-Projekts.

Cloud-Projekt für das Apps Script-Projekt festlegen

  1. Klicken Sie in Ihrem Apps Script-Projekt auf Symbol für Projekteinstellungen Projekteinstellungen.
  2. Klicken Sie unter Google Cloud Platform-Projekt (GCP-Projekt) auf Projekt ändern.
  3. Fügen Sie unter GCP-Projektnummer die Projektnummer Ihres Cloud-Projekts ein.
  4. Klicken Sie auf Projekt festlegen. Das Cloud-Projekt und das Apps Script-Projekt sind jetzt verbunden.

Apps Script-Bereitstellung erstellen

Nachdem der gesamte Code vorhanden ist, stellen Sie das Apps Script-Projekt bereit. Sie verwenden die Bereitstellungs-ID, wenn Sie die Chat-App in Google Cloud konfigurieren.

  1. Öffnen Sie in Apps Script das Projekt der App zur Reaktion auf Vorfälle.

    Zu Apps Script wechseln

  2. Klicken Sie auf Bereitstellen > Neue Bereitstellung.

  3. Wenn Add-on und Web-App noch nicht ausgewählt sind, klicken Sie neben Typ auswählen auf die Bereitstellungstypen Symbol für Projekteinstellungen und wählen Sie Add-on und Web-App aus.

  4. Geben Sie unter Beschreibung eine Beschreibung für diese Version ein, z. B. Complete version of incident management app.

  5. Wählen Sie unter Ausführen als die Option Nutzer, die auf die Webanwendung zugreifen aus.

  6. Wählen Sie unter Wer hat Zugriff? die Option Jeder in Ihrer Workspace-Organisation aus. „Ihre Workspace-Organisation“ ist der Name Ihrer Google Workspace-Organisation.

  7. Klicken Sie auf Bereitstellen. Apps Script meldet eine erfolgreiche Bereitstellung und stellt eine Bereitstellungs-ID und eine URL für die Webseite zur Initialisierung des Vorfalls bereit.

  8. Notieren Sie sich die URL der Web-App, die Sie später aufrufen, wenn Sie einen Vorfall starten. Kopieren Sie die Bereitstellungs-ID. Sie verwenden diese ID, wenn Sie die Chat-App in der Google Cloud Console konfigurieren.

  9. Klicken Sie auf Fertig.

Chat-App in der Google Cloud Console konfigurieren

In diesem Abschnitt wird beschrieben, wie Sie die Google Chat API in der Google Cloud Console mit Informationen zu Ihrer Chat-App konfigurieren, einschließlich der ID der Bereitstellung, die Sie gerade aus Ihrem Apps Script-Projekt erstellt haben.

  1. Klicken Sie in der Google Cloud Console auf das Menü > Weitere Produkte > Google Workspace > Produktbibliothek > Google Chat API > Verwalten > Konfiguration.

    Zur Chat API-Konfiguration

  2. Deaktivieren Sie Diese Chat-App als Google Workspace-Add‑on erstellen. Ein Dialogfeld wird geöffnet, in dem Sie den Vorgang bestätigen müssen. Klicken Sie im Dialogfeld auf Deaktivieren.

  3. Geben Sie unter App-Name Incident Management ein.

  4. Geben Sie unter Avatar URL (Avatar-URL) https://developers.google.com/chat/images/quickstart-app-avatar.png ein.

  5. Geben Sie unter Beschreibung den Wert Responds to incidents. ein.

  6. Klicken Sie auf die Ein/Aus-Schaltfläche Interaktive Funktionen aktivieren, um die Position „Ein“ festzulegen.

  7. Wählen Sie unter Funktionsweise die Option Gruppenbereichen und Gruppenunterhaltungen beitreten aus.

  8. Wählen Sie unter Verbindungseinstellungen die Option Apps Script aus.

  9. Fügen Sie unter Bereitstellungs-ID die Apps Script-Bereitstellungs-ID ein, die Sie zuvor aus der Bereitstellung des Apps Script-Projekts kopiert haben.

  10. Registrieren Sie einen Slash-Befehl, der von der vollständig implementierten Chat-App verwendet wird:

    1. Klicken Sie unter Befehle auf Befehl hinzufügen.

    2. Geben Sie als Befehls-ID 1 ein.

    3. Geben Sie unter Beschreibung den Wert Closes the incident being discussed in the space. ein.

    4. Wählen Sie unter Befehlstyp die Option Slash-Befehl aus.

    5. Geben Sie unter Name des Slash-Befehls /closeIncident ein.

    6. Wählen Sie Öffnet ein Dialogfeld aus.

    7. Klicken Sie auf Fertig. Der Slash-Befehl ist registriert und wird aufgeführt.

  11. Wählen Sie unter Sichtbarkeit die Option Diese Chat-App bestimmten Personen und Gruppen in Ihrer Workspace-Domain zur Verfügung stellen aus und geben Sie Ihre E-Mail-Adresse ein.

  12. Wählen Sie unter Logs die Option Fehler in Logging protokollieren aus.

  13. Klicken Sie auf Speichern. Eine Meldung wird angezeigt, dass die Konfiguration gespeichert wurde. Das bedeutet, dass die App bereit für Tests ist.

Administratorgenehmigung einholen

Damit Sie die Genehmigung des Administrators erhalten, müssen Sie die Chat-App im Google Workspace Marketplace SDK konfigurieren.

Chat-App im Google Workspace Marketplace SDK konfigurieren

So konfigurieren Sie die Chat-App im Google Workspace Marketplace SDK:

  1. Rufen Sie in der Google Cloud Console das Menü > APIs & Dienste > Aktivierte APIs & Dienste > Google Workspace Marketplace SDK > App-Konfiguration auf.

    Zu „App-Konfiguration“

  2. Füllen Sie die Seite „App-Konfiguration“ aus. Wie Sie Ihre Chat-App konfigurieren, hängt unter anderem von Ihrer beabsichtigten Zielgruppe ab. Hilfe beim Ausfüllen der Seite „App-Konfiguration“ finden Sie unter App im Google Workspace Marketplace SDK konfigurieren. Geben Sie für diesen Leitfaden die folgenden Informationen ein:

    1. Wählen Sie unter Sichtbarkeit der App die Option Privat aus.
    2. Wählen Sie unter Installation settings (Installationseinstellungen) die Option Admin install (Administratorinstallation) aus.
    3. Wählen Sie unter App-Integrationen die Option Chat-App aus.
    4. Geben Sie unter OAuth-Bereiche die folgenden Bereiche ein:
      • https://www.googleapis.com/auth/chat.app.spaces
      • https://www.googleapis.com/auth/chat.app.memberships
    5. Geben Sie unter Entwicklerinformationen den Namen des Entwicklers, die Website-URL des Entwicklers und die E-Mail-Adresse des Entwicklers ein.
    6. Klicken Sie auf Entwurf speichern.

Aktualisieren Sie nach der Konfiguration der App den Store-Eintrag:

  1. Rufen Sie in der Google Cloud Console das Menü > APIs & Dienste > Aktivierte APIs & Dienste > Google Workspace Marketplace SDK > Store-Eintrag auf.
  2. Wählen Sie unter App-Details die Kategorie „Webentwicklung“ aus.
  3. Laden Sie unter Grafikinhalte App-Symbole in den erforderlichen Formaten hoch.
  4. Laden Sie unter Screenshots einen Screenshot der Anwendung hoch.
  5. Geben Sie unter Support-Links eine URL für die Nutzungsbedingungen, eine Datenschutz-URL und eine Support-URL ein.
  6. Wählen Sie unter Distribution die Regionen aus, in denen diese Anwendung verfügbar sein soll.
  7. Klicken Sie auf Veröffentlichen.

Administratorgenehmigung einholen

Nachdem Ihr Dienstkonto für den Erhalt der Administratorgenehmigung konfiguriert wurde, müssen Sie die Genehmigung von einem Google Workspace-Administrator einholen, der sie erteilen kann, indem er die Schritte unter Autorisierung für Chat-Apps einrichten ausführt.

Chat App testen

So testen Sie die Chat-App für die Vorfallverwaltung: Starten Sie einen Vorfall über die Webseite und prüfen Sie, ob die Chat-App wie erwartet funktioniert:

  1. Rufen Sie die Web-App-URL der Apps Script-Bereitstellung auf.

  2. Wenn Apps Script Sie um die Erlaubnis bittet, auf Ihre Daten zuzugreifen, klicken Sie auf Berechtigungen prüfen, melden Sie sich mit einem geeigneten Google-Konto in Ihrer Google Workspace-Domain an und klicken Sie auf Zulassen.

  3. Die Webseite zur Initialisierung von Vorfällen wird geöffnet. Geben Sie die Testinformationen ein:

    1. Geben Sie unter Titel des Vorfalls The First Incident ein.
    2. Optional: Geben Sie unter Incident-Reaktionsteam die E-Mail-Adressen Ihrer Kollegen ein, die ebenfalls am Incident beteiligt sind. Sie müssen Nutzer mit einem Google Chat-Konto in Ihrer Google Workspace-Organisation sein, da sonst die Erstellung des Gruppenbereichs fehlschlägt. Geben Sie nicht Ihre eigene E-Mail-Adresse ein, da sie automatisch enthalten ist.
    3. Geben Sie bei Erste Nachricht den Wert Testing the incident management Chat app. ein.

  4. Klicken Sie auf Chatbereich erstellen. Die Meldung creating space wird angezeigt.

  5. Nachdem der Gruppenbereich erstellt wurde, wird eine Space created!-Meldung angezeigt. Klicken Sie auf Gruppenbereich öffnen. Der Gruppenbereich wird in Google Chat in einem neuen Tab geöffnet.

  6. Optional können Sie und die anderen Reaktionsverantwortlichen Nachrichten im Bereich senden. Die App fasst diese Nachrichten mit Vertex AI zusammen und gibt ein Retrospektivdokument aus.

  7. Wenn Sie die Reaktion auf den Vorfall beenden und mit der Behebung beginnen möchten, geben Sie im Chatbereich /closeIncident ein. Ein Dialogfeld zur Vorfallverwaltung wird geöffnet.

  8. Geben Sie unter Vorfall schließen eine Beschreibung für die Lösung des Vorfalls ein, z. B. Test complete.

  9. Klicken Sie auf Close Incident (Vorfall schließen).

Die Incident Management App listet die Nachrichten im Gruppenbereich auf, fasst sie mit Vertex AI zusammen, fügt die Zusammenfassung in ein Google-Dokument ein und gibt das Dokument im Gruppenbereich frei.

Bereinigen

Damit Ihrem Google Cloud-Konto die in dieser Anleitung verwendeten Ressourcen nicht in Rechnung gestellt werden, empfehlen wir, das Cloud-Projekt zu löschen.

  1. Wechseln Sie in der Google Cloud Console zur Seite Ressourcen verwalten. Klicken Sie auf das Menü > IAM & Verwaltung > Ressourcen verwalten.

    Zum Ressourcenmanager

  2. Wählen Sie in der Projektliste das Projekt aus, das Sie löschen möchten, und klicken Sie dann auf Löschen .
  3. Geben Sie im Dialogfeld die Projekt-ID ein und klicken Sie auf Beenden, um das Projekt zu löschen.