Diese Seite wurde von der Cloud Translation API übersetzt.

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 in 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 sichern
Slack-Bot in Cloud Run bereitstellen, einer vollständig verwalteten Computing-Plattform, die Ihre zustandslosen Container automatisch skaliert

Voraussetzungen

Ein Google Cloud-Projekt
Browser wie Chrome oder Firefox

Wie möchten Sie diese Anleitung nutzen?

<ph type="x-smartling-placeholder"></ph> Nur bis zum Ende lesen

Lies sie dir durch und absolviere die Übungen

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

<ph type="x-smartling-placeholder"></ph> Neuling

Leicht fortgeschritten

Kompetent

2. Einrichtung und Anforderungen

Umgebung für das selbstbestimmte 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 Projektteilnehmer. Es handelt sich um eine Zeichenfolge, die von Google APIs nicht verwendet wird. Sie können sie jederzeit aktualisieren.
Die Projekt-ID ist für alle Google Cloud-Projekte eindeutig und unveränderlich. Sie kann nach dem Festlegen nicht mehr geändert werden. Die Cloud Console generiert automatisch einen eindeutigen String. ist Ihnen meist egal, was es ist. In den meisten Codelabs musst du auf deine Projekt-ID verweisen, die üblicherweise als PROJECT_ID bezeichnet wird. Wenn Ihnen die generierte ID nicht gefällt, können Sie eine weitere zufällige ID generieren. Alternativ können Sie einen eigenen verwenden und nachsehen, ob er verfügbar ist. Sie kann nach diesem Schritt nicht mehr geändert werden und bleibt für die Dauer des Projekts erhalten.
Zur Information gibt es noch einen dritten Wert, die Projektnummer, die von manchen APIs verwendet wird. Weitere Informationen zu allen drei Werten finden Sie in der Dokumentation.

Als Nächstes müssen Sie in der Cloud Console die Abrechnung aktivieren, um Cloud-Ressourcen/APIs verwenden zu können. Dieses Codelab ist kostengünstig. Sie können die von Ihnen erstellten Ressourcen oder das Projekt löschen, um Ressourcen herunterzufahren, um zu vermeiden, dass über diese Anleitung hinaus Kosten anfallen. Neue Google Cloud-Nutzer haben Anspruch auf das kostenlose Testprogramm mit 300$Guthaben.

Cloud Shell starten

Sie können Google Cloud zwar über Ihren Laptop aus der Ferne bedienen, in dieser Anleitung verwenden Sie jedoch Cloud Shell, eine Befehlszeilenumgebung, die in der Cloud ausgeführt wird.

Cloud Shell aktivieren

Klicken Sie in der Cloud Console auf Cloud Shell aktivieren .

Wenn Sie Cloud Shell zum ersten Mal starten, wird ein Zwischenbildschirm mit einer Beschreibung der Funktion angezeigt. Wenn ein Zwischenbildschirm angezeigt wird, klicken Sie auf Weiter.

Die Bereitstellung und Verbindung mit Cloud Shell dauert nur einen Moment.

Diese virtuelle Maschine verfügt über alle erforderlichen Entwicklertools. Es bietet ein Basisverzeichnis mit 5 GB nichtflüchtigem Speicher und wird in Google Cloud ausgeführt, wodurch die Netzwerkleistung und Authentifizierung erheblich verbessert werden. Viele, wenn nicht sogar alle Arbeiten in diesem Codelab können mit einem Browser erledigt werden.

Sobald Sie mit Cloud Shell verbunden sind, sollten Sie sehen, dass Sie authentifiziert sind und das Projekt auf Ihre Projekt-ID eingestellt ist.

Führen Sie in 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 in Cloud Shell den folgenden Befehl aus, um zu prüfen, ob 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 Artifact Registry, Cloud Build, Cloud Run und Secret Manager APIs:

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

Dadurch wird eine Erfolgsmeldung wie diese ausgegeben:

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 dürfen. Sie können kostenlos einen Arbeitsbereich erstellen, wenn Sie noch keinen für diese Anleitung haben.

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, mit dem Sie eine einfache Begrüßungsnachricht posten können.

Neue Slack-Anwendung erstellen

Gehen Sie zur Slack-Seite für die App-Verwaltung.
Klicken Sie rechts oben auf die Schaltfläche Create new app (Neue Anwendung 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 im linken Bereich unter Funktionen auf App-Startseite.

Weisen Sie dem Bottoken einen Bereich zu, indem Sie auf Zu hinzufügende Bereiche überprüfen klicken.
Scrollen Sie nach unten zu Bot Token Scopes und klicken Sie auf Add an OAuth Scope (OAuth-Bereich hinzufügen). Wähle chat:write für „Nachrichten als Kittenbot senden“ aus

Scrollen Sie nach oben und klicken Sie auf die Schaltfläche App in Ihrem Arbeitsbereich installieren.
Dadurch wird die App in Ihrem Team installiert, der gerade erstellte Bot-Nutzer hinzugefügt und ein Bot-Token generiert.
Wenn Sie dazu aufgefordert werden, klicken Sie auf Zulassen. um den Bot zum Chatten in Ihrem Arbeitsbereich zu autorisieren.

Nachrichten und Befehle aktivieren

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

Clientsignaturschlüssel abrufen

Gehen Sie unter Einstellungen zu Allgemeine Informationen.
Scrollen Sie nach unten zu Signatur-Secret, klicken Sie auf 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

Gehen Sie zu OAuth & Berechtigungen unter Funktionen.
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. Wenn Sie diese Tokens wieder benötigen, können Sie über die Seite zur App-Verwaltung zu dieser Konfigurationsseite zurückkehren.

6. Geheimnisse schützen

Wir möchten sicherstellen, dass Ihr Bot-Token und Ihr Client-Signaturschlüssel sicher gespeichert werden. Durch die Hartcodierung im Quellcode besteht die Wahrscheinlichkeit, dass diese Secrets versehentlich für die Versionsverwaltung veröffentlicht oder in ein Docker-Image eingebettet werden.

Secret Manager bietet eine sichere und praktische Methode zum Speichern von API-Schlüsseln, Passwörtern, Zertifikaten und anderen sensiblen Daten. Secret Manager bietet eine zentrale Stelle und Single Source of Truth, um Secrets in Google Cloud zu verwalten, darauf zuzugreifen und sie zu prüfen.

Secrets erstellen

Speichern Sie das Client-Signatur-Secret und das Bot-Token mit den folgenden Befehlen:

Client-Signaturschlüssel

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

Bestätigen Sie, dass 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 zum Verzeichnis cloud-slack-bot/start.

cd cloud-slack-bot/start

Grundlegendes zum Code

Öffnen Sie die Datei kittenbot.js mit Ihrem bevorzugten Befehlszeileneditor (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. Eine besteht darin, die Secrets abzurufen und die andere besteht darin, den Bot auszuführen.

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');

SlackAdapter und SlackEventMiddleware sind Pakete, die Botkit erweitern und 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 vorherigen 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 Secrets zurück, die zur Authentifizierung des Bots erforderlich sind.

Mit der nächsten Funktion wird der Bot initialisiert:

/**
 * 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 alle Nachrichten, die „hello“, „hi“ oder „hey“ enthalten. mit „Miau. Speck“.

Sehen Sie sich die folgenden Teile des App-Manifests an:

package.json

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

Mit Cloud Run können Sie eine Node.js-Anwendung direkt aus der Quelle 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, wird es von Cloud Build verwendet, um ein Container-Image zu erstellen.
Da dies nicht der Fall ist, ruft Cloud Build Buildpacks auf, um die Quelle zu analysieren und automatisch ein produktionsfertiges Image zu generieren.
Buildpacks erkennt das Manifest package.json und erstellt ein Node.js-Image.
Über das Feld scripts.start wird festgelegt, wie die Anwendung gestartet wird.
Das Feld engines.node bestimmt die Node.js-Version des Container-Basis-Images.
Bei der Bereitstellung werden bekannte Sicherheitsupdates automatisch angewendet.

Sie können die Anwendung jetzt 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 angeben, die die Slack API anpingen kann.

Cloud Run ist eine gute Lösung zum Hosten von Webhook-Zielen. Sie können jede beliebige Sprache oder Laufzeit verwenden und profitieren gleichzeitig von einer Parallelität, d. h., Ihre Anwendung kann ein viel größeres Volumen verarbeiten.

Projekt-ID abrufen

Definieren Sie die Umgebungsvariable PROJECT_ID:

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

Cloud Run-Region definieren

Cloud Run ist regional. Das bedeutet, dass sich die Infrastruktur, in der Ihr Cloud Run-Dienst ausgeführt wird, in einer bestimmten Region befindet und von Google verwaltet wird, damit sie in allen Zonen innerhalb dieser Region redundant verfügbar ist. Definieren Sie die Region, die Sie für die Bereitstellung verwenden möchten. Beispiel:

REGION="us-central1"

Berechtigungen aktualisieren

Damit Sie auf Secrets aus Secret Manager zugreifen können, muss dem Cloud Run-Dienstkonto die Rolle roles/secretmanager.secretAccessor gewährt 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")

Bestätigen Sie, dass die E-Mail-Adresse gespeichert ist:

echo $SERVICE_ACCOUNT

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

Sobald 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 namens kittenbot erstellt.
Die Option --source verwendet den aktuellen Ordner, um die Anwendung mit Cloud Build zu erstellen. Cloud Build erkennt automatisch das Vorhandensein der Datei package.json.
Alternativ können Sie mit dem folgenden Befehl eine Standardregion definieren: gcloud config set run/region $REGION
Mit dem folgenden Befehl können Sie Cloud Run auch standardmäßig verwalten: gcloud config set run/platform managed
Mit der Option --set-env-vars werden die Dienstumgebungsvariablen festgelegt.
Mit der Option --allow-unauthenticated wird der Dienst öffentlich verfügbar.

Sie werden zum ersten Mal aufgefordert, ein Artifact Registry-Repository zu erstellen. Tippe zum Bestätigen auf die Eingabetaste:

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 werden der Upload Ihres Quellcodes in das Artifact Registry-Repository und der Build 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 folgendes Format:

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

Diese URL wird als Basis zum Aktivieren der Slack Events API verwendet. Kopieren Sie es in die Zwischenablage, um es 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 Version erstellt wurde und wie viel Traffic sie empfängt, und können sich die Logs ansehen. Wenn wir auf die Protokolle klicken, sehen wir, dass der Botkit-Controller aktiviert ist und Nachrichten empfangen kann.

Senden wir nun Nachrichten aus unserem Slack-Kanal.

9. Slack-Ereignisse aktivieren

Wie wir bereits gesehen haben, gibt unser Kittenbot-Code einen relativen Endpunkt für unser Webhook-Ziel an.

kittenbot.js

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

Unsere vollständige URL ist also der Basisteil des Cloud Run-Dienstes plus /api/messages.

Ereignisse aktivieren

Gehen Sie auf der Seite zur App-Verwaltung in der Seitenleiste zum Abschnitt Ereignisabos und aktivieren Sie die Option Ereignisse aktivieren. Gib deine Service-URL ein:

PASTE_THE_SERVICE_URL/api/messages

Je nachdem, wie schnell Sie die URL eingeben, wird möglicherweise versucht, die URL zu bestätigen, bevor Sie fertig sind. Wenn es fehlschlägt, klicken Sie auf „Wiederholen“.

Alle Nachrichtenbot-Ereignisse abonnieren.

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.

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

10. Bot testen

So senden Sie eine Direktnachricht an Kittenbot:

Gib „@kittenbot“ ein, um deinem Kanal Kittenbot hinzuzufügen Klicken Sie dann auf „Einladen“:

Jetzt kann jeder in 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, werden Sie feststellen, dass jede Nachricht einem POST-Eintrag im Log entspricht.

Der Kätzchenbot antwortet auf jede Nachricht mit „Miau. Speck“.

11. Bonus: Bot aktualisieren

Dieser optionale Abschnitt sollte ein paar Minuten dauern. Sie können direkt zum Tab „Bereinigen“ springen.

Unterhaltungsthreads

Der Bot soll mehr tun, als nur „Miau“ zu sagen. Aber wie stellen Sie eine neue Version von etwas bereit, das in 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 können Sie Unterhaltungen verarbeiten. So kann ein Bot noch mehr Informationen anfordern und mit mehr als einem Wort auf Nachrichten reagieren.

Dialogfeld definieren

Sehen Sie sich zuerst an, wie 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;
}

Diese neue Unterhaltung leitet den Thread basierend auf den Antworten weiter. Wenn der Nutzer z. B. mit „Nein“ antwortet der Kätzchenfrage an, wird die Nachricht mit dem Label „no_kittens“ aufgerufen, die das Ende dieses Unterhaltungsthreads ist.

Dialogfeld zum Controller hinzufügen

Nachdem Sie die Unterhaltung definiert haben, können 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

Das Dialogfeld ist jetzt für den Controller verfügbar. Sehen Sie sich an, wie die Unterhaltung beginnt, wenn der Chatbot „Kätzchen“, „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 gerade einen Slack-Bot, der in Cloud Run ausgeführt wird, auf eine neue Version aktualisiert.

Slash-Befehle

Was, wenn Sie keine Unterhaltung mit dem Nutzer führen möchten? Wie gehen Sie vor, wenn Sie lieber einfach eine Aktion mit einem einzigen Befehl auslösen möchten?

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

Slack-Slash-Befehle aktivieren

Gehen Sie auf der Seite für die Apps-Verwaltung unter Funktionen zum Abschnitt Slash-Befehle.
Klicken Sie auf Create New Command (Neuen Befehl erstellen).
Konfigurieren Sie einen /cats-Befehl mit Ihrer Kittenbot-Dienst-URL. Denken Sie daran, denselben Endpunkt zu verwenden, mit dem Sie die Events API aktiviert haben. Das ist Ihre URL plus '/api/messages'.

Folgen Sie der Anleitung, um die App und die Berechtigungen zu aktualisieren.

Dem Controller Slash-Befehle hinzufügen

Sehen Sie sich an, wie ein Handler für Slash-Befehle in der Funktion „controller.ready“ hinzugefügt wurde:

  // ...

  // 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 dich sichtbar sind:

12. Bereinigen

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

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

Clientsignaturschlüssel 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].

Bot-Token-Secret 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 abschließend den Cloud Bigtable-Bucket:

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

Befehlsausgabe

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

13. Glückwunsch!

Jetzt wissen Sie, wie Sie einen Slack-Bot in Cloud Run ausführen.

Wir haben uns bisher nur an der Oberfläche dieser Technologie bewegt und möchten Sie ermutigen, sie mit Ihren eigenen Cloud Run-Bereitstellungen weiter zu erkunden.

Behandelte Themen

Benutzerdefinierte Bot-Integration in Slack erstellen
Slack-Secrets mit Secret Manager sichern
Slack-Bot in Cloud Run bereitstellen

Nächste Schritte

Weitere Cloud Run-Anleitungen absolvieren

Weitere Informationen

Sehen Sie sich auf GitHub weitere Slack-Integrationsbeispiele für Google Cloud an.
Probieren Sie andere Google Cloud-Funktionen selbst aus. mit unseren Anleitungen ausprobieren

Slack-Bot mit Node.js in Cloud Run erstellen

1. Übersicht

Lerninhalte

Voraussetzungen

Wie möchten Sie diese Anleitung nutzen?

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

2. Einrichtung und Anforderungen

Umgebung für das selbstbestimmte Lernen einrichten

Cloud Shell starten

Cloud Shell aktivieren

3. APIs aktivieren

4. Slack-Arbeitsbereich erstellen

5. Slack-Bot-Nutzer erstellen

Neue Slack-Anwendung erstellen

Bot-Nutzer erstellen

Nachrichten und Befehle aktivieren

Clientsignaturschlüssel abrufen

Bot-Token abrufen

6. Geheimnisse schützen

7. Beispielcode abrufen

Grundlegendes zum Code

kittenbot.js

package.json

8. Anwendung bereitstellen

Projekt-ID abrufen

Cloud Run-Region definieren

Berechtigungen aktualisieren

Anwendung bereitstellen

9. Slack-Ereignisse aktivieren

kittenbot.js

Ereignisse aktivieren

Abonnieren

10. Bot testen

11. Bonus: Bot aktualisieren

Unterhaltungsthreads

Dialogfeld definieren

Dialogfeld zum Controller hinzufügen

Dialogfeld auslösen

App aktualisieren

Jetzt ausprobieren

Slash-Befehle

Slack-Slash-Befehle aktivieren

Dem Controller Slash-Befehle hinzufügen

Jetzt ausprobieren

12. Bereinigen

Projekt löschen

Bereitstellung löschen

Befehlsausgabe

Clientsignaturschlüssel löschen

Befehlsausgabe

Bot-Token-Secret löschen

Befehlsausgabe

Storage-Buckets löschen

Befehlsausgabe

Befehlsausgabe

Befehlsausgabe

13. Glückwunsch!

Behandelte Themen

Nächste Schritte

Weitere Informationen