Para as agências de WordPress que gerenciam vários sites de clientes, é essencial ter uma estratégia de backup robusta. No caso de uma interrupção inesperada, falha de plugin ou erro humano, os backups garantem que os dados possam ser restaurados rapidamente, minimizando o tempo de inatividade e reduzindo o risco para o cliente.
Na Kinsta, entendemos o papel crucial que os backups desempenham, e é por isso que oferecemos seis opções de backup: Diário automático, opcional de hora em hora (e a cada seis horas), manual, gerado pelo sistema, para download e backups externos enviados diretamente para o Amazon S3 ou Google Cloud Storage.
Embora o gerenciamento desses backups seja simples por meio do painel MyKinsta, a API da Kinsta oferece ótimas possibilidades para automatizar processos repetitivos.
Imagine simplesmente digitar um comando no Slack ou configurar um cron job para acionar backups de todos os seus sites WordPress na conta de agência Kinsta, sem precisar navegar manualmente por dezenas ou até centenas de painéis de sites.
Essa flexibilidade é uma das muitas vantagens de usar um provedor de hospedagem de sites que prioriza as necessidades de seus clientes, fornecendo ferramentas para criar soluções personalizadas e que economizam tempo.
Este guia explica como aproveitar a API da Kinsta para automatizar backups em vários sites. Quer você esteja se integrando à sua pilha preferida, usando ferramentas como o Slack ou configurando programações automatizadas, este guia fornece o conhecimento necessário para simplificar seu processo de backup e aprimorar seu fluxo de trabalho.
Implementando backups para todos os sites e sites específicos
Antes de entrar na parte de agendamento, é importante primeiro entender como acionar backups para todos os sites em sua conta Kinsta e como direcionar backups para sites ou ambientes específicos usando a API da Kinsta.
Assim que tivermos a base para criar backups, podemos facilmente integrar o agendamento para automatizar o processo.
Acionando backups para todos os sites em uma conta Kinsta
Como em todas as APIs, nem sempre há um único endpoint para fazer tudo o que você precisa – muitas vezes você precisa combinar vários endpoints para alcançar o resultado desejado.
A API da Kinsta não é diferente. Embora existam endpoints específicos para gerenciar backups, esses endpoints exigem determinados parâmetros, como IDs de ambiente, que você obtém fazendo solicitações adicionais a outros endpoints.
Por exemplo, para acionar um backup manual para um site, você precisa do ID do ambiente para esse ambiente específico. Para obter o ID do ambiente, primeiro você precisa do ID do site. Isso significa que você deve fazer várias chamadas de API: uma para obter o ID do site, outra para recuperar o ID do ambiente e, por fim, uma solicitação para acionar o backup.
Passo 1: Obtenha todos os sites WordPress com a API da Kinsta
A primeira etapa é recuperar uma lista de todos os sites associados à sua conta Kinsta. A API da Kinsta fornece um endpoint para que você obtenha esses dados, que incluem IDs de sites, nomes e outros detalhes relevantes. Usando o endpoint GET /sites, você pode obter uma lista de todos os sites na conta da sua empresa.
Aqui está um exemplo usando o Node.js e a API Fetch:
require('dotenv').config();
const KINSTA_API_URL = 'https://api.kinsta.com/v2';
const API_KEY = process.env.KINSTA_API_KEY;
async function getAllSites() {
const response = await fetch(`${KINSTA_API_URL}/sites`, {
headers: {
Authorization: `Bearer ${API_KEY}`
}
});
const data = await response.json();
return data.company.sites; // Returns array of all sites
}Essa função retorna um array de todos os sites em sua conta. Cada site contém informações como o ID, o nome e o(s) ambiente(s) do site.
Passo 2: Obtenha os IDs dos ambientes para cada site WordPress
Cada site pode ter vários ambientes (como produção ou teste), e os backups são acionados por ambiente. Para recuperar os IDs de ambiente de cada site, você faz outra chamada de API para o endpoint GET /sites/{site_id}/environments.
Aqui está um exemplo de função que obtém ambientes para um site específico:
async function getSiteEnvironments(siteId) {
const response = await fetch(`${KINSTA_API_URL}/sites/${siteId}/environments`, {
headers: {
Authorization: `Bearer ${API_KEY}`
}
});
const data = await response.json();
return data.site.environments;
}Passo 3: Acione backups para cada ambiente
Depois de obter os IDs de ambiente, você pode acionar backups para cada ambiente usando o endpoint POST /sites/environments/{env_id}/manual-backups. A API permite que você crie um backup manual fornecendo um ID de ambiente e uma tag opcional para identificar o backup.
Veja a seguir como você pode acionar um backup para um determinado ambiente:
async function createBackup(environmentId, tag) {
const response = await fetch(`${KINSTA_API_URL}/sites/environments/${environmentId}/manual-backups`, {
method: 'POST',
headers: {
Authorization: `Bearer ${API_KEY}`,
'Content-Type': 'application/json'
},
body: JSON.stringify({ tag })
});
if (response.ok) {
console.log(`Backup created for environment ${environmentId} with tag: ${tag}`);
} else {
console.error(`Failed to create backup for environment ${environmentId}`);
}
}Essa função aciona um backup manual para o ID de ambiente fornecido. Você também pode marcar seu backup para facilitar a identificação.
Passo 4: Automatize backups para todos os sites
Agora que você tem funções para buscar todos os sites, recuperar IDs de ambiente e acionar backups, pode combiná-las para criar um script que automatize os backups de todos os sites da sua conta Kinsta.
Aqui está como unir tudo em um único fluxo:
async function backupAllSites() {
const sites = await getAllSites();
for (const site of sites) {
const environments = await getSiteEnvironments(site.id);
for (const environment of environments) {
await createBackup(environment.id, `Backup-${new Date().toISOString()}`);
}
}
console.log('Backups for all sites have been triggered.');
}Essa função percorre todos os sites, recupera seus ambientes e aciona backups para cada ambiente com uma tag com registro de data e hora.
Agora, quando você executa backupAllSites(), ele aciona um backup para cada ambiente em sua conta Kinsta.
Exemplo de comando do Slack
Para facilitar ainda mais o gerenciamento, você pode integrar esse processo de backup em um comando no Slack. Com um aplicativo configurado no Slack, os usuários podem acionar backups para todos os sites com um único comando, como /backup_all_sites.
Aqui está um exemplo rápido de como isso poderia funcionar:
app.command('/backup_all_sites', async ({ ack, say }) => {
await ack();
await backupAllSites();
say('Backups for all sites have been triggered.');
});Acionando backups para sites selecionados usando IDs de ambiente
Em alguns casos, você pode querer acionar backups apenas para sites ou ambientes específicos, em vez de todos os sites em sua conta Kinsta. Isso pode ser útil se você estiver interessado em fazer backup apenas de ambientes de produção ou de determinados sites de alta prioridade.
Usando a API da Kinsta, podemos automatizar backups para ambientes selecionados ao passar um array de IDs de ambiente. Veja como implementar isso.
Passo 1: Passar IDs de Ambiente
Quando você quiser acionar backups para sites selecionados, precisa dos IDs dos ambientes desses sites. Você pode codificar esses IDs, recuperá-los da API da Kinsta, ou passá-los dinamicamente (por exemplo, através de um argumento de linha de comando, comando no Slack, etc.).
Aqui está uma função que aceita um array de IDs de ambiente e aciona backups para cada um:
async function backupSelectedEnvironments(environmentIds, tag) {
for (const envId of environmentIds) {
await createBackup(envId, tag);
}
}A função acima recebe um array de IDs de ambiente dos quais você deseja fazer backup (environmentIds). A função createBackup(envId, tag) aciona o backup para cada ambiente no array usando a função createBackup() (explicada na Etapa 2).
Etapa 2: Acionar o backup
Para acionar o backup real para cada ambiente, use o endpoint POST /sites/environments/{env_id}/manual-backups da API da Kinsta, como fizemos para todos os sites. Veja como isso funciona:
async function createBackup(environmentId, tag) {
const response = await fetch(`${KINSTA_API_URL}/sites/environments/${environmentId}/manual-backups`, {
method: 'POST',
headers: {
Authorization: `Bearer ${API_KEY}`,
'Content-Type': 'application/json'
},
body: JSON.stringify({ tag })
});
if (response.ok) {
console.log(`Backup created for environment ${environmentId} with tag: ${tag}`);
} else {
console.error(`Failed to create backup for environment ${environmentId}: ${response.statusText}`);
}
}Etapa 3: Executar backups para ambientes selecionados
Agora que temos funções para acionar backups e lidar com vários ambientes, podemos combiná-las para fazer backup de ambientes específicos. Neste exemplo, assumimos que já temos os IDs dos ambientes que desejamos fazer backup.
const selectedEnvironments = ['12345', '67890']; // Replace with actual environment IDs
backupSelectedEnvironments(selectedEnvironments, 'Manual Backup');Nesse caso:
- O array
selectedEnvironmentscontém os IDs de ambiente dos quais você deseja fazer backup. - A função
backupSelectedEnvironments()percorre cada ID e aciona o backup com a tag ‘Manual Backup’.
Exemplo de comando do Slack
Se você estiver usando um aplicativo Slack ou uma interface de linha de comando, também poderá permitir que os usuários especifiquem quais ambientes devem fazer backup.
Veja como você pode implementar isso em um aplicativo Slack:
app.command('/backup_selected_envs', async ({ command, ack, say }) => {
await ack();
const [tag, ...envIds] = command.text.split(' '); // First part is the tag, rest are env IDs
await backupSelectedEnvironments(envIds, tag);
say(`Backups triggered for selected environments with tag ${tag}.`);
});O usuário insere um comando como /backup_selected_envs Backup-Tag 12345 67890, em que Backup-Tag é a tag e 12345, 67890 são os IDs de ambiente.
O texto do comando é dividido e os IDs dos ambientes são passados para a função backupSelectedEnvironments().
Após acionar os backups, o aplicativo responde ao usuário confirmando o backup.
Agendamento de backups para seus sites WordPress
Uma das funcionalidades mais poderosas da automação é a capacidade de agendar tarefas em horários específicos, sem intervenção manual.
Agora que já falamos sobre como acionar backups para todos os sites e sites selecionados, a próxima etapa é automatizar esses processos adicionando o agendamento.
Se você quiser agendar backups localmente, em uma plataforma hospedada como a Kinsta ou dinamicamente via Slack, há várias maneiras de implementar isso.
Entendendo as expressões cron
Antes de explorar as diferentes abordagens de agendamento de backups, é importante que você entenda as expressões cron, que são usadas para especificar o tempo das tarefas agendadas em várias plataformas e ferramentas.
As expressões do cron definem quando uma tarefa deve ser executada. Elas são usadas em muitas bibliotecas e serviços de agendamento, como node-cron, node-schedule e até mesmo em tarefas cron do lado do servidor, como as disponíveis na plataforma de hospedagem de aplicativos da Kinsta.
As expressões do cron consistem em cinco campos, cada um controlando um aspecto específico de quando a tarefa deve ser executada. Uma expressão cron típica tem a seguinte aparência:
* * * * *
| | | | |
| | | | └─── Day of the week (0 - 7) (Sunday to Saturday, 0 and 7 represent Sunday)
| | | └────── Month (1 - 12)
| | └──────── Day of the month (1 - 31)
| └────────── Hour (0 - 23)
└──────────── Minute (0 - 59)Vamos detalhar o que cada campo representa:
- Minute: O minuto da hora em que a tarefa deve ser executada (0 – 59).
- Hour: A hora do dia em que a tarefa deve ser executada (0 a 23).
- Day of the month: O dia específico do mês em que a tarefa deve ser executada (1 a 31).
- Month: O mês do ano em que você deve executar a tarefa (1 – 12).
- Day of the week: O dia específico da semana para executar a tarefa (0 a 7, em que 0 e 7 representam domingo).
Você pode usar valores específicos, curingas (*) ou intervalos em cada campo para definir a agenda.
Exemplos de expressões cron:
0 0 * * *: Todos os dias à meia-noite (00:00)0 3 * * 1: Toda segunda-feira às 3h da manhã*/10 * * * *: A cada 10 minutos0 9-18 * * *: A cada hora entre 9 e 18 horas.
Com uma compreensão sólida das expressões cron, podemos agora avançar para diferentes métodos de agendamento de backups para seus sites WordPress usando a API da Kinsta.
Abordagem 1: Agendamento local com node-cron
O pacote node-cron do Node.js pode executar tarefas agendadas com base em uma sintaxe semelhante à do cron. É ideal para executar tarefas automáticas em aplicativos locais ou independentes em Node.js, sendo uma escolha popular para agendar backups, enviar e-mails ou executar outras tarefas recorrentes.
No node-cron, você define uma tarefa (como a função de backup) e usa uma expressão cron para especificar quando a tarefa deve ser executada. A expressão cron consiste em cinco campos que definem o minuto, a hora, o dia do mês, o mês e o dia da semana em que a tarefa deve ser executada.
Primeiro, instale o node-cron em seu projeto:
npm install node-cronDigamos que você queira agendar um backup diário de todos os sites à meia-noite usando o node-cron. Veja como você pode fazer isso:
const cron = require('node-cron');
const { backupAllSites } = require('./app'); // Import the backup function
// Schedule to run backups for all sites at midnight every day
cron.schedule('0 0 * * *', () => {
console.log('Running scheduled backup for all sites at midnight...');
backupAllSites();
});Da mesma forma, se você quiser fazer o backup de ambientes selecionados às 2h da manhã todos os dias, poderá programá-lo da seguinte forma:
cron.schedule('0 2 * * *', () => {
const environmentIds = ['env12345', 'env67890']; // Specific environments to back up
console.log('Running scheduled backup for selected environments...');
backupSelectedEnvironments(environmentIds, 'Scheduled Backup');
});Abordagem 2: Usando cron jobs em hospedagem na nuvem (como Kinsta)
Ao implantar seu aplicativo Node.js em uma plataforma como a Kinsta, você pode aproveitar a funcionalidade do Cron jobs integrada para agendar tarefas como backups. No entanto, configurar cron jobs em ambientes de nuvem requer uma estrutura ligeiramente diferente das ferramentas de agendamento locais, como o node-cron.
Quando você implanta seu aplicativo na Kinsta, ele precisa ter um processo web em execução (mesmo que não esteja realmente atendendo ao tráfego da web).
Para garantir que seu projeto seja executado corretamente e não chame automaticamente as funções de backup, você pode criar um arquivo que execute um servidor web simples. Esse arquivo atua como um processo web “fictício”, enquanto os trabalhos do cron lidam com a lógica de backup.
Você pode adicionar este código:
require('http').createServer((req, res) => {
res.writeHead(302, { Location: 'https://www.google.com' });
res.end();
}).listen(process.env.PORT);Dessa forma, você pode configurar o comando de script para distinguir entre o processo web (start) e o processo de cron jobs (cron).
"scripts": {
"start": "node index.js", // Web process
"cron": "node app.js" // Cron job process
},Por fim, configure o cron jobs na Kinsta para chamar a função de backup no horário específico. Usando as configurações do cron job, você pode definir o comando para executar o backup.
No painel MyKinsta, na aba Processos do aplicativo, configure o comando para o processo web como:
npm run startE defina o comando do Cron job para:
npm run cronPara executar o cron job em um horário específico (todos os dias às 11h30), defina a expressão cron assim:
30 11 * * *Este comando acionará a função backupAllSites() todos os dias às 11:30 AM.
Configurando um cron job na Hospedagem de Aplicativos da Kinsta.
Abordagem 3: Agendamento com node-schedule
Outra biblioteca Node.js, node-schedule, pode agendar tarefas usando o formato cron e também suporta agendamentos mais complexos.
Aqui está um exemplo que permite que os usuários agendem backups via Slack usando o formato cron do node-schedule:
const schedule = require('node-schedule');
const { backupAllSites } = require('./app');
// Slack command to schedule backups dynamically
app.command('/schedule_backup', async ({ command, ack, say }) => {
await ack();
// Extract hour and minute from the command (expects HH:MM format)
const [hour, minute] = command.text.split(':');
// Validate input
if (!hour || !minute) {
say('Please specify the time in HH:MM format.');
return;
}
// Schedule the backup using node-schedule's cron-like format
const job = schedule.scheduleJob(`${minute} ${hour} * * *`, () => {
console.log(`Running scheduled backup at ${hour}:${minute}`);
backupAllSites(); // This triggers the backup for all sites
});
say(`Backup scheduled at ${hour}:${minute} successfully.`);
});Por exemplo, um usuário poderia executar o seguinte comando do Slack para agendar um backup para as 23h30:
/schedule_backup 23:30Depois de executar esse comando, o backup será programado para ser executado às 23h30 todos os dias. A resposta do Slack pode ser semelhante a:
Backup scheduled at 23:30 successfully.Essa abordagem permite que os usuários agendem backups dinamicamente no Slack simplesmente especificando a hora sem precisar interagir com o servidor ou com o código do aplicativo. É uma maneira flexível e poderosa de lidar com tarefas agendadas, como backups, de uma maneira fácil de usar.
Resumo
Agendar backups em vários sites WordPress é bom para agências que gerenciam vários sites de clientes. Automatizar esses backups não apenas economiza tempo, mas também garante consistência, reduz o risco de erro humano e proporciona tranquilidade.
Essa solução beneficiaria sua agência? Gostaríamos muito de saber o que você pensa. Compartilhe-as na seção de comentários abaixo!
Deixe um comentário