Jak używać newsblog.pl DNS Lookup API w JavaScript (NodeJS)

W niniejszym poradniku pokażę, w jaki sposób wykorzystać API newsblog.pl w środowisku NodeJS do weryfikacji rekordów DNS dowolnej domeny.

Stworzymy nieskomplikowany program, który po uruchomieniu zaprezentuje adres IP serwera, na którym działa wyszukiwarka Google.

Ten skrypt będzie bazował na interfejsie API newsblog.pl służącym do wyszukiwania DNS.

Do jego budowy zastosujemy trzy różne strategie. Pierwsza opiera się na wbudowanym module https NodeJS. Druga wykorzystuje moduł pobierania danych (node-fetch). Wreszcie, trzecia posłuży się biblioteką klienta axios.

Czym jest API newsblog.pl?

API newsblog.pl udostępnia zestaw interfejsów REST API do analizy wydajności witryn, DNS oraz metryk bezpieczeństwa. Pozwala na wykonywanie działań takich jak tworzenie zrzutów ekranu, generowanie plików PDF, pobieranie danych ze stron internetowych, skanowanie portów i wiele innych.

Wymagania wstępne

Aby w pełni skorzystać z tego samouczka, niezbędna jest znajomość języka JavaScript, w tym mechanizmów obietnic i składni ES6. W kwestii oprogramowania, powinieneś mieć zainstalowane NodeJS oraz edytor kodu, na przykład Visual Studio Code.

Konieczne będzie również posiadanie konta w serwisie newsblog.pl, aby móc uzyskać klucz API niezbędny do uwierzytelniania podczas wysyłania zapytań. Aby to zrobić, przejdź na stronę docelową API i załóż bezpłatne konto.

Po utworzeniu konta zostaniesz przeniesiony do panelu, gdzie znajdziesz swój klucz API.

Rozpoczęcie projektu

Na początek, stwórz folder projektu i otwórz go za pomocą preferowanego terminala. Następnie wykonaj poniższe polecenie:

npm init -y

Powyższe polecenie zainicjuje katalog projektu jako projekt NodeJS.

Następnie użyj poniższego polecenia, aby zainstalować wszystkie zależności niezbędne dla naszego projektu:

npm install dotenv axios node-fetch

Po udanej instalacji zależności, utwórz trzy skrypty w głównym folderze projektu: vanilla.js, with-axios.js, with-fetch.js oraz plik .env, w którym przechowamy nasze zmienne środowiskowe.

Ostateczny układ katalogów projektu powinien prezentować się następująco:

Następnie otwórz plik .env i wklej swój klucz API newsblog.pl, stosując następujący schemat:

API_KEY=<api key>

Pamiętaj, aby zastąpić <api key> swoim rzeczywistym kluczem API.

vanilla.js

NodeJS oferuje wbudowane moduły http i https, które można wykorzystać do tworzenia zapytań klienckich. Na początku zastosujemy to podejście.

Otwórz plik vanilla.js i wklej na jego początku poniższe linie kodu, które zaimportują niezbędne zależności projektu:

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

Następnie wywołamy funkcję config(), aby załadować zmienne środowiskowe. Potem przypiszemy klucz API i nazwę hosta do odpowiednich zmiennych.

config();

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

Gdy będziemy wywoływać funkcję żądania w celu wykonania zapytania HTTP w NodeJS, konieczne będzie zdefiniowanie opcji dla hosta i punktu końcowego, z którym chcemy się połączyć, metody HTTP, którą będziemy wykorzystywać, oraz nagłówków żądania. W tym celu stworzymy zmienną, która przechowa te opcje.

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

W tym momencie, kod w pliku vanilla.js przedstawia się następująco:

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

  config();

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

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

Teraz możemy przejść do wywołania funkcji request, przekazując do niej zmienną options:

const req = request(options, response => {

    // tutaj umieścimy obsługę odpowiedzi

  });

Jak widzimy, funkcja request przyjmuje dwa argumenty. Pierwszy to obiekt options, który zdefiniowaliśmy wcześniej. Drugi to funkcja zwrotna, która będzie obsługiwać odpowiedź z serwera. Wewnątrz funkcji zwrotnej możemy dodać nasłuchiwanie zdarzeń, które wystąpią, gdy serwer przesyła dane, kończy przesyłanie danych, lub gdy pojawi się błąd.

Aby dodać obsługę różnych rodzajów odpowiedzi, wstaw następujący kod do wnętrza funkcji zwrotnej:

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 prosty ciąg znaków, w którym będziemy gromadzić dane odpowiedzi JSON z serwera w miarę ich przesyłania.

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

Następnie, aby ostatecznie wykorzystać dane, będziemy nasłuchiwać zdarzenia end w obiekcie odpowiedzi. Zostanie ono wywołane, gdy wszystkie dane zostaną przesłane z serwera i zakończy on swoją odpowiedź.

Na końcu, będziemy nasłuchiwać błędów i zapisywać je w konsoli, jeśli wystąpią.

W związku z tym, wywołanie funkcji żądania powinno wyglądać następująco:

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

  });

Ostatnim krokiem jest zapisanie danych w treści zapytania i zakończenie procesu żądania.

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

Finalnie, kod w pliku 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.newsblog.pl.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ś zobaczyć 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 wszystko, jeśli chodzi o pierwszą część. Oczywistą wadą wykorzystywania wbudowanych modułów HTTP/S jest ich kompleksowość. Biblioteki klienta, takie jak node-fetch, mogą pomóc w stworzeniu tego samego programu, ale z czytelniejszym i bardziej zwięzłym kodem.

pobieranie węzłów

Aby zbudować ten sam skrypt, ale z użyciem node-fetch, otwórz plik with-fetch.js i na samej górze dodaj następujące importy:

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

Następnie wywołaj funkcję config, aby załadować zmienne środowiskowe i ustawić stałe dla API_KEY oraz hosta, o którego rekordy A będziemy pytać.

config();

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

Teraz zdefiniujemy funkcję, która wykona wywołanie API. Funkcja ta będzie miała charakter asynchroniczny.

async function request() {
    // Ciało funkcji zostanie umieszczone tutaj
  }

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

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

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

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

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

Na koniec dodaj wywołanie funkcji po jej zdefiniowaniu.

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.newsblog.pl.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 poleceniem node with-fetch.js powinno zwrócić następujące dane:

[
    { 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 wykorzystamy Axios, aby uzyskać dostęp do API newsblog.pl. Na początek zaimportujmy pakiety dotenv i axios.

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

Następnie wywołajmy funkcję config, aby skonfigurować 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 kolejnej stałej.

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

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

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

Ostatnią rzeczą, którą zrobimy przed wysłaniem zapytania, jest zapisanie opcji meta, takich jak nagłówki, w odrębnej stałej.

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

Na koniec wywołajmy funkcję post, którą wcześniej zaimportowaliśmy, przekazując zmienne url, data i options jako argumenty. Ponieważ funkcja ta zwraca obietnicę, możemy użyć then, aby obsłużyć odpowiedź, gdy zostanie ona ostatecznie zwrócona.

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

W konsekwencji kod w pliku with-axios powinien prezentować się następująco:

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

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

  const url = "https://api.newsblog.pl.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);
  });
  

Uruchomienie skryptu poleceniem node with-axios.js powinno dać 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 }
  ]

Podsumowanie

W niniejszym artykule stworzyliśmy skrypt, stosując trzy różne podejścia. Naszym celem było pokazanie, jak proste jest korzystanie z API newsblog.pl i jak można je zaimplementować w JavaScript, a dokładniej w środowisku NodeJS.

Zachęcamy do zapoznania się z dokumentacją API newsblog.pl, aby dowiedzieć się więcej.