สร้างบ็อต Slack ด้วย Node.js ใน Cloud Run

1. ภาพรวม

ในโค้ดแล็บนี้ คุณจะได้เรียนรู้วิธีสร้างบ็อต Slack โดยใช้ชุดเครื่องมือ Botkit และเรียกใช้ใน Google Cloud คุณจะโต้ตอบกับบ็อตได้ในช่อง Slack แบบเรียลไทม์

สิ่งที่คุณจะได้เรียนรู้

วิธีสร้างการผสานรวมบ็อตที่กำหนดเองใน Slack
วิธีรักษาความปลอดภัยของข้อมูลลับใน Slack ด้วย Secret Manager
วิธีติดตั้งใช้งานบ็อต Slack ใน Cloud Run ซึ่งเป็นแพลตฟอร์มการประมวลผลที่มีการจัดการครบวงจรซึ่งจะปรับขนาดคอนเทนเนอร์แบบไม่เก็บสถานะโดยอัตโนมัติ

สิ่งที่คุณต้องมี

โปรเจ็กต์ Google Cloud
เบราว์เซอร์ เช่น Chrome หรือ Firefox

คุณจะใช้บทแนะนำนี้อย่างไร

อ่านอย่างเดียว

อ่านและทำแบบฝึกหัด

คุณจะให้คะแนนประสบการณ์การใช้งาน Google Cloud เท่าใด

ผู้ฝึกหัด

ขั้นกลาง

ผู้ชำนาญ

2. การตั้งค่าและข้อกำหนด

การตั้งค่าสภาพแวดล้อมแบบเรียนรู้ด้วยตนเอง

ลงชื่อเข้าใช้ Google Cloud Console แล้วสร้างโปรเจ็กต์ใหม่หรือใช้โปรเจ็กต์ที่มีอยู่ซ้ำ หากยังไม่มีบัญชี Gmail หรือ Google Workspace คุณต้องสร้างบัญชี

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

จากนั้นคุณจะต้องเปิดใช้การเรียกเก็บเงินใน Cloud Console เพื่อใช้ทรัพยากร/API ของ Cloud การทำตาม Codelab นี้จะไม่มีค่าใช้จ่ายมากนัก หรืออาจไม่มีค่าใช้จ่ายเลย หากต้องการปิดทรัพยากรเพื่อหลีกเลี่ยงการเรียกเก็บเงินนอกเหนือจากบทแนะนำนี้ คุณสามารถลบทรัพยากรที่สร้างขึ้นหรือลบโปรเจ็กต์ได้ ผู้ใช้ Google Cloud รายใหม่มีสิทธิ์เข้าร่วมโปรแกรมช่วงทดลองใช้ฟรีมูลค่า$300 USD

เริ่มต้น Cloud Shell

แม้ว่าคุณจะใช้งาน Google Cloud จากระยะไกลในแล็ปท็อปได้ แต่ในบทแนะนำนี้ คุณจะได้ใช้ Cloud Shell ซึ่งเป็นสภาพแวดล้อมบรรทัดคำสั่งที่ทำงานในระบบคลาวด์

เปิดใช้งาน Cloud Shell

จาก Cloud Console ให้คลิกเปิดใช้งาน Cloud Shell

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

การจัดสรรและเชื่อมต่อกับ Cloud Shell จะใช้เวลาไม่นาน

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

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

เรียกใช้คำสั่งต่อไปนี้ใน Cloud Shell เพื่อยืนยันว่าคุณได้รับการตรวจสอบสิทธิ์แล้ว

gcloud auth list

เอาต์พุตของคำสั่ง

 Credentialed Accounts
ACTIVE  ACCOUNT
*       <my_account>@<my_domain.com>

To set the active account, run:
    $ gcloud config set account `ACCOUNT`

เรียกใช้คำสั่งต่อไปนี้ใน Cloud Shell เพื่อยืนยันว่าคำสั่ง gcloud รู้จักโปรเจ็กต์ของคุณ

gcloud config list project

เอาต์พุตของคำสั่ง

[core]
project = <PROJECT_ID>

หากไม่ได้ตั้งค่าไว้ คุณตั้งค่าได้ด้วยคำสั่งนี้

gcloud config set project <PROJECT_ID>

เอาต์พุตของคำสั่ง

Updated property [core/project].

3. เปิดใช้ API

จาก Cloud Shell ให้เปิดใช้ Artifact Registry, Cloud Build, Cloud Run และ Secret Manager API โดยทำดังนี้

gcloud services enable \
  artifactregistry.googleapis.com \
  cloudbuild.googleapis.com \
  run.googleapis.com \
  secretmanager.googleapis.com

ซึ่งจะแสดงข้อความแสดงความสำเร็จที่คล้ายกับข้อความนี้

Operation "operations/..." finished successfully.

ตอนนี้คุณพร้อมที่จะเตรียมและติดตั้งใช้งานแอปพลิเคชันแล้ว...

4. สร้างพื้นที่ทำงาน Slack

คุณจะต้องมีพื้นที่ทำงาน Slack ที่ได้รับอนุญาตให้สร้างการผสานรวมที่กำหนดเอง คุณสร้างพื้นที่ทำงานได้ฟรีหากยังไม่มีพื้นที่ทำงานที่ต้องการใช้สำหรับบทแนะนำนี้

5. สร้างผู้ใช้บ็อต Slack

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

สร้างแอป Slack ใหม่

ไปที่หน้าการจัดการแอป Slack
คลิกปุ่มสร้างแอปใหม่ที่มุมขวาบน
ตั้งชื่อแอป เช่น "Kittenbot"
เลือกทีม Slack ที่ต้องการติดตั้ง

สร้างผู้ใช้บ็อต

ไปที่หน้าแรกของแอปในแผงด้านซ้ายใต้ฟีเจอร์

กำหนดขอบเขตให้กับโทเค็นบ็อตโดยคลิกตรวจสอบขอบเขตที่จะเพิ่ม
เลื่อนลงไปที่ขอบเขตโทเค็นบ็อต แล้วคลิกเพิ่มขอบเขต OAuth เลือก chat:write เพื่อ "ส่งข้อความในชื่อ Kittenbot"

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

เปิดใช้ข้อความและคำสั่ง

เลื่อนลงไปที่แสดงแท็บและตรวจสอบว่าได้เปิดใช้ตัวเลือกทั้ง 2 รายการแล้ว

รับรหัสลับการลงนามของไคลเอ็นต์

ไปที่ข้อมูลพื้นฐานในส่วนการตั้งค่า
เลื่อนลงไปที่ข้อมูลลับในการลงนาม คลิกแสดง แล้วคัดลอกข้อมูลลับไปยังคลิปบอร์ด

บันทึกข้อมูลลับในตัวแปรสภาพแวดล้อม

CLIENT_SIGNING_SECRET=PASTE_THE_SIGNING_SECRET

รับโทเค็นบ็อต

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

บันทึกโทเค็นบอทในตัวแปรสภาพแวดล้อม

BOT_TOKEN=PASTE_THE_BOT_TOKEN

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

6. เก็บข้อมูลไว้เป็นความลับ

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

Secret Manager มีวิธีที่ปลอดภัยและสะดวกในการจัดเก็บคีย์ API, รหัสผ่าน, ใบรับรอง และข้อมูลที่ละเอียดอ่อนอื่นๆ Secret Manager เป็นศูนย์กลางและแหล่งข้อมูลที่เชื่อถือได้แหล่งเดียวในการจัดการ เข้าถึง และตรวจสอบข้อมูลลับใน Google Cloud

สร้างข้อมูลลับ

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

ข้อมูลลับในการลงนามไคลเอ็นต์

echo -n $CLIENT_SIGNING_SECRET | gcloud secrets create client-signing-secret \
  --replication-policy automatic \
  --data-file -

โทเค็นบ็อต

echo -n $BOT_TOKEN | gcloud secrets create bot-token \
  --replication-policy automatic \
  --data-file -

เข้าถึงข้อมูลลับ

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

echo $(gcloud secrets versions access 1 --secret client-signing-secret)
echo $(gcloud secrets versions access 1 --secret bot-token)

นอกจากนี้ คุณยังดูและจัดการข้อมูลลับได้ในคอนโซล Google Cloud

7. รับโค้ดตัวอย่าง

ใน Cloud Shell ที่บรรทัดคำสั่ง ให้เรียกใช้คำสั่งต่อไปนี้เพื่อโคลนที่เก็บ GitHub

git clone https://github.com/googlecodelabs/cloud-slack-bot.git

เปลี่ยนไดเรกทอรีเป็น cloud-slack-bot/start

cd cloud-slack-bot/start

ทำความเข้าใจโค้ด

เปิดไฟล์ kittenbot.js ด้วยโปรแกรมแก้ไขบรรทัดคำสั่งที่คุณต้องการ (nano, vim, emacs...) หรือใช้คำสั่งต่อไปนี้เพื่อเปิดโฟลเดอร์ปัจจุบันใน Cloud Shell Editor โดยตรง

cloudshell workspace .

โค้ด Kittenbot มีฟังก์ชันหลัก 2 อย่าง โดยมี 2 อย่างคือ ดึงข้อมูลลับ และเรียกใช้บ็อต

ก่อนอื่นเราจะนำเข้าการอ้างอิง

kittenbot.js

const { Botkit } = require('botkit');
const {
  SlackAdapter,
  SlackEventMiddleware,
} = require('botbuilder-adapter-slack');
const { SecretManagerServiceClient } = require('@google-cloud/secret-manager');

SlackAdapter และ SlackEventMiddleware เป็นแพ็กเกจที่ขยาย Botkit และอนุญาตให้บ็อตแปลข้อความไปยังและจาก Slack API ได้อย่างง่ายดาย ไคลเอ็นต์ Secret Manager จะช่วยให้คุณเข้าถึงข้อมูลลับที่บันทึกไว้ในขั้นตอนก่อนหน้าได้

ต่อไปคือฟังก์ชันสำหรับการดึงข้อมูลลับ

/**
 * Returns the secret string from Google Cloud Secret Manager
 * @param {string} name The name of the secret.
 * @return {Promise<string>} The string value of the secret.
 */
async function accessSecretVersion(name) {
  const client = new SecretManagerServiceClient();
  const projectId = process.env.PROJECT_ID;
  const [version] = await client.accessSecretVersion({
    name: `projects/${projectId}/secrets/${name}/versions/1`,
  });

  // Extract the payload as a string.
  const payload = version.payload.data.toString('utf8');

  return payload;
}

ฟังก์ชันนี้จะแสดงผลค่าสตริงของข้อมูลลับที่จำเป็นในการตรวจสอบสิทธิ์บอท

ฟังก์ชันถัดไปจะเริ่มต้นบ็อต

/**
 * Function to initialize kittenbot.
 */
async function kittenbotInit() {
  const adapter = new SlackAdapter({
    clientSigningSecret: await accessSecretVersion('client-signing-secret'),
    botToken: await accessSecretVersion('bot-token'),
  });

  adapter.use(new SlackEventMiddleware());

  const controller = new Botkit({
    webhook_uri: '/api/messages',
    adapter: adapter,
  });

  controller.ready(() => {
    controller.hears(
      ['hello', 'hi', 'hey'],
      ['message', 'direct_message'],
      async (bot, message) => {
        await bot.reply(message, 'Meow. :smile_cat:');
      }
    );
  });
}

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

ดูส่วนต่อไปนี้ในไฟล์ Manifest ของแอป

package.json

{
  // ...
  "scripts": {
    "start": "node kittenbot.js",
    // ...
  },
  "engines": {
    "node": "16"
  },
  // ...
}

คุณทำให้แอป Node.js ใช้งานได้จากแหล่งที่มาโดยตรงด้วย Cloud Run โดยระบบจะดำเนินการต่อไปนี้เบื้องหลัง

Cloud Run เรียกใช้ Cloud Build เพื่อสร้างอิมเมจคอนเทนเนอร์ (ดูการทําให้ใช้งานได้จากซอร์สโค้ด)
หากมี Dockerfile ในไดเรกทอรีซอร์สโค้ด Cloud Build จะใช้เพื่อสร้างอิมเมจคอนเทนเนอร์
เนื่องจากไม่มี Cloud Build จึงเรียกใช้ Buildpack เพื่อวิเคราะห์แหล่งที่มาและสร้างอิมเมจที่พร้อมใช้งานจริงโดยอัตโนมัติ
Buildpack จะตรวจหา package.json Manifest และสร้างอิมเมจ Node.js
ฟิลด์ scripts.start จะกำหนดวิธีเริ่มต้นแอป
ฟิลด์ engines.node จะกำหนดเวอร์ชัน Node.js ของอิมเมจฐานของคอนเทนเนอร์
ระบบจะใช้การแก้ไขด้านความปลอดภัยที่ทราบโดยอัตโนมัติในเวลาที่ติดตั้งใช้งาน

คุณพร้อมที่จะติดตั้งใช้งานแอปแล้ว

8. ปรับใช้แอป

Slack Events API ใช้เว็บฮุคเพื่อส่งข้อความขาออกเกี่ยวกับเหตุการณ์ เมื่อกำหนดค่าแอป Slack คุณจะต้องระบุ URL ที่เข้าถึงได้แบบสาธารณะเพื่อให้ Slack API ตรวจสอบ

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

ดึงข้อมูลรหัสโปรเจ็กต์

กำหนดตัวแปรสภาพแวดล้อม PROJECT_ID ดังนี้

PROJECT_ID=$(gcloud config get-value core/project)

กำหนดภูมิภาค Cloud Run

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

REGION="us-central1"

อัปเดตสิทธิ์

หากต้องการเข้าถึงข้อมูลลับจาก Secret Manager คุณต้องให้บทบาท roles/secretmanager.secretAccessor แก่บัญชีบริการ Cloud Run

ขั้นแรก ให้บันทึกบัญชีบริการเริ่มต้นลงในตัวแปรสภาพแวดล้อม

SERVICE_ACCOUNT=$(gcloud iam service-accounts list \
  --format "value(email)" \
  --filter "displayName:Compute Engine default service account")

วิธียืนยันว่าคุณได้บันทึกอีเมลไว้แล้ว

echo $SERVICE_ACCOUNT

บัญชีบริการมีรูปแบบดังนี้ PROJECT_NUMBER-compute@developer.gserviceaccount.com

เมื่อได้อีเมลแล้ว ให้เปิดใช้บทบาทสำหรับบัญชีบริการโดยทำดังนี้

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member serviceAccount:$SERVICE_ACCOUNT \
  --role roles/secretmanager.secretAccessor

ติดตั้งใช้งานแอป

บริการ Cloud Run แสดงปลายทางที่ไม่ซ้ำกันและปรับขนาดโครงสร้างพื้นฐานที่สำคัญโดยอัตโนมัติเพื่อจัดการคำขอขาเข้า

ทำให้แอปใช้งานได้ใน Cloud Run โดยทำดังนี้

gcloud run deploy kittenbot \
  --source . \
  --platform managed \
  --region $REGION \
  --set-env-vars PROJECT_ID=$PROJECT_ID \
  --allow-unauthenticated

ซึ่งจะสร้างบริการชื่อ kittenbot
ตัวเลือก --source จะใช้โฟลเดอร์ปัจจุบันเพื่อสร้างแอปพลิเคชันด้วย Cloud Build Cloud Build จะตรวจหาไฟล์ package.json โดยอัตโนมัติ
หรือจะกำหนดภูมิภาคเริ่มต้นด้วยคำสั่ง gcloud config set run/region $REGION ก็ได้
นอกจากนี้ คุณยังทำให้ Cloud Run เป็นบริการที่มีการจัดการโดยค่าเริ่มต้นได้ด้วยคำสั่งนี้ gcloud config set run/platform managed
--set-env-vars option จะตั้งค่าตัวแปรสภาพแวดล้อมของบริการ
ตัวเลือก --allow-unauthenticated จะทำให้บริการพร้อมให้บริการแก่บุคคลทั่วไป

ในครั้งแรก คุณจะได้รับข้อความแจ้งให้สร้างที่เก็บ Artifact Registry แตะ Enter เพื่อตรวจสอบ

Deploying from source requires an Artifact Registry Docker repository to store
built containers. A repository named [cloud-run-source-deploy] in region [REGION]
will be created.

Do you want to continue (Y/n)?

ซึ่งจะเริ่มการอัปโหลดซอร์สโค้ดไปยังที่เก็บ Artifact Registry และสร้างอิมเมจคอนเทนเนอร์

Building using Dockerfile and deploying container ...
* Building and deploying new service... Building Container.
  OK Creating Container Repository...
  OK Uploading sources...
  * Building Container... Logs are available at ...

จากนั้นรอสักครู่จนกว่าการสร้างและการติดตั้งใช้งานจะเสร็จสมบูรณ์ เมื่อสำเร็จ บรรทัดคำสั่งจะแสดง URL ของบริการดังนี้

...
OK Building and deploying new service... Done.
  OK Creating Container Repository...
  OK Uploading sources...
  OK Building Container... Logs are available at ...
  OK Creating Revision... Creating Service.
  OK Routing traffic...
  OK Setting IAM Policy...
Done.
Service [SERVICE]... has been deployed and is serving 100 percent of traffic.
Service URL: https://SERVICE-PROJECTHASH-REGIONID.a.run.app

คุณรับ URL ของบริการได้ด้วยคำสั่งต่อไปนี้

SERVICE_URL=$( \
  gcloud run services describe kittenbot \
  --platform managed \
  --region $REGION \
  --format "value(status.url)" \
)
echo $SERVICE_URL

URL มีรูปแบบดังนี้

https://kittenbot-PROJECTHASH-REGIONID.a.run.app

URL นี้จะเป็นฐานที่ใช้เพื่อเปิดใช้ Slack Events API คัดลอกไปยังคลิปบอร์ดเพื่อใช้ในขั้นตอนถัดไป

ตอนนี้บริการของคุณพร้อมใช้งานและเผยแพร่ต่อสาธารณะแล้ว ดูข้อมูลเพิ่มเติมได้ที่คอนโซล Cloud Run

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

มาเริ่มส่งข้อความจากช่อง Slack กันเลย

9. เปิดใช้กิจกรรม Slack

ดังที่เราได้เห็นไปก่อนหน้านี้ โค้ด kittenbot ของเราจะระบุปลายทางที่เกี่ยวข้องสำหรับเป้าหมายของเว็บฮุก

kittenbot.js

 const controller = new Botkit({
    webhook_uri: '/api/messages',
    adapter: adapter,
  });

ซึ่งหมายความว่า URL แบบเต็มของเราจะเป็นส่วนฐานจากบริการ Cloud Run บวกกับ /api/messages

เปิดใช้กิจกรรม

ในหน้าการจัดการแอป ให้ไปที่ส่วนการติดตามเหตุการณ์ในแถบด้านข้าง แล้วเปิดเปิดใช้เหตุการณ์ ป้อน URL ของบริการ

PASTE_THE_SERVICE_URL/api/messages

ระบบอาจพยายามยืนยันก่อนที่คุณจะพิมพ์ URL เสร็จ ทั้งนี้ขึ้นอยู่กับความเร็วในการพิมพ์ หากไม่สำเร็จ ให้คลิก "ลองอีกครั้ง"

สมัครรับข้อมูลเหตุการณ์ของบ็อตข้อความทั้งหมด

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

ตอนนี้บ็อตของคุณก็ผสานรวมเรียบร้อยแล้ว ข้อความในพื้นที่ทำงานจะทริกเกอร์ให้ Slack ส่งข้อความไปยังบริการ Cloud Run ซึ่งจะตอบกลับด้วยคำทักทายง่ายๆ

10. ทดสอบบ็อต

วิธีส่งข้อความส่วนตัวถึง Kittenbot

เพิ่ม kittenbot ลงในช่องโดยป้อน "@kittenbot" แล้วคลิก "เชิญ"

ตอนนี้ทุกคนในช่องของคุณจะโต้ตอบกับ Kittenbot ได้แล้ว

ข้อความแต่ละรายการใน Slack จะทริกเกอร์เหตุการณ์และส่งข้อความ HTTP POST ไปยังบริการ Cloud Run ของเรา หากดูบันทึกบริการ Cloud Run คุณจะเห็นว่าแต่ละข้อความสอดคล้องกับรายการ POST ในบันทึก

Kittenbot จะตอบกลับแต่ละข้อความด้วยคำว่า "เหมียว 😺"

11. โบนัส - อัปเดตบ็อต

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

ชุดข้อความการสนทนา

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

เปลี่ยนไดเรกทอรีเป็น cloud-slack-bot/extra-credit

cd ../extra-credit/

เปิดโฟลเดอร์ปัจจุบันใน Cloud Shell Editor โดยทำดังนี้

cloudshell workspace .

Botkit มีความสามารถในการจัดการการสนทนา ซึ่งจะช่วยให้บ็อตขอข้อมูลเพิ่มเติมและตอบกลับข้อความได้มากกว่าการตอบกลับด้วยคำเดียว

กำหนดกล่องโต้ตอบ

ก่อนอื่น ให้ดูวิธีกำหนดฟังก์ชันการสนทนาที่ส่วนท้ายของไฟล์

// ...
const maxCats = 20;
const catEmojis = [
  ':smile_cat:',
  ':smiley_cat:',
  ':joy_cat:',
  ':heart_eyes_cat:',
  ':smirk_cat:',
  ':kissing_cat:',
  ':scream_cat:',
  ':crying_cat_face:',
  ':pouting_cat:',
  ':cat:',
  ':cat2:',
  ':leopard:',
  ':lion_face:',
  ':tiger:',
  ':tiger2:',
];

/**
 * Function to concatenate cat emojis
 * @param {number} numCats Number of cat emojis.
 * @return {string} The string message of cat emojis.
 */
function makeCatMessage(numCats) {
  let catMessage = '';
  for (let i = 0; i < numCats; i++) {
    // Append a random cat from the list
    catMessage += catEmojis[Math.floor(Math.random() * catEmojis.length)];
  }
  return catMessage;
}

/**
 * Function to create the kitten conversation
 * @param {Object} controller The botkit controller.
 * @return {Object} The BotkitConversation object.
 */
function createKittenDialog(controller) {
  const convo = new BotkitConversation('kitten-delivery', controller);

  convo.ask('Does someone need a kitten delivery?', [
    {
      pattern: 'yes',
      handler: async (response, convo, bot) => {
        await convo.gotoThread('yes_kittens');
      },
    },
    {
      pattern: 'no',
      handler: async (response, convo, bot) => {
        await convo.gotoThread('no_kittens');
      },
    },
    {
      default: true,
      handler: async (response, convo, bot) => {
        await convo.gotoThread('default');
      },
    },
  ]);

  convo.addQuestion(
    'How many would you like?',
    [
      {
        pattern: '^[0-9]+?',
        handler: async (response, convo, bot, message) => {
          const numCats = parseInt(response);
          if (numCats > maxCats) {
            await convo.gotoThread('too_many');
          } else {
            convo.setVar('full_cat_message', makeCatMessage(numCats));
            await convo.gotoThread('cat_message');
          }
        },
      },
      {
        default: true,
        handler: async (response, convo, bot, message) => {
          if (response) {
            await convo.gotoThread('ask_again');
          } else {
            // The response '0' is interpreted as null
            await convo.gotoThread('zero_kittens');
          }
        },
      },
    ],
    'num_kittens',
    'yes_kittens'
  );

  // If numCats is too large, jump to start of the yes_kittens thread
  convo.addMessage(
    'Sorry, {{vars.num_kittens}} is too many cats. Pick a smaller number.',
    'too_many'
  );
  convo.addAction('yes_kittens', 'too_many');

  // If response is not a number, jump to start of the yes_kittens thread
  convo.addMessage("Sorry I didn't understand that", 'ask_again');
  convo.addAction('yes_kittens', 'ask_again');

  // If numCats is 0, send a dog instead
  convo.addMessage(
    {
      text:
        'Sorry to hear you want zero kittens. ' +
        'Here is a dog, instead. :dog:',
      attachments: [
        {
          fallback: 'Chihuahua Bubbles - https://youtu.be/s84dBopsIe4',
          text: '<https://youtu.be/s84dBopsIe4|' + 'Chihuahua Bubbles>!',
        },
      ],
    },
    'zero_kittens'
  );

  // Send cat message
  convo.addMessage('{{vars.full_cat_message}}', 'cat_message');

  convo.addMessage('Perhaps later.', 'no_kittens');

  return convo;
}

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

เพิ่มกล่องโต้ตอบลงในคอนโทรลเลอร์

เมื่อกำหนดการสนทนาแล้ว ให้ดูวิธีเพิ่มลงในคอนโทรลเลอร์

async function kittenbotInit() {
  // ...
  const controller = new Botkit({
    webhook_uri: '/api/messages',
    adapter: adapter,
  });

  // Add Kitten Dialog
  const convo = createKittenDialog(controller);
  controller.addDialog(convo);

  // Controller is ready
  controller.ready(() => {
    // ...
  });
}

ทริกเกอร์กล่องโต้ตอบ

ตอนนี้คอนโทรลเลอร์สามารถใช้กล่องโต้ตอบได้แล้ว มาดูวิธีเริ่มการสนทนาเมื่อแชทบอทได้ยินคำว่า "ลูกแมว" "ลูกแมว" "แมว" หรือ "แมว"

  // ...

  controller.ready(() => {
    controller.hears(
      ['hello', 'hi', 'hey'],
      ['message', 'direct_message'],
      async (bot, message) => {
        await bot.reply(message, 'Meow. :smile_cat:');
        return;
      }
    );

    // START: listen for cat emoji delivery
    controller.hears(
      ['cat', 'cats', 'kitten', 'kittens'],
      ['message', 'direct_message'],
      async (bot, message) => {
        // Don't respond to self
        if (message.bot_id !== message.user) {
          await bot.startConversationInChannel(message.channel, message.user);
          await bot.beginDialog('kitten-delivery');
          return;
        }
      }
    );
    // END: listen for cat emoji delivery

    // ...
  });

  // ...

อัปเดตแอป

ติดตั้งใช้งานแอปพลิเคชันไปยัง Cloud Run อีกครั้งโดยทำดังนี้

gcloud run deploy kittenbot \
  --source . \
  --platform managed \
  --region $REGION \
  --set-env-vars PROJECT_ID=$PROJECT_ID \
  --allow-unauthenticated

ลองเลย

ยินดีด้วย คุณเพิ่งอัปเดตบ็อต Slack ที่ทำงานบน Cloud Run เป็นเวอร์ชันใหม่

คำสั่งเครื่องหมายทับ

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

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

เปิดใช้คำสั่งเครื่องหมายทับของ Slack

ไปที่ส่วนคำสั่ง Slash ในส่วนฟีเจอร์ในหน้าการจัดการแอป
คลิกสร้างคำสั่งใหม่
กำหนดค่าคำสั่ง /cats ด้วย URL ของบริการ kittenbot โปรดอย่าลืมใช้ปลายทางเดียวกันกับที่คุณใช้เพื่อเปิดใช้ Events API นี่คือ URL ของคุณบวกกับ '/api/messages'

ทำตามข้อความแจ้งเพื่ออัปเดตแอปและสิทธิ์

เพิ่มคำสั่ง Slash ลงในตัวควบคุม

ดูวิธีเพิ่มตัวแฮนเดิลสำหรับคำสั่งเครื่องหมายทับภายในฟังก์ชัน controller.ready

  // ...

  // Controller is ready
  controller.ready(() => {
    // ...

    // START: slash commands
    controller.on('slash_command', async (bot, message) => {
      const numCats = parseInt(message.text);
      const response = makeCatMessage(numCats);
      bot.httpBody({ text: response });
    });
    // END: slash commands
  });

  // ...

ลองเลย

ป้อน /cats ตามด้วยตัวเลขเพื่อส่งคำสั่งเครื่องหมายทับ เช่น /cats 8

บ็อตจะตอบกลับด้วยรูปแมว 8 ตัว ซึ่งมีเพียงคุณเท่านั้นที่เห็น

12. ล้างข้อมูล

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

ลบโปรเจ็กต์

คุณลบทั้งโปรเจ็กต์ได้โดยตรงจาก Cloud Shell โดยทำดังนี้

gcloud projects delete $PROJECT_ID

หรือหากต้องการลบทรัพยากรต่างๆ ทีละรายการ ให้ไปที่ส่วนถัดไป

ลบการทำให้ใช้งานได้

gcloud run services delete kittenbot --region $REGION

เอาต์พุตของคำสั่ง

Service [kittenbot] will be deleted.
Do you want to continue (Y/n)?  y
Deleted service [kittenbot].

ลบรหัสลับการลงนามของไคลเอ็นต์

gcloud secrets delete client-signing-secret

เอาต์พุตของคำสั่ง

You are about to destroy the secret [client-signing-secret] and its
[1] version(s). This action cannot be reversed.
Do you want to continue (Y/n)?  y
Deleted secret [client-signing-secret].

ลบข้อมูลลับของโทเค็นบ็อต

gcloud secrets delete bot-token

เอาต์พุตของคำสั่ง

You are about to destroy the secret [bot-token] and its [1]
version(s). This action cannot be reversed.
Do you want to continue (Y/n)?  y
Deleted secret [bot-token].

ลบที่เก็บข้อมูล

ก่อนอื่น ให้แสดงรายการ Bucket ของ Google Cloud Storage เพื่อรับเส้นทางของ Bucket โดยทำดังนี้

gsutil ls

เอาต์พุตของคำสั่ง

gs://[REGION.]artifacts.<PROJECT_ID>.appspot.com/
gs://<PROJECT_ID>_cloudbuild/

ตอนนี้ให้ลบที่เก็บข้อมูลอาร์ติแฟกต์โดยทำดังนี้

gsutil rm -r gs://[REGION.]artifacts.${PROJECT_ID}.appspot.com/

เอาต์พุตของคำสั่ง

Removing gs://[REGION.]artifacts.<PROJECT_ID>.appspot.com/...

สุดท้าย ให้ลบ Bucket ของ Cloud Build โดยทำดังนี้

gsutil rm -r gs://${PROJECT_ID}_cloudbuild/

เอาต์พุตของคำสั่ง

Removing gs://<PROJECT_ID>_cloudbuild/...

13. ยินดีด้วย

ตอนนี้คุณก็รู้วิธีเรียกใช้บ็อต Slack ใน Cloud Run แล้ว

เราเพิ่งเริ่มต้นใช้เทคโนโลยีนี้ และขอแนะนำให้คุณสำรวจเพิ่มเติมด้วยการติดตั้งใช้งาน Cloud Run ของคุณเอง

สิ่งที่เราได้พูดถึง

การสร้างการผสานรวมบ็อตที่กำหนดเองใน Slack
การรักษาความปลอดภัยของข้อมูลลับใน Slack ด้วย Secret Manager
การติดตั้งใช้งานบ็อต Slack ใน Cloud Run

ขั้นตอนถัดไป

ดูบทแนะนำ Cloud Run เพิ่มเติม

ดูข้อมูลเพิ่มเติม

ดูตัวอย่างการผสานรวม Slack กับ Google Cloud อื่นๆ ใน GitHub
ลองใช้ฟีเจอร์อื่นๆ ของ Google Cloud ด้วยตัวคุณเอง ดูบทแนะนำของเรา