So verwenden Sie die DNS-Lookup-API von Geekflare in JavaScript (NodeJS)

In diesem Tutorial werde ich demonstrieren, wie Sie die Geekflare-API in NodeJS verwenden, um die DNS-Einträge einer beliebigen Domain zu überprüfen.

Wir werden ein einfaches Skript erstellen, das bei seiner Ausführung die IP-Adresse des Google-Suchservers.

Dieses Skript verwendet die Geekflare DNS-Lookup-API.

Um es zu erstellen, werden wir drei Ansätze verwenden, der erste verwendet die integrierte https Modul in NodeJS. Die zweite verwendet die node-fetch Modul. Dann wird der letzte die verwenden axios Client-Bibliothek.

Was ist die Geekflare-API?

Geekflare-API bietet Anzüge von REST-APIs zum Testen von Website-Performance, DNS und Sicherheitsmetriken. Sie können beispielsweise einen Screenshot machen, PDFs generieren, Web Scraping durchführen, Ports scannen und vieles mehr.

Voraussetzungen:

Um diesem Tutorial zu folgen, benötigen Sie ein Verständnis von JavaScript, einschließlich Promises und ES6-Syntax. Was die Software betrifft, sollten Sie haben KnotenJS und einen Texteditor wie z Visual Studio-Code installiert.

Sie benötigen ein Geekflare-Konto, um bei Anfragen einen API-Schlüssel zur Authentifizierung zu erhalten. Um einen zu bekommen, gehen Sie zu API-Landingpage und erstellen Sie ein kostenloses Konto.

Nachdem Sie das Konto erstellt haben, sollten Sie zum Dashboard weitergeleitet werden, wo Sie Ihren API-Schlüssel finden.

Das Projekt aufbauen

Erstellen Sie zunächst einen Projektordner und öffnen Sie ihn mit einem Terminal Ihrer Wahl. Führen Sie dann den folgenden Befehl aus.

npm init -y

Der obige Befehl initialisiert das Projektverzeichnis als NodeJS-Projekt.

Führen Sie als Nächstes den folgenden Befehl aus, der alle Abhängigkeiten für unser Projekt installiert

npm install dotenv axios node-fetch

Nachdem die Abhängigkeiten erfolgreich installiert wurden, erstellen Sie drei Skripte im Projektstammordner nämlich vanilla.js, with-axios.js, with-fetch.js und einem .env Datei zum Speichern unserer Umgebungsvariablen.

Am Ende sollte die Projektwurzel so aussehen:

Als nächstes öffne die .env Datei und fügen Sie Ihren Geekflare-API-Schlüssel mit der folgenden Codezeile hinzu:

API_KEY=<api key>

Ersetzen <API key> mit Ihrem tatsächlichen API-Schlüssel.

Vanilla.js

NodeJS hat eine eingebaute http funktioniert https Modul, das wir verwenden können, um zu machen Kundenanfragen. Wir werden diesen Ansatz zuerst verwenden.

Öffnen Sie die Vanille.js -Datei und fügen Sie oben die folgenden Codezeilen hinzu, um die Abhängigkeiten des Projekts zu importieren.

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

Als nächstes rufen wir die an config() Funktion zum Laden von Umgebungsvariablen. Dann speichern wir den API-Schlüssel und den Hostnamen in Variablen.

config();

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

Wenn wir die Anforderungsfunktion aufrufen, um eine HTTP-Anforderung in NodeJS zu starten, müssen wir Optionen für den Host und den Endpunkt bereitstellen, zu dem wir eine Verbindung herstellen möchten, die HTTP-Methode, die wir verwenden werden, und die Header für die Anforderung. Als Nächstes erstellen wir eine Variable, die diese Optionen speichert.

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

Bisher ist der Code in der vanilla.js Datei sieht so aus:

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

config();

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

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

Jetzt können wir damit fortfahren, die Anforderungsfunktion aufzurufen, indem wir die Optionsmethode übergeben:

const req = request(options, response => {

  // we are going to add response handlers here

});

Wie Sie sehen können, nimmt die Anforderungsfunktion zwei Argumente entgegen. Das erste ist das Optionsobjekt, das wir zuvor definiert haben. Die zweite ist eine Rückruffunktion, die die Antwort vom Server verarbeitet. Innerhalb der Rückruffunktion können wir Ereignis-Listener hinzufügen, wenn der Server Daten sendet, das Senden von Daten beendet oder einen Fehler sendet.

Um die verschiedenen Response-Handler hinzuzufügen, fügen Sie die folgenden Codezeilen in die Callback-Funktion ein:

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

Die Datenvariable ist einfach eine Zeichenfolge, in der wir die JSON-Antwort des Servers speichern, während sie an uns zurückgesendet wird.

Um die Daten tatsächlich zu speichern, hören wir auf die Antwortobjekte on data Veranstaltung. Immer wenn dieses Ereignis ausgelöst wird, hängen wir den vom Server gesendeten Datenblock an die Datenvariable an.

Um die Daten dann endlich zu nutzen, werden wir uns die anhören on end Ereignis für das Antwortobjekt. Dies wird aufgerufen, wenn alle Daten vom Server gesendet wurden und seine Antwort beendet ist.

Schließlich werden wir auf Fehler lauschen und sie in der Konsole protokollieren, wenn sie auftreten.

Daher sollte der Aufruf der Request-Funktion so aussehen

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

});

Zuletzt müssen wir einige Daten in den Anfragetext schreiben und die Anfrage beenden.

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

Am Ende sollte die Datei so aussehen:

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

config();

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

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

Wenn Sie nun zum Terminal zurückkehren und das Skript mit der node vanilla.js Befehl, sollten Sie die folgende Ausgabe erhalten.

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

Das war's für den ersten Teil. Der offensichtliche Nachteil der Verwendung der integrierten HTTP/S-Module besteht darin, dass sie ausführlich sind. Client-Bibliotheken wie z node-fetch wird Ihnen helfen, das gleiche Programm zu erstellen, aber mit klarerem und prägnanterem Code.

node-fetch

Um das gleiche Skript zu erstellen, aber mit node-fetch, öffne das with-fetch.js Datei und fügen Sie die folgenden Importe oben hinzu.

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

Rufen Sie dann die config-Funktion auf, um Umgebungsvariablen zu konfigurieren und Konstanten für den API_KEY und den Host einzurichten, dessen A-Einträge wir anfordern werden.

config();

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

Als Nächstes definieren wir eine Funktion, um den API-Aufruf durchzuführen. Diese Funktion ist asynchron.

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

Im Körper der Funktion müssen wir die aufrufen fetch Funktion, die wir zuvor aus der importiert haben node-fetch Paket.

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

Dann nach dem Anruf an die fetch -Funktion möchten wir unsere Antwort parsen und eventuell auftretende Fehler behandeln.

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

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

Fügen Sie an dieser Stelle der Funktion nach ihrer Anforderung einen Aufruf hinzu.

request();

Ihre Datei sollte nun so aussehen:

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

Und das Ausführen dieses Skripts mit node with-fetch.js sollte folgende Ausgabe erzeugen:

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

Schließlich werden wir Axios verwenden, um auf die Geekflare-API zuzugreifen. Importieren wir zunächst die dotenv funktioniert axios Pakete.

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

Als nächstes rufen wir die an config Funktion zum Einrichten von Umgebungsvariablen. Lassen Sie uns außerdem den Namen des Hosts und den API-Schlüssel in separaten Konstanten speichern.

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

Speichern wir nun die URL des API-Endpunkts in einer anderen Konstante

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

Als Nächstes speichern wir die Daten, die als Teil des Anforderungstexts gesendet werden, in einer anderen Konstante

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

Dann ist das letzte, was Sie tun müssen, bevor Sie die Anfrage senden, auch die Meta-Optionen, wie Header, in einer anderen Konstante zu speichern.

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

Lassen Sie uns zum Schluss den Anruf tätigen post Funktion, die wir zuvor importiert haben, indem wir die übergeben url, data funktioniert options Variablen, die wir zuvor als Argumente definiert haben. Da dies ein Versprechen zurückgibt, können Sie es dann verwenden then um die Antwort zu verarbeiten, wenn sie schließlich zurückgegeben wird.

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

Am Ende von all dem ist der Code in der with-axios Datei sollte so aussehen:

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

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

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

Und wenn Sie das Skript mit ausführen node with-axios.js, sollte es die folgende Ausgabe anzeigen:

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

Zusammenfassung

In diesem Beitrag haben wir das Skript mit drei verschiedenen Ansätzen erstellt. Das Ziel war es, hervorzuheben, wie einfach die Verwendung der Geekflare-API ist und wie wir sie speziell in Javascript verwenden könnten KnotenJS.

Mehr Erfahren Geekflare-API-Dokumentation für mehr.