Mit Google Chat, Vertex AI und Google 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 die App einen Chatbereich mit den relevanten Personen, erleichtert die Vorfallbehebung mit Nachrichten, App-Befehlen und Dialogen und fasst die Incident Response mithilfe von KI in einem Google Docs-Dokument zusammen.

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.
  • Es kommt zu einem Erdbeben mit hoher Magnitude und Einsatzkräfte müssen ihre Reaktion koordinieren.

In dieser Anleitung beginnt die Benachrichtigung über den Vorfall, wenn jemand den Vorfall über einen Klick auf einen Button 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 ein Vorfall gemeldet werden kann.
  • Benachrichtigung, dass der Chatbereich für den Vorfall erstellt wurde.
    Abbildung 2: Benachrichtigung, dass der Chatbereich für den Vorfall erstellt wurde.
  • Der Incident Response Chatbereich.
    Abbildung 3: Der Chatbereich für die Incident Response.
  • Den Vorfall mit einem Slash-Befehl beheben.
    Abbildung 4: Vorfall mit einem Slash-Befehl beheben
  • Dialogfeld „Vorfallbehebung“
    Abbildung 5. Dialogfeld zur Behebung von Vorfällen.
  • Google Docs-Dokument zur Vorfallbehebung, das im Gruppenbereich geteilt wurde.
    Abbildung 6. Google Docs-Dokument zur Vorfallbehebung, das im Gruppenbereich freigegeben wurde.
  • Das Google-Dokument zur Vorfallbehebung mit KI-Zusammenfassung.
    Abbildung 7. Das Google Docs-Dokument mit der KI-Zusammenfassung zur Vorfallbehebung.

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 oder Enterprise 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, z. B. Name und E-Mail-Adresse, nachzuschlagen. Die Reaktionsverantwortlichen müssen Nutzer mit einem 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:
    • Incident Response-Bereiche 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 von der Chat-App zur Reaktion auf Vorfälle verwendeten Google Workspace- und Google Cloud-Ressourcen.

Architektur der Incident Response Chat-App

Die Architektur zeigt, wie die Incident Response Chat-App einen Vorfall und seine Lösung verarbeitet.

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

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

  3. Die Incident Response Chat-App 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 Chat-App für die Incident Response einen Chatbereich für den Vorfall, fügt Teammitglieder hinzu und sendet eine Nachricht an den Bereich.

  4. Teammitglieder besprechen den Vorfall im Chatbereich.

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

    1. Bei einem HTTP-Aufruf der Chat API mit dem erweiterten Chat-Dienst von Apps Script werden alle Nachrichten des Chat-Gruppenbereichs aufgelistet.

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

    3. Mit dem Apps Script-Dienst DocumentApp wird ein Google-Dokument erstellt und die Zusammenfassung von Vertex AI dem Dokument hinzugefügt.

    4. Die Chat-App für die Incident Response 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 API-Konsole

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

    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 für die gesamte Lebensdauer des Projekts geeignet ist.

  3. Klicken Sie im Feld Speicherort auf Durchsuchen, um potenzielle Speicherorte für Ihr Projekt anzuzeigen. Klicken Sie danach auf Auswählen.
  4. Klicken Sie auf Erstellen. In der Google API 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 den Befehl gcloud projects create, um ein Cloud-Projekt zu erstellen: 
    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 API-Konsole

  1. Rufen Sie in der Google API 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 Ihrem Google Cloud-Projekt zugeordnet ist.
  3. Öffnen Sie in der Projektzeile das Menü Aktionen (), klicken Sie auf Abrechnung ändern und wählen Sie das Cloud-Rechnungskonto 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 des Cloud-Projekts, 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 API-Konsole

  1. Aktivieren Sie in der Google API 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. Prüfen Sie, ob 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 bei Bedarf das aktuelle Cloud-Projekt auf das Projekt fest, das Sie mit dem Befehl gcloud config set project 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, das Google Workspace Marketplace SDK 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 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 Incident Response zu verarbeiten. Insbesondere wird die Nutzerauthentifizierung verwendet, um die 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, ersetzen Sie die Platzhalterinformationen auf dem Zustimmungsbildschirm durch echte Informationen.

  1. Rufen Sie in der Google API Console das Menü  > Google Auth-Plattform > Branding auf.

    Zum Branding

  2. Wenn Sie die Google Auth-Plattform bereits konfiguriert haben, können Sie die folgenden Einstellungen für den OAuth-Zustimmungsbildschirm unter Branding, Zielgruppe und Datenzugriff konfigurieren. Wenn Sie die Meldung Google Auth Platform 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 Nutzersupport-E‑Mail 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 akzeptiere die Richtlinie zu Nutzerdaten für Google API-Dienste 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 aller anderen autorisierten Testnutzer ein und klicken Sie auf Speichern.

  3. Klicken Sie auf Datenzugriff > 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/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 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 und Verwaltung > Dienstkonten auf.

    Zur Seite „Dienstkonten“

    Die verbleibenden Schritte werden in der Google Cloud Console angezeigt.

  2. Wählen Sie ein Google Cloud-Projekt aus.
  3. Klicken Sie auf Dienstkonto erstellen.
  4. Geben Sie einen Dienstkontonamen ein, der in der Google Cloud Console angezeigt werden soll.
  5. Wenn Sie die Zugriffssteuerungen derzeit nicht festlegen möchten, klicken Sie auf Fertig, um das Erstellen des Dienstkontos abzuschließen. Wenn Sie die Zugriffssteuerungen jetzt festlegen möchten, klicken Sie auf Erstellen und fortfahren und fahren mit dem nächsten Schritt fort.
  6. Optional: Weisen Sie Ihrem Dienstkonto Rollen zu, um zusätzlich zu Google Workspace-Ressourcen Zugriff auf die Ressourcen Ihres Google Cloud-Projekts zu gewähren. Weitere Informationen finden Sie unter Zugriff auf Projekte, Ordner und Organisationen verwalten.
  7. Klicken Sie auf Weiter.
  8. Optional: Geben Sie Nutzer oder Gruppen ein, die dieses Dienstkonto verwalten und Aktionen damit ausführen können. Weitere Informationen finden Sie unter Identitätsübernahme des Dienstkontos.
  9. Klicken Sie auf Fertig, um das Erstellen des Dienstkontos abzuschließen.

    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 zusätzlich zu Google Workspace-Ressourcen Zugriff auf die Ressourcen Ihres Google Cloud-Projekts zu gewähren. Weitere Informationen finden Sie unter Zugriff auf Projekte, Ordner und Organisationen verwalten.

Das Dienstkonto wird auf der Dienstkontoseite 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 und Verwaltung > Dienstkonten auf.

    Zur Seite „Dienstkonten“

    Die verbleibenden Schritte werden in der Google Cloud Console angezeigt.

  2. Wählen Sie ein Google Cloud-Projekt aus.
  3. Klicken Sie auf die E-Mail-Adresse des Dienstkontos, für das Sie einen Schlüssel erstellen möchten.
  4. Klicken Sie auf den Tab Schlüssel.
  5. Klicken Sie auf das Drop-down-Menü Schlüssel hinzufügen und wählen Sie Neuen Schlüssel erstellen aus.
  6. Wählen Sie als Schlüsseltyp JSON aus und klicken Sie dann auf Erstellen.

    Ihr neues öffentliches/privates Schlüsselpaar wird generiert und als Dienstkontoschlüsseldatei 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. Nachdem Sie die Schlüsseldatei heruntergeladen haben, können Sie sie nicht noch einmal herunterladen. Informationen dazu, wie Sie Ihren Schlüssel sicher speichern, finden Sie unter Best Practices für die Verwaltung von Dienstkontoschlüsseln.

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. Rufen Sie in der Google API Console das Menü  > IAM & Verwaltung > Dienstkonten auf.

    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.

Es wird eine Bestätigungsmeldung 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. concatenateAllSpaceMessages_() aus ChatApp.gs. Der Unterstrich blendet die Funktion auf der Webseite zur Vorfallinitialisierung 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. Damit die App diese Unterstützung bietet, ist das clientseitige JavaScript 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 eine Übersicht ü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-Zielgebiets-ID, der Anmeldedaten der App für das Dienstkonto und der Schnellbefehl-ID zum Schließen eines Vorfalls.

Consts.gs-Code ansehen

apps-script/chat/incident-response-app-auth/Consts.gs
const PROJECT_ID = 'replace-with-your-project-id';
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 CLOSE_INCIDENT_COMMAND_ID = 1;
const MODEL_ID = 'gemini-2.5-flash-lite';
ChatApp.gs

Verarbeitet Chat-Interaktionsereignisse, einschließlich Nachrichten, Schaltflächenklicks, App-Befehle (onAppCommand) und Dialogfelder. Reagiert auf den Schnellbefehl Close incident, indem ein Dialogfeld geöffnet wird, in dem Details zur Behebung des Vorfalls erfasst werden. Nachrichten im Bereich werden durch Aufrufen der Methode spaces.messages.list in der Chat API gelesen. Ruft Nutzer-IDs mit dem Admin SDK Verzeichnisdienst in Apps Script ab.

ChatApp.gs-Code ansehen

apps-script/chat/incident-response-app-auth/ChatApp.gs
/**
 * Responds to a MESSAGE event in Google Chat.
 * 
 * It always responds with a simple "Hello" text message.
 *
 * @param {Object} event the event object from Google Chat
 */
function onMessage(event) {
  return { hostAppDataAction: { chatDataAction: { createMessageAction: { message: {
    text: "Hello from Incident Response app!"
  }}}}};
}

/**
 * Responds to an APP_COMMAND event in Google Chat.
 *
 * @param {Object} event the event object from Google Chat
 */
function onAppCommand(event) {
  if (event.chat.appCommandPayload.appCommandMetadata.appCommandId != CLOSE_INCIDENT_COMMAND_ID) {
    return { hostAppDataAction: { chatDataAction: { createMessageAction: { message: {
      text: "Command not recognized. Use the quick command `Close incident` to close the incident managed by this space."
    }}}}};
  }
  return { action: { navigations: [{ pushCard: { 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" }}
      }]}
    }]
  }]}}]}};
}

/**
 * Responds to a BUTTON_CLICKED event in Google Chat from Close Incident dialog.
 *
 * @param {Object} event the event object from Google Chat
 */
function closeIncident(event) {
  if (event.chat.buttonClickedPayload.isDialogEvent) {
    if (event.chat.buttonClickedPayload.dialogEventType == 'SUBMIT_DIALOG') {
      return processSubmitDialog_(event);
    }
    return { action: { navigations: [{ endNavigation: {
      action: "CLOSE_DIALOG" }
    }]}};
  }
}

/**
 * Responds to a BUTTON_CLICKED event in Google Chat from Close Incident dialog submission.
 *
 * 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.commonEventObject.formInputs.description.stringInputs.value[0];
  const space = event.chat.buttonClickedPayload.space;
  const chatHistory = concatenateAllSpaceMessages_(space.name);
  const chatSummary = summarizeChatHistory_(chatHistory);
  const docUrl = createDoc_(space.displayName, resolution, chatHistory, chatSummary);
  return { hostAppDataAction: { chatDataAction: { createMessageAction: { 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.
 *
 * @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
    .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/chat/incident-response-app-auth/ChatSpaceCreator.gs
/**
 * Handles an incident by creating a chat space with the provided title and 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.
 *
 * @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 human membership in a chat space.
 *
 * @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 chat message.
 *
 * @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 message.
 */
function createMessage_(spaceName, message, service) {
  try {
    const request = {
      text: message
    };
    // Call Chat API with a service account to create a message.
    const result = Chat.Spaces.Messages.create(
        request,
        spaceName,
        {},
        // Authenticate with the service account token.
        {'Authorization': 'Bearer ' + service.getAccessToken()});
    return result.name;
  } catch (err) {
    // TODO (developer) - Handle exception.
    console.log('Failed to create message 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 Docs API auf, um ein Google-Dokument im Google Drive eines Nutzers zu erstellen, und schreibt eine Zusammenfassung der in VertexAiApi.gs erstellten Vorfallinformationen in das Dokument.

DocsApi.gs-Code ansehen

apps-script/chat/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 mit der Vertex AI API zusammen. Diese Zusammenfassung wird in einem speziell erstellten Dokument in DocsAPI.gs veröffentlicht.

VertexAiApi.gs-Code ansehen

apps-script/chat/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/chat/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, auf der der Vorfall initialisiert wurde.

Index.html-Code ansehen

apps-script/chat/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 eingefügt.

JavaScript.html-Code ansehen

apps-script/chat/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/chat/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 finden

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

    Zur Google API Console

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

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

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 die Projekteinstellungen Projekteinstellungen.
  2. Klicken Sie unter Google Cloud Platform-Projekt (GCP) auf Projekt wechseln.
  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 Incident Response-App.

    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 die 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, der auf die Web-App zugreift aus.

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

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

  8. Notieren Sie sich die Web-App-URL, 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 API Console konfigurieren.

  9. Klicken Sie auf Fertig.

Chat-App in der Google API Console konfigurieren

In diesem Abschnitt wird beschrieben, wie Sie die Google Chat API in der Google API 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 API Console auf das Menü > APIs und Dienste > Aktivierte APIs und Dienste > Google Chat API > Konfiguration.

    Zur Chat API-Konfiguration

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

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

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

  5. Klicken Sie auf den Ein/Aus-Button Interaktive Funktionen aktivieren, um die Option zu aktivieren.

  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 in Deployment-ID die Apps Script-Deployment-ID ein, die Sie zuvor aus dem Apps Script-Projekt-Deployment kopiert haben.

  9. Konfigurieren Sie unter Trigger onAppCommand für den Trigger App-Befehl.

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

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

    2. Geben Sie unter Befehls-ID 1 ein.

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

    4. Wählen Sie unter Befehlstyp die Option Schnellbefehl aus.

    5. Geben Sie unter Name des Schnellbefehls Close incident ein.

    6. Wählen Sie Öffnet ein Dialogfeld (oder Dialogfeld) aus.

    7. Klicken Sie auf Fertig. Der 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 erhalten

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 API Console das Menü > APIs und Dienste > Aktivierte APIs und 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 Zielgruppe ab. Hilfe beim Ausfüllen der Seite für die App-Konfiguration finden Sie unter App im SDK konfigurieren. Geben Sie für diese Anleitung 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.

Nachdem Sie die App konfiguriert haben, aktualisieren Sie den Store-Eintrag:

  1. Rufen Sie in der Google Cloud Console das Menü > APIs und Dienste > Aktivierte APIs und 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 URL für die Datenschutzerklärung und eine Support-URL ein.
  6. Wählen Sie unter Vertrieb 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 die Genehmigung erteilen kann, indem er der Anleitung unter Autorisierung für Chat-Apps einrichten folgt.

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 die Berechtigung zum Zugriff auf Ihre Daten anfordert, 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-Reagierende die E‑Mail-Adressen Ihrer Kollegen ein, die auf den Vorfall 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 enthalten ist.
    3. Geben Sie unter 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 Incident-Responder Nachrichten im Bereich senden. Die App fasst diese Nachrichten mit Vertex AI zusammen und gibt ein Retrospektivdokument aus.

  7. Um die Incident Response zu beenden und mit der Behebung zu beginnen, starten Sie im Chatbereich den Schnellbefehl Close incident. 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 Vorfall schließen.

In der App „Incident Management“ werden die Nachrichten im Gruppenbereich aufgelistet, mit Vertex AI zusammengefasst, die Zusammenfassung in ein Google-Dokument eingefügt und das Dokument im Gruppenbereich freigegeben.

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 API Console zur Seite Ressourcen verwalten. Klicken Sie auf das Menü > IAM und Verwaltung > Ressourcen verwalten.

    Zum Ressourcenmanager

  2. Wählen Sie in der Projektliste das Projekt aus, das Sie löschen möchten, und klicken Sie auf Löschen .
  3. Geben Sie im Dialogfeld die Projekt-ID ein und klicken Sie auf Beenden, um das Projekt zu löschen.
  • Die Incident Response App authentifiziert sich mit Nutzeranmeldedaten, um APIs aufzurufen und Google Cloud-Dienste wie die Chat API und die Vertex AI API aufzurufen. Das bedeutet, dass der Nutzer, der einen Vorfall initiiert, Zugriff auf diese Dienste haben muss. Um die App robuster zu machen, sollten Sie die Vertex AI API mit einem Dienstkonto aufrufen, anstatt mit den Nutzeranmeldedaten des Nutzers, der den Schnellbefehl Close incident aufruft. Hilfe beim Konfigurieren eines Dienstkontos für die Vertex AI API finden Sie unter Benutzerdefiniertes Dienstkonto verwenden.

Chat-Apps, die keine Add-ons sind: Mit Google Chat, Vertex AI und Google Apps Script auf Vorfälle reagieren (App-Authentifizierung)

Die folgenden Anleitungen und Codebeispiele gelten für eine Chat-App, die kein Google Workspace-Add-on ist (auf GitHub ansehen).

Apps Script-Projekt erstellen und konfigurieren

  1. Öffnen Sie das Apps Script-Projekt Mit Google Chat auf Vorfälle reagieren für eine Chat-App, die kein Add‑on ist, und erstellen Sie eine Kopie.
  2. Wenn Sie die Chat API in der Google API Console konfigurieren, 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. Registrieren Sie den /closeIncident-Slash-Befehl (Befehls-ID 1, wählen Sie Öffnet ein Dialogfeld aus) und geben Sie /closeIncident in das Feld ein, um einen Vorfall zu beheben.

Quellcode

Consts.gs
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
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
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
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
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
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
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
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
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>