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

Verwendung der wdzwdz-API mit NodeJS: Eine Schritt-für-Schritt-Anleitung

In dieser Anleitung zeige ich Ihnen, wie Sie die wdzwdz-API in NodeJS nutzen können, um die DNS-Einträge einer beliebigen Domain abzufragen. Wir erstellen ein einfaches Skript, das bei Ausführung die IP-Adresse des Google-Suchservers ausgibt. Hierfür greifen wir auf die wdzwdz-DNS-Lookup-API zurück.

Um dies zu realisieren, verwenden wir drei unterschiedliche Methoden: Zuerst nutzen wir das in NodeJS integrierte https-Modul. Dann verwenden wir das node-fetch-Modul und schließlich die Axios-Client-Bibliothek.

Was ist die wdzwdz-API?

Die wdzwdz-API bietet eine Reihe von REST-APIs für das Testen der Website-Performance, DNS- und Sicherheitsmetriken. Sie können damit beispielsweise Screenshots erstellen, PDFs generieren, Web Scraping durchführen oder Ports scannen. Es stehen Ihnen viele weitere Funktionen zur Verfügung.

Voraussetzungen

Für diese Anleitung benötigen Sie grundlegende Kenntnisse in JavaScript, einschließlich Promises und ES6-Syntax. Auf der Softwareseite sollten NodeJS und ein Texteditor wie Visual Studio Code installiert sein.

Zudem benötigen Sie ein wdzwdz-Konto, um einen API-Schlüssel für die Authentifizierung zu erhalten. Um ein solches Konto zu erstellen, besuchen Sie die API-Landingpage und registrieren Sie sich kostenlos. Nach der Kontoerstellung gelangen Sie zum Dashboard, wo Sie Ihren API-Schlüssel finden.

Projektstruktur

Beginnen Sie mit der Erstellung eines Projektordners und öffnen Sie diesen in einem Terminal Ihrer Wahl. Führen Sie dann den folgenden Befehl aus, um das Projekt als NodeJS-Projekt zu initialisieren:

npm init -y

Als Nächstes installieren wir alle benötigten Abhängigkeiten mit dem folgenden Befehl:

npm install dotenv axios node-fetch

Nach erfolgreicher Installation der Abhängigkeiten erstellen Sie im Hauptverzeichnis des Projekts drei JavaScript-Dateien: vanille.js, with-axios.js und with-fetch.js. Erstellen Sie außerdem eine .env-Datei, um die Umgebungsvariablen zu speichern.

Ihre Projektstruktur sollte am Ende wie folgt aussehen:

Öffnen Sie nun die .env-Datei und fügen Sie Ihren wdzwdz-API-Schlüssel in der folgenden Zeile ein:

API_KEY=<Ihr API-Schlüssel>

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

vanille.js

NodeJS enthält die Module http und https, die wir für Client-Anfragen verwenden können. Wir beginnen mit dieser Methode.

Öffnen Sie die Datei vanille.js und fügen Sie zu Beginn folgende Zeilen hinzu, um die Projekt-Abhängigkeiten zu importieren:

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

Als Nächstes rufen wir config() auf, um die Umgebungsvariablen zu laden, und speichern dann den API-Schlüssel und den Hostnamen in separaten Variablen:

config();

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

Für den Aufruf der request-Funktion, um eine HTTP-Anfrage in NodeJS zu starten, benötigen wir Optionen für den Host und den Endpunkt, die zu verwendende HTTP-Methode und die Header für die Anfrage. Diese Optionen speichern wir in einer Variablen:

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 vanille.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,
  },
};

Nun fahren wir mit dem Aufruf der request-Funktion fort, indem wir das Optionen-Objekt übergeben:

const req = request(options, response => {

  // Hier werden die Response-Handler hinzugefügt

});

Die request-Funktion benötigt zwei Argumente: das Optionen-Objekt und eine Callback-Funktion, die die Antwort des Servers verarbeitet. Innerhalb der Callback-Funktion können wir Ereignis-Listener für den Fall hinzufügen, dass der Server Daten sendet, das Senden beendet oder einen Fehler sendet.

Fügen Sie folgende Codezeilen innerhalb der Callback-Funktion hinzu, um die Response-Handler hinzuzufügen:

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 Variable data ist ein String, in dem wir die JSON-Antwort des Servers speichern. Um die Daten zu speichern, lauschen wir auf das data-Ereignis des Antwortobjekts. Immer wenn dieses ausgelöst wird, fügen wir den vom Server gesendeten Datenblock an die Daten-Variable an. Schließlich nutzen wir das end-Ereignis, das ausgelöst wird, wenn alle Daten gesendet wurden und die Antwort abgeschlossen ist.

Wir lauschen auch auf Fehler und protokollieren diese in der Konsole, falls sie auftreten.

Der Aufruf der request-Funktion sieht dann so aus:

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 Daten in den Anfragetext schreiben und die Anfrage beenden:

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

Die vollständige Datei sollte nun 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, sollte die folgende Ausgabe erfolgen:

[
  { 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 der erste Teil. Der Nachteil der Verwendung der eingebauten HTTP/S-Module ist, dass der Code sehr ausführlich ist. Client-Bibliotheken wie node-fetch helfen dabei, das gleiche Programm mit saubererem und prägnanterem Code zu erstellen.

node-fetch

Um dasselbe Skript mit node-fetch zu erstellen, öffnen Sie die Datei with-fetch.js und fügen Sie zu Beginn die folgenden Importe hinzu:

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

Rufen Sie dann die config-Funktion auf, um Umgebungsvariablen zu konfigurieren, und richten Sie Konstanten für den API-Schlüssel und den Hostnamen ein:

config();

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

Als Nächstes definieren wir eine asynchrone Funktion für den API-Aufruf:

async function request() {
  // Der Funktionskörper wird hier platziert
}

Innerhalb des Funktionskörpers rufen wir die fetch-Funktion auf:

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"] }),
});

Nach dem fetch-Aufruf möchten wir die Antwort parsen und eventuelle Fehler behandeln:

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

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

Am Ende fügen wir noch einen Aufruf der Funktion 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 des 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 verwenden wir Axios, um auf die wdzwdz-API zuzugreifen. Zunächst importieren wir dotenv und axios:

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

Rufen wir die config-Funktion auf, um Umgebungsvariablen einzurichten, und speichern wir den Hostnamen und den API-Schlüssel in separaten Konstanten:

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

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

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

Speichern wir dann die Daten für den Anfragetext in einer weiteren Konstante:

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

Und schließlich speichern wir die Meta-Optionen wie die Header in einer Konstanten:

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

Abschließend rufen wir die zuvor importierte post-Funktion auf und übergeben die URL, Daten und Optionen als Argumente. Da dies ein Promise zurückgibt, verwenden wir then, um die Antwort zu verarbeiten:

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 die Ausführung dieses Skripts mit node with-axios.js sollte 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 }
]

Fazit

In dieser Anleitung haben wir dasselbe Skript mit drei verschiedenen Ansätzen erstellt. Ziel war es zu demonstrieren, wie einfach die Verwendung der wdzwdz-API ist und wie wir sie in JavaScript, insbesondere in NodeJS, nutzen können.

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