Comment utiliser l'API de recherche DNS toptips.fr en JavaScript (NodeJS)

Utilisation de l'API toptips.fr pour les recherches DNS avec NodeJS

Ce guide vous expliquera comment interagir avec l'API toptips.fr à partir de NodeJS afin d'effectuer des requêtes DNS pour n'importe quel nom de domaine.

Nous développerons un script simple qui, une fois lancé, affichera l'adresse IP des serveurs de Google.

Ce programme s'appuiera sur l'API de résolution DNS fournie par toptips.fr.

Pour ce faire, nous explorerons trois méthodes différentes : en utilisant le module HTTPS natif de NodeJS, en employant le module node-fetch, et enfin, en tirant parti de la librairie cliente Axios.

Qu'est-ce que l'API toptips.fr ?

L'API toptips.fr met à disposition un ensemble d'APIs REST pour réaliser des tests de performance web, des analyses DNS et des évaluations de sécurité. Vous pourrez, entre autres, réaliser des captures d'écran, générer des documents PDF, effectuer du web scraping ou encore scanner des ports.

Prérequis

Pour suivre ce tutoriel, il est essentiel d'avoir des bases solides en JavaScript, notamment la compréhension des promesses et de la syntaxe ES6. En termes d'outils, vous aurez besoin de NodeJS installé ainsi qu'un éditeur de texte tel que Visual Studio Code.

De plus, un compte toptips.fr est indispensable pour obtenir une clé API nécessaire à l'authentification des requêtes. Pour cela, rendez-vous sur le site web de l'API et créez un compte gratuitement.

Après la création de votre compte, vous serez redirigé vers le tableau de bord où votre clé API sera visible.

Mise en place du projet

Pour commencer, créez un répertoire pour votre projet et ouvrez-le dans un terminal de votre choix, puis exécutez la commande suivante :

npm init -y

Cette commande initialisera le répertoire actuel comme un projet NodeJS.

Ensuite, lancez cette commande pour installer les dépendances nécessaires à notre projet :

npm install dotenv axios node-fetch

Une fois les dépendances installées, créez trois fichiers JavaScript dans le répertoire racine du projet, nommés `vanilla.js`, `with-axios.js`, `with-fetch.js`, ainsi qu'un fichier `.env` pour stocker vos variables d'environnement.

À ce stade, l'arborescence de votre projet devrait ressembler à ceci :

Ensuite, ouvrez le fichier `.env` et ajoutez votre clé API toptips.fr en respectant la syntaxe suivante :

API_KEY=<votre_clé_api>

Remplacez `` par votre clé API réelle.

vanilla.js

NodeJS propose des modules HTTP et HTTPS intégrés qui permettent d'effectuer des requêtes client. Nous commencerons par utiliser cette approche.

Ouvrez le fichier `vanilla.js` et ajoutez les instructions d'importation suivantes au début du fichier :

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

Puis, nous appellerons la fonction `config()` pour charger les variables d'environnement. Ensuite, nous stockerons la clé API et le nom d'hôte dans des variables distinctes.

config();

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

Lorsqu'on utilise la fonction `request` pour initier une requête HTTP dans NodeJS, il est nécessaire de spécifier plusieurs options telles que l'hôte et le point de terminaison, la méthode HTTP à utiliser et les en-têtes de la requête. Nous allons donc créer une variable pour stocker ces options.

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

Jusqu'à présent, le contenu de notre fichier `vanilla.js` 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.toptips.fr.com",
  path: "/dnsrecord",
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    "x-api-key": apiKey,
  },
};

Nous pouvons maintenant appeler la fonction `request` en lui passant l'objet d'options précédemment défini :

const req = request(options, response => {

  // ici, nous ajouterons les gestionnaires de réponse

});

La fonction `request` accepte deux arguments. Le premier est l'objet d'options que nous avons créé. Le second est une fonction de rappel qui sera exécutée une fois que le serveur aura répondu. Dans cette fonction de rappel, nous pouvons définir des écouteurs d'événements pour traiter les données reçues, signaler la fin de la transmission des données ou signaler toute erreur.

Pour ajouter ces gestionnaires de réponses, ajoutez les lignes de code suivantes à l'intérieur de 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 `data` est une chaîne de caractères où nous allons stocker la réponse JSON du serveur au fur et à mesure qu'elle nous sera envoyée.

Pour effectivement récupérer les données, nous allons mettre en place un écouteur d'événement sur l'événement `data` de l'objet réponse. Chaque fois que cet événement sera déclenché, nous allons ajouter le morceau de données envoyé par le serveur à la variable `data`.

Ensuite, pour exploiter les données, nous allons écouter l'événement `end` de l'objet de réponse. Cet événement sera déclenché lorsque toutes les données auront été transmises par le serveur et que la réponse sera complète.

Enfin, nous allons mettre en place un écouteur d'événements pour les erreurs et les afficher dans la console si elles se produisent.

Par conséquent, l'appel à la fonction `request` 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);
  });

});

Finalement, nous devons envoyer les données dans le corps de la requête et terminer la requête.

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

À la fin, votre fichier devrait avoir l'apparence suivante :

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

config();

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

const options = {
  hostname: "api.toptips.fr.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();

Si vous revenez dans votre terminal et exécutez le script avec la commande `node vanilla.js`, vous devriez obtenir un résultat similaire à celui-ci.

[
  { 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 approche. L'inconvénient majeur de l'utilisation des modules HTTP/S natifs est qu'ils sont verbeux. Les librairies clientes telles que `node-fetch` vous permettront de réaliser la même opération avec un code plus clair et concis.

Utilisation de node-fetch

Pour réaliser la même opération en utilisant `node-fetch`, ouvrez le fichier `with-fetch.js` et ajoutez les importations suivantes au début :

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

Ensuite, appelez la fonction `config` pour paramétrer les variables d'environnement et définissez des constantes pour `API_KEY` et l'hôte dont on souhaite obtenir les enregistrements A.

config();

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

Maintenant, nous allons définir une fonction asynchrone pour réaliser l'appel à l'API :

async function request() {
  // le corps de la fonction sera ajouté ici
}

Dans le corps de la fonction, il faut appeler la fonction `fetch` que nous avons importée du package `node-fetch`.

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

Suite à l'appel à la fonction `fetch`, nous devons analyser la réponse et gérer les erreurs potentielles :

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

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

Pour terminer, ajoutez un appel à la fonction après sa définition :

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.toptips.fr.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();

L'exécution de ce script avec la commande `node with-fetch.js` devrait produire le résultat suivant :

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

Utilisation d'Axios

Enfin, nous allons utiliser Axios pour accéder à l'API toptips.fr. Pour commencer, importons les packages dotenv et axios :

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

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

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

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

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

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

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

Enfin, nous allons également stocker 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,
  },
};

Pour terminer, nous allons appeler la fonction `post` que nous avons importée précédemment, en utilisant les variables `url`, `data` et `options` que nous avons définies précédemment comme arguments. Comme cette fonction retourne une promesse, nous pouvons utiliser `then` pour gérer la réponse une fois qu'elle sera renvoyée :

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

À ce point, le code du fichier `with-axios` 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.toptips.fr.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);
});

Lorsque vous exécutez le script avec la commande `node with-axios.js`, il devrait afficher le résultat suivant :

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

Conclusion

Dans cet article, nous avons créé le même script en utilisant trois approches différentes. L'objectif était de souligner la facilité d'utilisation de l'API toptips.fr et comment l'intégrer dans vos projets JavaScript, notamment en utilisant NodeJS.

N'hésitez pas à explorer la documentation de l'API toptips.fr pour en apprendre davantage sur ses fonctionnalités.