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

In diesem Tutorial erstellen Sie eine Google Chat-App, 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.

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-Dokument zur Problembehebung, das im Gruppenbereich geteilt wurde.
  • Das Google-Dokument zur Behebung von Vorfällen mit KI-Zusammenfassungen.
    Abbildung 7. Das Google-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 Reaktionsverantwortlichen müssen Nutzer mit einem Google Chat-Konto in Ihrer Google Workspace-Organisation sein.

Lernziele

  • 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 Docs-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 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, die Google Docs API, die Admin SDK API und die Vertex AI API mit dem Befehl gcloud services enable:

    gcloud services enable chat.googleapis.com docs.googleapis.com admin.googleapis.com aiplatform.googleapis.com

Authentifizierung 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.

In dieser Anleitung veröffentlichen Sie die App intern. Daher ist es in Ordnung, Platzhalterinformationen zu verwenden. Bevor Sie die App extern veröffentlichen, müssen Sie die Platzhalterinformationen auf dem Zustimmungsbildschirm 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 Fertigstellen die Nutzerdatenrichtlinie für Google API-Dienste an und wählen Sie Ich stimme der Nutzerdatenrichtlinie für Google API-Dienste zu aus, wenn Sie damit einverstanden sind.
    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 (Bereiche hinzufügen oder entfernen). Ein Bereich mit einer Liste der Bereiche für jede API, die Sie in Ihrem Google Cloud-Projekt aktiviert haben, wird angezeigt.

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

      • https://www.googleapis.com/auth/chat.spaces.create
      • https://www.googleapis.com/auth/chat.memberships
      • https://www.googleapis.com/auth/chat.memberships.app
      • https://www.googleapis.com/auth/chat.messages
      • 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.

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 und der Slash-Befehls-ID zum Schließen eines Vorfalls.

Consts.gs-Code ansehen

apps-script/incident-response/Consts.gs
const PROJECT_ID = 'replace-with-your-project-id';
const VERTEX_AI_LOCATION_ID = 'us-central1';
const CLOSE_INCIDENT_COMMAND_ID = 1;
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 Behebung des Vorfalls erfasst werden. Liest Nachrichten im Bereich durch Aufrufen der Methode spaces.messages.list in der Chat API. Ruft Nutzer-IDs über den Admin SDK Directory-Dienst in Apps Script ab.

ChatApp.gs-Code ansehen

apps-script/incident-response/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/ChatSpaceCreator.gs
/**
 * Creates a space in Google Chat with the provided title and members, and posts an
 * initial message to it.
 *
 * @param {Object} formData the data submitted by the user. It should contain the fields
 *                          title, description, and users.
 * @return {string} the resource name of the new space.
 */
function createChatSpace(formData) {
  const users = formData.users.trim().length > 0 ? formData.users.split(',') : [];
  const spaceName = setUpSpace_(formData.title, users);
  addAppToSpace_(spaceName);
  createMessage_(spaceName, formData.description);
  return spaceName;
}

/**
 * Creates a space in Google Chat with the provided display name and members.
 *
 * @return {string} the resource name of the new space.
 */
function setUpSpace_(displayName, users) {
  const memberships = users.map(email => ({
    member: {
      name: `users/${email}`,
      type: "HUMAN"
    }
  }));
  const request = {
    space: {
      displayName: displayName,
      spaceType: "SPACE",
      externalUserAllowed: true
    },
    memberships: memberships
  };
  // Call Chat API method spaces.setup
  const space = Chat.Spaces.setup(request);
  return space.name;
}

/**
 * Adds this Chat app to the space.
 *
 * @return {string} the resource name of the new membership.
 */
function addAppToSpace_(spaceName) {
  const request = {
    member: {
      name: "users/app",
      type: "BOT"
    }
  };
  // Call Chat API method spaces.members.create
  const membership = Chat.Spaces.Members.create(request, spaceName);
  return membership.name;
}

/**
 * Posts a text message to the space on behalf of the user.
 *
 * @return {string} the resource name of the new message.
 */
function createMessage_(spaceName, text) {
  const request = {
    text: text
  };
  // Call Chat API method spaces.messages.create
  const message = Chat.Spaces.Messages.create(request, spaceName);
  return message.name;
}
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/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 mit Vertex AI zusammen. Diese Zusammenfassung wird in einem speziell erstellten Dokument in DocsAPI.gs veröffentlicht.

VertexAiApi.gs-Code ansehen

apps-script/incident-response/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 prompt =
    "Summarize the following conversation between Engineers resolving an incident"
      + " in a few sentences. Use only the information from the conversation.\n\n"
      + chatHistory;
  const request = {
    instances: [
      { prompt: prompt }
    ],
    parameters: {
      temperature: 0.2,
      maxOutputTokens: 256,
      topK: 40,
      topP: 0.95
    }
  }
  const fetchOptions = {
    method: 'POST',
    headers: { Authorization: 'Bearer ' + ScriptApp.getOAuthToken() },
    contentType: 'application/json',
    payload: JSON.stringify(request)
  }
  const response = UrlFetchApp.fetch(
    `https://${VERTEX_AI_LOCATION_ID}-aiplatform.googleapis.com/v1`
      + `/projects/${PROJECT_ID}/locations/${VERTEX_AI_LOCATION_ID}`
      + "/publishers/google/models/text-bison:predict",
    fetchOptions);
  const payload = JSON.parse(response.getContentText());
  return payload.predictions[0].content;
}
WebController.gs

Stellt die Website zur Initialisierung von Vorfällen bereit.

WebController.gs-Code ansehen

apps-script/incident-response/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/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, Fehler und Löschvorgänge, 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/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)
      .createChatSpace(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 Initialisierung von Vorfällen. Sie wird von der benutzerdefinierten include-Funktion in WebController.gs in Index.html eingefügt.

Stylesheet.html-Code ansehen

apps-script/incident-response/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 einen Namen für die Kopie des Apps Script-Projekts ein:

    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 müssen, 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. Geben Sie unter App-Name Incident Management ein.

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

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

  5. Klicke auf die Ein/Aus-Schaltfläche Interaktive Funktionen aktivieren, um die Position „Ein“ festzulegen.

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

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

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

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

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

    2. Geben Sie unter Name Close incident ein.

    3. Geben Sie als Befehls-ID 1 ein.

    4. Geben Sie unter Beschreibung Folgendes ein: Closes the incident being discussed in the space.

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

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

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

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

  10. 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.

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

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

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 den Wert The First Incident ein.
    2. Optional können Sie unter Incident responders (Reagierende auf Vorfälle) die E-Mail-Adressen Ihrer Kollegen eingeben, die auf Vorfälle reagieren. 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 berücksichtigt wird.
    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.