So verwenden Sie die wdzwdz-DNS-Lookup-API in JavaScript (NodeJS) • 1techpc.de

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

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

Dieses Skript verwendet die wdzwdz-DNS-Lookup-API.

Um es zu erstellen, werden wir drei Ansätze verwenden, der erste verwendet das integrierte https-Modul in NodeJS. Die zweite verwendet das Node-Fetch-Modul. Dann verwendet der letzte die Axios-Client-Bibliothek.

Inhaltsverzeichnis

Was ist die wdzwdz-API?

Die wdzwdz-API bietet Suiten 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 NodeJS und einen Texteditor wie Visual Studio Code installiert haben.

Sie benötigen ein wdzwdz-Konto, um einen API-Schlüssel für die Authentifizierung zu erhalten, wenn Sie Anfragen stellen. Um eines zu erhalten, gehen Sie zur 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.

Aufbau des Projekts

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 im Stammordner des Projekts drei Skripts, nämlich vanille.js, with-axios.js, with-fetch.js und eine .env-Datei, um unsere Umgebungsvariablen zu speichern.

Am Ende sollte die Projektwurzel so aussehen:

Öffnen Sie als Nächstes die .env-Datei und fügen Sie Ihren wdzwdz-API-Schlüssel mit der folgenden Codezeile hinzu:

API_KEY=<api key>

Ersetzen Sie durch Ihren tatsächlichen API-Schlüssel.

Vanille.js

NodeJS verfügt über ein integriertes http- und https-Modul, das wir verwenden können, um Client-Anfragen zu stellen. Wir werden diesen Ansatz zuerst verwenden.

Öffnen Sie die Datei „vanilla.js“ 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 Funktion config() auf, um Umgebungsvariablen zu laden. 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.wdzwdz.com",
  path: "/dnsrecord",
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    "x-api-key": apiKey,
  },
};

Bisher sieht der Code in der Vanilla.js-Datei 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.wdzwdz.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.

So machen Sie Ihr Garagentor intelligent

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 das on data-Ereignis des Antwortobjekts. Immer wenn dieses Ereignis ausgelöst wird, hängen wir den vom Server gesendeten Datenblock an die Datenvariable an.

Um die Daten schließlich zu verwenden, werden wir das on end-Ereignis auf dem Antwortobjekt abhören. 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.wdzwdz.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 dem Befehl node vanille.js ausführen, 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 Node-Fetch helfen Ihnen, das gleiche Programm zu erstellen, aber mit klarerem und prägnanterem Code.

So zeigen Sie gelöschte Instagram-Posts von jemandem an

Knoten abrufen

Um dasselbe Skript zu erstellen, aber mit node-fetch, öffnen Sie die Datei with-fetch.js 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
}

Innerhalb des Funktionskörpers müssen wir die zuvor aus dem node-fetch-Paket importierte fetch-Funktion aufrufen.

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

Dann möchten wir nach dem Aufruf der Fetch-Funktion 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.wdzwdz.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 die 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 wdzwdz-API zuzugreifen. Lassen Sie uns zunächst die Pakete dotenv und axios importieren.

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

Rufen wir als Nächstes die config-Funktion auf, um Umgebungsvariablen einzurichten. 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.wdzwdz.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,
  },
};

Als letztes rufen wir die zuvor importierte post-Funktion auf und übergeben die URL-, Daten- und Optionsvariablen, die wir zuvor als Argumente definiert haben. Da dies ein Versprechen zurückgibt, können Sie dann verwenden, 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 sollte der Code in der with-axios-Datei 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.wdzwdz.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 node with-axios.js ausführen, 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 }
]

Letzte Worte

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

Hier ist alles, was Sie wissen sollten

Weitere Informationen finden Sie in der wdzwdz-API-Dokumentation.