Backups bieten Website-Betreibern ein vertrauensbildendes Sicherheitsnetz für den Fall von Missgeschicken. Nutzer des Managed WordPress Hosting Dienstes von Kinsta profitieren von sechs Arten von Backups: automatische tägliche, optionale stündliche, manuelle, systemgenerierte, herunterladbare und externe Backups, die automatisch an deinen Amazon S3 oder Google Cloud Storage gesendet werden.
Die Verwaltung dieser Backups ist über das MyKinsta-Dashboard ein Kinderspiel. Und jetzt ermöglicht die Kinsta-API die Arbeit mit WordPress-Seiten und deren Backups. Von Agenturen, die mit ihren Dashboards Hunderte von Installationen verwalten, bis hin zu Teams, die Produktivitäts-Tools wie Slack nutzen wollen, kann die Kinsta-API helfen, alles miteinander zu verbinden.
Dieser Leitfaden beschreibt die verschiedenen Backup-Endpunkte, die über die API verfügbar sind, ihr Potenzial und wie du sie nutzen kannst, um Backups in einer Slack-Umgebung zu verwalten.
Die Kinsta-API verstehen
Die Kinsta-API ist ein leistungsstarkes Tool, mit dem du programmatisch mit Kinsta-Diensten wie gehosteten WordPress-Websites interagieren kannst. Sie kann dir helfen, verschiedene Aufgaben im Zusammenhang mit der WordPress-Verwaltung zu automatisieren, z. B. das Erstellen von Websites, das Abrufen von Website-Informationen, das Abrufen des Status einer Website, das Durchsuchen und Wiederherstellen von Backups und vieles mehr.
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 auf dein Konto zuzugreifen.
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.
Nachdem du einen API-Schlüssel generiert hast, kopiere ihn und bewahre ihn an einem sicheren Ort auf (wir empfehlen die Verwendung eines Passwortmanagers), denn dies ist das einzige Mal, dass er innerhalb von MyKinsta sichtbar ist. Du kannst mehrere API-Schlüssel erstellen, die dann auf der Seite API-Schlüssel aufgelistet werden. Wenn du einen API-Schlüssel widerrufen möchtest, klicke auf die Schaltfläche Widerrufen neben dem Namen und dem Ablaufdatum des Schlüssels.
WordPress-Website-Backups mit der Kinsta-API verwalten
Die Kinsta-API hat Endpunkte für diese Backup-bezogenen Vorgänge:
- Manuelle, geplante und vom System generierte Backups auflisten
- Herunterladbare Backups auflisten
- Wiederherstellen eines geplanten, manuellen oder vom System erstellten Backups
Um mit diesen Endpunkten zu interagieren, brauchst du den API-Schlüssel, den du zuvor generiert hast. Wir werden uns diese Endpunkte ansehen und sie später in einen Slackbot integrieren, damit du die Slash-Befehle von Slack zur Interaktion mit der Kinsta-API nutzen kannst.
Wie du mit der Kinsta-API manuelle, geplante und vom System generierte Backups abrufst
Wenn du in deinem MyKinsta-Dashboard zu einer bestimmten WordPress-Website navigierst und auf den Reiter Backups klickst, findest du eine Liste mit täglichen, stündlichen (wenn aktiviert), manuellen und systemgenerierten Backups.
Wenn du nun von einer externen Anwendung oder Plattform aus auf diese Daten zugreifen oder Aktionen ausführen möchtest, vereinfacht unsere API diesen Prozess.
Du kannst Sicherungsdetails wie ID, Name, Typ und Erstellungszeit programmatisch abrufen. Wenn du die API in deinen eigenen Tools verwendest, musst du nicht mehr auf das Dashboard zugreifen, wenn diese Informationen benötigt werden
Um auf diesen Endpunkt zuzugreifen, rufst du die Umgebungs-ID deiner Website programmatisch über den Endpunkt „get site environment“ ab, der Details über die Umgebung deiner Website, einschließlich der ID, zurückgibt:
{
"site": {
"environments": [
{
"id": "54fb80af-576c-4fdc-ba4f-b596c83f15a1",
"name": "first-site",
"display_name": "First site",
"is_blocked": false,
"id_edge_cache": "54fb80af-576c-4fdc-ba4f-b596c83f15a1",
"cdn_cache_id": "54fb80af-576c-4fdc-ba4f-b596c83f15a1",
"is_premium": false,
"domains": [
{
"id": "54fb80af-576c-4fdc-ba4f-b596c83f15a1",
"name": "example.com",
"type": "live"
}
],
"primaryDomain": {
"id": "54fb80af-576c-4fdc-ba4f-b596c83f15a1",
"name": "example.com",
"type": "live"
},
"ssh_connection": {
"ssh_port": "808080",
"ssh_ip": {
"external_ip": "1xx.1xx.1xx.1xx"
}
},
"container_info": {
"id": "54fb80af-576c-4fdc-ba4f-b596c83f15a1",
"php_engine_version": "php8.0"
}
}
]
}
}Wenn du die Umgebungs-ID deiner Website kennst, kannst du eine GET Anfrage an https://api.kinsta.com/v2/sites/environments/${envId}/backups senden, um ein Array mit allen Backups deiner Website abzurufen:
curl -i -X GET \
'https://api.kinsta.com/v2/sites/environments/{env_id}/backups' \
-H 'Authorization: Bearer 'Du erhältst ein Objekt mit einem Array von Backups zurück, das du in deinen Client einschleifen und dessen Daten du manipulieren kannst:
{
"environment": {
"display_name": "MyEnvironment",
"backups": [
{
"id": 123456789,
"name": "mySiteName-1234567890-backupType",
"note": "Daily Auto Backup",
"type": "manual",
"created_at": 1665382600770
}
]
}
}Wie man mit der Kinsta-API ein geplantes, manuelles oder vom System generiertes Backup wiederherstellt
Mit der Kinsta-API kannst du auch ein bestimmtes Backup aus der generierten Liste mit einer POST -Anfrage in einer Umgebung wiederherstellen.
Alles, was du dafür brauchst, sind die Backup-ID, die ID der Zielumgebung und der Umgebungsname des Backups. Mit dieser Aktion musst du auch nicht mehr das MyKinsta-Dashboard für Wiederherstellungsaufgaben aufsuchen.
curl -i -X POST \
'https://api.kinsta.com/v2/sites/environments/{target_env_id}/backups/restore' \
-H 'Authorization: Bearer ' \
-H 'Content-Type: application/json' \
-d '{
"backup_id": 123456789,
"env_display_name_of_backup": "my-env"
}'Die Antwort auf diese Anfrage enthält einen Vorgangsstatus und eine Vorgangs-ID, so dass du den Fortschritt der Wiederherstellung mit unserem Endpunkt für den Vorgangsstatus programmatisch verfolgen kannst:
{
"operation_id": "backups:restore-54fb80af-576c-4fdc-ba4f-b596c83f15a1",
"message": "Restoring a backup to environment in progress",
"status": 202
}Wie du mit der Kinsta-API herunterladbare Backups erhältst
Derzeit gibt es zwar keinen Endpunkt, um herunterladbare Backups zu erstellen, aber du kannst programmatisch auf bestehende herunterladbare Backups und ihre Download-Links zugreifen.
Dazu sendest du eine GET-Anfrage an https://api.kinsta.com/v2/sites/environments/{env_id}/downloadable-backups, um ein Array mit allen herunterladbaren Backups deiner Website abzurufen:
curl -i -X GET \
'https://api.kinsta.com/v2/sites/environments/{env_id}/downloadable-backups' \
-H 'Authorization: Bearer 'Jedes herunterladbare Backup in diesem Array enthält eine ID, einen Erstellungszeitpunkt, einen Download-Link, einen Ablaufzeitpunkt und einen Status, der angibt, ob der Erstellungsprozess noch läuft:
{
"environment": {
"display_name": "MyEnvironment",
"downloadable_backups": [
{
"id": "1915fa3a-7ef4-4766-806d-71104be7deb0",
"created_at": 1665382600770,
"download_link": "https://example.com",
"expires_at": 1665382600770,
"is_generation_in_progress": true
}
]
}
}Wenn du auf den Download-Link klickst, wird die Zip-Datei des Backups heruntergeladen. So kannst du den Link in deine Anwendung einbetten, damit deine Nutzer/innen bequem darauf zugreifen und sie herunterladen können.
Implementierung von Slack Slash-Befehlen zur Verwaltung von Backups mit der Kinsta-API
In einem kürzlich erschienenen Leitfaden wurde beschrieben, wie du einen Slackbot mit Node.js und der Kinsta-API für die Verwaltung von Websites erstellst. Der Leitfaden beschreibt die Erstellung eines Slackbots und die Interaktion mit der Kinsta-API über eine Node.js-Anwendung, die auf unserer Anwendungs-Hosting-Plattform gehostet wird.
Hier konzentrierst du dich auf die Erstellung neuer Slack Slash-Befehle für die drei Backup-Endpunkte. Um hier weiterzukommen, solltest du dir zunächst die frühere Anleitung ansehen, um die Node.js-Anwendung und die Konfiguration deines personalisierten Slackbots zu verstehen.
Danach kannst du unser Startprojekt mit Git klonen:
- Navigiere zu deinem bevorzugten Verzeichnis für die Speicherung deines Codes und führe den folgenden Befehl in deinem Terminal aus:
git clone -b tutorial-1 --single-branch https://github.com/olawanlejoel/SlackBot-KinstaAPI.git - Wechsle in den Projektordner und installiere alle erforderlichen Abhängigkeiten:
cd SlackBot-KinstaAPI npm install
Erstellen von Slash-Befehlen auf Slack für die Handhabung von Backups
Im vorherigen Artikel wurden fünf Slash-Befehle erstellt, die folgende Aufgaben erfüllen:
/site_id [site name]: Zum Abrufen der Site-ID./environment_id [site name]: Abfrage der Umgebungs-ID./clear_site_cache [environment id]: Zum Löschen des Site-Caches./restart_php_engine [environment id]: Zum Neustart der PHP-Engine einer Website./operation_status [operation id]: Überprüft den Status einer Operation.
In diesem Leitfaden fügst du drei neue Befehle hinzu. Um Slash-Befehle auf Slack zu erstellen, navigiere zu deiner Slack-Anwendung, klicke auf die Menüoption Slash-Befehle in der linken Seitenleiste und dann auf die Schaltfläche Neuen Befehl erstellen. Erstelle drei Befehle mit den unten stehenden Informationen:
| Befehl | Kurze Beschreibung | Hinweis zur Verwendung |
| /get_backups | Ruft alle Backups deiner Website mit den dazugehörigen Informationen ab | [Umgebungs-ID] |
| /get_downloadable_backups | Ruft alle herunterladbaren Backups deiner Website mit den dazugehörigen Informationen und dem Link ab | [Umgebungs-ID] |
| /restore_backup | Stellt ein geplantes, manuelles oder vom System generiertes Backup in einer Umgebung wieder her | [Zielumgebung ID] [Backup ID] [Umgebungsname] |
Sobald du diese Befehle erstellt hast, kannst du deine Slack-Umgebung überprüfen, indem du / eingibst. Du wirst feststellen, dass diese Befehle hinzugefügt wurden.
Der nächste Schritt besteht darin, die Interaktion mit der Kinsta-API zu implementieren, damit die von Slack übergebenen Daten empfangen und zur Abfrage des spezifischen API-Endpunkts verwendet werden können.
Implementierung von Node.js Fetch Requests für Backup-Operationen
Sobald du die notwendigen Slash-Befehle erstellt hast, kannst du deine Node.js-Anwendung so anpassen, dass sie darauf reagiert. Beginnen wir damit, asynchrone Funktionen zu erstellen, die mit jedem Endpunkt interagieren.
In der Datei app.js definieren wir drei Funktionen:
getBackups(environmentId): Holt Informationen über Backups für eine bestimmte Umgebung ab.getDownloadableBackups(environmentId): Ruft herunterladbare Backups für eine bestimmte Umgebung ab.restoreBackup(targetEnvironmentId, backupId, environmentName): Startet einen Wiederherstellungsprozess für ein bestimmtes Backup in einer bestimmten Umgebung.
Hier ist die Fetch-Anfrage für jede Funktion:
async function getBackups(environmentId) {
const resp = await fetch(
`${KinstaAPIUrl}/sites/environments/${environmentId}/backups`,
{
method: 'GET',
headers: getHeaders,
}
);
const data = await resp.json();
return data;
}
async function getDownloadableBackups(environmentId) {
const resp = await fetch(
`${KinstaAPIUrl}/sites/environments/${environmentId}/downloadable-backups`,
{
method: 'GET',
headers: getHeaders,
}
);
const data = await resp.json();
return data;
}
async function restoreBackup(targetEnvironmentId, backupId, environmentName) {
const resp = await fetch(
`${KinstaAPIUrl}/sites/environments/${targetEnvironmentId}/backups/restore`,
{
method: 'POST',
headers: postHeaders,
body: JSON.stringify({
backup_id: backupId,
env_display_name_of_backup: environmentName,
}),
}
);
const data = await resp.json();
return data;
}Jede Funktion ist so aufgebaut, dass sie mit der Kinsta-API kommuniziert, indem sie die Fetch-API von JavaScript nutzt. Parameter für Umgebungs-IDs, Backup-IDs und Umgebungsnamen sind erwartete Eingaben, die von Slack-Befehlen empfangen und dann zur Ausführung an diese Funktionen weitergegeben werden sollen.
Um den Code zu vereinfachen und Wiederholungen zu vermeiden, werden drei Variablen verwendet, um wichtige Elemente zu speichern: die Basis-URL der API und Header für die Anfragen GET und POST.
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}`,
};Außerdem werden sensible Schlüssel und Token, wie das Slack-Signiergeheimnis, das Bot-Token, das Anwendungs-Token, die Unternehmens-ID und der API-Schlüssel, sicher in der .env-Datei gespeichert.
SLACK_SIGNING_SECRET="YOUR_SIGNING_SECRET"
SLACK_BOT_TOKEN="xoxb-YOUR_BOT_TOKEN"
APP_TOKEN="xapp-YOUR_APP_TOKEN"
REACT_APP_KINSTA_COMPANY_ID = 'YOUR_COMPANY_ID'
REACT_APP_KINSTA_API_KEY = 'YOUR_API_KEY'Wenn diese Funktionen und Schlüssel vorhanden sind, müssen im nächsten Schritt die Slack-Befehle konfiguriert werden. Bei dieser Konfiguration werden Eingabewerte von Slack empfangen, die entsprechenden Methoden auf der Grundlage dieser Eingaben aufgerufen und eine bestimmte Antwort an Slack zurückgeschickt.
Konfigurieren von Slash-Befehlen mit Node.js für die Verwaltung von Backups
Um einen Slash-Befehl zu konfigurieren, verwendest du die 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, der vom Benutzer gesendet wurde.ack: Bestätigt den Empfang des Slash-Befehls.say: Sendet eine Nachricht zurück an den Slack-Kanal.
Hier ist die Konfiguration für die drei Befehle:
app.command('/get_backups', async ({ command, ack, say }) => {
await ack();
let environmentId = command.text;
let response = await getBackups(environmentId);
let backups = response.environment.backups;
let backupDetails = backups
.map((backup) => {
return `Backup ID: ${backup.id}\nName: ${backup.name}\nNote: ${
backup.note
}\nType: ${backup.type}\nCreated At: ${new Date(backup.created_at)}\n\n`;
})
.join('');
if (backupDetails) {
say(
`Hey 👋, here are the backup details for environment ID ${environmentId}:\n\n${backupDetails}`
);
} else {
say(`No backups found for environment ID ${environmentId}`);
}
});
app.command('/get_downloadable_backups', async ({ command, ack, say }) => {
await ack();
let environmentId = command.text;
let response = await getDownloadableBackups(environmentId);
let backups = response.environment.downloadable_backups;
let downloadable_backupDetails = backups
.map((backup) => {
return `Backup ID: ${backup.id}\nDownload Link: ${
backup.download_link
}\nCreated At: ${new Date(backup.created_at)}\nExpires At: ${new Date(
backup.expires_at
)}\nIs Generation in Progress: ${backup.is_generation_in_progress}\n\n`;
})
.join('');
if (downloadable_backupDetails) {
say(
`Hey 👋, here are the downloadable backup details for environment ${environmentId}:\n\n${downloadable_backupDetails}`
);
} else {
say(`No downloadable backups found for environment ${environmentId}`);
}
});
app.command('/restore_backup', async ({ command, ack, say }) => {
await ack();
const [targetEnvironmentId, backupId, environmentName] =
command.text.split(' ');
let response = await restoreBackup(
targetEnvironmentId,
backupId,
environmentName
);
if (response) {
say(
`Hey 👋, \n\n${response.message}. You can use the /operation_status slack commmand to check the status of this Operation Id ${response.operation_id}`
);
}
});Die obigen Slash-Befehle verwalten verschiedene Backup-bezogene Aufgaben: /get_backups ruft umgebungsspezifische Backup-Details ab, /get_downloadable_backups holt herunterladbare Backup-Informationen und /restore_backup initiiert die Wiederherstellung basierend auf den angegebenen Parametern.
Jeder Befehl bestätigt den Empfang, verarbeitet die Eingaben, löst die entsprechenden Funktionen aus (getBackups(), getDownloadableBackups(), restoreBackup()), formatiert die Antworten und übermittelt die Ergebnisse zurück an Slack und bietet so eine umfassende Schnittstelle für Backup-Vorgänge.
Wenn du deine Anwendung einsetzt, kannst du jetzt Slack besuchen, um die verschiedenen Befehle zu testen.
Den vollständigen Code für dieses Projekt findest du in unserem GitHub-Repository.
Zusammenfassung
In dieser Anleitung hast du gelernt, wie du die neuesten in die Kinsta-API integrierten Backup-Endpunkte effektiv nutzen kannst. Diese Endpunkte ermöglichen es dir, Backup-Vorgänge nahtlos in deine Frontend-Anwendungen zu integrieren, Pipelines einzurichten und verschiedene Aufgaben zu übernehmen, die die Verwaltung deiner Websites auf programmatischem Wege vereinfachen.
Die Kinsta-API bietet darüber hinaus noch viele weitere Möglichkeiten. Du bist also herzlich eingeladen, weitere Endpunkte zu erforschen und innovative Wege zu finden, sie in deinen Projekten zu nutzen.
Wie nutzt du derzeit die Kinsta-API? Gibt es bestimmte Funktionen, die du in Zukunft gerne einführen oder zugänglich machen würdest?
Schreibe einen Kommentar