Wie man Geekflare DNS Lookup API in JavaScript (NodeJS) verwendet

In diesem Tutorial zeige ich Ihnen, wie Sie die Geekflare API in NodeJS verwenden können, um die DNS-Einträge einer beliebigen Domain zu überprüfen.

Wir werden ein einfaches Skript erstellen, das, wenn es ausgeführt wird, die IP-Adresse des Google-Such-Servers ausgibt.

Dieses Skript wird die Geekflare DNS Lookup API verwenden.

Um es zu erstellen, verwenden wir drei Ansätze: Der erste nutzt das integrierte https-Modul in NodeJS. Der zweite verwendet das node-fetch Modul. Der letzte Ansatz verwendet die axios Client-Bibliothek.

Was ist die Geekflare API?

DieGeekflare API bietet eine Reihe von REST-APIs zum Testen von Website-Performance-, DNS- und Sicherheitsmetriken. Sie können z.B. einen Screenshot machen, PDFs generieren, Web Scraping, Port Scanning und vieles mehr durchführen.

Voraussetzungen

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

Sie benötigen ein Geekflare-Konto, um einen API-Schlüssel für die Authentifizierung bei Anfragen zu erhalten. Gehen Sie dazu auf die 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 erstellen

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

npm init -y

Der obige Befehl initialisiert das Projektverzeichnis als NodeJS-Projekt.

Als nächstes führen Sie 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 Stammverzeichnis des Projekts, nämlich vanilla.js, with-axios.js, with-fetch.js und eine .env-Datei, um unsere Umgebungsvariablen zu speichern.

Am Ende sollte das Projektstammverzeichnis wie folgt aussehen:

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

API_KEY=<API-Schlüssel&gt

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

Vanilla.js

NodeJS verfügt über ein eingebautes http- und https-Modul, mit dem wir Client-Anfragen stellen können. Wir werden zunächst diesen Ansatz verwenden.

Öffnen Sie die Datei vanilla.js und fügen Sie die folgenden Codezeilen am Anfang ein, um die Abhängigkeiten des Projekts zu importieren.

import { request } from "https";
importieren Sie { config } von "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 Funktion request aufrufen, um eine HTTP-Anfrage in NodeJS zu starten, müssen wir Optionen für den Host und den Endpunkt, mit dem wir uns verbinden wollen, die HTTP-Methode, die wir verwenden wollen, und die Header für die Anfrage angeben. Als nächstes erstellen wir eine Variable, die diese Optionen speichert.

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

Bislang sieht der Code in der Datei vanilla.js wie folgt 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/de",
  path: "/dnsrecord",
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    "x-api-key": apiKey,
  },
};

Jetzt können wir die Anforderungsfunktion aufrufen, indem wir die Optionsmethode übergeben:

const req = request(options, response => {

  // hier fügen wir Antwort-Handler hinzu

});

Wie Sie sehen können, nimmt die Anfrage-Funktion zwei Argumente entgegen. Das erste ist das Optionsobjekt, das wir zuvor definiert haben. Das zweite ist eine Callback-Funktion, die die Antwort des Servers verarbeiten wird. Innerhalb der Callback-Funktion können wir Ereignislisten für den Fall hinzufügen, dass der Server Daten sendet, das Senden von Daten beendet oder einen Fehler sendet.

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

let data = "";

response.on("Daten", chunk => {
  data = chunk;
});

response.on("end", () => {
  console.log(JSON.parse(data).data.A);
});

response.on("error", error => {
  console.log(error);
});

Die data-Variable ist einfach eine Zeichenkette, in der wir die JSON-Antwort des Servers speichern, wenn sie an uns zurückgesendet wird.

Um die Daten tatsächlich zu speichern, werden wir auf das Ereignis on data des Antwortobjekts hören. Immer wenn dieses Ereignis ausgelöst wird, fügen wir den vom Server gesendeten Datenblock an die Variable data an.

Um die Daten schließlich zu verwenden, werden wir auf das Ereignis on end des Antwortobjekts warten. Dieses Ereignis wird aufgerufen, wenn alle Daten vom Server gesendet wurden und er seine Antwort beendet hat.

Schließlich warten wir auf Fehler und protokollieren sie auf der Konsole, falls sie auftreten.

Daher sollte der Aufruf der Anfragefunktion wie folgt aussehen

const req = Anfrage(Optionen, Antwort => {

  let data = "";

  response.on("Daten", chunk => {
    data = chunk;
  });

  response.on("end", () => {
    console.log(JSON.parse(data).data.A);
  });

  response.on("error", error => {
    console.log(error);
  });

});

Zum Schluss müssen wir noch einige Daten in den Body der Anfrage schreiben und die Anfrage beenden.

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

Am Ende sollte die Datei wie folgt 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/de",
  path: "/dnsrecord",
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    "x-api-key": apiKey,
  },
};

const req = Anfrage(Optionen, Antwort => {

  let data = "";

  response.on("Daten", 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 vanilla.js ausführen, sollten Sie die folgende Ausgabe erhalten.

[
  { Adresse: '172.253.122.101', ttl: 247 },
  { Adresse: '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 eingebauten HTTP/S-Module ist, dass sie sehr umfangreich sind. Mit Client-Bibliotheken wie node-fetch können Sie das gleiche Programm erstellen, allerdings mit einem klareren und prägnanteren Code.

node-fetch

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

importieren Sie fetch von "node-fetch";
importieren Sie { config } von "dotenv";

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

config();

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

Als nächstes definieren wir eine Funktion, die den API-Aufruf durchführt. Diese Funktion wird asynchron sein.

asynchrone Funktion request() {
  // Der Körper der Funktion wird hier abgelegt
}

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

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

Nach dem Aufruf der fetch-Funktion möchten wir unsere Antwort parsen und eventuelle Fehler behandeln.

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

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

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

anfrage();

Ihre Datei sollte nun wie folgt aussehen:

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

config();

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

asynchrone Funktion request() {
  const response = await fetch("https://api.geekflare.com/de/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(daten.A);
  } else {
    console.log(response);
  }
}

request();

Wenn Sie dieses Skript mit node with-fetch.js ausführen, sollten Sie die folgende Ausgabe erhalten:

[
  { Adresse: '172.253.122.113', ttl: 134 },
  { Adresse: '172.253.122.138', ttl: 134 },
  { address: '172.253.122.100', ttl: 134 },
  { Adresse: '172.253.122.139', ttl: 134 },
  { Adresse: '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. Lassen Sie uns zunächst die Pakete dotenv und axios importieren.

import axios von "axios";
importieren Sie { config } von "dotenv";

Als nächstes rufen wir die Funktion config auf, um Umgebungsvariablen einzurichten. Außerdem speichern wir den Namen des Hosts und den API-Schlüssel in separaten Konstanten.

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.geekflare.com/de/dnsrecord";

Als nächstes speichern wir die Daten, die als Teil des Anfragekörpers gesendet werden, in einer weiteren Konstante

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

Als letztes, bevor wir die Anfrage abschicken, speichern wir auch die Meta-Optionen, wie z.B. die Kopfzeilen, in einer weiteren Konstante.

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

Abschließend rufen wir die Funktion post auf, die wir zuvor importiert haben, und übergeben die Variablen url, data und options, die wir zuvor als Argumente definiert haben. Da diese Funktion ein Versprechen zurückgibt, können Sie damit die Antwort verarbeiten, wenn sie schließlich zurückgegeben wird.

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

Am Ende sollte der Code in der Datei with-axios wie folgt aussehen:

import axios from "axios";
importieren Sie { config } von "dotenv";

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

const url = "https://api.geekflare.com/de/dnsrecord";
const data = { url: host, Typen: ["A"] };
const options = {
  kopfzeilen: {
    "Content-Type": "application/json",
    "x-api-key": key,
  },
};

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

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

[
  { Adresse: '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. Ziel war es, zu zeigen, wie einfach die Nutzung der Geekflare API ist und wie wir sie in Javascript, insbesondere in NodeJS, verwenden können.

Weitere Informationen finden Sie in der Geekflare API-Dokumentation.