Hur man använder adminvista.com API i JavaScript (NodeJS)

I den här handledningen kommer jag att demonstrera hur man använder adminvista.com API i NodeJS.

För att demonstrera detta kommer vi att bygga ett enkelt skript som, när det körs, skriver ut IP-adressen till Googles sökserver. Detta skript kommer att använda DNS-postens slutpunkt för adminvista.com API.

För att bygga den kommer vi att använda tre tillvägagångssätt, den första använder den inbyggda https-modulen i NodeJS. Den andra kommer att använda nodhämtningsmodulen. Sedan kommer den sista att använda axios klientbibliotek.

Innehållsförteckning

Vad är adminvista.com API?

adminvista.com är en webbplats som tillhandahåller verktyg, API:er och resurser för att skapa, hantera och växa ett onlineföretag. Inkluderat i dessa verktyg är ett API som kan användas för att hantera en webbplats prestanda, säkerhet och granskning av webbplatsproblem. API:et har en generös gratisnivå som du kan dra nytta av.

Förutsättningar

För att följa denna handledning behöver du en förståelse för JavaScript, inklusive löften och ES6-syntax. När det gäller programvaran bör du ha NodeJS och en textredigerare som Visual Studio Code installerad.

Du behöver ett adminvista.com-konto för att få en API-nyckel för autentisering när du gör förfrågningar. För att få en, gå till API-målsidan och skapa ett gratis konto.

När du har skapat kontot bör du omdirigeras till instrumentpanelen, där du hittar din API-nyckel.

Bygga projektet

För att börja, skapa en projektmapp och öppna den med en valfri terminal, kör sedan kommandot nedan.

npm init -y

Ovanstående kommando kommer att initiera projektkatalogen som ett NodeJS-projekt.

Kör sedan kommandot nedan, vilket kommer att installera alla beroenden för vårt projekt

npm install dotenv axios node-fetch

Efter att beroenden har installerats, skapa tre skript i projektets rotmapp, nämligen vanilla.js, with-axios.js, with-fetch.js och en .env-fil för att lagra våra miljövariabler.

I slutändan bör projektroten se ut så här:

Öppna sedan .env-filen och lägg till din adminvista.com API-nyckel med följande kodrad:

API_KEY=<api key>

Ersätt med din faktiska API-nyckel.

Med Vanilla.js

NodeJS har en inbyggd http- och https-modul som vi kan använda för att göra klientförfrågningar. Vi kommer att använda detta tillvägagångssätt först.

Öppna filen vanilla.js och lägg till följande kodrader högst upp för att importera projektets beroenden.

import { request } from "https";
import { config } from "dotenv";

Därefter kommer vi att anropa funktionen config() för att ladda miljövariabler. Sedan ska vi lagra API-nyckeln och värdnamnet i variabler.

config();

const apiKey = process.env.API_KEY;
const host="google.com";

När vi anropar förfrågningsfunktionen för att starta en HTTP-förfrågan i NodeJS måste vi tillhandahålla alternativ för den värd och slutpunkt vi vill ansluta till, HTTP-metoden vi kommer att använda och rubrikerna för förfrågan. Så härnäst kommer vi att skapa en variabel som lagrar dessa alternativ.

const options = {
  hostname: "api.adminvista.com.com",
  path: "/dnsrecord",
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    "x-api-key": apiKey,
  },
};

Hittills ser koden i filen vanilla.js ut så här:

import { request } from "https";
import { config } from "dotenv";

config();

const apiKey = process.env.API_KEY;
const host="google.com"

const options = {
  hostname: "api.adminvista.com.com",
  path: "/dnsrecord",
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    "x-api-key": apiKey,
  },
};

Nu kan vi fortsätta att anropa begäran-funktionen som passerar i alternativmetoden:

const req = request(options, response => {

  // we are going to add response handlers here

});

Som du kan se tar begäran-funktionen in två argument. Det första är optionsobjektet vi definierade tidigare. Den andra är en återuppringningsfunktion som kommer att hantera svaret från servern. Inuti callback-funktionen kan vi lägga till händelseavlyssnare för när servern skickar data, slutar skicka data eller skickar ett fel.

För att lägga till de olika svarshanterarna, lägg till följande kodrader i återuppringningsfunktionen:

let data = "";

response.on("data", chunk => {
  data += chunk;
});

response.on("end", () => {
  console.log(JSON.parse(data).data.A);
});

response.on("error", error => {
  console.log(error);
});

Datavariabeln är helt enkelt en sträng där vi ska lagra serverns JSON-svar när det streamas tillbaka till oss.

För att faktiskt lagra data kommer vi att lyssna på responsobjektets på data-händelse. Närhelst den här händelsen avfyras kommer vi att lägga till den bit av data som skickas av servern till datavariabeln.

För att sedan slutligen använda datan kommer vi att lyssna på on end-händelsen på responsobjektet. Detta kommer att anropas när all data har skickats från servern och den har avslutat sitt svar.

Slutligen kommer vi att lyssna efter fel och logga dem till konsolen om de uppstår.

Därför bör anropet till förfrågningsfunktionen se ut så här

const req = request(options, response => {

  let data = "";

  response.on("data", chunk => {
    data += chunk;
  });

  response.on("end", () => {
    console.log(JSON.parse(data).data.A);
  });

  response.on("error", error => {
    console.log(error);
  });

});

Slutligen måste vi skriva lite data till förfrågningsorganet och avsluta förfrågan.

req.write(JSON.stringify({ url: host, types: ["A"] }));
req.end();

I slutändan bör filen se ut så här:

import { request } from "https";
import { config } from "dotenv";

config();

const apiKey = process.env.API_KEY;
const host="google.com"

const options = {
  hostname: "api.adminvista.com.com",
  path: "/dnsrecord",
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    "x-api-key": apiKey,
  },
};

const req = request(options, response => {

  let data = "";

  response.on("data", chunk => {
    data += chunk;
  });

  response.on("end", () => {
    console.log(JSON.parse(data).data.A);
  });

  response.on("error", error => {
    console.log(error);
  });

});

req.write(JSON.stringify({ url: host, types: ["A"] }));
req.end();

Nu, om du går tillbaka till terminalen och kör skriptet med kommandot node vanilla.js, bör du få följande utdata.

[
  { address: '172.253.122.101', ttl: 247 },
  { address: '172.253.122.113', ttl: 247 },
  { address: '172.253.122.100', ttl: 247 },
  { address: '172.253.122.102', ttl: 247 },
  { address: '172.253.122.138', ttl: 247 },
  { address: '172.253.122.139', ttl: 247 }
]

Det var det för första delen. Den uppenbara nackdelen med att använda de inbyggda HTTP/S-modulerna är att det är mångsidigt. Klientbibliotek som node-fetch hjälper dig att skapa samma program men med tydligare och mer koncis kod.

Med nodhämtning

För att skapa samma skript men med nod-fetch, öppna with-fetch.js-filen och lägg till följande importer högst upp.

import fetch from "node-fetch";
import { config } from "dotenv";

Anropa sedan config-funktionen för att konfigurera miljövariabler och ställa in konstanter för API_KEY och värden vars A-poster vi kommer att begära.

config();

const apiKey = process.env.API_KEY;
const host="google.com"

Därefter kommer vi att definiera en funktion för att göra API-anropet. Denna funktion kommer att vara asynkron.

async function request() {
  // The function body will go here
}

Inuti funktionens kropp måste vi anropa hämta-funktionen som vi importerade tidigare från nod-fetch-paketet.

const response = await fetch("https://api.adminvista.com.com/dnsrecord", {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "x-api-key": apiKey,
    },
    body: JSON.stringify({ url: host, types: ["A"] }),
});

Sedan efter anropet till hämtningsfunktionen skulle vi vilja analysera vårt svar och hantera eventuella fel som kan uppstå.

if (response.ok) {
    const { data } = await response.json();

    console.log(data.A);
  } else {
    console.log(response);
  }

Lägg nu till ett anrop till funktionen efter dess begäran.

request();

Din fil bör nu se ut så här:

import fetch from "node-fetch";
import { config } from "dotenv";

config();

const apiKey = process.env.API_KEY;
const host = "google.com";

async function request() {
  const response = await fetch("https://api.adminvista.com.com/dnsrecord", {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "x-api-key": apiKey,
    },
    body: JSON.stringify({ url: host, types: ["A"] }),
  });

  if (response.ok) {
    const { data } = await response.json();

    console.log(data.A);
  } else {
    console.log(response);
  }
}

request();

Och att köra det skriptet med noden with-fetch.js bör producera följande utdata:

[
  { address: '172.253.122.113', ttl: 134 },
  { address: '172.253.122.138', ttl: 134 },
  { address: '172.253.122.100', ttl: 134 },
  { address: '172.253.122.139', ttl: 134 },
  { address: '172.253.122.102', ttl: 134 },
  { address: '172.253.122.101', ttl: 134 }
]

Med Axios

Slutligen kommer vi att använda Axios för att komma åt adminvista.com API. Till att börja, låt oss importera dotenv och axios-paketen.

import axios from "axios";
import { config } from "dotenv";

Låt oss sedan anropa config-funktionen för att ställa in miljövariabler. Låt oss dessutom lagra värdens namn och API-nyckeln i separata konstanter.

const host = "google.com";
const key = process.env.API_KEY;

Låt oss nu lagra URL:en för API-slutpunkten i en annan konstant

const url = "https://api.adminvista.com.com/dnsrecord";

Låt oss sedan lagra data som kommer att skickas som en del av förfrågningskroppen i en annan konstant

const data = { url: host, types: ["A"] };

Då är det sista du ska göra innan du skickar ut förfrågan att även lagra metaalternativen, såsom rubriker, i en annan konstant.

const options = {
  headers: {
    "Content-Type": "application/json",
    "x-api-key": key,
  },
};

Låt oss slutligen göra anropet till postfunktionen som vi importerade tidigare, och skicka in url-, data- och alternativvariablerna som vi definierade tidigare som argument. Eftersom detta kommer att returnera ett löfte kan du sedan använda sedan för att hantera svaret när det så småningom returneras.

axios.post(url, data, options).then(({ data }) => {
  console.log(data.data.A);
});

I slutet av allt detta bör koden i with-axios-filen se ut så här:

import axios from "axios";
import { config } from "dotenv";

config();
const host = "google.com";
const key = process.env.API_KEY;

const url = "https://api.adminvista.com.com/dnsrecord";
const data = { url: host, types: ["A"] };
const options = {
  headers: {
    "Content-Type": "application/json",
    "x-api-key": key,
  },
};

axios.post(url, data, options).then(({ data }) => {
  console.log(data.data.A);
});

Och när du kör skriptet med noden with-axios.js, bör det visa följande utdata:

[
  { address: '142.251.163.138', ttl: 60 },
  { address: '142.251.163.113', ttl: 60 },
  { address: '142.251.163.100', ttl: 60 },
  { address: '142.251.163.101', ttl: 60 },
  { address: '142.251.163.102', ttl: 60 },
  { address: '142.251.163.139', ttl: 60 }
]

Slutord

I det här inlägget skapade vi samma manus med tre olika tillvägagångssätt. Syftet med detta var att belysa hur lätt det är att använda adminvista.com API, och hur vi kan gå tillväga för att använda det i Javascript, specifikt NodeJS.

Alla andra endpoints kan användas på liknande sätt; allt som ändras är slutpunkten och parametrarna som du måste skicka som en del av förfrågningskroppen. Dokumentation för API:t finns här.