Slack ist eine leistungsstarke Messaging-Plattform, die es Teams ermöglicht, effizient zusammenzuarbeiten. Und wenn diese Zusammenarbeit auch die Betreuung mehrerer WordPress-Websites hier bei Kinsta umfasst, kannst du mit Hilfe der Kinsta-API einige gängige Aufgaben der Website-Verwaltung auf Slack übertragen.
Wenn du einen Slackbot in deinen Arbeitsablauf integrierst, kannst du Zeit sparen und deine Produktivität steigern. In diesem Tutorial kombinierst du die Möglichkeiten von Slack und der Kinsta-API, um einen Slackbot zu bauen, der Aufgaben wie die Überprüfung des Site-Status, das Löschen des Site-Caches und den Neustart der PHP-Engine einer Site übernimmt.
Was du erstellst
Du erstellst einen Slackbot auf Node.js unter Verwendung der Bolt API (der schnellste Weg, um mit der Slack-Plattform zu programmieren). Deine Anwendung wandelt die Slash-Befehle von Slack in Aufrufe an die Kinsta-API um und leitet die Antworten weiter, sodass die gesamte Benutzerinteraktion in Slack stattfindet.
Voraussetzungen
Um an diesem Projekt mitzuarbeiten, solltest du Folgendes mitbringen:
- Grundkenntnisse in JavaScript und Node.js
- Node.js Version 12 oder höher
- npm (Node Package Manager) auf deinem Computer installiert haben
- Slack-Arbeitsbereich
Eine Slack-Anwendung erstellen
Ein Slackbot ist im Grunde eine Slack-Anwendung. Um eine neue Slack-Anwendung zu erstellen, befolge diese Schritte:
- Navigiere zum Slack API Dashboard.
- Klicke auf die Schaltfläche Neue Anwendung erstellen, wodurch sich ein Modal öffnet.
- Wähle die Option Von Grund auf, um deine Anwendung von Grund auf zu erstellen.
- Gib einen Namen für deine Slack-Anwendung an. Zum Beispiel: Kinsta Bot.
- Wähle dann den Arbeitsbereich aus, in dem du die Anwendung installieren möchtest, und klicke auf die Schaltfläche Anwendung erstellen.
Zögere nicht, die grundlegenden Informationen deiner Anwendung zu bearbeiten, indem du zu der Option Basisinformationen in der Seitenleiste navigierst. Scrolle nach unten zu Display Information, um Details wie ein Bild, einen Namen, eine Beschreibung, eine Farbe und mehr hinzuzufügen.
Konfigurieren von oAuth und Berechtigungen
Du hast erfolgreich einen Slackbot erstellt. Damit er jedoch auf Daten zugreifen und Aktionen in deinem Slack-Arbeitsbereich durchführen kann, müssen bestimmte Berechtigungen erteilt werden. Um auf die notwendigen Einstellungen zuzugreifen:
- Gehe zum Dashboard deiner Slack-Anwendung und suche die Option OAuth und Berechtigungen in der linken Seitenleiste.
- Wenn du dort bist, scrolle nach unten zum Abschnitt Scopes.
- Gib deinem Bot die Möglichkeit, Sofortnachrichten von Nutzern zu lesen und auf diese Nachrichten zu antworten.
Unten siehst du einen Screenshot mit den Bereichen, die du deinem Bot zuweisen solltest:
Wenn du diese Bereiche konfigurierst, ist dein Bot in der Lage, nahtlos mit Slack-Nutzern zu interagieren und die vorgesehenen Funktionen effektiv auszuführen.
Installation des Slack Bot in deinem Arbeitsbereich
Um den Prozess abzuschließen, musst du deinen neuen Slackbot in deinem Slack-Arbeitsbereich installieren. Navigiere zur linken Seitenleiste und wähle Anwendungen installieren. Dort klickst du auf In Arbeitsbereich installieren und gibst den Kanal an, zu dem du den Bot hinzufügen möchtest.
Dein Slackbot ist jetzt bereit. Richten wir nun einen Node.js-Server ein, der deine Anfragen empfängt und verarbeitet.
Einrichten der Entwicklungsumgebung
Um mit deinem neuen Node.js-Projekt zu beginnen, erstelle ein neues Verzeichnis für deine Anwendung und initialisiere es mit npm:
mkdir my-express-app
cd my-express-app
npm init -yNachdem du den obigen Befehl ausgeführt hast, wird eine neue package.json-Datei in dem von dir gewählten Verzeichnis mit Standardwerten erstellt. Die package.json Datei ist wichtig, da sie Informationen über dein Projekt und seine Abhängigkeiten enthält. Diese Abhängigkeiten ermöglichen eine reibungslose Entwicklung und erweitern die Funktionalität deines Projekts:
@slack/bolt: Mit diesem JavaScript-Framework kannst du schnell funktionsreiche Slack-Anwendungen erstellen und dabei die neuesten Funktionen der Plattform nutzen.nodemon: Ein wertvolles Tool, das deine Node.js-Anwendung automatisch neu startet, sobald Datei-Änderungen im Verzeichnis erkannt werden, und so für einen optimierten Entwicklungs-Workflow sorgt.dotenv: Dieses Zero-Dependency-Modul spielt eine entscheidende Rolle beim Laden von Umgebungsvariablen aus der .env-Datei inprocess.envund macht das Konfigurationsmanagement zum Kinderspiel.
Um die benötigten Pakete zu installieren, führe die folgenden Befehle aus:
npm i @slack/bolt
npm i --save-dev nodemon dotenvNach der erfolgreichen Installation dieser Abhängigkeiten und der dev-Abhängigkeiten ist es an der Zeit, ein dev-Skript zu deiner package.json-Datei hinzuzufügen, das nodemon nutzt, um deine JavaScript-Datei auszuführen. Vergewissere dich, dass dein package.json Skriptobjekt Folgendes enthält:
"scripts": {
"dev": "nodemon app.js"
}Zu guter Letzt ist es wichtig zu erwähnen, dass das dev Skript auf eine nicht existierende app.js Datei verweist. Erstelle diese Datei im Verzeichnis deines Projekts, denn dort wird die Logik deines Projekts verarbeitet.
touch app.jsKonfigurieren deiner Umgebungsvariablen (Token und Secrets)
Um von deinem Node.js-Projekt aus mit deiner Slack-Anwendung zu interagieren, benötigst du bestimmte Token und Secrets. Diese Anmeldeinformationen sind sensibel. Um sie bei der Versionskontrolle zu schützen, speichern wir sie in der .env-Datei.
Um das Signing Secret zu erhalten, gehst du in dein Slack Dashboard, klickst auf Basisinformationen und scrollst dann nach unten zu App Credentials, wo du das Signing Secret findest. Für das Token klickst du auf Anwendung installieren oder OAuth & Permissions und findest dort das OAuth Token. Normalerweise beginnt das Token mit „xoxb“.
Erstelle eine Datei namens .env im Hauptverzeichnis deines Projekts und füge das Signing Secret und das Bot Token im folgenden Format hinzu:
SLACK_SIGNING_SECRET="YOUR SIGNING SECRET"
SLACK_BOT_TOKEN="YOUR BOT TOKEN"Um sicherzustellen, dass diese sensiblen Informationen nicht an deinen Git-Anbieter weitergegeben werden, erstelle eine .gitignore-Datei im Hauptverzeichnis deines Projekts und füge die folgenden Zeilen hinzu, um die .env-Datei und den Ordner node_modules zu ignorieren:
/node_modules
.envNachdem du diese Einstellungen vorgenommen hast, kannst du mit der Serverkonfiguration fortfahren.
Einrichten des Node.js-Servers
Das Einrichten des Node.js-Servers ist ein wichtiger Schritt bei der Erstellung deines Slackbots. Du musst die notwendigen Pakete und Module importieren, sie initialisieren und den Port festlegen, auf dem dein Projekt lauschen soll. Öffne die Datei app.js, die du zuvor erstellt hast, und füge den folgenden Code hinzu:
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}!`);
})();Im obigen Code importierst du die Klasse App aus der Bibliothek @slack/bolt, eine wichtige Komponente für die Erstellung von Slack-Anwendungen. Außerdem verwendest du das Paket dotenv, um Umgebungsvariablen zu verarbeiten.
Dann wird die Konstante app mithilfe der Klasse App erstellt, die deine Slack-Bot-Anwendung darstellt. Sie benötigt zwei wichtige Parameter: token und signingSecret. Diese Werte werden aus der .env-Datei geholt.
Als Nächstes erfolgt in der Funktion async die Einrichtung des Servers. Die Anwendung wird durch den Aufruf von app.start() gestartet. Sie lauscht lokal auf Port 3000 und gibt eine Meldung auf der Konsole aus, die bestätigt, dass die Kinsta-Bot-Anwendung läuft.
Wenn du jetzt das dev Skript ausführst, das du konfiguriert hast (npm run dev), bekommst du die Meldung in deinem Terminal: „⚡️ Kinsta Bot app is running on port 3000!“
Den Socket-Modus der Slack-API verstehen
Bei der Slack API-Integration mit Node.js-Servern gibt es zwei primäre Verbindungsmethoden: die Nutzung des öffentlichen HTTP-Endpunkts deines Servers oder die Verwendung des Socket-Modus, um WebSockets zu aktivieren. Dieses Tutorial konzentriert sich auf die Verwendung des Socket-Modus, da er die Implementierung interaktiver Funktionen wie Slack-Slash-Befehle erleichtert. Mit diesem Ansatz kann sich Slack mit deinem Node.js-Server über WebSockets statt über das herkömmliche HTTP verbinden.
Wenn du dich jedoch dafür entscheidest, den HTTP-Endpunkt lokal zu verwenden, kannst du mit ngrok eine öffentliche URL erstellen, die auf deinen lokalen Host verweist.
Erste Schritte mit dem Socket-Modus
Um mit dem Socket-Modus zu beginnen, befolge diese Schritte:
- Navigiere in der linken Seitenleiste deines Slack-Dashboards zu Basisinformationen. Scrolle nach unten zu Token auf Anwendungsebene und klicke auf die Schaltfläche Token und Geltungsbereiche generieren.
- Gib deinem Token einen Namen und füge die beiden verfügbaren Bereiche hinzu:
connections:writeundauthorizations:read. Klicke auf Erzeugen, um das Token zu erstellen. - Kopiere das erzeugte Token und füge es in deine .env-Datei ein, indem du es einer Variablen namens
APP_TOKENzuweist. Denke daran, dass Token-Strings auf Anwendungsebene mitxapp-beginnen.
Als Nächstes klickst du in der Seitenleiste auf Socket Mode und schaltest die Option Enable Socket Mode ein. Zum Schluss fügst du in deiner app.js-Datei socketMode:true und deine appToken zu dem Code hinzu, der deine Anwendung/Server initialisiert:
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,
});Sobald du diese Schritte durchgeführt hast, werden alle Anfragen an deinen Entwicklungsserver über WebSockets und nicht über HTTP erfolgen. Mit dieser Einrichtung kannst du den Socket-Modus optimal nutzen und die Funktionalität deines Slackbots erweitern.
Slack Slash-Befehle
Slash-Befehle sind eine leistungsstarke Funktion in Slack, die benutzerdefinierte Auslöser für bestimmte Aktionen ermöglicht. Diese Auslöser können in Chat-Nachrichten in allen Slack-Kanälen erkannt werden. Außerdem kannst du mit Slash-Befehlen Textdaten direkt an deinen Server übermitteln. Wenn du z.B. einen Befehl wie /operation_status [operation ID] einrichtest, wird er die angegebene operation ID an deinen Server weitergeben und den entsprechenden operation_status Befehlslistener auslösen.
Wenn dein Server richtig für die Interaktion mit Slack konfiguriert ist, kannst du im nächsten Schritt Slash-Befehle einrichten, die Aktionen auf deinem Server auslösen.
Slash-Befehle auf Slack erstellen
Um Slash-Befehle auf Slack zu erstellen, klicke auf die Menüoption Slash-Befehle in der linken Seitenleiste und dann auf die Schaltfläche Neuen Befehl erstellen. Fülle das Formular aus und orientiere dich dabei an der Abbildung unten.
Nachdem du das Formular ausgefüllt hast, klicke auf die Schaltfläche Speichern. Slack fordert dich auf, die Anwendung erneut in deinem Arbeitsbereich zu installieren, damit die Änderungen wirksam werden. Folge den Anweisungen, um einige Slash-Befehle zu erstellen, wie in der Abbildung unten gezeigt:
Slash-Befehle mit Node.js konfigurieren
Sobald du die notwendigen Slash-Befehle erstellt hast, musst du deine Node.js-Anwendung so anpassen, dass sie auf diese Befehle reagiert.
Beginnen wir mit dem Testen des /operation_status Befehls. Richte einen Listener für Ereignisse ein, die den Befehl /operation_status enthalten, indem du den folgenden Code in deine app.js-Datei einfügst:
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}!`);
})();Im obigen Code liegt der Schwerpunkt auf der Funktion app.command(), die ähnlich wie ein Ereignis-Listener in JavaScript funktioniert. Du gibst den Befehl an, auf den du hören willst, und erstellst dann eine asynchrone Callback-Funktion, um die gewünschte Aktion zu definieren. Diese Funktion benötigt drei Parameter:
command: Enthält die Details des Schrägstrich-Befehls, den der Benutzer gesendet hat.ack: Bestätigt den Empfang des Slash-Befehls.say: Sendet eine Nachricht zurück an den Slack-Kanal.
Mit dem obigen Code wird der Befehl /operation_status in Slack die Nachricht erzeugen: „Wooah! Es funktioniert!“
Fügen wir nun die Befehlszuhörer für alle Slash-Befehle hinzu, die du erstellt hast:
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.
});Deine Anwendung ist jetzt bereit, auf die Slack-Slash-Befehle zu hören. Es ist Zeit, die Aktionen hinzuzufügen, die jeder Befehl auslösen wird.
Slash-Befehle mit der Kinsta-API implementieren
Deine Anwendung wird auf jeden Slash-Befehl mit einem Aufruf der Kinsta-API reagieren und dann das Ergebnis dieser Aktion an Slack zurückgeben. Um die Kinsta-API zu nutzen, musst du ein Konto mit mindestens einer WordPress-Website, -Anwendung oder -Datenbank in MyKinsta haben. Außerdem musst du einen API-Schlüssel erstellen, um dich zu authentifizieren und über die API auf dein Konto zuzugreifen.
So erstellst du einen Kinsta-API-Schlüssel
Um einen API-Schlüssel zu erstellen:
- Gehe zu deinem MyKinsta-Dashboard.
- Navigiere zur Seite mit den API-Schlüsseln (Dein Name > Unternehmenseinstellungen > API-Schlüssel).
- Klicke auf API-Schlüssel erstellen.
- Wähle ein Ablaufdatum oder lege ein benutzerdefiniertes Startdatum und die Anzahl der Stunden fest, nach denen der Schlüssel abläuft.
- Gib dem Schlüssel einen eindeutigen Namen.
- Klicke auf Erzeugen.
Wenn du einen API-Schlüssel erstellt hast, kopiere ihn und bewahre ihn an einem sicheren Ort auf, da ihn nur dann du sehen kannst. Für dieses Projekt speicherst du ihn in deiner .env-Datei als KINSTA_API_KEY.
Mit der Kinsta-API in Node.js interagieren
Die Interaktion mit der Kinsta-API kann mit einer Reihe von Node.js-Bibliotheken erfolgen, darunter Axios. In diesem Tutorial entscheiden wir uns jedoch für die JavaScript-Methode fetch(), die jetzt in den neuesten Node.js-Versionen unterstützt wird und effizient funktioniert.
Für diesen Slackbot werden viele API-Anfragen gestellt, darunter GET- und POST-Anfragen. Um Wiederholungen zu vermeiden, solltest du die API-URL und die Header in Variablen speichern, damit dein Code einfach zu pflegen und zu lesen ist:
// 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}`,
};Bevor du mit der Codierung der Antwort deiner Anwendung auf jeden Slash-Befehl beginnst, solltest du deine Kinsta-Firmen-ID kopieren und sie in der .env-Datei als KINSTA_COMPANY_ID speichern. Sie wird benötigt, um deine Standortliste abzurufen.
Implementierung des Slash-Befehls Environment ID
Wenn du den Slash-Befehl /environment_id verwendest, wird jeder Wert, der nach dem Befehl angegeben wird, abgerufen und in deinem Node.js-Server verwendet. Für diesen Befehl wurde ein Hinweis hinzugefügt, der anzeigt, dass er einen Parameter erwartet: die [Site name].
Jede Website auf MyKinsta hat einen eindeutigen Site-Namen, aber es gibt keinen direkten Endpunkt, um die Umgebungs-ID einer Website über ihren Namen abzufragen. Daher musst du zunächst eine Anfrage für alle Websites deines Unternehmenskontos stellen und dann die Methode find() verwenden, um die Website zu finden, dessen Name dem mit dem Slash-Befehl übergebenen Namen entspricht.
Zu diesem Zweck werden zwei Anfragen gestellt. Zuerst erhältst du die ID der Website und dann stellst du eine weitere Anfrage an den Endpunkt /environments, um die zu dieser Website gehörende Umgebungs-ID abzurufen.
Um den Code übersichtlich zu halten und die Wartung zu vereinfachen, wird jede Anfrage unabhängig gestellt. Das bedeutet, dass es einzelne Funktionen für diese Anfragen gibt, die dann im Command Listener aufgerufen werden.
Beginnen wir damit, die Liste all deiner Websites abzurufen:
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;
}Der obige Code gibt ein Array mit allen Websites zurück. Im /environment_id Command Listener erhältst du die Antwort und speicherst sie in einer Variablen. Dann suchst du mit der Methode find() nach einer Website, deren Name mit dem von Slack übergebenen Namen übereinstimmt. Die Informationen aus Slack werden in command.text gespeichert.
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
}
});Jetzt, wo du die Website hast, benutze ihre ID, um die Umgebungs-ID abzurufen. Ähnlich wie bei der Abfrage einer Liste von Websites erstellst du eine eigene Funktion, die eine HTTP-Anfrage an den Endpunkt /environments stellt:
async function getEnvironmentId(siteId) {
const resp = await fetch(`${KinstaAPIUrl}/sites/${siteId}/environments`, {
method: 'GET',
headers: getHeaders,
});
const data = await resp.json();
return data;
}Der obige Code erwartet, dass die Website-ID als Argument übergeben wird, wenn diese Funktion im /environment_id command listener aufgerufen wird. Wenn du die ID erhältst, wird die API-Anfrage gestellt und die Antwort in einer Variablen gespeichert. Anschließend kannst du die Umgebungs-ID mit der Methode say() auf Slack ausgeben:
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}`);
}
}
});Wenn du jetzt Slack öffnest und /environment_id gefolgt von einem gültigen Websitenamen wie /environment_id fashionstored eingibst, erhältst du eine Antwort, die wie folgt aussieht:
Implementierung von Site Tools (Site Cache löschen, PHP Engine neu starten) Slash-Befehl
Zwei Aufgaben, die du ganz einfach über die API ausführen kannst, ohne zu MyKinsta navigieren zu müssen, sind die Site-Tool-Vorgänge Clear Site Cache und Restart PHP Engine.
Um einen der Website-Tool-Vorgänge durchzuführen, brauchst du nur die Umgebungs-ID. Diese ID wird verwendet, um eine POST-Anfrage an /sites/tools/clear-cache bzw. /sites/tools/restart-php zu stellen. Wie zuvor führst du die API-Anfrage selbstständig aus und gibst die Antwort zurück:
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;
}Als Nächstes erstellst du in Slack Command Listener für beide Vorgänge. Diese Listener werden so konfiguriert, dass sie immer dann ausgelöst werden, wenn der jeweilige Befehl verwendet wird:
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}`
);
}
});Im obigen Code werden die von den API-Anfragen abgerufenen Daten verwendet, um die Antwort zu erstellen, die an Slack zurückgeschickt wird. Die Antwort enthält Informationen über den Vorgang, wie z. B. die Nachricht und die Vorgangs-ID.
Wenn du diese Slash-Befehle und die dazugehörigen Listener implementierst, kannst du deinen Slackbot nahtlos mit der Kinsta-API interagieren lassen und so den Cache und die PHP-Engine deiner Website direkt von Slack aus verwalten.
Implementierung eines Schrägstrichbefehls für den Betriebsstatus
Es wäre auch gut, wenn du den Status deiner Operationen von Slack aus abrufen könntest. Dazu verwendest du neben operation_id auch den Endpunkt /operations. Wie zuvor erstellst du eine Funktion, die diese Anfrage bearbeitet und die Antwort auf die Anfrage zurückgibt:
async function CheckOperationStatus(operationId) {
const resp = await fetch(`${KinstaAPIUrl}/operations/${operationId}`, {
method: 'GET',
headers: getHeaders,
});
const data = await resp.json();
return data;
}Definieren wir den Command Listener, um die Anfrage auszulösen und die operation ID zu übergeben, die über Slack gesendet wird:
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}`);
}
});Wenn du nun den Befehl /operation_status slash mit einem beliebigen gültigen operation ID verwendest, erhältst du den Status der ID über Slack zurück.
Zusätzlich zu den Befehlen, die du bereits mit der Kinsta-API implementiert hast, gibt es weitere Befehle, die integriert werden können, sowie zusätzliche Ereignisse, die vom Slackbot verarbeitet werden können. Zum Beispiel kann der Slackbot reagieren, wenn er mit dem Symbol @ erwähnt oder getaggt wird.
Um diese Funktion zu aktivieren, musst du die notwendigen Ereignisse in Slack abonnieren. Statt der Methode app.command() verwendest du die Methode app.message(), die die beiden Parameter command und say benötigt.
Hier ist ein Beispiel dafür, wie du das erreichen kannst:
app.message("hey", async ({ command, say }) => {
say("Woah! It works!");
});Nachdem du deinen Slackbot erstellt hast, stellst du vielleicht fest, dass du keine Nachrichten an ihn senden kannst. Wenn du in Slack unter der Registerkarte „Apps“ zum Bot navigierst, kann es sein, dass du eine Meldung erhältst, die besagt: „Das Senden von Nachrichten an diese Anwendung wurde deaktiviert“ Aber keine Sorge, wir können das ganz einfach beheben!
Um das Senden von Nachrichten zu aktivieren, befolge diese Schritte:
- Klicke auf die Menüoption App Home in der linken Seitenleiste.
- Auf dieser Seite kannst du alle Einstellungen für deinen Bot verwalten. Scrolle nach unten, bis du das Kontrollkästchen „Slash-Befehle und Nachrichten von der Registerkarte Nachrichten aus senden können“ findest.
- Aktiviere das Kästchen, um diese Funktion zu aktivieren.
Wenn du diese Änderungen vorgenommen hast, musst du unbedingt deine Slack-Anwendung neu laden, damit die Updates übernommen werden. Wenn du einen Mac verwendest, kannst du Slack mit CMD + R neu laden. PC-Nutzer können dies mit STRG + R tun.
Jetzt kannst du Nachrichten an deinen Bot senden! In der Slack-Anwendung solltest du die Kinsta-Bot-Anwendung direkt unter dem Abschnitt Deine Anwendungen sehen. Klicke darauf, um mit dem Senden von Nachrichten zu beginnen. Du kannst jeden deiner konfigurierten Slash-Befehle ausprobieren, und sie sollten einwandfrei funktionieren. Genieße die nahtlose Interaktion mit deinem Slackbot!
Der vollständige Quellcode für dieses Projekt ist auf GitHub verfügbar.
Bereitstellen deiner Node.js-Anwendung auf Kinsta
Wenn du deinen Node.js-Server gebaut hast, ist es wichtig, dass du ihn bereitstellst, damit dein Slackbot immer verfügbar ist, auch wenn du deine lokale Entwicklung stoppst. Wenn dein Code bei den Git-Anbietern Bitbucket, GitHub oder GitLab gehostet wird, kannst du ihn auf der Anwendungs-Hosting-Plattform von Kinsta bereitstellen.
Befolge diese Schritte, um dein Repository auf Kinsta bereitzustellen:
- Melde dich in deinem Kinsta-Konto auf dem MyKinsta-Dashboard an.
- Klicke auf Dienst hinzufügen.
- Wähle Anwendung aus dem Dropdown-Menü.
- Wähle im erscheinenden Modal das Repository aus, das du bereitstellen möchtest. Wenn du mehrere Zweige hast, kannst du den gewünschten Zweig auswählen und einen Namen für deine Anwendung vergeben.
- Wähle einen der verfügbaren Rechenzentrumsstandorte aus. Kinsta erkennt und installiert die Abhängigkeiten deiner Anwendung aus der package.json, erstellt sie dann und stellt sie bereit.
Schließlich ist es nicht sicher, API-Schlüssel an öffentliche Hosts wie deinen Git-Provider weiterzugeben. Wenn du auf Kinsta hostest, kannst du sie als Umgebungsvariablen hinzufügen, indem du denselben Variablennamen und -wert verwendest, den du in der .env-Datei deiner Entwicklung angegeben hast.
Sobald du die Bereitstellung deiner Anwendung initiierst, beginnt der Prozess und ist normalerweise innerhalb weniger Minuten abgeschlossen. Wenn Probleme mit deinen Node.js-Konfigurationen die Bereitstellung beeinträchtigen, kannst du auf der Registerkarte Bereitstellungseinstellungen ein Node.js-Buildpack hinzufügen.
Zusammenfassung
In diesem Artikel hast du gelernt, wie du eine Node.js-Anwendung erstellst, die Slack mit der Kinsta-API verbindet, und wie du diese Anwendung bei Kinsta bereitstellst.
Mit Slackbots und der Kinsta-API kannst du deine bei Kinsta gehosteten Dienste leichter überwachen und verwalten. Stell dir aufbauend auf den Grundlagen dieses Tutorials vor, was du mit einem Slackbot und der API alles machen kannst. Denke an komplexere Befehle, die Vorgänge wie das Klonen von WordPress-Websites und die Erstellung von Websites direkt von Slack aus durchführen.
Wie nutzt du die Kinsta-API? Welche Funktionen würdest du gerne als Nächstes hinzufügen/offenlegen?
Schreibe einen Kommentar