หน้านี้ได้รับการแปลโดย Cloud Translation API

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

1. ภาพรวม

ใน Codelab นี้ คุณจะได้เรียนรู้วิธีสร้างบ็อต 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 ของระบบคลาวด์ การใช้งาน Codelab นี้จะไม่มีค่าใช้จ่ายใดๆ หากมี หากต้องการปิดทรัพยากรเพื่อหลีกเลี่ยงการเรียกเก็บเงินที่นอกเหนือจากบทแนะนำนี้ คุณสามารถลบทรัพยากรที่คุณสร้างหรือลบโปรเจ็กต์ได้ ผู้ใช้ Google Cloud ใหม่มีสิทธิ์เข้าร่วมโปรแกรมช่วงทดลองใช้ฟรี$300 USD

เริ่มต้น Cloud Shell

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

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

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

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

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

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

เมื่อเชื่อมต่อกับ 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, โพสต์ข้อความ และอัปโหลดไฟล์ได้ ใน Codelab นี้ คุณจะสร้างบ็อตเพื่อโพสต์ข้อความทักทายง่ายๆ

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

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

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

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

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

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

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

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

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

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

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

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 Console ได้ด้วย

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

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

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 ฟังก์ชันหลัก วิธีแรกคือรับข้อมูลลับ ส่วนอีกวิธีคือการเรียกใช้บ็อต

ก่อนอื่น เราจะนำเข้าทรัพยากร Dependency ต่อไปนี้

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 จะเรียกใช้ Buildpacks เพื่อวิเคราะห์ซอร์สและสร้างอิมเมจที่พร้อมใช้งานจริงโดยอัตโนมัติ
Buildpack จะตรวจหาไฟล์ Manifest package.json และสร้างอิมเมจ Node.js
ช่อง scripts.start จะกำหนดวิธีเริ่มต้นใช้งานแอป
ช่อง engines.node กำหนดเวอร์ชัน Node.js ของอิมเมจฐานคอนเทนเนอร์
เมื่อมีการทำให้ใช้งานได้ การแก้ไขด้านความปลอดภัยที่รู้จักจะถูกนำไปใช้โดยอัตโนมัติ

คุณพร้อมที่จะทำให้แอปนี้ใช้งานได้แล้ว

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

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

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

เรียกข้อมูลรหัสโปรเจ็กต์

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

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

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

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

REGION="us-central1"

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

บัญชีบริการ Cloud Run ต้องได้รับบทบาท roles/secretmanager.secretAccessor จึงจะเข้าถึงข้อมูลลับจาก Secret Manager ได้

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

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 จะกำหนดตัวแปรสภาพแวดล้อมของบริการ
ตัวเลือก --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 Event 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 เสร็จสิ้น ทั้งนี้ขึ้นอยู่กับความเร็วในการพิมพ์ URL หากไม่สำเร็จ ให้คลิก "ลองอีกครั้ง"

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

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

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

10. ทดสอบบ็อต

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

เพิ่ม kittenbot ลงในช่องของคุณโดยป้อน "@kittenbot" จากนั้นคลิก "เชิญพวกเขา"

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

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

ลูกแมวจะตอบกลับแต่ละข้อความด้วยคำว่า "Meow. 😺"

11. โบนัส - อัปเดตบ็อตของคุณ

ส่วนที่ไม่บังคับนี้อาจใช้เวลา 2-3 นาที คุณสามารถข้ามไปที่การล้างข้อมูลโดยตรงได้

ชุดข้อความแบบสนทนา

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

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

cd ../extra-credit/

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

cloudshell workspace .

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

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

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

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

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

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

เพิ่มคำสั่งเครื่องหมายทับลงในตัวควบคุม

ดูวิธีเพิ่มเครื่องจัดการสำหรับคำสั่งเครื่องหมายทับภายในฟังก์ชัน 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].

ลบที่เก็บข้อมูลของพื้นที่เก็บข้อมูล

ก่อนอื่นให้แสดงรายการที่เก็บข้อมูล Google Cloud Storage เพื่อรับเส้นทางของที่เก็บข้อมูล

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

สุดท้าย ให้ลบที่เก็บข้อมูล cloudbuild ตามขั้นตอนต่อไปนี้

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 ด้วยตัวคุณเอง ดูวิดีโอบทแนะนำ

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

1. ภาพรวม

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

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

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

คุณจะให้คะแนนประสบการณ์การใช้งาน Google Cloud อย่างไร

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

การตั้งค่าสภาพแวดล้อมตามเวลาที่สะดวก

เริ่มต้น Cloud Shell

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

3. เปิดใช้ API

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

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

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

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

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

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

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

6. รักษาความลับของคุณให้ปลอดภัย

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

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

kittenbot.js

package.json

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

เรียกข้อมูลรหัสโปรเจ็กต์

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

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

ทำให้แอปใช้งานได้

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

kittenbot.js

เปิดใช้เหตุการณ์

ติดตาม

10. ทดสอบบ็อต

11. โบนัส - อัปเดตบ็อตของคุณ

ชุดข้อความแบบสนทนา

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

การเพิ่มกล่องโต้ตอบลงในตัวควบคุม

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

อัปเดตแอป

ลองเลย

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

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

เพิ่มคำสั่งเครื่องหมายทับลงในตัวควบคุม

ลองเลย

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

ลบโปรเจ็กต์

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

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

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

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

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

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

ลบที่เก็บข้อมูลของพื้นที่เก็บข้อมูล

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

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

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

13. ยินดีด้วย

หัวข้อที่ครอบคลุม

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

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