Os backups oferecem aos proprietários de sites uma rede de segurança que aumenta a confiança em caso de imprevistos. Os usuários do serviço de hospedagem gerenciada de WordPress da Kinsta se beneficiam de seis tipos de backups: diários automáticos, a cada hora (opcional), manuais, criados automaticamente pelo sistema, que podem ser baixados e também backups externos, enviados diretamente para o Amazon S3 ou Google Cloud Storage.
Você pode gerenciar esses backups com facilidade no painel MyKinsta. E agora a API da Kinsta abre as portas para que você possa trabalhar com sites WordPress e seus backups. De agências com seus painéis de controle para gerenciar centenas de instalações a equipes que buscam aproveitar ferramentas de produtividade como o Slack, a API da Kinsta pode ajudar a conectar tudo isso.
Este guia analisa os diversos endpoints de backup disponíveis através da API, o potencial deles e como você pode utilizá-los para administrar backups em um ambiente do Slack.
Entendendo a API da Kinsta
A API da Kinsta é uma ferramenta poderosa que permite que você interaja com os serviços da Kinsta, como sites WordPress hospedados, de forma programática. Ela pode ajudar você a automatizar várias tarefas relacionadas ao gerenciamento do WordPress, incluindo a criação de sites, a recuperação de informações do site, a obtenção do status de um site, a navegação e a restauração de backups e muito mais.
Para utilizar a API da Kinsta, é necessário ter uma conta com ao menos um site, aplicativo ou banco de dados do WordPress no MyKinsta. Também é preciso gerar uma chave de API para autenticação e acesso à sua conta.
Para gerar uma chave API:
- Vá para o painel MyKinsta.
- Navegue até a página Chaves API (Seu nome > Configurações da empresa > Chaves API).
- Clique em Criar chave API.
- Escolha uma expiração ou defina uma data de início personalizada e o número de horas para a chave expirar.
- Dê à chave um nome exclusivo.
- Clique em Gerar.
Depois de criar uma chave API, faça uma cópia dela e guarde em um lugar seguro (recomenda-se o uso de um gerenciador de senhas), pois essa é a única ocasião em que ela será exibida no MyKinsta. Você pode gerar várias chaves API, que serão listadas na página Chaves API. Se você precisar revogar uma chave API, clique no botão Revogar ao lado de seu nome e data de validade.
Gerenciando backups de sites WordPress com a API da Kinsta
A API da Kinsta tem endpoints para essas operações relacionadas a backups:
- Listar backups manuais, programados e gerados pelo sistema
- Listar backups que podem ser baixados
- Restaurar um backup agendado, manual ou gerado pelo sistema
Para interagir com esses endpoints, você precisará da chave API que gerou anteriormente. Vamos explorar esses endpoints e depois integrá-los a um Slackbot para que você possa usar os comandos Slash do Slack para interagir com a API da Kinsta.
Como obter backups manuais, programados e gerados pelo sistema com a API da Kinsta
Quando você navega para um site WordPress específico no seu painel MyKinsta e clicar na aba Backups, você encontrará uma lista de backups, incluindo backups diários, a cada hora (se ativados), manuais e gerados pelo sistema.
Agora, se você deseja acessar esses dados ou executar ações de um aplicativo, ou plataforma externa, nossa API simplifica o processo.
Você pode recuperar os detalhes do backup, como ID, nome, tipo e hora de criação, de forma programática. Ao usar a API em suas próprias ferramentas, você pode eliminar a necessidade de acesso ao painel sempre que essas informações forem necessárias
Para acessar este endpoint, obtenha o ID do ambiente do seu site programaticamente por meio do get site environment endpoint, que retorna detalhes sobre o ambiente do seu site, incluindo seu 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"
}
}
]
}
}Quando você souber o ID do ambiente do seu site, poderá enviar uma solicitação GET para https://api.kinsta.com/v2/sites/environments/${envId}/backups para recuperar uma array de todos os backups do seu site:
curl -i -X GET \
'https://api.kinsta.com/v2/sites/environments/{env_id}/backups' \
-H 'Authorization: Bearer 'Isso retornará um objeto com uma array de backups, que você pode inserir em seu cliente e também manipular seus dados:
{
"environment": {
"display_name": "MyEnvironment",
"backups": [
{
"id": 123456789,
"name": "mySiteName-1234567890-backupType",
"note": "Daily Auto Backup",
"type": "manual",
"created_at": 1665382600770
}
]
}
}Como restaurar um backup programado, manual ou gerado pelo sistema com a API da Kinsta
Com a API da Kinsta, você também pode restaurar um backup específico da lista gerada para um ambiente usando uma solicitação POST.
Tudo o que você precisa é do ID do backup, do ID do ambiente de destino e do nome do ambiente do backup. Essa ação também elimina a necessidade de você revisitar o painel MyKinsta para tarefas de restauração.
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"
}'A resposta a esta solicitação inclui um status da operação e um ID da operação, permitindo que você acompanhe programaticamente o progresso da restauração com nosso endpoint de status da operação:
{
"operation_id": "backups:restore-54fb80af-576c-4fdc-ba4f-b596c83f15a1",
"message": "Restoring a backup to environment in progress",
"status": 202
}Como obter backups para download com a API da Kinsta
Embora atualmente não haja um endpoint para criar backups para download, você pode acessar os backups existentes para download e seus links de download de forma programática.
Isso pode ser feito enviando uma solicitação GET para https://api.kinsta.com/v2/sites/environments/{env_id}/downloadable-backups para recuperar uma array de todos os backups para download do seu site:
curl -i -X GET \
'https://api.kinsta.com/v2/sites/environments/{env_id}/downloadable-backups' \
-H 'Authorization: Bearer 'Cada backup para download na array inclui um ID, registro de data e hora de criação, link de download, registro de data e hora de expiração e um status que indica se o processo de geração está em andamento:
{
"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
}
]
}
}Clicando no link de download solicita o download do arquivo zip do backup, permitindo que você incorpore o link no seu aplicativo para acesso e download convenientes pelos seus usuários.
Implementação de comandos Slack Slash para gerenciar backups com a API da Kinsta
Em um aba recente, foi detalhado o processo de build de um Slackbot utilizando Node.js e a API da Kinsta para gerenciamento de sites. O guia descreveu a criação de um Slackbot e o estabelecimento da interação com a API da Kinsta por meio de um aplicativo Node.js hospedado em nossa plataforma de hospedagem de aplicativos.
Aqui, você se concentrará na criação de novos comandos Slack Slash para os três endpoints de backup. Para continuar aqui, primeiro você deve revisar o guia anterior para entender o aplicativo Node.js e como configurar seu Slackbot personalizado.
Depois de concluído, você poderá clonar nosso projeto inicial com o Git:
- Navegue até o diretório de sua preferência para armazenar seu código e execute o seguinte comando no terminal:
git clone -b tutorial-1 --single-branch https://github.com/olawanlejoel/SlackBot-KinstaAPI.git - Vá para a pasta do projeto e instale todas as dependências necessárias:
cd SlackBot-KinstaAPI npm install
Como criar comandos de barra no Slack para lidar com backups
No artigo anterior, foram criados cinco comandos slash para lidar com o seguinte:
/site_id [site name]: Usado para recuperar o ID do site./environment_id [site name]: Usado para recuperar o ID do ambiente./clear_site_cache [environment id]: Usado para limpar o cache do site./restart_php_engine [environment id]: Usado para reiniciar o mecanismo PHP de um site./operation_status [operation id]: Usado para verificar o status de uma operação.
Para este guia, você adicionará três novos comandos. Para criar comandos Slash no Slack, navegue até seu aplicativo Slack, clique na opção de menu Slash Commands na barra lateral esquerda e clique no botão Create New Command. Você criará três comandos com as informações abaixo:
| Comando | Descrição curta | Dica de uso |
| /get_backups | Recupera todos os backups do site com suas informações associadas | [ID do ambiente] |
| /get_downloadable_backups | Recupera todos os backups para download do seu site com as informações e o link associados | [ID do ambiente] |
| /restore_backup | Restaura um backup agendado, manual ou gerado pelo sistema em um ambiente | [ID do ambiente de destino] [ID do backup] [Nome do ambiente] |
Depois de criar esses comandos, você pode verificar seu ambiente do Slack digitando /. Você notará que esses comandos foram adicionados.
A próxima etapa é implementar a interação com a API da Kinsta para que os dados passados do Slack possam ser recebidos e usados para consultar o endpoint específico da API.
Implementando solicitações de busca do Node.js para operações de backup
Depois de criar os comandos de barra necessários, agora você pode modificar seu aplicativo Node.js para responder a eles. Vamos começar criando funções assíncronas para interagir com cada endpoint.
No arquivo app.js, vamos definir três funções:
getBackups(environmentId): Obtém informações sobre backups para um ambiente específico.getDownloadableBackups(environmentId): Recupera backups que podem ser baixados para um determinado ambiente.restoreBackup(targetEnvironmentId, backupId, environmentName): Inicia um processo de restauração para um determinado backup em um ambiente específico.
Aqui está a solicitação Fetch para cada função:
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;
}Cada função é construída para se comunicar com a API da Kinsta utilizando a API Fetch do JavaScript. Os parâmetros para IDs de ambiente, IDs de backup e nomes de ambiente são entradas esperadas, que devem ser recebidas dos comandos do Slack e, em seguida, passadas para essas funções para execução.
Para simplificar o código e evitar repetições, você notará o uso de três variáveis usadas para armazenar elementos essenciais: A URL da API básica e os cabeçalhos para solicitações 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}`,
};Além disso, chaves e tokens confidenciais, como o segredo de assinatura do Slack, o token do bot, o token do aplicativo, o ID da empresa e a chave da API, são armazenados com segurança no arquivo .env.
SLACK_SIGNING_SECRET="YOUR_SIGNING_SECRET"
SLACK_BOT_TOKEN="xoxb-YOUR_BOT_TOKEN"
APP_TOKEN="xapp-YOUR_APP_TOKEN"Com essas funções e chaves em vigor, a próxima etapa envolve a configuração dos comandos do Slack. Essa configuração implica receber valores de entrada do Slack, invocar os métodos relevantes com base nessa entrada e enviar uma resposta específica de volta ao Slack.
Configuração de comandos do Slash com o Node.js para gerenciar backups
Para configurar um comando do Slash, você usará a função app.command(), que funciona de forma semelhante aos ouvintes de eventos em JavaScript. Você especifica o comando que deseja ouvir e, em seguida, cria uma função callback assíncrona para definir a ação desejada. Essa função recebe três parâmetros:
command: Contém os detalhes do comando de barra enviado pelo usuário.ack: Confirma o recebimento do comando de barra.say: Envia uma mensagem de volta ao canal do Slack.
Aqui está a configuração para os três comandos:
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}`
);
}
});Os comandos Slash acima gerenciam várias tarefas relacionadas a backup: /get_backups recupera detalhes de backup específicos do ambiente, /get_downloadable_backups busca informações de backup para download e /restore_backup inicia a restauração com base nos parâmetros fornecidos.
Cada comando reconhece o recebimento, processa a entrada, aciona as respectivas funções (getBackups(), getDownloadableBackups(), restoreBackup()), formata as respostas e comunica os resultados de volta ao Slack, oferecendo uma interface abrangente para operações de backup.
Agora, ao implantar seu aplicativo, você pode visitar o Slack para testar os vários comandos.
Você pode acessar o código completo deste projeto em nosso repositório do GitHub.
Resumo
Neste guia, você aprendeu como usar eficientemente os endpoints de backup mais recentes integrados à API da Kinsta. Esses endpoints possibilitam a incorporação suave das operações de backup nos seus aplicativos de frontend, a criação de pipelines e a execução de diversas tarefas que facilitam a gestão dos seus sites de maneira programática.
A API da Kinsta oferece muitos recursos além desses, portanto, você é incentivado a explorar endpoints adicionais e pensar em maneiras inovadoras de aproveitá-los em seus projetos.
Como você atualmente utiliza a API da Kinsta? Há alguma funcionalidade específica que você gostaria de ver introduzida ou disponibilizada no futuro?
Deixe um comentário