Les sauvegardes offrent aux propriétaires de sites web un filet de sécurité qui renforce la confiance en cas d’incident. Les utilisateurs du service d’ hébergement WordPress infogéré de Kinsta bénéficient de six types de sauvegardes : quotidiennes automatiques, horaires optionnelles, manuelles, générées par le système, téléchargeables et externes, envoyées automatiquement à votre compte Amazon S3 ou Google Cloud Storage.
La gestion de ces sauvegardes est un jeu d’enfant dans le tableau de bord MyKinsta. Et maintenant, l’API Kinsta ouvre la porte à votre approche du travail avec les sites WordPress et leurs sauvegardes. Des agences avec leurs tableaux de bord pour gérer des centaines d’installations aux équipes qui cherchent à tirer parti d’outils de productivité comme Slack, l’API Kinsta peut aider à tout connecter.
Ce guide explore les différents points de terminaison de sauvegarde disponibles à travers l’API, leur potentiel, et comment vous pouvez les utiliser pour gérer les sauvegardes dans un environnement Slack.
Comprendre l’API Kinsta
L’API Kinsta est un outil puissant qui vous permet d’interagir avec les services Kinsta tels que les sites WordPress hébergés de manière programmatique. Elle peut vous aider à automatiser diverses tâches liées à la gestion de WordPress, y compris la création de sites, la récupération d’informations sur les sites, l’obtention de l’état d’un site, la navigation et la restauration de sauvegardes, et plus encore.
Pour utiliser l’API de Kinsta, vous devez avoir un compte avec au moins un site, une application ou une base de données WordPress dans MyKinsta. Vous devez également générer une clé API pour vous authentifier et accéder à votre compte.
Pour générer une clé API :
- Allez sur votre tableau de bord MyKinsta.
- Naviguez jusqu’à la page des clés API (Votre nom > Réglages de l’entreprise > Clés API).
- Cliquez sur Créer une clé API.
- Choisissez une date d’expiration ou définissez une date de début personnalisée et un nombre d’heures pour l’expiration de la clé.
- Donnez un nom unique à la clé.
- Cliquez sur Générer.
Après avoir créé une clé API, copiez-la et conservez-la en lieu sûr (l’utilisation d’un gestionnaire de mots de passe est recommandée), car c’est la seule fois où elle sera révélée dans MyKinsta. Vous pouvez générer plusieurs clés API, qui seront listées sur la page Clés API. Si vous avez besoin de révoquer une clé API, cliquez sur le bouton Révoquer à côté de son nom et de sa date d’expiration.
Gérer les sauvegardes de sites WordPress avec l’API Kinsta
L’API de Kinsta a des points de terminaison pour ces opérations liées à la sauvegarde :
- Lister les sauvegardes manuelles, planifiées et générées par le système
- Lister les sauvegardes téléchargeables
- Restaurer une sauvegarde planifiée, manuelle ou générée par le système
Pour interagir avec ces points de terminaison, vous aurez besoin de la clé API que vous avez générée précédemment. Nous allons explorer ces points de terminaison et les intégrer plus tard dans un Slackbot afin que vous puissiez utiliser les commandes Slash de Slack pour interagir avec l’API Kinsta.
Comment obtenir des sauvegardes manuelles, planifiées et générées par le système avec l’API Kinsta
Lorsque vous naviguez vers un site WordPress spécifique dans votre tableau de bord MyKinsta et que vous cliquez sur l’onglet Sauvegardes, vous trouverez une liste de sauvegardes, y compris les sauvegardes quotidiennes, horaires (si activées), manuelles et générées par le système.
Maintenant, si vous souhaitez accéder à ces données ou exécuter des actions depuis une application ou une plateforme externe, notre API simplifie le processus.
Vous pouvez récupérer les détails de la sauvegarde tels que l’ID, le nom, le type et l’heure de création de manière programmatique. En utilisant l’API dans vos propres outils, vous pouvez éliminer la nécessité d’accéder au tableau de bord chaque fois que ces informations sont requises
Pour accéder à ce point de terminaison, obtenez l’identifiant de l’environnement de votre site par programmation via le point de terminaison get site environment, qui renvoie des informations sur l’environnement de votre site, y compris son identifiant :
{
"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"
}
}
]
}
}Lorsque vous connaissez l’identifiant de l’environnement de votre site, vous pouvez envoyer une requête GET à https://api.kinsta.com/v2/sites/environments/${envId}/backups pour récupérer un tableau de toutes les sauvegardes de votre site :
curl -i -X GET \
'https://api.kinsta.com/v2/sites/environments/{env_id}/backups' \
-H 'Authorization: Bearer 'Cette requête renvoie un objet contenant un tableau de sauvegardes, que vous pouvez mettre en boucle dans votre client et manipuler ses données :
{
"environment": {
"display_name": "MyEnvironment",
"backups": [
{
"id": 123456789,
"name": "mySiteName-1234567890-backupType",
"note": "Daily Auto Backup",
"type": "manual",
"created_at": 1665382600770
}
]
}
}Comment restaurer une sauvegarde planifiée, manuelle ou générée par le système avec l’API de Kinsta ?
Avec l’API Kinsta, vous pouvez également restaurer une sauvegarde spécifique de la liste générée vers un environnement en utilisant une requête POST.
Tout ce dont vous avez besoin est l’ID de la sauvegarde, l’ID de l’environnement cible et le nom de l’environnement de la sauvegarde. Cette action élimine également le besoin de revisiter le tableau de bord MyKinsta pour les tâches de restauration.
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 réponse à cette requête inclut un statut d’opération et un ID d’opération, vous permettant de suivre de manière programmatique la progression de la restauration avec notre point de terminaison de statut d’opération:
{
"operation_id": "backups:restore-54fb80af-576c-4fdc-ba4f-b596c83f15a1",
"message": "Restoring a backup to environment in progress",
"status": 202
}Comment obtenir des sauvegardes téléchargeables avec l’API Kinsta
Bien qu’il n’y ait actuellement aucun point de terminaison pour créer des sauvegardes téléchargeables, vous pouvez accéder aux sauvegardes téléchargeables existantes et à leurs liens de téléchargement de manière programmatique.
Pour ce faire, envoyez une requête GET à https://api.kinsta.com/v2/sites/environments/{env_id}/downloadable-backups pour récupérer un tableau de toutes les sauvegardes téléchargeables de votre site :
curl -i -X GET \
'https://api.kinsta.com/v2/sites/environments/{env_id}/downloadable-backups' \
-H 'Authorization: Bearer 'Chaque sauvegarde téléchargeable du tableau comprend un identifiant, une date de création, un lien de téléchargement, une date d’expiration et un état indiquant si le processus de génération est en cours :
{
"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
}
]
}
}En cliquant sur le lien de téléchargement, le fichier zip de la sauvegarde est téléchargé, ce qui vous permet d’intégrer le lien dans votre application pour faciliter l’accès et le téléchargement par vos utilisateurs.
Implémenter des commandes Slack Slash pour gérer les sauvegardes avec l’API Kinsta
Dans un guide récent, le processus de création d’un Slackbot utilisant Node.js et l’API Kinsta pour la gestion de site a été détaillé. Le guide décrivait la création d’un Slackbot et l’établissement d’une interaction avec l’API Kinsta via une application Node.js hébergée sur notre plateforme d’hébergement d’applications.
Ici, vous vous concentrez sur la création de nouvelles commandes Slack Slash pour les trois points de terminaison de sauvegarde. Pour suivre ici, relisez d’abord le guide précédent pour comprendre l’application Node.js et la manière de configurer votre Slackbot personnalisé.
Une fois terminé, vous pouvez procéder au clonage de notre projet de départ avec Git :
- Naviguez vers votre répertoire préféré pour stocker votre code et exécutez la commande suivante dans votre terminal :
git clone -b tutorial-1 --single-branch https://github.com/olawanlejoel/SlackBot-KinstaAPI.git - Déplacez-vous dans le dossier du projet et installez toutes les dépendances nécessaires :
cd SlackBot-KinstaAPI npm install
Créer des commandes Slash sur Slack pour gérer les sauvegardes
Dans l’article précédent, cinq commandes Slash ont été créées pour gérer les éléments suivants :
/site_id [site name]: Utilisée pour récupérer l’identifiant du site./environment_id [site name]: Permet de récupérer l’identifiant de l’environnement./clear_site_cache [environment id]: Permet d’effacer le cache du site./restart_php_engine [environment id]: Permet de redémarrer le moteur PHP du site./operation_status [operation id]: Permet de vérifier l’état d’une opération.
Pour ce guide, vous ajoutez trois nouvelles commandes. Pour créer des commandes Slash sur Slack, accédez à votre application Slack, cliquez sur l’option de menu Commandes Slash dans la barre latérale gauche, puis cliquez sur le bouton Créer une nouvelle commande. Créez trois commandes avec les informations ci-dessous :
| Commande | Brève description | Conseil d’utilisation |
| /get_backups | Récupère toutes les sauvegardes de votre site avec les informations associées | [ID de l’environnement] |
| /get_downloadable_backups | Récupère toutes les sauvegardes téléchargeables de votre site avec les informations et le lien associés | [ID de l’environnement] |
| /restore_backup | Restaure une sauvegarde programmée, manuelle ou générée par le système dans un environnement | [ID de l’environnement cible] [ID de la sauvegarde] [Nom de l’environnement] |
Une fois que vous avez créé ces commandes, vous pouvez vérifier votre environnement Slack en tapant /. Vous remarquerez que ces commandes ont été ajoutées.
L’étape suivante consiste à mettre en œuvre l’interaction avec l’API Kinsta afin que les données transmises par Slack puissent être reçues et utilisées pour interroger le point de terminaison spécifique de l’API.
Implémenter des requêtes Node.js Fetch pour les opérations de sauvegarde
Une fois que vous avez créé les commandes slash nécessaires, vous pouvez maintenant modifier votre application Node.js pour y répondre. Commençons par créer des fonctions asynchrones pour interagir avec chaque point de terminaison.
Dans le fichier app.js, définissons trois fonctions :
getBackups(environmentId): Recherche des informations sur les sauvegardes pour un environnement spécifique.getDownloadableBackups(environmentId): Récupère les sauvegardes téléchargeables pour un environnement donné.restoreBackup(targetEnvironmentId, backupId, environmentName): Lance un processus de restauration pour une sauvegarde particulière dans un environnement spécifié.
Voici la requête Fetch pour chaque fonction :
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;
}Chaque fonction est conçue pour communiquer avec l’API Kinsta en utilisant l’API Fetch de JavaScript. Les paramètres pour les ID d’environnement, les ID de sauvegarde et les noms d’environnement sont des entrées attendues, qui sont censées être reçues des commandes Slack et ensuite transmises à ces fonctions pour exécution.
Pour rationaliser le code et éviter les répétitions, vous remarquerez l’utilisation de trois variables utilisées pour stocker des éléments essentiels : l’URL de base de l’API et les en-têtes pour les requêtes GET et 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}`,
};De plus, les clés et les jetons sensibles, tels que le secret de signature Slack, le jeton de robot, le jeton d’application, l’identifiant de l’entreprise et la clé d’API, sont stockés en toute sécurité dans le fichier .env.
SLACK_SIGNING_SECRET="YOUR_SIGNING_SECRET"
SLACK_BOT_TOKEN="xoxb-YOUR_BOT_TOKEN"
APP_TOKEN="xapp-YOUR_APP_TOKEN"Une fois ces fonctions et clés en place, l’étape suivante consiste à configurer les commandes Slack. Cette configuration consiste à recevoir des valeurs d’entrée de Slack, à invoquer les méthodes pertinentes en fonction de ces entrées et à renvoyer une réponse spécifique à Slack.
Configuration des commandes Slash avec Node.js pour la gestion des sauvegardes
Pour configurer une commande Slash, vous utilisez la fonction app.command(), qui fonctionne de la même manière que les récepteurs d’évènements en JavaScript. Vous indiquez la commande que vous souhaitez écouter, puis vous créez une fonction de rappel asynchrone pour définir l’action souhaitée. Cette fonction prend trois paramètres :
command: Contient les détails de la commande slash envoyée par l’utilisateur.ack: Accuse réception de la commande slash.say: Renvoie un message au canal Slack.
Voici la configuration des trois commandes :
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}`
);
}
});Les commandes Slash ci-dessus gèrent diverses tâches liées à la sauvegarde : /get_backups récupère les détails de la sauvegarde spécifiques à l’environnement, /get_downloadable_backups récupère les informations de sauvegarde téléchargeables et /restore_backup lance la restauration en fonction des paramètres fournis.
Chaque commande accuse réception, traite les entrées, déclenche les fonctions correspondantes (getBackups(), getDownloadableBackups(), restoreBackup()), met en forme les réponses et communique les résultats à Slack, offrant ainsi une interface complète pour les opérations de sauvegarde.
Désormais, lorsque vous déployez votre application, vous pouvez vous rendre sur Slack pour tester les différentes commandes.
Vous pouvez accéder au code complet de ce projet sur notre dépôt GitHub.
Résumé
Dans ce guide, vous avez appris à utiliser efficacement les derniers points de terminaison de sauvegarde intégrés à l’API Kinsta. Ces points de terminaison vous permettent d’incorporer de manière transparente des opérations de sauvegarde dans vos applications frontend, d’établir des pipelines et d’entreprendre diverses tâches qui simplifient la gestion de vos sites par des moyens programmatiques.
L’API Kinsta offre de nombreuses possibilités au-delà de celles-ci, vous êtes donc encouragé à explorer d’autres points de terminaison et à réfléchir à des façons innovantes de les exploiter dans vos projets.
Comment exploitez-vous actuellement l’API Kinsta ? Y a-t-il des fonctionnalités spécifiques que vous aimeriez voir introduites ou rendues accessibles à l’avenir ?
Joel est un développeur d'interfaces publiques qui travaille chez Kinsta en tant que rédacteur technique. Il est un enseignant passionné par l'open source et a écrit plus de 200 articles techniques, principalement autour de JavaScript et de ses frameworks.
Laisser un commentaire