Esta página foi traduzida pela API Cloud Translation.

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 a 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 os secrets do Slack com o Secret Manager
Como implantar um bot do Slack no Cloud Run, uma plataforma de computação totalmente gerenciada que faz o escalonamento automático dos 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 um laptop, neste tutorial você 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 você estiver iniciando o Cloud Shell pela primeira vez, verá uma tela intermediária com a descrição dele. Se aparecer uma tela intermediária, clique em Continuar.

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

Essa máquina virtual tem 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. Grande parte do trabalho neste codelab, se não todo, pode ser feito em um navegador.

Depois de se conectar ao Cloud Shell, você verá sua autenticação e o projeto estará 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 seguinte comando no Cloud Shell para confirmar que 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

Será exibida uma mensagem de sucesso semelhante a esta:

Operation "operations/..." finished successfully.

Agora está tudo pronto para preparar e implantar o aplicativo...

4. Criar um espaço de trabalho no Slack

Você vai precisar de um espaço de trabalho do Slack em que poderá criar integrações personalizadas. É possível criar um espaço de trabalho sem custo financeiro se você ainda não tiver um que queira 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 Create new app no canto superior direito.
Dê um nome ao aplicativo, como "Kittenbot".
Escolha a equipe do Slack onde você quer que ele seja instalado.

Criar um usuário bot

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

Clique em Revisar escopos para adicionar para atribuir um escopo ao token do bot.
Role para baixo até Bot Token Scopes e clique em Add an OAuth Scope. Selecione chat:write para "Enviar mensagens como Kittenbot"

Role para cima e clique no botão Install App to your Workspace.
Isso instalará o aplicativo para sua equipe, adicionará o usuário bot que você acabou de criar e gerará um token do bot.
Quando for solicitado, clique em Permitir. para autorizar o bot a conversar no seu espaço de trabalho.

Ativar mensagens e comandos

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

Gerar a chave secreta de assinatura do cliente

Acesse Informações básicas em Configurações.
Role para baixo até Assinatura de senha, clique em Mostrar e copie a chave 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 & 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 para esta página de configuração na página de gerenciamento de aplicativos se precisar obter esses tokens novamente.

6. Proteja seus segredos

Queremos garantir que o token do bot e a chave secreta de assinatura do cliente sejam armazenados com segurança. Codificá-los no código-fonte aumenta a probabilidade de expor esses secrets acidentalmente, publicando-os no controle de versões ou incorporando-os 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 central e uma fonte confiável para gerenciar, acessar e fazer auditoria de secrets no Google Cloud.

Crie 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 os Secrets

Vamos confirmar se os secrets foram criados corretamente e se suas 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 consultar e gerenciar seus secrets no console do Google Cloud.

7. Fazer o download do 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

Como entender o código

Abra o arquivo kittenbot.js com o editor de linha de comando de sua preferência (nano, vim, emacs...) ou com o comando a seguir para abrir diretamente a pasta atual no editor do Cloud Shell:

cloudshell workspace .

O código do kittenbot tem duas funções principais. Uma delas é recuperar os secrets, e a outra é 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 facilmente mensagens de e para a API Slack. O cliente do Secret Manager permitirá que você acesse 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, em seguida, especifica um endpoint para receber mensagens. Em seguida, quando o controlador estiver ativado, o bot responderá a qualquer mensagem que contenha "hello", "hi" ou "ei" com "Miau. ➘".

Confira estas partes específicas no manifesto do app:

package.json

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

Implante um app Node.js diretamente da origem com o Cloud Run. Em segundo plano, acontecerá o seguinte:

O Cloud Run chama o Cloud Build para criar uma imagem de contêiner. Consulte Como implantar a partir do código-fonte.
Se um Dockerfile estiver presente no diretório do código-fonte, o Cloud Build o usará para criar uma imagem de contêiner.
Como não é, o Cloud Build chama 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 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, correções de segurança conhecidas são aplicadas automaticamente.

Você já pode implantar o app.

8. Implantar o aplicativo

A API Slack Events usa webhooks para enviar mensagens sobre eventos. Ao configurar o aplicativo Slack, é preciso fornecer um URL acessível publicamente para a API Slack dar um ping.

O Cloud Run é uma boa solução para hospedar destinos de webhook. Ele permite que você use qualquer linguagem ou ambiente de execução que quiser e oferece simultaneidade, o que significa que seu aplicativo será capaz de lidar com volumes muito maiores.

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, ou seja, a infraestrutura que executa o 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ê usará para sua implantação, por exemplo:

REGION="us-central1"

Atualizar as permissões

Para acessar os 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")

Verifique se o endereço de e-mail foi salvo:

echo $SERVICE_ACCOUNT

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

Depois que você tiver o endereço de e-mail, ative o papel para a conta de serviço:

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

Implantar o app

Um serviço do Cloud Run expõe um endpoint exclusivo e escalona automaticamente a infraestrutura subjacente para lidar com 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.
Também é possível definir uma região padrão com este comando: gcloud config set run/region $REGION
Também é possível tornar o Cloud Run 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 de serviço.
A opção --allow-unauthenticated torna o serviço disponível publicamente.

Na primeira vez, você vai receber um comando 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 seu código-fonte para o repositório do Artifact Registry e o build da imagem de 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 o build e a implantação sejam concluídos. 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

Para conseguir o URL do serviço, use 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 Slack Events. Copie-o para a área de transferência para usar na próxima etapa.

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

É possível ver quando a última revisão foi criada, quanto tráfego está recebendo e analisar os registros. Se clicarmos nos registros, poderemos 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 anteriormente, o código 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 de base do serviço do Cloud Run, mais /api/messages.

Ativar eventos

Na página de gerenciamento de aplicativos, vá para a seção Assinaturas de eventos na barra lateral e ative a opção Ativar eventos. Insira o URL do seu serviço:

PASTE_THE_SERVICE_URL/api/messages

Dependendo da velocidade com que você digita o URL, ele pode tentar verificá-lo antes de terminar. Em caso de falha, clique em "Tentar novamente".

Inscreva-se em todos os eventos de bots de mensagens.

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

Neste ponto, seu bot está totalmente integrado. As mensagens no espaço de trabalho acionarão o Slack para enviar mensagens ao seu serviço do Cloud Run, que, por sua vez, responderá com uma simples saudação.

10. Testar seu bot

Enviar uma mensagem direta para Kittenbot:

Adicione o kittenbot ao seu canal digitando "@kittenbot" e, em seguida, clicando em "Convidar".

Agora todos no canal podem interagir com o Kittenbot!

Cada mensagem no Slack aciona um evento e envia uma mensagem HTTP POST para o serviço do Cloud Run. Se você analisar os registros do 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

Esta seção opcional deve levar alguns minutos. Pule diretamente para "Limpar".

Conversas

Queremos que o bot faça mais do que apenas dizer "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 .

Com o Botkit, você pode lidar com 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, confira como as funções de conversação 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" para a pergunta do gatinho, ele pula para a mensagem intitulada "no_gatinhos", que é o final da conversa.

Como adicionar a caixa de diálogo ao controlador

Agora que a conversa foi definida, confira 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 o controlador usar, confira como a conversa é iniciada quando o bot de bate-papo ouve "kitten", "kittens", "cat" ou "cats":

  // ...

  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

Implante o aplicativo novamente 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 para uma nova versão um bot do Slack em execução no Cloud Run.

Comandos de barra

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

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

Ativar comandos Slash do Slack

Vá para a seção Comandos Slash em Recursos na página de gerenciamento do Google Apps.
Clique em Criar novo comando.
Configure um comando /cats com o URL de serviço do kittenbot. Use o mesmo endpoint usado 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 controle

Veja como um gerenciador para comandos de barra foi adicionado dentro da 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 responderá com oito gatos, visíveis apenas para você:

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 o projeto inteiro diretamente no Cloud Shell:

gcloud projects delete $PROJECT_ID

Como alternativa, se preferir excluir os diferentes recursos um a um, prossiga 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 a 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].

Excluir 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 ver o caminho deles:

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.

Nós abordamos apenas uma pequena parte dessa tecnologia e incentivamos você a explorá-la ainda mais com suas próprias implantações do Cloud Run.

O que vimos

Como criar uma integração de bot personalizada no Slack
Como proteger os secrets do Slack com o Secret Manager
Como implantar seu 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.