Se usó la API de Cloud Translation para traducir esta página.

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 de 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 escala automáticamente 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, verás una pantalla intermedia que describe en qué consiste. 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 mejora 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 estás autenticado y que el proyecto está configurado 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`

Ejecuta el siguiente comando en Cloud Shell para confirmar que el comando de 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. Habilitación de las API

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 mostrará un mensaje de éxito similar a este:

Operation "operations/..." finished successfully.

Ya está todo listo para preparar y, luego, implementar tu aplicación...

4. Crea un espacio de trabajo de Slack

Necesitarás un lugar de trabajo de Slack en el que tengas permitido 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 sencillo.

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 Create new app en la esquina superior derecha.
Asígnale un nombre a la app, como "Kittenbot".
Seleccione el equipo de Slack en el que desea instalarla.

Crea un usuario bot

Ve a Página principal de la app en el panel lateral izquierdo en Funciones.

Para asignar un alcance al token de tu bot, haz clic en Review Scopes to Add.
Desplázate hacia abajo a Bot Token Scopes y haz clic en Agregar un permiso de OAuth. Selecciona chat:write para "Enviar mensajes como Kittenbot".

Desplázate hacia arriba y haz clic en el botón Install App to your Workspace.
Esto instalará la app para tu equipo, agregará el usuario 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

En Configuración, ve a Información básica.
Desplázate hacia abajo hasta Signing Secret, haz clic en Show y, luego, cópialo en el portapapeles:

Guarda el secreto en una variable de entorno:

CLIENT_SIGNING_SECRET=PASTE_THE_SIGNING_SECRET

Obtén el token del bot

Dirígete a OAuth & 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 nuevamente.

6. Protege tus secretos

Queremos asegurarnos de que el token de tu bot y el secreto de firma de tu cliente se almacenen de forma segura. Si los codificas en el código fuente, es probable que se expongan accidentalmente estos secretos mediante su publicación en el control de versiones o su incorporación en una imagen de Docker.

Secret Manager proporciona 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 secretos

Guarda el secreto de firma de tu 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 de bot

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

Accede a tus Secrets

Confirma que tus Secrets 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

Comprensión del código

Abre el archivo kittenbot.js con tu editor de línea de comandos preferido (nano, vim, emacs, etc.) 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. Una es recuperar los secretos y la otra es 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 mensajes fácilmente desde y hacia 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 muestra 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 "hello", "hi" o "hey". con "Miau. salas de compras.

Echa un vistazo a 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 la fuente con Cloud Run. Lo siguiente sucederá en niveles más profundos:

Cloud Run llama a Cloud Build para compilar una imagen de contenedor (consulta Implementa 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.
Dado que no es así, Cloud Build llama a Buildpacks para analizar la fuente y generar automáticamente una imagen lista para la producción.
Los paquetes de compilación 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, las correcciones de seguridad conocidas se aplican automáticamente.

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

Cloud Run es una buena solución para alojar objetivos 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á manejar volúmenes mucho mayores.

Recupera el ID de tu 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 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 la implementación, por ejemplo:

REGION="us-central1"

Actualiza los permisos

Para poder acceder a los secretos desde Secret Manager, a la cuenta de servicio de Cloud Run se le debe otorgar 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 hayas guardado 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.
Como alternativa, 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
Con la opción --set-env-vars, se establecen las variables de entorno de 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 lo siguiente:

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 al 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 eventos de Slack. Cópiala en el portapapeles para usarla en el siguiente paso.

Tu servicio ya está activo y 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 ver los registros. Si hacemos clic en los registros, podemos ver que el controlador de Botkit está encendido y listo para recibir mensajes.

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

9. Habilita eventos de Slack

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

kittenbot.js

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

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

Cómo habilitar eventos

En la página de administración de apps, ve a la sección Events Subscriptions (Suscripciones a eventos) en la barra lateral y activa la opción Enable Events. Ingresa la URL de servicio:

PASTE_THE_SERVICE_URL/api/messages

Según qué tan rápido escribas la URL, es posible que se intente verificar antes de terminar. Si se produce un error, haz clic en "Reintentar".

Suscribirse a todos los eventos del bot de mensajes.

Haz clic en Guardar cambios en la parte inferior de la página. Se te solicitará que reinstales la aplicación. Revisa las indicaciones y haz clic en Permitir.

En este punto, tu bot está completamente integrado. Los mensajes en el espacio de trabajo activarán Slack para enviar mensajes a tu servicio de Cloud Run, el cual, a su vez, responderá con un saludo sencillo.

10. Prueba tu bot

Envía un mensaje directo a Kittenbot:

Ingrese “@kittenbot” para agregar a kittenbot a su canal. y, luego, en "Invitarlos":

Ahora todos los usuarios 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. salas de compras.

11. Contenido adicional: Actualiza tu bot

Esta sección opcional debería tardar unos minutos. Puedes pasar directamente a Limpieza.

Conversaciones

Queremos que el bot no diga solamente "meow". Pero ¿cómo se implementa una nueva versión 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 conversación nueva dirige la conversación en función de las respuestas. Por ejemplo, si el usuario responde "no", a la pregunta sobre gatitos, salta al mensaje etiquetado "no_kittens", que es el final de esa conversación.

Agrega el diálogo al control

Ahora que la conversación está definida, observa 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(() => {
    // ...
  });
}

Cómo activar el diálogo

Ahora que el diálogo está disponible para que lo use el control, 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! Acabas 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? ¿Y si prefieres activar una acción con un solo comando sencillo?

Slack ofrece esta funcionalidad mediante 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 Comandos de barra en Funciones en la página de administración de apps.
Haz clic en Crear nuevo comando.
Configura un comando /cats con la URL de 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 indicaciones para actualizar la app y los permisos.

Agrega comandos de barra a tu controlador

Observa cómo se agregó un controlador para 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, solo visibles para ti:

12. Limpieza

Felicitaciones, ahora tienes un bot de Slack ejecutándose 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 el secreto de firma de tu 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].

Cómo borrar el secreto del token de tu 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 sabes cómo ejecutar un bot de Slack en Cloud Run.

Apenas conocimos la superficie de esta tecnología, y te recomendamos que sigas explorando con tus propias implementaciones de Cloud Run.

Temas abordados

Crea una integración personalizada de bot en Slack
Protege tus secretos de Slack con Secret Manager
Implementa el bot de Slack en Cloud Run

Próximos pasos

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