Im Laufe der Jahre wurden unsere Dienste bei Kinsta immer manuell über das MyKinsta-Dashboard bedient. Doch mit der Einführung der Kinsta-API und der laufenden Veröffentlichung neuer API-Endpunkte kannst du dein Spiel verbessern, indem du eine personalisierte Methode zur Nutzung der Kinsta-Dienste entwickelst. Eine solche Methode ist die Entwicklung eines Slackbots zur Überwachung und Verwaltung von Aktivitäten wie der Erstellung von Websites.
Was du baust
In diesem Lernprogramm wird erklärt, wie du einen Slackbot (oder eine Slack-Anwendung) entwickelst, der mit der Kinsta-API interagiert, um Informationen abzurufen und sie als Echtzeitnachrichten an einen bestimmten Slack-Kanal zu senden, indem du die Slack-API Incoming Webhooks verwendest.
Zu diesem Zweck erstellst du eine Node.js-Anwendung mit dem Express-Framework, um eine Benutzeroberfläche für die Erstellung von WordPress-Sites zu erstellen und sie in die Kinsta-API zu integrieren. Die Anwendung verwendet ein Formular, um die Konfigurationsdaten deiner WordPress-Site zu erfassen, und sendet dann eine Echtzeitaktualisierung der Site-Informationen und Informationen darüber, wie du den Betriebsstatus überprüfen kannst, an den angegebenen Slack-Kanal.
Voraussetzungen
Um an diesem Projekt mitzuarbeiten, solltest du folgende Voraussetzungen mitbringen:
- Grundkenntnisse in JavaScript und Node.js
- Node.js Version 12 oder höher
- npm (Node Package Manager) auf deinem Computer installiert haben
- Einen Slack-Arbeitsbereich
Einrichten der Entwicklungsumgebung
Um loszulegen, 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 Befehl npm init -y ausgeführt hast, wird im Verzeichnis deines Projekts eine neue package.json-Datei mit Standardwerten erstellt. Diese Datei enthält wichtige Informationen über dein Projekt und seine Abhängigkeiten.
Als nächstes installierst du die notwendigen Abhängigkeiten für dein Projekt. Die folgenden Abhängigkeiten sind unerlässlich:
- ejs: EJS (Embedded JavaScript) ist eine Templating-Engine, mit der du dynamische HTML-Inhalte mit JavaScript erzeugen kannst.
- express: Express ist ein schnelles und minimalistisches Webanwendungs-Framework für Node.js. Es vereinfacht die Entwicklung von Webanwendungen und APIs, indem es wichtige Funktionen wie Routing, Middleware-Unterstützung und die Verarbeitung von HTTP-Anfragen und -Antworten bietet.
- express-ejs-layouts: Express EJS-Layouts ist eine Erweiterung für Express, die die Verwendung von Layouts oder Vorlagen ermöglicht, um eine einheitliche Struktur über mehrere Ansichten hinweg zu erhalten.
Um diese Abhängigkeiten zu installieren, führe den folgenden Befehl aus:
npm install ejs express express-ejs-layoutsAußerdem musst du die folgenden Abhängigkeiten installieren, damit du dein Node.js-Projekt leichter bauen und testen kannst:
- nodemon: Ein wertvolles Tool, das deine Node.js-Anwendung automatisch neu startet, wenn sich Dateien im Verzeichnis ändern, und so für einen reibungslosen Entwicklungsablauf sorgt.
- dotenv: Dieses Zero-Dependency-Modul spielt eine wichtige Rolle beim Laden von Umgebungsvariablen aus einer .env-Datei.
Um diese Dev-Abhängigkeiten zu installieren, führe den folgenden Befehl aus:
npm install -D nodemon dotenvSobald deine package.json initialisiert ist und alle Abhängigkeiten installiert sind, erstelle eine neue Datei, z.B. app.js.
touch app.jsHier ist ein Standard-Setup für deine app.js-Datei, bei dem du die notwendigen Module importierst und festlegst, dass sie auf einem bestimmten Port läuft:
// Import required modules
const express = require('express');
const app = express();
// Set up your routes and middleware here
// ...
// Start the server to listen on the specified port
app.listen(process.env.PORT || 3000, () => {
console.log(`Server is running on port ${process.env.PORT || 3000}`);
});Um deine Node.js-Anwendung zu starten, führe den Befehl aus:
node app.jsEine solche Anwendung zu starten, bedeutet jedoch, dass du sie jedes Mal neu starten musst, wenn du Änderungen an deinem Projekt vornimmst. Um diese Unannehmlichkeit zu umgehen, kannst du nodemon verwenden, das du bereits installiert hast. Konfiguriere sie in deiner package.json Datei, indem du einen Skriptbefehl erstellst:
"scripts": {
"dev": "nodemon app.js"
},Führe nun deine Node.js-Anwendung mit automatischen Neustarts aus, indem du den folgenden Befehl verwendest:
npm run devErste Schritte mit Express und EJS Templating
In diesem Leitfaden erstellst du eine Node.js-Anwendung, die Inhalte im Browser anzeigt. Dazu verwendest du express.js als Web-Framework und EJS (Embedded JavaScript) als Templating-Engine.
Um EJS als View-Engine festzulegen, fügst du die folgende Zeile in deine app.js-Datei ein. Dadurch wird es möglich, .ejs Dateien auszuführen:
// Use EJS as the view engine
app.set('view engine', 'ejs');Jetzt, wo Express mit EJS konfiguriert ist, definierst du deine Routen. In Webanwendungen legen Routen fest, wie die Anwendung auf verschiedene HTTP-Anfragen (z. B. GET oder POST) reagiert und welche Aktionen ausgeführt werden sollen, wenn eine bestimmte URL aufgerufen wird.
Erstelle zum Beispiel eine Route, die eine bestimmte Seite lädt, wenn ein Nutzer zur Indexseite (/) navigiert. Dazu verwendest du die GET-Anforderungsmethode.
// Define a route for the homepage
app.get('/', (req, res) => {
// Here, you can specify what to do when someone accesses the homepage
// For example, render an EJS template or send some HTML content
});Im obigen Code führt der Server die als zweiten Parameter angegebene Callback-Funktion aus, wenn ein Nutzer auf den Index deiner Anwendung zugreift. In dieser Callback-Funktion kannst du die Logik zum Rendern einer EJS-Vorlage oder zum Senden von HTML-Inhalten, die auf der Homepage angezeigt werden sollen, verarbeiten.
Du kannst die Methode res.render() verwenden, um eine EJS-Vorlage zu rendern, oder res.send(), um einfache HTML-Inhalte zu senden.
app.get('/', (req, res) => {
res.send('Hello World');
});Wenn du deine Anwendung startest, wird „Hello World“ auf der Indexseite angezeigt.
EJS-Vorlagen erstellen
Dieses Tutorial konzentriert sich auf die Logik und enthält Starterdateien, damit du dich nicht um die Erstellung von Vorlagen kümmern musst. Befolge diese Schritte, um loszulegen:
- Rufe die Vorlage auf GitHub auf, um ein neues Repository zu erstellen.
- Aktiviere die Option Alle Zweige bei der Repository-Erstellung einbeziehen.
- Sobald das Repository erstellt ist, klone das Projekt mit Git auf deinen Computer.
- Um auf den Startcode zuzugreifen, wechsle in deinem lokalen Repository zum Zweig starter-files.
Im Startcode gibt es zwei Hauptordner: public und views. Der Ordner public enthält alle statischen Elemente (CSS-Dateien und Bilder). Sie werden der Vorlage als statische Dateien hinzugefügt:
// Static files
app.use(express.static('/public'));
app.use('/css', express.static(__dirname + '/public/css'));
app.use('/images', express.static(__dirname + '/public/images'));Im Ordner views findest du die Datei layout.ejs und zwei Ordner: pages und partials. Die Datei layout.ejs enthält das allgemeine Layout des Projekts, damit du nicht für alle Seiten einen wiederkehrenden Code verwenden musst. Importiere die Bibliothek express-ejs-layouts in die Datei app.js und konfiguriere sie dann:
// Import
const expressEjsLayouts = require('express-ejs-layouts');
// Configure
app.use(expressEjsLayouts);Der Ordner pages enthält die Routendateien (index.ejs und operation.ejs), während der Ordner partials Komponenten enthält (header.ejs und footer.ejs). Füge sie wie folgt zum Layout hinzu:
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<link rel="icon" href="/images/favicon.ico" />
<link rel="stylesheet" href="/css/index.css" />
<title>Site Builder</title>
</head>
<body>
<div class="app-container">
<%- include('partials/header') %>
<div class="container"><%- body %></div>
<%- include('partials/footer') %>
</div>
</body>
</html>Wenn du deine Node.js-Anwendung startest, wird die Benutzeroberfläche geladen, aber du musst dieser Anwendung eine Logik hinzufügen, um die Formulardaten an die Kinsta-API zu senden und Informationen über die Website an Slack zu senden, wenn der Vorgang beginnt.
Erste Schritte mit Slack Incoming Webhooks
Slack Incoming Webhooks bieten eine einfache Möglichkeit, Nachrichten von externen Anwendungen an Slack zu senden. Um Slack Incoming Webhooks zu nutzen, erstellst und konfigurierst du eine Slack-Anwendung und kopierst dann deine Webhook-URL, um Nachrichten programmatisch an Slack zu senden.
Einrichten einer Slack-Anwendung und Abrufen der Webhook-URL
Erstelle eine neue Slack-Anwendung, indem du diese Schritte ausführst:
- Navigiere zum Slack API Dashboard.
- Klicke auf die Schaltfläche Neue App erstellen, woraufhin sich ein Modal öffnet.
- Wähle die Option Von Grund auf neu, um deine Anwendung von Grund auf zu erstellen.
- Gib einen Namen für deine Slack-Anwendung ein, z. B. Kinsta Bot.
- Wähle dann den Arbeitsbereich aus, in dem du die Anwendung installieren möchtest, und klicke auf die Schaltfläche Anwendung erstellen.
Sobald deine Slack-Anwendung erstellt ist, kannst du eingehende Webhooks aktivieren, indem du zu Funktionen navigierst und eingehende Webhooks auswählst. Schalte den Schalter um, um eingehende Webhooks für deine Anwendung zu aktivieren.
Scrolle runter zum Abschnitt Webhook-URLs für deinen Arbeitsbereich und klicke auf Neuen Webhook zum Arbeitsbereich hinzufügen. Du wirst aufgefordert, einen Kanal auszuwählen, über den die Nachrichten gesendet werden sollen. Wähle den gewünschten Kanal und klicke auf Autorisieren.
Nach der Autorisierung erhältst du eine Webhook-URL für den ausgewählten Kanal. Diese URL verwendest du, um Nachrichten programmgesteuert an Slack zu senden. So sieht eine Webhook-URL aus:
https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXXXXXXDieser Webhook ist für einen einzigen Nutzer und einen einzigen Kanal bestimmt. Bewahre ihn sicher auf, denn er dient als Authentifizierungs-Token für deine Anwendung. Du kannst die eindeutigen Codes nach /services/ in deiner .env-Datei speichern. Du wirst außerdem aufgefordert, die Anwendung in deinem Arbeitsbereich neu zu installieren, damit die Änderungen wirksam werden.
Nachrichten mit Node.js und der Kinsta-API an Slack senden
Jetzt, da die Schnittstelle deiner Node.js-Anwendung eingerichtet und der Slackbot erfolgreich erstellt wurde (zusammen mit deiner WebHook-URL), ist es an der Zeit, sich um die Logik zu kümmern.
Formulardaten in Node.js abrufen
Auf der Index-Seite gibt es ein Formular, das Daten an die Kinsta-API sendet, um eine neue WordPress-Seite zu erstellen. Damit das funktioniert, musst du eine POST-Anfrage von der Index-Seite erstellen. Achte darauf, dass dein Formular eine Methode POST hat und die Eingabefelder ein name Attribut haben, das in der app.js Datei verwendet wird.
app.post('/', (req, res) => {
// Perform the desired operation with the form data
});Um Daten aus einem Formular in Node.js abzurufen, musst du die folgende Middleware verwenden:
app.use(express.json());
app.use(express.urlencoded({ extended: true }));Jetzt kannst du mit req.body.[form field name] auf deine Formularwerte zugreifen. Unter req.body.displayName findest du zum Beispiel den Anzeigenamen, den du über das Formular eingegeben hast. Lass uns die gesamten Formulardaten protokollieren:
app.post('/', (req, res) => {
console.log(req.body);
});Wenn du deinen Code ausführst, werden die Formulardaten angezeigt, nachdem du das Formular ausgefüllt und auf die Schaltfläche Senden geklickt hast.
Website-Erstellung mit der Kinsta-API in Node.js
Um eine WordPress-Website mit der Kinsta-API in Node.js zu erstellen, kannst du die Methode fetch() verwenden, die jetzt in den neuesten Node.js-Versionen unterstützt wird und effizient funktioniert.
Um eine Operation mit der Kinsta-API durchzuführen, musst du einen API-Schlüssel generieren. So generierst du einen API-Schlüssel:
- Gehe zu deinem MyKinsta-Dashboard.
- Navigiere zur Seite mit den API-Schlüsseln (Dein Name > Unternehmenseinstellungen > API-Schlüssel).
- Klicke auf API-Schlüssel generieren.
- 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 Generieren.
Kopiere den generierten API-Schlüssel und bewahre ihn sicher auf, da er nur in diesem Moment sichtbar ist. Für dieses Projekt erstellst du eine .env-Datei in deinem Stammverzeichnis und speicherst den API-Schlüssel als KINSTA_API_KEY.
Um eine WordPress-Site mit der Kinsta-API zu erstellen, brauchst du außerdem deine Unternehmens-ID (die du in MyKinsta unter Unternehmen > Rechnungsdetails > Unternehmens-ID findest). Speichere diese ID auch in der .envi-Datei, damit du über process.env auf diese Umgebungsvariablen zugreifen kannst. Um diese Funktion zu aktivieren, musst du die Abhängigkeit dotenv am Anfang deiner app.js-Datei wie folgt konfigurieren:
require('dotenv').config();Um mit der Erstellung einer WordPress-Site über die Kinsta-API fortzufahren, sende eine POST-Anfrage an den /sites endpunkt und gib die erforderlichen Daten im req.body Objekt an:
const KinstaAPIUrl = 'https://api.kinsta.com/v2';
app.post('/', (req, res) => {
const createSite = async () => {
const resp = await fetch(`${KinstaAPIUrl}/sites`, {
method: 'POST',
headers: {
'Content-Type': 'application/json',
Authorization: `Bearer ${process.env.REACT_APP_KINSTA_API_KEY}`,
},
body: JSON.stringify({
company: process.env.REACT_APP_KINSTA_COMPANY_ID,
display_name: req.body.displayName,
region: req.body.location,
install_mode: 'new',
is_subdomain_multisite: false,
admin_email: req.body.email,
admin_password: req.body.password,
admin_user: req.body.username,
is_multisite: false,
site_title: req.body.siteTitle,
woocommerce: false,
wordpressseo: false,
wp_language: 'en_US',
}),
});
const data = await resp.json();
console.log(data);
};
createSite();
});Wenn du den obigen Code ausführst, erstellst du eine neue WordPress-Website mit der Kinsta-API. Aber das ist nicht das Hauptziel. Das Ziel ist es, eine Nachricht an Slack zu senden, die Informationen über die Website enthält, wenn die Erstellung der Website erfolgreich war.
Sende eine Nachricht an Slack mit der eingehenden Webhook-URL
Dazu erstellst du eine If-Anweisung, um den Antwortstatus der API-Anfrage zu überprüfen. Wenn sie 202 lautet, bedeutet das, dass die Website-Erstellung begonnen hat und du eine Nachricht mit der eingehenden Webhooks-URL an Slack senden kannst. Um dies zu erreichen, kannst du deine bevorzugte HTTP-Anforderungsbibliothek (z. B. Axios) oder Methode verwenden, um eine POST-Anforderung an Slack zu senden. Wir verwenden die Methode fetch():
if (data.status === 202) {
fetch(
`https://hooks.slack.com/services/${process.env.SLACK_WEBHOOK_ID}`,
{
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
body: JSON.stringify({
text: 'Hello, world.',
}),
}
);
}Führe den obigen Code aus und fülle das Formular zur Erstellung einer Website aus. Wenn der Vorgang erfolgreich ist, wird sofort eine Nachricht an Slack gesendet.
Slack-Nachrichten anpassen
Das obige Beispiel sendet eine einfache Textnachricht, aber Slack Incoming Webhooks unterstützen viel mehr als einfachen Text. Du kannst deine Nachrichten so anpassen, dass sie Anhänge, Links, Bilder, Schaltflächen und mehr enthalten.
Eine Möglichkeit, wie du Slack-Nachrichten anpassen kannst, ist die Verwendung des Slack Block Kit Builders. Das Block Kit ist ein von Slack bereitgestelltes UI-Framework, mit dem du umfangreiche und interaktive Nachrichten mit verschiedenen Inhaltselementen erstellen kannst.
Für diesen Leitfaden haben wir einen Block mit dem Block Kit Builder erstellt, um die Nachricht richtig zu formatieren und einige Werte aus dem Formular und der Antwort auf die Website-Erstellung hinzuzufügen:
const message = {
blocks: [
{
type: 'section',
text: {
type: 'mrkdwn',
text: `Hello, your new site (${req.body.displayName}) has started building. It takes minutes to build. You can check the operation status intermittently via https://site-builder-nodejs-xvsph.kinsta.app/operation/${req.body.displayName}/${data.operation_id}.`,
},
},
{
type: 'divider',
},
{
type: 'section',
text: {
type: 'mrkdwn',
text: "_Here are your site's details:_",
},
},
{
type: 'section',
text: {
type: 'mrkdwn',
text: `1. *Site URL:* http://${req.body.displayName}.kinsta.cloud/n2. *WP Admin URL:* http://${req.body.displayName}.kinsta.cloud/wp-admin/`,
},
},
],
};In diesem Code erstellst du ein Nachrichtenobjekt, das ein Array von Blöcken enthält. Jeder Block steht für einen bestimmten Abschnitt der Slack-Nachricht und kann verschiedene Arten von Inhalten enthalten.
- Abschnittsblock: Dieser Blocktyp wird verwendet, um einen Textabschnitt anzuzeigen. Du verwendest das
type: 'section', um anzuzeigen, dass es sich um einen Abschnittsblock handelt. Innerhalb des Abschnittsblocks wird die Eigenschaft text mittype: 'mrkdwn'verwendet, um anzugeben, dass der Textinhalt im Markdown-Format interpretiert werden soll. Der eigentliche Textinhalt wird in der text-Eigenschaft angegeben, und wir verwenden Vorlagenliterale, um dynamische Werte aus dem Formular und der Antwort auf die Website-Erstellung einzubinden, wiereq.body.displayNameunddata.operation_id. - Divider Block: Dieser Blocktyp wird verwendet, um Abschnitte der Nachricht durch eine horizontale Linie zu trennen. Wir verwenden
type: 'divider', um den Divider Block zu erstellen.
Wenn diese Nachricht mit dem Incoming Webhook an Slack gesendet wird, erzeugt sie eine visuell ansprechende und informative Nachricht in deinem Slack-Kanal. Die Nachricht enthält dynamische Werte aus dem Formular (z. B. den Namen der Website) und Informationen aus der Antwort auf die Website-Erstellung, was sie zu einer sehr individuellen und personalisierten Nachricht macht.
Um diese individuelle Nachricht zu versenden, ersetze das Objekt im Body der fetch() durch den Inhalt der Nachrichtenvariable:
if (data.status === 202) {
fetch(
`https://hooks.slack.com/services/${process.env.SLACK_WEBHOOK_ID}`,
{
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
body: JSON.stringify(message),
}
);
}
Website-Erstellung mit der Kinsta-API abwickeln
In der an Slack gesendeten Nachricht wird ein Link erstellt, der die ID und den Anzeigenamen der Operation enthält. Du kannst eine neue Route für die Seite Vorgänge erstellen, um diese Daten zu verwenden und den Status des Vorgangs zu überprüfen.
In Express kannst du auf URL-Parameter mit dem Parameter req zugreifen. Um zum Beispiel die Vorgangs-ID zu erhalten, verwendest du req.params.operationId.
const KinstaAPIUrl = 'https://api.kinsta.com/v2';
app.get('/operation/:displayName/:operationId', (req, res) => {
const checkOperation = async () => {
const operationId = req.params.operationId;
const resp = await fetch(`${KinstaAPIUrl}/operations/${operationId}`, {
method: 'GET',
headers: {
Authorization: `Bearer ${process.env.REACT_APP_KINSTA_API_KEY}`,
},
});
const data = await resp.json();
res.render('pages/operation', {
operationID: req.params.operationId,
displayName: req.params.displayName,
operationMessage: data.message,
});
};
checkOperation();
});Wenn du mit dem obigen Code auf den Link in Slack klickst, wird eine Anfrage an die Kinsta-API gestellt, um den Betriebsstatus deiner Website zu überprüfen. Aktualisiere die Datei operation.ejs, um dynamische Daten hinzuzufügen:
<div class="container-title">
<h1 class="title">Check Site Operation Status</h1>
<p>
Check the status of your site tools operation via the id. Feel free to copy
the ID and check in few seconds.
</p>
</div>
<div class="form-container">
<div class="input-div">
<input class="form-control" value="<%= operationID %>" readOnly />
</div>
<button class="btn" type="submit" onclick="window.location.reload()">
Refresh Operation Status
</button>
</div>
<div class="services">
<div class="details">
<p><%= operationMessage %>..</p>
</div>
</div>
<div class="services">
<p class="description">
If message above indicates that "Operation has successfully finished", use
the links below to access your WP admin and the site itself.
</p>
<div class="details">
<a
href="http://<%= displayName %>.kinsta.cloud/wp-admin/"
target="_blank"
rel="noreferrer"
class="detail-link"
>
<p>Open WordPress admin</p>
<FiExternalLink />
</a>
<a
href="http://<%= displayName %>.kinsta.cloud/"
target="_blank"
rel="noreferrer"
class="detail-link"
>
<p>Open URL</p>
<FiExternalLink />
</a>
</div>
</div>
Als Letztes kannst du die Redirect-Methode verwenden, um zur Vorgangsseite zu navigieren, wenn der Erstellungsprozess einer Website beginnt:
if (data.status === 202) {
fetch(
`https://hooks.slack.com/services/${process.env.SLACK_WEBHOOK_ID}`,
{
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
body: JSON.stringify(message),
}
);
res.redirect(`/operation/${req.body.displayName}/${data.operation_id}`);
}Der vollständige Quellcode für dieses Projekt ist im Hauptzweig dieses GitHub-Repositorys verfügbar.
Bereitstellen deiner Node.js-Anwendung auf Kinsta
Du kannst diese Node.js-Anwendung ganz einfach auf der Anwendungs-Hosting-Plattform von Kinsta bereitstellen. Dazu musst du nur deinen Code zu deinem bevorzugten Git-Anbieter (Bitbucket, GitHub oder GitLab) pushen. Dann befolge diese Schritte:
- 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 in dem 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, baut sie dann und stellt sie bereit.
Schließlich ist es nicht sicher, API-Schlüssel an öffentliche Hosts wie deinen Git-Provider weiterzugeben. Beim Hosten kannst du sie als Umgebungsvariablen hinzufügen, indem du denselben Variablennamen und Wert wie in der .env-Datei angibst.
Sobald du die Bereitstellung deiner Anwendung initiiert hast, wird sie in der Regel innerhalb weniger Minuten erstellt und bereitgestellt. Du erhältst einen Link zu deiner neuen Anwendung, der wie folgt aussieht: https://site-builder-nodejs-xvsph.kinsta.app.
Zusammenfassung
In diesem Leitfaden hast du gelernt, wie du aus einer Node.js-Anwendung mit Hilfe von Incoming Webhooks Nachrichten an Slack sendest und wie du Slack-Nachrichten mit dem Block Kit Builder anpasst.
Die Möglichkeiten von Slack und der Kinsta-API sind vielfältig, und dieses Tutorial ist erst der Anfang. Durch die Integration dieser Tools kannst du einen nahtlosen Workflow schaffen, der dein Team auf dem Laufenden hält und die Produktivität steigert.
Wie nutzt du die Kinsta-API? Welche Funktionen würdest du gerne als Nächstes hinzufügen/offenlegen?
Schreibe einen Kommentar