O Slack é uma poderosa plataforma de mensagens que permite que as equipes colaborem de forma eficiente. E se essa colaboração também envolve cuidar de vários sites WordPress aqui na Kinsta, você pode mover algumas tarefas comuns de gerenciamento de sites para o Slack com a ajuda da API da Kinsta.
Ao integrar um Slackbot ao seu fluxo de trabalho, você pode economizar tempo e aumentar a produtividade. Este tutorial combina o poder do Slack e da API da Kinsta para criar um Slackbot capaz de gerenciar tarefas como verificar o status, limpar o cache e reiniciar o mecanismo PHP de um site.
O que você está criando
Aqui você está criando um Slackbot no Node.js usando a API Bolt (a maneira mais rápida de começar a programar com a plataforma Slack). Seu aplicativo transforma os comandos slash do Slack em chamadas para a API da Kinsta e retransmite as respostas para que toda a interação do usuário ocorra no Slack.
Pré-requisitos
Para acompanhar este projeto, você deve ter o seguinte:
- Conhecimento básico de JavaScript e Node.js
- Node.js versão 12 ou superior
- npm (gerenciador de pacotes do Node) instalado em seu computador
- Espaço de trabalho do Slack
Como criar um aplicativo do Slack
Um Slackbot é essencialmente um aplicativo do Slack. Para criar um novo aplicativo do Slack, siga estas etapas:
- Navegue até o painel de controle da API do Slack.
- Clique no botão Create New App, que abrirá um modal.
- Selecione a opção From Scratch para começar a criar seu aplicativo do zero.
- Forneça um nome para seu aplicativo Slack. Por exemplo, Kinsta Bot.
- Em seguida, escolha o espaço de trabalho onde você deseja instalar o aplicativo e clique no botão Create App.
Não hesite em editar as informações básicas do seu aplicativo navegando até a opção Basic Information na barra lateral. Role para baixo até Display Information para adicionar detalhes como uma imagem, nome, descrição, cor e muito mais.
Configuração do OAuth e das permissões
Você criou um Slackbot com sucesso. No entanto, algumas permissões devem ser concedidas para que você possa acessar dados e executar ações no seu espaço de trabalho do Slack. Para acessar as configurações necessárias:
- Vá ao painel do aplicativo Slack e localize a opção OAuth and Permissions na barra lateral esquerda.
- Quando você estiver lá, role para baixo até a seção Scopes.
- Conceda ao seu bot a capacidade de ler mensagens instantâneas dos usuários e responder a essas mensagens.
Abaixo está uma captura de tela mostrando os escopos que você deve fornecer ao seu bot:
Ao configurar esses escopos, seu bot estará equipado para interagir perfeitamente com os usuários do Slack e realizar suas funções pretendidas de forma eficaz.
Instalando o Slackbot em seu espaço de trabalho
Para concluir o processo, você deve instalar o novo Slackbot no seu espaço de trabalho do Slack. Navegue até a barra lateral esquerda e selecione Install Apps. A partir daí, clique em Install to Workspace e especifique o canal em que você deseja adicionar o bot.
Agora seu Slackbot está pronto. Vamos configurar um servidor Node.js, que será usado para receber e processar suas solicitações.
Configurando o ambiente de desenvolvimento
Para começar com seu novo projeto Node.js, crie um novo diretório para o seu aplicativo e o inicialize com o npm:
mkdir my-express-app
cd my-express-app
npm init -yApós executar o comando acima, um novo arquivo package.json é criado no diretório que você escolheu com valores padrão. O arquivo package.json é essencial, pois contém informações sobre seu projeto e suas dependências. Essas dependências permitirão que você desenvolva sem problemas e aprimore a funcionalidade do seu projeto:
@slack/bolt: Este framework JavaScript permite que você crie rapidamente aplicativos Slack ricos em recursos, aproveitando os recursos mais recentes da plataforma.nodemon: Uma ferramenta valiosa que reinicia automaticamente o aplicativo Node.js sempre que são detectadas alterações de arquivos no diretório, garantindo um fluxo de trabalho de desenvolvimento simplificado.dotenv: Este módulo de dependência zero desempenha um papel crucial no carregamento de variáveis de ambiente do arquivo .env para oprocess.env, facilitando o gerenciamento da configuração.
Para instalar os pacotes necessários, execute os seguintes comandos:
npm i @slack/bolt
npm i --save-dev nodemon dotenvApós instalar com êxito essas dependências e as dependências de desenvolvimento, é hora de adicionar um script de desenvolvimento ao arquivo package.json, utilizando nodemon para executar o arquivo JavaScript. Certifique-se de que seu objeto de script package.json inclua o seguinte:
"scripts": {
"dev": "nodemon app.js"
}Por fim, é importante mencionar que o script dev está apontando para um arquivo app.js inexistente. Crie esse arquivo no diretório do seu projeto, pois é nele que a lógica do seu projeto será tratada.
touch app.jsConfiguração das variáveis de ambiente (tokens e segredos)
Você precisará de tokens e segredos específicos para interagir com o aplicativo Slack a partir do seu projeto Node.js. Essas credenciais são confidenciais e, para garantir sua proteção ao usar o controle de versão, nós as armazenaremos no arquivo .env.
Para obter o segredo de assinatura, acesse o painel do Slack, clique em Basic Information e role para baixo até App Credentials, onde você encontrará o segredo de assinatura. Para obter o token, clique em Install App ou OAuth & Permissions, e lá você encontrará o token OAuth. Normalmente o token começa com “xoxb”.
Crie um arquivo chamado .env no diretório raiz do seu projeto e adicione o Signing Secret e o Bot Token no seguinte formato:
SLACK_SIGNING_SECRET="YOUR SIGNING SECRET"
SLACK_BOT_TOKEN="YOUR BOT TOKEN"Para garantir que essas informações confidenciais não sejam enviadas ao seu provedor Git, crie um arquivo .gitignore no diretório raiz do seu projeto e adicione as seguintes linhas para ignorar o arquivo .env e a pasta node_modules:
/node_modules
.envCom essa configuração concluída, agora você está pronto para prosseguir com a configuração do servidor.
Configuração do servidor Node.js
A configuração do servidor Node.js é uma etapa fundamental na criação do Slackbot. Você precisa importar os pacotes e módulos necessários, inicializá-los e definir a porta na qual o projeto escutará. Abra o arquivo app.js que você criou anteriormente e adicione o seguinte código:
const { App } = require("@slack/bolt");
require("dotenv").config();
// Initializes your app with your bot token and signing secret
const app = new App({
token: process.env.SLACK_BOT_TOKEN,
signingSecret: process.env.SLACK_SIGNING_SECRET,
});
(async () => {
// Start your app
await app.start(process.env.PORT || 3000);
console.log(`⚡️ Kinsta Bot app is running on port ${process.env.PORT || 3000}!`);
})();No código acima, você importa a classe App da biblioteca @slack/bolt, um componente crucial para a criação de aplicativos do Slack. Além disso, você usa o pacote dotenv para processar variáveis de ambiente.
Em seguida, a constante app é criada usando a classe App, que representa seu aplicativo de bot do Slack. Ela requer dois parâmetros importantes: token e signingSecret. Esses valores são obtidos do arquivo .env.
Em seguida, dentro da função async, ocorre a configuração do servidor. O aplicativo é iniciado chamando app.start(). Ele escuta a porta 3000 localmente e registra uma mensagem no console, confirmando que o aplicativo Kinsta Bot está em execução.
Agora, quando você executar o script dev que configurou (npm run dev), receberá a mensagem no terminal: “⚡️ O aplicativo Kinsta Bot está sendo executado na porta 3000!”
Entendendo o Modo Socket da API do Slack
Na integração da API do Slack com os servidores Node.js, há dois métodos principais de conexão: utilizar o ponto de extremidade HTTP público do seu servidor ou empregar o Modo Socket para ativar os WebSockets. Este tutorial se concentra na utilização do Modo Socket, pois ele permite a implantação de recursos interativos, como os comandos slash do Slack, com maior facilidade. Essa abordagem permite que o Slack se conecte ao seu servidor Node.js usando WebSockets em vez do HTTP tradicional.
No entanto, se você optar por usar o ponto de extremidade HTTP localmente, poderá aproveitar o ngrok para criar uma URL pública que faça proxy para o seu host local.
Primeiros passos com o Modo Socket
Para começar a usar o Modo Socket, siga estas etapas:
- Navegue até Basic Information na barra lateral esquerda do seu painel do Slack. Role para baixo até App-Level Tokens e clique no botão Generate Token and Scopes.
- Dê um nome ao seu token e adicione os dois escopos disponíveis:
connections:writeeauthorizations:read. Clique em Generate para criar o token. - Copie o token gerado e cole-o em seu arquivo .env, atribuindo-o a uma variável chamada
APP_TOKEN. Lembre-se de que as cadeias de tokens em nível de aplicativo começam comxapp-.
Em seguida, clique em Socket Mode na barra lateral e mude a opção Enable Socket Mode. Por fim, no arquivo app.js, adicione socketMode:true e appToken ao código que inicializa o aplicativo/servidor:
const app = new App({
token: process.env.SLACK_BOT_TOKEN,
signingSecret: process.env.SLACK_SIGNING_SECRET,
socketMode: true, // enable socket mode
appToken: process.env.APP_TOKEN,
});Depois que você tiver concluído essas etapas, todas as solicitações ao seu servidor de desenvolvimento ocorrerão via WebSockets em vez de HTTP. Essa configuração permite que você aproveite ao máximo o Modo Socket e aprimore a funcionalidade do Slackbot.
Comandos slash do Slack
Os comandos slash (Slash Commands) são um recurso avançado do Slack que permite que você acione gatilhos personalizados para ações específicas. Esses acionadores podem ser detectados em mensagens de chat nos canais do Slack. Além disso, os comandos slash permitem que você passe dados de texto diretamente ao seu servidor. Por exemplo, se você configurar um comando como /operation_status [operation ID], ele passará o operation ID fornecido ao seu servidor e acionará o ouvinte do comando operation_status correspondente.
Com o servidor devidamente configurado para interagir com o Slack, a próxima etapa é configurar comandos slash que acionarão ações no seu servidor.
Como criar comandos slash no Slack
Para criar comandos slash no Slack, clique na opção Slash Commands na barra lateral esquerda e, em seguida, clique no botão Create New Command. Preencha o formulário resultante usando a imagem abaixo como guia.
Após preencher o formulário, clique no botão Save. O Slack solicitará que você reinstale o aplicativo no seu espaço de trabalho para que as alterações tenham efeito. Siga as instruções para criar alguns comandos slash, conforme mostrado na imagem abaixo:
Configurando comandos slash com o Node.js
Depois que você tiver criado os comandos slash necessários, modifique seu aplicativo Node.js para responder a eles.
Vamos começar testando o comando /operation_status. Configure um ouvinte para eventos que incluam o comando /operation_status adicionando o seguinte código ao seu arquivo app.js:
const { App } = require('@slack/bolt');
require('dotenv').config();
const app = new App({
token: process.env.SLACK_BOT_TOKEN,
signingSecret: process.env.SLACK_SIGNING_SECRET,
socketMode: true, // enable the following to use socket mode
appToken: process.env.APP_TOKEN,
});
app.command('/operation_status', async ({ command, ack, say }) => {
await ack();
say('Wooah! Iit works!');
});
(async () => {
// Start your app
await app.start(process.env.PORT || 3000);
console.log(`⚡️ Kinsta Bot app is running on port ${process.env.PORT || 3000}!`);
})();No código acima, o foco está na função app.command(), que funciona de forma semelhante aos ouvintes de eventos em JavaScript. Você especifica o comando que deseja ouvir e, em seguida, cria uma função callback assíncrona para definir a ação desejada. Essa função recebe três parâmetros:
command: Contém os detalhes do comando slash enviado pelo usuário.ack: Confirma o recebimento do comando slash.say: Envia uma mensagem de volta ao canal do Slack.
Com o código acima, o comando /operation_status no Slack gerará a mensagem: “Wooah! it works!” (“Uhuu! funciona!”).
Agora vamos adicionar os ouvintes de comando para todos os comandos slash que você criou:
app.command('/environment_id', async ({ command, ack, say }) => {
await ack();
// Perform the desired action using the command and then send a response.
});
app.command('/site_id', async ({ command, ack, say }) => {
await ack();
// Perform the desired action using the command and then send a response.
});
app.command('/operation_status', async ({ command, ack, say }) => {
await ack();
// Perform the desired action using the command and then send a response.
});
app.command('/clear_site_cache', async ({ command, ack, say }) => {
await ack();
// Perform the desired action using the command and then send a response.
});
app.command('/restart_php_engine', async ({ command, ack, say }) => {
await ack();
// Perform the desired action using the command and then send a response.
});Seu aplicativo agora está pronto para ouvir os comandos slash do Slack. É hora de adicionar as ações que cada comando acionará.
Implantação de comandos slash com a API da Kinsta
Seu aplicativo responderá a cada comando slash com uma chamada para a API da Kinsta, e em seguida retornará o resultado dessa ação para o Slack. Para usar a API da Kinsta, você deve ter uma conta com pelo menos um site, aplicativo ou banco de dados do WordPress no MyKinsta. Você também precisará gerar uma chave API para autenticar e acessar sua conta através da API.
Como criar uma chave API da Kinsta
Para gerar uma chave API:
- Vá ao seu painel MyKinsta.
- Navegue até a página Chaves API (Seu nome > Configurações da empresa > Chaves API).
- Clique em Criar chave API.
- Escolha uma data de expiração ou defina uma data de início personalizada e o número de horas para a chave expirar.
- Dê à chave um nome exclusivo.
- Clique em Gerar.
Quando você criar uma chave API, copie-a e armazene-a em algum lugar seguro, pois essa é a única vez que você poderá vê-la. Para este projeto, salve-a em seu arquivo .env como KINSTA_API_KEY.
Interagindo com a API da Kinsta no Node.js
Para interagir com a API da Kinsta, você pode usar várias bibliotecas Node.js, incluindo a Axios. No entanto, neste tutorial, optaremos pelo método JavaScript fetch(), que agora é suportado e funciona de forma eficiente nas versões mais recentes do Node.js.
Para esse Slackbot serão feitas muitas solicitações de API, incluindo solicitações GET e POST. Para evitar repetições, armazene a URL da API e os cabeçalhos em variáveis para que seu código seja fácil de manter e ler:
// kinsta API utilities
const KinstaAPIUrl = 'https://api.kinsta.com/v2';
const getHeaders = {
Authorization: `Bearer ${process.env.KINSTA_API_KEY}`,
};
const postHeaders = {
'Content-Type': 'application/json',
Authorization: `Bearer ${process.env.KINSTA_API_KEY}`,
};Antes de começar a codificar a resposta do seu aplicativo a cada comando slash, você deve copiar o ID da sua empresa na Kinsta e armazená-lo no arquivo .env como KINSTA_COMPANY_ID. Você precisará dele para recuperar sua lista de sites.
Implantação do comando slash Environment ID
Quando você usa o comando slash /environment_id, qualquer valor fornecido após o comando será recuperado e usado no seu servidor Node.js. Para esse comando, foi adicionada uma dica para indicar que você espera um parâmetro: o [Site name].
Cada site no MyKinsta tem um nome de site exclusivo, mas não há um ponto de extremidade direto para solicitar o ID de ambiente (environment ID) de um site usando seu nome. Consequentemente, primeiro você precisa fazer uma solicitação para todos os sites na conta da sua empresa e, em seguida, usar o método find() para localizar o site cujo nome corresponda ao que foi passado com o comando slash.
Para isso são feitas duas solicitações. Primeiro você obtém o ID do site e, em seguida, faz outra solicitação ao ponto de extremidade /environments para recuperar o ID de ambiente associado a esse site.
Para manter a clareza do código e a facilidade de manutenção, cada solicitação é feita de forma independente. Isso significa ter funções individuais para essas solicitações, e, em seguida, chamar essas funções no ouvinte de comando.
Vamos começar buscando a lista de todos os seus sites:
async function getAllSites() {
const query = new URLSearchParams({
company: process.env.KINSTA_COMPANY_ID,
}).toString();
const resp = await fetch(`${KinstaAPIUrl}/sites?${query}`, {
method: 'GET',
headers: getHeaders,
});
const data = await resp.json();
return data;
}O código acima retornará um array contendo todos os sites. No ouvinte de comando /environment_id, você recuperará a resposta e a armazenará em uma variável. Em seguida, usando o método find(), você procurará um site cujo nome corresponda ao que foi passado pelo Slack. As informações do Slack são armazenadas em command.text.
app.command('/environment_id', async ({ command, ack, say }) => {
await ack();
let siteName = command.text;
let response = await getAllSites();
if (response) {
let mySites = response.company.sites;
let currentSite = mySites.find((site) => site.name === siteName);
// get environment ID
}
});Agora que você tem o site, use seu ID para buscar o ID de ambiente. Da mesma forma que quando consultamos uma lista de sites, crie uma função dedicada para fazer uma solicitação HTTP para o ponto de extremidade /environments:
async function getEnvironmentId(siteId) {
const resp = await fetch(`${KinstaAPIUrl}/sites/${siteId}/environments`, {
method: 'GET',
headers: getHeaders,
});
const data = await resp.json();
return data;
}O código acima espera que o ID do site seja passado como um argumento quando você chamar essa função no ouvinte de comando /environment_id. Ao receber o ID, a solicitação de API é feita e a resposta é armazenada em uma variável. Em seguida, você pode emitir o ID de ambiente no Slack usando o método say():
app.command('/environment_id', async ({ command, ack, say }) => {
await ack();
let siteName = command.text;
let response = await getAllSites();
if (response) {
let mySites = response.company.sites;
let currentSite = mySites.find((site) => site.name === siteName);
let envIdResponse = await getEnvironmentId(currentSite.id);
let envId = envIdResponse.site.environments[0].id;
if (envId) {
say(`Hey 👋,nnThe environment ID for "${siteName}" is 👉 ${envId}`);
}
}
});Neste ponto, quando você abrir o Slack e digitar /environment_id seguido de um nome de site válido, como /environment_id fashionstored, receberá uma resposta semelhante a esta:
Implantação do comando slash das ferramentas de site (limpar cache do site, reiniciar mecanismo PHP)
Duas tarefas que você pode implantar facilmente por meio da API sem precisar navegar até o MyKinsta são as operações de ferramentas de site Clear Site Cache (limpar cache do site) e Restart PHP Engine (reiniciar mecanismo PHP).
Para executar qualquer operação de ferramentas de site, tudo o que você precisa é do ID do ambiente. Esse ID é usado para fazer uma solicitação POST para /sites/tools/clear-cache e /sites/tools/restart-php, respectivamente. Como você fez anteriormente, execute a solicitação de API de forma independente e retorne a resposta:
async function clearSiteCache(environmentId) {
const resp = await fetch(`${KinstaAPIUrl}/sites/tools/clear-cache`, {
method: 'POST',
headers: postHeaders,
body: JSON.stringify({
environment_id: environmentId,
}),
});
const data = await resp.json();
return data;
}
async function restartPHPEngine(environmentId) {
const resp = await fetch(`${KinstaAPIUrl}/sites/tools/restart-php`, {
method: 'POST',
headers: postHeaders,
body: JSON.stringify({
environment_id: environmentId,
}),
});
const data = await resp.json();
return data;
}Em seguida, você criará ouvintes de comando para ambas as operações no Slack. Esses ouvintes serão configurados para serem acionados sempre que o respectivo comando for usado:
app.command('/clear_site_cache', async ({ command, ack, say }) => {
await ack();
let environmentId = command.text;
let response = await clearSiteCache(environmentId);
if (response) {
say(
`Hey 👋, nn${response.message} by using the /operation_status slack commmand. nnOperation Id is ${response.operation_id}`
);
}
});
app.command('/restart_php_engine', async ({ command, ack, say }) => {
await ack();
let environmentId = command.text;
let response = await restartPHPEngine(environmentId);
if (response) {
say(
`Hey 👋, nn${response.message} by using the /operation_status slack command. nnOperation Id is ${response.operation_id}`
);
}
});No código acima, os dados recuperados das solicitações de API são usados para construir a resposta enviada de volta ao Slack. A resposta inclui informações sobre a operação, como a mensagem e o ID da operação.
Ao implantar esses comandos slash e seus ouvintes correspondentes, você capacitará seu Slackbot a interagir perfeitamente com a API da Kinsta, tornando mais fácil do que nunca gerenciar o cache do seu site e o mecanismo PHP diretamente do Slack.
Implantação de um comando slash de status de operação
Também seria útil se você pudesse obter o status das suas operações no Slack. Você usará o ponto de extremidade /operations com o operation_id para fazer isso. Como antes, crie uma função para lidar com essa solicitação e retornar a resposta da solicitação:
async function CheckOperationStatus(operationId) {
const resp = await fetch(`${KinstaAPIUrl}/operations/${operationId}`, {
method: 'GET',
headers: getHeaders,
});
const data = await resp.json();
return data;
}Vamos definir o ouvinte de comando para acionar a solicitação e passar o operation ID enviado pelo Slack:
app.command('/operation_status', async ({ command, ack, say }) => {
await ack();
let operationId = command.text;
let response = await CheckOperationStatus(operationId);
let operationMessage = response.message;
if (operationMessage) {
say(`Hey 👋, nn${operationMessage}`);
}
});Agora, quando você usar o comando slash /operation_status com qualquer operation ID válido, obterá o status do ID retornado pelo Slack.
Além dos comandos que você já implantar com a API da Kinsta, há outros comandos que podem ser integrados, bem como eventos adicionais que podem ser tratados pelo Slackbot. Por exemplo, o Slackbot pode responder quando ele é mencionado ou marcado usando-se o símbolo @.
Para ativar essa funcionalidade, você precisa se inscrever nos eventos necessários no Slack. Em vez de usar o método app.command(), você utilizará o método app.message(), que recebe os parâmetros command e say.
Aqui está um exemplo de como você pode fazer isso:
app.message("hey", async ({ command, say }) => {
say("Woah! It works!");
});Depois de criar o Slackbot, talvez você perceba que não consegue enviar mensagens para ele. Ao navegar até o bot na aba Slack Apps, pode encontrar uma mensagem informando: “Sending messages to this app has been turned off.” (‘O envio de mensagens para este aplicativo foi desativado.’). Mas não se preocupe, pois podemos corrigir isso facilmente!
Para ativar o envio de mensagens, siga estas etapas:
- Clique na opção de menu App Home localizada na barra lateral esquerda.
- Essa página permite que você gerencie todas as configurações do seu bot. Role para baixo até encontrar a caixa de seleção “Allow users to send Slash Commands and messages from the messages tab” (‘Permitir que os usuários enviem comandos slash e mensagens da guia de mensagens’).
- Marque a caixa para ativar essa funcionalidade.
Depois que você tiver feito essas alterações, é essencial recarregar o aplicativo Slack para refletir as atualizações. Se estiver usando um Mac, você pode recarregar o Slack pressionando CMD + R. Outros usuários de PCs fazem isso pressionando CTRL + R.
Agora você está pronto para enviar mensagens ao seu bot! No aplicativo Slack, você deve ver o aplicativo Kinsta Bot listado logo abaixo da seção Your Apps (Seus Aplicativos). Clique nele para começar a enviar mensagens. Sinta-se à vontade para testar qualquer um dos comandos slash que você configurou, e eles devem funcionar perfeitamente. Aproveite a interação perfeita com seu Slackbot!
O código-fonte completo deste projeto está disponível no GitHub.
Implantando seu aplicativo Node.js na Kinsta
Quando você constrói seu servidor Node.js, é importante implantá-lo para que seu Slackbot esteja sempre disponível, mesmo que você interrompa seu desenvolvimento local. Você pode implantar na plataforma de hospedagem de aplicativos da Kinsta se seu código estiver hospedado nos provedores Git Bitbucket, GitHub ou GitLab.
Para implantar seu repositório na Kinsta, siga estas etapas:
- Faça login em sua conta Kinsta no painel MyKinsta.
- Clique em Adicionar serviço.
- Selecione Aplicativo no menu suspenso.
- No modal que aparece, escolha o repositório que você deseja implantar. Se você tiver várias branches, poderá selecionar a branch desejada e dar um nome ao seu aplicativo.
- Selecione um dos locais de centros de dados disponíveis. A Kinsta detectará e instalará as dependências do seu aplicativo a partir do arquivo package.json. Em seguida, procederá com a criação e implantação do aplicativo.
Por fim, não é seguro enviar chaves API para hosts públicos, como seu provedor Git. Ao hospedar na Kinsta, você pode adicioná-las como variáveis de ambiente usando o mesmo nome e valor de variável especificados no seu arquivo .env de desenvolvimento.
Quando você iniciar a implantação do seu aplicativo, o processo começará, e normalmente será concluído em alguns minutos. Se algum problema com as configurações do Node.js afetar a implantação, você poderá adicionar um buildpack do Node.js na aba de configurações de implantação.
Resumo
Neste artigo, você aprendeu a criar um aplicativo Node.js que conecta o Slack à API da Kinsta, e a implantar esse aplicativo na Kinsta.
Slackbots e a API da Kinsta facilitam monitorar e gerenciar seus serviços hospedados na Kinsta. Com base nos princípios básicos deste tutorial, imagine o que você pode fazer com um Slackbot e a API. Considere comandos mais complexos que realizam operações como clonagem de sites WordPress e criação de sites diretamente do Slack.
Como você está usando a API da Kinsta? Quais recursos você gostaria de ver adicionados/expostos em seguida?
Deixe um comentário