Jak korzystać z interfejsu API wyszukiwania Geekflare DNS w JavaScript (NodeJS)

W tym samouczku zademonstruję, jak używać API Geekflare w NodeJS do sprawdzania rekordów DNS dowolnej domeny.

Zbudujemy prosty skrypt, który po uruchomieniu wyświetla adres IP serwera wyszukiwania Google.

Ten skrypt będzie używał interfejsu API wyszukiwania Geekflare DNS.

Aby go zbudować, użyjemy trzech podejść, pierwsze wykorzystuje wbudowany moduł https w NodeJS. Drugi użyje modułu node-fetch . Wtedy ostatni użyje biblioteki klienta axios .

Co to jest API Geekflare?

Geekflare API oferuje zestawy interfejsów API REST do testowania wydajności witryny, DNS i metryk bezpieczeństwa. Możesz robić takie rzeczy, jak robienie zrzutów ekranu, generowanie plików PDF, skrobanie stron internetowych, skanowanie portów i wiele więcej.

Warunki wstępne

Aby śledzić ten samouczek, będziesz potrzebować zrozumienia JavaScript, w tym obietnic i składni ES6. Jeśli chodzi o oprogramowanie, powinieneś mieć zainstalowany NodeJS i edytor tekstu, taki jak Visual Studio Code.

Będziesz potrzebować konta Geekflare, aby uzyskać klucz API do uwierzytelniania podczas składania żądań. Aby go zdobyć, przejdź do strony docelowej API i załóż darmowe konto.

Po utworzeniu konta powinieneś zostać przekierowany do pulpitu nawigacyjnego, gdzie znajdziesz swój klucz API.

Budowanie projektu

Aby rozpocząć, utwórz folder projektu i otwórz go za pomocą wybranego terminala, a następnie uruchom poniższe polecenie.

 npm init -y

Powyższe polecenie zainicjuje katalog projektu jako projekt NodeJS.

Następnie uruchom poniższe polecenie, które zainstaluje wszystkie zależności dla naszego projektu

 npm install dotenv axios node-fetch

Po pomyślnym zainstalowaniu zależności utwórz trzy skrypty w folderze głównym projektu, a mianowicie vanilla.js , with-axios.js , with-fetch.js i plik .env do przechowywania naszych zmiennych środowiskowych.

Ostatecznie korzeń projektu powinien wyglądać tak:

Następnie otwórz plik .env i dodaj klucz API Geekflare za pomocą następującego wiersza kodu:

 API_KEY=<api key>

Zastąp <API key> swoim aktualnym kluczem API.

wanilia.js

NodeJS ma wbudowany moduł http i https , których możemy użyć do tworzenia żądań klientów. Najpierw zastosujemy to podejście.

Otwórz plik vanilla.js i dodaj następujące wiersze kodu u góry, aby zaimportować zależności projektu.

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

Następnie wywołamy funkcję config() , aby załadować zmienne środowiskowe. Następnie będziemy przechowywać klucz API i nazwę hosta w zmiennych.

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

Kiedy wywołujemy funkcję żądania, aby uruchomić żądanie HTTP w NodeJS, będziemy musieli podać opcje dla hosta i punktu końcowego, z którym chcemy się połączyć, metodę HTTP, której będziemy używać, oraz nagłówki żądania. Więc teraz stworzymy zmienną, która będzie przechowywać te opcje.

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

Jak na razie kod w pliku vanilla.js wygląda tak:

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

Teraz możemy przystąpić do wywołania funkcji żądania przekazującej w metodzie options:

 const req = request(options, response => { // we are going to add response handlers here });

Jak widać, funkcja request przyjmuje dwa argumenty. Pierwszym z nich jest obiekt opcji, który zdefiniowaliśmy wcześniej. Druga to funkcja zwrotna, która obsłuży odpowiedź z serwera. Wewnątrz funkcji wywołania zwrotnego możemy dodać detektory zdarzeń, gdy serwer wysyła dane, kończy wysyłanie danych lub wysyła błąd.

Aby dodać różne programy obsługi odpowiedzi, dodaj następujące wiersze kodu wewnątrz funkcji wywołania zwrotnego:

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

Zmienna data to po prostu ciąg znaków, w którym będziemy przechowywać odpowiedź JSON serwera, gdy jest do nas przesyłana strumieniowo.

Aby faktycznie przechowywać dane, będziemy nasłuchiwać zdarzenia on data obiektu odpowiedzi. Za każdym razem, gdy zostanie uruchomione to zdarzenie, dołączymy porcję danych przesłanych przez serwer do zmiennej data.

Następnie, aby w końcu wykorzystać dane, nasłuchujemy zdarzenia na on end w obiekcie odpowiedzi. Zostanie to wywołane, gdy wszystkie dane zostaną wysłane z serwera i zakończy on swoją odpowiedź.

Na koniec będziemy nasłuchiwać błędów i logować je do konsoli, jeśli się pojawią.

Dlatego wywołanie funkcji żądania powinno wyglądać tak

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

Na koniec musimy zapisać trochę danych w treści żądania i zakończyć żądanie.

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

Ostatecznie plik powinien wyglądać tak:

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

Teraz, jeśli wrócisz do terminala i uruchomisz skrypt za pomocą polecenia node vanilla.js , powinieneś otrzymać następujące dane wyjściowe.

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

To tyle, jeśli chodzi o pierwszą część. Oczywistą wadą korzystania z wbudowanych modułów HTTP/S jest to, że są one pełne. Biblioteki klienta, takie jak node-fetch , pomogą Ci stworzyć ten sam program, ale z jaśniejszym i bardziej zwięzłym kodem.

pobieranie węzłów

Aby utworzyć ten sam skrypt, ale z node-fetch , otwórz plik with-fetch.js i dodaj na początek następujące importy.

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

Następnie wywołaj funkcję config, aby skonfigurować zmienne środowiskowe i ustawić stałe dla API_KEY i hosta, którego rekordy A będziemy żądać.

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

Następnie zdefiniujemy funkcję, która wykona wywołanie API. Ta funkcja będzie asynchroniczna.

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

Wewnątrz ciała funkcji musimy wywołać funkcję fetch , którą zaimportowaliśmy wcześniej z pakietu node-fetch .

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

Następnie po wywołaniu funkcji fetch chcielibyśmy przeanalizować naszą odpowiedź i obsłużyć wszelkie błędy, które mogą się pojawić.

 if (response.ok) { const { data } = await response.json(); console.log(data.A); } else { console.log(response); }

W tym momencie dodaj wywołanie funkcji po jej żądaniu.

 request();

Twój plik powinien teraz wyglądać tak:

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

Uruchomienie tego skryptu z node with-fetch.js powinno dać następujące dane wyjściowe:

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

Aksjos

Na koniec użyjemy Axios, aby uzyskać dostęp do API Geekflare. Na początek zaimportujmy pakiety dotenv i axios .

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

Następnie wywołajmy funkcję config , aby ustawić zmienne środowiskowe. Dodatkowo przechowajmy nazwę hosta i klucz API w osobnych stałych.

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

Teraz zapiszmy adres URL punktu końcowego API w innej stałej

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

Następnie przechowajmy dane, które zostaną wysłane jako część treści żądania, w innej stałej

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

Następnie ostatnią rzeczą do zrobienia przed wysłaniem żądania będzie również przechowywanie opcji meta, takich jak nagłówki, w innej stałej.

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

Na koniec wykonajmy wywołanie funkcji post , którą zaimportowaliśmy wcześniej, przekazując zmienne url , data i options , które wcześniej zdefiniowaliśmy jako argumenty. Ponieważ zwróci to obietnicę, możesz następnie użyć then do obsługi odpowiedzi, gdy zostanie ona ostatecznie zwrócona.

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

Na koniec kod w pliku with-axios powinien wyglądać tak:

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

A kiedy uruchomisz skrypt używając node with-axios.js , powinien wyświetlić następujące dane wyjściowe:

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

Ostatnie słowa

W tym poście stworzyliśmy skrypt z trzema różnymi podejściami. Celem tego było podkreślenie, jak łatwe jest korzystanie z interfejsu API Geekflare i jak możemy go używać w JavaScript, a konkretnie NodeJS.

Zapoznaj się z dokumentacją interfejsu Geekflare API, aby uzyskać więcej informacji.