Mit Google Chat, Vertex AI und Apps Script auf Vorfälle reagieren
In dieser Anleitung erfahren Sie, wie Sie eine Google Chat-App erstellen, die
in Echtzeit auf Vorfälle reagieren. Wenn die App auf einen Vorfall reagiert,
erstellt und füllt einen Chatbereich, erleichtert Vorfälle.
mit Meldungen, Slash-Befehlen und Dialogfeldern
und nutzt KI für Zusammenfassungen
die Reaktion auf Vorfälle in einem Google Docs-Dokument.
Ein Vorfall ist ein Ereignis, das die sofortige Aufmerksamkeit eines Teams erfordert.
zu klären. Beispiele für Vorfälle:
In einem CRM-System (Customer-Relationship-Management) wird eine zeitkritische Anfrage erstellt.
Plattform, bei der ein Serviceteam
zusammen an einer Lösung arbeiten muss.
Ein System geht offline und eine Gruppe von Site Reliability Engineers (SREs) wird benachrichtigt
damit sie es gemeinsam wieder online bringen können.
Ein schweres Erdbeben erleidet, und Rettungskräfte benötigen
um die Reaktion zu koordinieren.
Im Rahmen dieser Anleitung wird die Vorfallbenachrichtigung gestartet,
meldet den Vorfall mit einem Klick auf eine Schaltfläche auf einer Webseite. Die Webseite simuliert
indem Sie die Nutzer auffordern,
grundlegende Informationen zum Vorfall einzugeben: Titel,
eine Beschreibung und die E-Mail-Adressen der Teilnehmer.
Sehen Sie sich die Chat-App für das Vorfallmanagement in Aktion an:
<ph type="x-smartling-placeholder"></ph>
Abbildung 1: Die Website, auf der jemand einen Vorfall melden kann.
Abbildung 2: Benachrichtigung, dass der für den Vorfall vorbereitete Chatbereich erstellt wird.
Abbildung 3: Der Chatbereich für die Reaktion auf Vorfälle.
Abbildung 4: Vorfall mit einem Slash-Befehl beheben.
Abbildung 5: Dialogfeld zur Behebung von Vorfällen.
Abbildung 6: Google Docs-Dokument zur Behebung von Vorfällen, das im Gruppenbereich freigegeben ist.
Abbildung 7: Das Google Docs-Dokument zur Zusammenfassung von KI-Vorfällen.
Vorbereitung
Wenn Sie eine dieser Voraussetzungen für Ihre Organisation aktivieren müssen, fragen Sie nach
Ihren Google Workspace-Administrator, um sie zu aktivieren:
Muss
Verzeichnis
(Kontaktfreigabe) für Google Workspace aktiviert. Die Vorfall-App verwendet
das Verzeichnis, um die Incident-Response-Experten nachzuschlagen, Kontaktdaten wie Name
und E-Mail-Adresse. Incident-Response-Teams müssen Nutzer mit einem Google Chat-Konto sein
in Ihrer Google Workspace-Organisation.
Zielsetzungen
Chat-App erstellen, die auf Vorfälle reagiert
So helfen Sie Nutzern, auf Vorfälle zu reagieren:
<ph type="x-smartling-placeholder">
</ph>
Erstellen von Antwortbereichen für Vorfälle
Nachrichten mit einer Zusammenfassung der Vorfälle und Antworten posten
Förderung der Zusammenarbeit durch interaktive
Funktionen der Chat-App.
Unterhaltungen und Lösungen mit Vertex AI zusammenfassen.
Architektur
Das folgende Diagramm zeigt die Architektur von Google Workspace und
Von der Vorfallreaktion verwendete Google Cloud-Ressourcen
Google Chat App.
Die Architektur zeigt, wie die Vorfallreaktion
Die Google Chat App verarbeitet einen Vorfall und eine Lösung.
Ein Nutzer startet einen Vorfall über eine externe Website, die auf
Apps Script.
Die Website sendet eine asynchrone HTTP-Anfrage an den
Google Chat App, die auch in Apps Script gehostet wird.
Die Google Chat App verarbeitet die Anfrage:
Mit dem Apps Script Admin SDK-Dienst können Teammitglieder
wie Nutzer-ID und E-Mail-Adresse.
Bei einer Reihe von HTTP-Anfragen an die Chat API über die
„Apps Script Advanced Chat“,
Incident Response
Die Google Chat App erstellt einen Vorfall in Chat
Gruppenbereich, füllt ihn mit Teammitgliedern und sendet eine Nachricht an den Gruppenbereich.
Teammitglieder besprechen den Vorfall im Chatbereich.
Ein Teammitglied ruft einen Slash-Befehl auf, um dem
Vorfall.
HTTP-Aufruf an die Chat API mit dem Apps Script
Der erweiterte Chat-Dienst listet alle
Nachrichten des Gruppenbereichs.
Vertex AI empfängt die aufgeführten Nachrichten und generiert eine Zusammenfassung.
Der Apps Script-Dienst DocumentApp erstellt ein
Docs-Dokument und fügt die Zusammenfassung von Vertex AI zum
Dokument.
Google Chat App – Reaktion auf Vorfälle
Chat API, um eine Nachricht mit einem Link zur Zusammenfassung zu senden
Docs-Dokument.
Umgebung vorbereiten
In diesem Abschnitt erfahren Sie, wie Sie ein Google Cloud-Projekt für die
Chat-App.
Durch Authentifizierung und Autorisierung kann das
Zugriff auf Ressourcen der Chat-App in Google Workspace und
Google Cloud, um eine Reaktion auf Vorfälle zu verarbeiten.
In dieser Anleitung veröffentlichen Sie die App intern, sodass Sie Platzhalter
Informationen. Ersetzen Sie den Platzhalter, bevor Sie die App extern veröffentlichen.
mit echten Informationen für den Zustimmungsbildschirm.
Gehen Sie in der Google Cloud Console zu
Menümenu>APIs und Dienste>OAuth-Zustimmungsbildschirm.
Wählen Sie unter Nutzertyp die Option Intern aus und klicken Sie dann auf Erstellen.
Geben Sie unter App-NameIncident Management ein.
Wählen Sie unter Nutzer-Support-E-Mail Ihre E-Mail-Adresse oder eine geeignete
Google-Gruppe.
Geben Sie unter Kontaktdaten des Entwicklers Ihre E-Mail-Adresse ein.
Klicken Sie auf Speichern und fortfahren.
Klicken Sie auf Bereiche hinzufügen oder entfernen. Ein Steuerfeld mit einer Liste der Bereiche wird angezeigt
für jede API, die Sie in Ihrem Cloud-Projekt aktiviert haben.
Fügen Sie unter Bereiche manuell hinzufügen die folgenden Bereiche ein:
Sehen Sie sich die Zusammenfassung der App-Registrierung an und klicken Sie dann auf Zurück zum Dashboard.
Chat-App erstellen und bereitstellen
Im folgenden Abschnitt kopieren und aktualisieren Sie
Apps Script-Projekt, das alle erforderlichen Anwendungen enthält
Code für Ihre Chat-App ändern. Sie müssen den Code also nicht
fügen Sie jede Datei ein.
Einige Funktionen stehen mit Unterstrichen am Ende des Namens, z. B.:
processSlashCommand_() von ChatApp.gs. Mit dem Unterstrich wird die Funktion
von der Webseite zur Initialisierung des Vorfalls ein, wenn diese in einem Browser geöffnet ist. Weitere Informationen
finden Sie unter
Private Funktionen:
Apps Script unterstützt zwei Dateitypen: .gs-Scripts und .html
Dateien. Zur Erfüllung dieser Unterstützung ist das clientseitige JavaScript der App enthalten
innerhalb von <script />-Tags und der zugehörige CSS-Code innerhalb von <style />-Tags innerhalb
eine HTML-Datei.
Optional können Sie das gesamte Projekt auf GitHub ansehen.
Definiert Konstanten, auf die von anderen Codedateien verwiesen wird,
einschließlich der Cloud-Projekt-ID, der Vertex AI-Standort-ID und der
Slash-Befehls-ID zum Schließen eines Vorfalls.
Verarbeitet Chat-Interaktionsereignisse, einschließlich
Nachrichten, Klicks auf Karten, Slash-Befehle und Dialogfelder. Reagiert auf den
Slash-Befehl /closeIncident durch Öffnen eines Dialogfelds zum Erfassen des Vorfalls
Details zur Lösung des Problems. Nachrichten im Gruppenbereich durch Aufrufen der
spaces.messages.list-Methode in der Chat API.
Ruft Nutzer-IDs über den Admin SDK Directory-Dienst in
Apps Script.
/**
* 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
Erhält Formulardaten, die Nutzer bei dem Vorfall eingeben
Initialisierungswebseite zum Einrichten einer Chat-Nachricht
indem Sie ihn erstellen und ausfüllen, und anschließend eine Nachricht zur
Vorfall.
/**
* 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 das Google Docs-API auf, um ein Google Docs-Dokument in einem
eine Zusammenfassung der Informationen
zum Vorfall erstellt,
in VertexAiApi.gs erstellt, in das Dokument.
/**
* 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 Chat zusammen
mit Vertex AI. Diese Zusammenfassung wird in einem eigens erstellten
Dokument in DocsAPI.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
Bedient die Website zur Initialisierung der Vorfälle.
/**
* 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, in dem die Website zur Initialisierung des Vorfalls verwendet wird
<!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 Formularverhalten, einschließlich Senden,
Fehler und Löschungen
für die Website zur Initialisierung des Vorfalls. Inbegriffen
durch die benutzerdefinierte include-Funktion in WebController.gs in Index.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 des Vorfalls Es ist
durch die benutzerdefinierte Funktion include in Index.html aufgenommen
WebController.gs
Klicke auf Einstellungen und Dienstprogramme.
more_vert>Projekteinstellungen.
Notieren Sie sich die Werte in den Feldern Projektnummer und Projekt-ID. Ich
in den folgenden Abschnitten.
Apps Script-Projekt erstellen
Um ein Apps Script-Projekt zu erstellen und mit Ihrem
Cloud-Projekt:
Klicken Sie auf die folgende Schaltfläche, um das Apps Script-Projekt Mit Google Chat auf Vorfälle reagieren zu öffnen.
Projekt öffnen
Klicken Sie auf info_outlineÜbersicht.
Klicken Sie auf der Übersichtsseite auf Kopie erstellen.
Benennen Sie Ihre Kopie des Apps Script-Projekts:
Klicken Sie auf Kopie von „Mit Google Chat auf Vorfälle reagieren“.
Geben Sie unter ProjekttitelIncident Management Chat app ein.
Klicken Sie auf Umbenennen.
Gehen Sie in Ihrer Kopie des Apps Script-Projekts zum Consts.gs
und ersetzen Sie YOUR_PROJECT_ID durch die ID Ihres
Cloud-Projekt
Cloud-Projekt des Apps Script-Projekts festlegen
In Ihrem Apps Script-Projekt
Klicken Sie auf Projekteinstellungen.
Klicken Sie unter Google Cloud Platform-Projekt (GCP-Projekt) auf Projekt ändern.
Fügen Sie unter GCP-Projektnummer die Projektnummer Ihres Cloud-Projekts ein.
Klicken Sie auf Projekt festlegen. Cloud-Projekt und Apps Script
sind jetzt verbunden.
Apps Script-Bereitstellung erstellen
Jetzt, wo der gesamte Code vorhanden ist, können Sie das Apps Script bereitstellen.
Projekt arbeiten. Mit der Bereitstellungs-ID konfigurieren Sie die
Chat-App in Google Cloud
Öffnen Sie in Apps Script das Projekt der App zur Reaktion auf Vorfälle.
Klicken Sie auf Bereitstellen > Neue Bereitstellung.
Wenn Add-on und Web-App noch nicht ausgewählt sind, klicken Sie neben
Wählen Sie den Typ aus, klicken Sie auf die Bereitstellungstypen und wählen Sie dann Add-on und Web-App aus.
Geben Sie unter Beschreibung eine Beschreibung für die Version ein, z. B.
Complete version of incident management app
Wählen Sie unter Ausführen als die Option Nutzer, der auf die Web-App zugreift aus.
Wählen Sie unter Wer hat Zugriff? die Option Jeder in meiner Workspace-Organisation aus.
wobei „Ihre Workspace-Organisation“ ist der Name Ihres
Google Workspace-Organisation.
Klicken Sie auf Bereitstellen. Apps Script-Berichte erfolgreich
Bereitstellung und stellt eine Bereitstellungs-ID und eine URL für den Vorfall bereit
Initialisierungswebseite.
Notieren Sie sich die URL der Web-App. Diese rufen Sie später auf, wenn Sie einen Vorfall starten.
Kopieren Sie die Bereitstellungs-ID. Sie verwenden diese ID bei der Konfiguration des
Chat-App in der Google Cloud Console
Klicken Sie auf Fertig.
Chat-App in der Google Cloud Console konfigurieren
In diesem Abschnitt erfahren Sie, wie Sie die Google Chat API in der Google Cloud Console konfigurieren
mit Informationen zu Ihrer Chat-App, einschließlich der
ID der Bereitstellung, die Sie gerade aus Ihrem Apps Script erstellt haben
Projekt arbeiten.
Klicken Sie in der Google Cloud Console auf das Dreistrich-Menü.
menu>Weitere Produkte>Google Workspace>Produktbibliothek>Google Chat API>Verwalten>Konfiguration.
Geben Sie unter Avatar-URLhttps://developers.google.com/chat/images/quickstart-app-avatar.png ein.
Geben Sie unter BeschreibungResponds to incidents. ein.
Stellen Sie die Ein/Aus-Schaltfläche Interaktive Funktionen aktivieren auf „Ein“.
Wählen Sie unter Funktionen die Option 1:1-Nachrichten empfangen und Gruppenbereichen und Gruppenunterhaltungen beitreten aus.
Wählen Sie unter Verbindungseinstellungen die Option Apps Script-Projekt aus.
Fügen Sie unter Deployment ID (Bereitstellungs-ID) die Deployment-ID für Apps Script ein.
die Sie zuvor aus dem Apps Script-Projekt kopiert haben,
Bereitstellung.
Registrieren Sie einen Slash-Befehl,
die vollständig implementierte Chat-App nutzt:
Klicken Sie unter Slash-Befehle auf Slash-Befehl hinzufügen.
Geben Sie unter Name den Wert /closeIncident ein.
Geben Sie unter Befehls-ID1 ein.
Geben Sie unter BeschreibungCloses the incident being discussed in the space.
Wählen Sie Öffnet ein Dialogfeld aus.
Klicken Sie auf Fertig. Der Slash-Befehl wird registriert und aufgeführt.
Wähle unter Sichtbarkeit die Option
Diese Chat-App für bestimmte Personen und Gruppen in Ihrem
Workspace Domain und geben Sie Ihre E-Mail-Adresse ein.
Wählen Sie unter Logs die Option Fehler in Logging protokollieren aus.
Klicken Sie auf Speichern. Eine Meldung, dass die Konfiguration gespeichert ist, wird angezeigt, was bedeutet, dass die App
testen können.
Chat App testen
Um die Chat-App für das Vorfallmanagement zu testen, initiieren Sie eine
den Vorfall über die Webseite und vergewissern Sie sich, dass die Chat-App
wie erwartet funktioniert:
Rufen Sie die Webanwendungs-URL für die Apps Script-Bereitstellung auf.
Wenn Apps Script Sie um Zugriff auf Ihre Daten bittet,
Klicken Sie auf Berechtigungen prüfen und melden Sie sich mit einem geeigneten Google-Konto an.
in Ihrer Google Workspace-Domain auf und klicken Sie auf Zulassen.
Die Webseite zur Initialisierung des Vorfalls wird geöffnet. Testinformationen eingeben:
Geben Sie unter Titel des VorfallsThe First Incident ein.
Optional: Geben Sie unter Incident Responseers (Incident-Response-Teams) die E-Mail-Adressen der folgenden Personen ein:
anderen Incident-Response-Teams nachzuvollziehen. Sie müssen Nutzer mit einer
Google Chat-Konto in Ihrer Google Workspace-Organisation oder
Fehler beim Erstellen des Gruppenbereichs. Geben Sie nicht Ihre eigene E-Mail-Adresse ein,
automatisch eingeschlossen.
Geben Sie unter Erste NachrichtTesting the incident management Chat app. ein.
Klicken Sie auf Chatbereich erstellen. Die Meldung „creating space“ wird angezeigt.
Nachdem der Gruppenbereich erstellt wurde, wird die Meldung Space created! angezeigt. Klicken Sie auf
Gruppenbereich öffnen: Der Gruppenbereich wird in Google Chat in einem neuen Tab geöffnet.
Optional können Sie und die anderen Incident-Response-Teams Nachrichten im
Leerzeichen. Die Anwendung fasst diese Nachrichten mit Vertex AI zusammen und gibt
Retrospektive dokumentieren können.
Um die Reaktion auf Vorfälle zu beenden und den Lösungsprozess zu starten, klicken Sie in der
Chatbereich, geben Sie „/closeIncident“ ein. Vorfallmanagement
wird geöffnet.
Geben Sie unter Vorfall schließen eine Beschreibung für die Lösung des Vorfalls ein.
wie Test complete.
Klicken Sie auf Vorfall schließen.
Die App „Vorfallmanagement“ listet die Nachrichten im Gruppenbereich auf und fasst sie zusammen
mit Vertex AI, fügt die Zusammenfassung in ein Google Docs-Dokument ein und gibt
im Projektbereich.
Bereinigen
Um zu vermeiden, dass Ihrem Google Cloud-Konto Gebühren für
Ressourcen, die in dieser Anleitung verwendet werden, empfehlen wir, dass Sie den
Cloud-Projekt
Wechseln Sie in der Google Cloud Console zur Seite Ressourcen verwalten. Klicken Sie auf
Menümenu>IAM und Verwaltung>Ressourcen verwalten.
Die Anwendung für die Vorfallreaktion authentifiziert sich mit Nutzeranmeldedaten, um APIs aufzurufen.
und Google Cloud-Dienste wie Chat API und Vertex AI API aufrufen.
Das bedeutet, dass der Nutzer, der einen Vorfall initialisiert,
. Rufen Sie die Vertex AI API auf, um die Anwendung robuster zu machen
als Dienstkonto anstelle der Nutzeranmeldedaten des Nutzers, der
den Slash-Befehl /closeIncident. Hilfe beim Konfigurieren eines Dienstkontos
für die Vertex AI API finden Sie unter
Benutzerdefiniertes Dienstkonto verwenden
Kopie erstellen.
Projekteinstellungen.