Crie um bot do Slack com o Node.js no Cloud Run

1. Visão geral

Neste codelab, você vai aprender a criar um bot do Slack usando o Botkit toolkit (links em inglês) e executá-lo no Google Cloud. Você poderá interagir com o bot em um canal do Slack ao vivo.

O que você vai aprender

Como criar uma integração de bot personalizada no Slack
Como proteger seus secrets do Slack com o Secret Manager
Como implantar um bot do Slack no Cloud Run, uma plataforma de computação totalmente gerenciada que escalona automaticamente seus contêineres sem estado

O que é necessário

um projeto do Google Cloud;
Um navegador, como o Chrome ou o Firefox

Como você usará este tutorial?

Apenas leitura

Leitura e exercícios

Como você classificaria sua experiência com o Google Cloud?

Iniciante

Intermediário

Proficiente

2. Configuração e requisitos

Configuração de ambiente autoguiada

Faça login no Console do Google Cloud e crie um novo projeto ou reutilize um existente. Crie uma conta do Gmail ou do Google Workspace, se ainda não tiver uma.

O Nome do projeto é o nome de exibição para os participantes do projeto. É uma string de caracteres não usada pelas APIs do Google e pode ser atualizada quando você quiser.
O ID do projeto precisa ser exclusivo em todos os projetos do Google Cloud e não pode ser mudado após a definição. O console do Cloud gera automaticamente uma string exclusiva. Em geral, não importa o que seja. Na maioria dos codelabs, é necessário fazer referência ao ID do projeto, normalmente identificado como PROJECT_ID. Se você não gostar do ID gerado, crie outro aleatório. Se preferir, teste o seu e confira se ele está disponível. Ele não pode ser mudado após essa etapa e permanece durante o projeto.
Para sua informação, há um terceiro valor, um Número do projeto, que algumas APIs usam. Saiba mais sobre esses três valores na documentação.

Em seguida, ative o faturamento no console do Cloud para usar os recursos/APIs do Cloud. A execução deste codelab não vai ser muito cara, se tiver algum custo. Para encerrar os recursos e evitar cobranças além deste tutorial, exclua os recursos criados ou exclua o projeto. Novos usuários do Google Cloud estão qualificados para o programa de US$ 300 de avaliação sem custos.

Inicie o Cloud Shell

Embora o Google Cloud possa ser operado remotamente em seu laptop, neste tutorial você vai usar o Cloud Shell, um ambiente de linha de comando executado no Cloud.

Ativar o Cloud Shell

No Console do Cloud, clique em Ativar o Cloud Shell.

Se esta for a primeira vez que você inicia o Cloud Shell, uma tela intermediária vai aparecer com a descrição dele. Se isso acontecer, clique em Continuar.

Leva apenas alguns instantes para provisionar e se conectar ao Cloud Shell.

Essa máquina virtual contém todas as ferramentas de desenvolvimento necessárias. Ela oferece um diretório principal persistente de 5 GB, além de ser executada no Google Cloud. Isso aprimora o desempenho e a autenticação da rede. Neste codelab, quase todo o trabalho pode ser feito com um navegador.

Depois de se conectar ao Cloud Shell, você vai ver que sua conta já está autenticada e que o projeto está configurado com o ID do seu projeto.

Execute o seguinte comando no Cloud Shell para confirmar se a conta está autenticada:

gcloud auth list

Resposta ao comando

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

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

Execute o comando a seguir no Cloud Shell para confirmar se o comando gcloud sabe sobre seu projeto:

gcloud config list project

Resposta ao comando

[core]
project = <PROJECT_ID>

Se o projeto não estiver configurado, configure-o usando este comando:

gcloud config set project <PROJECT_ID>

Resposta ao comando

Updated property [core/project].

3. Ative as APIs

No Cloud Shell, ative as APIs Artifact Registry, Cloud Build, Cloud Run e Secret Manager:

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

Isso gera uma mensagem de sucesso semelhante a esta:

Operation "operations/..." finished successfully.

Agora você está pronto para preparar e implantar seu aplicativo.

4. Criar um espaço de trabalho do Slack

Você vai precisar de um espaço de trabalho do Slack em que seja possível criar integrações personalizadas. Você pode criar um espaço de trabalho sem custo financeiro se ainda não tiver um para usar neste tutorial.

5. Crie um usuário bot no Slack

Um usuário bot pode ouvir mensagens no Slack, postar mensagens e fazer o upload de arquivos. Neste codelab, você vai criar um bot para postar uma mensagem de saudação simples.

Criar um novo aplicativo do Slack

Acesse a página de gerenciamento de aplicativos do Slack.
Clique no botão Criar novo app no canto superior direito.
Dê um nome ao app, como "Kittenbot".
Escolha a equipe do Slack onde você quer que ele seja instalado.

Criar um usuário bot

Acesse Página inicial do app no painel à esquerda, em Recursos.

Clique em Analisar escopos a serem adicionados para atribuir um escopo ao token do bot.
Role a tela para baixo até Escopos do token de bot e clique em Adicionar um escopo do OAuth. Selecione chat:write para "Enviar mensagens como Kittenbot".

Role para cima e clique no botão Instalar app no espaço de trabalho.
Isso vai instalar o app na sua equipe, adicionar o usuário de bot que você acabou de criar e gerar um token de bot.
Quando solicitado, clique em Permitir para autorizar o bot a conversar no seu espaço de trabalho.

Ativar mensagens e comandos

Role a tela para baixo até Mostrar guias e verifique se as duas opções estão ativadas:

Receber a chave secreta de assinatura do cliente

Acesse Informações básicas em Configurações.
Role a tela para baixo até Segredo de assinatura, clique em Mostrar e copie o segredo para a área de transferência:

Salve o secret em uma variável de ambiente:

CLIENT_SIGNING_SECRET=PASTE_THE_SIGNING_SECRET

Receber o token do bot

Acesse OAuth e permissões em Recursos.
Clique no botão Copy para copiar o texto Bot User OAuth Access Token na área de transferência.

Salve o token do bot em uma variável de ambiente:

BOT_TOKEN=PASTE_THE_BOT_TOKEN

Não se preocupe. Você pode voltar a esta página de configuração na página de gerenciamento de apps se precisar receber esses tokens novamente.

6. Proteja seus secrets

Queremos garantir que seu token de bot e sua chave secreta de assinatura do cliente sejam armazenados com segurança. Incluir a codificação deles no código-fonte aumenta a probabilidade de expor esses secrets acidentalmente ao publicá-los no controle de versões ou ao incorporá-los em uma imagem do Docker.

O Secret Manager oferece um método seguro e conveniente para armazenar chaves de API, senhas, certificados e outros dados sensíveis. Ele oferece um local centralizado e uma fonte confiável para gerenciar, acessar e fazer auditoria de secrets no Google Cloud.

Criar seus secrets

Salve a chave secreta de assinatura do cliente e o token do bot com os seguintes comandos:

Chave secreta de assinatura do cliente

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

Token do bot

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

Acessar seus secrets

Vamos confirmar se os secrets foram criados corretamente e se as permissões estão funcionando. Acesse seus secrets com os seguintes comandos:

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

Também é possível ver e gerenciar seus segredos no console do Google Cloud.

7. Acessar o exemplo de código

No Cloud Shell, na linha de comando, execute o seguinte comando para clonar o repositório do GitHub:

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

Mude o diretório para cloud-slack-bot/start.

cd cloud-slack-bot/start

Entender o código

Abra o arquivo kittenbot.js com o editor de linha de comando que preferir (nano, vim, emacs...) ou com o seguinte comando para abrir diretamente a pasta atual no editor do Cloud Shell:

cloudshell workspace .

O código do kittenbot tem duas funções principais. Uma é para recuperar os secrets, e a outra é para executar o bot.

Primeiro, importamos as dependências:

kittenbot.js

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

O SlackAdapter e o SlackEventMiddleware são pacotes que estendem o Botkit e permitem que o bot traduza mensagens com facilidade para e da API do Slack. O cliente do Secret Manager permite acessar os secrets salvos em uma etapa anterior.

Em seguida, temos nossa função para recuperar os secrets:

/**
 * Returns the secret string from Google Cloud Secret Manager
 * @param {string} name The name of the secret.
 * @return {Promise<string>} The string value of the secret.
 */
async function accessSecretVersion(name) {
  const client = new SecretManagerServiceClient();
  const projectId = process.env.PROJECT_ID;
  const [version] = await client.accessSecretVersion({
    name: `projects/${projectId}/secrets/${name}/versions/1`,
  });

  // Extract the payload as a string.
  const payload = version.payload.data.toString('utf8');

  return payload;
}

Essa função retorna os valores de string dos secrets necessários para autenticar o bot.

A próxima função inicializa o 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:');
      }
    );
  });
}

A primeira parte da função configura o SlackAdapter com os secrets e especifica um endpoint para receber mensagens. Depois, quando o controlador estiver ligado, o bot vai responder a qualquer mensagem que contenha "olá", "oi" ou "ei" com "Miau. 😺".

Confira estas partes específicas no manifesto do app:

package.json

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

É possível implantar um app Node.js diretamente da origem com o Cloud Run. O seguinte vai acontecer em segundo plano:

O Cloud Run chama o Cloud Build para criar uma imagem de contêiner (consulte Implantação do código-fonte).
Se um Dockerfile estiver presente no diretório de código-fonte, o Cloud Build o usará para criar uma imagem de contêiner.
Como não é, o Cloud Build chama os Buildpacks para analisar a origem e gerar automaticamente uma imagem pronta para produção.
Os buildpacks detectam o manifesto package.json e criam uma imagem do Node.js.
O campo scripts.start determina como o app é iniciado.
O campo engines.node determina a versão do Node.js da imagem base do contêiner.
No momento da implantação, as correções de segurança conhecidas são aplicadas automaticamente.

Tudo pronto para implantar o app.

8. Implantar o aplicativo

A API Slack Events usa webhooks para enviar mensagens sobre eventos. Ao configurar o app Slack, você precisa fornecer um URL acessível publicamente para a API Slack fazer ping.

O Cloud Run é uma boa solução para hospedar destinos de webhook. Ele permite usar qualquer linguagem ou ambiente de execução que você quiser e oferece simultaneidade, o que significa que seu aplicativo poderá lidar com um volume muito maior.

Recuperar o ID do projeto

Defina a variável de ambiente PROJECT_ID:

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

Definir a região do Cloud Run

O Cloud Run é regional, o que significa que a infraestrutura que executa seu serviço do Cloud Run está localizada em uma região específica e é gerenciada pelo Google para estar disponível de maneira redundante em todas as zonas dessa região. Defina a região que você vai usar para a implantação, por exemplo:

REGION="us-central1"

Atualizar as permissões

Para acessar secrets do Secret Manager, a conta de serviço do Cloud Run precisa receber o papel roles/secretmanager.secretAccessor.

Primeiro, salve a conta de serviço padrão em uma variável de ambiente:

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

Confirme se você salvou o endereço de e-mail:

echo $SERVICE_ACCOUNT

A conta de serviço tem o seguinte formato: PROJECT_NUMBER-compute@developer.gserviceaccount.com.

Depois de ter o endereço de e-mail, ative a função para a conta de serviço:

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

Implante o app

Um serviço do Cloud Run expõe um endpoint exclusivo e escalona automaticamente a infraestrutura subjacente para processar as solicitações recebidas.

Implante o app no Cloud Run:

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

Isso cria um serviço chamado kittenbot.
A opção --source usa a pasta atual para criar o aplicativo com o Cloud Build. O Cloud Build detecta automaticamente a presença do arquivo package.json.
Como alternativa, defina uma região padrão com este comando: gcloud config set run/region $REGION
Também é possível definir o Cloud Run como gerenciado por padrão com este comando: gcloud config set run/platform managed
A opção --set-env-vars define as variáveis de ambiente do serviço.
A opção --allow-unauthenticated torna o serviço disponível publicamente.

Na primeira vez, você vai receber uma solicitação para criar um repositório do Artifact Registry. Toque em "Enter" 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)?

Isso inicia o upload do código-fonte para o repositório do Artifact Registry e a criação da imagem do contêiner:

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

Aguarde um momento até que a criação e a implantação sejam concluídas. Em caso de sucesso, a linha de comando vai exibir o URL de serviço:

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

É possível receber o URL do serviço com este comando:

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

O URL tem o seguinte formato:

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

Esse URL será a base usada para ativar a API Events do Slack. Copie para a área de transferência para usar na próxima etapa.

Seu serviço está ativo e disponível publicamente. Acesse o console do Cloud Run para mais informações.

Você pode ver quando a última revisão foi criada, quanto tráfego ela está recebendo e consultar os registros. Se clicarmos nos registros, vamos ver que o controlador do Botkit está ativado e pronto para receber mensagens.

Agora vamos começar a enviar mensagens do nosso canal do Slack.

9. Ativar eventos do Slack

Como vimos antes, o código do kittenbot especifica um endpoint relativo para o destino do webhook.

kittenbot.js

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

Isso significa que o URL completo será a parte base do serviço do Cloud Run mais /api/messages.

Ativar eventos

Na página de gerenciamento de apps, acesse a seção Inscrições em eventos na barra lateral e ative a opção Ativar eventos. Insira o URL do serviço:

PASTE_THE_SERVICE_URL/api/messages

Dependendo da velocidade com que você digita o URL, ele pode tentar fazer a verificação antes de você terminar. Se isso não funcionar, clique em "Tentar novamente".

Inscreva-se em todos os eventos do bot de mensagens.

Clique em Salvar alterações na parte de baixo da página. Você vai receber uma solicitação para Reinstalar o app. Siga as instruções e clique em Permitir.

Nesse momento, seu bot está totalmente integrado. As mensagens no espaço de trabalho vão acionar o Slack para enviar mensagens ao serviço do Cloud Run, que vai responder com uma saudação simples.

10. Testar seu bot

Envie uma mensagem direta para o Kittenbot:

Adicione o kittenbot ao seu canal digitando "@kittenbot" e clicando em "Convidar":

Agora todos no seu canal podem interagir com o Kittenbot!

Cada mensagem no Slack aciona um evento e envia uma mensagem HTTP POST para nosso serviço do Cloud Run. Se você consultar os registros de serviço do Cloud Run, vai notar que cada mensagem corresponde a uma entrada POST no registro.

O kittenbot responde a cada mensagem com "Miau. 😺".

11. Bônus: atualize seu bot

Essa seção opcional leva alguns minutos. Se quiser, pule direto para "Limpeza".

Conversas

Queremos que o bot faça mais do que dizer apenas "miau". Mas como implantar uma nova versão de algo em execução no Cloud Run?

Altere o diretório para cloud-slack-bot/extra-credit:

cd ../extra-credit/

Abra a pasta atual no editor do Cloud Shell:

cloudshell workspace .

O Botkit oferece a capacidade de gerenciar conversas. Com elas, o bot pode solicitar mais informações e reagir a mensagens além de uma resposta de uma só palavra.

Definir a caixa de diálogo

Primeiro, veja como as funções de conversa são definidas no final do arquivo:

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

Essa nova conversa direciona a conversa com base nas respostas. Por exemplo, se o usuário responder "não" à pergunta sobre o gatinho, a conversa vai para a mensagem marcada como "no_kittens", que é o fim dessa conversa.

Como adicionar a caixa de diálogo ao controlador

Agora que a conversa está definida, veja como adicioná-la ao 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(() => {
    // ...
  });
}

Acionar a caixa de diálogo

Agora que a caixa de diálogo está disponível para uso pelo controlador, veja como a conversa começa quando o chatbot ouve "gatinho", "gatinhos", "gato" ou "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

    // ...
  });

  // ...

Atualizar o app

Reimplante o aplicativo no Cloud Run:

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

Fazer um teste

Parabéns! Você acabou de atualizar um bot do Slack em execução no Cloud Run para uma nova versão.

Comandos de barra

E se você não quiser conversar com o usuário? E se você preferir apenas acionar uma ação com um comando simples?

O Slack oferece essa funcionalidade com os comandos de barra, que permitem aos usuários invocar seu aplicativo inserindo o comando na caixa de mensagem.

Ativar os comandos de barra do Slack

Acesse a seção Comandos de barra em Recursos na página de gerenciamento de apps.
Clique em Criar novo comando.
Configure um comando /cats com o URL do serviço kittenbot. Use o mesmo endpoint que você usou para ativar a API Events. Este é seu URL, mais '/api/messages'.

Siga as instruções para atualizar o app e as permissões.

Adicionar comandos de barra ao seu controlador

Veja como um gerenciador de comandos de barra foi adicionado à função 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
  });

  // ...

Fazer um teste

Digite /cats mais um número para enviar o comando de barra. Por exemplo: /cats 8

O bot vai responder com oito gatos, que só você pode ver:

12. Limpeza

Parabéns, agora você tem um bot do Slack em execução no Cloud Run. É hora de limpar alguns dos recursos utilizados para economizar custos e ser um bom cidadão da nuvem.

Excluir o projeto

É possível excluir todo o projeto diretamente no Cloud Shell:

gcloud projects delete $PROJECT_ID

Como alternativa, se você preferir excluir os diferentes recursos um por um, siga para a próxima seção.

Excluir a implantação

gcloud run services delete kittenbot --region $REGION

Resposta ao comando

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

Excluir sua chave secreta de assinatura do cliente

gcloud secrets delete client-signing-secret

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

Exclua o secret do token do bot

gcloud secrets delete bot-token

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

Excluir os buckets de armazenamento

Primeiro, liste os buckets do Google Cloud Storage para receber o caminho do bucket:

gsutil ls

Resposta ao comando

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

Agora, exclua o bucket de artefatos:

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

Resposta ao comando

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

Por fim, exclua o bucket do cloudbuild:

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

Resposta ao comando

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

13. Parabéns!

Agora você sabe como executar um bot do Slack no Cloud Run!

Como abordamos muito pouco dessa tecnologia aqui, incentivamos você a conhecê-la melhor com suas próprias implantações do Cloud Run.

O que vimos

criar uma integração de bot personalizada no Slack;
Como proteger seus secrets do Slack com o Secret Manager
Como implantar o bot do Slack no Cloud Run

Próximas etapas

Conclua mais tutoriais do Cloud Run

Saiba mais

Confira outros exemplos de integração do Slack com o Google Cloud no GitHub.
Teste outros recursos do Google Cloud. Confira nossos tutoriais.