ตอบสนองต่อเหตุการณ์ต่างๆ ด้วย Google Chat, Vertex AI และ Apps Script

บทแนะนำนี้จะแสดงวิธีสร้างแอป Google Chat ที่ตอบสนองต่อเหตุการณ์แบบเรียลไทม์ เมื่อตอบสนองต่อเหตุการณ์ แอปจะสร้างและป้อนข้อมูลพื้นที่ทำงานใน Chat, อำนวยความสะดวกในการแก้ปัญหาด้วยข้อความ คำสั่งขีดกลาง และกล่องโต้ตอบ และใช้ AI เพื่อสรุปการตอบสนองต่อเหตุการณ์ในเอกสาร Google เอกสาร

เหตุการณ์คือเหตุการณ์ที่ทีมบุคคลที่เกี่ยวข้องต้องดำเนินการแก้ไขทันที ตัวอย่างเหตุการณ์ ได้แก่

• ระบบจะสร้างเคสที่ต้องดำเนินการโดยเร็วในแพลตฟอร์มการจัดการลูกค้าสัมพันธ์ (CRM) ซึ่งกำหนดให้ทีมบริการต้องทำงานร่วมกันเพื่อหาวิธีแก้ปัญหา
• ระบบออฟไลน์ ซึ่งจะแจ้งเตือนกลุ่มวิศวกรความเสถียรสำหรับเว็บไซต์ (SRE) เพื่อให้ทำงานร่วมกันเพื่อทำให้ระบบกลับมาออนไลน์ได้
• เกิดแผ่นดินไหวขนาดรุนแรงขึ้น และเจ้าหน้าที่กู้ภัยต้องประสานงานกันเพื่อตอบสนอง

ในการทําบทแนะนํานี้ การแจ้งเตือนเหตุการณ์จะเริ่มขึ้นเมื่อมีผู้รายงานเหตุการณ์ด้วยการคลิกปุ่มจากหน้าเว็บ หน้าเว็บจะจำลองเหตุการณ์โดยขอให้ผู้ใช้ป้อนข้อมูลพื้นฐานของเหตุการณ์ ได้แก่ ชื่อ คำอธิบาย และอีเมลของผู้ตอบ

ดูการทำงานจริงของแอป Chat สำหรับเหตุการณ์

ข้อกำหนดเบื้องต้น

หากต้องการเปิดใช้ข้อกําหนดเบื้องต้นต่อไปนี้สําหรับองค์กร โปรดขอให้ผู้ดูแลระบบ Google Workspace เปิดใช้

• บัญชี Google Workspace รุ่น Business หรือ Enterprise ที่มีสิทธิ์เข้าถึง Google Chat
• หากต้องการเปิดใช้ไดเรกทอรี (การแชร์รายชื่อติดต่อ) สำหรับ Google Workspace แอปเหตุการณ์ใช้ไดเรกทอรีเพื่อค้นหาข้อมูลติดต่อของผู้ตอบสนองต่อเหตุการณ์ เช่น ชื่อและอีเมล ผู้ตอบกลับเหตุการณ์ต้องเป็นผู้ใช้ที่มีบัญชี Google Chat ในองค์กร Google Workspace

วัตถุประสงค์

• สร้างแอป Chat ที่ตอบสนองต่อเหตุการณ์
• ช่วยเหลือผู้ใช้ในการตอบสนองต่อเหตุการณ์โดยทําดังนี้
  • การสร้างพื้นที่ทำงานสำหรับการตอบสนองต่อเหตุการณ์
  • โพสต์ข้อความที่สรุปเหตุการณ์และการตอบกลับ
  • การรองรับการทำงานร่วมกันด้วยฟีเจอร์แบบอินเทอร์แอกทีฟของแอปรับแชท
• สรุปการสนทนาและการแก้ปัญหาด้วย Vertex AI

สถาปัตยกรรม

แผนภาพต่อไปนี้แสดงสถาปัตยกรรมของ Google Workspace และแหล่งข้อมูล Google Cloud ที่แอป Google Chat ที่ใช้จัดการเหตุการณ์ใช้

สถาปัตยกรรมนี้แสดงวิธีที่ทีมตอบสนองต่อเหตุการณ์แอป Google Chat ประมวลผลเหตุการณ์และการแก้ปัญหา

1. ผู้ใช้เริ่มเหตุการณ์จากเว็บไซต์ภายนอกที่โฮสต์ใน Apps Script

2. เว็บไซต์จะส่งคำขอ HTTP แบบไม่พร้อมกันไปยังแอป Google Chat ซึ่งโฮสต์อยู่ใน Apps Script ด้วย

3. แอป Google Chat ที่ตอบสนองต่อเหตุการณ์จะดำเนินการตามคำขอ ดังนี้

   1. บริการ Admin SDK ของ Apps Script จะรับข้อมูลสมาชิกในทีม เช่น รหัสผู้ใช้และอีเมล

   2. เมื่อใช้ชุดคำขอ HTTP ไปยัง Chat API โดยใช้บริการ Chat ขั้นสูงของ Apps Script ทีมตอบกลับเหตุการณ์ของแอป Google Chat จะสร้างพื้นที่ทำงานใน Chat สำหรับเหตุการณ์นั้น เพิ่มสมาชิกในทีม และส่งข้อความไปยังพื้นที่ทำงาน

4. สมาชิกทีมพูดคุยเกี่ยวกับเหตุการณ์ดังกล่าวในพื้นที่ใน Chat

5. สมาชิกในทีมเรียกใช้คำสั่งเครื่องหมายทับเพื่อส่งสัญญาณการแก้ปัญหาเหตุการณ์

   1. การเรียก HTTP ไปยัง Chat API โดยใช้บริการ Chat ขั้นสูง Apps Script จะแสดงรายการข้อความทั้งหมดของพื้นที่ใน Chat

   2. Vertex AI จะได้รับข้อความที่แสดงและสร้างสรุป

   3. บริการ Apps Script DocumentApp จะสร้างเอกสารใน Google เอกสารและเพิ่มข้อมูลสรุปของ Vertex AI ลงในเอกสาร

   4. แอป Google Chat สำหรับการตอบสนองต่อเหตุการณ์จะเรียกใช้ Chat API เพื่อส่งข้อความที่แชร์ลิงก์ไปยังเอกสารสรุปใน Google เอกสาร

เตรียมสภาพแวดล้อม

ส่วนนี้จะแสดงวิธีสร้างและกําหนดค่าโปรเจ็กต์ Google Cloud สําหรับแอป Chat

สร้างโปรเจ็กต์ Google Cloud

คอนโซล Google Cloud

1. ใน Google Cloud Console ให้ไปที่เมนู menu > IAM และผู้ดูแลระบบ > สร้างโปรเจ็กต์

   ไปที่ "สร้างโปรเจ็กต์"

2. ป้อนชื่อที่สื่อความหมายสำหรับโปรเจ็กต์ในช่องชื่อโปรเจ็กต์

   ไม่บังคับ: หากต้องการแก้ไขรหัสโปรเจ็กต์ ให้คลิกแก้ไข คุณจะเปลี่ยนรหัสโปรเจ็กต์ไม่ได้หลังจากสร้างโปรเจ็กต์แล้ว ดังนั้นโปรดเลือกรหัสที่ตรงกับความต้องการของคุณตลอดอายุการใช้งานของโปรเจ็กต์

3. ในช่องสถานที่ ให้คลิกเรียกดูเพื่อแสดงสถานที่ที่เป็นไปได้สำหรับโปรเจ็กต์ จากนั้นคลิกเลือก
4. คลิกสร้าง คอนโซล Google Cloud จะไปยังหน้าแดชบอร์ดและสร้างโปรเจ็กต์ภายในไม่กี่นาที

gcloud CLI

เข้าถึง Google Cloud CLI (gcloud) ในสภาพแวดล้อมการพัฒนาข้อใดข้อหนึ่งต่อไปนี้

• Cloud Shell: หากต้องการใช้เทอร์มินัลออนไลน์ที่มีการตั้งค่า gcloud CLI ไว้แล้ว ให้เปิดใช้งาน Cloud Shell
  เปิดใช้งาน Cloud Shell
• เชลล์ในเครื่อง: หากต้องการใช้สภาพแวดล้อมการพัฒนาซอฟต์แวร์ในเครื่อง ให้ติดตั้งและเริ่มต้น CLI ของ gcloud
  หากต้องการสร้างโปรเจ็กต์ Cloud ให้ใช้คำสั่ง gcloud projects create ดังนี้

  gcloud projects create PROJECT_ID

  แทนที่ PROJECT_ID ด้วยการตั้งรหัสสำหรับโปรเจ็กต์ที่ต้องการสร้าง

เปิดใช้การเรียกเก็บเงินสำหรับโปรเจ็กต์ที่อยู่ในระบบคลาวด์

คอนโซล Google Cloud

1. ในคอนโซล Google Cloud ให้ไปที่การเรียกเก็บเงิน คลิกเมนู menu > การเรียกเก็บเงิน > โปรเจ็กต์ของฉัน

   ไปที่การเรียกเก็บเงินสำหรับโปรเจ็กต์

2. ในส่วนเลือกองค์กร ให้เลือกองค์กรที่เชื่อมโยงกับโปรเจ็กต์ Google Cloud
3. ในแถวโปรเจ็กต์ ให้เปิดเมนูการดําเนินการ (more_vert) คลิกเปลี่ยนการเรียกเก็บเงิน แล้วเลือกบัญชีการเรียกเก็บเงินระบบคลาวด์
4. คลิกตั้งค่าบัญชี

gcloud CLI

1. หากต้องการแสดงรายการบัญชีสำหรับการเรียกเก็บเงินที่ใช้ได้ ให้เรียกใช้

   gcloud billing accounts list

2. วิธีลิงก์บัญชีสำหรับการเรียกเก็บเงินกับโปรเจ็กต์ Google Cloud

   gcloud billing projects link PROJECT_ID --billing-account=BILLING_ACCOUNT_ID

   แทนที่ค่าต่อไปนี้

   • PROJECT_ID คือรหัสโปรเจ็กต์ของโปรเจ็กต์ที่อยู่ในระบบคลาวด์ที่คุณต้องการเปิดใช้การเรียกเก็บเงิน
   • BILLING_ACCOUNT_ID คือรหัสบัญชีสำหรับการเรียกเก็บเงินที่จะลิงก์กับโปรเจ็กต์ Google Cloud

เปิดใช้ API

ตั้งค่าการตรวจสอบสิทธิ์และการให้สิทธิ์

การตรวจสอบสิทธิ์และการให้สิทธิ์ช่วยให้แอป Chat เข้าถึงทรัพยากรใน Google Workspace และ Google Cloud เพื่อประมวลผลการตอบสนองของเหตุการณ์ได้

ในบทแนะนำนี้ คุณเผยแพร่แอปภายในได้ จึงใช้ข้อมูลตัวยึดตำแหน่งได้ ก่อนเผยแพร่แอปสู่ภายนอก ให้แทนที่ข้อมูลตัวยึดตําแหน่งด้วยข้อมูลจริงสําหรับหน้าจอความยินยอม

1. ในคอนโซล Google Cloud ให้ไปที่ เมนู menu > API และบริการ > หน้าจอขอความยินยอม OAuth

   ไปที่หน้าจอขอความยินยอม OAuth

2. ในส่วนประเภทผู้ใช้ ให้เลือกภายใน แล้วคลิกสร้าง

3. พิมพ์ Incident Management ในชื่อแอป

4. ในอีเมลการสนับสนุนผู้ใช้ ให้เลือกอีเมลของคุณหรือกลุ่ม Google ที่เหมาะสม

5. ป้อนอีเมลของคุณในส่วนข้อมูลติดต่อของนักพัฒนาแอป

6. คลิกบันทึกและต่อไป

7. คลิกเพิ่มหรือนำขอบเขตออก แผงจะปรากฏขึ้นพร้อมรายการขอบเขตสำหรับ API แต่ละรายการที่คุณเปิดใช้ในโปรเจ็กต์ Cloud

8. ในส่วนเพิ่มขอบเขตด้วยตนเอง ให้วางขอบเขตต่อไปนี้

   • https://www.googleapis.com/auth/chat.spaces.create
   • https://www.googleapis.com/auth/chat.memberships
   • https://www.googleapis.com/auth/chat.memberships.app
   • https://www.googleapis.com/auth/chat.messages
   • https://www.googleapis.com/auth/documents
   • https://www.googleapis.com/auth/admin.directory.user.readonly
   • https://www.googleapis.com/auth/script.external_request
   • https://www.googleapis.com/auth/userinfo.email
   • https://www.googleapis.com/auth/cloud-platform

9. คลิกเพิ่มลงในตาราง

10. คลิกอัปเดต

11. คลิกบันทึกและต่อไป

12. ตรวจสอบข้อมูลสรุปการลงทะเบียนแอป แล้วคลิกกลับไปที่หน้าแดชบอร์ด

สร้างและติดตั้งใช้งานแอป Chat

ในส่วนต่อไปนี้ คุณจะคัดลอกและอัปเดตโปรเจ็กต์ Apps Script ทั้งหมดซึ่งมีโค้ดแอปพลิเคชันที่จำเป็นทั้งหมดสำหรับแอป Chat คุณจึงไม่ต้องคัดลอกและวางไฟล์แต่ละไฟล์

ฟังก์ชันบางรายการจะมีขีดล่างต่อท้ายชื่อ เช่น processSlashCommand_() จาก ChatApp.gs เครื่องหมายขีดล่างจะซ่อนฟังก์ชันนี้จากหน้าเว็บสำหรับการเริ่มต้นเหตุการณ์เมื่อเปิดในเบราว์เซอร์ ดูข้อมูลเพิ่มเติมได้ที่ฟังก์ชันส่วนตัว

Apps Script รองรับไฟล์ 2 ประเภท ได้แก่ .gsสคริปต์และ.htmlไฟล์ ในการปฏิบัติตามการรองรับนี้ คุณต้องรวม JavaScript ฝั่งไคลเอ็นต์ของแอปไว้ในแท็ก <script /> และรวม CSS ไว้ในแท็ก <style /> ภายในไฟล์ HTML

คุณดูทั้งโปรเจ็กต์ใน GitHub ได้ด้วย (ไม่บังคับ)

ดูใน GitHub

ต่อไปนี้เป็นภาพรวมของไฟล์แต่ละไฟล์

Consts.gs

กำหนดค่าคงที่ที่ไฟล์โค้ดอื่นๆ อ้างอิง ซึ่งรวมถึงรหัสโปรเจ็กต์ที่อยู่ในระบบคลาวด์ รหัสตำแหน่ง Vertex AI และรหัสคำสั่งเครื่องหมายทับสำหรับการปิดเหตุการณ์

ดูรหัส Consts.gs

apps-script/incident-response/Consts.gs

ดูใน GitHub

const PROJECT_ID = 'replace-with-your-project-id';
const VERTEX_AI_LOCATION_ID = 'us-central1';
const CLOSE_INCIDENT_COMMAND_ID = 1;

ChatApp.gs

จัดการเหตุการณ์การโต้ตอบใน Chat ซึ่งรวมถึงข้อความ การคลิกการ์ด คำสั่งขีดกลาง และกล่องโต้ตอบ ตอบสนองต่อคอมมา /closeIncident โดยเปิดกล่องโต้ตอบเพื่อรวบรวมรายละเอียดการแก้ปัญหาเหตุการณ์ อ่านข้อความในพื้นที่ทำงานโดยการเรียกใช้เมธอด spaces.messages.list ใน Chat API รับรหัสผู้ใช้โดยใช้บริการไดเรกทอรี Admin SDK ใน Apps Script

ดูรหัส ChatApp.gs

apps-script/incident-response/ChatApp.gs

ดูใน GitHub

/**
 * 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

รับข้อมูลแบบฟอร์มที่ผู้ใช้ป้อนในหน้าเว็บสำหรับการเริ่มต้นเหตุการณ์ และใช้ข้อมูลดังกล่าวเพื่อตั้งค่าพื้นที่ใน Chat โดยการสร้างและป้อนข้อมูลในนั้น จากนั้นโพสต์ข้อความเกี่ยวกับเหตุการณ์

ดูรหัส ChatSpaceCreator.gs

apps-script/incident-response/ChatSpaceCreator.gs

ดูใน GitHub

/**
 * 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

เรียกใช้ Google Docs API เพื่อสร้างเอกสาร Google เอกสารใน Google ไดรฟ์ของผู้ใช้ และเขียนข้อมูลสรุปของเหตุการณ์ที่สร้างขึ้นเมื่อ VertexAiApi.gs ลงในเอกสาร

ดูรหัส DocsApi.gs

apps-script/incident-response/DocsApi.gs

ดูใน GitHub

/**
 * 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

สรุปการสนทนาในพื้นที่ทำงานของ Chat โดยใช้ Vertex AI สรุปนี้จะโพสต์ในเอกสารที่สร้างขึ้นเป็นพิเศษใน DocsAPI.gs

ดูรหัส VertexAiApi.gs

apps-script/incident-response/VertexAiApi.gs

ดูใน GitHub

/**
 * 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

แสดงเว็บไซต์สำหรับการเริ่มต้นเหตุการณ์

ดูรหัส WebController.gs

apps-script/incident-response/WebController.gs

ดูใน GitHub

/**
 * 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

HTML ที่ประกอบขึ้นเป็นเว็บไซต์สำหรับการเริ่มต้นเหตุการณ์

ดูรหัส Index.html

apps-script/incident-response/Index.html

ดูใน GitHub

<!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

จัดการลักษณะการทํางานของแบบฟอร์ม ซึ่งรวมถึงการส่ง ข้อผิดพลาด และการล้างสําหรับเว็บไซต์การเริ่มต้นเหตุการณ์ ข้อมูลนี้รวมอยู่ใน Index.html โดยฟังก์ชัน include ที่กําหนดเองใน WebController.gs

ดูรหัส JavaScript.html

apps-script/incident-response/JavaScript.html

ดูใน GitHub

<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

CSS สําหรับเว็บไซต์การเริ่มต้นเหตุการณ์ ข้อมูลนี้รวมอยู่ใน Index.html โดยฟังก์ชัน include ที่กําหนดเองใน WebController.gs

ดูรหัส Stylesheet.html

apps-script/incident-response/Stylesheet.html

ดูใน GitHub

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

ค้นหาหมายเลขและรหัสโปรเจ็กต์ที่อยู่ในระบบคลาวด์

1. ไปที่โปรเจ็กต์ที่อยู่ในระบบคลาวด์ในคอนโซล Google Cloud

   ไปที่คอนโซล Google Cloud

2. คลิกการตั้งค่าและยูทิลิตี more_vert > การตั้งค่าโปรเจ็กต์

3. สังเกตค่าต่างๆ ในช่องหมายเลขโปรเจ็กต์และรหัสโปรเจ็กต์ คุณจะใช้ส่วนต่อไปนี้ได้

สร้างโปรเจ็กต์ Apps Script

วิธีสร้างโปรเจ็กต์ Apps Script และเชื่อมต่อกับโปรเจ็กต์ใน Cloud

1. คลิกปุ่มต่อไปนี้เพื่อเปิดโปรเจ็กต์ Apps Script ตอบกลับเหตุการณ์ด้วย Google Chat
   เปิดโปรเจ็กต์
2. คลิก info_outline ภาพรวม
3. ในหน้าภาพรวม ให้คลิก ทำสำเนา

4. ตั้งชื่อสําเนาของโปรเจ็กต์ Apps Script

   1. คลิกสำเนาของ "ตอบกลับเหตุการณ์ด้วย Google Chat"

   2. ในชื่อโปรเจ็กต์ ให้พิมพ์ Incident Management Chat app

   3. คลิกเปลี่ยนชื่อ

5. ในสำเนาโปรเจ็กต์ Apps Script ให้ไปที่Consts.gsไฟล์ แล้วแทนที่ YOUR_PROJECT_ID ด้วยรหัสโปรเจ็กต์ Google Cloud

ตั้งค่าโปรเจ็กต์ที่อยู่ในระบบคลาวด์ของโปรเจ็กต์ Apps Script

1. ในโปรเจ็กต์ Apps Script ให้คลิก Project Settings
2. ในส่วนโครงการ Google Cloud Platform (GCP) ให้คลิกเปลี่ยนโครงการ
3. ในหมายเลขโปรเจ็กต์ GCP ให้วางหมายเลขโปรเจ็กต์ที่อยู่ในระบบคลาวด์
4. คลิกตั้งค่าโปรเจ็กต์ โปรเจ็กต์ Cloud และโปรเจ็กต์ Apps Script เชื่อมต่อกันแล้ว

สร้าง Apps Script ที่นำไปใช้งาน

เมื่อใส่โค้ดทั้งหมดแล้ว ให้ทำให้โปรเจ็กต์ Apps Script ใช้งานได้ คุณจะใช้รหัสการทำให้ใช้งานได้เมื่อกำหนดค่าแอป Chat ใน Google Cloud

1. เปิดโปรเจ็กต์ของแอปการตอบสนองเหตุการณ์ใน Apps Script

   ไปที่ Apps Script

2. คลิกทำให้ใช้งานได้ > การทำให้ใช้งานได้ใหม่

3. หากยังไม่ได้เลือกส่วนเสริมและเว็บแอป ให้คลิกประเภทการทำให้ใช้งานได้ ถัดจากเลือกประเภท จากนั้นเลือกส่วนเสริมและเว็บแอป

4. ในคำอธิบาย ให้ป้อนคำอธิบายสำหรับเวอร์ชันนี้ เช่น Complete version of incident management app

5. ในดำเนินการในฐานะ ให้เลือกผู้ใช้ที่เข้าถึงเว็บแอป

6. ในส่วนผู้ที่มีสิทธิ์เข้าถึง ให้เลือกทุกคนภายในองค์กร Workspace ของคุณ โดย "องค์กร Workspace ของคุณ" คือชื่อองค์กร Google Workspace ของคุณ

7. คลิกทำให้ใช้งานได้ Apps Script รายงานการติดตั้งใช้งานที่ประสบความสำเร็จ พร้อมระบุรหัสการทำให้ใช้งานได้และ URL สำหรับหน้าเว็บการเริ่มต้นเหตุการณ์

8. จด URL ของ เว็บแอปไว้เพื่อเข้าชมในภายหลังเมื่อคุณเริ่มเหตุการณ์ คัดลอกรหัสการทำให้ใช้งานได้ คุณจะใช้รหัสนี้ขณะกำหนดค่าแอป Chat ในคอนโซล Google Cloud

9. คลิกเสร็จสิ้น

กำหนดค่าแอป Chat ในคอนโซล Google Cloud

ส่วนนี้จะแสดงวิธีกำหนดค่า Google Chat API ในคอนโซล Google Cloud พร้อมข้อมูลเกี่ยวกับแอป Chat รวมถึงรหัสของการใช้งานที่คุณเพิ่งสร้างขึ้นจากโปรเจ็กต์ Apps Script

1. ในคอนโซล Google Cloud ให้คลิกเมนู menu > ผลิตภัณฑ์เพิ่มเติม > Google Workspace > คลังผลิตภัณฑ์ > Google Chat API > จัดการ > การกำหนดค่า

   ไปที่การกำหนดค่า Chat API

2. พิมพ์ Incident Management ในชื่อแอป

3. ใน URL ของรูปโปรไฟล์ ให้พิมพ์ https://developers.google.com/chat/images/quickstart-app-avatar.png

4. พิมพ์ Responds to incidents. ในคำอธิบาย

5. คลิกปุ่มเปิด/ปิดเปิดใช้ฟีเจอร์แบบอินเทอร์แอกทีฟเป็นเปิด

6. ในส่วนฟังก์ชัน ให้เลือกรับข้อความแบบ 1:1 เข้าร่วมพื้นที่ทำงานและการสนทนากลุ่ม

7. ในส่วนการตั้งค่าการเชื่อมต่อ ให้เลือก Apps Script

8. ในรหัสการทำให้ใช้งานได้ ให้วางรหัสการทำให้ใช้งานได้ของ Apps Script ที่คัดลอกไว้ก่อนหน้านี้จากการทำให้ใช้งานได้ของโปรเจ็กต์ Apps Script

9. ลงทะเบียนคำสั่งเครื่องหมายทับซึ่งแอป Chat ที่ใช้งานอย่างเต็มรูปแบบจะใช้สิ่งต่อไปนี้

   1. ในส่วนคำสั่งเครื่องหมายทับ ให้คลิกเพิ่มคำสั่งเครื่องหมายทับ

   2. พิมพ์ /closeIncident ในส่วนชื่อ

   3. ในรหัสคําสั่ง ให้พิมพ์ 1

   4. ใน Description ให้พิมพ์ Closes the incident being discussed in the space.

   5. เลือกเปิดกล่องโต้ตอบ

   6. คลิกเสร็จสิ้น ลงทะเบียนและแสดงคำสั่งเครื่องหมายทับแล้ว

10. ในส่วนระดับการเข้าถึง ให้เลือกทำให้แอป Chat นี้พร้อมให้บริการแก่บุคคลและกลุ่มที่เฉพาะเจาะจงในโดเมน Workspace แล้วป้อนอีเมลของคุณ

11. ในส่วนบันทึก ให้เลือกบันทึกข้อผิดพลาดไปยังการบันทึก

12. คลิกบันทึก ข้อความ "การกําหนดค่าที่บันทึกไว้" จะปรากฏขึ้น ซึ่งหมายความว่าแอปพร้อมที่จะทดสอบแล้ว

ทดสอบแอป Chat

หากต้องการทดสอบแอป Chat การจัดการเหตุการณ์ ให้เริ่มต้นเหตุการณ์จากหน้าเว็บ แล้วตรวจสอบว่าแอป Chat ทำงานตามที่คาดไว้ ดังนี้

1. ไปที่ URL ของเว็บแอปที่ใช้ติดตั้งใช้งาน Apps Script

2. เมื่อ Apps Script ขอสิทธิ์เข้าถึงข้อมูล ให้คลิกตรวจสอบสิทธิ์ ลงชื่อเข้าใช้ด้วยบัญชี Google ที่เหมาะสมในโดเมน Google Workspace แล้วคลิกอนุญาต

3. หน้าเว็บสำหรับเริ่มต้นเหตุการณ์จะเปิดขึ้น ป้อนข้อมูลการทดสอบ

   1. พิมพ์ The First Incident ในชื่อเหตุการณ์
   2. (ไม่บังคับ) ในผู้ตอบกลับเหตุการณ์ ให้ป้อนอีเมลของผู้ตอบกลับเหตุการณ์คนอื่นๆ โดยบุคคลดังกล่าวต้องเป็นผู้ใช้ที่มีบัญชี Google Chat ในองค์กร Google Workspace มิฉะนั้นการสร้างพื้นที่ทำงานจะไม่สำเร็จ อย่าป้อนอีเมลของคุณเองเนื่องจากระบบจะรวมอีเมลนั้นไว้ให้โดยอัตโนมัติ
   3. ในข้อความเริ่มต้น ให้พิมพ์ Testing the incident management Chat app.

4. คลิกสร้างพื้นที่ทำงานใน Chat ข้อความ creating space จะปรากฏขึ้น

5. หลังจากสร้างพื้นที่ทำงานแล้ว ข้อความ Space created! จะปรากฏขึ้น คลิกเปิดพื้นที่ทำงาน ซึ่งจะเปิดพื้นที่ทำงานใน Chat ในแท็บใหม่

6. หรือคุณจะเลือกคุณและผู้ตอบเหตุการณ์คนอื่นๆ จะส่งข้อความในพื้นที่ทำงานได้ แอปจะสรุปข้อความเหล่านี้โดยใช้ Vertex AI และแชร์เอกสารย้อนหลัง

7. หากต้องการสิ้นสุดการตอบสนองต่อเหตุการณ์และเริ่มกระบวนการแก้ไข ให้พิมพ์ /closeIncident ในพื้นที่ทำงานของแชท กล่องโต้ตอบการจัดการเหตุการณ์จะเปิดขึ้น

8. ในปิดเหตุการณ์ ให้ป้อนคำอธิบายสำหรับการแก้ไขเหตุการณ์ เช่น Test complete

9. คลิกปิดเหตุการณ์

แอปการจัดการเหตุการณ์จะแสดงข้อความในพื้นที่ทำงาน สรุปข้อความด้วย Vertex AI วางข้อมูลสรุปในเอกสาร Google เอกสาร และแชร์เอกสารในพื้นที่ทำงาน

ล้างข้อมูล

เราขอแนะนำให้คุณลบโปรเจ็กต์ Cloud เพื่อหลีกเลี่ยงการเรียกเก็บเงินจากบัญชี Google Cloud สำหรับทรัพยากรที่ใช้ในบทแนะนำนี้

1. ในคอนโซล Google Cloud ให้ไปที่หน้าจัดการทรัพยากร คลิก เมนู menu > IAM และผู้ดูแลระบบ > จัดการทรัพยากร

   ไปที่เครื่องมือจัดการทรัพยากร

2. ในรายการโปรเจ็กต์ ให้เลือกโปรเจ็กต์ที่ต้องการลบ แล้วคลิกลบ delete
3. ในกล่องโต้ตอบ ให้พิมพ์รหัสโปรเจ็กต์แล้วคลิกปิดเครื่องเพื่อลบโปรเจ็กต์

หัวข้อที่เกี่ยวข้อง

• ตอบคำถามตามการสนทนาใน Chat ด้วยแอปแชท AI ของ Gemini
• จัดการโปรเจ็กต์ด้วย Google Chat, Vertex AI และ Firestore
• แอปการตอบสนองต่อเหตุการณ์จะตรวจสอบสิทธิ์ด้วยข้อมูลเข้าสู่ระบบของผู้ใช้เพื่อเรียกใช้ API และเรียกใช้บริการ Google Cloud เช่น Chat API และ Vertex AI API ซึ่งหมายความว่าผู้ใช้ที่เริ่มต้นเหตุการณ์ต้องมีสิทธิ์เข้าถึงบริการเหล่านี้ หากต้องการให้แอปมีประสิทธิภาพมากขึ้น ให้ลองเรียกใช้ Vertex AI API ด้วยบัญชีบริการแทนข้อมูลเข้าสู่ระบบของผู้ใช้ที่เรียกใช้คำสั่ง /closeIncident slash หากต้องการความช่วยเหลือในการกําหนดค่าบัญชีบริการสําหรับ Vertex AI API โปรดดูหัวข้อใช้บัญชีบริการที่กําหนดเอง