Comment utiliser l’API toptips.fr en JavaScript (NodeJS)

par
Tweetez
Partagez
Enregistrer
Partagez
Partagez
0 Partages

Dans ce tutoriel, je vais montrer comment utiliser l’API toptips.fr dans NodeJS.

Pour le démontrer, nous allons créer un script simple qui, une fois exécuté, imprime l’adresse IP du serveur de recherche de Google. Ce script utilisera le point de terminaison d’enregistrement DNS de l’API de toptips.fr.

Pour le construire, nous allons utiliser trois approches, la première utilise le module https intégré dans NodeJS. Le second utilisera le module node-fetch. Ensuite, le dernier utilisera la bibliothèque client axios.

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

toptips.fr est un site Web qui fournit des outils, des API et des ressources pour créer, gérer et développer une entreprise en ligne. Ces outils incluent une API qui peut être exploitée pour gérer les performances, la sécurité et l’audit d’un site Web pour les problèmes de site. L’API a un niveau gratuit généreux dont vous pouvez profiter.

Conditions préalables

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 devez avoir installé NodeJS et un éditeur de texte tel que Visual Studio Code.

Vous aurez besoin d’un compte toptips.fr pour obtenir une clé API pour l’authentification lors des demandes. Pour en obtenir un, rendez-vous sur la page d’accueil 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 un fichier .env pour stocker nos variables d’environnement.

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

Ensuite, ouvrez le fichier .env et ajoutez votre clé API toptips.fr avec la ligne de code suivante : 

API_KEY=<api key>

Remplacez par votre clé API réelle.

Avec Vanilla.js

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

Ouvrez le fichier vanilla.js 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 la fonction config() pour charger les 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.toptips.fr.com",
  path: "/dnsrecord",
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    "x-api-key": apiKey,
  },
};

Jusqu’à présent, le code du 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 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 l’événement on data de l’objet de réponse. Chaque fois que cet événement est déclenché, nous allons ajouter le bloc de données envoyé par le serveur à la variable data.

Ensuite, pour enfin utiliser les données, nous allons écouter l’événement on end 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.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();

Maintenant, si vous revenez au terminal et exécutez le script à l’aide de la commande node vanilla.js, 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 aideront à créer le même programme mais avec un code plus clair et plus concis.

Avec récupération de nœud

Pour créer le même script mais avec node-fetch, ouvrez le fichier with-fetch.js 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 la fonction de récupération que nous avons importée précédemment à partir 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"] }),
});

Ensuite, après l’appel à la fonction de récupération, 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 demande.

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

Et l’exécution de ce script avec 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 }
]

Avec 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.

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.toptips.fr.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, appelons la fonction post que nous avons importée précédemment, en transmettant les variables url, data et options que nous avons définies précédemment comme arguments. Étant donné que cela renverra une promesse, vous pouvez ensuite utiliser then pour gérer la réponse lorsqu’elle sera 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 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);
});

Et lorsque vous exécutez le script à l’aide de 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 }
]

Derniers mots

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

Tous les autres points de terminaison peuvent être utilisés de la même manière ; tout ce qui change est le point de terminaison et les paramètres que vous devez envoyer dans le corps de la requête. La documentation de l’API est disponible ici.