Criar perfeitamente um Bot no Slack para Invocar Ações do GitHub via Hubot

Tutoriais

Se você usa o GitHub Actions como seu pipeline de build e release e sua equipe também usa o Slack, você sabia que nem precisa sair do Slack? Crie um bot no Slack para invocar fluxos de trabalho do GitHub Actions diretamente do Slack automaticamente!

Neste tutorial, você aprenderá como configurar um novo chatbot do Slack usando a ferramenta de construção de bots chamada Hubot e iniciar automaticamente um fluxo de trabalho do GitHub Actions para implantar código em um servidor.

Vamos começar!

Pré-requisitos

Este tutorial será uma demonstração prática. Se você quiser acompanhar, certifique-se de ter o seguinte:

  • A Slack Workspace
  • A GitHub account and a GitHub personal token
  • A Linux server to deploy code to – This tutorial will use Ubuntu 19.
  • A local Linux machine – This tutorial will use Ubuntu so that all local commands will be Linux. If you’re running another operating system, the commands may be slightly different.
  • Credenciais SSH para se conectar ao servidor para o qual você irá implantar o código.
  • A code editor of your choice that understands YAML like Visual Studio Code.

Relacionado:Automatizando Ações do Git do Lado do Cliente com Git Hooks

Criando um Projeto e um Fluxo de Trabalho do GitHub Actions

Antes de poder invocar rapidamente fluxos de trabalho do GitHub Actions do Slack, você primeiro precisa criar o fluxo de trabalho.

Para criar o fluxo de trabalho, vamos criar uma pasta de projeto para conter todos os arquivos com os quais você estará trabalhando.

Relacionado:Como Configurar o Visual Studio Code para o GitHub!

1. Abra o seu aplicativo de terminal favorito.

2. Agora execute a série de comandos abaixo para criar a pasta do projeto chamada Hubot e navegar até ela. 

mkdir ~/Hubot # Cria um diretório chamado Hubot
cd ~/Hubot    # Mude para o diretório Hubot

3. Em seguida, execute npm init para criar um arquivo package.json do Node.JS. Executando npm init cria um projeto padrão do Node.JS que inclui o arquivo package.json que contém várias informações sobre o projeto e quaisquer pacotes NPM dependentes. 

npm init      # Inicializa o arquivo package.json

4. Agora, crie um diretório workflows e o arquivo de fluxo de trabalho deploy.yml. O arquivo de fluxo de trabalho é uma série de etapas definidas em uma sequência que as Ações do GitHub seguirão.

mkdir .github/workflows && touch deploy.yml

5. Em seguida, defina cada um dos segredos do GitHub que seu fluxo de trabalho irá ler. O fluxo de trabalho que você está prestes a criar fará referência a esses segredos. Como você precisará do endereço do seu servidor, nome de usuário, senha e porta do seu servidor para SSH, vamos criar segredos do GitHub.

Visite esta URL https://github.com/seunomeusuário/seurepositório/configurações/secrets/actions onde você adicionará seus segredos do GitHub. Substitua seunomeusuário pelo seu nome de usuário do GitHub e seurepositório pelo seu repositório do GitHub.

Clique no botão Novo segredo do repositório, como mostrado abaixo, para preencher informações sobre o segredo que você está adicionando.

Adding GitHub Secrets

6. Agora preencha o Nome e o Valor do segredo e clique em Adicionar segredo para salvá-lo. A página será redirecionada para a página de segredos do GitHub, onde você verá todos os seus segredos. Para adicionar mais segredos, clique no botão Novo segredo do repositório como fez anteriormente.

Certifique-se de salvar os segredos para as variáveis fornecidas com o mesmo nome exato, pois você fará referência às mesmas variáveis, que são HOST, USERNAME, PASSWORD e PORTA.

Filling up Information for a GitHub Secret
Viewing All GitHub Secrets

7. Por fim, abra o arquivo de fluxo de trabalho ~/Hubot/.github/workflows/deploy.yml no seu editor de código e copie/cole o código a seguir. O código abaixo é o fluxo de trabalho que será executado sempre que você acionar o fluxo de trabalho via Slack posteriormente.

Ao invocar o fluxo de trabalho, ocorrerão algumas ações:

  • GitHub Actions irá analisar o arquivo de fluxo de trabalho abaixo para fazer SSH no host alvo definido no segredo HOST com o USERNAME e PASSWORD definidos como segredos.
  • O fluxo de trabalho então irá baixar o conteúdo do repositório do GitHub para um ramo específico ($branchName) executando git pull origin$branchName. Certifique-se de que o nome do ramo contenha o código que deseja implantar.
  • Você estará utilizando um Pacote de Fluxo de Trabalho do GitHub Marketplace chamado ssh-remote-commands. Este pacote possui um bom envoltório para contornar onde você só precisa fornecer host, nome de usuário, senha, porta e comando para executar na produção.

Verifique se o seu servidor tem git instalado com as credenciais de login necessárias para puxar o código do repositório do GitHub

# Nome que será referenciado muito mais com ele programaticamente 
name: deploy 
on:
  # O evento respository_dispatch significa em cada gatilho da API, 
  # este arquivo inteiro é executado 
  repository_dispatch: 
    types: [deploy-service]
# Pode haver vários jobs, mas atualmente, 
# este tutorial só funcionará em um 
jobs:
  deploy:
    name: Deploy
    # O nome da imagem base onde todos os códigos em YAML são executados 
    runs-on: ubuntu-latest
    steps:
    - name: executing remote ssh commands using password
      # appleboy/ssh-action@master é um pacote de código aberto 
      # que faz login em um servidor via ssh e executa o script 
      uses: appleboy/ssh-action@master
      # Estas são geralmente as variáveis que o pacote precisa 
      # para fazer login no servidor e executar o script 
      with:
       # Os segredos são as variáveis de 
       # https://docs.github.com/en/actions/security-guides/encrypted-secrets 

       # Seu host do servidor armazenado em segredos do github com o mesmo nome HOST 
        host: ${{ secrets.HOST }} 
        # Nome de usuário do seu servidor para fazer login 
        # que é armazenado em segredos do github com o nome de USUÁRIO 
        username: ${{ secrets.USERNAME }} 
        # Senha do seu servidor para fazer login 
        # que é armazenado em segredos do github com o nome de SENHA 
        password: ${{ secrets.PASSWORD }} 
        # Porta do seu servidor para fazer login 
        # que é armazenada em segredos do github com o nome de PORTA 
        port: ${{ secrets.PORT }}  
        # deploy-app.sh pode ser qualquer coisa, como você pode puxar código do GitHub 
        # e reiniciar seu servidor web ou filas, qualquer coisa 
        # Certifique-se de ter clonado o repositório no seu servidor 
        # Você pode executar quantos scripts quiser 
        script: git pull origin {{ github.event.client_payload.branch

Executando o Fluxo de Trabalho Manualmente

Agora você criou o fluxo de trabalho do GitHub Actions para ser invocado via Slack. Mas, neste ponto, seu código está apenas em sua máquina local. Para acionar o fluxo de trabalho, você precisará fazer o push do código para o GitHub.

Executando a série de comandos abaixo, o git saberá de onde deve puxar e para onde deve enviar o código, neste exemplo, do seu repositório remoto do GitHub. No comando git remote add origin abaixo, substitua seunomedeusuário e seurepositório pelo seu nome de usuário e repositório do GitHub

# Abra github.com e crie um repositório
git init # Inicializa o git
git remote add origin https://github.com/yourusername/yourrepository.git
git add . # adiciona arquivos recém-criados para o git rastrear
git commit -m "Created GitHub workflow file"
git push -u origin master

Vamos primeiro testar se o seu código funciona. Invoque seu código manualmente usando o utilitário curl popular.

Execute o comando abaixo para fazer uma solicitação POST para o URL do seu Repositório GitHub https://github.com/username/repository/dispatches para informar ao GitHub para acionar um arquivo de Fluxo de Trabalho deploy.yml que você criou anteriormente. Substitua username pelo seu nome de usuário real do GitHub e repositório pelo seu repositório GitHub.

Substitua $github_personal_token no código abaixo pelo seu token pessoal.

# Faz uma solicitação de postagem no URL https://github.com/username/repository/dispatches 
curl-X POST  https://github.com/username/repository/dispatches \
# Adiciona cabeçalho para aceitar tipo de conteúdo
-H 'Accept: application/vnd.github.everest-preview+json' \
# Adiciona cabeçalho para autorização
-H "Authorization: token $github_personal_token" \
# Adiciona conteúdo JSON no corpo da solicitação de postagem para que você possa enviar vários parâmetros 
# a partir desta seção de dados e você pode realizar várias ações com base nos argumentos
--data '{"event_type": "deploy-service", "client_payload": {"environment": "'"$1"'", "ref": "'"$2"'"}}' # Você pode passar o nome do ambiente & ref como um nome de branch para que você saiba em qual branch implantar em qual servidor

Criar Bot do Slack com o Hubot

Já que você conseguiu acionar o Fluxo de Trabalho da Ação do GitHub manualmente, isso é um bom começo. Agora vamos tentar automatizar as mesmas etapas manuais via Bot do Slack. Você irá criar um Bot do Slack, que escuta seu comando e aciona a Ação do GitHub com argumentos.

Você tem duas opções para criar um Bot do Slack, seja do zero ou com um pacote pré-construído do hubot para espaços de trabalho do Slack. Neste tutorial, você usará um pacote de Bot pré-construído chamado Hubot. Hubot é uma ferramenta de automação de código aberto que integra com serviços de chat como Slack, Discord, Gitter, TeamSpeak, etc.

Criar um bot personalizado sem usar um aplicativo como o Hubot leva muito tempo. Por quê? Porque você lidará com todos os processos de configuração, ouvindo webhooks e hospedando o bot. Então, neste tutorial, você usará o aplicativo Hubot Slack para simplificar todos esses processos.

Instalando o Hubot com o Npm

Como você está usando o Hubot para criar um Bot do Slack, primeiro baixe e instale o Hubot em sua máquina local. Hubot será o conector que vincula o Slack e as ações do GitHub.

1. No seu terminal, navegue (cd) até o diretório do seu projeto (~/Hubot). 

cd ~/Hubot

2. Instale o pacote yo e generator-hubot globalmente (-g) em sua máquina local com o comando npm install abaixo. O pacote yo ajuda a instalar novos projetos gerando projetos em qualquer linguagem (Web, Java, Python, C#, etc.). O pacote generator-hubot usa o pacote yo para instalar todas as dependências junto com as configurações iniciais.

Depois de instalado, você pode executar o comando yo de qualquer lugar, pois foi instalado globalmente.

npm install -g yo generator-hubot

3. Agora, crie um boilerplate básico do Hubot com o seguinte comando. Um boilerplate é uma seção de código incluída em muitos lugares. Sem um boilerplate, você sempre precisa escrever código do zero.

O comando abaixo cria um boilerplate básico do Hubot no diretório do seu projeto. O boilerplate do Hubot vincula-se ao Slack (--adapter=slack) para que o Bot possa ouvir e responder às mensagens dentro do canal do Slack. yo hubot --adapter=slack

yo hubot --adapter=slack

Adicionando o Hubot ao seu Espaço de Trabalho no Slack

Agora que o Hubot está instalado em sua máquina local, você precisa configurar o Hubot para se comunicar com o Slack.

Vamos instalar o Hubot no seu Espaço de Trabalho no Slack.

1. Abra seu navegador da web e acesse as configurações de administrador do Slack com a URL, como https://workspacename.slack.com/admin/settings. Substitua workspacename pelo nome real do seu Espaço de Trabalho no Slack.

Clique no Configurar aplicativos à esquerda, como mostrado abaixo, para que você possa procurar o Hubot no marketplace. O Slack possui um marketplace onde você pode encontrar aplicativos pré-construídos.

Accessing Slack Admin Settings

2. Clique na barra de pesquisa e digite hubot para procurar o Hubot no marketplace e selecione Hubot.

Agora, clique no botão Adicionar ao Slack, conforme você vê abaixo, para adicionar o Hubot ao seu Espaço de Trabalho no Slack.

Searching Hubot and Adding it to Slack Workspace

3. Por fim, preencha algumas informações gerais sobre o seu Bot, como o nome (deployerhubot) e o ícone. Preste atenção no Token da API pois você o usará posteriormente no Hubot Deployer para ativar o Bot no seu projeto do Hubot que você criou anteriormente.

Setting up Bot Information and Taking Note of the API Token

Testando a Integração do Fluxo de Trabalho do GitHub Actions com o Slack

Agora você tem o Hubot instalado no seu Espaço de Trabalho do Slack, então vamos testar o bot ouvindo e enviando mensagens para o canal. Mas primeiro, você precisa ativar o Bot.

1. Execute o comando abaixo dentro do diretório raiz do projeto para ativar o Bot para o Slack (--adapter slack) do seu repositório do Hubot (./bin/hubot). Certifique-se de substituir o $token pelo token da API que você anotou anteriormente

HUBOT_SLACK_TOKEN=$token ./bin/hubot --adapter slack

2. Execute o comando abaixo para convidar (/invite) o Bot (nome do bot) para o seu canal do Slack. Substitua nome do bot pelo nome do Bot que você registrou no terceiro passo da seção “Adicionando o Hubot ao seu Espaço de Trabalho do Slack”. 

/invite deployerhubot

Agora, mencione um Bot com um texto no Slack, como @deployerhubot ping, para testar se a integração está funcionando. Se o Bot responder PONG, como mostrado abaixo, então está tudo certo.

Testing Hubot and Slack Integration

Se o Bot não responder, navegue até o seu repositório do GitHub no seu navegador da web e clique na aba Actions. Você pode identificar qual fluxo de trabalho falhou, pois terá um distintivo de verificação redondo vermelho nele. Clique no fluxo de trabalho falhado para ver o que causou o erro e corrigi-lo.

Viewing Failed Workflows

Abaixo, você pode ver que a falha está em executar comandos remotos ssh usando senha. Após corrigir o fluxo de trabalho, volte para o passo 3 e veja se o Bot responde PONG.

Navigating to GitHub repository to fix failed workflow

Iniciando um Fluxo de Trabalho do GitHub Actions a partir do Slack

Agora que você ativou o seu Slack Bot, é hora de iniciar um fluxo de trabalho do GitHub Actions a partir do Slack!

Você precisa da flexibilidade para implantar o ramo fornecido em um servidor fornecido, como puxar os códigos do ramo fornecido. Você ensinará o Bot a responder automaticamente quando alguém digita ***@*bot deploy API feature-x to production em um canal do Slack. Você pode validar o nome do ambiente onde as pessoas só podem implantar certos ambientes e ramos mais tarde.

Para automatizar as respostas do Bot:

1. Crie um diretório com o nome ~/Hubot/scripts. O diretório ~/Hubot/scripts é onde você salvará um script que aciona seu fluxo de trabalho do GitHub.

2. Em seu editor de código, crie um arquivo com o nome bot.js dentro do diretório ~/Hubot/scripts. Agora copie o código abaixo e cole-o dentro do arquivo bot.js.

O código abaixo permite que o Bot escute as mensagens do chat no Canal do Slack, em seguida, aciona o fluxo de trabalho para enviar uma resposta ao Canal do Slack.

const validServices = ['api','app'];
const validEnvironments = ['production'];
robot.hear (`@${process.env.BOT_ID}`,async (bot) => {
    // O Bot está apenas interessado em ouvir mensagens 
    // como @deploy api featurex para produção 
    // Configurando variável reutilizável
	  const payload = bot.message.text.split(" ")
    const service = payload[2];
    const branch = payload[3];
    const environment = payload[5];
    const username = bot.message.user.name;
    // Informar o usuário que estamos processando
    bot.send(`Roger that! Please wait.`);
// Validar se o comando utilizado é válido ou não 
// porque o usuário também pode usar comandos inválidos 
if(!validateCommand(bot,username,service,branch,environment)) {
      return;
    }
    // Se o comando parecer válido, então acionar um fluxo de trabalho
    await triggerWorkflow(bot,username,service,environment,branch)
    
    // Informar o usuário que o fluxo de trabalho foi acionado com sucesso
    bot.send(`Github Action has been triggered successfully`);
  })
  const validateCommand = (bot,username,service,branch,environment) => {
    // Limitar os serviços, já que os usuários podem usar serviços que não estão listados 
    // o que tentará acionar o fluxo de trabalho e resultará em erro
    if(!validServices.includes(service)) {
       bot.send(`${service} is not availble, Only ${validServices.join(', ')} are available`);
      return false;
      }
      // Limitar o ambiente, já que os usuários podem usar uma lista inválida de ambientes também
      if(!validEnvironments.includes(environment)) {
        bot.send(`${environment} is not availble. Only ${validEnvironments.join(', ')} are available`);
        return false;
      }
      return true;
  }

  const triggerWorkflow = (bot,username,service,environment,branch) => {
    try {
      // Este é o mesmo código manual de acionamento de fluxo de trabalho convertido 
      // de curl para uma solicitação de postagem javascript real
      const data = await axios.post(`https://api.github.com/repos/yourusername/yourreponame/dispatches`,{
        'event_type': 'deploy-service',
        'client_payload': {'environment': environment, 'ref': branch}
      },{headers:{
      Authorization: `token ${token}`,
      }})
    }
      catch(e) {
        bot.send(`Sorry @${username} could not trigger github action. Please check my logs ${e.message}`);
      }
  }

3. Por fim, envie a mensagem @nome_do_bot deploy api staging para dev no Slack e você verá uma resposta semelhante, como mostrado abaixo.

Os arquivos de fluxo de trabalho podem ser acionados em vários Eventos do GitHub, como enviar código para um determinado branch, criar tags, criar solicitações de pull, solicitar alguns URLs e muito mais.

send the @botusername deploy api staging to dev message in slack

Conclusão

Ao longo deste tutorial, você aprendeu sobre o Fluxo de Trabalho do GitHub, desde acionar manualmente respostas no Slack com códigos até construir um chatbot. Você também aprendeu que ter um chatbot no Slack permite automatizar tarefas invocando o fluxo de trabalho das ações do GitHub.

Você levará esse novo conhecimento a um nível superior, talvez adicionando um Bot de Lembrete ou criando mensagens interativas?

Source:
https://adamtheautomator.com/create-slack-bot/