Compila un bot de Slack con Node.js en Cloud Run

1. Descripción general

En este codelab, aprenderás a compilar un bot de Slack con el kit de herramientas Botkit y a ejecutarlo en Google Cloud. Podrá interactuar con el bot en un canal de Slack en vivo.

Qué aprenderás

Cómo crear una integración personalizada de bot en Slack
Cómo proteger tus secretos de Slack con Secret Manager
Cómo implementar un bot de Slack en Cloud Run, una plataforma de procesamiento completamente administrada que ajusta automáticamente la escala de tus contenedores sin estado

Requisitos

Un proyecto de Google Cloud
Un navegador, como Chrome o Firefox

¿Cómo usarás este instructivo?

Ler

Leer y completar los ejercicios

¿Cómo calificarías tu experiencia con Google Cloud?

Principiante

Intermedio

Avanzado

2. Configuración y requisitos

Configuración del entorno de autoaprendizaje

Accede a Google Cloud Console y crea un proyecto nuevo o reutiliza uno existente. Si aún no tienes una cuenta de Gmail o de Google Workspace, debes crear una.

El Nombre del proyecto es el nombre visible de los participantes de este proyecto. Es una cadena de caracteres que no se utiliza en las APIs de Google. Puedes actualizarla cuando quieras.
El ID del proyecto es único en todos los proyectos de Google Cloud y es inmutable (no se puede cambiar después de configurarlo). La consola de Cloud genera automáticamente una cadena única. Por lo general, no importa cuál sea. En la mayoría de los codelabs, deberás hacer referencia al ID de tu proyecto (suele identificarse como PROJECT_ID). Si no te gusta el ID que se generó, podrías generar otro aleatorio. También puedes probar uno propio y ver si está disponible. No se puede cambiar después de este paso y se usa el mismo durante todo el proyecto.
Recuerda que hay un tercer valor, un número de proyecto, que usan algunas APIs. Obtén más información sobre estos tres valores en la documentación.

A continuación, deberás habilitar la facturación en la consola de Cloud para usar las APIs o los recursos de Cloud. Ejecutar este codelab no costará mucho, tal vez nada. Para cerrar recursos y evitar que se generen cobros más allá de este instructivo, puedes borrar los recursos que creaste o borrar el proyecto. Los usuarios nuevos de Google Cloud son aptos para participar en el programa Prueba gratuita de $300.

Inicia Cloud Shell

Si bien Google Cloud se puede operar de manera remota desde tu laptop, en este instructivo usarás Cloud Shell, un entorno de línea de comandos que se ejecuta en la nube.

Activar Cloud Shell

En la consola de Cloud, haz clic en Activar Cloud Shell.

Si es la primera vez que inicias Cloud Shell, aparecerá una pantalla intermedia en la que se describirá qué es. Si apareció una pantalla intermedia, haz clic en Continuar.

El aprovisionamiento y la conexión a Cloud Shell solo tomará unos minutos.

Esta máquina virtual está cargada con todas las herramientas de desarrollo necesarias. Ofrece un directorio principal persistente de 5 GB y se ejecuta en Google Cloud, lo que permite mejorar considerablemente el rendimiento de la red y la autenticación. Gran parte de tu trabajo en este codelab, si no todo, se puede hacer con un navegador.

Una vez que te conectes a Cloud Shell, deberías ver que te autenticaste y que el proyecto se configuró con tu ID del proyecto.

En Cloud Shell, ejecuta el siguiente comando para confirmar que tienes la autenticación:

gcloud auth list

Resultado del comando

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

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

En Cloud Shell, ejecuta el siguiente comando para confirmar que el comando gcloud conoce tu proyecto:

gcloud config list project

Resultado del comando

[core]
project = <PROJECT_ID>

De lo contrario, puedes configurarlo con el siguiente comando:

gcloud config set project <PROJECT_ID>

Resultado del comando

Updated property [core/project].

3. Habilita las APIs

En Cloud Shell, habilita las APIs de Artifact Registry, Cloud Build, Cloud Run y Secret Manager:

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

Esto genera un mensaje de éxito similar al siguiente:

Operation "operations/..." finished successfully.

Ahora, ya puedes preparar e implementar tu aplicación…

4. Crea un espacio de trabajo de Slack

Necesitarás un espacio de trabajo de Slack en el que puedas crear integraciones personalizadas. Puedes crear un lugar de trabajo de forma gratuita si aún no tienes uno que desees usar para este instructivo.

5. Cree un usuario bot de Slack

Un usuario bot puede escuchar mensajes en Slack, publicarlos y subir archivos. En este codelab, crearás un bot para publicar un mensaje de saludo simple.

Cree una aplicación de Slack nueva

Vaya a la página de administración de aplicaciones de Slack.
Haz clic en el botón Crear app nueva en la esquina superior derecha.
Asigna un nombre a la app, como "Kittenbot".
Seleccione el equipo de Slack en el que desea instalarla.

Crea un usuario de bot

Ve a Página principal de la aplicación en el panel lateral izquierdo, en Funciones.

Haz clic en Revisar los alcances para agregar para asignar un alcance a tu token de bot.
Desplázate hacia abajo hasta Bot Token Scopes y haz clic en Add an OAuth Scope. Selecciona chat:write para "Enviar mensajes como Kittenbot".

Desplázate hacia arriba y haz clic en el botón Instalar la app en tu lugar de trabajo.
Esto instalará la app en tu equipo, agregará el usuario de bot que acabas de crear y generará un token de bot.
Cuando se te solicite, haz clic en "Permitir" para autorizar al bot a chatear en tu espacio de trabajo.

Habilita mensajes y comandos

Desplázate hacia abajo hasta Mostrar pestañas y asegúrate de que ambas opciones estén habilitadas:

Obtén el secreto de firma del cliente

Ve a Información básica en Configuración.
Desplázate hacia abajo hasta Signing Secret, haz clic en Show y, luego, copia el secreto en el portapapeles:

Guarda el secreto en una variable de entorno:

CLIENT_SIGNING_SECRET=PASTE_THE_SIGNING_SECRET

Obtén el token del bot

Ve a OAuth y permisos en Funciones.
Haga clic en el botón Copiar para copiar el texto del token de acceso OAuth del usuario bot en su portapapeles.

Guarda el token del bot en una variable de entorno:

BOT_TOKEN=PASTE_THE_BOT_TOKEN

No te preocupes. Puedes volver a esta página de configuración desde la página de administración de apps si necesitas obtener estos tokens de nuevo.

6. Protege tus secretos

Queremos asegurarnos de que tu token de bot y tu secreto de firma del cliente se almacenen de forma segura. Si los codificas de forma rígida en el código fuente, es probable que expongas accidentalmente estos secretos publicándolos en el control de versiones o incorporándolos en una imagen de Docker.

Secret Manager ofrece un método seguro y conveniente para almacenar claves de API, contraseñas, certificados y otros datos sensibles. Secret Manager proporciona una ubicación central y una fuente de información única para administrar, acceder y auditar secretos en Google Cloud.

Crea tus secretos

Guarda el secreto de firma del cliente y el token del bot con los siguientes comandos:

Secreto de firma del cliente

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 -

Accede a tus Secrets

Confirmemos que tus secretos se crearon correctamente y que tus permisos funcionan. Accede a tus secretos con los siguientes comandos:

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

También puedes ver y administrar tus secretos en la consola de Google Cloud.

7. Obtén el código de muestra

En Cloud Shell, en la línea de comandos, ejecute el siguiente comando para clonar el repositorio de GitHub:

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

Cambia el directorio a cloud-slack-bot/start.

cd cloud-slack-bot/start

Cómo comprender el código

Abre el archivo kittenbot.js con tu editor de línea de comandos preferido (nano, vim, emacs…) o con el siguiente comando para abrir directamente la carpeta actual en el editor de Cloud Shell:

cloudshell workspace .

El código de Kittenbot tiene dos funciones principales. Uno es para recuperar los secretos y el otro es para ejecutar el bot.

Primero, importamos las dependencias:

kittenbot.js

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

SlackAdapter y SlackEventMiddleware son paquetes que extienden Botkit y permiten que el bot traduzca fácilmente mensajes hacia y desde la API de Slack. El cliente de Secret Manager te permitirá acceder a los secretos que guardaste en un paso anterior.

A continuación, tenemos nuestra función para recuperar los secretos:

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

Esta función devuelve los valores de cadena de los secretos necesarios para autenticar el bot.

La siguiente función inicializa el 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 primera parte de la función configura SlackAdapter con los secretos y, luego, especifica un extremo para recibir mensajes. Luego, una vez que el controlador esté encendido, el bot responderá a cualquier mensaje que contenga "hola" con "Miau. 😺".

Consulta estas partes específicas en el manifiesto de la app:

package.json

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

Puedes implementar una app de Node.js directamente desde el código fuente con Cloud Run. A continuación, se muestra lo que sucederá en segundo plano:

Cloud Run llama a Cloud Build para compilar una imagen de contenedor (consulta Implementación desde el código fuente).
Si hay un Dockerfile en el directorio del código fuente, Cloud Build lo usa para compilar una imagen de contenedor.
Como no lo es, Cloud Build llama a Buildpacks para analizar la fuente y generar automáticamente una imagen lista para la producción.
Los buildpacks detectan el manifiesto package.json y compilan una imagen de Node.js.
El campo scripts.start determina cómo se inicia la app.
El campo engines.node determina la versión de Node.js de la imagen base del contenedor.
En el momento de la implementación, se aplican automáticamente las correcciones de seguridad conocidas.

Ya puedes implementar la app.

8. Implementa la app

La API de Slack Events usa webhooks para enviar mensajes salientes sobre eventos. Cuando configures la app de Slack, deberás proporcionar una URL de acceso público para que la API de Slack haga un ping.

Cloud Run es una buena solución para alojar destinos de webhook. Te permite usar cualquier lenguaje o entorno de ejecución que desees y proporciona simultaneidad, lo que significa que tu aplicación podrá controlar un volumen mucho mayor.

Recupera tu ID del proyecto

Define la variable de entorno PROJECT_ID:

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

Define tu región de Cloud Run

Cloud Run es regional, lo que significa que la infraestructura que ejecuta tu servicio de Cloud Run se ubica en una región específica y Google la administra para que esté disponible de manera redundante en todas las zonas de esa región. Define la región que usarás para tu implementación, por ejemplo:

REGION="us-central1"

Actualiza los permisos

Para poder acceder a los secretos de Secret Manager, se le debe otorgar a la cuenta de servicio de Cloud Run el rol roles/secretmanager.secretAccessor.

Primero, guarda la cuenta de servicio predeterminada en una variable de entorno:

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

Confirma que tienes guardada la dirección de correo electrónico:

echo $SERVICE_ACCOUNT

La cuenta de servicio tiene el siguiente formato: PROJECT_NUMBER-compute@developer.gserviceaccount.com.

Una vez que tengas la dirección de correo electrónico, habilita el rol para la cuenta de servicio:

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

Implementa la app

Un servicio de Cloud Run expone un extremo único y ajusta automáticamente la escala de la infraestructura subyacente para controlar las solicitudes entrantes.

Implementa la aplicación en Cloud Run:

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

Esto crea un servicio llamado kittenbot.
La opción --source usa la carpeta actual para compilar la aplicación con Cloud Build. Cloud Build detecta automáticamente la presencia del archivo package.json.
También puedes definir una región predeterminada con este comando: gcloud config set run/region $REGION
También puedes hacer que Cloud Run sea administrado de forma predeterminada con este comando: gcloud config set run/platform managed
La opción --set-env-vars establece las variables de entorno del servicio.
La opción --allow-unauthenticated hace que el servicio esté disponible de forma pública.

La primera vez, recibirás un mensaje para crear un repositorio de Artifact Registry. Presiona Intro para validar:

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

Esto inicia la carga de tu código fuente en el repositorio de Artifact Registry y la compilación de tu imagen de contenedor:

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

Luego, espera un momento hasta que se completen la compilación y la implementación. Si la operación es exitosa, la línea de comandos mostrará la URL de servicio:

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

Puedes obtener la URL del servicio con este comando:

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

La URL tiene el siguiente formato:

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

Esta URL será la base que se usará para habilitar la API de Slack Events. Cópialo en el portapapeles para usarlo en el siguiente paso.

Tu servicio ya está disponible de forma pública. Ve a la consola de Cloud Run para obtener más información.

Puedes ver cuándo se creó la última revisión, cuánto tráfico recibe y consultar los registros. Si hacemos clic en los registros, podemos ver que el controlador de Botkit está activado y listo para recibir mensajes.

Ahora, comencemos a enviar mensajes desde nuestro canal de Slack.

9. Habilita los eventos de Slack

Como vimos antes, nuestro código de kittenbot especifica un extremo relativo para nuestro destino de webhook.

kittenbot.js

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

Esto significa que nuestra URL completa será la parte base del servicio de Cloud Run, más /api/messages.

Habilita Eventos

En la página de administración de aplicaciones, ve a la sección Suscripciones a eventos en la barra lateral y activa Habilitar eventos. Ingresa la URL de tu servicio:

PASTE_THE_SERVICE_URL/api/messages

Según la velocidad con la que escribas la URL, es posible que intente verificarla antes de que termines. Si falla, haz clic en "Reintentar".

Suscríbete a todos los eventos del bot de mensajes.

Al final de la página, haz clic en Guardar cambios. Se te pedirá que reinstales la app. Sigue las instrucciones y haz clic en Permitir.

En este punto, tu bot está completamente integrado. Los mensajes del espacio de trabajo activarán Slack para que envíe mensajes a tu servicio de Cloud Run, que, a su vez, responderá con un saludo simple.

10. Prueba tu bot

Envía un mensaje directo a Kittenbot:

Para agregar Kittenbot a tu canal, ingresa “@kittenbot” y, luego, haz clic en “Invitar”.

Ahora todos los miembros de tu canal pueden interactuar con Kittenbot.

Cada mensaje en Slack activa un evento y envía un mensaje HTTP POST a nuestro servicio de Cloud Run. Si observas los registros del servicio de Cloud Run, verás que cada mensaje corresponde a una entrada POST en el registro.

El kittenbot responde a cada mensaje con "Miau. 😺".

11. Bonificación: Actualiza tu bot

Esta sección opcional debería tomarte unos minutos. Puedes ir directamente a la sección Limpieza.

Hilos de conversaciones

Queremos que el bot haga algo más que decir "miau". Pero ¿cómo implementas una versión nueva de algo que se ejecuta en Cloud Run?

Cambia el directorio a cloud-slack-bot/extra-credit:

cd ../extra-credit/

Abre la carpeta actual en el editor de Cloud Shell:

cloudshell workspace .

Botkit ofrece la capacidad de controlar conversaciones. Con estas, el bot puede solicitar más información y reaccionar a los mensajes con respuestas de más de una palabra.

Define el diálogo

Primero, observa cómo se definen las funciones conversacionales al final del archivo:

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

Esta nueva conversación dirige el hilo según las respuestas. Por ejemplo, si el usuario responde "no" a la pregunta sobre los gatitos, se salta al mensaje etiquetado como "no_kittens", que es el final de ese hilo de conversación.

Cómo agregar el diálogo al controlador

Ahora que se definió la conversación, veamos cómo agregarla al controlador:

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

Activa el diálogo

Ahora que el diálogo está disponible para que lo use el controlador, observa cómo se inicia la conversación cuando el chatbot escucha "gatito", "gatitos", "gato" o "gatos":

  // ...

  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

    // ...
  });

  // ...

Actualizar la aplicación

Vuelve a implementar la aplicación en Cloud Run:

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

Probar

¡Felicitaciones! Acaba de actualizar un bot de Slack que se ejecuta en Cloud Run a una versión nueva.

Comandos de barra

¿Qué sucede si no quieres tener una conversación con el usuario? ¿Qué sucede si prefieres simplemente activar una acción con un comando sencillo?

Slack ofrece esta funcionalidad a través de los comandos de barra, que permiten a los usuarios invocar tu aplicación ingresando el comando en el cuadro de mensaje.

Habilita los comandos de barra de Slack

Ve a la sección Slash Commands en Features en la página de administración de apps.
Haz clic en Create New Command.
Configura un comando /cats con la URL de tu servicio de kittenbot. Recuerda usar el mismo extremo que usaste para habilitar la API de Events. Esta es tu URL, más '/api/messages'.

Sigue las instrucciones para actualizar tu app y los permisos.

Cómo agregar comandos de barra a tu controlador

Observa cómo se agregó un controlador para los comandos de barra dentro de la función 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
  });

  // ...

Probar

Ingresa /cats y un número para enviar el comando de barra. P. ej.: /cats 8

El bot responderá con 8 gatos, que solo tú podrás ver:

12. Limpieza

Felicitaciones, ahora tienes un bot de Slack que se ejecuta en Cloud Run. Es hora de limpiar los recursos usados (para reducir los costos y ser un buen ciudadano de la nube).

Borra el proyecto

Puedes borrar todo el proyecto directamente desde Cloud Shell:

gcloud projects delete $PROJECT_ID

Como alternativa, si prefieres borrar los diferentes recursos uno por uno, continúa con la siguiente sección.

Borra la implementación

gcloud run services delete kittenbot --region $REGION

Resultado del comando

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

Borra tu secreto de firma del cliente

gcloud secrets delete client-signing-secret

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

Borra el secreto de tu token de bot

gcloud secrets delete bot-token

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

Borra los buckets de almacenamiento

Primero, enumera los buckets de Google Cloud Storage para obtener la ruta de acceso al bucket:

gsutil ls

Resultado del comando

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

Ahora, borra el bucket de artefactos:

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

Resultado del comando

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

Por último, borra el bucket de cloudbuild:

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

Resultado del comando

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

13. ¡Felicitaciones!

Ahora ya sabes cómo ejecutar un bot de Slack en Cloud Run.

Solo aprendimos los aspectos básicos de esta tecnología y te recomendamos que sigas explorando con tus propias implementaciones de Cloud Run.

Temas abordados

Cómo crear una integración personalizada de un bot en Slack
Protege tus secretos de Slack con Secret Manager
Implementa tu bot de Slack en Cloud Run

Próximos pasos

Completar más instructivos de Cloud Run

Más información

Consulta los otros ejemplos de integración de Slack de Google Cloud en GitHub.
Prueba otras funciones de Google Cloud. Revisa nuestros instructivos.

Compila un bot de Slack con Node.js en Cloud Run

1. Descripción general

Qué aprenderás

Requisitos

¿Cómo usarás este instructivo?

¿Cómo calificarías tu experiencia con Google Cloud?

2. Configuración y requisitos

Configuración del entorno de autoaprendizaje

Inicia Cloud Shell

Activar Cloud Shell

3. Habilita las APIs

4. Crea un espacio de trabajo de Slack

5. Cree un usuario bot de Slack

Cree una aplicación de Slack nueva

Crea un usuario de bot

Habilita mensajes y comandos

Obtén el secreto de firma del cliente

Obtén el token del bot

6. Protege tus secretos

7. Obtén el código de muestra

Cómo comprender el código

kittenbot.js

package.json

8. Implementa la app

Recupera tu ID del proyecto

Define tu región de Cloud Run

Actualiza los permisos

Implementa la app

9. Habilita los eventos de Slack

kittenbot.js

Habilita Eventos

Suscribirse

10. Prueba tu bot

11. Bonificación: Actualiza tu bot

Hilos de conversaciones

Define el diálogo

Cómo agregar el diálogo al controlador

Activa el diálogo

Actualizar la aplicación

Probar

Comandos de barra

Habilita los comandos de barra de Slack

Cómo agregar comandos de barra a tu controlador

Probar

12. Limpieza

Borra el proyecto

Borra la implementación

Resultado del comando

Borra tu secreto de firma del cliente

Resultado del comando

Borra el secreto de tu token de bot

Resultado del comando

Borra los buckets de almacenamiento

Resultado del comando

Resultado del comando

Resultado del comando

13. ¡Felicitaciones!

Temas abordados

Próximos pasos

Más información