Backups bieden website-eigenaren een vangnet waar ze in het geval van ongelukken op kunnen vertrouwen. Gebruikers van Kinsta’s Managed WordPress Hosting dienst profiteren dan ook van zes soorten backups: automatische dagelijkse, optionele uurlijkse, handmatige, door het systeem gegenereerde, downloadbare en externe backups die automatisch worden verzonden naar je Amazon S3 of Google Cloud Storage.
Het beheren van deze backups is een fluitje van een cent in het MyKinsta dashboard. En nu opent de Kinsta API de deur voor nieuwe mogelijkheden rond het werken met WordPress sites en hun backups. Van bureaus met hun vele dashboards om honderden installaties te beheren tot teams die gebruik willen maken van productiviteitstools zoals Slack: de Kinsta API kan helpen om alles met elkaar te verbinden.
Deze tutorial verkent de verschillende backup endpoints die beschikbaar zijn via de API, hun mogelijkheden en hoe je ze kunt gebruiken om backups te beheren in een Slack omgeving.
De Kinsta API
De Kinsta API is een krachtig hulpmiddel waarmee je programmatisch kunt communiceren met Kinsta diensten zoals gehoste WordPress sites. Het kan helpen bij het automatiseren van verschillende taken met betrekking tot het beheer van WordPress, zoals het maken van sites, het ophalen van site-informatie, het opvragen van de status van een site, het doorzoeken en herstellen van backups en nog veel meer.
Om de API van Kinsta te gebruiken, moet je een account hebben met ten minste één WordPress site, applicatie of database in MyKinsta. Je moet ook een API sleutel genereren om je te authenticeren en toegang te krijgen tot je account.
Om een API sleutel te genereren:
- Ga naar je MyKinsta dashboard.
- Navigeer naar de pagina API sleutels (Je naam > Bedrijfsinstellingen > API sleutels).
- Klik op Maak API sleutel aan.
- Kies een vervaldatum of stel een aangepaste begintijd in en het aantal uren dat de sleutel moet verlopen.
- Geef de sleutel een unieke naam.
- Klik op Genereer.
Nadat je een API sleutel hebt gemaakt, moet je deze kopiëren en ergens veilig opslaan (het gebruik van een wachtwoordmanager wordt aanbevolen), omdat dit de enige keer is dat de sleutel wordt getoond binnen MyKinsta. Je kunt meerdere API-sleutels genereren, die worden weergegeven op de pagina API-sleutels. Als je een API sleutel wilt intrekken, klik dan op de Intrekken knop naast de naam en vervaldatum.
WordPress sitebackups beheren met Kinsta API
De Kinsta API heeft endpoints voor deze backup gerelateerde bewerkingen:
- Lijst handmatige, geplande en door het systeem gegenereerde backups
- Lijst downloadbare backups
- Een geplande, handmatige of door het systeem gegenereerde backup herstellen
Voor interactie met deze endpoints heb je de API sleutel nodig die je eerder hebt gegenereerd. Laten we deze endpoints verkennen en ze later integreren in een Slackbot zodat je de Slash commando’s van Slack kunt gebruiken voor interactie met de Kinsta API.
Handmatige, geplande en door het systeem gegenereerde backups maken met de Kinsta API
Wanneer je naar een specifieke WordPress site navigeert binnen je MyKinsta dashboard en op het tabblad Backups klikt, vind je een lijst met backups, waaronder dagelijkse, uurlijkse (indien geactiveerd), handmatige en systeemgegenereerde backups.
Als je nu toegang wilt krijgen tot deze gegevens of acties wilt uitvoeren vanuit een externe applicatie of platform, vereenvoudigt onze API het proces.
Je kunt backupgegevens zoals ID, naam, type en aanmaaktijd programmatisch ophalen. Door de API in je eigen tools te gebruiken, hoef je het dashboard niet meer te openen wanneer je deze informatie nodig hebt.
Om toegang te krijgen tot dit endpoint, moet je de omgevings-ID van je site programmatisch verkrijgen via het Get site environment endpoint, dat details over de omgeving van je site retourneert, inclusief de ID:
{
"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"
}
}
]
}
}Als je het omgevings-ID van je site weet, kun je een GET verzoek sturen naar https://api.kinsta.com/v2/sites/environments/${envId}/backups om een array van alle backups van je site op te halen:
curl -i -X GET \
'https://api.kinsta.com/v2/sites/environments/{env_id}/backups' \
-H 'Authorization: Bearer 'Dit retourneert een Object met een array van backups, die je in je client kunt loopen en ook de gegevens kunt manipuleren:
{
"environment": {
"display_name": "MyEnvironment",
"backups": [
{
"id": 123456789,
"name": "mySiteName-1234567890-backupType",
"note": "Daily Auto Backup",
"type": "manual",
"created_at": 1665382600770
}
]
}
}Een geplande, handmatige of door het systeem gegenereerde backup herstellen met Kinsta API
Met de Kinsta API kun je ook een specifieke backup uit de gegenereerde lijst terugzetten naar een omgeving met behulp van een POST verzoek.
Alles wat je nodig hebt is de backup-ID, de doelomgeving-ID en de omgevingsnaam van de backup. Met deze actie hoef je het MyKinsta dashboard niet opnieuw te bezoeken voor hersteltaken.
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"
}'Het antwoord op dit verzoek bevat een operation status en een operation ID, zodat je de voortgang van de restore programmatisch kunt volgen met ons Operation status endpoint:
{
"operation_id": "backups:restore-54fb80af-576c-4fdc-ba4f-b596c83f15a1",
"message": "Restoring a backup to environment in progress",
"status": 202
}Downloadbare backups verkrijgen met Kinsta API
Hoewel er momenteel geen endpoint is om downloadbare backups te maken, kun je bestaande downloadbare backups en hun downloadlinks programmatisch benaderen.
Dit kun je doen door een GET-verzoek te sturen naar https://api.kinsta.com/v2/sites/environments/{env_id}/downloadable-backups om een array van alle downloadbare backups van je site op te halen:
curl -i -X GET \
'https://api.kinsta.com/v2/sites/environments/{env_id}/downloadable-backups' \
-H 'Authorization: Bearer 'Elke downloadbare backup in de array bevat een ID, tijdstempel van aanmaak, downloadlink, tijdstempel van afloop en een status die aangeeft of het aanmaakproces bezig is:
{
"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
}
]
}
}Als je op de downloadlink klikt, wordt het zipbestand van de backup gedownload, zodat je de link in je applicatie kunt insluiten voor gemakkelijke toegang en download door je gebruikers.
Slack Slash commando’s gebruiken voor het beheren van backups met Kinsta API
In een recente gids werd het proces uitgebreid beschreven van het maken van een Slackbot met Node.js en de Kinsta API voor sitebeheer . De gids beschreef het creëren van een Slackbot en het tot stand brengen van interactie met de Kinsta API via een Node.js applicatie die gehost wordt op ons Applicatie Hosting platform.
In dit artikel richt je je op het maken van nieuwe Slack Slash commando’s voor de drie backup endpoints. Om dit te kunnen doen, moet je eerst de eerdere gids doornemen om de Node.js applicatie te begrijpen en hoe je je persoonlijke Slackbot kunt configureren.
Eenmaal klaar, kun je doorgaan met het klonen van ons startproject met Git:
- Navigeer naar de gewenste map voor het opslaan van je code en voer het volgende commando uit in je terminal:
git clone -b tutorial-1 --single-branch https://github.com/olawanlejoel/SlackBot-KinstaAPI.git - Ga naar de projectmap en installeer alle vereiste dependencies:
cd SlackBot-KinstaAPI npm install
Slash commando’s op Slack maken voor het afhandelen van backups
In het vorige artikel zijn vijf slash commando’s gemaakt om het volgende af te handelen:
/site_id [site name]: Gebruikt om site-ID op te halen./environment_id [site name]: Gebruikt om omgeving-ID op te halen./clear_site_cache [environment id]: Wordt gebruikt om site-cache te wissen./restart_php_engine [environment id]: Wordt gebruikt om de PHP engine van een site opnieuw op te starten./operation_status [operation id]: Wordt gebruikt om de status van een bewerking te controleren.
Voor deze handleiding voeg je drie nieuwe commando’s toe. Om Slash commando’s op Slack te maken, navigeer je naar je Slack applicatie, klik je op de menuoptie Slash commands in de linker zijbalk en klik je op de knop Create new command. Maak drie commando’s met de onderstaande informatie:
| Commando | Korte beschrijving | Gebruik hint |
| /get_backups | Haal alle backups van je site op met de bijbehorende informatie | [Omgeving-ID] |
| /get_downloadable_backups | Haal alle downloadbare backups van je site op met de bijbehorende informatie en link | [Omgevings-ID] |
| /restore_backup | Zet geplande of handmatige of door het systeem gegenereerde backup terug naar een omgeving | [Doelomgevings-ID] [Backup-ID] [Naam omgeving] |
Zodra je deze commando’s hebt gemaakt, kun je je Slack-omgeving controleren door / te typen. Je zult zien dat deze commando’s zijn toegevoegd.
De volgende stap is het implementeren van interactie met de Kinsta API, zodat de gegevens die vanuit Slack worden doorgegeven, kunnen worden ontvangen en gebruikt om het specifieke API endpoint te bevragen.
Node.js fetch verzoeken implementeren voor backupbewerkingen
Als je eenmaal de benodigde slash commando’s hebt gemaakt, kun je nu je Node.js app aanpassen zodat deze erop kan reageren. Laten we beginnen met het maken van asynchrone functies voor interactie met elk endpoint.
Laten we in het app.js bestand drie functies definiëren:
getBackups(environmentId): Vraagt informatie op over backups voor een specifieke omgeving.getDownloadableBackups(environmentId): Haalt downloadbare backups voor een bepaalde omgeving op.restoreBackup(targetEnvironmentId, backupId, environmentName): Start een herstelproces voor een bepaalde backup in een opgegeven omgeving.
Hier is het Fetch verzoek voor elke functie:
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;
}Elke functie is gemaakt om te communiceren met de Kinsta API door gebruik te maken van JavaScript’s Fetch API. Parameters voor omgevings-ID’s, backup-ID’s en omgevingsnamen zijn verwachte ingangen, die bedoeld zijn om te worden ontvangen van Slack commando’s en vervolgens te worden doorgegeven aan deze functies voor uitvoering.
Om de code te stroomlijnen en herhaling te voorkomen, zie je het gebruik van drie variabelen om essentiële elementen op te slaan: de basis API URL en headers voor GET en POST verzoeken.
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}`,
};Bovendien worden gevoelige sleutels en tokens, zoals het Slack signing secret, bot token, app token, bedrijfs-ID en API-sleutel, veilig opgeslagen in het .env-bestand.
SLACK_SIGNING_SECRET="YOUR_SIGNING_SECRET"
SLACK_BOT_TOKEN="xoxb-YOUR_BOT_TOKEN"
APP_TOKEN="xapp-YOUR_APP_TOKEN"Met deze functies en sleutels op hun plaats is de volgende stap het configureren van de Slack commando’s. Deze configuratie bestaat uit het ontvangen van invoerwaarden van Slack, het callen van de relevante methoden op basis van deze invoer en het terugsturen van een specifiek antwoord naar Slack.
Slash commando’s configureren met Node.js voor het beheren van backups
Om een Slash commando te configureren, gebruik je de functie app.command(), die net zo werkt als event listeners in JavaScript. Je specificeert het commando waar je naar wilt luisteren en maakt dan een asynchrone callback functie om de gewenste actie te definiëren. Deze functie gebruikt drie parameters:
command: Bevat de details van het slash commando dat door de gebruiker is verzonden.ack: Bevestigt de ontvangst van het slash commando.say: Stuurt een bericht terug naar het Slack kanaal.
Hier is de configuratie voor de drie commando’s:
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}`
);
}
});De Slash commando’s hierboven beheren verschillende backupgerelateerde taken: /get_backups haalt omgevingsspecifieke backupdetails op, /get_downloadable_backups haalt downloadbare backupinformatie op en /restore_backup start een herstel op basis van opgegeven parameters.
Elk commando bevestigt de ontvangst, verwerkt de invoer, activeert de respectievelijke functies (getBackups(), getDownloadableBackups(), restoreBackup()), formatteert de antwoorden en communiceert de resultaten terug naar Slack.
Wanneer je nu je applicatie deployt, kun je Slack bezoeken om de verschillende commando’s te testen.
Je kunt de volledige code van dit project vinden op onze GitHub repository.
Samenvatting
In deze handleiding heb je geleerd hoe je effectief gebruik kunt maken van de nieuwste backup endpoints die zijn geïntegreerd in de Kinsta API. Deze endpoints stellen je in staat om naadloos backup operaties op te nemen in je frontend applicaties, pipelines op te zetten en verschillende taken uit te voeren die het beheer van je sites vereenvoudigen met programmatische middelen.
De Kinsta API biedt nog veel meer mogelijkheden, dus we raden zeker aan om aanvullende endpoints te verkennen en innovatieve manieren te bedenken om ze in je projecten te gebruiken.
Hoe maak jij momenteel gebruik van de Kinsta API? Zijn er specifieke functies die je graag in de toekomst zou willen zien?
Laat een reactie achter