Questa pagina è stata tradotta dall'API Cloud Translation.

Crea un bot Slack con Node.js su Cloud Run

1. Panoramica

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

Cosa imparerai a fare

Come creare un'integrazione personalizzata di bot in Slack
Come proteggere i tuoi secret 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?

Solo lettura

Leggilo e completa gli esercizi

Come valuteresti la tua esperienza con Google Cloud?

Principiante

Livello intermedio

Eccellente

2. Configurazione e requisiti

Configurazione dell'ambiente da seguire in modo 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 progetto è il nome visualizzato dei partecipanti del progetto. Si tratta di una stringa di caratteri non utilizzata dalle API di Google. Puoi sempre aggiornarla.
L'ID progetto è univoco in tutti i progetti Google Cloud ed è immutabile (non può essere modificato dopo essere stato impostato). La console Cloud genera automaticamente una stringa univoca. di solito non ti importa cosa sia. Nella maggior parte dei codelab, dovrai fare riferimento al tuo ID progetto (in genere identificato come PROJECT_ID). Se l'ID generato non ti soddisfa, potresti generarne un altro casuale. In alternativa, puoi provarne una personalizzata per verificare se è disponibile. Non può essere modificato dopo questo passaggio e rimane per tutta la durata del progetto.
Per informazione, c'è un terzo valore, il numero di progetto, utilizzato da alcune API. Scopri di più su tutti e tre questi valori nella documentazione.

Successivamente, dovrai abilitare la fatturazione nella console Cloud per utilizzare risorse/API Cloud. L'esecuzione di questo codelab non ha alcun costo. Per arrestare le risorse ed evitare di incorrere in fatturazione dopo questo tutorial, puoi eliminare le risorse che hai creato o eliminare il progetto. I nuovi utenti di Google Cloud sono idonei al programma prova senza costi di 300$.

Avvia Cloud Shell

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

Attiva Cloud Shell

Dalla console Cloud, fai clic su Attiva Cloud Shell .

Se è la prima volta che avvii Cloud Shell, ti verrà mostrata una schermata intermedia che descrive di cosa si tratta. Se ti è stata presentata una schermata intermedia, fai clic su Continua.

Il provisioning e la connessione a Cloud Shell dovrebbero richiedere solo qualche istante.

Questa macchina virtuale viene 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 di rete e l'autenticazione. Gran parte, se non tutto, del lavoro in questo codelab può essere svolto con un browser.

Una volta stabilita la connessione a Cloud Shell, dovresti vedere che hai eseguito l'autenticazione e che 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 confermare che il comando gcloud è a conoscenza del 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 della tua applicazione...

4. Crea un'area di lavoro Slack

Hai bisogno di un'area di lavoro Slack in cui puoi creare integrazioni personalizzate. Puoi creare un'area di lavoro senza costi aggiuntivi se non ne hai già una da utilizzare per questo tutorial.

5. Crea un utente bot Slack

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

Creare una nuova app Slack

Vai alla pagina di gestione delle app di 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 di Slack in cui vuoi installarlo.

Creare un utente bot

Vai alla home page dell'app nel riquadro laterale a sinistra, nella sezione Funzionalità.

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

Scorri verso l'alto e fai clic sul pulsante Installa l'app in Workspace.
L'app verrà installata nel tuo team, verrà aggiunto l'utente bot che hai appena creato e verrà generato un token del bot.
Quando richiesto, fai clic su "Consenti". per autorizzare il bot a chattare nell'area di lavoro.

Attivare messaggi e comandi

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

Recuperare il secret di firma client

Vai a Informazioni di base in Impostazioni.
Scorri verso il basso fino a Segreto di firma, fai clic su Mostra,quindi copia il secret negli appunti:

Salva il secret in una variabile di ambiente:

CLIENT_SIGNING_SECRET=PASTE_THE_SIGNING_SECRET

Scaricare il token del bot

Vai a OAuth e Autorizzazioni nella sezione Funzionalità.
Fai clic sul pulsante Copia per copiare il testo 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. Custodisci i tuoi segreti

Vogliamo assicurarci che il token del bot e il secret di firma del client siano archiviati in modo sicuro. L'hardcoded nel codice sorgente consente di esporre accidentalmente questi secret pubblicandoli nel controllo della versione o incorporandoli in un'immagine Docker.

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

Crea i tuoi secret

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

Secret di firma client

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

Token del bot

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

Accedi ai tuoi secret

Confermiamo che i tuoi secret sono stati creati correttamente e che le tue autorizzazioni funzionano. 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 visualizzare e gestire i tuoi secret anche nella console Google Cloud.

7. recupera il codice campione

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

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

Cambia directory in 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 seguente comando per aprire direttamente la cartella corrente nell'editor di Cloud Shell:

cloudshell workspace .

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

Per prima cosa, importi 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 nostra 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 lo SlackAdapter con i secret, quindi specifica un endpoint per la ricezione dei messaggi. Una volta attivato il controller, il bot risponderà a qualsiasi messaggio contenente "ciao", "ciao" o "ehi" con "Miao. 💩".

Dai un'occhiata a queste parti specifiche nel file 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. Di seguito è riportata la situazione:

Cloud Run chiama Cloud Build per creare un'immagine container (consulta Deployment da codice sorgente).
Se nella directory del codice sorgente è presente un elemento Dockerfile, Cloud Build lo utilizza per creare un'immagine container.
Poiché non lo è, Cloud Build chiama Buildpacks per analizzare l'origine e generare automaticamente un'immagine pronta per la produzione.
Buildpacks 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 Node.js dell'immagine di base del container.
Al momento del deployment, vengono applicate automaticamente le correzioni note alla sicurezza.

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 relativi agli eventi. Quando configuri l'app Slack, devi fornire un URL pubblicamente accessibile a cui l'API Slack può eseguire il ping.

Cloud Run è una buona soluzione per l'hosting di destinazioni webhook. Ti consente di usare qualsiasi linguaggio o runtime che preferisci e offre contemporaneità, 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 di Cloud Run

Cloud Run è regionale, il che significa che l'infrastruttura che esegue il tuo 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"

Aggiornare le autorizzazioni

Per poter accedere ai secret da Secret Manager, all'account di servizio Cloud Run deve essere concesso il ruolo roles/secretmanager.secretAccessor.

Innanzitutto, salva l'account di servizio predefinito in una variabile di ambiente:

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

Verifica di aver salvato l'indirizzo email:

echo $SERVICE_ACCOUNT

L'account di servizio ha il seguente formato: PROJECT_NUMBER-compute@developer.gserviceaccount.com.

Una volta ottenuto l'indirizzo email, abilita il ruolo per l'account di servizio:

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 chiamato 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 rendere Cloud Run 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)?

Verrà avviato il caricamento del codice sorgente nel repository Artifact Registry e la build 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 ...

Quindi, attendi il 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. Copiala negli appunti per utilizzarla nel passaggio successivo.

Il tuo servizio è ora attivo e disponibile pubblicamente. Per ulteriori informazioni, vai alla console Cloud Run.

Puoi vedere quando è stata creata l'ultima revisione, il volume di traffico che sta ricevendo e controllare i log. Se facciamo clic sui log, vediamo che il controller Botkit è acceso e pronto a ricevere messaggi.

Ora iniziamo a inviare messaggi dal nostro canale Slack.

9. Abilita eventi Slack

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

kittenbot.js

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

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

Abilitare gli eventi

Nella pagina di gestione delle app, vai alla sezione Abbonamenti a Eventi nella barra laterale e attiva Abilita eventi. Inserisci l'URL del tuo servizio:

PASTE_THE_SERVICE_URL/api/messages

A seconda della velocità con cui digiti l'URL, potrebbe provare a effettuare una verifica prima che tu abbia finito. Se il tentativo 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 tuo bot è completamente integrato. I messaggi nell'area di lavoro attiveranno l'invio di messaggi da parte di Slack al servizio Cloud Run, che a sua volta risponderà con un semplice saluto.

10. Testa il bot

Invia un messaggio diretto a Kittenbot:

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

Ora tutti i membri del tuo canale possono interagire con Kittenbot.

Ogni messaggio in Slack attiva un evento e invia un messaggio POST HTTP al nostro servizio Cloud Run. Se dai un'occhiata ai log del servizio Cloud Run, noterai che ogni messaggio corrisponde a una voce POST nel log.

Il kittenbot risponde a ogni messaggio con "Miao. 💩".

11. Bonus: aggiorna il tuo bot

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

Thread conversazionali

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

Cambia directory in 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. Con queste funzionalità, il bot può richiedere maggiori informazioni e reagire ai messaggi anche dopo una risposta di una sola parola.

Definisci la finestra di dialogo

Vediamo anzitutto come vengono 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 di quel thread di conversazione.

Aggiunta della finestra di dialogo al controller

Ora che la conversazione è stata 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(() => {
    // ...
  });
}

Attiva la finestra di dialogo

Ora che la finestra di dialogo è disponibile per il controller, guarda 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 a una nuova versione un bot Slack in esecuzione su Cloud Run.

Comandi di Slash

E se non si vuole avere una conversazione con l'utente? E se invece volessi attivare un'azione con un semplice comando?

Slack offre questa funzionalità tramite i comandi di SSH, che consentono agli utenti di richiamare la tua applicazione inserendo il comando nella casella del messaggio.

Abilita i comandi slash di Slack

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

Segui le istruzioni per aggiornare l'app e le autorizzazioni.

Aggiungi comandi slash al controller

Guarda 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. Esempio: /cats 8

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

12. Esegui la pulizia

Complimenti, ora hai un bot Slack in esecuzione su Cloud Run. È il momento di ripulire le risorse utilizzate (per risparmiare sui costi ed essere una buona cittadinanza del cloud).

Eliminare il progetto

Puoi eliminare l'intero progetto direttamente da Cloud Shell:

gcloud projects delete $PROJECT_ID

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

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

Elimina il secret di firma del client

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

Eliminare i bucket di archiviazione

Per prima cosa, 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 approfondire la questione con i tuoi deployment di Cloud Run.

Argomenti trattati

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

Passaggi successivi

Completa altri tutorial su Cloud Run

Scopri di più

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