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

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

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

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

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

ดูแอปการจัดการเหตุการณ์ใน Chat ใช้งานได้จริง

  • เว็บไซต์ที่เริ่มเหตุการณ์
    รูปที่ 1 เว็บไซต์ที่ผู้ใช้รายงานเหตุการณ์ได้
  • การแจ้งเตือนว่าสร้างพื้นที่ใน Chat ของเหตุการณ์แล้ว
    รูปที่ 2 การแจ้งเตือนว่ามีการสร้างพื้นที่ใน Chat ของเหตุการณ์
  • พื้นที่ใน Chat สำหรับการตอบสนองต่อเหตุการณ์
    รูปที่ 3 พื้นที่ใน Chat สำหรับการตอบสนองต่อเหตุการณ์
  • การแก้ไขเหตุการณ์ด้วยคําสั่งเครื่องหมายทับ
    รูปที่ 4 แก้ปัญหาด้วยคำสั่งเครื่องหมายทับ
  • กล่องโต้ตอบการแก้ไขเหตุการณ์
    รูปที่ 5 กล่องโต้ตอบการแก้ไขเหตุการณ์
  • เอกสารใน Google เอกสารเกี่ยวกับการแก้ไขเหตุการณ์ที่แชร์ในพื้นที่ทำงาน
    รูปที่ 6 เอกสาร Google เอกสารเกี่ยวกับการแก้ปัญหาที่แชร์ในพื้นที่ทำงาน
  • เอกสารเกี่ยวกับการแก้ปัญหาเหตุการณ์สรุปเหตุการณ์โดย AI ใน Google เอกสาร
    รูปที่ 7 เอกสาร Google เอกสารเกี่ยวกับการแก้ปัญหาเกี่ยวกับ AI ฉบับสรุป

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

หากต้องการเปิดใช้ข้อกําหนดเบื้องต้นต่อไปนี้สําหรับองค์กร โปรดขอให้ผู้ดูแลระบบ 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 สำหรับการตอบสนองต่อเหตุการณ์

สถาปัตยกรรมแสดงการตอบสนองของเหตุการณ์ แอป Google Chat จะประมวลผลเหตุการณ์และการแก้ไขปัญหา

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

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

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

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

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

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

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

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

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

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

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

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

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

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

คอนโซล Google Cloud

  1. ในคอนโซล Google Cloud ให้ไปที่เมนู > IAM และ ผู้ดูแลระบบ > สร้างโครงการ

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

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

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

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

gcloud CLI

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

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

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

คอนโซล Google Cloud

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

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

  2. ในส่วนเลือกองค์กร ให้เลือกองค์กรที่เชื่อมโยงกับโปรเจ็กต์ Google Cloud
  3. ในแถวโปรเจ็กต์ ให้เปิดเมนูการดำเนินการ (), คลิกเปลี่ยนแปลงการเรียกเก็บเงิน และเลือก บัญชีสำหรับการเรียกเก็บเงินใน Cloud
  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

คอนโซล Google Cloud

  1. ในคอนโซล Google Cloud ให้เปิดใช้ Google Chat API, Google Docs API Admin SDK API และ Vertex AI API

    เปิดใช้ API

  2. ยืนยันว่าคุณเปิดใช้ API ใน โปรเจ็กต์ที่อยู่ในระบบคลาวด์ จากนั้นคลิกถัดไป

  3. ตรวจสอบว่าคุณเปิดใช้ API ที่ถูกต้อง แล้วคลิกเปิดใช้

gcloud CLI

  1. หากจำเป็น ให้ตั้งค่าโปรเจ็กต์ระบบคลาวด์ปัจจุบันเป็นโปรเจ็กต์ที่คุณสร้าง ด้วยคำสั่ง gcloud config set project:

    gcloud config set project PROJECT_ID

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

  2. เปิดใช้ Google Chat API, Google Docs API, Admin SDK API และ Vertex AI API ด้วยคำสั่ง gcloud services enable:

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

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

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

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

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

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

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

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

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

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

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

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

  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

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

ดูรหัส Consts.gs

apps-script/incident-response/Consts.gs
const PROJECT_ID = 'replace-with-your-project-id';
const VERTEX_AI_LOCATION_ID = 'us-central1';
const CLOSE_INCIDENT_COMMAND_ID = 1;
ChatApp.gs

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

ดูรหัส ChatApp.gs

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

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

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

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

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

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

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

ดูรหัส ChatSpaceCreator.gs

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

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

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

/**
 * Posts a text message to the space on behalf of the user.
 *
 * @return {string} the resource name of the new message.
 */
function createMessage_(spaceName, text) {
  const request = {
    text: text
  };
  // Call Chat API method spaces.messages.create
  const message = Chat.Spaces.Messages.create(request, spaceName);
  return message.name;
}
DocsApi.gs

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

ดูรหัส DocsApi.gs

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

สรุปการสนทนาในพื้นที่ทำงานของ Chat โดยใช้ Vertex AI ข้อมูลสรุปนี้โพสต์ไว้ในหมวดหมู่ เอกสารใน DocsAPI.gs

ดูรหัส VertexAiApi.gs

apps-script/incident-response/VertexAiApi.gs
/**
 * Summarizes a Chat conversation using the Vertex AI text prediction API.
 *
 * @param {string} chatHistory The Chat history that will be summarized.
 * @return {string} The content from the text prediction response.
 */
function summarizeChatHistory_(chatHistory) {
  const prompt =
    "Summarize the following conversation between Engineers resolving an incident"
      + " in a few sentences. Use only the information from the conversation.\n\n"
      + chatHistory;
  const request = {
    instances: [
      { prompt: prompt }
    ],
    parameters: {
      temperature: 0.2,
      maxOutputTokens: 256,
      topK: 40,
      topP: 0.95
    }
  }
  const fetchOptions = {
    method: 'POST',
    headers: { Authorization: 'Bearer ' + ScriptApp.getOAuthToken() },
    contentType: 'application/json',
    payload: JSON.stringify(request)
  }
  const response = UrlFetchApp.fetch(
    `https://${VERTEX_AI_LOCATION_ID}-aiplatform.googleapis.com/v1`
      + `/projects/${PROJECT_ID}/locations/${VERTEX_AI_LOCATION_ID}`
      + "/publishers/google/models/text-bison:predict",
    fetchOptions);
  const payload = JSON.parse(response.getContentText());
  return payload.predictions[0].content;
}
WebController.gs

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

ดูรหัส WebController.gs

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

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

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

HTML ที่ประกอบด้วยเว็บไซต์การเริ่มต้นเหตุการณ์

ดูรหัส Index.html

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

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

ดูรหัส JavaScript.html

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

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

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

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

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

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

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

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

ดูรหัส Stylesheet.html

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

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

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

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

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

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

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

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

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

  4. ตั้งชื่อสำเนาโครงการ Apps Script ดังนี้

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

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

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

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

ตั้งค่าโปรเจ็กต์ 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 ให้คลิกเมนู > ผลิตภัณฑ์เพิ่มเติม > 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. ในคำอธิบาย ให้พิมพ์ 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 แล้วคลิก Allow

  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. หากต้องการสิ้นสุดการตอบสนองต่อเหตุการณ์และเริ่มกระบวนการแก้ปัญหาใน พื้นที่ใน Chat ประเภท /closeIncident การจัดการเหตุการณ์ กล่องโต้ตอบจะเปิดขึ้น

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

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

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

ล้างข้อมูล

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

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

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

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