Bij Kinsta helpen we duizenden websites van alle groottes te ondersteunen. Eén ding dat ze allemaal gemeen hebben is de behoefte aan een database. Ongeacht de grootte van je site, je database bevat de informatie. Daarom kun je bij ons databases maken en beheren met de Kinsta API.
Hoewel je je databases kunt beheren met het MyKinsta dashboard, geeft de Kinsta API je meer flexibiliteit als je een programmatische aanpak nodig hebt. Hiermee kun je die databases maken, bijwerken en verwijderen en ze tot op zekere hoogte uitlezen. Het grote voordeel is echter de integratie van de Kinsta API – en in het verlengde daarvan je database – met je bestaande tools en workflows.
Dit artikel laat zien hoe je databases kunt maken en beheren met de Kinsta API. Ook komen de voordelen aan bod, hoe je toegang krijgt tot de endpoints en waar deze aanpak past in je algehele workflow. Laten we beginnen met de voordelen en mogelijkheden.
De mogelijkheden van de Kinsta API begrijpen
De Kinsta API is de programmatische manier om te communiceren met je Kinsta server. We bieden veel endpoints voor verschillende manieren om je sites te beheren, zoals het werken met je omgevingen, WordPress thema’s en plugins, applicatie statistieken en meer.
Dit strekt zich ook uit tot je databases via de typische CRUD architectuur:
- Met een enkel endpoint kun je een nieuwe database voor je site aanmaken, een serverlocatie kiezen en referenties instellen.
- Er is een methode om alle databases voor je server op te halen met behulp van bedrijfs-ID. Van daaruit kun je een specifieke database en de details daarvan ophalen met zijn individuele ID.
- Met de API kun je de grootte en weergavenaam van je database aanpassen. Dit kan helpen bij sommige toepassingen voor het schalen van resources.
- Je kunt een database verwijderen als je hem niet meer nodig hebt. Dit is eenvoudig en maakt gebruik van een enkel commando.
Over het algemeen kun je deze endpoints gebruiken om je hele databasebeheerworkflow te stroomlijnen. Later zullen we hier dieper op ingaan. Laten we eerst bespreken waarom je de Kinsta API zou moeten gebruiken om je databases te beheren.
De voordelen van databases beheren via de Kinsta API
Natuurlijk zouden we geen speciale API aanbieden om je databases te beheren zonder dat het je een paar overtuigende voordelen biedt ten opzichte van het MyKinsta dashboard. Beide kunnen in je workflow passen, hoewel de Kinsta API een paar specifieke manieren heeft om nieuwe mogelijkheden te benutten.
1. Je kunt je huidige beheerprocessen stroomlijnen
Een belangrijk voordeel van het beheren van je databases via de Kinsta API is hoe je de stappen die je normaal gesproken zou nemen kunt afslanken. Als je het MyKinsta dashboard gebruikt, heb je al een efficiënte workflow. Elke WordPress website geeft je bijvoorbeeld toegang tot de database van je site via phpMyAdmin:
Dit geeft je een vertrouwde interface om wijzigingen aan te brengen. Voor applicaties zal het Databases scherm in MyKinsta je aanloophaven zijn:
Je kunt echter al deze stappen overslaan door onze API endpoints te gebruiken. Dit zou een fluitje van een cent moeten zijn als je andere programmatische diensten voor je site gebruikt. De tijd die je bespaart door deze workflow te automatiseren kan ook een positieve invloed hebben op je efficiëntie.
2. Er zijn bijna onbeperkte automatiseringsmogelijkheden beschikbaar
Zoals met alle endpoints van de Kinsta API kun je taken automatiseren waarvoor je anders naar het MyKinsta dashboard zou moeten gaan. We zullen later meer vertellen over de integratiemogelijkheden. Als je al bestaande tools en scripts gebruikt, kan het automatiseren van je databasebeheer onderdeel worden van dat proces.
Je wilt bijvoorbeeld de mogelijkheid inbouwen om een nieuwe database aan te maken wanneer je een nieuwe site maakt. Je zou binnen je code, tools en scripts vooraf gedefinieerde criteria kunnen instellen om databases automatisch te verwijderen. Alle workflows die het schalen van je resources bevatten kunnen hier ook van profiteren, gezien de manier waarop je het resource type van een database kunt bijwerken.
Net als bij gerichte stroomlijning zal het automatiseren van je workflow de tijd (en het geld) die je besteedt aan databasebeheer verder beïnvloeden.
3. Potentiële integratie met andere tools en platforms
API’s bieden over het algemeen een uitstekende manier om te integreren met bijna alle andere beschikbare tools en platforms, zelfs als er geen bestaande API is. Je kunt diensten zoals Zapier of If This Then That (IFTTT) gebruiken om tools met elkaar te verbinden, waar je Kinsta server deel van zou kunnen uitmaken.
In feite vereisen veel opstellingen dat je andere diensten erbij haalt voor een soepele ervaring. Denk aan je continue integratie en implementatie (CI/CD) pijplijnen die TeamCity, Travis CI of Buddy gebruiken. De Kinsta API, als onderdeel van je toolchain, kan je helpen bij het creëren van een samenhangende workflow van ontwikkeling tot productie.
In de volgende secties behandelen we de verschillende methoden en verzoeken die de Kinsta API je geeft. Aan het einde van het artikel post leer je hoe je de informatie die je ophaalt kunt gebruiken in enkele voorbeeldscenario’s.
Wat je nodig hebt om je databases te beheren met de Kinsta API
Het gebruik van het databases endpoint is een eenvoudig proces, net als bij elk ander Kinsta API endpoint. We zullen hier niet ingaan op alle subtiliteiten van elke actie of workflow, hoewel we daar later meer over zullen vertellen.
Om toegang te krijgen tot het databases endpoint moet je wat informatie bij de hand hebben, waarbij een geldig API token centraal staat. Als je dit genereert, krijg je toegang tot de API, wat geldt voor elk endpoint. In feite hebben we een authenticatie endpoint voor dit doel.
Je kunt een API-sleutel aanmaken op het scherm Bedrijfsinstellingen > API-sleutels via het MyKinsta dashboard.
Om toegang te krijgen tot de meeste endpoints, heb je ook je bedrijfs-ID nodig. Dit is in wezen het ID voor de server en je kunt het vinden in de werkbalk van je browser wanneer je bent ingelogd op het MyKinsta dashboard:
De typische workflow bij het gebruik van Kinsta API endpoints is het valideren van je API-sleutel, het ophalen van gegevens die zijn gekoppeld aan de bedrijfs-ID, het ophalen van gegevens die zijn gekoppeld aan de ID van de site en het verwerken van die gegevens. Voor deze laatste stap moet je de juiste parameters voor het verzoek opgeven.
Dit is natuurlijk afhankelijk van wat je wilt bereiken. Tijdens het beheren van je databases zullen we deze parameters behandelen.
Een nieuwe database maken met de Kinsta API
Het aanmaken van je database vereist het meeste werk van alle verzoeken die we hier behandelen, maar het is nog steeds een koud kunstje. Hiervoor moet je een POST verzoek sturen en er zijn acht vereiste attributen voor dat verzoek om geldig te zijn. Deze omvatten de serverlocatie, het type bron, het type database en de databasegegevens.
Met deze parameters kun je je API-sleutel valideren en je database aanmaken:
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();
Voor elk endpoint ontvang je de gevraagde gegevens in JSON formaat:
{
"database": {
"id": "54fb80af-576c-4fdc-ba4f-b596c83f15a1"
}
}
Merk op dat als het verzoek mislukt, je die informatie zult zien in de teruggestuurde JSON:
{
"message": "No or invalid API key provided to the request",
"status": 401,
"data": null
}
Zoals bij elk verzoek dat je doet, moet je de gegevens die je verstuurt en ontvangt veilig houden. Het valideren van je API-sleutel is één manier om dit te doen, maar er zijn nog andere belangrijke factoren:
- ‘Hardcode’ geen informatie in je verzoeken, zoals ID’s of je API-sleutel. Gebruik in plaats daarvan omgevingsvariabelen om je code bijna ‘anoniem’ te maken.
- Controleer regelmatig of er updates zijn voor de Kinsta API, omdat details van endpoints kunnen veranderen of omdat er modernere methoden voor gegevensbescherming beschikbaar kunnen zijn.
- Het debuggen van je API-verzoeken kan iets zijn waar je veel tijd aan besteedt, vooral bij complexe integraties. Dit is waar de geretourneerde responscodes van je verzoek, je Kinsta foutenlogboeken en typische debugging tools en technieken van pas komen.
Het goede nieuws is dat veel van deze informatie kan worden overgedragen naar andere acties met betrekking tot het databases endpoint. De volgende sectie zal kijken hoe je ze kunt verwijderen.
Bestaande databases ophalen en verwijderen
Het ophalen en verwijderen van je databases neemt beide enkele seconden in beslag en hergebruikt veel van dezelfde code die je al geïmplementeerd hebt bij het maken van die databases. Voor het verzoek GET hoef je alleen maar de methode in je code op te geven:
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();
Er wordt een lijst met informatie over je databases teruggestuurd, inclusief details over je CPU- en geheugenlimieten, de interne hostnaam en poort, en nog veel meer:
{
"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"
}
}
Het verwijderen van een database is net zo eenvoudig. Je stuurt de methode DELETE en de ID naar het endpoint databases:
…
const resp = await fetch(
`https://api.kinsta.com/v2/databases/${id}`,
{
method: 'DELETE',
headers: {
…
In tegenstelling tot het gebruik van het MyKinsta dashboard, moet je echter voorzichtig zijn bij het verwijderen van databases met de API. Hier krijg je geen bevestigingsbericht of ‘buffer’ Daarom wil je misschien ook wat foutafhandeling of controles inbouwen om er zeker van te zijn dat je de database echt voorgoed wilt verwijderen.
Hoe de Kinsta API je helpt databases bij te werken
We bewaren database updates tot het laatst, want hoewel ze aan de oppervlakte eenvoudig en beperkt lijken, kan dit verzoek ook een aantal unieke mogelijkheden bieden.
Aan de oppervlakte geven updates weinig ruimte voor verandering. De enige parameters die je kunt wijzigen zijn de databasenaam en het type bron:
{
"resource_type": "db1",
"display_name": "test-db"
}
Dit is waar database-updates goed kunnen worden ingepast in je hele ontwikkelings- of systeembeheerworkflow. De database kan er bijvoorbeeld een zijn die van de ene staat naar de andere gaat en van de ene naar de andere omgeving. Op verschillende momenten kun je een update uitvoeren die de database een andere naam geeft op basis van de projectconventies, de status van een sprint of wat je maar wilt.
Het resourcetype is een eenvoudige manier om de grootte en prestaties van je database te veranderen. Zo kun je die database aanpassen aan veranderende projectvariabelen of zelfs aan de publieke vraag naar je site. Laten we het hier nu verder over hebben.
Het belang van resource_type bij verticaal schalen
Schaalbaarheid is een vitaal element van een moderne website, en dat zou voor die van jou niet anders moeten zijn. Daarom biedt de Kinsta API de parameter resource_type. Als het aankomt op verticaal schalen, zou dit de voorhoede van je strategie kunnen zijn. Het beste van alles is dat er maar één regel nodig is om de bronnen van je database te wijzigen en meer of minder toe te wijzen:
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();
Je kunt kiezen uit acht verschillende types en over het algemeen geldt: hoe hoger het getal, hoe meer resources je toewijst – dus db8 geeft je meer dan db1.
Dit kan je een supersnelle manier geven om op of af te schalen, afhankelijk van je huidige behoeften.
Als je bijvoorbeeld meer verkeer ervaart of intensievere databasetaken moet uitvoeren, kun je je bronnen opvoeren naar een hoger niveau.
Integratie met andere Kinsta API endpoints
In het verlengde daarvan kun je het databases endpoint gebruiken naast andere Kinsta API endpoints om een volledig database management systeem op te bouwen of om dat beheer op te nemen in je andere workflows.
Een geweldige benadering is de verticale schaalbaarheid uit de vorige paragraaf. Er zijn er echter nog veel meer, afhankelijk van de behoeften van je site:
- Je zou een database kunnen maken op het moment dat je een nieuwe applicatie opstart. Deze kan alle relevante informatie bevatten, zoals de serverlocatie en referenties.
- Als onderdeel van je implementatieproces kun je het resourcetype van de database bijwerken op basis van de belasting die je verwacht.
- Het opvragen van je logbestanden en sitemetriek kan betekenen dat je een manier hebt om een geautomatiseerde en programmatische methode te creëren om de databaseresources van je site te schalen zonder je volledige inbreng.
Dit brengt een cruciaal element van je databasebeheerworkflow naar voren, namelijk het gebruik van de informatie die je overal opvraagt. Laten we dit onderzoeken in de voorlaatste paragraaf.
Database-informatie van de Kinsta API gebruiken in je workflow
Veel projecten bestaan uit meerdere fasen, zoals initiële ontwikkeling, staging, testen en productie. De beschikbaarheid binnen de Kinsta API kan je helpen bij het afhandelen van veel taken in combinatie met je andere tools. Het creëren en beheren van databases kan een integraal radertje in dit wiel zijn.
Als je bijvoorbeeld een nieuwe feature branch aanmaakt binnen het versiebeheersysteem van je keuze (VCS), kun je een proces starten om een nieuwe database aan te maken met behulp van de Kinsta API.
Hier is een vereenvoudigd voorbeeld van hoe je het aanmaken van een database kunt triggeren met behulp van de 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);
Hier is een veelgebruikt, typisch voorbeeld waarbij we een functie definiëren om een database aan te maken die een POST verzoek doet naar het databases endpoint. Ons gebruiksvoorbeeld laat het proces zien: een variabele bevat het Git functie branch pad, dat we dan gebruiken als parameter voor de databaseName. Van daaruit kunnen we het creatieproces starten op basis van de dynamische databasenaam.
Met deze aanpak voor het automatiseren van database creaties, kun je ervoor zorgen dat stages of features een eigen database krijgen. Dit kan het makkelijker maken om de ontwikkelworkflow te beheren, geeft je een schonere basis om vanuit te werken en vermindert het risico op conflicten.
Database-informatie integreren in samenwerkingstools
Een ander veelvoorkomend en waardevol gebruik voor het beheren van je databases met de Kinsta API is het leveren van statusupdates aan je samenwerkingstools, zoals Slack of Microsoft Teams. Je zou bijvoorbeeld een apart kanaal kunnen hebben dat alleen databasestatussen post.
Zo kun je je team op de hoogte houden van de status en beschikbaarheid van databases. Dit bevordert niet alleen een betere communicatie en samenwerking, maar het kan ook de proactieve houding ten opzichte van fouten en problemen verbeteren.
Er zijn nog veel meer voordelen aan dit soort integratie:
- Vergroot de zichtbaarheid. Je kunt iedereen op de hoogte houden van de status van je databases. Dit zorgt ervoor dat iedereen op de hoogte is van mogelijke problemen of komende onderhoudswerkzaamheden.
- Reactievermogen verbeteren. Je kunt ook relevante teamleden op de hoogte stellen wanneer een database aandacht nodig heeft. Dit is de directe katalysator van proactief zijn, waar we het over hadden.
- Discussie vergemakkelijken. Het gecentraliseerde platform stelt jou en je team in staat om onderwerpen met betrekking tot de database in kwestie te bespreken. Deze samenwerking kan het oplossen van problemen, het delen van kennis en nog veel meer stimuleren.
- Communicatie stroomlijnen. Dankzij de geautomatiseerde berichtenstroom heb je geen handmatige meldingen en updates meer nodig.
Het koppelen van de Kinsta API met een authenticatie-endpoint van een tool lijkt op papier complex, maar in de praktijk is er niet veel voor nodig:
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 dit stukje code definiëren we een functie die een Slack webhook gebruikt om berichten naar een Slack kanaal te sturen. Vervolgens voeren we een GET verzoek uit om een lijst van databases op te halen die aan onze server zijn gekoppeld. Voor de databases zonder ‘klaar’-status sturen we een melding naar het Slack-kanaal.
Dit zijn slechts twee snelle manieren om de Kinsta API te integreren met andere platforms om je databases te beheren. Hoe dan ook, je kunt navigeren door betere projectresultaten en grotere efficiëntie terwijl je een betere allround service ontwikkelt.
Samenvatting
Het beheren van je databases is zo’n belangrijk aspect van het uitvoeren van een WordPress project of applicatie dat we je het databases endpoint geven binnen de Kinsta API. Je kunt dit gebruiken om je databasebeheerproces te stroomlijnen en specifieke taken te automatiseren waarvoor je anders het MyKinsta dashboard nodig zou hebben.
Hoewel de methoden om deze taken uit te voeren eenvoudig zijn, heb je veel controle binnen handbereik. Je kunt bijvoorbeeld eenvoudig nieuwe databases aanmaken of verwijderen als je dat wilt. Er zijn veel creatieve manieren om deze verzoeken te gebruiken, zoals het schalen van bronnen, algemene database ‘huishouding’ en nog veel meer.
We horen graag hoe jij denkt over het maken en beheren van databases met behulp van de Kinsta API. Deel je ervaringen en inzichten in het commentaarveld hieronder!
Laat een reactie achter