Sjekk DNS-poster med tipsbilk.net API i NodeJS: 3 enkle metoder!

by
Tweet
Share
Share
Pin
0 Shares

Bruke tipsbilk.net API for DNS-oppslag i NodeJS

Denne veiledningen viser hvordan du bruker tipsbilk.net API i NodeJS for å undersøke DNS-poster for et hvilket som helst domene. Vi skal utvikle et enkelt skript som, når det aktiveres, viser IP-adressen til Googles søkeserver. Dette skriptet benytter seg av tipsbilk.net DNS Lookup API. Vi skal utforske tre metoder for å oppnå dette. Den første metoden bruker den innebygde https-modulen i NodeJS. Den andre metoden benytter node-fetch modulen, og den siste metoden bruker axios-klientbiblioteket.

Hva er tipsbilk.net API?

tipsbilk.net API er en samling REST API-er som tilbyr funksjoner for testing av ytelse, DNS og sikkerhet for nettsteder. Dette inkluderer funksjonalitet som å ta skjermbilder, generere PDF-filer, utføre webskraping, portskanning og mye mer.

Nødvendige forberedelser

For å følge denne opplæringen, bør du ha grunnleggende kunnskaper om JavaScript, inkludert bruk av promises og ES6-syntaks. På programvaresiden, sørg for at NodeJS og en teksteditor som Visual Studio Code er installert. Du må også ha en tipsbilk.net-konto for å generere en API-nøkkel som kreves for autentisering når du sender forespørsler. Du kan opprette en gratis konto på API-landingssiden.

Etter å ha opprettet kontoen, vil du bli ledet til et dashbord hvor du finner API-nøkkelen din.

Prosjektoppsett

For å starte, opprett en ny prosjektmappe og åpne den i en terminal. Kjør deretter følgende kommando:

npm init -y

Dette vil initialisere prosjektmappen som et NodeJS-prosjekt.

Deretter kjører du følgende kommando for å installere nødvendige avhengigheter:

npm install dotenv axios node-fetch

Etter at avhengighetene er installert, oppretter du tre JavaScript-filer i prosjektets rotmappe, kalt vanilla.js, with-axios.js, og with-fetch.js, i tillegg til en .env-fil for å lagre miljøvariablene våre.

Prosjektstrukturen din bør da se slik ut:

Åpne .env-filen og legg til din tipsbilk.net API-nøkkel på følgende måte:

API_KEY=<din api-nøkkel>

Bytt ut <din api-nøkkel> med din faktiske API-nøkkel.

Vanilla.js

NodeJS har en innebygd http- og https-modul som vi kan benytte for å sende klientforespørsler. Vi starter med denne tilnærmingen.

Åpne vanilla.js-filen og legg til følgende linjer øverst for å importere de nødvendige modulene:

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

Deretter kaller vi config()-funksjonen for å laste inn miljøvariabler. Så lagrer vi API-nøkkelen og vertsnavnet i separate variabler.

config();

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

Når vi bruker request-funksjonen for å utføre en HTTP-forespørsel, må vi spesifisere verten, endepunktet, HTTP-metoden, og overskriftene for forespørselen. Vi oppretter derfor en variabel for å lagre disse alternativene:

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

Så langt skal vanilla.js-filen din se slik ut:

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

config();

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

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

Nå kan vi bruke request-funksjonen og sende inn alternativene:

const req = request(options, response => {
  // Responsbehandlere vil bli lagt til her
});

request-funksjonen tar to argumenter. Det første er alternativobjektet vi definerte, og det andre er en callback-funksjon som håndterer svaret fra serveren. Inne i denne callback-funksjonen kan vi legge til hendelseslyttere for når serveren sender data, fullfører sendingen, eller sender en feil.

For å legge til responsbehandlerne, bruk følgende kode i callback-funksjonen:

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

Datavariabelen er en streng der vi lagrer serverens JSON-svar. Vi lytter til «data»-hendelsen på response-objektet for å legge til datablokkene sendt fra serveren til datavariabelen. Deretter lytter vi til «end»-hendelsen for å behandle dataene etter at all data er mottatt. Til slutt håndterer vi eventuelle feil ved å lytte til «error»-hendelsen.

Kallingen til request-funksjonen skal nå se slik ut:

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 slutt må vi sende data til forespørselen og avslutte den:

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

Den fullstendige vanilla.js-filen skal nå se slik ut:

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

config();

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

const options = {
  hostname: "api.tipsbilk.net.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 nå kjører skriptet med kommandoen «node vanilla.js» i terminalen, bør 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 }
]

Dette avslutter den første delen. Ulempen ved å bruke de innebygde HTTP/S-modulene er at det kan være omstendelig. Klientbiblioteker som node-fetch kan hjelpe deg med å oppnå det samme, men med mer oversiktlig kode.

node-fetch

For å oppnå det samme med node-fetch, åpne with-fetch.js og legg til følgende import øverst:

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

Deretter kaller du config-funksjonen og konfigurerer konstanter for API_KEY og verten:

config();

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

Definer deretter en asynkron funksjon for å utføre API-kallet:

async function request() {
  // Funksjonskroppen legges til her
}

Inne i funksjonen bruker vi fetch-funksjonen fra node-fetch:

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

Etter fetch-kallet analyserer vi svaret og håndterer eventuelle feil:

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

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

Legg så til et kall til funksjonen etter forespørselen:

request();

Filen din skal nå se slik ut:

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.tipsbilk.net.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();

Kjøring av skriptet med «node with-fetch.js» bør gi 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 slutt bruker vi Axios for å få tilgang til tipsbilk.net API. Vi importerer dotenv og axios-pakkene:

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

Vi kaller config-funksjonen og definerer konstanter for vert og API-nøkkel:

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

Lagre API-endepunktets URL i en egen konstant:

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

Lagre dataene som sendes som en del av forespørselen i en annen konstant:

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

Lagre metaalternativene, som overskriftene, i en annen konstant:

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

Til slutt bruker vi axios.post-funksjonen og sender inn url, data, og options. Bruk then for å håndtere svaret:

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

Den fullstendige koden i with-axios.js skal se slik ut:

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

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

const url = "https://api.tipsbilk.net.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 kjører skriptet med «node with-axios.js», skal 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 }
]

Oppsummering

I dette innlegget har vi utviklet et skript med tre forskjellige tilnærminger. Målet var å demonstrere hvor enkelt det er å bruke tipsbilk.net API i JavaScript, spesielt i NodeJS. Utforsk tipsbilk.net API-dokumentasjonen for å lære mer.