I backup offrono ai proprietari di siti web una rete di sicurezza che aumenta la fiducia in caso di incidenti. Gli utenti del servizio di Hosting WordPress gestito di Kinsta possono usufruire di sei tipi di backup: giornaliero automatico, orario opzionale, manuale, generato dal sistema, scaricabile e backup esterno inviato automaticamente al proprio account Amazon S3 o Google Cloud Storage.
Gestire questi backup è un gioco da ragazzi dalla dashboard di MyKinsta. E ora l’API di Kinsta apre le porte alla possibilità di lavorare con i siti WordPress e i loro backup. Dalle agenzie con le loro dashboard per gestire centinaia di installazioni ai team che vogliono sfruttare strumenti di produttività come Slack, l’API di Kinsta può aiutare a collegare tutto.
Questa guida esplora i vari endpoint di backup disponibili attraverso l’API, le loro potenzialità e come utilizzarli per gestire i backup in un ambiente Slack.
Come funziona l’API di Kinsta
L’API di Kinsta è un potente strumento che permette di interagire programmaticamente con i servizi di Kinsta come i siti WordPress ospitati. Può aiutare ad automatizzare diverse attività legate alla gestione di WordPress, tra cui la creazione di un sito, il recupero di informazioni sul sito, lo stato di un sito, la consultazione e il ripristino dei backup e altro ancora.
Per utilizzare l’API di Kinsta, è necessario avere un account con almeno un sito WordPress, un’applicazione o un database in MyKinsta. È anche necessario generare una chiave API per autenticarsi e accedere al proprio account.
Per generare una chiave API:
- Andare alla dashboard di MyKinsta.
- Andare alla pagina delle chiavi API (Nome > Impostazioni aziendali > Chiavi API).
- Cliccare su Crea chiave API.
- Scegliere una scadenza o impostare una data di inizio personalizzata e un numero di ore di scadenza della chiave.
- Assegnare alla chiave un nome univoco.
- Cliccare su Genera.
Dopo aver creato una chiave API, copiatela e conservatela in un luogo sicuro (vi consigliamo l’uso di un gestore di password ), poiché è l’unica volta che verrà rivelata all’interno di MyKinsta. Potete generare più chiavi API, che saranno elencate nella pagina delle chiavi API. Se avete bisogno di revocare una chiave API, cliccate sul pulsante Revoca accanto al suo nome e alla data di scadenza.
Gestire i backup del sito WordPress con l’API di Kinsta
L’API di Kinsta dispone di endpoint per queste operazioni relative al backup:
- Elencare i backup manuali, programmati e generati dal sistema
- Elencare i backup scaricabili
- Ripristinare un backup programmato, manuale o generato dal sistema
- Creare un backup manuale per un ambiente specifico
- Rimuovere il backup dell’ambiente di un sito WordPress
Per interagire con questi endpoint, avrete bisogno della chiave API che avete generato in precedenza. Esploriamo questi endpoint e poi integriamoli in uno Slackbot in modo da poter utilizzare i comandi Slash di Slack per interagire con l’API di Kinsta.
Come ottenere backup manuali, programmati e generati dal sistema con l’API di Kinsta
Quando accedete a un sito WordPress specifico nella vostra dashboard MyKinsta e fate clic sulla scheda Backup, troverete un elenco di backup, compresi quelli giornalieri, orari (se attivati), manuali e generati dal sistema.
Ora, se volete accedere a questi dati o eseguire azioni da un’applicazione o piattaforma esterna, la nostra API semplifica il processo.
Potete recuperare i dettagli del backup come ID, nome, tipo e ora di creazione in modo programmatico. Utilizzando l’API nei vostri strumenti, potete eliminare la necessità di accedere alla dashboard ogni volta che queste informazioni sono necessarie
Per accedere a questo endpoint, potete ottenere l’ID dell’ambiente del vostro sito in modo programmatico attraverso l’endpoint get site environment, che restituisce i dettagli dell’ambiente del sito, compreso il suo 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"
}
}
]
}
}Una volta conosciuto l’ID dell’ambiente del vostro sito, potete inviare una richiesta GET a https://api.kinsta.com/v2/sites/environments/${envId}/backups per recuperare un array di tutti i backup del vostro sito:
curl -i -X GET \
'https://api.kinsta.com/v2/sites/environments/{env_id}/backups' \
-H 'Authorization: Bearer <YOUR_TOKEN_HERE>'Questo restituirà un Oggetto con un array di backup, che potrete inserire nel vostro client e manipolare i suoi dati:
{
"environment": {
"display_name": "MyEnvironment",
"backups": [
{
"id": 123456789,
"name": "mySiteName-1234567890-backupType",
"note": "Daily Auto Backup",
"type": "manual",
"created_at": 1665382600770
}
]
}
}Come ripristinare un backup programmato, manuale o generato dal sistema con Kinsta API
Con l’API di Kinsta, potete anche ripristinare un backup specifico dall’elenco generato a un ambiente utilizzando una richiesta a POST.
Tutto ciò che serve è l’ID del backup, l’ID dell’ambiente di destinazione e il nome dell’ambiente del backup. Questa azione elimina anche la necessità di rivisitare la dashboard di MyKinsta per le attività di ripristino.
curl -i -X POST \
'https://api.kinsta.com/v2/sites/environments/{target_env_id}/backups/restore' \
-H 'Authorization: Bearer <YOUR_TOKEN_HERE>' \
-H 'Content-Type: application/json' \
-d '{
"backup_id": 123456789,
"env_display_name_of_backup": "my-env"
}'La risposta a questa richiesta include uno stato dell’operazione e un ID dell’operazione, consentendoti di monitorare programmaticamente l’avanzamento del ripristino con il nostro endpoint operation status:
{
"operation_id": "backups:restore-54fb80af-576c-4fdc-ba4f-b596c83f15a1",
"message": "Restoring a backup to environment in progress",
"status": 202
}Come ottenere backup scaricabili con Kinsta API
È possibile accedere ai backup scaricabili esistenti e ai relativi link di download in modo programmatico, inviando una richiesta GET a https://api.kinsta.com/v2/sites/environments/{env_id}/downloadable-backups per recuperare un array di tutti i backup scaricabili del proprio sito:
curl -i -X GET \
'https://api.kinsta.com/v2/sites/environments/{env_id}/downloadable-backups' \
-H 'Authorization: Bearer <YOUR_TOKEN_HERE>'Ogni backup scaricabile nell’array include un ID, un timestamp di creazione, un link di download, un timestamp di scadenza e uno stato che indica se il processo di generazione è in corso:
{
"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
}
]
}
}Cliccando sul link per il download viene richiesto il download del file zip del backup, consentendovi di incorporare il link nella vostra applicazione per facilitare l’accesso e il download da parte dei vostri utenti.
Come aggiungere un backup manuale a un ambiente con l’API di Kinsta
Creare un backup manuale per il vostro sito WordPress tramite MyKinsta è semplice e, allo stesso modo, l’API di Kinsta offre un modo efficiente per eseguire questa operazione in modo programmatico.
Per avviare un backup manuale, è necessario inviare una richiesta POST all’API di Kinsta al seguente endpoint: https://api.kinsta.com/v2/sites/environments/{env_id}/manual-backups. Per questa richiesta è necessario l’ID dell’ambiente in cui si intende aggiungere il backup e un tag nel corpo del messaggio. Questo tag serve come breve nota, per facilitare l’identificazione del backup in un secondo momento.
curl -i -X POST \
'https://api.kinsta.com/v2/sites/environments/{env_id}/manual-backups' \
-H 'Authorization: Bearer <YOUR_TOKEN_HERE>' \
-H 'Content-Type: application/json' \
-d '{
"tag": "my-awesome-backup"
}'Se la richiesta viene eseguita correttamente, l’API restituisce lo stato dell’operazione e un ID. Queste informazioni consentono di seguire l’avanzamento dell’operazione di backup manuale.
Come rimuovere il backup dell’ambiente di un sito WordPress con l’API di Kinsta
L’API di Kinsta non solo consente di aggiungere backup, ma anche di rimuoverli, consentendo una gestione programmatica completa dei backup dall’inizio alla fine.
Per eliminare un backup, è necessario inviare una richiesta DELETE che includa l’ID del backup specifico. Ecco come si può strutturare questa richiesta utilizzando curl:
curl -i -X DELETE \
'https://api.kinsta.com/v2/sites/environments/backups/{backup_id}' \
-H 'Authorization: Bearer <YOUR_TOKEN_HERE>'Dopo l’esecuzione, questa richiesta fornirà lo stato dell’operazione, l’ID e il messaggio.
Implementazione dei comandi Slack Slash per la gestione dei backup con l’API di Kinsta
In una recente guida, abbiamo illustrato il processo di creazione di uno Slackbot utilizzando Node.js e l’API Kinsta per gestire il sito. La guida illustrava la creazione di uno Slackbot e l’interazione con l’API di Kinsta tramite un’applicazione Node.js ospitata sulla nostra piattaforma di Hosting di Applicazioni.
Qui ci si concentra sulla creazione di nuovi comandi Slack Slash per i tre endpoint di backup. Per seguire questa guida, consultate prima la guida precedente per capire come funziona l’applicazione Node.js e come configurare il vostro Slackbot personalizzato.
Una volta finito, potete procedere a clonare il nostro progetto iniziale con Git:
- Navigate nella directory che preferite per archiviare il vostro codice ed eseguite il comando qui sotto nel vostro terminale:
git clone -b tutorial-1 --single-branch https://github.com/olawanlejoel/SlackBot-KinstaAPI.git - Spostatevi nella cartella del progetto e installate tutte le dipendenze necessarie:
cd SlackBot-KinstaAPI npm install
Creare comandi slash su Slack per gestire i backup
Nell’articolo precedente sono stati creati cinque comandi slash per gestire quanto segue:
/site_id [site name]: utilizzato per recuperare l’ID del sito./environment_id [site name]: utilizzato per recuperare l’ID dell’ambiente./clear_site_cache [environment id]: utilizzato per cancellare la cache del sito./restart_php_engine [environment id]: utilizzato per riavviare il motore PHP di un sito./operation_status [operation id]: utilizzato per controllare lo stato di un’operazione.
Con questa guida, aggiungerete tre nuovi comandi. Per creare comandi Slash su Slack, accedete all’applicazione Slack, cliccate sull’opzione di menu Comandi Slash nella barra laterale sinistra e cliccate sul pulsante Crea nuovo comando. Create tre comandi con le informazioni riportate di seguito:
| Comando | Descrizione breve | Suggerimento per l’uso |
| /get_backups | Recupera tutti i backup del sito con le informazioni ad essi associate | [ID ambiente] |
| /get_downloadable_backups | Recupera tutti i backup scaricabili del sito con le informazioni associate e il link | [ID ambiente] |
| /restore_backup | Ripristina un backup programmato o manuale o generato dal sistema in un ambiente | [ID ambiente di destinazione] [ID backup] [Nome ambiente] |
| /add_manual_backup | Crea un backup manuale dell’ambiente del sito | [ID ambiente] [Tag] |
| /delete_backup | Rimuove uno specifico backup dall’ambiente del sito | [ID backup] |
Una volta creati questi comandi, potete controllare il vostro ambiente Slack digitando /. Noterete che questi comandi sono stati aggiunti.
Il passo successivo consiste nell’implementare l’interazione con l’API di Kinsta in modo che i dati passati da Slack possano essere ricevuti e utilizzati per interrogare lo specifico endpoint dell’API.
Implementare le richieste di Node.js Fetch per le operazioni di backup
Una volta creati i comandi slash necessari, potrete modificare l’applicazione Node.js per rispondere ad essi. Iniziamo creando delle funzioni asincrone per interagire con ogni endpoint.
Nel file app.js, definiamo cinque funzioni:
getBackups(environmentId): recupera informazioni sui backup per un ambiente specifico.getDownloadableBackups(environmentId): recupera i backup scaricabili per un determinato ambiente.restoreBackup(targetEnvironmentId, backupId, environmentName): avvia un processo di ripristino per un determinato backup in un ambiente specifico.addManualBackup(environmentId, tag): Crea un backup manuale per un ambiente specificato, con un’etichetta opzionale per una facile identificazione.deleteBackup(backupId): rimuove un backup specificato dall’elenco dei backup dell’ambiente..
Ecco la richiesta di Fetch per ogni funzione:
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;
}
async function addManualBackup(environmentId, tag) {
const resp = await fetch(
`${KinstaAPIUrl}/sites/environments/${environmentId}/manual-backups`,
{
method: 'POST',
headers: postHeaders,
body: JSON.stringify({
tag,
}),
}
);
const data = await resp.json();
return data;
}
async function deleteBackup(backupId) {
const resp = await fetch(
`${KinstaAPIUrl}/sites/environments/backups/${backupId}`,
{
method: 'DELETE',
headers: getHeaders,
}
);
const data = await resp.json();
return data;
}Ogni funzione è costruita per comunicare con l’API di Kinsta utilizzando l’API Fetch di JavaScript. I parametri per gli ID degli ambienti, gli ID dei backup e i nomi degli ambienti sono input previsti, che devono essere ricevuti dai comandi di Slack e poi passati a queste funzioni per l’esecuzione.
Per snellire il codice ed evitare ripetizioni, noterete l’uso di tre variabili utilizzate per memorizzare elementi essenziali: l’URL dell’API di base e le intestazioni per le richieste GET e 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}`,
};Inoltre, chiavi e token sensibili, come il segreto di firma di Slack, il token del bot, il token dell’app, l’ID dell’azienda e la chiave API, sono conservati in modo sicuro all’interno del file .env.
SLACK_SIGNING_SECRET="YOUR_SIGNING_SECRET"
SLACK_BOT_TOKEN="xoxb-YOUR_BOT_TOKEN"
APP_TOKEN="xapp-YOUR_APP_TOKEN"
KINSTA_COMPANY_ID = "YOUR_COMPANY_ID"
KINSTA_API_KEY = "YOUR_API_KEY"Con queste funzioni e chiavi al loro posto, il passo successivo consiste nel configurare i comandi di Slack. Questa configurazione prevede la ricezione di valori di input da Slack, l’invocazione dei metodi pertinenti in base a questi input e l’invio di una risposta specifica a Slack.
Configurare i comandi Slash con Node.js per gestire i backup
Per configurare un comando Slash, utilizzate la funzione app.command(), che funziona in modo simile agli ascoltatori di eventi in JavaScript. Specificate il comando che volete ascoltare e poi create una funzione di callback asincrona per definire l’azione desiderata. Questa funzione accetta tre parametri:
command: contiene i dettagli del comando slash inviato dall’utente.ack: conferma la ricezione del comando slash.say: invia un messaggio al canale Slack.
Ecco la configurazione dei cinque comandi:
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}`
);
}
});
app.command('/add_manual_backup', async ({ command, ack, say }) => {
await ack();
const [environmentId, tag] = command.text.split(' ');
let response = await addManualBackup(environmentId, tag);
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}`
);
}
});
app.command('/delete_backup', async ({ command, ack, say }) => {
await ack();
let backupId = command.text;
let response = await deleteBackup(backupId);
if (response) {
say(`Hey 👋, \n\n${response.message}`);
}
});I comandi Slash di cui sopra gestiscono varie attività relative al backup: /get_backups recupera i dettagli di backup specifici dell’ambiente, /get_downloadable_backups recupera le informazioni di backup scaricabili, /restore_backup avvia il ripristino in base ai parametri forniti, /add_manual_backup consente la creazione di backup manuali con etichettatura opzionale per una facile identificazione, e /delete_backup facilita la rimozione dei backup specificati.
Ogni comando conferma la ricezione, elabora gli input, attiva le rispettive funzioni (getBackups(), getDownloadableBackups(), restoreBackup(), addManualBackup(), deleteBackup()), formatta le risposte e comunica i risultati a Slack, offrendo un’interfaccia completa per le operazioni di backup.
Ora, quando distribuite l’applicazione, potete visitare Slack per testare i vari comandi.
Potete accedere al codice completo di questo progetto sul nostro repository GitHub.
Riepilogo
In questa guida abbiamo imparato a utilizzare in modo efficace gli ultimi endpoint di backup integrati nell’API di Kinsta. Questi endpoint permettono di incorporare senza problemi le operazioni di backup nelle applicazioni frontend, di creare pipeline e di svolgere varie attività che semplificano la gestione dei vostri siti attraverso strumenti programmatici.
L’API di Kinsta offre molte altre funzionalità, quindi vi invitiamo a esplorare altri endpoint e a trovare modi innovativi per sfruttarle nei vostri progetti.
Come utilizzate attualmente l’API di Kinsta? Ci sono funzioni specifiche che vi piacerebbe vedere introdotte o rese accessibili in futuro?
