Slack è un’ottima piattaforma di messaggistica che permette ai team di collaborare in modo efficiente. E se questa collaborazione implica anche la gestione di più siti WordPress qui su Kinsta, è possibile spostare alcune attività comuni di gestione dei siti su Slack con l’aiuto dell’API di Kinsta.
Integrare uno Slackbot nel proprio flusso di lavoro può far risparmiare tempo e migliorare la produttività. Questo tutorial combina la potenza di Slack e dell’API di Kinsta per costruire uno Slackbot in grado di gestire attività come la verifica dello stato del sito, la cancellazione della cache e il riavvio del motore PHP di un sito.
Cosa costruiremo
In questo caso, stiamo costruendo uno Slackbot su Node.js utilizzando l’API Bolt (il modo più rapido per iniziare a programmare con la piattaforma Slack). L’applicazione trasformerà i comandi slash di Slack in chiamate all’API di Kinsta e inoltrerà le risposte in modo che tutta l’interazione con l’utente avvenga in Slack.
Prerequisiti
Per seguire questo progetto, è necessario possedere i seguenti requisiti:
- Conoscenza di base di JavaScript e Node.js
- Node.js versione 12 o superiore
- npm (Node Package Manager) installato sul computer
- Spazio di lavoro Slack
Creare un’applicazione Slack
Uno Slackbot è essenzialmente un’applicazione Slack. Per creare una nuova applicazione Slack, seguiamo questi passaggi:
- Andiamo alla dashboard di Slack API.
- Clicchiamo sul pulsante Create New App, che aprirà una finestra di dialogo.
- Selezioniamo l’opzione From Scratch per iniziare a creare l’applicazione da zero.
- Scegliamo un nome per l’app Slack. Ad esempio, Kinsta Bot.
- Scegliamo quindi l’area di lavoro in cui vogliamo installare l’app e clicchiamo sul pulsante Create app.
Non esitate a modificare le informazioni di base dell’app navigando fino all’opzione Basic Information nella barra laterale. Scorrete verso il basso fino a Display Information per aggiungere dettagli come un’immagine, un nome, una descrizione, un colore e altro ancora.
Configurare oAuth e i permessi
Abbiamo creato con successo uno Slackbot. Tuttavia, è necessario concedere alcuni permessi per consentirgli di accedere ai dati ed eseguire azioni all’interno del nostro spazio di lavoro Slack. Per accedere alle impostazioni necessarie:
- Andiamo nella dashboard dell’app Slack e individuiamo l’opzione OAuth & Permissions nella barra laterale sinistra.
- Una volta lì, scorriamo verso il basso fino alla sezione Scopes.
- Diamo al bot il permesso di leggere i messaggi istantanei degli utenti e di rispondere a tali messaggi.
Di seguito è riportata una schermata che mostra i permessi da fornire al bot:
Configurando questi permessi, il bot sarà in grado di interagire perfettamente con gli utenti di Slack e di svolgere efficacemente le funzioni previste.
Installare lo Slackbot nello spazio di lavoro
Per completare il processo, dobbiamo installare il nuovo Slackbot nel nostro spazio di lavoro Slack. Andiamo nella barra laterale di sinistra e selezioniamo Install Apps. Da qui, clicchiamo su Install to Workspace e specifichiamo il canale in cui desideriamo aggiungere il bot.
Lo Slackbot è ora pronto. Configuriamo un server Node.js che verrà utilizzato per ricevere ed elaborare le richieste.
Impostazione dell’ambiente di sviluppo
Per iniziare il nostro nuovo progetto Node.js, creiamo una nuova directory per l’applicazione e inizializziamola con npm:
mkdir my-express-app
cd my-express-app
npm init -yDopo aver eseguito il comando precedente, viene creato un nuovo file package.json nella directory scelta con i valori predefiniti. Il file package.json è fondamentale perché contiene informazioni sul progetto e sulle sue dipendenze. Queste dipendenze permetteranno uno sviluppo fluido e miglioreranno le funzionalità del progetto:
@slack/bolt: questo framework JavaScript permette di creare rapidamente applicazioni Slack ricche di funzionalità, sfruttando le ultime funzionalità della piattaforma.nodemon: un prezioso strumento che riavvia automaticamente l’applicazione Node.js ogni volta che vengono rilevate modifiche ai file nella directory, assicurando un flusso di sviluppo semplificato.dotenv: questo modulo a dipendenza zero svolge un ruolo fondamentale nel caricamento delle variabili d’ambiente dal file .env aprocess.env, rendendo la gestione della configurazione un gioco da ragazzi.
Per installare i pacchetti necessari, eseguiamo questi comandi:
npm i @slack/bolt
npm i --save-dev nodemon dotenvDopo aver installato con successo queste dipendenze e le dipendenze dev, è il momento di aggiungere uno script dev al file package.json, utilizzando nodemon per eseguire il file JavaScript. Assicuriamoci che l’oggetto package.json includa quanto segue:
"scripts": {
"dev": "nodemon app.js"
}Infine, è importante sottolineare che lo script dev punta a un file app.js inesistente. Creiamo questo file nella directory del progetto, poiché è qui che verrà gestita la logica del progetto.
touch app.jsConfigurazione delle variabili d’ambiente (token e segreti)
Avremo bisogno di token e segreti specifici per interagire con l’applicazione Slack dal progetto Node.js. Queste credenziali sono sensibili e per garantirne la protezione quando si utilizza il controllo di versione, le memorizzeremo nel file .env.
Per ottenere il Signing Secret, o segreto di firma, accediamo alla dashboard di Slack, clicchiamo su Basic Information e poi scorriamo fino a App Credentials, dove troveremo il Signing Secret. Per il token, clicchiamo su Install App o su OAuth & Permissions e troveremo il token OAuth. In genere, il token inizia con “xoxb”.
Creaiamo un file chiamato .env nella directory principale del progetto e aggiungiamo il Signing Secret e il Bot Token nel seguente formato:
SLACK_SIGNING_SECRET="YOUR SIGNING SECRET"
SLACK_BOT_TOKEN="YOUR BOT TOKEN"Per assicurarci che queste informazioni sensibili non vengano inviate al provider Git, creiamo un file .gitignore nella directory principale del progetto e aggiungiamo le seguenti righe per ignorare il file .env e la cartella node_modules:
/node_modules
.envUna volta completata questa impostazione, siamo pronti a procedere con la configurazione del server.
Configurazione del server Node.js
La configurazione del server Node.js è un passo fondamentale per la creazione del nostro Slackbot. Dobbiamo importare i pacchetti e i moduli necessari, inizializzarli e impostare la porta su cui il progetto sarà in ascolto. Apriamo il file app.js che abbiamo creato in precedenza e aggiungiamo il seguente codice:
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}!`);
})();Nel codice qui sopra, importiamo la classe App dalla libreria @slack/bolt, un componente fondamentale per la creazione di app Slack. Inoltre, utilizziamo il pacchetto dotenv per elaborare le variabili d’ambiente.
Quindi, la costante app viene creata utilizzando la classe App, che rappresenta l’applicazione bot Slack. Richiede due parametri importanti: token e signingSecret. Questi valori vengono recuperati dal file .env.
Successivamente, all’interno della funzione async, avviene la configurazione del server. L’applicazione viene avviata chiamando app.start(). L’applicazione ascolta la porta 3000 in locale e registra un messaggio nella console, confermando che l’applicazione Kinsta Bot è in esecuzione.
Ora, quando eseguiamo lo script dev che abbiamo configurato (npm run dev), nel nostro terminale apparirà il messaggio: “⚡️ Kinsta Bot app is running on port 3000!”
La modalità Socket dell’API di Slack
Nell’integrazione dell’API di Slack con i server Node.js, esistono due metodi principali di connessione: l’utilizzo dell’endpoint HTTP pubblico del server o la modalità Socket per attivare i WebSocket. Questo tutorial si concentra sull’utilizzo della modalità Socket, in quanto consente di implementare con maggiore facilità funzioni interattive come i comandi Slack slash. Questo approccio permette a Slack di connettersi al server Node.js utilizzando WebSockets invece del tradizionale HTTP.
Tuttavia, se scegliamo di utilizzare l’endpoint HTTP in locale, possiamo sfruttare ngrok per creare un URL pubblico che faccia da proxy al nostro localhost.
Come iniziare con la modalità Socket
Per iniziare a utilizzare la modalità Socket, seguiamo questi passaggi:
- Andiamo su Basic Information nella barra laterale sinistra della dashboard Slack. Scorriamo verso il basso fino a App-Level Tokens e clicchiamo sul pulsante Generate Token and Scopes.
- Diamo un nome al token e aggiungiamo i due ambiti disponibili:
connections:writeeauthorizations:read. Clicchiamo su Generate per creare il token. - Copiamo il token generato e incolliamolo nel file .env, assegnandolo a una variabile chiamata
APP_TOKEN. Ricordate che le stringhe di token a livello di app iniziano conxapp-.
Successivamente, clicchiamo su Socket Mode nella barra laterale e attiviamo l’opzione Enable Socket Mode. Infine, nel file app.js, aggiungiamo socketMode:true e appToken al codice che inizializza l’app/server:
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,
});Una volta completati questi passaggi, tutte le richieste al server di sviluppo avverranno tramite WebSockets anziché HTTP. Questa configurazione permette di sfruttare al meglio la modalità Socket e di migliorare le funzionalità dello Slackbot.
Comandi slash su Slack
I comandi slash sono una funzione di Slack che consente di attivare azioni specifiche. Questi comandi possono essere rilevati nei messaggi di chat dei vari canali di Slack. Inoltre, i comandi slash permettono di passare dati di testo direttamente al server. Ad esempio, se impostiamo un comando come /operation_status [operation ID], questo passerà il testo operation ID al server e attiverà l’ascoltatore del comando operation_status corrispondente.
Dopo aver configurato correttamente il server per interagire con Slack, il passo successivo consiste nell’impostare i comandi slash che attiveranno le azioni sul nostro server.
Creare comandi slash su Slack
Per creare comandi slash su Slack, clicchiamo sull’opzione di menu Slash Commands nella barra laterale sinistra, quindi clicchiamo sul pulsante Create New Command. Compiliamo il modulo risultante utilizzando l’immagine qui sotto come guida.
Dopo aver compilato il modulo, clicchiamo sul pulsante Salva. Slack chiederà di reinstallare l’app nello spazio di lavoro affinché le modifiche abbiano effetto. Seguiamo le istruzioni per creare alcuni comandi slash, come mostrato nell’immagine qui sotto:
Configurare i comandi slash con Node.js
Una volta creati i comandi slash necessari, modifichiamo la nostra applicazione Node.js per rispondere a questi ultimi.
Cominciamo a testare il comando /operation_status. Impostiamo un ascoltatore per gli eventi che includono il comando /operation_status aggiungendo il seguente codice al file 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! It 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}!`);
})();Nel codice qui sopra, l’attenzione è rivolta alla funzione app.command(), che funziona in modo simile agli ascoltatori di eventi in JavaScript. Specifichiamo il comando che desideriamo ascoltare e poi creiamo una funzione di callback asincrona per definire l’azione desiderata. Questa funzione accetta tre parametri:
command: contiene i dettagli del comando slash inviato dall’utente.ack: conferma la ricezione del comando slash.say: invia un messaggio al canale Slack.
Con il codice di cui sopra, il comando /operation_status in Slack genererà il messaggio: “Wooah! It works!”
Ora aggiungiamo gli ascoltatori di comandi per tutti i comandi slash che abbiamo creato:
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.
});L’applicazione è ora pronta ad ascoltare i comandi Slack slash. È ora di aggiungere le azioni che ogni comando attiverà.
Implementare i comandi slack con l’API di Kinsta
L’applicazione risponderà a ogni comando slash con una chiamata all’API di Kinsta e poi restituirà il risultato dell’azione a Slack. Per utilizzare l’API di Kinsta, è necessario avere un account con almeno un sito WordPress, un’applicazione o un database in MyKinsta. Sarà inoltre necessario generare una chiave API per autenticarsi e accedere al proprio account tramite l’API.
Come creare una chiave API di Kinsta
Per generare una chiave API:
- Andare alla dashboard di MyKinsta.
- Andare alla pagina delle chiavi API (Nome > Impostazioni dell’azienda > Chiavi API).
- Cliccare su Crea chiave API.
- Scegliere una data di scadenza o impostare una data di inizio personalizzata e un numero di ore di scadenza della chiave.
- Assegnare alla chiave un nome univoco.
- Cliccare su Genera.
Una volta creata la chiave API, copiatela e conservatela in un posto sicuro, perché è l’unico momento in cui potrete vederla. Per questo progetto, salvatela nel file .env come KINSTA_API_KEY.
Interagire con l’API di Kinsta in Node.js
L’interazione con l’API di Kinsta può essere ottenuta utilizzando diverse librerie Node.js, tra cui Axios. Tuttavia, in questo tutorial opteremo per il metodo JavaScript fetch(), che ora è supportato e funziona in modo efficiente nelle ultime versioni di Node.js.
Per questo Slackbot verranno effettuate molte richieste API, tra cui GET e POST. Per evitare ripetizioni, memorizziamo l’URL dell’API e le intestazioni in variabili in modo che il codice sia facile da mantenere e da leggere:
// 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}`,
};Prima di iniziare a codificare la risposta dell’applicazione a ogni comando slash, dobbiamo copiare l’ID azienda Kinsta e memorizzarlo nel file .env come KINSTA_COMPANY_ID. Sarà necessario per recuperare l’elenco dei siti.
Implementazione del comando slash ID ambiente
Quando utilizziamo il comando slash /environment_id, qualsiasi valore fornito dopo il comando verrà recuperato e utilizzato nel nostro server Node.js. Per questo comando è stato aggiunto un suggerimento per indicare che si aspetta un parametro: [Site name].
Ogni sito su MyKinsta ha un nome univoco, ma non esiste un endpoint diretto per richiedere l’ID ambiente di un sito utilizzando il suo nome. Di conseguenza, dobbiamo prima fare una richiesta per tutti i siti dell’account aziendale e poi utilizzare il metodo find() per individuare il sito il cui nome corrisponde a quello passato con il comando slash.
A tal fine, vengono effettuate due richieste. Prima si ottiene l’ID del sito e poi si effettua un’altra richiesta all’endpoint /environments per recuperare l’ID dell’ambiente associato a quel sito.
Per mantenere il codice chiaro e la manutenzione semplice, ogni richiesta viene effettuata in modo indipendente. Ciò significa avere funzioni individuali per queste richieste e richiamare tali funzioni nel listener di comandi.
Iniziamo recuperando l’elenco di tutti i siti:
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;
}Il codice precedente restituirà un array contenente tutti i siti. Nell’ascoltatore del comando /environment_id recupereremo la risposta e la memorizzeremo in una variabile. Quindi, utilizzando il metodo find(), cerchiamo un sito il cui nome corrisponda a quello passato da Slack. Le informazioni provenienti da Slack sono memorizzate in 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
}
});Ora che abbiamo il sito, utilizziamo il suo ID per ottenere l’ID dell’ambiente. Come per la ricerca di un elenco di siti, creiamo una funzione dedicata per fare una richiesta HTTP all’endpoint /environments:
async function getEnvironmentId(siteId) {
const resp = await fetch(`${KinstaAPIUrl}/sites/${siteId}/environments`, {
method: 'GET',
headers: getHeaders,
});
const data = await resp.json();
return data;
}Il codice precedente prevede che l’ID del sito venga passato come argomento quando si chiama questa funzione nell’ascoltatore di comandi /environment_id. Una volta ricevuto l’ID, viene effettuata la richiesta API e la risposta viene memorizzata in una variabile. Quindi, possiamo inviare l’ID dell’ambiente su Slack utilizzando il metodo 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 👋,\n\nThe environment ID for "${siteName}" is 👉 ${envId}`);
}
}
});A questo punto, quando apriamo Slack e digitiamo /environment_id seguito da un nome di sito valido, ad esempio /environment_id fashionstored, riceveremo una risposta simile a questa:
Implementare un comando slash per gli strumenti del sito (svuotare la cache del sito, riavviare il motore PHP)
Due operazioni che si possono implementare facilmente tramite l’API senza dover navigare in MyKinsta sono gli strumenti del sito Svuota cache del sito e Riavvia motore PHP.
Per eseguire qualsiasi operazione tra quelle degli strumenti del sito, tutto ciò di cui abbiamo bisogno è l’ID dell’ambiente. Questo ID viene utilizzato per effettuare una richiesta POST ai siti /sites/tools/clear-cache e /sites/tools/restart-php. Come in precedenza, eseguiamo la richiesta API in modo indipendente e poi restituiamo la risposta:
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;
}Successivamente, creeremo degli ascoltatori di comandi per entrambe le operazioni in Slack. Questi ascoltatori saranno configurati per attivarsi ogni volta che viene utilizzato il rispettivo comando:
app.command('/clear_site_cache', async ({ command, ack, say }) => {
await ack();
let environmentId = command.text;
let response = await clearSiteCache(environmentId);
if (response) {
say(
`Hey 👋, \n\n${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 👋, \n\n${response.message} by using the /operation_status slack command. nnOperation Id is ${response.operation_id}`
);
}
});Nel codice sopra riportato, i dati recuperati dalle richieste API vengono utilizzati per costruire la risposta inviata a Slack. La risposta include informazioni sull’operazione, come il messaggio e l’ID dell’operazione.
Implementando questi comandi slash e i relativi ascoltatori, potremo far interagire lo Slackbot con l’API di Kinsta, rendendo più facile che mai la gestione della cache e del motore PHP del sito direttamente da Slack.
Implementare un comando Slash di stato dell’operazione
Sarebbe anche opportuno ottenere lo stato delle nostre operazioni da Slack. Per farlo, utilizzeremo l’endpoint /operations insieme al comando operation_id. Come in precedenza, creiamo una funzione per gestire questa richiesta e restituire la risposta:
async function CheckOperationStatus(operationId) {
const resp = await fetch(`${KinstaAPIUrl}/operations/${operationId}`, {
method: 'GET',
headers: getHeaders,
});
const data = await resp.json();
return data;
}Definiamo l’ascoltatore di comandi per attivare la richiesta e passare l’indirizzo operation ID inviato via 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 👋, \n\n${operationMessage}`);
}
});Ora, quando usiamo il comando /operation_status slash con un qualsiasi operation ID valido, otterremo lo stato dell’ID restituito via Slack.
Oltre ai comandi che abbiamo già implementato con l’API Kinsta, ci sono altri comandi che possono essere integrati e altri eventi che possono essere gestiti dallo Slackbot. Ad esempio, lo Slackbot può rispondere quando viene menzionato o taggato con il simbolo @.
Per abilitare questa funzionalità, è necessario sottoscrivere gli eventi necessari in Slack. Invece di usare il metodo app.command(), utilizzeremo il metodo app.message(), che accetta i parametri command e say.
Ecco un esempio di come ottenere questo risultato:
app.message("hey", async ({ command, say }) => {
say("Woah! It works!");
});Dopo aver creato lo Slackbot, potreste notare di non riuscire a inviargli dei messaggi. Navigando verso il bot nella scheda App di Slack, potreste trovare un messaggio che dice: “L’invio di messaggi a questa applicazione è stato disattivato”. Non preoccupatevi, possiamo risolvere facilmente il problema!
Per abilitare l’invio di messaggi, seguite questi passaggi:
- Cliccare sull’opzione del menu App Home che si trova nella barra laterale sinistra.
- Questa pagina permette di gestire tutte le impostazioni del bot. Scorrere verso il basso fino a trovare la casella “Consenti agli utenti di inviare comandi e messaggi Slash dalla scheda messaggi”.
- Spuntare la casella per abilitare questa funzionalità.
Una volta apportate queste modifiche, è fondamentale ricaricare l’applicazione Slack per riflettere gli aggiornamenti. Se utilizzate un Mac, potete ricaricare Slack premendo CMD + R. Per gli altri utenti di PC, potete farlo premendo CTRL + R.
Ora siete pronti per inviare messaggi al vostro bot! Nell’app Slack, dovreste vedere l’app Kinsta Bot elencata sotto la sezione Your Apps. Cliccateci sopra per iniziare a inviare messaggi. Provate liberamente tutti i comandi slash che abbiamo configurato e dovrebbero funzionare perfettamente. E godetevi un’interazione perfetta con il vostro Slackbot!
Il codice sorgente completo di questo progetto è disponibile su GitHub.
Distribuire l’applicazione Node.js su Kinsta
Quando costruiamo il nostro server Node.js, è importante distribuirlo in modo che lo Slackbot sia sempre disponibile, anche se si interrompe lo sviluppo locale. Potete effettuare il deploy sulla piattaforma di Hosting di Applicazioni di Kinsta se il codice è ospitato sui provider Git Bitbucket, GitHub o GitLab.
Per distribuire il repository su Kinsta, seguite i passaggi qui sotto:
- Accedere all’account Kinsta nella dashboard MyKinsta.
- Cliccare su Aggiungi servizio.
- Selezionare Applicazione dal menu a tendina.
- Nella finestra di dialogo che appare, scegliere il repository che si vuole distribuire. Se si hanno più branch, è possibile selezionare il branch desiderato e dare un nome all’applicazione.
- Selezionare uno dei data center disponibili. Kinsta rileverà e installerà le dipendenze dell’applicazione dal file package.json, quindi eseguirà la compilazione e la distribuzione.
Infine, non è sicuro inviare le chiavi API a host pubblici come un provider Git. Quando l’hosting è su Kinsta, è possibile aggiungerle come variabili d’ambiente utilizzando lo stesso nome e valore della variabile specificata nel file .env di sviluppo.
Una volta avviata la distribuzione dell’applicazione, il processo inizierà e si concluderà in genere entro pochi minuti. Se qualche problema con le configurazioni di Node.js influisce sulla distribuzione, è possibile aggiungere un buildpack Node.js nella scheda delle impostazioni di distribuzione.
Riepilogo
In questo articolo abbiamo imparato a costruire un’applicazione Node.js che collega Slack con l’API di Kinsta e a distribuirla su Kinsta.
Slackbot e l’API di Kinsta facilitano il monitoraggio e la gestione dei servizi ospitati da Kinsta. Partendo dalle basi di questo tutorial, immaginate cosa potreste fare con uno Slackbot e l’API. Pensate a comandi più complessi per eseguire operazioni come la clonazione di un sito WordPress e la creazione di un sito direttamente da Slack.
Come utilizzate l’API di Kinsta? Quali funzioni vorreste vedere aggiunte/esposte prossimamente?
Lascia un commento