Slack-Bot mit Node.js in Cloud Run erstellen

1. Übersicht

In diesem Codelab erfahren Sie, wie Sie mit dem Botkit-Toolkit einen Slack-Bot erstellen und auf Google Cloud ausführen. Sie können den Bot in einem Slack-Livekanal interaktiv nutzen.

Lerninhalte

Benutzerdefinierte Bot-Integration in Slack erstellen
Slack-Secrets mit Secret Manager schützen
Bereitstellen eines Slack-Bots in Cloud Run, einer vollständig verwalteten Computing-Plattform, die Ihre zustandslosen Container automatisch skaliert

Voraussetzungen

Ein Google Cloud-Projekt
Ein Browser wie Chrome oder Firefox

Wie werden Sie diese Anleitung verwenden?

Nur lesen

Lesen und Übungen durchführen

Wie würden Sie Ihre Erfahrung mit Google Cloud bewerten?

Anfänger

Mittelstufe

Fortgeschritten

2. Einrichtung und Anforderungen

Umgebung zum selbstbestimmten Lernen einrichten

Melden Sie sich in der Google Cloud Console an und erstellen Sie ein neues Projekt oder verwenden Sie ein vorhandenes Projekt. Wenn Sie noch kein Gmail- oder Google Workspace-Konto haben, müssen Sie eines erstellen.

Der Projektname ist der Anzeigename für die Teilnehmer dieses Projekts. Es handelt sich um einen String, der nicht von Google APIs verwendet wird. Sie können sie jederzeit aktualisieren.
Die Projekt-ID ist für alle Google Cloud-Projekte eindeutig und unveränderlich (kann nach dem Festlegen nicht mehr geändert werden). In der Cloud Console wird automatisch ein eindeutiger String generiert. Normalerweise ist es nicht wichtig, wie dieser String aussieht. In den meisten Codelabs müssen Sie auf Ihre Projekt-ID verweisen (in der Regel als PROJECT_ID angegeben). Wenn Ihnen die generierte ID nicht gefällt, können Sie eine andere zufällige ID generieren. Alternativ können Sie es mit einem eigenen Namen versuchen und sehen, ob er verfügbar ist. Sie kann nach diesem Schritt nicht mehr geändert werden und bleibt für die Dauer des Projekts bestehen.
Zur Information: Es gibt einen dritten Wert, die Projektnummer, die von einigen APIs verwendet wird. Weitere Informationen zu diesen drei Werten

Als Nächstes müssen Sie die Abrechnung in der Cloud Console aktivieren, um Cloud-Ressourcen/-APIs zu verwenden. Die Durchführung dieses Codelabs kostet wenig oder gar nichts. Wenn Sie Ressourcen herunterfahren möchten, um Kosten zu vermeiden, die über diese Anleitung hinausgehen, können Sie die erstellten Ressourcen oder das Projekt löschen. Neue Google Cloud-Nutzer können am kostenlosen Testzeitraum mit einem Guthaben von 300$ teilnehmen.

Cloud Shell starten

Während Sie Google Cloud von Ihrem Laptop aus per Fernzugriff nutzen können, wird in dieser Anleitung Cloud Shell verwendet, eine Befehlszeilenumgebung, die in der Cloud ausgeführt wird.

Cloud Shell aktivieren

Klicken Sie in der Cloud Console auf Cloud Shell aktivieren .

Wenn Sie die Cloud Shell zum ersten Mal starten, wird ein Fenster mit einer Beschreibung eingeblendet. Klicken Sie in diesem Fall einfach auf Weiter.

Das Herstellen der Verbindung mit der Cloud Shell sollte nur wenige Augenblicke dauern.

Auf dieser virtuellen Maschine sind alle erforderlichen Entwicklungstools installiert. Sie bietet ein Basisverzeichnis mit 5 GB nichtflüchtigem Speicher und läuft in Google Cloud, was die Netzwerkleistung und Authentifizierung erheblich verbessert. Die meisten, wenn nicht sogar alle Aufgaben in diesem Codelab können mit einem Browser erledigt werden.

Sobald die Verbindung mit der Cloud Shell hergestellt ist, sehen Sie, dass Sie authentifiziert sind und für das Projekt Ihre Projekt-ID eingestellt ist.

Führen Sie in der Cloud Shell den folgenden Befehl aus, um zu prüfen, ob Sie authentifiziert sind:

gcloud auth list

Befehlsausgabe

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

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

Führen Sie den folgenden Befehl in Cloud Shell aus, um zu bestätigen, dass der gcloud-Befehl Ihr Projekt kennt:

gcloud config list project

Befehlsausgabe

[core]
project = <PROJECT_ID>

Ist dies nicht der Fall, können Sie die Einstellung mit diesem Befehl vornehmen:

gcloud config set project <PROJECT_ID>

Befehlsausgabe

Updated property [core/project].

3. APIs aktivieren

Aktivieren Sie in Cloud Shell die APIs für Artifact Registry, Cloud Build, Cloud Run und Secret Manager:

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

Wenn der Vorgang erfolgreich war, erhalten Sie eine Meldung, die ungefähr so aussieht:

Operation "operations/..." finished successfully.

Jetzt können Sie Ihre Anwendung vorbereiten und bereitstellen.

4. Slack-Arbeitsbereich erstellen

Sie benötigen einen Slack-Workspace, in dem Sie benutzerdefinierte Integrationen erstellen können. Wenn Sie noch keinen Workspace haben, den Sie für diese Anleitung verwenden möchten, können Sie kostenlos einen erstellen.

5. Slack-Bot-Nutzer erstellen

Ein Bot-Nutzer kann Nachrichten auf Slack empfangen und veröffentlichen sowie Dateien hochladen. In diesem Codelab erstellen Sie einen Bot, der eine einfache Begrüßungsnachricht postet.

Neue Slack-App erstellen

Gehen Sie zur Slack-Seite für die App-Verwaltung.
Klicken Sie rechts oben auf die Schaltfläche Create new app (Neue App erstellen).
Geben Sie der App einen Namen, z. B. „Kittenbot“.
Wählen Sie das Slack-Team aus, für das die App installiert werden soll.

Bot-Nutzer erstellen

Klicken Sie in der Seitenleiste links unter Features auf App Home.

Weisen Sie Ihrem Bot-Token einen Bereich zu, indem Sie auf Review Scopes to Add (Hinzuzufügende Bereiche überprüfen) klicken.
Scrollen Sie nach unten zu Bereiche für Bot-Token und klicken Sie auf OAuth-Bereich hinzufügen. Wählen Sie chat:write aus, um Nachrichten als „Kittenbot“ zu senden.

Scrollen Sie nach oben und klicken Sie auf die Schaltfläche App in Ihrem Arbeitsbereich installieren.
Dadurch wird die App für Ihr Team installiert, der von Ihnen erstellte Bot-Nutzer hinzugefügt und ein Bot-Token generiert.
Klicken Sie bei Aufforderung auf Zulassen, um den Bot zu autorisieren, in Ihrem Arbeitsbereich zu chatten.

Nachrichten und Befehle aktivieren

Scrollen Sie nach unten zu Tabs anzeigen und prüfen Sie, ob beide Optionen aktiviert sind:

Signatur-Secret des Clients abrufen

Rufen Sie unter Einstellungen die Allgemeinen Informationen auf.
Scrollen Sie nach unten zu Signing Secret (Signatur-Secret), klicken Sie auf Show (Anzeigen) und kopieren Sie das Secret in die Zwischenablage:

Speichern Sie das Secret in einer Umgebungsvariablen:

CLIENT_SIGNING_SECRET=PASTE_THE_SIGNING_SECRET

Bot-Token abrufen

Rufen Sie unter Funktionen die Option OAuth & Berechtigungen auf.
Kopieren Sie den Text im Feld Bot user OAuth access token (OAuth-Zugriffstoken des Bot-Nutzers) in die Zwischenablage. Klicken Sie dazu am Ende der Zeile auf Copy (Kopieren).

Speichern Sie das Bot-Token in einer Umgebungsvariablen:

BOT_TOKEN=PASTE_THE_BOT_TOKEN

Keine Sorge. Sie können jederzeit über die App-Verwaltungsseite zu dieser Konfigurationsseite zurückkehren, wenn Sie diese Tokens noch einmal benötigen.

6. Secrets schützen

Wir möchten sicherstellen, dass Ihr Bot-Token und Ihr geheimer Clientschlüssel sicher gespeichert werden. Wenn sie im Quellcode hartcodiert sind, erhöht dies die Wahrscheinlichkeit, dass sie im Rahmen der Versionsverwaltung oder aufgrund der Einbettung in ein Docker-Image versehentlich veröffentlicht werden.

Secret Manager bietet eine sichere und praktische Methode zum Speichern von API-Schlüsseln, Passwörtern, Zertifikaten und anderen sensiblen Daten. So können Sie Secrets in Google Cloud an einer zentralen Stelle und Single Source Of Truth verwalten, darauf zugreifen und prüfen.

Secrets erstellen

Speichern Sie den Clientsignaturschlüssel und das Bot-Token mit den folgenden Befehlen:

Signatur-Secret des Clients

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

Bot-Token

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

Auf Ihre Secrets zugreifen

Prüfen wir, ob Ihre Secrets richtig erstellt wurden und Ihre Berechtigungen funktionieren. Greifen Sie mit den folgenden Befehlen auf Ihre Secrets zu:

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

Sie können Ihre Secrets auch in der Google Cloud Console ansehen und verwalten.

7. Beispielcode abrufen

Führen Sie in Cloud Shell über die Befehlszeile den folgenden Befehl aus, um das GitHub-Repository zu klonen:

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

Wechseln Sie in das Verzeichnis cloud-slack-bot/start.

cd cloud-slack-bot/start

Den Code verstehen

Öffnen Sie die Datei kittenbot.js mit dem Befehlszeileneditor Ihrer Wahl (nano, vim, emacs usw.) oder mit dem folgenden Befehl, um den aktuellen Ordner direkt im Cloud Shell-Editor zu öffnen:

cloudshell workspace .

Der Kittenbot-Code hat zwei Hauptfunktionen. Zum einen müssen die Secrets abgerufen werden, zum anderen muss der Bot ausgeführt werden.

Zuerst importieren wir die Abhängigkeiten:

kittenbot.js

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

Der SlackAdapter und die SlackEventMiddleware sind Pakete, die Botkit erweitern und es dem Bot ermöglichen, Nachrichten einfach in die und aus der Slack API zu übersetzen. Mit dem Secret Manager-Client können Sie auf die Secrets zugreifen, die Sie in einem früheren Schritt gespeichert haben.

Als Nächstes haben wir unsere Funktion zum Abrufen der Secrets:

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

Diese Funktion gibt die Stringwerte der Geheimnisse zurück, die zur Authentifizierung des Bots erforderlich sind.

Die nächste Funktion initialisiert den Bot:

/**
 * 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:');
      }
    );
  });
}

Im ersten Teil der Funktion wird der SlackAdapter mit den Secrets konfiguriert und dann ein Endpunkt für den Empfang von Nachrichten angegeben. Sobald der Controller eingeschaltet ist, antwortet der Bot auf jede Nachricht, die „Hallo“, „Hi“ oder „Hey“ enthält, mit „Miau“. 😺“.

Sehen Sie sich diese spezifischen Teile im App-Manifest an:

package.json

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

Sie können eine Node.js-Anwendung mit Cloud Run direkt aus dem Quellcode bereitstellen. Im Hintergrund passiert Folgendes:

Cloud Run ruft Cloud Build auf, um ein Container-Image zu erstellen (siehe Aus Quellcode bereitstellen).
Wenn im Quellcodeverzeichnis ein Dockerfile vorhanden ist, verwendet Cloud Build es zum Erstellen eines Container-Images.
Da dies nicht der Fall ist, ruft Cloud Build Buildpacks auf, um die Quelle zu analysieren und automatisch ein produktionsfähiges Image zu generieren.
Buildpacks erkennt das package.json-Manifest und erstellt ein Node.js-Image.
Das Feld scripts.start legt fest, wie die App gestartet wird.
Das Feld engines.node bestimmt die Node.js-Version des Container-Basis-Images.
Bei der Bereitstellung werden bekannte Sicherheitskorrekturen automatisch angewendet.

Jetzt können Sie die App bereitstellen.

8. Anwendung bereitstellen

Die Slack Events API verwendet Webhooks, um ausgehende Nachrichten zu Ereignissen zu senden. Wenn Sie die Slack-App konfigurieren, müssen Sie eine öffentlich zugängliche URL für die Slack API angeben, an die Pings gesendet werden.

Cloud Run ist eine gute Lösung für das Hosten von Webhook-Zielen. Sie können jede beliebige Sprache oder Laufzeit verwenden und die Anwendung kann gleichzeitig ausgeführt werden, sodass sie ein viel höheres Volumen bewältigen kann.

Projekt-ID abrufen

Legen Sie die Umgebungsvariable PROJECT_ID fest:

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

Cloud Run-Region definieren

Cloud Run ist regional. Die Infrastruktur, in der Ihr Cloud Run-Dienst ausgeführt wird, befindet sich demnach in einer bestimmten Region. Aufgrund der Verwaltung durch Google ist sie in allen Zonen innerhalb dieser Region redundant verfügbar. Definieren Sie die Region, die Sie für Ihre Bereitstellung verwenden möchten, z. B.:

REGION="us-central1"

Berechtigungen aktualisieren

Damit auf Secrets aus Secret Manager zugegriffen werden kann, muss dem Cloud Run-Dienstkonto die Rolle roles/secretmanager.secretAccessor zugewiesen werden.

Speichern Sie zuerst das Standarddienstkonto in einer Umgebungsvariablen:

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

Prüfen Sie, ob Sie die E‑Mail-Adresse gespeichert haben:

echo $SERVICE_ACCOUNT

Das Dienstkonto hat das folgende Format: PROJECT_NUMBER-compute@developer.gserviceaccount.com.

Wenn Sie die E‑Mail-Adresse haben, aktivieren Sie die Rolle für das Dienstkonto:

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

Anwendung bereitstellen

Ein Cloud Run-Dienst stellt einen eindeutigen Endpunkt bereit und skaliert die zugrunde liegende Infrastruktur automatisch, um eingehende Anfragen zu verarbeiten.

Stellen Sie die Anwendung für Cloud Run bereit:

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

Dadurch wird ein Dienst mit dem Namen kittenbot erstellt.
Mit der Option --source wird der aktuelle Ordner verwendet, um die Anwendung mit Cloud Build zu erstellen. Cloud Build erkennt das Vorhandensein der Datei package.json automatisch.
Alternativ können Sie mit diesem Befehl eine Standardregion definieren: gcloud config set run/region $REGION
Sie können Cloud Run auch mit diesem Befehl als Standard festlegen: gcloud config set run/platform managed
Mit der Option --set-env-vars werden die Umgebungsvariablen des Dienstes festgelegt.
Mit der Option --allow-unauthenticated wird der Dienst öffentlich verfügbar.

Beim ersten Mal werden Sie aufgefordert, ein Artifact Registry-Repository zu erstellen. Tippen Sie zur Bestätigung auf „Eingabe“:

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

Dadurch wird das Hochladen Ihres Quellcodes in das Artifact Registry-Repository und das Erstellen Ihres Container-Images gestartet:

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

Warten Sie dann einen Moment, bis der Build und die Bereitstellung abgeschlossen sind. Wenn die Bereitstellung erfolgreich war, wird in der Befehlszeile die Dienst-URL angezeigt:

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

Sie können die Dienst-URL mit diesem Befehl abrufen:

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

Die URL hat das folgende Format:

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

Diese URL ist die Basis, die zum Aktivieren der Slack Events API verwendet wird. Kopieren Sie sie in die Zwischenablage, um sie im nächsten Schritt zu verwenden.

Ihr Dienst ist jetzt live und öffentlich verfügbar. Weitere Informationen finden Sie in der Cloud Run-Konsole.

Sie können sehen, wann die letzte Überarbeitung erstellt wurde, wie viele Zugriffe sie erhält, und sich die Protokolle ansehen. Wenn wir auf die Logs klicken, sehen wir, dass der Botkit-Controller aktiv und bereit ist, Nachrichten zu empfangen.

Jetzt können wir Nachrichten über unseren Slack-Kanal senden.

9. Slack-Ereignisse aktivieren

Wie wir bereits gesehen haben, wird im Kittenbot-Code ein relativer Endpunkt für unser Webhook-Ziel angegeben.

kittenbot.js

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

Das bedeutet, dass unsere vollständige URL aus dem Basisteil des Cloud Run-Dienstes plus /api/messages besteht.

Events aktivieren

Rufen Sie auf der Seite zur App-Verwaltung in der Seitenleiste den Abschnitt Ereignisabos auf und aktivieren Sie Ereignisse aktivieren. Geben Sie die URL Ihres Dienstes ein:

PASTE_THE_SERVICE_URL/api/messages

Je nachdem, wie schnell Sie die URL eingeben, wird die Bestätigung möglicherweise gestartet, bevor Sie fertig sind. Wenn das nicht funktioniert, klicken Sie auf „Wiederholen“.

Abonnieren Sie alle Ereignisse des Nachrichtenbots.

Klicken Sie unten auf der Seite auf Änderungen speichern. Sie werden aufgefordert, Ihre App neu zu installieren. Folgen Sie der Anleitung und klicken Sie auf Zulassen.

Ihr Bot ist jetzt vollständig integriert. Nachrichten im Arbeitsbereich lösen aus, dass Slack Nachrichten an Ihren Cloud Run-Dienst sendet, der wiederum mit einer einfachen Begrüßung antwortet.

10. Bot testen

So senden Sie eine Direktnachricht an Kittenbot:

Fügen Sie Kittenbot Ihrem Kanal hinzu, indem Sie „@kittenbot“ eingeben und dann auf „Invite Them“ (Einladen) klicken:

Jetzt kann jeder auf deinem Kanal mit Kittenbot interagieren.

Jede Nachricht in Slack löst ein Ereignis aus und sendet eine HTTP-POST-Nachricht an unseren Cloud Run-Dienst. Wenn Sie sich die Cloud Run-Dienstlogs ansehen, sehen Sie, dass jede Nachricht einem POST-Eintrag im Log entspricht.

Der Kittenbot antwortet auf jede Nachricht mit „Miau. 😺“.

11. Bonus: Bot aktualisieren

Das Ausfüllen dieses optionalen Abschnitts sollte nur wenige Minuten dauern. Sie können auch direkt zum Abschnitt „Bereinigen“ springen.

Konversationen

Wir möchten, dass der Bot mehr sagt als nur „Miau“. Doch wie lässt sich eine neue Version eines Bots bereitstellen, der auf Cloud Run ausgeführt wird?

Ändern Sie das Verzeichnis in cloud-slack-bot/extra-credit:

cd ../extra-credit/

Öffnen Sie den aktuellen Ordner im Cloud Shell-Editor:

cloudshell workspace .

Mit Botkit lassen sich Unterhaltungen verarbeiten. So kann ein Bot noch mehr Informationen anfordern und mit mehr als einem Wort auf Nachrichten reagieren.

Dialog definieren

Sehen Sie sich zuerst an, wie die Konversationsfunktionen am Ende der Datei definiert sind:

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

In dieser neuen Unterhaltung wird der Thread anhand der Antworten weitergeführt. Wenn der Nutzer beispielsweise mit „Nein“ auf die Frage nach dem Kätzchen antwortet, wird die Nachricht mit dem Label „no_kittens“ angezeigt, was das Ende dieses Konversationsstrangs ist.

Dialogfeld dem Controller hinzufügen

Nachdem die Unterhaltung definiert wurde, erfahren Sie hier, wie Sie sie dem Controller hinzufügen:

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(() => {
    // ...
  });
}

Dialogfeld auslösen

Jetzt ist der Dialog für den Controller verfügbar. Sehen Sie sich an, wie die Unterhaltung beginnt, wenn der Chatbot „Kätzchen“, „Katze“ oder „Katzen“ hört:

  // ...

  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

    // ...
  });

  // ...

App aktualisieren

Stellen Sie die Anwendung noch einmal in Cloud Run bereit:

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

Jetzt ausprobieren

Glückwunsch! Sie haben soeben einen Slack-Bot, der auf Cloud Run ausgeführt wird, auf eine neue Version aktualisiert.

Slash-Befehle

Was passiert, wenn Sie nicht mit dem Nutzer sprechen möchten? Was, wenn Sie lieber eine Aktion mit einem einfachen Befehl auslösen möchten?

Slack bietet diese Funktion über Slash-Befehle an. Damit können Nutzer Ihre Anwendung aufrufen, indem sie den Befehl in das Nachrichtenfeld eingeben.

Slack-Slash-Befehle aktivieren

Rufen Sie auf der Seite „App-Verwaltung“ unter Funktionen den Abschnitt Slash-Befehle auf.
Klicken Sie auf Create New Command (Neuen Befehl erstellen).
Konfigurieren Sie einen /cats-Befehl mit der URL Ihres Kittenbot-Dienstes. Verwenden Sie denselben Endpunkt, den Sie zum Aktivieren der Events API verwendet haben. Das ist Ihre URL plus '/api/messages'.

Folgen Sie der Aufforderung, um Ihre App und Berechtigungen zu aktualisieren.

Slash-Befehle zum Controller hinzufügen

So wurde ein Handler für Slash-Befehle in der Funktion „controller.ready“ hinzugefügt:

  // ...

  // 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
  });

  // ...

Jetzt ausprobieren

Geben Sie „/cats“ und eine Zahl ein, um den Slash-Befehl zu senden. Beispiel: /cats 8

Der Bot antwortet mit acht Katzen, die nur für Sie sichtbar sind:

12. Bereinigen

Herzlichen Glückwunsch! Sie haben jetzt einen Slack-Bot, der in Cloud Run ausgeführt wird. Sie können nun die genutzten Ressourcen wieder entfernen. So sparen Sie Kosten und geben nicht mehr benötigte Ressourcen für andere frei.

Projekt löschen

Sie können das gesamte Projekt direkt über Cloud Shell löschen:

gcloud projects delete $PROJECT_ID

Wenn Sie die verschiedenen Ressourcen lieber einzeln löschen möchten, fahren Sie mit dem nächsten Abschnitt fort.

Deployment löschen

gcloud run services delete kittenbot --region $REGION

Befehlsausgabe

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

Signatur-Secret des Clients löschen

gcloud secrets delete client-signing-secret

Befehlsausgabe

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

Secret für Bot-Token löschen

gcloud secrets delete bot-token

Befehlsausgabe

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

Storage-Buckets löschen

Listen Sie zuerst die Google Cloud Storage-Buckets auf, um den Bucket-Pfad zu erhalten:

gsutil ls

Befehlsausgabe

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

Löschen Sie nun den Artefakt-Bucket:

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

Befehlsausgabe

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

Löschen Sie zum Schluss den Cloud Build-Bucket:

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

Befehlsausgabe

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

13. Glückwunsch!

Sie wissen jetzt, wie man einen Slack-Bot auf Cloud Run ausführt.

Wir haben uns bisher nur an der Oberfläche dieser Technologie bewegt. Anhand Ihrer eigenen Cloud Run-Deployments können Sie noch vieles entdecken!

Behandelte Themen

Benutzerdefinierte Bot-Integration in Slack erstellen
Slack-Secrets mit Secret Manager schützen
Slack-Bot in Cloud Run bereitstellen

Nächste Schritte

Weitere Cloud Run-Tutorials

Weitere Informationen

Testen Sie auf der GitHub-Seite weitere Slack-Integrationsbeispiele für Google Cloud.
Probieren Sie andere Google Cloud-Funktionen selbst aus. mit unseren Anleitungen ausprobieren