Bei Kinsta unterstützen wir Tausende von Websites aller Größen. Eine Sache, die sie alle eint, ist die Notwendigkeit einer Datenbank. Unabhängig von der Größe deiner Website enthält deine Datenbank ihre Informationen. Deshalb kannst du mit der Kinsta-API Datenbanken erstellen und verwalten.
Du kannst deine Datenbanken zwar über das MyKinsta-Dashboard verwalten, aber die Kinsta-API bietet dir mehr Flexibilität, wenn du einen programmatischen Ansatz brauchst. Damit kannst du diese Datenbanken erstellen, aktualisieren, löschen und bis zu einem gewissen Grad auch lesen. Der große Vorteil ist jedoch, dass du die Kinsta-API – und damit auch deine Datenbank – in deine bestehenden Tools und Arbeitsabläufe integrieren kannst.
In diesem Beitrag zeige ich dir, wie du mit der Kinsta-API Datenbanken erstellen und verwalten kannst. Außerdem geht es um die Vorteile der API, den Zugang zu den Endpunkten und wie sich dieser Ansatz in deinen Arbeitsablauf einfügt. Beginnen wir mit den Vorteilen und Möglichkeiten.
Die Möglichkeiten der Kinsta-API verstehen
Die Kinsta-API ist der programmatische Weg, um mit deinem Kinsta-Server zu interagieren. Wir bieten viele Endpunkte an, die verschiedene Möglichkeiten zur Verwaltung deiner Websites abdecken, wie z. B. die Arbeit mit deinen Umgebungen, WordPress-Themes und Plugins, Anwendungsmetriken und mehr.
Über die typische CRUD-Architektur kannst du auch auf deine Datenbanken zugreifen:
- Mit einem einzigen Endpunkt kannst du eine neue Datenbank für deine Website erstellen, einen Serverstandort auswählen und Anmeldedaten festlegen.
- Es gibt eine Methode, mit der du alle Datenbanken deines Servers über die Unternehmens-ID abrufen kannst. Von dort aus kannst du eine bestimmte Datenbank und ihre Details über ihre individuelle ID abrufen.
- Mit der API kannst du die Größe und den Anzeigenamen deiner Datenbank ändern. Das kann bei einigen Anwendungen zur Skalierung der Ressourcen hilfreich sein.
- Du kannst eine Datenbank entfernen, wenn du sie nicht mehr brauchst. Das ist ganz einfach und erfolgt mit einem einzigen Befehl.
Insgesamt kannst du diese Endpunkte nutzen, um deinen gesamten Datenbankverwaltungs-Workflow zu rationalisieren. Später werden wir darauf noch genauer eingehen. Zunächst wollen wir besprechen, warum du die Kinsta-API für die Verwaltung deiner Datenbanken nutzen solltest.
Die Vorteile der Verwaltung von Datenbanken über die Kinsta-API
Natürlich würden wir keine eigene API für die Verwaltung deiner Datenbanken anbieten, wenn sie dir nicht ein paar überzeugende Vorteile gegenüber dem MyKinsta-Dashboard bieten würde. Beide können sich in deinen Arbeitsablauf einfügen, aber die Kinsta-API hat ein paar besondere Möglichkeiten, um neue Möglichkeiten zu erschließen.
1. Du kannst deine aktuellen Verwaltungsprozesse rationalisieren
Ein Hauptvorteil der Verwaltung deiner Datenbanken über die Kinsta-API ist, dass du die Schritte, die du normalerweise machen würdest, verschlanken kannst. Mit dem MyKinsta-Dashboard hast du bereits einen effizienten Arbeitsablauf. Jede WordPress-Website bietet dir zum Beispiel über phpMyAdmin Zugriff auf die Datenbank deiner Website:
Damit hast du eine vertraute Oberfläche, um Änderungen vorzunehmen. Für Anwendungen ist der Bildschirm Datenbanken in MyKinsta deine Anlaufstelle:
Mit unseren API-Endpunkten kannst du all diese Schritte jedoch überspringen. Das sollte ein Kinderspiel sein, wenn du andere programmatische Dienste für deine Website betreibst. Die Zeit, die du durch die Automatisierung dieses Workflows sparst, könnte sich auch positiv auf deine Effizienz auswirken.
2. Die Automatisierungsmöglichkeiten sind fast grenzenlos
Wie bei allen Endpunkten der Kinsta-API kannst du Aufgaben automatisieren, für die du sonst auf das MyKinsta-Dashboard zugreifen müsstest. Wir werden später mehr über die Integrationsmöglichkeiten sprechen. Kurz gesagt: Wenn du bereits bestehende Tools und Skripte verwendest, kann die Automatisierung deiner Datenbankverwaltung Teil dieses Prozesses werden.
Du könntest zum Beispiel die Möglichkeit einbauen, eine neue Datenbank zu erstellen, wenn du eine neue Website einrichtest. Du könntest in deinem Code, deinen Tools und Skripten vordefinierte Kriterien festlegen, um Datenbanken automatisch zu löschen. Auch Workflows, die die Skalierung deiner Ressourcen beinhalten, könnten davon profitieren, da du den Ressourcentyp einer Datenbank aktualisieren kannst.
Wie bei der gezielten Rationalisierung wird die Automatisierung deiner Arbeitsabläufe die Zeit (und das Geld), die du für die Datenbankverwaltung aufbringst, weiter verringern.
3. Mögliche Integration mit anderen Tools und Plattformen
APIs bieten im Allgemeinen eine hervorragende Möglichkeit zur Integration mit fast allen anderen verfügbaren Tools und Plattformen, selbst wenn es keine API gibt. Du kannst Dienste wie Zapier oder If This Then That (IFTTT) nutzen, um Tools miteinander zu verbinden, zu denen auch dein Kinsta-Server gehören könnte.
Bei vielen Setups musst du andere Dienste einbeziehen, damit alles reibungslos funktioniert. Denk an deine Pipelines für kontinuierliche Integration und Bereitstellung (CI/CD), die TeamCity, Travis CI oder Buddy verwenden. Die Kinsta-API kann dir als Teil deiner Toolchain helfen, einen kohärenten Workflow von der Entwicklung bis zur Produktion zu schaffen.
In den nächsten Abschnitten werden wir uns mit den verschiedenen Methoden und Anfragen beschäftigen, die dir die Kinsta-API bietet. Am Ende des Beitrags erfährst du, wie du die Informationen, die du abrufst, in einigen Beispielszenarien nutzen kannst.
Was du brauchst, um deine Datenbanken mit der Kinsta-API zu verwalten
Die Verwendung des Endpunkts databases ist genauso einfach wie die Verwendung jedes anderen Endpunkts der Kinsta-API. Wir werden hier nicht auf alle Feinheiten der einzelnen Aktionen oder Arbeitsabläufe eingehen, aber später werden wir das genauer besprechen.
Wenn du auf den Endpunkt databases zugreifen willst, musst du einige Informationen bereithalten, darunter ein gültiges API-Token. Wenn du dieses generierst, kannst du auf die API zugreifen, was für jeden Endpunkt gilt. Zu diesem Zweck haben wir einen Authentifizierungsendpunkt.
Du kannst einen API-Schlüssel auf dem Bildschirm Unternehmenseinstellungen > API-Schlüssel im MyKinsta-Dashboard generieren.
Um auf die meisten Endpunkte zuzugreifen, brauchst du auch deine Unternehmens-ID. Dies ist im Wesentlichen die ID für den Server. Du findest sie in der Symbolleiste deines Browsers, wenn du im MyKinsta-Dashboard angemeldet bist:
Der typische Arbeitsablauf bei der Nutzung eines Kinsta-API-Endpunkts besteht darin, deinen API-Schlüssel zu validieren, die mit der Unternehmens-ID verbundenen Daten abzurufen, die mit der ID der Website verbundenen Daten abzurufen und diese Daten zu verarbeiten. In diesem letzten Schritt musst du die richtigen Parameter für die Anfrage angeben.
Das hängt natürlich davon ab, was du erreichen willst. Im Laufe der Verwaltung deiner Datenbanken werden wir uns mit diesen Parametern beschäftigen.
Erstellen einer neuen Datenbank mit der Kinsta-API
Das Anlegen einer Datenbank ist die aufwändigste aller hier behandelten Anfragen, aber dennoch ein Kinderspiel. Dazu musst du eine Anfrage an POST senden. Damit diese Anfrage gültig ist, sind acht Attribute erforderlich. Dazu gehören der Serverstandort, der Ressourcentyp, der Datenbanktyp und die Datenbankanmeldedaten.
Mit diesen Parametern kannst du deinen API-Schlüssel validieren und deine Datenbank erstellen:
import fetch from 'node-fetch';
async function run() {
const resp = await fetch(
`https://api.kinsta.com/v2/databases`,
{
method: 'POST',
headers: {
'Content-Type': 'application/json',
Authorization: 'Bearer <YOUR_TOKEN_HERE>'
},
body: JSON.stringify({
company_id: '54fb80af-576c-4fdc-ba4f-b596c83f15a1',
location: 'us-central1',
resource_type: 'db1',
display_name: 'test-db',
db_name: 'test-db',
db_password: 'example-password',
db_user: 'example-user',
type: 'postgresql',
version: '15'
})
}
);
const data = await resp.json();
console.log(data);
}
run();
Für jeden Endpunkt erhältst du die angeforderten Daten im JSON-Format:
{
"database": {
"id": "54fb80af-576c-4fdc-ba4f-b596c83f15a1"
}
}
Wenn die Anfrage fehlschlägt, siehst du diese Information in der JSON-Rückgabe:
{
"message": "No or invalid API key provided to the request",
"status": 401,
"data": null
}
Wie bei jeder Anfrage, die du stellst, solltest du darauf achten, dass die Daten, die du sendest und empfängst, sicher sind. Die Validierung deines API-Schlüssels ist eine Möglichkeit, dies zu tun, aber es gibt noch andere wichtige Faktoren:
- Füge keine Informationen wie IDs oder deinen API-Schlüssel fest in deine Anfragen ein. Verwende stattdessen Umgebungsvariablen, um deinen Code fast zu „anonymisieren“.
- Überprüfe regelmäßig die Aktualisierungen der Kinsta-API, da sich die Endpunktdetails ändern können oder modernere Datenschutzmethoden verfügbar sein könnten.
- Das Debugging deiner API-Anfragen kann dich viel Zeit kosten, vor allem bei komplexen Integrationen. Hier sind die zurückgegebenen Antwortcodes deiner Anfrage, deine Kinsta-Fehlerprotokolle und typische Debugging-Tools und -Techniken sehr hilfreich.
Die gute Nachricht ist, dass viele dieser Informationen auf andere Aktionen im Zusammenhang mit dem Endpunkt databases übertragen werden können. Im nächsten Abschnitt geht es darum, wie du sie löschen kannst.
Abrufen und Löschen von bestehenden Datenbanken
Das Abrufen und Löschen deiner Datenbanken dauert nur wenige Sekunden und verwendet einen Großteil des Codes, den du bereits bei der Erstellung der Datenbanken implementiert hast. Bei der Anfrage GET musst du lediglich die Methode in deinem Code angeben:
import fetch from 'node-fetch';
async function run() {
const query = new URLSearchParams({
internal: 'true',
external: 'true'
}).toString();
const id = 'YOUR_id_PARAMETER';
const resp = await fetch(
`https://api.kinsta.com/v2/databases/${id}?${query}`,
{
method: 'GET',
headers: {
Authorization: 'Bearer <YOUR_TOKEN_HERE>'
}
}
);
const data = await resp.text();
console.log(data);
}
run();
Diese gibt eine Liste mit Informationen zu deinen Datenbanken zurück, darunter Angaben zu deinen CPU- und Speichergrenzen, dem internen Hostnamen und Port und vieles mehr:
{
"database": {
"id": "54fb80af-576c-4fdc-ba4f-b596c83f15a1",
"name": "unique-db-name",
"display_name": "firstsite-db",
"status": "ready",
"created_at": 1668697088806,
"memory_limit": 250,
"cpu_limit": 250,
"storage_size": 1000,
"type": "postgresql",
"version": "14",
"cluster": {
"id": "54fb80af-576c-4fdc-ba4f-b596c83f15a1",
"location": "europe-west3",
"display_name": "Frankfurt, Germany Europe"
},
"resource_type_name": "db1",
"internal_hostname": "some-name.dns.svc.cluster.local",
"internal_port": "5432",
"internal_connections": [
{
"id": "54fb80af-576c-4fdc-ba4f-b596c83f15a1",
"type": "appResource"
}
],
"data": {
"db_name": "firstsite-db",
"db_password": "password",
"db_root_password": "password",
"db_user": "username"
},
"external_connection_string": "postgresql://username:password@localhost:31866/firstsite-db",
"external_hostname": "firstsite-db-postgresql.external.kinsta.app",
"external_port": "31866"
}
}
Eine Datenbank zu löschen, ist genauso einfach. Du sendest die Methode DELETE und die ID an den Endpunkt databases:
…
const resp = await fetch(
`https://api.kinsta.com/v2/databases/${id}`,
{
method: 'DELETE',
headers: {
…
Anders als bei der Verwendung des MyKinsta-Dashboards musst du beim Löschen von Datenbanken über die API jedoch Vorsicht walten lassen. Hier bekommst du keine Bestätigungsmeldung oder einen „Puffer“ Daher solltest du eine Fehlerbehandlung oder Überprüfung einbauen, um sicherzustellen, dass du die Datenbank wirklich löschen willst.
Wie die Kinsta-API dir hilft, Datenbanken zu aktualisieren
Wir heben uns Datenbankaktualisierungen bis zum Schluss auf, denn obwohl sie auf den ersten Blick einfach und begrenzt erscheinen, bietet diese Anfrage einige einzigartige Möglichkeiten.
Oberflächlich betrachtet bieten Aktualisierungen nur wenig Spielraum für Änderungen. Die einzigen Parameter, die du ändern kannst, sind der Name der Datenbank und ihr Ressourcentyp:
{
"resource_type": "db1",
"display_name": "test-db"
}
Hier können sich Datenbankaktualisierungen gut in deinen gesamten Entwicklungs- oder Systemmanagement-Workflow einfügen. Die Datenbank könnte zum Beispiel zwischen verschiedenen Zuständen und Umgebungen wechseln. Zu verschiedenen Zeitpunkten könntest du eine Aktualisierung durchführen, die die Datenbank entsprechend den Projektkonventionen, dem Status eines Sprints oder was auch immer du möchtest, umbenennt.
Der Ressourcentyp ist eine einfache Möglichkeit, die Größe und Leistung deiner Datenbank im laufenden Betrieb zu ändern. So kannst du die Datenbank an veränderte Projektvariablen oder sogar an die öffentliche Nachfrage nach deiner Website anpassen. Lass uns im Folgenden mehr darüber sprechen.
Die Bedeutung von resource_type bei der vertikalen Skalierung
Skalierbarkeit ist ein wichtiges Element einer modernen Website, und das sollte auch für deine Website gelten. Aus diesem Grund bietet die Kinsta-API den Parameter resource_type. Wenn es um die vertikale Skalierung geht, könnte dieser Parameter ein wichtiger Bestandteil deiner Strategie sein. Das Beste daran ist, dass es nur eine Zeile braucht, um die Ressourcen deiner Datenbank zu ändern und mehr oder weniger zuzuweisen:
import fetch from 'node-fetch';
async function run() {
const id = 'YOUR_id_PARAMETER';
const resp = await fetch(
`https://api.kinsta.com/v2/databases/${id}`,
{
method: 'PUT',
headers: {
'Content-Type': 'application/json',
Authorization: 'Bearer <YOUR_TOKEN_HERE>'
},
body: JSON.stringify({
resource_type: 'db1',
display_name: 'test-db'
})
}
);
const data = await resp.json();
console.log(data);
}
run();
Du kannst zwischen acht verschiedenen Typen wählen, und im Allgemeinen gilt: Je höher die Zahl, desto mehr Ressourcen kannst du zuweisen – db8 bietet dir also mehr als db1.
Auf diese Weise kannst du die Anzahl der Ressourcen schnell erhöhen oder verringern, je nachdem, was du gerade brauchst.
Wenn du zum Beispiel mehr Datenverkehr hast oder intensivere Datenbankaufgaben durchführen musst, kannst du deine Ressourcen auf eine höhere Ebene erhöhen.
Integration mit anderen Kinsta-API-Endpunkten
Du kannst den Datenbank-Endpunkt zusammen mit anderen Kinsta-API-Endpunkten nutzen, um ein vollwertiges Datenbankmanagementsystem aufzubauen oder die Verwaltung in deine anderen Workflows einzubinden.
Ein großartiger Ansatz ist die Möglichkeit der vertikalen Skalierung aus dem letzten Abschnitt. Es gibt aber noch viele weitere Möglichkeiten, je nach den Bedürfnissen deiner Website:
- Du könntest eine Datenbank erstellen, während du eine neue Anwendung startest. Diese kann alle relevanten Informationen enthalten, z. B. den Standort des Servers und die Anmeldedaten.
- Als Teil deines Bereitstellungsprozesses könntest du den Ressourcentyp der Datenbank auf der Grundlage der zu erwartenden Last aktualisieren.
- Wenn du deine Logdateien und Website-Metriken abrufst, hast du die Möglichkeit, die Datenbankressourcen deiner Website automatisch und programmgesteuert zu skalieren, ohne dass du selbst eingreifen musst.
Damit ist ein wichtiges Element deines Datenbankmanagement-Workflows angesprochen, nämlich die Verwendung der von dir angeforderten Informationen. Das wollen wir im vorletzten Abschnitt untersuchen.
Verwendung von Datenbankinformationen aus der Kinsta-API in deinem Arbeitsablauf
Viele Projekte bestehen aus mehreren Phasen, wie z.B. der anfänglichen Entwicklung, dem Staging, den Tests und der Produktion. Die Verfügbarkeit der Kinsta-API kann dir helfen, viele Aufgaben in Verbindung mit deinen anderen Tools zu erledigen. Das Erstellen und Verwalten von Datenbanken kann ein wichtiges Rädchen in diesem Getriebe sein.
Wenn du zum Beispiel einen neuen Funktionszweig in einem Versionskontrollsystem (VCS) deiner Wahl erstellst, kannst du mit der Kinsta-API einen Prozess zur Erstellung einer neuen Datenbank auslösen.
Hier ist ein vereinfachtes Beispiel dafür, wie du die Erstellung einer Datenbank über die API auslösen kannst:
import fetch from 'node-fetch';
async function createDatabase(databaseName) {
const apiToken = 'your_api_token';
const companyId = 'your_company_id';
const response = await fetch('https://api.kinsta.com/v2/databases', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${apiToken}`
},
body: JSON.stringify({
company_id: companyId,
location: 'us-central1',
resource_type: 'db1',
display_name: databaseName,
db_name: databaseName,
db_password: 'example-password',
db_user: 'example-user',
type: 'postgresql',
version: '15'
})
});
if (response.ok) {
const data = await response.json();
console.log(`Database '${databaseName}' created successfully.`);
console.log('Database details:', data);
} else {
console.error(`Error creating database '${databaseName}':`, response.statusText);
}
}
// Usage example
const featureBranchName = 'feature/new-blog-section';
const databaseName = `db_${featureBranchName}`;
createDatabase(databaseName);
Hier ist ein typisches Beispiel für eine Mehrfachverwendung, bei dem wir eine Funktion zum Erstellen einer Datenbank definieren, die eine POST Anfrage an den databases Endpunkt stellt. Unser Anwendungsbeispiel zeigt den Prozess: Eine Variable enthält den Pfad des Git-Feature-Zweigs, den wir dann als Parameter für die databaseName verwenden. Von dort aus können wir den Erstellungsprozess anhand des dynamischen Datenbanknamens auslösen.
Mit diesem Ansatz zur Automatisierung der Datenbankerstellung kannst du sicherstellen, dass Stages oder Features eine eigene Datenbank erhalten. Das kann die Verwaltung des Entwicklungsworkflows erleichtern, eine saubere Arbeitsgrundlage schaffen und das Risiko von Konflikten verringern.
Integration von Datenbankinformationen in Tools zur Zusammenarbeit
Ein weiterer häufiger und wertvoller Anwendungsfall für die Verwaltung deiner Datenbanken mit der Kinsta-API ist die Bereitstellung von Status-Updates für deine Kollaborationstools wie Slack oder Microsoft Teams. Du könntest z.B. einen separaten Kanal einrichten, in dem nur der Datenbankstatus gepostet wird.
Auf diese Weise kannst du dein Team über den Status und die Verfügbarkeit der Datenbanken auf dem Laufenden halten. Das fördert nicht nur die Kommunikation und Zusammenarbeit, sondern kann auch dazu beitragen, dass du proaktiv auf Fehler und Probleme reagierst.
Diese Art der Integration hat noch viele weitere Vorteile:
- Bessere Sichtbarkeit. Du kannst alle Beteiligten über den Status deiner Datenbanken auf dem Laufenden halten. So ist sichergestellt, dass alle über mögliche Probleme oder anstehende Wartungsarbeiten informiert sind.
- Verbesserte Reaktionsfähigkeit. Du kannst auch die zuständigen Teammitglieder benachrichtigen, wenn eine Datenbank gewartet werden muss. Das ist der direkte Auslöser für die bereits erwähnte Proaktivität.
- Erleichtere die Diskussion. Die zentrale Plattform ermöglicht es dir und deinem Team, Themen rund um die betreffende Datenbank zu diskutieren. Diese gemeinsame Arbeit kann die Fehlerbehebung, den Wissensaustausch und vieles mehr fördern.
- Rationalisierung der Kommunikation. Der automatische Nachrichtenfluss macht manuelle Benachrichtigungen und Aktualisierungen überflüssig.
Die Verknüpfung der Kinsta-API mit dem Authentifizierungsendpunkt eines Tools scheint auf dem Papier kompliziert zu sein, aber in der Praxis braucht es nicht viel:
import fetch from 'node-fetch';
const { IncomingWebhook } = require('@slack/webhook');
// Set up the Slack webhook URL (using an environment variable)
const slackWebhookUrl = process.env.SLACK_WEBHOOK_URL;
const webhook = new IncomingWebhook(slackWebhookUrl);
async function sendSlackNotification(message) {
try {
await webhook.send({
text: message
});
console.log('Slack notification sent successfully.');
} catch (error) {
console.error('Error sending Slack notification:', error);
}
}
async function getDatabases() {
const apiToken = process.env.KINSTA_API_TOKEN;
const companyId = process.env.KINSTA_COMPANY_ID;
const query = new URLSearchParams({
company: companyId,
limit: '10',
offset: '3'
}).toString();
try {
const response = await fetch(`https://api.kinsta.com/v2/databases?${query}`, {
method: 'GET',
headers: {
'Authorization': `Bearer ${apiToken}`
}
});
if (response.ok) {
const data = await response.json();
console.log('Retrieved databases:', data);
// Check the status of each database and send Slack notifications if necessary
data.forEach(database => {
if (database.status !== 'ready') {
const message = `Database '${database.display_name}' is in status '${database.status}'. Please check.`;
sendSlackNotification(message);
}
});
} else {
console.error('Error retrieving databases:', response.statusText);
}
} catch (error) {
console.error('Error retrieving databases:', error);
}
}
// Usage example
getDatabases();
In diesem Codeschnipsel definieren wir eine Funktion, die einen Slack-Webhook verwendet, um Nachrichten an einen Slack-Kanal zu senden. Dann führen wir eine GET Anfrage aus, um eine Liste der Datenbanken abzurufen, die mit unserem Server verbunden sind. Für die Datenbanken, die noch nicht bereit sind, senden wir eine Benachrichtigung an den Slack-Kanal.
Dies sind nur zwei schnelle Möglichkeiten, die Kinsta-API mit anderen Plattformen zu integrieren, um deine Datenbanken zu verwalten. Unabhängig davon kannst du bessere Projektergebnisse und eine höhere Effizienz ansteuern, während du einen besseren Rundum-Service entwickelst.
Zusammenfassung
Die Verwaltung deiner Datenbanken ist ein so wichtiger Aspekt beim Betrieb eines WordPress-Projekts oder einer Anwendung, dass wir dir den Datenbank-Endpunkt in der Kinsta-API zur Verfügung stellen. Damit kannst du deinen Datenbankverwaltungsprozess optimieren und bestimmte Aufgaben automatisieren, für die du sonst das MyKinsta-Dashboard benötigst.
Die Methoden, mit denen du diese Aufgaben erledigst, sind zwar einfach, aber du hast eine Menge Kontrolle über sie. Du kannst zum Beispiel einfach neue Datenbanken einrichten oder löschen, wenn du das möchtest. Es gibt viele kreative Möglichkeiten, diese Anfragen zu nutzen, z. B. für die Skalierung von Ressourcen, die allgemeine Verwaltung von Datenbanken und vieles mehr.
Wir würden gerne wissen, was du über die Erstellung und Verwaltung von Datenbanken mit der Kinsta-API denkst. Teile uns deine Erfahrungen und Erkenntnisse in den Kommentaren unten mit!
Schreibe einen Kommentar