Crea un bot Slack con Node.js su Cloud Run

1. Panoramica

In questo codelab, imparerai a creare un bot Slack utilizzando il toolkit Botkit ed eseguirlo su Google Cloud. Potrai interagire con il bot in un canale Slack live.

Obiettivi didattici

Come creare un'integrazione personalizzata di bot in Slack
Come proteggere i secret di Slack con Secret Manager
Come eseguire il deployment di un bot Slack su Cloud Run, una piattaforma di computing completamente gestita che scala automaticamente i tuoi container stateless

Che cosa ti serve

Un progetto Google Cloud
Un browser come Chrome o Firefox

Come utilizzerai questo tutorial?

Leggilo e basta

Leggilo e completa gli esercizi

Come valuteresti la tua esperienza con Google Cloud?

Principiante

Intermedio

Avanzato

2. Configurazione e requisiti

Configurazione dell'ambiente autonomo

Accedi alla console Google Cloud e crea un nuovo progetto o riutilizzane uno esistente. Se non hai ancora un account Gmail o Google Workspace, devi crearne uno.

Il nome del progetto è il nome visualizzato per i partecipanti a questo progetto. È una stringa di caratteri non utilizzata dalle API di Google. Puoi sempre aggiornarlo.
L'ID progetto è univoco in tutti i progetti Google Cloud ed è immutabile (non può essere modificato dopo l'impostazione). La console Cloud genera automaticamente una stringa univoca, di solito non ti interessa di cosa si tratta. Nella maggior parte dei codelab, dovrai fare riferimento all'ID progetto (in genere identificato come PROJECT_ID). Se non ti piace l'ID generato, puoi generarne un altro casuale. In alternativa, puoi provare a crearne uno e vedere se è disponibile. Non può essere modificato dopo questo passaggio e rimane per tutta la durata del progetto.
Per tua informazione, esiste un terzo valore, un numero di progetto, utilizzato da alcune API. Scopri di più su tutti e tre questi valori nella documentazione.

Successivamente, devi abilitare la fatturazione in Cloud Console per utilizzare le risorse/API Cloud. Completare questo codelab non costa molto, se non nulla. Per arrestare le risorse ed evitare addebiti oltre a quelli previsti in questo tutorial, puoi eliminare le risorse che hai creato o il progetto. I nuovi utenti di Google Cloud possono usufruire del programma prova senza costi di 300$.

Avvia Cloud Shell

Sebbene Google Cloud possa essere gestito da remoto dal tuo laptop, in questo tutorial utilizzerai Cloud Shell, un ambiente a riga di comando in esecuzione nel cloud.

Attiva Cloud Shell

Nella console Cloud, fai clic su Attiva Cloud Shell .

Se è la prima volta che avvii Cloud Shell, viene visualizzata una schermata intermedia che ne descrive le funzionalità. Se è stata visualizzata una schermata intermedia, fai clic su Continua.

Bastano pochi istanti per eseguire il provisioning e connettersi a Cloud Shell.

Questa macchina virtuale è caricata con tutti gli strumenti di sviluppo necessari. Offre una home directory permanente da 5 GB e viene eseguita in Google Cloud, migliorando notevolmente le prestazioni e l'autenticazione della rete. Gran parte del lavoro per questo codelab, se non tutto, può essere svolto con un browser.

Una volta eseguita la connessione a Cloud Shell, dovresti vedere che il tuo account è autenticato e il progetto è impostato sul tuo ID progetto.

Esegui questo comando in Cloud Shell per verificare che l'account sia autenticato:

gcloud auth list

Output comando

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

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

Esegui questo comando in Cloud Shell per verificare che il comando gcloud conosca il tuo progetto:

gcloud config list project

Output comando

[core]
project = <PROJECT_ID>

In caso contrario, puoi impostarlo con questo comando:

gcloud config set project <PROJECT_ID>

Output comando

Updated property [core/project].

3. Abilita le API

Da Cloud Shell, abilita le API Artifact Registry, Cloud Build, Cloud Run e Secret Manager:

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

Viene visualizzato un messaggio di operazione riuscita simile a questo:

Operation "operations/..." finished successfully.

Ora puoi preparare ed eseguire il deployment dell'applicazione.

4. Creare un workspace Slack

Avrai bisogno di un'area di lavoro Slack in cui ti è consentito creare integrazioni personalizzate. Puoi creare uno spazio di lavoro senza costi se non ne hai già uno che vuoi utilizzare per questo tutorial.

5. Creare un utente bot Slack

Un utente bot può ascoltare i messaggi su Slack, pubblicare messaggi e caricare file. In questo codelab creerai un bot per pubblicare un semplice messaggio di saluto.

Creare una nuova app Slack

Vai alla pagina di gestione delle app Slack.
Fai clic sul pulsante Crea nuova app nell'angolo in alto a destra.
Assegna un nome all'app, ad esempio "Kittenbot".
Scegli il team Slack in cui vuoi installarla.

Creare un utente bot

Vai a Home page dell'app nel riquadro a sinistra in Funzionalità.

Assegna un ambito al token del bot facendo clic su Esamina gli ambiti da aggiungere.
Scorri verso il basso fino ad Ambiti token bot e fai clic su Aggiungi un ambito OAuth. Seleziona chat:write per "Inviare messaggi come Kittenbot".

Scorri verso l'alto e fai clic sul pulsante Installa l'app nel tuo spazio di lavoro.
In questo modo, l'app verrà installata nel tuo team, verrà aggiunto l'utente bot appena creato e verrà generato un token bot.
Quando richiesto, fai clic su "Consenti" per autorizzare il bot a chattare nel tuo spazio di lavoro.

Attivare messaggi e comandi

Scorri verso il basso fino a Mostra schede e assicurati che entrambe le opzioni siano attive:

Ottenere il secret di firma del client

Vai a Informazioni di base in Impostazioni.
Scorri verso il basso fino a Signing Secret, fai clic su Mostra e poi copia il secret negli appunti:

Salva il secret in una variabile di ambiente:

CLIENT_SIGNING_SECRET=PASTE_THE_SIGNING_SECRET

Recuperare il token del bot

Vai a OAuth e autorizzazioni in Funzionalità.
Fai clic sul pulsante Copia per copiare il testo del token di accesso OAuth utente bot negli appunti.

Salva il token del bot in una variabile di ambiente:

BOT_TOKEN=PASTE_THE_BOT_TOKEN

Non preoccuparti. Puoi tornare a questa pagina di configurazione dalla pagina di gestione delle app se devi recuperare di nuovo questi token.

6. Proteggere i secret

Vogliamo assicurarci che il token del bot e il segreto di firma del client siano archiviati in modo sicuro. La codifica hardcoded nel codice sorgente rende probabile l'esposizione accidentale di questi segreti pubblicandoli nel controllo delle versioni o incorporandoli in un'immagine Docker.

Secret Manager offre un metodo sicuro e conveniente per archiviare chiavi API, password, certificati e altri dati sensibili. Secret Manager fornisce un posto centralizzato e un'unica fonte attendibile per gestire, accedere e controllare i secret in Google Cloud.

Crea i tuoi segreti

Salva il segreto di firma del client e il token del bot con i seguenti comandi:

Client secret di firma

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

Token bot

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

Accedere ai segreti

Verifichiamo che i segreti siano stati creati correttamente e che le autorizzazioni funzionino. Accedi ai tuoi secret con i seguenti comandi:

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

Puoi anche visualizzare e gestire i tuoi secret nella console Google Cloud.

7. recupera il codice campione

In Cloud Shell, nella riga di comando, esegui questo comando per clonare il repository GitHub:

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

Passa alla directory cloud-slack-bot/start.

cd cloud-slack-bot/start

Comprendere il codice

Apri il file kittenbot.js con il tuo editor della riga di comando preferito (nano, vim, emacs...) o con il comando seguente per aprire direttamente la cartella corrente nell'editor di Cloud Shell:

cloudshell workspace .

Il codice di kittenbot ha due funzioni principali. Uno per recuperare i secret e l'altro per eseguire il bot.

Innanzitutto, importiamo le dipendenze:

kittenbot.js

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

SlackAdapter e SlackEventMiddleware sono pacchetti che estendono Botkit e consentono al bot di tradurre facilmente i messaggi da e verso l'API Slack. Il client Secret Manager ti consentirà di accedere ai secret salvati in un passaggio precedente.

Poi abbiamo la funzione per recuperare i secret:

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

Questa funzione restituisce i valori stringa dei secret necessari per autenticare il bot.

La funzione successiva inizializza il 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:');
      }
    );
  });
}

La prima parte della funzione configura SlackAdapter con i secret, quindi specifica un endpoint per la ricezione dei messaggi. Una volta acceso il controller, il bot risponderà a qualsiasi messaggio contenente "hello", "hi" o "hey" con "Meow. 😺".

Controlla queste parti specifiche nel manifest dell'app:

package.json

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

Puoi eseguire il deployment di un'app Node.js direttamente dall'origine con Cloud Run. Ecco cosa succederà in background:

Cloud Run chiama Cloud Build per creare un'immagine container (vedi Deployment dal codice sorgente).
Se nella directory del codice sorgente è presente un Dockerfile, Cloud Build lo utilizza per creare un'immagine container.
Poiché non lo è, Cloud Build chiama Buildpack per analizzare l'origine e generare automaticamente un'immagine pronta per la produzione.
Buildpack rileva il manifest package.json e crea un'immagine Node.js.
Il campo scripts.start determina la modalità di avvio dell'app.
Il campo engines.node determina la versione di Node.js dell'immagine di base del container.
Al momento del deployment, vengono applicate automaticamente le correzioni di sicurezza note.

Ora puoi eseguire il deployment dell'app.

8. Esegui il deployment dell'app

L'API Slack Events utilizza i webhook per inviare messaggi in uscita sugli eventi. Quando configuri l'app Slack, devi fornire un URL accessibile pubblicamente per il ping dell'API Slack.

Cloud Run è una buona soluzione per l'hosting delle destinazioni webhook. Ti consente di utilizzare qualsiasi linguaggio o runtime e offre la concorrenza, il che significa che la tua applicazione sarà in grado di gestire un volume molto più elevato.

Recuperare l'ID progetto

Definisci la variabile di ambiente PROJECT_ID:

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

Definisci la regione Cloud Run

Cloud Run è regionale, il che significa che l'infrastruttura che esegue il servizio Cloud Run si trova in una regione specifica ed è gestita da Google per essere disponibile in modo ridondante in tutte le zone all'interno di quella regione. Definisci la regione che utilizzerai per il deployment, ad esempio:

REGION="us-central1"

Aggiorna le autorizzazioni

Per poter accedere ai secret da Secret Manager, al service account Cloud Run deve essere concesso il ruolo roles/secretmanager.secretAccessor.

Innanzitutto, salva il service account predefinito in una variabile di ambiente:

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

Conferma di aver salvato l'indirizzo email:

echo $SERVICE_ACCOUNT

Il service account ha il seguente formato: PROJECT_NUMBER-compute@developer.gserviceaccount.com.

Una volta ottenuto l'indirizzo email, attiva il ruolo per il service account:

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

Eseguire il deployment dell'app

Un servizio Cloud Run espone un endpoint univoco e scala automaticamente l'infrastruttura sottostante per gestire le richieste in entrata.

Esegui il deployment dell'app in Cloud Run:

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

Viene creato un servizio denominato kittenbot.
L'opzione --source utilizza la cartella corrente per creare l'applicazione con Cloud Build. Cloud Build rileva automaticamente la presenza del file package.json.
In alternativa, puoi definire una regione predefinita con questo comando: gcloud config set run/region $REGION
Puoi anche impostare Cloud Run come servizio gestito per impostazione predefinita con questo comando: gcloud config set run/platform managed
L'opzione --set-env-vars imposta le variabili di ambiente del servizio.
L'opzione --allow-unauthenticated rende il servizio disponibile pubblicamente.

La prima volta, ti verrà chiesto di creare un repository Artifact Registry. Tocca Invio per convalidare:

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

Viene avviato il caricamento del codice sorgente nel repository Artifact Registry e la creazione dell'immagine container:

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

Poi, attendi qualche istante fino al completamento della build e del deployment. Se l'operazione riesce, la riga di comando visualizza l'URL del servizio:

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

Puoi ottenere l'URL del servizio con questo comando:

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

L'URL ha il seguente formato:

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

Questo URL sarà la base utilizzata per abilitare l'API Slack Events. Copialo negli appunti per utilizzarlo nel passaggio successivo.

Il tuo servizio è ora attivo e disponibile pubblicamente. Per saperne di più, vai alla console Cloud Run.

Puoi vedere quando è stata creata l'ultima revisione, il volume di traffico che riceve e consultare i log. Se facciamo clic sui log, possiamo vedere che il controller Botkit è attivo e pronto a ricevere messaggi.

Ora iniziamo a inviare messaggi dal nostro canale Slack.

9. Attivare gli eventi Slack

Come abbiamo visto in precedenza, il nostro codice kittenbot specifica un endpoint relativo per la destinazione del webhook.

kittenbot.js

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

Ciò significa che l'URL completo sarà la parte di base del servizio Cloud Run, più /api/messages.

Attiva Eventi

Nella pagina di gestione delle app, vai alla sezione Abbonamenti agli eventi nella barra laterale e attiva l'opzione Attiva eventi. Inserisci l'URL del servizio:

PASTE_THE_SERVICE_URL/api/messages

A seconda della velocità con cui digiti l'URL, potrebbe tentare di eseguire la verifica prima che tu abbia finito. Se non va a buon fine, fai clic su "Riprova".

Iscriviti a tutti gli eventi del bot di messaggi.

Fai clic su Salva modifiche nella parte inferiore della pagina. Ti verrà chiesto di reinstallare l'app. Segui le istruzioni e fai clic su Consenti.

A questo punto, il bot è completamente integrato. I messaggi nel workspace attiveranno l'invio di messaggi da parte di Slack al tuo servizio Cloud Run, che a sua volta risponderà con un semplice saluto.

10. Testa il bot

Inviare un messaggio diretto a Kittenbot:

Aggiungi kittenbot al tuo canale inserendo "@kittenbot" e poi facendo clic su "Invita":

Ora tutti gli utenti del tuo canale possono interagire con Kittenbot.

Ogni messaggio in Slack attiva un evento e invia un messaggio HTTP POST al nostro servizio Cloud Run. Se esamini i log del servizio Cloud Run, vedrai che ogni messaggio corrisponde a una voce POST nel log.

Il gattobot risponde a ogni messaggio con "Miao. 😺".

11. Bonus: aggiorna il bot

Questa sezione facoltativa dovrebbe richiedere alcuni minuti. Puoi passare direttamente alla pulizia.

Thread conversazionali

Vorremmo che il bot facesse di più che dire "miao". Ma come si esegue il deployment di una nuova versione di un elemento in esecuzione su Cloud Run?

Passa alla directory cloud-slack-bot/extra-credit:

cd ../extra-credit/

Apri la cartella corrente nell'editor di Cloud Shell:

cloudshell workspace .

Botkit offre la possibilità di gestire le conversazioni. In questo modo, il bot può richiedere maggiori informazioni e reagire ai messaggi in modo più articolato di una semplice risposta di una parola.

Definisci la finestra di dialogo

Innanzitutto, vedi come sono definite le funzioni conversazionali alla fine del file:

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

Questa nuova conversazione indirizza il thread in base alle risposte. Ad esempio, se l'utente risponde "no" alla domanda sul gattino, si passa al messaggio con l'etichetta "no_kittens", che è la fine del thread della conversazione.

Aggiungere la finestra di dialogo al controller

Ora che la conversazione è definita, scopri come aggiungerla al controller:

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

Attivare la finestra di dialogo

Ora che la finestra di dialogo è disponibile per l'utilizzo da parte del controller, scopri come inizia la conversazione quando il chatbot sente "gattino", "gattini", "gatto" o "gatti":

  // ...

  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

    // ...
  });

  // ...

Aggiornamento dell'app

Esegui di nuovo il deployment dell'applicazione in Cloud Run:

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

Prova

Complimenti! Hai appena aggiornato un bot Slack in esecuzione su Cloud Run a una nuova versione.

Comandi slash

Cosa succede se non vuoi avere una conversazione con l'utente? E se preferissi semplicemente attivare un'azione con un solo comando?

Slack offre questa funzionalità tramite i comandi slash, che consentono agli utenti di richiamare l'applicazione inserendo il comando nella casella di messaggio.

Abilitare i comandi slash di Slack

Vai alla sezione Comandi slash in Funzionalità nella pagina di gestione delle app.
Fai clic su Crea nuovo comando.
Configura un comando /cats con l'URL del servizio kittenbot. Ricorda di utilizzare lo stesso endpoint che hai utilizzato per abilitare l'API Events. Questo è il tuo URL, più '/api/messages'.

Segui il prompt per aggiornare l'app e le autorizzazioni.

Aggiungere comandi slash al controller

Scopri come è stato aggiunto un gestore per i comandi slash all'interno della funzione 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
  });

  // ...

Prova

Inserisci /cats più un numero per inviare il comando slash. Ad es.: /cats 8

Il bot risponderà con 8 gatti, visibili solo a te:

12. Esegui la pulizia

Congratulazioni, ora hai un bot Slack in esecuzione su Cloud Run. È il momento di pulire le risorse utilizzate (per risparmiare sui costi ed essere un buon cittadino del cloud).

Elimina il progetto

Puoi eliminare l'intero progetto direttamente da Cloud Shell:

gcloud projects delete $PROJECT_ID

In alternativa, se preferisci eliminare le diverse risorse una alla volta, vai alla sezione successiva.

Eliminare il deployment

gcloud run services delete kittenbot --region $REGION

Output comando

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

Eliminare il client secret di firma

gcloud secrets delete client-signing-secret

Output comando

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

Eliminare il secret del token del bot

gcloud secrets delete bot-token

Output comando

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

Elimina i bucket di archiviazione

Innanzitutto, elenca i bucket Google Cloud Storage per ottenere il percorso del bucket:

gsutil ls

Output comando

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

Ora elimina il bucket degli artefatti:

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

Output comando

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

Infine, elimina il bucket cloudbuild:

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

Output comando

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

13. Complimenti!

Ora sai come eseguire un bot Slack su Cloud Run.

Abbiamo solo scalfito la superficie di questa tecnologia e ti invitiamo a esplorarla ulteriormente con le tue implementazioni di Cloud Run.

Argomenti trattati

Creazione di un'integrazione personalizzata di un bot in Slack
Proteggere i secret di Slack con Secret Manager
Deployment del bot Slack su Cloud Run

Passaggi successivi

Completa altri tutorial di Cloud Run

Scopri di più

Dai un'occhiata agli altri esempi di integrazione di Slack di Google Cloud su GitHub.
Prova le altre funzionalità di Google Cloud. Dai un'occhiata ai nostri tutorial.