Für WordPress-Agenturen, die mehrere Kunden-Websites verwalten, ist eine solide Backup-Strategie unerlässlich. Im Falle eines unerwarteten Ausfalls, eines Plugin-Fehlers oder menschlichen Versagens stellen Backups sicher, dass die Daten schnell wiederhergestellt werden können – so werden Ausfallzeiten minimiert und das Risiko für die Kunden verringert.
Wir bei Kinsta wissen, wie wichtig Backups sind. Deshalb bieten wir sechs Backup-Optionen an: automatische tägliche, optional stündliche (und alle sechs Stunden), manuelle, systemgenerierte, herunterladbare und externe Backups, die direkt an Amazon S3 oder Google Cloud Storage gesendet werden.
Die Verwaltung dieser Backups ist ganz einfach über das MyKinsta-Dashboard möglich, aber die API von Kinsta bietet großartige Möglichkeiten, sich wiederholende Prozesse zu automatisieren.
Stell dir vor, du gibst einfach einen Befehl in Slack ein oder richtest einen Cron-Job ein, um Backups für alle deine WordPress-Websites in deinem Kinsta-Agenturkonto auszulösen, ohne manuell durch Dutzende oder gar Hunderte von Websites-Dashboards zu navigieren.
Diese Flexibilität ist einer der vielen Vorteile eines Hosters, der die Bedürfnisse seiner Kunden in den Vordergrund stellt und ihnen die Werkzeuge zur Verfügung stellt, um individuelle, zeitsparende Lösungen zu erstellen.
In diesem Leitfaden wird erklärt, wie du die Kinsta-API nutzen kannst, um Backups für mehrere Websites zu automatisieren. Ganz gleich, ob du sie mit deinem bevorzugten Stack integrierst, Tools wie Slack verwendest oder automatische Zeitpläne einrichtest, dieser Leitfaden vermittelt dir das Wissen, um deinen Backup-Prozess zu rationalisieren und deinen Workflow zu verbessern.
Backups für alle und für ausgewählte Websites einrichten
Bevor du dich mit der Planung beschäftigst, solltest du wissen, wie du Backups für alle Websites in deinem Kinsta-Konto auslösen kannst und wie du mit der Kinsta-API bestimmte Websites oder Umgebungen ansteuern kannst.
Sobald wir die Grundlage für die Erstellung von Backups geschaffen haben, können wir ganz einfach die Zeitplanung integrieren, um den Prozess zu automatisieren.
Auslösen von Backups für alle Websites in einem Kinsta-Konto
Wie bei jeder API gibt es nicht immer einen einzigen Endpunkt, der alles kann, was du brauchst – oft musst du mehrere Endpunkte kombinieren, um das gewünschte Ergebnis zu erzielen.
Bei der Kinsta-API ist das nicht anders. Es gibt zwar spezielle Endpunkte für die Verwaltung von Backups, aber diese Endpunkte benötigen bestimmte Parameter, wie z. B. Umgebungs-IDs, die du durch zusätzliche Anfragen an andere Endpunkte erhältst.
Um zum Beispiel ein manuelles Backup für eine Website auszulösen, brauchst du die Umgebungs-ID für diese bestimmte Umgebung. Um die Umgebungs-ID zu erhalten, brauchst du zunächst die Site-ID. Das bedeutet, dass du mehrere API-Aufrufe tätigen musst: einen, um die Site-ID zu erhalten, einen weiteren, um die Umgebungs-ID abzurufen, und schließlich eine Anfrage, um das Backup auszulösen.
Schritt 1: Alle WordPress-Websites mit Kinsta-API abrufen
Der erste Schritt besteht darin, eine Liste aller Websites abzurufen, die mit deinem Kinsta-Konto verbunden sind. Die Kinsta-API bietet einen Endpunkt, um diese Daten abzurufen, darunter Site-IDs, Namen und andere relevante Details. Mit dem Endpunkt GET /sites kannst du eine Liste aller Websites deines Unternehmenskontos abrufen.
Hier ist ein Beispiel mit Node.js und der Fetch API:
require('dotenv').config();
const KINSTA_API_URL = 'https://api.kinsta.com/v2';
const API_KEY = process.env.KINSTA_API_KEY;
async function getAllSites() {
const response = await fetch(`${KINSTA_API_URL}/sites`, {
headers: {
Authorization: `Bearer ${API_KEY}`
}
});
const data = await response.json();
return data.company.sites; // Returns array of all sites
}Diese Funktion gibt ein Array mit allen Websites in deinem Konto zurück. Jede Antwort enthält Informationen wie die ID, den Namen und die Umgebung(en) der Website.
Schritt 2: Umgebungs-IDs für jede WordPress-Website abrufen
Jede Website kann mehrere Umgebungen haben (z. B. Produktions- oder Staging-Umgebungen), und die Backups werden pro Umgebung ausgelöst. Um die Umgebungs-IDs für jede Website abzurufen, machst du einen weiteren API-Aufruf an den Endpunkt GET /sites/{site_id}/environments.
Hier ist eine Beispielfunktion, die die Umgebungen für eine bestimmte Website abruft:
async function getSiteEnvironments(siteId) {
const response = await fetch(`${KINSTA_API_URL}/sites/${siteId}/environments`, {
headers: {
Authorization: `Bearer ${API_KEY}`
}
});
const data = await response.json();
return data.site.environments;
}Schritt 3: Backups für jede Umgebung auslösen
Sobald du die Umgebungs-IDs hast, kannst du über den Endpunkt POST /sites/environments/{env_id}/manual-backups Backups für jede Umgebung auslösen. Mit der API kannst du eine manuelle Sicherung erstellen, indem du eine Umgebungs-ID und einen optionalen Tag zur Identifizierung des Backups angibst.
Hier erfährst du, wie du ein Backup für eine bestimmte Umgebung auslöst:
async function createBackup(environmentId, tag) {
const response = await fetch(`${KINSTA_API_URL}/sites/environments/${environmentId}/manual-backups`, {
method: 'POST',
headers: {
Authorization: `Bearer ${API_KEY}`,
'Content-Type': 'application/json'
},
body: JSON.stringify({ tag })
});
if (response.ok) {
console.log(`Backup created for environment ${environmentId} with tag: ${tag}`);
} else {
console.error(`Failed to create backup for environment ${environmentId}`);
}
}Diese Funktion löst ein manuelles Backup für die angegebene Umgebungs-ID aus. Du kannst dein Backup auch markieren, um es leichter zu identifizieren.
Schritt 4: Automatisiere Backups für alle Websites
Jetzt, wo du die Funktionen zum Abrufen aller Websites, zum Abrufen der Umgebungs-IDs und zum Auslösen von Backups hast, kannst du sie kombinieren, um ein Skript zu erstellen, das Backups für jede Website in deinem Kinsta-Konto automatisiert.
Hier siehst du, wie du alles miteinander verbinden kannst:
async function backupAllSites() {
const sites = await getAllSites();
for (const site of sites) {
const environments = await getSiteEnvironments(site.id);
for (const environment of environments) {
await createBackup(environment.id, `Backup-${new Date().toISOString()}`);
}
}
console.log('Backups for all sites have been triggered.');
}Diese Funktion durchläuft alle Websites, ruft ihre Umgebungen ab und löst für jede Umgebung mit einem Zeitstempel Backups aus.
Wenn du nun backupAllSites() aufrufst, wird ein Backup für jede Umgebung in deinem Kinsta-Konto ausgelöst.
Beispiel für einen Slack-Befehl
Du kannst diesen Backup-Prozess in einen Slack-Befehl integrieren, um die Verwaltung noch einfacher zu gestalten. Wenn eine Slack-App eingerichtet ist, können die Nutzer mit einem einzigen Befehl wie /backup_all_sites Backups für alle Websites auslösen.
Hier ist ein kurzes Beispiel, wie das funktionieren könnte:
app.command('/backup_all_sites', async ({ ack, say }) => {
await ack();
await backupAllSites();
say('Backups for all sites have been triggered.');
});Auslösen von Backups für ausgewählte Websites mithilfe von Umgebungs-IDs
In manchen Fällen möchtest du vielleicht nur für bestimmte Websites oder Umgebungen Backups auslösen und nicht für alle Websites in deinem Kinsta-Konto. Das kann nützlich sein, wenn du nur Produktionsumgebungen oder bestimmte Websites mit hoher Priorität sichern möchtest.
Mit der Kinsta-API können wir Backups für ausgewählte Umgebungen automatisieren, indem wir ein Array von Umgebungs-IDs übergeben. Wir gehen jetzt durch, wie wir das umsetzen.
Schritt 1: Umgebungs-IDs übergeben
Wenn du Backups für ausgewählte Websites auslösen willst, brauchst du die Umgebungs-IDs für diese Websites. Du kannst diese IDs entweder fest einprogrammieren, von der Kinsta-API abrufen oder dynamisch übergeben (z. B. über ein Kommandozeilenargument, einen Slack-Befehl usw.).
Hier ist eine Funktion, die ein Array mit Umgebungs-IDs akzeptiert und Backups für jede dieser IDs auslöst:
async function backupSelectedEnvironments(environmentIds, tag) {
for (const envId of environmentIds) {
await createBackup(envId, tag);
}
}Die obige Funktion erhält ein Array von Umgebungs-IDs, die du sichern möchtest (environmentIds). Die Funktion createBackup(envId, tag) löst die Sicherung für jede Umgebung im Array mit der Funktion createBackup() aus (wird in Schritt 2 erklärt).
Schritt 2: Auslösen des Backups
Um das eigentliche Backup für jede Umgebung auszulösen, verwendest du den Endpunkt POST /sites/environments/{env_id}/manual-backups der Kinsta-API, so wie wir es für alle Websites getan haben. So funktioniert es:
async function createBackup(environmentId, tag) {
const response = await fetch(`${KINSTA_API_URL}/sites/environments/${environmentId}/manual-backups`, {
method: 'POST',
headers: {
Authorization: `Bearer ${API_KEY}`,
'Content-Type': 'application/json'
},
body: JSON.stringify({ tag })
});
if (response.ok) {
console.log(`Backup created for environment ${environmentId} with tag: ${tag}`);
} else {
console.error(`Failed to create backup for environment ${environmentId}: ${response.statusText}`);
}
}Schritt 3: Backups für ausgewählte Umgebungen ausführen
Da wir jetzt Funktionen haben, um Backups auszulösen und mehrere Umgebungen zu verwalten, können wir sie kombinieren, um bestimmte Umgebungen zu sichern. In diesem Beispiel gehen wir davon aus, dass wir bereits die Umgebungs-IDs haben, die wir sichern wollen.
const selectedEnvironments = ['12345', '67890']; // Replace with actual environment IDs
backupSelectedEnvironments(selectedEnvironments, 'Manual Backup');In diesem Fall:
- Das Array
selectedEnvironmentsenthält die Umgebungs-IDs, die du sichern willst. - Die Funktion
backupSelectedEnvironments()geht jede ID in einer Schleife durch und löst das Backup mit dem Tag „Manual Backup“ aus.
Beispiel für einen Slack-Befehl
Wenn du eine Slack-App oder eine Befehlszeilenschnittstelle verwendest, kannst du den Nutzern auch erlauben, anzugeben, welche Umgebungen gesichert werden sollen.
Hier siehst du, wie du das in einer Slack-App umsetzen kannst:
app.command('/backup_selected_envs', async ({ command, ack, say }) => {
await ack();
const [tag, ...envIds] = command.text.split(' '); // First part is the tag, rest are env IDs
await backupSelectedEnvironments(envIds, tag);
say(`Backups triggered for selected environments with tag ${tag}.`);
});Der Benutzer gibt einen Befehl wie /backup_selected_envs Backup-Tag 12345 67890 ein, wobei Backup-Tag der Tag und 12345, 67890 die Umgebungs-IDs sind.
Der Text des Befehls wird geteilt und die Umgebungs-IDs werden an die Funktion backupSelectedEnvironments() übergeben.
Nachdem die Backups ausgelöst wurden, antwortet die App dem Nutzer und bestätigt das Backup.
Planen von Backups für deine WordPress-Websites
Einer der wichtigsten Aspekte der Automatisierung ist die Möglichkeit, Aufgaben zu bestimmten Zeiten zu planen, ohne dass ein manuelles Eingreifen erforderlich ist.
Nachdem wir nun beschrieben haben, wie du Backups für alle und ausgewählte Websites auslösen kannst, ist der nächste Schritt die Automatisierung dieser Prozesse durch Hinzufügen von Zeitplänen.
Egal, ob du Backups lokal, auf einer gehosteten Plattform wie Kinsta oder dynamisch über Slack planen willst, es gibt verschiedene Möglichkeiten, dies umzusetzen.
Cron-Ausdrücke verstehen
Bevor du dich mit den verschiedenen Ansätzen zur Planung von Backups beschäftigst, ist es wichtig, die Cron-Ausdrücke zu verstehen, die verwendet werden, um den Zeitplan für geplante Aufgaben auf verschiedenen Plattformen und Tools festzulegen.
Cron-Ausdrücke legen fest, wann eine Aufgabe ausgeführt werden soll. Sie werden in vielen Zeitplanungsbibliotheken und -diensten verwendet, z. B. in node-cron, node-schedule und sogar in serverseitigen Cron-Jobs, wie sie in der Anwendungs-Hosting-Plattform von Kinsta verfügbar sind.
Cron-Ausdrücke bestehen aus fünf Feldern, von denen jedes einen bestimmten Aspekt des Ausführungszeitpunkts der Aufgabe steuert. Ein typischer Cron-Ausdruck sieht wie folgt aus:
* * * * *
| | | | |
| | | | └─── Day of the week (0 - 7) (Sunday to Saturday, 0 and 7 represent Sunday)
| | | └────── Month (1 - 12)
| | └──────── Day of the month (1 - 31)
| └────────── Hour (0 - 23)
└──────────── Minute (0 - 59)Schauen wir uns an, was jedes Feld bedeutet:
- Minute: Die Minute der Stunde, in der die Aufgabe ausgeführt werden soll (0 – 59).
- Stunde: Die Stunde des Tages, an dem die Aufgabe ausgeführt werden soll (0 – 23).
- Tag des Monats: Der bestimmte Tag des Monats, an dem die Aufgabe ausgeführt werden soll (1 – 31).
- Monat: Der Monat des Jahres, in dem die Aufgabe ausgeführt werden soll (1 – 12).
- Wochentag: Der Wochentag, an dem die Aufgabe ausgeführt werden soll (0 – 7, wobei 0 und 7 jeweils für Sonntag stehen).
Du kannst in jedem Feld bestimmte Werte, Platzhalter (*) oder Bereiche verwenden, um den Zeitplan zu definieren.
Beispiele für Cron-Ausdrücke:
0 0 * * *: Jeden Tag um Mitternacht (00:00)0 3 * * 1: Jeden Montag um 3 Uhr morgens*/10 * * * *: Alle 10 Minuten0 9-18 * * *: Jede Stunde zwischen 9 Uhr und 18 Uhr
Mit einem soliden Verständnis der Cron-Ausdrücke können wir nun zu den verschiedenen Methoden übergehen, mit denen du Backups für deine WordPress-Websites mithilfe der Kinsta-API planst.
Ansatz 1: Lokales Planen mit node-cron
Das Node.js-Paket node-cron kann geplante Aufgaben mit einer cron-ähnlichen Syntax ausführen. Es eignet sich ideal für die Ausführung automatisierter Aufgaben in lokalen oder eigenständigen Node.js-Anwendungen und ist eine beliebte Wahl für die Planung von Backups, den Versand von E-Mails oder die Ausführung anderer wiederkehrender Aufgaben.
In node-cron definierst du eine Aufgabe (z. B. deine Backup-Funktion) und gibst mit einem Cron-Ausdruck an, wann die Aufgabe ausgeführt werden soll. Der Cron-Ausdruck besteht aus fünf Feldern, die die Minute, die Stunde, den Tag des Monats, den Monat und den Wochentag festlegen, an dem die Aufgabe ausgeführt werden soll.
Installiere zunächst node-cron in deinem Projekt:
npm install node-cronAngenommen, du möchtest ein tägliches Backup aller Websites um Mitternacht mit node-cron planen. So würde es funktionieren:
const cron = require('node-cron');
const { backupAllSites } = require('./app'); // Import the backup function
// Schedule to run backups for all sites at midnight every day
cron.schedule('0 0 * * *', () => {
console.log('Running scheduled backup for all sites at midnight...');
backupAllSites();
});Wenn du jeden Tag um 2 Uhr nachts ein Backup ausgewählter Umgebungen erstellen willst, kannst du es so einrichten:
cron.schedule('0 2 * * *', () => {
const environmentIds = ['env12345', 'env67890']; // Specific environments to back up
console.log('Running scheduled backup for selected environments...');
backupSelectedEnvironments(environmentIds, 'Scheduled Backup');
});Ansatz 2: Cron-Jobs beim Cloud-Hosting (wie Kinsta) nutzen
Wenn du deine Node.js-Anwendung auf einer Plattform wie Kinsta bereitstellst, kannst du die integrierte Cronjob-Funktion der Plattform nutzen, um Aufgaben wie Backups zu planen. Die Einrichtung von Cron-Jobs in Cloud-Umgebungen erfordert jedoch eine etwas andere Struktur als lokale Scheduling-Tools wie node-cron.
Wenn du deine Anwendungf bei Kinsta bereitstellst, muss sie einen laufenden Webprozess haben (auch wenn er nicht für den Webverkehr zuständig ist).
Um sicherzustellen, dass dein Projekt korrekt läuft und nicht automatisch Backup-Funktionen aufruft, kannst du eine Datei erstellen, in der ein einfacher Webserver läuft. Diese Datei fungiert als „Dummy“-Webprozess, während Cron-Jobs die Backup-Logik übernehmen.
Du kannst diesen Code so einfügen:
require('http').createServer((req, res) => {
res.writeHead(302, { Location: 'https://www.google.com' });
res.end();
}).listen(process.env.PORT);Auf diese Weise kannst du einen Skriptbefehl einrichten, der zwischen dem Webprozess (start) und dem Cronjob-Prozess (cron) unterscheidet.
"scripts": {
"start": "node index.js", // Web process
"cron": "node app.js" // Cron job process
},Schließlich konfigurierst du den Cron-Job in Kinsta so, dass er deine Backup-Funktion zur angegebenen Zeit aufruft. In den Cron-Job-Einstellungen kannst du den Befehl zum Ausführen des Backups festlegen.
Lege auf der Registerkarte Prozesse der MyKinsta-Dashboard-Anwendungen den Befehl für den Webprozess fest:
npm run startUnd setze den Befehl für den Cron-Job auf:
npm run cronUm den Cron-Job zu einer bestimmten Zeit auszuführen (jeden Tag um 11:30 Uhr), setzt du den Cron-Ausdruck wie folgt:
30 11 * * *Dieser Befehl wird die Funktion backupAllSites() jeden Tag um 11:30 Uhr auslösen.
Ansatz 3: Zeitplanung mit node-schedule
Eine weitere Node.js-Bibliothek, node-schedule, kann Aufgaben im Cron-Format planen und unterstützt auch komplexere Zeitpläne.
Hier ist ein Beispiel, das es Nutzern ermöglicht, Backups über Slack mit dem node-schedule Cron-Format zu planen:
const schedule = require('node-schedule');
const { backupAllSites } = require('./app');
// Slack command to schedule backups dynamically
app.command('/schedule_backup', async ({ command, ack, say }) => {
await ack();
// Extract hour and minute from the command (expects HH:MM format)
const [hour, minute] = command.text.split(':');
// Validate input
if (!hour || !minute) {
say('Please specify the time in HH:MM format.');
return;
}
// Schedule the backup using node-schedule's cron-like format
const job = schedule.scheduleJob(`${minute} ${hour} * * *`, () => {
console.log(`Running scheduled backup at ${hour}:${minute}`);
backupAllSites(); // This triggers the backup for all sites
});
say(`Backup scheduled at ${hour}:${minute} successfully.`);
});Ein Benutzer könnte zum Beispiel den folgenden Slack-Befehl ausführen, um ein Backup für 23:30 Uhr zu planen:
/schedule_backup 23:30Nachdem er diesen Befehl ausgeführt hat, wird das Backup jeden Tag um 23:30 Uhr ausgeführt. Die Antwort von Slack könnte wie folgt aussehen:
Backup scheduled at 23:30 successfully.Mit diesem Ansatz können Nutzer/innen dynamisch Backups von Slack aus planen, indem sie einfach die Zeit angeben, ohne mit dem Server oder dem Anwendungscode interagieren zu müssen. Das ist eine flexible und leistungsstarke Methode, um geplante Aufgaben wie Backups auf benutzerfreundliche Weise zu erledigen.
Zusammenfassung
Die Planung von Backups für mehrere WordPress-Websites ist für Agenturen, die zahlreiche Kunden-Websites verwalten, sehr nützlich. Die Automatisierung dieser Backups spart nicht nur Zeit, sondern sorgt auch für Konsistenz, verringert das Risiko menschlicher Fehler und gibt dir ein sicheres Gefühl.
Wäre diese Lösung auch für deine Agentur von Vorteil? Wir würden gerne deine Meinung hören. Teile sie uns in den Kommentaren unten mit!
Joel ist Frontend-Entwickler und arbeitet bei Kinsta als Technical Editor. Er ist ein leidenschaftlicher Lehrer mit einer Vorliebe für Open Source und hat über 200 technische Artikel geschrieben, die sich hauptsächlich um JavaScript und seine Frameworks drehen.
Schreibe einen Kommentar