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 dal cruscotto 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:

  1. Andare alla dashboard di MyKinsta.
  2. Andare alla pagina delle chiavi API (Nome > Impostazioni aziendali > Chiavi API).
  3. Cliccare su Crea chiave API.
  4. Scegliere una scadenza o impostare una data di inizio personalizzata e un numero di ore di scadenza della chiave.
  5. Assegnare alla chiave un nome univoco.
  6. 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:

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 '

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 ' \
  -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 dello stato dell’operazione:

{
  "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

Anche se attualmente non esiste un endpoint per creare backup scaricabili, potete accedere ai backup scaricabili esistenti e ai loro link di download in modo programmatico.

Questo può essere fatto 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 vostro sito:

curl -i -X GET \
  'https://api.kinsta.com/v2/sites/environments/{env_id}/downloadable-backups' \
  -H 'Authorization: Bearer '

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.

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:

  1. 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
  2. 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.

In 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]

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 tre 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.

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;
}

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"

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 tre comandi:

aapp.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}`
        );
    }
});

I comandi Slash di cui sopra gestiscono diverse attività relative al backup: /get_backups recupera i dettagli di backup specifici dell’ambiente, /get_downloadable_backups recupera le informazioni di backup scaricabili e /restore_backup avvia il ripristino in base ai parametri forniti.

Ogni comando conferma la ricezione, elabora gli input, attiva le rispettive funzioni (getBackups(), getDownloadableBackups(), restoreBackup()), 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.

Interazione con gli endpoint di backup di Kinsta API tramite i comandi Slack Slash
Interazione con gli endpoint di backup dell’API Kinsta tramite i comandi Slack Slash.

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?

Joel Olawanle Kinsta

Joel is a Frontend developer working at Kinsta as a Technical Editor. He is a passionate teacher with love for open source and has written over 200 technical articles majorly around JavaScript and it's frameworks.