Sådan bruger du toadmin.dk DNS Lookup API i JavaScript (NodeJS)

Af
Tweet
Share
Share
Pin

I denne tutorial skal jeg demonstrere, hvordan man bruger toadmin.dk API i NodeJS til at kontrollere DNS-posterne for ethvert domæne.

Vi skal bygge et simpelt script, der, når det udføres, udskriver IP-adressen på Googles søgeserver.

Dette script vil bruge toadmin.dk DNS Lookup API.

For at bygge det skal vi bruge tre tilgange, den første bruger det indbyggede https-modul i NodeJS. Den anden vil bruge node-fetch-modulet. Så vil den sidste bruge axios-klientbiblioteket.

Hvad er toadmin.dk API?

toadmin.dk API tilbyder dragter af REST API’er til test af webstedets ydeevne, DNS og sikkerhedsmålinger. Du kan gøre ting som at tage et skærmbillede, generere PDF’er, lave web-skrabning, portscanning og meget mere.

Forudsætninger

For at følge denne vejledning skal du have en forståelse af JavaScript, inklusive løfter og ES6-syntaks. Hvad angår softwaren, skal du have NodeJS og en teksteditor som Visual Studio Code installeret.

Du skal bruge en toadmin.dk-konto for at få en API-nøgle til godkendelse, når du foretager anmodninger. For at få en skal du gå til API-landingssiden og oprette en gratis konto.

Når du har oprettet kontoen, bør du blive omdirigeret til dashboardet, hvor du finder din API-nøgle.

Opbygning af projektet

For at begynde skal du oprette en projektmappe og åbne den med en terminal efter eget valg, og derefter køre kommandoen nedenfor.

npm init -y

Ovenstående kommando vil initialisere projektmappen som et NodeJS-projekt.

Kør derefter kommandoen nedenfor, som vil installere alle afhængigheder for vores projekt

npm install dotenv axios node-fetch

Efter at afhængighederne er blevet installeret, skal du oprette tre scripts i projektets rodmapp, nemlig vanilla.js, with-axios.js, with-fetch.js og en .env-fil til at gemme vores miljøvariabler.

I sidste ende skulle projektroden se sådan ud:

Åbn derefter .env-filen og tilføj din toadmin.dk API-nøgle med følgende kodelinje: 

API_KEY=<api key>

Erstat med din faktiske API-nøgle.

Vanilla.js

NodeJS har et indbygget http- og https-modul, som vi kan bruge til at lave klientanmodninger. Vi vil først bruge denne tilgang.

Åbn filen vanilla.js og tilføj følgende kodelinjer øverst for at importere projektets afhængigheder.

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

Dernæst vil vi kalde funktionen config() for at indlæse miljøvariabler. Så skal vi gemme API-nøglen og værtsnavnet i variabler.

config();

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

Når vi kalder anmodningsfunktionen for at starte en HTTP-anmodning i NodeJS, bliver vi nødt til at give muligheder for den vært og det slutpunkt, vi vil oprette forbindelse til, den HTTP-metode, vi skal bruge, og overskrifterne for anmodningen. Så næste gang skal vi oprette en variabel, der gemmer disse muligheder.

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

Indtil videre ser koden i vanilla.js-filen således ud:

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

config();

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

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

Nu kan vi fortsætte med at kalde anmodningsfunktionen, der passerer i indstillingsmetoden:

const req = request(options, response => {

  // we are going to add response handlers here

});

Som du kan se, tager anmodningsfunktionen to argumenter ind. Det første er option-objektet, vi definerede tidligere. Den anden er en tilbagekaldsfunktion, der håndterer svaret fra serveren. Inde i tilbagekaldsfunktionen kan vi tilføje hændelseslyttere til, hvornår serveren sender data, afslutter med at sende data eller sender en fejl.

  Sådan annullerer du et møde i Microsoft Teams

For at tilføje de forskellige svarhandlere skal du tilføje følgende kodelinjer i tilbagekaldsfunktionen:

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

Datavariablen er simpelthen en streng, hvor vi skal gemme serverens JSON-svar, når det streames tilbage til os.

For faktisk at gemme dataene vil vi lytte til responsobjektets på data-hændelse. Hver gang denne hændelse udløses, vil vi tilføje den del af data, der sendes af serveren, til datavariablen.

For så endelig at bruge dataene, skal vi lytte til on-end-hændelsen på responsobjektet. Dette vil blive kaldt, når alle data er blevet sendt fra serveren, og det har afsluttet sit svar.

Til sidst vil vi lytte efter fejl og logge dem på konsollen, hvis de opstår.

Derfor skulle opkaldet til anmodningsfunktionen se sådan ud

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

});

Til sidst skal vi skrive nogle data til anmodningsorganet og afslutte anmodningen.

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

I sidste ende skulle filen se sådan ud:

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

config();

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

const options = {
  hostname: "api.toadmin.dk.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();

Hvis du nu går tilbage til terminalen og kører scriptet ved hjælp af kommandoen node vanilla.js, skulle du få følgende output.

[
  { 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 for første del. Den åbenlyse ulempe ved at bruge de indbyggede HTTP/S-moduler er, at det er verbose. Klientbiblioteker såsom node-fetch vil hjælpe dig med at oprette det samme program, men med klarere og mere kortfattet kode.

  Hvad er COBOL, og hvorfor stoler så mange institutioner på det?

node-hentning

For at oprette det samme script, men med node-fetch, skal du åbne filen with-fetch.js og tilføje følgende importer til toppen.

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

Kald derefter config-funktionen for at konfigurere miljøvariabler og opsætte konstanter for API_KEY og værten, hvis A-poster vi vil anmode om.

config();

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

Dernæst skal vi definere en funktion til at foretage API-kaldet. Denne funktion vil være asynkron.

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

Inde i funktionens krop skal vi kalde den hente-funktion, vi importerede tidligere fra node-fetch-pakken.

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

Så efter opkaldet til hentefunktionen, vil vi gerne analysere vores svar og håndtere eventuelle fejl, der måtte opstå.

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

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

På dette tidspunkt skal du tilføje et opkald til funktionen efter dens anmodning.

request();

Din fil skulle nu se sådan ud:

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.toadmin.dk.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();

Og at køre det script med node with-fetch.js skulle producere følgende output:

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

Til sidst skal vi bruge Axios til at få adgang til toadmin.dk API. For at begynde, lad os importere dotenv- og axios-pakkerne.

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

Lad os derefter kalde config-funktionen for at opsætte miljøvariabler. Lad os desuden gemme værtens navn og API-nøglen i separate konstanter.

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

Lad os nu gemme URL’en for API-endepunktet i en anden konstant

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

Lad os derefter gemme de data, der vil blive sendt som en del af anmodningsteksten, i en anden konstant

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

Så vil den sidste ting at gøre, før du sender anmodningen, også være at gemme metaindstillingerne, såsom overskrifter, i en anden konstant.

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

Til sidst, lad os kalde til postfunktionen, vi importerede tidligere, ved at indsætte url-, data- og optionvariablerne, vi definerede tidligere som argumenter. Fordi dette vil returnere et løfte, kan du derefter bruge derefter til at håndtere svaret, når det til sidst returneres.

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

I slutningen af ​​alt dette skulle koden i with-axios-filen se sådan ud:

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

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

const url = "https://api.toadmin.dk.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);
});

Og når du kører scriptet ved hjælp af node with-axios.js, skulle det vise følgende output:

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

Afsluttende ord

I dette indlæg har vi lavet manuskriptet med tre forskellige tilgange. Formålet med dette var at fremhæve, hvor let det er at bruge toadmin.dk API’en, og hvordan vi kunne bruge det i Javascript, specifikt NodeJS.

  10 bedste kundeoplevelsessoftware til at vokse forretning

Udforsk toadmin.dk API-dokumentation for mere.