Noi di Kinsta aiutiamo a supportare migliaia di siti web di tutte le dimensioni. Una cosa che li accomuna tutti è la necessità di un database. Indipendentemente dalle dimensioni di un sito, è il database a contenere le sue informazioni. Ecco perché permettiamo di creare e gestire i database utilizzando le API di Kinsta.
Sebbene si possano gestire i database tramite la dashboard di MyKinsta, l’API di Kinsta offre una maggiore flessibilità se si ha bisogno di un approccio programmatico. Permette di creare, aggiornare e cancellare i database e di leggerli in una certa misura. Tuttavia, il grande vantaggio è l’integrazione dell’API di Kinsta (e di conseguenza del database) con gli strumenti e i flussi di lavoro esistenti.
Questo post vi mostrerà come creare e gestire i database utilizzando l’API di Kinsta. Inoltre, ne illustrerà i vantaggi, le modalità di accesso agli endpoint e l’inserimento di questo approccio nel vostro flusso di lavoro complessivo. Iniziamo con i vantaggi e le funzionalità.
Le funzionalità dell’API di Kinsta
L’API di Kinsta è il modo programmatico per interagire con il vostro server Kinsta. Offriamo molti endpoint per coprire vari modi di gestire i siti, come ad esempio lavorare con gli ambienti, i temi e i plugin di WordPress, le metriche delle applicazioni e altro ancora.
Ciò si estende anche ai database attraverso la tipica architettura CRUD:
- Utilizzando un singolo endpoint, è possibile creare un nuovo database per il proprio sito, scegliere la posizione del server e impostare le credenziali.
- Esiste un metodo per recuperare tutti i database del server utilizzando l’ID dell’azienda. Da lì, si possono recuperare un database specifico e i suoi dettagli utilizzando il suo ID individuale.
- L’API permette di modificare le dimensioni e il nome visualizzato del database. Questo può essere utile in alcune applicazioni di scalabilità delle risorse.
- È possibile rimuovere un database quando non serve più. L’operazione è semplice e utilizza un solo comando.
Nel complesso, è possibile sfruttare questi endpoint e iniziare a semplificare l’intero flusso di lavoro della gestione dei database. In seguito, esploreremo questo aspetto in modo più dettagliato. Per prima cosa, parliamo del perché usare l’API di Kinsta per gestire i database.
I vantaggi della gestione dei database tramite l’API di Kinsta
Ovviamente non forniremmo un’API dedicata alla gestione dei database senza che questa offra alcuni vantaggi interessanti rispetto alla dashboard MyKinsta. Entrambe possono essere inserite nel vostro flusso di lavoro, anche se l’API di Kinsta offre alcuni modi specifici per sbloccare nuove possibilità.
1. Ottimizzare i processi di gestione attuali
Uno dei principali vantaggi della gestione dei database tramite l’API di Kinsta è la possibilità di snellire i passaggi che normalmente si compiono. Utilizzando la dashboard MyKinsta, avete già un flusso di lavoro efficiente. Ad esempio, ogni sito WordPress dà accesso al database del vostro sito tramite phpMyAdmin:
Ciò offre un’interfaccia familiare per apportare modifiche. Per le applicazioni, la schermata Database di MyKinsta sarà il vostro punto di riferimento:
Tuttavia, è possibile saltare tutti questi passaggi utilizzando i nostri endpoint API. Se già gestite altri servizi programmatici per il vostro sito, questo dovrebbe essere un gioco da ragazzi. Il tempo che risparmierete automatizzando questo flusso di lavoro potrebbe avere un impatto positivo sulla vostra efficienza.
2. Le possibilità di automazione a disposizione sono pressoché infinite
Come per tutti gli endpoint dell’API di Kinsta, è possibile automatizzare attività che altrimenti richiederebbero l’accesso alla dashboard di MyKinsta. Parleremo più avanti delle opportunità di integrazione. In breve, se già utilizzate strumenti e script esistenti, l’automazione della gestione del vostro database può diventare parte di quel processo.
Ad esempio, potreste voler creare un nuovo database ogni volta che create un nuovo sito. Potreste impostare dei criteri predefiniti all’interno del codice, degli strumenti e degli script per eliminare i database in modo automatico. Anche i flussi di lavoro che incorporano lo scaling delle risorse potrebbero trarre vantaggio da questo aspetto, dato che è possibile aggiornare il tipo di risorsa di un database.
Come nel caso di una razionalizzazione mirata, l’automazione del flusso di lavoro avrà un ulteriore impatto sul tempo (e sulle spese) che dedicate alla gestione dei database.
3. Potenziale integrazione con altri strumenti e piattaforme
Le API, in generale, offrono un modo eccellente per integrarsi con quasi tutti gli altri strumenti e piattaforme disponibili, anche quando non esistono API pronte all’uso. Potete utilizzare servizi come Zapier o If This Then That (IFTTT) per collegare tra loro strumenti di cui il vostro server Kinsta potrebbe far parte.
In effetti, molte configurazioni richiedono l’integrazione di altri servizi per un’esperienza ottimale. Considerate le vostre pipeline di integrazione e distribuzione continua (CI/CD) che utilizzano TeamCity, Travis CI o Buddy. L’API Kinsta, come parte della vostra catena di strumenti, può aiutarvi a creare un flusso di lavoro coeso dallo sviluppo alla produzione.
Nelle prossime sezioni tratteremo i diversi metodi e le richieste che l’API Kinsta mette a disposizione. Alla fine del post, vedremo come utilizzare le informazioni ottenute in alcuni scenari di esempio.
Cosa serve per gestire i database con l’API di Kinsta
L’utilizzo dell’endpoint database è un processo semplice, come qualsiasi altro endpoint dell’API Kinsta. In questa sede non ci addentreremo in tutte le sottigliezze di ogni azione o flusso di lavoro, anche se più avanti ne parleremo ancora.
Per accedere all’endpoint database è necessario avere a disposizione alcune informazioni, tra cui un token API valido. Generarlo permetterà di accedere all’API, cosa che vale per ogni endpoint. Infatti, abbiamo un endpoint di autenticazione per questo scopo.
È possibile creare una chiave API nella schermata Impostazioni azienda > Chiavi API della dashboard di MyKinsta.
Per accedere alla maggior parte degli endpoint è necessario anche l’ID azienda. Si tratta essenzialmente dell’ID del server, che trovate nella barra degli strumenti del browser quando ci si connette alla dashboard di MyKinsta:
Il flusso di lavoro tipico quando si utilizzano gli endpoint dell’API di Kinsta consiste nel convalidare la chiave API, recuperare i dati associati all’ID dell’azienda, recuperare i dati associati all’ID del sito ed elaborare tali dati. Questa fase finale richiede che forniate i parametri giusti per la richiesta.
Naturalmente, questi parametri variano a seconda di ciò che volete ottenere. Nel corso della gestione dei database, ci occuperemo di questi parametri.
Creare un nuovo database utilizzando l’API di Kinsta
La creazione di un database richiede il maggior numero di operazioni tra tutte le richieste che tratteremo qui, ma è comunque un’operazione semplice. Si tratta di inviare una richiesta all’indirizzo POST e ci sono otto attributi necessari affinché la richiesta sia valida. Questi includono la posizione del server, il tipo di risorsa, il tipo di database e le credenziali del database.
Una volta definiti questi parametri, procedete con il convalidare la vostra chiave API e creare il vostro database:
import fetch from 'node-fetch';
async function run() {
const resp = await fetch(
`https://api.kinsta.com/v2/databases`,
{
method: 'POST',
headers: {
'Content-Type': 'application/json',
Authorization: 'Bearer <YOUR_TOKEN_HERE>'
},
body: JSON.stringify({
company_id: '54fb80af-576c-4fdc-ba4f-b596c83f15a1',
location: 'us-central1',
resource_type: 'db1',
display_name: 'test-db',
db_name: 'test-db',
db_password: 'example-password',
db_user: 'example-user',
type: 'postgresql',
version: '15'
})
}
);
const data = await resp.json();
console.log(data);
}
run();
Per ogni endpoint, riceverete i dati richiesti in formato JSON:
{
"database": {
"id": "54fb80af-576c-4fdc-ba4f-b596c83f15a1"
}
}
Se la richiesta non va a buon fine, vedrete l’informazione all’interno del JSON di ritorno:
{
"message": "No or invalid API key provided to the request",
"status": 401,
"data": null
}
Come per ogni richiesta che effettuate, dovete cercare di mantenere sicuri i dati che inviate e ricevete. La convalida della chiave API è un modo per farlo, ma ci sono altri fattori importanti:
- Non inserite nelle richieste informazioni “hard code”, come gli ID o la chiave API. Utilizzate invece le variabili d’ambiente per rendere quasi anonimo il vostro codice.
- Controllate regolarmente gli aggiornamenti dell’API di Kinsta, poiché i dettagli degli endpoint potrebbero cambiare o potrebbero essere disponibili metodi di protezione dei dati più moderni.
- Il debug delle richieste API potrebbe essere un’attività a cui dover dedicare molto tempo, soprattutto nel caso di integrazioni complesse. In questo caso vi saranno utili i codici di risposta restituiti dalla richiesta, i log degli errori di Kinsta e i tipici strumenti e tecniche di debug.
La buona notizia è che molte di queste informazioni possono essere trasferite ad altre azioni relative all’endpoint database. Nella prossima sezione vedremo come eliminarli.
Recuperare e cancellare i database esistenti
Recuperare e cancellare i vostri database richiede pochi secondi e riutilizza gran parte del codice che avete già implementato al momento della creazione dei database. La richiesta GET richiede semplicemente che specifichiate il metodo all’interno del vostro codice:
import fetch from 'node-fetch';
async function run() {
const query = new URLSearchParams({
internal: 'true',
external: 'true'
}).toString();
const id = 'YOUR_id_PARAMETER';
const resp = await fetch(
`https://api.kinsta.com/v2/databases/${id}?${query}`,
{
method: 'GET',
headers: {
Authorization: 'Bearer <YOUR_TOKEN_HERE>'
}
}
);
const data = await resp.text();
console.log(data);
}
run();
Questo restituirà un elenco di informazioni relative ai vostri database che include dettagli sui limiti di CPU e memoria, l’hostname e la porta interna e molto altro ancora:
{
"database": {
"id": "54fb80af-576c-4fdc-ba4f-b596c83f15a1",
"name": "unique-db-name",
"display_name": "firstsite-db",
"status": "ready",
"created_at": 1668697088806,
"memory_limit": 250,
"cpu_limit": 250,
"storage_size": 1000,
"type": "postgresql",
"version": "14",
"cluster": {
"id": "54fb80af-576c-4fdc-ba4f-b596c83f15a1",
"location": "europe-west3",
"display_name": "Frankfurt, Germany Europe"
},
"resource_type_name": "db1",
"internal_hostname": "some-name.dns.svc.cluster.local",
"internal_port": "5432",
"internal_connections": [
{
"id": "54fb80af-576c-4fdc-ba4f-b596c83f15a1",
"type": "appResource"
}
],
"data": {
"db_name": "firstsite-db",
"db_password": "password",
"db_root_password": "password",
"db_user": "username"
},
"external_connection_string": "postgresql://username:password@localhost:31866/firstsite-db",
"external_hostname": "firstsite-db-postgresql.external.kinsta.app",
"external_port": "31866"
}
}
Cancellare un database è altrettanto semplice. Inviate il metodo DELETE e l’ID all’endpoint database:
…
const resp = await fetch(
`https://api.kinsta.com/v2/databases/${id}`,
{
method: 'DELETE',
headers: {
…
Tuttavia, a differenza dell’utilizzo della dashboard di MyKinsta, dovrete prestare ulteriore attenzione quando cancellate i database con l’API. In questo caso, non riceverete alcun messaggio di conferma o “buffer”. Per questo motivo, potreste anche prevedere una gestione degli errori o dei controlli per assicurarvi di voler davvero eliminare il database per sempre.
Come l’API di Kinsta aiuta ad aggiornare i database
Lasciamo per ultimo l’aggiornamento dei database perché, sebbene all’apparenza sembri un’operazione semplice e limitata, questa richiesta può offrire alcune opportunità uniche.
In apparenza, gli aggiornamenti offrono poche possibilità di modifica. Gli unici parametri che si possono modificare sono il nome del database e il suo tipo di risorsa:
{
"resource_type": "db1",
"display_name": "test-db"
}
In questo caso gli aggiornamenti del database possono inserirsi bene nell’intero flusso di lavoro di sviluppo o di gestione del sistema. Ad esempio, il database potrebbe essere un database che passa da uno stato all’altro e da un ambiente all’altro. In momenti diversi, potreste effettuare un aggiornamento che rinomini il database in base alle convenzioni del progetto, allo stato di uno sprint o a qualsiasi altra cosa vogliate.
Il tipo di risorsa è un modo semplice per modificare al volo le dimensioni e le prestazioni del database. Ciò permette di adattare il database alle variabili del progetto o alla domanda del pubblico per il vostro sito. Parleremo di questo aspetto più avanti.
L’importanza di resource_type nel vertical scaling
La scalabilità è un elemento vitale di un sito web moderno e il vostro non dovrebbe fare eccezione. Per questo motivo, l’API di Kinsta offre il parametro resource_type. Quando si parla di scalabilità verticale, questo parametro potrebbe essere in prima linea nella vostra strategia. Inoltre, basta una sola riga per modificare le risorse del vostro database e allocarne di più o di meno:
import fetch from 'node-fetch';
async function run() {
const id = 'YOUR_id_PARAMETER';
const resp = await fetch(
`https://api.kinsta.com/v2/databases/${id}`,
{
method: 'PUT',
headers: {
'Content-Type': 'application/json',
Authorization: 'Bearer <YOUR_TOKEN_HERE>'
},
body: JSON.stringify({
resource_type: 'db1',
display_name: 'test-db'
})
}
);
const data = await resp.json();
console.log(data);
}
run();
Esistono otto tipi diversi tra cui scegliere e, in generale, più alto è il numero, maggiori sono le risorse allocate – quindi db8 vi darà più di db1.
In questo modo potete aumentare o diminuire le risorse in modo molto rapido, a seconda delle vostre esigenze.
Ad esempio, se il traffico aumenta o se dovete eseguire attività di database più intensive, potete aumentare le risorse a un livello superiore.
Integrazione con altri endpoint API di Kinsta
Per estensione, potete utilizzare l’endpoint dei database insieme ad altri endpoint dell’API di Kinsta per creare un sistema di gestione dei database completo o incorporare tale gestione in altri flussi di lavoro.
Un ottimo approccio è l’opportunità di vertical scaling descritta nell’ultima sezione. Tuttavia, ce ne sono molti altri in base alle esigenze del vostro sito:
- Potreste creare un database nello stesso momento in cui avviate una nuova applicazione. Questo può includere tutte le informazioni rilevanti, come la posizione del server e le credenziali.
- Come parte del processo di distribuzione, potete aggiornare il tipo di risorsa del database in base al carico che vi aspettate di ricevere.
- Richiedendo i file di log e le metriche del sito, potete creare un metodo automatico e programmatico per scalare le risorse del database del vostro sito senza dover intervenire.
Questo è un elemento cruciale del vostro flusso di lavoro di gestione del database, ovvero l’utilizzo delle informazioni che richiedete. Analizziamo questo aspetto nella penultima sezione.
Utilizzare le informazioni sul database dall’API di Kinsta nel proprio flusso di lavoro
Molti progetti sono costituiti da più fasi, come lo sviluppo iniziale, lo staging, i test e la produzione. La disponibilità dell’API di Kinsta può aiutarvi a gestire molte attività in associazione con altri strumenti. La creazione e la gestione dei database può essere un ingranaggio fondamentale.
Ad esempio, quando create un nuovo branch di funzionalità all’interno del sistema di controllo della versione (VCS) che avete scelto, potete attivare un processo di creazione di un nuovo database utilizzando l’API di Kinsta.
Ecco un esempio semplificato di come attivare la creazione di un database utilizzando l’API:
import fetch from 'node-fetch';
async function createDatabase(databaseName) {
const apiToken = 'your_api_token';
const companyId = 'your_company_id';
const response = await fetch('https://api.kinsta.com/v2/databases', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${apiToken}`
},
body: JSON.stringify({
company_id: companyId,
location: 'us-central1',
resource_type: 'db1',
display_name: databaseName,
db_name: databaseName,
db_password: 'example-password',
db_user: 'example-user',
type: 'postgresql',
version: '15'
})
});
if (response.ok) {
const data = await response.json();
console.log(`Database '${databaseName}' created successfully.`);
console.log('Database details:', data);
} else {
console.error(`Error creating database '${databaseName}':`, response.statusText);
}
}
// Usage example
const featureBranchName = 'feature/new-blog-section';
const databaseName = `db_${featureBranchName}`;
createDatabase(databaseName);
Ecco un esempio tipico e multiuso in cui definiamo una funzione per creare un database che effettua una richiesta POST all’endpoint database. Il nostro esempio di utilizzo mostra il processo: una variabile contiene il percorso del branch della funzione Git, che poi utilizziamo come parametro per la funzione databaseName. Da qui, possiamo attivare il processo di creazione in base al nome dinamico del database.
Con questo approccio alla creazione automatica dei database, potete assicurarvi che le fasi o le funzioni abbiano un database dedicato. In questo modo sarà più facile gestire il flusso di lavoro dello sviluppo, avrete una base più pulita su cui lavorare e ridurrete il rischio di conflitti.
Integrare le informazioni del database negli strumenti di collaborazione
Un altro caso d’uso comune e prezioso per la gestione dei database con l’API di Kinsta è quello di fornire aggiornamenti sullo stato dei lavori ai vostri strumenti di collaborazione, come Slack o Microsoft Teams. Ad esempio, potete gestire un canale separato che pubblichi solo gli stati dei database.
In questo modo potrete tenere il vostro team aggiornato sullo stato e sulla disponibilità dei database. Questo non solo favorisce una migliore comunicazione e collaborazione, ma può anche aumentare il livello di proattività nei confronti di errori e problemi.
Questo tipo di integrazione offre molti altri vantaggi:
- Migliorare la visibilità. Potete aggiornare tutti sullo stato dei vostri database. In questo modo tutti saranno al corrente di eventuali problemi o di attività di manutenzione imminenti.
- Migliorare la reattività. Potrete anche avvisare i membri del team interessati quando un database richiede attenzione. Questo è il catalizzatore diretto dell’essere proattivi, di cui abbiamo parlato.
- Facilitare la discussione. La piattaforma centralizzata consente a voi e al vostro team di discutere di argomenti relativi al database in questione. Questo sforzo collaborativo può migliorare la risoluzione dei problemi, la condivisione delle conoscenze e molto altro ancora.
- Semplificare la comunicazione. Il flusso automatico di messaggi elimina la necessità di notifiche e aggiornamenti manuali.
Collegare l’API di Kinsta con l’endpoint di autenticazione di uno strumento sembra complesso sulla carta, ma in pratica non ci vuole molto:
import fetch from 'node-fetch';
const { IncomingWebhook } = require('@slack/webhook');
// Set up the Slack webhook URL (using an environment variable)
const slackWebhookUrl = process.env.SLACK_WEBHOOK_URL;
const webhook = new IncomingWebhook(slackWebhookUrl);
async function sendSlackNotification(message) {
try {
await webhook.send({
text: message
});
console.log('Slack notification sent successfully.');
} catch (error) {
console.error('Error sending Slack notification:', error);
}
}
async function getDatabases() {
const apiToken = process.env.KINSTA_API_TOKEN;
const companyId = process.env.KINSTA_COMPANY_ID;
const query = new URLSearchParams({
company: companyId,
limit: '10',
offset: '3'
}).toString();
try {
const response = await fetch(`https://api.kinsta.com/v2/databases?${query}`, {
method: 'GET',
headers: {
'Authorization': `Bearer ${apiToken}`
}
});
if (response.ok) {
const data = await response.json();
console.log('Retrieved databases:', data);
// Check the status of each database and send Slack notifications if necessary
data.forEach(database => {
if (database.status !== 'ready') {
const message = `Database '${database.display_name}' is in status '${database.status}'. Please check.`;
sendSlackNotification(message);
}
});
} else {
console.error('Error retrieving databases:', response.statusText);
}
} catch (error) {
console.error('Error retrieving databases:', error);
}
}
// Usage example
getDatabases();
In questo frammento di codice, definiamo una funzione che utilizza un webhook di Slack per inviare messaggi a un canale Slack. Poi, eseguiamo una richiesta a GET per recuperare un elenco di database associati al nostro server. Per i database che non hanno uno stato “pronto”, inviamo una notifica al canale Slack.
Questi sono solo due modi rapidi per integrare l’API di Kinsta con altre piattaforme per gestire i vostri database. In ogni caso, potrete ottenere risultati migliori per i progetti e una maggiore efficienza sviluppando al contempo un servizio migliore.
Riepilogo
La gestione dei database è un aspetto talmente importante nella gestione di un progetto o di un’applicazione WordPress che vi abbiamo fornito l’endpoint database all’interno dell’API di Kinsta. Potete utilizzarlo per semplificare il processo di gestione del database e automatizzare attività specifiche per le quali avreste altrimenti bisogno della dashboard MyKinsta.
Sebbene i metodi per realizzare queste attività siano semplici, avete a disposizione un grande controllo. Ad esempio, potete semplicemente aggiungere o eliminare nuovi database. Esistono molti modi “creativi” per utilizzare queste richieste, come lo scaling delle risorse, la manutenzione generale dei database e molto altro ancora.
Ci piacerebbe conoscere le vostre opinioni sulla creazione e la gestione dei database utilizzando le API di Kinsta. Condividete le vostre esperienze e le vostre intuizioni nella sezione commenti qui sotto!
Lascia un commento