Comment utiliser l'API de recherche DNS Geekflare en JavaScript (NodeJS)

Dans ce tutoriel, je vais montrer comment utiliser l'API Geekflare dans NodeJS pour vérifier les enregistrements DNS de n'importe quel domaine.

Nous allons construire un script simple qui, lorsqu'il est exécuté, affiche le adresse IP du serveur de recherche de Google.

Ce script utilisera le API de recherche DNS Geekflare.

Pour le construire, nous allons utiliser trois approches, la première utilise la fonction intégrée https module dans NodeJS. La seconde utilisera le node-fetch module. Ensuite, le dernier utilisera le axios bibliothèque cliente.

Qu'est-ce que l'API Geekflare ?

API Geekflare propose des combinaisons d'API REST pour les tests de performances de sites Web, de DNS et de mesures de sécurité. Vous pouvez faire des choses comme prendre une capture d'écran, générer des PDF, faire du grattage Web, scanner des ports et bien plus encore.

Pré-requis

Pour suivre ce didacticiel, vous aurez besoin de comprendre JavaScript, y compris les promesses et la syntaxe ES6. En ce qui concerne le logiciel, vous devriez avoir NodeJS et un éditeur de texte tel que Code Visual Studio installé.

Vous aurez besoin d'un compte Geekflare pour obtenir une clé API pour l'authentification lors des demandes. Pour en obtenir un, rendez-vous au Page de destination de l'API et créez un compte gratuit.

Après avoir créé le compte, vous devriez être redirigé vers le tableau de bord, où vous trouverez votre clé API.

Construire le projet

Pour commencer, créez un dossier de projet et ouvrez-le avec un terminal de votre choix, puis exécutez la commande ci-dessous.

npm init -y

La commande ci-dessus initialisera le répertoire du projet en tant que projet NodeJS.

Ensuite, exécutez la commande ci-dessous, qui installera toutes les dépendances pour notre projet

npm install dotenv axios node-fetch

Une fois les dépendances installées avec succès, créez trois scripts dans le dossier racine du projet, à savoir vanilla.js, with-axios.js, with-fetch.js et .env fichier pour stocker nos variables d'environnement.

Au final, la racine du projet devrait ressembler à ceci :

Ensuite, ouvrez le .env file et ajoutez votre clé API Geekflare avec la ligne de code suivante :

API_KEY=<api key>

remplacer <API key> avec votre clé API réelle.

Vanilla.js

NodeJS a un intégré http et https module que nous pouvons utiliser pour faire demandes des clients. Nous allons d'abord utiliser cette approche.

Ouvrez le vanille.js fichier et ajoutez les lignes de code suivantes en haut pour importer les dépendances du projet.

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

Ensuite, nous allons appeler le config() fonction pour charger des variables d'environnement. Ensuite, nous allons stocker la clé API et le nom d'hôte dans des variables.

config();

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

Lorsque nous appelons la fonction de requête pour démarrer une requête HTTP dans NodeJS, nous devrons fournir des options pour l'hôte et le point de terminaison auxquels nous voulons nous connecter, la méthode HTTP que nous allons utiliser et les en-têtes de la requête. Ensuite, nous allons créer une variable qui stockera ces options.

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

Jusqu'à présent, le code dans le vanilla.js le fichier ressemble à ceci :

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

Nous pouvons maintenant appeler la fonction de requête en passant la méthode options :

const req = request(options, response => {

  // we are going to add response handlers here

});

Comme vous pouvez le voir, la fonction request prend deux arguments. Le premier est l'objet options que nous avons défini précédemment. La seconde est une fonction de rappel qui gérera la réponse du serveur. Dans la fonction de rappel, nous pouvons ajouter des écouteurs d'événement lorsque le serveur envoie des données, termine l'envoi de données ou envoie une erreur.

Pour ajouter les différents gestionnaires de réponse, ajoutez les lignes de code suivantes dans la fonction de rappel :

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

La variable de données est simplement une chaîne dans laquelle nous allons stocker la réponse JSON du serveur au fur et à mesure qu'elle nous est renvoyée.

Pour stocker réellement les données, nous allons écouter la réponse de l'objet on data un événement. Chaque fois que cet événement est déclenché, nous allons ajouter le bloc de données envoyé par le serveur à la variable data.

Puis pour enfin utiliser les données, nous allons écouter les on end événement sur l'objet de réponse. Celui-ci sera appelé lorsque toutes les données auront été envoyées depuis le serveur et qu'il aura terminé sa réponse.

Enfin, nous allons écouter les erreurs et les consigner dans la console si elles surviennent.

Par conséquent, l'appel à la fonction de requête devrait ressembler à ceci

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

});

Enfin, nous devons écrire des données dans le corps de la requête et terminer la requête.

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

Au final, le fichier devrait ressembler à ceci :

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

Maintenant, si vous revenez au terminal et exécutez le script en utilisant le node vanilla.js commande, vous devriez obtenir la sortie suivante.

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

Voilà pour la première partie. L'inconvénient évident de l'utilisation des modules HTTP/S intégrés est qu'ils sont verbeux. Les bibliothèques clientes telles que node-fetch vous aidera à créer le même programme mais avec un code plus clair et plus concis.

node-fetch

Pour créer le même script mais avec node-fetch, ouvre le with-fetch.js fichier et ajoutez les importations suivantes en haut.

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

Appelez ensuite la fonction config pour configurer les variables d'environnement et définir des constantes pour API_KEY et l'hôte dont nous allons demander les enregistrements A.

config();

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

Ensuite, nous allons définir une fonction pour effectuer l'appel API. Cette fonction sera asynchrone.

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

Dans le corps de la fonction, nous devons appeler le fetch fonction que nous avons importée plus tôt de la node-fetch paquet.

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

Puis après l'appel au fetch fonction, nous voudrions analyser notre réponse et gérer les erreurs qui pourraient survenir.

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

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

À ce stade, ajoutez un appel à la fonction après sa requête.

request();

Votre fichier devrait maintenant ressembler à ceci :

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

Et exécuter ce script avec node with-fetch.js devrait produire la sortie suivante :

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

Enfin, nous allons utiliser Axios pour accéder à l'API Geekflare. Pour commencer, importons le dotenv et axios packages.

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

Ensuite, appelons le config fonction de configuration des variables d'environnement. De plus, stockons le nom de l'hôte et la clé API dans des constantes distinctes.

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

Maintenant, stockons l'URL du point de terminaison de l'API dans une autre constante

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

Ensuite, stockons les données qui seront envoyées dans le corps de la requête dans une autre constante

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

Ensuite, la dernière chose à faire avant d'envoyer la requête sera de stocker également les options méta, telles que les en-têtes, dans une autre constante.

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

Enfin, lançons l'appel au post fonction que nous avons importée plus tôt, en passant dans le url, data et options variables que nous avons définies précédemment comme arguments. Parce que cela renverra une promesse, vous pouvez ensuite utiliser then pour gérer la réponse lorsqu'elle est finalement renvoyée.

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

A la fin de tout cela, le code dans le with-axios le fichier devrait ressembler à ceci:

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

Et lorsque vous exécutez le script en utilisant node with-axios.js, il doit afficher la sortie suivante :

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

Mot de la fin

Dans cet article, nous avons créé le script avec trois approches différentes. L'objectif était de mettre en évidence la facilité d'utilisation de l'API Geekflare et la manière dont nous pourrions l'utiliser en Javascript, en particulier NodeJS.

Explorer Documentation de l'API Geekflare pour plus d'information.