Verwendung der wdzwdz-API mit NodeJS: Ein umfassender Leitfaden
In diesem Tutorial zeige ich Ihnen, wie Sie die wdzwdz-API in einer NodeJS-Umgebung nutzen können.
Um dies zu veranschaulichen, entwickeln wir ein simples Skript, das beim Ausführen die IP-Adressen der Google-Suchserver ausgibt. Dieses Skript greift auf den DNS-Eintrags-Endpunkt der wdzwdz-API zu.
Für die Erstellung dieses Skripts werden wir drei verschiedene Methoden anwenden: Die erste verwendet das in NodeJS integrierte https-Modul, die zweite nutzt das node-fetch-Modul und die dritte die Axios-Client-Bibliothek.
Was ist die wdzwdz-API?
wdzwdz ist eine Plattform, die eine Reihe von Tools, APIs und Ressourcen bereitstellt, um Online-Geschäfte zu initiieren, zu betreiben und zu skalieren. Ein Bestandteil dieser Werkzeuge ist eine API, die dazu dient, die Leistung, Sicherheit und Fehleranalyse von Websites zu optimieren. Die API bietet ein großzügiges kostenloses Kontingent, das Sie nutzen können.
Benötigte Vorkenntnisse
Um diesem Tutorial folgen zu können, sollten Sie über Grundkenntnisse in JavaScript verfügen, einschließlich des Umgangs mit Promises und der ES6-Syntax. Auf der Softwareseite benötigen Sie eine Installation von NodeJS sowie einen Texteditor, beispielsweise Visual Studio Code.
Für den Zugriff auf die API benötigen Sie ein wdzwdz-Konto, um einen API-Schlüssel zur Authentifizierung zu erhalten. Sie können ein kostenloses Konto auf der API-Landingpage erstellen.
Nach der Kontoerstellung werden Sie zum Dashboard weitergeleitet, wo Sie Ihren API-Schlüssel finden.
Projektstruktur
Beginnen Sie, indem Sie einen Projektordner erstellen und ihn in einem Terminal Ihrer Wahl öffnen. Führen Sie dann den folgenden Befehl aus:
npm init -yDieser Befehl initialisiert das Projektverzeichnis als NodeJS-Projekt.
Installieren Sie anschließend alle erforderlichen Abhängigkeiten für unser Projekt mit dem folgenden Befehl:
npm install dotenv axios node-fetchSobald die Installation der Abhängigkeiten abgeschlossen ist, erstellen Sie drei Skriptdateien im Hauptverzeichnis des Projekts – vanille.js, with-axios.js, with-fetch.js – sowie eine .env-Datei zur Speicherung unserer Umgebungsvariablen.
Die endgültige Projektstruktur sollte folgendermaßen aussehen:
Öffnen Sie nun die .env-Datei und tragen Sie Ihren wdzwdz-API-Schlüssel in folgender Form ein:
API_KEY=<api key>Ersetzen Sie <api key> durch Ihren tatsächlichen API-Schlüssel.
Verwendung von Vanilla.js
NodeJS stellt integrierte HTTP- und HTTPS-Module bereit, die wir für Client-Anfragen verwenden können. Wir werden zunächst diesen Ansatz verfolgen.
Öffnen Sie die Datei vanilla.js und fügen Sie die folgenden Zeilen am Anfang hinzu, um die Projekt-Abhängigkeiten zu importieren.
import { request } from "https";
import { config } from "dotenv";Als Nächstes rufen wir die config()-Funktion auf, um die Umgebungsvariablen zu laden. Anschließend 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 Request-Funktion aufrufen, um eine HTTP-Anfrage in NodeJS zu starten, müssen wir Optionen für den Host und den Endpunkt, zu dem wir uns verbinden wollen, die HTTP-Methode, die wir verwenden werden, sowie die Header für die Anfrage angeben. Im Folgenden erstellen wir eine Variable, um diese Optionen zu speichern.
const options = {
hostname: "api.wdzwdz.com",
path: "/dnsrecord",
method: "POST",
headers: {
"Content-Type": "application/json",
"x-api-key": apiKey,
},
};Bis jetzt 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,
},
};Nun können wir die Request-Funktion mit den Optionen übergeben:
const req = request(options, response => {
// Hier werden wir die Antwort-Handler einfügen
});Wie Sie sehen können, akzeptiert die Request-Funktion zwei Argumente: Das erste ist das von uns zuvor definierte Optionsobjekt, das zweite eine Callback-Funktion, welche die Serverantwort verarbeitet. Innerhalb der Callback-Funktion können wir Event-Listener hinzufügen, die reagieren, wenn der Server Daten sendet, die Datenübertragung beendet oder einen Fehler ausgibt.
Um die verschiedenen Antwort-Handler hinzuzufügen, fügen Sie die folgenden Codezeilen innerhalb der 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 data-Variable ist lediglich ein String, in dem wir die JSON-Antwort des Servers speichern, während sie an uns zurückgesendet wird.
Um die Daten tatsächlich zu speichern, registrieren wir einen Event-Listener für das on data-Ereignis des Antwortobjekts. Jedes Mal, wenn dieses Ereignis ausgelöst wird, wird der vom Server gesendete Datenblock an die data-Variable angehängt.
Um die Daten letztendlich zu nutzen, registrieren wir einen Event-Listener für das on end-Ereignis auf dem Antwortobjekt. Dieses wird aufgerufen, sobald alle Daten vom Server gesendet wurden und seine Antwort beendet ist.
Zuletzt werden wir nach Fehlern suchen und sie bei Bedarf in die Konsole schreiben.
Der Aufruf der Request-Funktion sollte also wie folgt 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);
});
});Abschließend müssen wir noch Daten in den Anfragekörper schreiben und die Anfrage abschließen.
req.write(JSON.stringify({ url: host, types: ["A"] }));
req.end();Die vollständige Datei sollte jetzt 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 jetzt 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 bei der Verwendung der integrierten HTTP/S-Module liegt in ihrer Ausführlichkeit. Client-Bibliotheken wie Node-Fetch helfen Ihnen, dasselbe Programm mit saubererem und prägnanterem Code zu erstellen.
Verwendung von Node-Fetch
Um dasselbe Skript mit node-fetch zu erstellen, öffnen Sie die Datei with-fetch.js und fügen Sie die folgenden Importe am Anfang ein:
import fetch from "node-fetch";
import { config } from "dotenv";Danach rufen Sie die Funktion config auf, um Umgebungsvariablen zu konfigurieren und Konstanten für den API_KEY sowie den Host festzulegen, 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 zum Ausführen des API-Aufrufs. Diese Funktion ist asynchron.
async function request() {
// Hier wird der Funktionskörper stehen
}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"] }),
});Nachdem wir die Fetch-Funktion aufgerufen haben, möchten wir unsere Antwort parsen und eventuell auftretende Fehler abfangen.
if (response.ok) {
const { data } = await response.json();
console.log(data.A);
} else {
console.log(response);
}Fügen Sie am Ende der Funktion einen Aufruf der Funktion selbst 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();Wenn Sie dieses Skript nun mit node with-fetch.js ausführen, sollte die folgende Ausgabe generiert werden:
[
{ 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 }
]Verwendung von Axios
Abschließend werden wir Axios verwenden, um auf die wdzwdz-API zuzugreifen. Beginnen wir mit dem Import der Pakete dotenv und axios.
import axios from "axios";
import { config } from "dotenv";Als Nächstes rufen wir die config-Funktion auf, um Umgebungsvariablen zu konfigurieren. Speichern wir außerdem den Namen des Hosts und den API-Schlüssel in separaten Konstanten.
config();
const host = "google.com";
const key = process.env.API_KEY;Lassen Sie uns nun die URL des API-Endpunkts in einer weiteren Konstante speichern.
const url = "https://api.wdzwdz.com/dnsrecord";Als Nächstes speichern wir die Daten, die als Teil des Anfragetexts gesendet werden, in einer anderen Konstante.
const data = { url: host, types: ["A"] };Das Letzte, was wir tun müssen, bevor wir die Anfrage absenden, ist, auch die Meta-Optionen, wie Header, in einer separaten Konstante zu speichern.
const options = {
headers: {
"Content-Type": "application/json",
"x-api-key": key,
},
};Schließlich rufen wir die zuvor importierte post-Funktion auf und übergeben die von uns zuvor definierten Variablen url, data und options als Argumente. Da dies ein Promise zurückgibt, können wir .then verwenden, um die Antwort zu verarbeiten, wenn sie 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 wie folgt 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);
});
Wenn Sie das Skript mit node with-axios.js ausführen, sollte es die folgende Ausgabe liefern:
[
{ 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 }
]Schlusswort
In diesem Beitrag haben wir dasselbe Skript mit drei verschiedenen Ansätzen erstellt. Ziel war es, zu verdeutlichen, wie einfach die Verwendung der wdzwdz-API ist und wie wir sie in JavaScript, insbesondere in NodeJS, einsetzen können.
Alle anderen Endpunkte können auf ähnliche Weise verwendet werden; es ändern sich lediglich der Endpunkt und die Parameter, die Sie als Teil des Anfragetextes senden müssen. Die Dokumentation zur API finden Sie hier.