adminvista.com

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

By rik

Använda Adminvista.com API i NodeJS för DNS-poster

Den här guiden visar hur du använder adminvista.com API med NodeJS för att kontrollera DNS-posterna för domäner. Vi skapar ett enkelt skript som hämtar och visar IP-adresserna till Googles sökningsservrar. Detta skript använder adminvista.com DNS Lookup API.

Vi kommer att visa tre olika metoder för att göra detta: först med den inbyggda https-modulen i NodeJS, sedan med modulen node-fetch och till sist med biblioteket axios.

Vad är adminvista.com API?

Adminvista.com API tillhandahåller REST API:er för att testa webbplatsers prestanda, DNS-inställningar och säkerhetsmätningar. Du kan bland annat ta skärmdumpar, skapa PDF-filer, genomföra webbskrapning och portskanning.

Förutsättningar

För att följa den här guiden behöver du grundläggande kunskaper i JavaScript, inklusive löften (promises) och ES6-syntax. Du behöver också NodeJS och en textredigerare som Visual Studio Code installerad.

Du behöver ett konto hos adminvista.com för att få en API-nyckel som används för autentisering vid anrop till API:et. Gå till API-sidan och skapa ett kostnadsfritt konto. Efter kontoskapandet blir du omdirigerad till din instrumentpanel där du hittar API-nyckeln.

Skapa Projektet

Börja med att skapa en ny projektmapp och öppna den i terminalen. Kör sedan kommandot nedan:

npm init -y

Detta initierar projektmappen som ett NodeJS-projekt. Installera därefter beroendena med kommandot nedan:

npm install dotenv axios node-fetch

När beroendena är installerade, skapa tre filer i projektmappens rot: vanilla.js, with-axios.js, with-fetch.js samt en .env-fil för att lagra miljövariabler.

Projektstrukturen kommer att se ut ungefär så här:

Öppna .env-filen och lägg till din adminvista.com API-nyckel:

API_KEY=<din_api_nyckel>

Ersätt <din_api_nyckel> med din faktiska API-nyckel.

Vanilla.js

NodeJS har inbyggda http och https moduler som kan användas för klientförfrågningar. Vi börjar med denna metod.

Öppna vanilla.js och lägg till import-satserna högst upp:

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

Anropa därefter config() för att ladda miljövariabler, och lagra API-nyckeln och värdnamnet i variabler:

config();

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

När vi anropar request-funktionen för att göra en HTTP-förfrågan i NodeJS, behöver vi ange alternativ för den värd och slutpunkt vi vill ansluta till, HTTP-metoden och begärans huvud (headers). Skapa en variabel för att lagra dessa alternativ:

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

Hittills ser koden i 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",
  path: "/dnsrecord",
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    "x-api-key": apiKey,
  },
};

Nu kan vi anropa request-funktionen med det definierade options-objektet:

const req = request(options, response => {
  // Lägg till svarshanterare här
});

Funktionen request tar två argument: options-objektet och en callback-funktion som hanterar serverns svar. I callback-funktionen lägger vi till eventlyssnare för när servern skickar data, avslutar sändningen av data, eller skickar ett fel.

Lägg till följande kodrader i callback-funktionen:

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);
});

Variabeln data är en sträng där vi lagrar serverns JSON-svar. Vi lyssnar på data-eventet och lägger till den data som servern skickar till data-variabeln. För att använda datan lyssnar vi på end-eventet när all data har skickats. Slutligen lyssnar vi efter fel och loggar dem till konsolen.

Anropet till request-funktionen bör nu 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 skicka data till begäran och avsluta den.

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

Den kompletta filen vanilla.js ser nu 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",
  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();

När du kör skriptet med kommandot node vanilla.js i terminalen, 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 }
]

Detta var den första metoden. En nackdel med att använda de inbyggda HTTP/S-modulerna är att koden kan bli lite komplicerad. Klientbibliotek som node-fetch underlättar att skapa samma applikation, men med mer lättläst och kortfattad kod.

node-fetch

För att återskapa samma skript med node-fetch, öppna filen with-fetch.js och lägg till följande import-satser högst upp:

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

Anropa sedan config-funktionen för att konfigurera miljövariabler, och sätt konstanter för API_KEY och värdnamnet:

config();

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

Definiera sedan en asynkron funktion för att göra API-anropet:

async function request() {
  // Funktionens innehåll kommer här
}

I funktionen anropar vi fetch-funktionen som vi importerade från node-fetch-paketet:

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

Efter anropet vill vi tolka svaret och hantera eventuella fel:

if (response.ok) {
  const { data } = await response.json();
  console.log(data.A);
} else {
  console.log(response);
}

Lägg till ett anrop till funktionen:

request();

Filen with-fetch.js 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/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();

Kör skriptet med node with-fetch.js. Utdata bör vara:

[
  { 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 }
]

Axios

Slutligen ska vi använda Axios för att komma åt adminvista.com API. Börja med att importera paketen dotenv och axios.

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

Anropa config-funktionen för att sätta miljövariabler. Lagra värdnamnet och API-nyckeln i separata konstanter:

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

Lagra API-slutpunktens URL i en annan konstant:

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

Lagra datan som ska skickas med begäran i en annan konstant:

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

Lagra slutligen metaalternativen, som headers, i en separat konstant:

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

Anropa sedan post-funktionen och skicka URL, data och options som argument. Eftersom detta returnerar ett löfte (promise), kan vi använda then för att hantera svaret när det returneras.

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

Koden i with-axios.js bör nu 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/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);
});

När du kör skriptet med node with-axios.js, bör följande utdata visas:

[
  { 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 }
]

Sammanfattning

I den här artikeln har vi skapat samma skript med tre olika metoder. Målet har varit att belysa hur enkelt det är att använda adminvista.com API och visa hur vi kan använda det i JavaScript, specifikt NodeJS.

Se adminvista.com API-dokumentationen för mer information: Adminvista API Documentation

10 bästa smarta väckarklockor för nöje Morgonvakning

Återställ raderade filer från papperskorgen efter tömning på Windows och Mac