layout: post title: “Développer un Back End en Node.js” date: 2024-10-19 02:00:00 +0002 tags: node

Développer en Node.js

Créer un serveur HTTP avec Node.js : guide du débutant

📝 Dans ce post, nous allons reprendre les bases de la documentation Create an HTTP Server with Node.js: Beginner’s Guide traduite en français afin de pouvoir installer notre environnement de développement dans des conditions optimales, de manière à compendre les rouages du module Node.js.

Node.js est un puissant environnement d’exécution JavaScript open source, multiplateforme et back-end qui s’exécute sur le moteur V8 de Chrome et exécute le code JavaScript en dehors d’un navigateur Web. Node.js permet aux développeurs d’utiliser JavaScript pour écrire des outils de ligne de commande ainsi que pour des scripts côté serveur, ce qui signifie exécuter des scripts côté serveur pour produire un contenu de page Web dynamique avant que la page ne soit envoyée au navigateur Web de l’utilisateur. Par conséquent, Node.js représente un paradigme appelé « JavaScript partout » qui, simplement mis en place, représente un développement Web complet unifié autour d’un langage de programmation commun, plutôt que l’utilisation de langages différents pour les scripts côté serveur et côté client.

L’application la plus basique pour essayer la même chose est la mise en œuvre d’un serveur Web HTTP (HyperText Transfer Protocol). HTTP est un protocole utilisé pour récupérer des ressources telles que des documents HTML et plus encore. Il s’agit de la base la plus courante pour tout échange de données sur le Web. Il s’agit essentiellement d’un protocole client-serveur, ce qui signifie que les requêtes sont déclenchées par le destinataire, généralement le navigateur Web. Lorsque nous voyons une page dans notre navigateur, nous faisons en arrière-plan une requête à un autre système sur Internet, qui nous fournit la page Web en réponse. Le système avec lequel nous communiquons via Internet est un serveur Web.

Dans cet article, nous couvrirons une implémentation de base d’un simple serveur HTTP utilisant NodeJS. Un serveur http Node est le moyen le plus simple de mettre la main dessus et de pratiquer un serveur Web Node js.

💡 Le code source de cet exercice est disponible sur le dépôt Github webapps-conception/nodejs-server-example.

Création d’un serveur HTTP

Pour cet exemple, nous supposerons que Node.js est installé sur le système. Node.js prend en charge la création de serveurs Web prêts à l’emploi, ce qui signifie qu’un serveur Web Node js peut être directement créé à partir d’un jeu de commandes de base.

Nous allons commencer par créer un serveur http simple Node, dont le but sera de renvoyer un texte brut à l’utilisateur. Cela couvrira les concepts clés nécessaires à la configuration d’un serveur, qui peuvent à leur tour être extrapolés pour fournir la base nécessaire pour renvoyer d’autres formats de données complexes tels que JSON.

Tout d’abord, il est nécessaire de configurer un environnement, donc pour cela nous allons créer un dossier appelé sampleServer et créer un fichier qui va héberger le serveur. Après cela, nous devons ouvrir le fichier dans un éditeur de notre choix, puis commencer par charger le module http. Ceci est fourni en standard avec toutes les installations Node.js.

const http = require("http");

Le module http disponible avec le bundle Node js contient les fonctions nécessaires à la création du serveur, que nous découvrirons plus tard. L’étape suivante consiste à définir deux constantes, l’hôte et le port. Cela ferait référence à l’endroit où notre serveur sera lié :

const host = 'localhost'; 
const port = 8000; 

Comme mentionné précédemment, un serveur Web accepte les requêtes de différents navigateurs et d’autres types de clients. Nous pouvons interagir avec un serveur Web via un nom de domaine, qui est ensuite traduit en adresse IP d’un système respectif par un serveur DNS. Une adresse IP est une séquence d’identifiants uniques de chiffres qui identifient un système sur un réseau.

Localhost est une adresse privée spéciale que les systèmes informatiques utilisent pour se référer à eux-mêmes. Elle est généralement représentée par l’adresse IP interne 127.0.0.1 et n’est disponible que pour l’ordinateur spécifique, et non pour aucun des réseaux auxquels nous sommes connectés.

Le port est un numéro utilisé par les serveurs comme point de terminaison de nos adresses IP. Dans cet exemple, nous allons continuer avec le port 8000 pour notre serveur Web. Les ports 8080 et 8000 sont généralement utilisés comme ports par défaut dans les phases de développement et de test, et il est en quelque sorte non-dit parmi les développeurs de les utiliser plutôt que d’autres ports disponibles pour les serveurs HTTP.

Lorsque nous lions notre serveur à cet hôte et à ce port spécifiques, nous pouvons accéder à notre serveur en visitant http://localhost:8000 dans un navigateur local. Maintenant, afin de vérifier que le serveur est créé, nous devons ajouter une fonction qui, dans Node.js, est appelée en tant qu’écouteur de requêtes. Cette fonction gère une requête HTTP entrante et renvoie une réponse HTTP respective. Cette fonction a deux arguments spécifiques, un objet requête et un objet réponse. L’objet de requête est chargé de capturer toutes les données de la requête HTTP entrante. L’objet de réponse est chargé de renvoyer les réponses HTTP du serveur.

Nous renverrons un message Bonjour du serveur !, chaque fois que quelqu’un y accédera. Ajoutons ensuite cette fonction requise :

const requestListener = function (req, res) { 
 res.writeHead(200); 
 res.end("Hello from Server!"); 
};

La fonction doit généralement être nommée en fonction de son objectif. Puisqu’il s’agit d’un exemple de cas générique, nous utiliserons le nom générique requestListener.

Ces fonctions d’écoute de requête acceptent deux arguments spécifiques, à savoir la requête et la réponse. Dans l’exemple ci-dessus, ils sont écrits sous la forme req et res, nous pouvons les nommer selon notre convenance. Un objet Request encapsule la requête HTTP envoyée par l’utilisateur, qui est le premier argument. La réponse HTTP renvoyée à l’utilisateur est générée en interagissant avec l’objet Response qui est le deuxième argument. Veuillez noter que si requestListener() n’utilise pas l’objet req, il doit néanmoins s’agir du premier argument de la fonction.

La première ligne, res.writeHead(200), définit le code d’état HTTP nécessaire de la réponse. Le code d’état HTTP indique comment une requête HTTP spécifique a été traitée par le serveur. Il existe de nombreuses réponses comme 404 représentant non trouvé, 501 représentant un échec, etc. Dans ce cas, la valeur du code d’état 200 correspond au succès.

La ligne suivante, res.end("Hello from Server!"), écrit la réponse en texte brut au client. Cette fonction est chargée de renvoyer toutes les données que le serveur doit renvoyer. Dans notre cas, il renvoie des données en texte brut.

Enfin, nous pouvons maintenant créer notre serveur et utiliser notre écouteur de requêtes :

La ligne suivante de la fonction correspondante, res.end("Hello from Server!") est chargée de réécrire la réponse HTTP au client qui l’a demandée. Cette fonction gère tous les retours de données fournis par le serveur. Dans notre exemple, il renvoie des données textuelles.

Enfin, nous pouvons maintenant créer notre serveur en utilisant notre écouteur de requêtes :

const server = http.createServer(requestListener); 
server.listen(port, host, () => { 
 console.log(`Server is running on http://${host}:${port}`); 
});

Dans cet exemple, dans la première ligne, nous créons un nouvel objet serveur à l’aide du module http, en utilisant la fonction createServer(). Cela montre que le serveur accepte les requêtes HTTP et les transmet à la fonction requestListener().

Une fois le serveur créé, nous devons le lier à une adresse réseau spécifique. Cela se fait à l’aide de la méthode server.listen(). Il accepte trois paramètres : le port, l’hôte et une fonction de rappel qui se déclenche lorsque le serveur commence à écouter.

Notez que tous les arguments mentionnés sont en fait facultatifs, mais il est recommandé d’indiquer explicitement le port et l’hôte que nous utilisons pour le serveur Web, car cela aide à configurer l’équilibrage de charge ou un alias DNS, si nécessaire. La fonction de rappel enregistre également un message sur la console afin que nous puissions savoir quand le serveur a commencé à écouter les connexions.

Maintenant, pour tester cela, nous devons exécuter le fichier js que nous avons créé :

Node sample.js et on voit ça dans la console :

Après avoir exécuté cela, le serveur Node.js continuera à fonctionner. Il ne s’arrêtera que si nous terminons manuellement le processus qui exécute le serveur ou s’il rencontre une erreur d’exécution.

Nous pouvons désormais communiquer avec le serveur à l’aide d’une fenêtre de terminal distincte, en utilisant cURL, un outil CLI utilisé pour transférer des données vers et depuis un réseau. Nous pouvons directement utiliser curl sur l’adresse localhost et obtenir le résultat.

Le déroulement du processus est le suivant :

• Nous envoyons une requête GET au serveur à l’adresse http://localhost:8000 en utilisant Curl.
• Le serveur Node.js écoute les connexions à partir de l’adresse du serveur localhost.
• Le serveur a ensuite transmis cette requête à la fonction requestListener().
• La fonction a renvoyé les données texte ajoutées avec le code d’état 200, ce qui implique OK.
• Le serveur a ensuite renvoyé cette réponse à cURL, qui est ensuite affichée dans le terminal.

Retour de contenu

La réponse du serveur n’est pas toujours du texte brut, nous pouvons également renvoyer du HTML, Json, XML, CSV et d’autres formats de réponse. Nous pouvons également renvoyer des données non textuelles telles que PDF, audio vidéo, etc.

Tout d’abord, pour garantir cela, nous devons définir l’en-tête Content-Type dans nos réponses HTTP avec le type de réponse approprié et nous assurer que res.end() doit obtenir les données dans le bon format.

Dans l’exemple suivant, nous verrons comment renvoyer des données json depuis le serveur. JSON signifie JavaScript Object Notation, qui est un format d’échange de données basé sur du texte. Bien qu’il soit dérivé de JavaScript, il est très indépendant du langage, ce qui lui permet d’être utilisé par n’importe quel langage capable de l’analyser. JSON est le plus souvent utilisé comme moyen incontournable pour accepter et renvoyer des données avec des API, en raison de sa taille de transfert de données inférieure à celle des normes d’échange de données existantes.

Créons un nouveau fichier avec le modèle pour le serveur :

const http = require("http"); 
const host = 'localhost'; 
const port = 8000; 
const requestListener = function (req, res) {}; 
const server = http.createServer(requestListener); 
server.listen(port, host, () => { 
 console.log(`Server is running on http://${host}:${port}`); 
});

Ici, nous renvoyons une réponse JSON, nous allons donc modifier la fonction requestListener() pour renvoyer l’en-tête approprié :

const requestListener = function (req, res) { 
 res.setHeader("Content-Type", "application/json"); 
};

La méthode setHeader() de l’objet de réponse ajoute un en-tête HTTP à la réponse. Les en-têtes HTTP déduisent des informations supplémentaires qui peuvent être jointes à la fois à la demande ou à la réponse. La méthode res.setHeader() a besoin de deux arguments, le nom de l’en-tête et sa valeur correspondante.

L’en-tête « Content-Type » est utilisé pour indiquer le format des données transmises avec la demande ou la réponse. Puisque nous allons utiliser JSON, notre Content-Type est application/json.

Maintenant, afin de renvoyer un exemple de contenu JSON à l’utilisateur, nous devrons modifier le fichier avec des informations JSON aléatoires :

const requestListener = function (req, res) { 
 res.setHeader("Content-Type", "application/json"); 
 res.writeHead(200); 
 res.end(`{"sample message": "This is a sample JSON response"}`); 
};

Ici également, nous informons l’utilisateur que la requête a abouti en renvoyant le code d’état 200. Notez que dans l’appel response.end(), notre argument de chaîne contient un JSON valide. Voici le résultat.

Servir une page HTML à partir d’un fichier

HTML (HyperText Markup Language) est le format le plus couramment utilisé pour permettre à l’utilisateur d’interagir avec un serveur Web, à l’aide d’un navigateur Web. Il a été créé spécifiquement pour le contenu Web structuré. Tous les navigateurs Web prennent en charge le contenu HTML, ainsi que tout ajout de style effectué avec CSS. CSS est un autre élément de technologie Web frontal qui nous permet de modifier l’esthétique globale de nos sites Web.

Afin de renvoyer la page html, nous devons spécifier le type de contenu dans l’objet de réponse similaire à ce que nous avions fait dans le cas de JSON dans l’exemple précédent.

const requestListener = function (req, res) { 
 res.setHeader("Content-Type", "text/html"); 
 res.writeHead(200); 
 res.end(`<html><body><h2><Strong>This is HTML</h2></body></html>`); 
};

Une fois que nous avons exécuté ce fichier JavaScript et ouvert http://localhost:8000 dans un navigateur, nous pouvons voir le code HTML que nous avons renvoyé.

Cependant, outre l’ajout manuel du contenu, nous pouvons également servir une page HTML à partir d’un fichier comme réponse. Pour servir des fichiers HTML, nous chargeons le fichier HTML à l’aide du « module fs » et utilisons ses données lors de l’écriture de notre réponse HTTP.

Prenons l’exemple d’un exemple de page html que nous devons afficher :

<!DOCTYPE html> 
<html> 
<body> 
  <H1> This is an Html from a file </H1> 
  <p> This is the common ways to serve a page</p> 
</body> 
</html>

Maintenant, pour importer le fichier, nous devons d’abord le lire, ce qui se fait à l’aide du module fs :

const http = require("http"); 
const fs = require('fs').promises;

Le module fs contient une fonction readFile() qui est généralement utilisée pour charger des fichiers HTML. Afin de suivre les pratiques JavaScript modernes, nous importons la variante promise de l’appel. C’est également mieux que les rappels, dans divers cas.

Nous devons maintenant modifier le fichier js en cours d’exécution avec ces informations et renvoyer la page en utilisant then une fois terminé :

const requestListener = function (req, res) { 
 fs.readFile(__dirname + "/samplePage.html") 
 .then(contents => { 
 res.setHeader("Content-Type", "text/html"); 
 res.writeHead(200); 
 res.end(contents); 
 }) 
.catch(err => { 
 res.writeHead(500); 
 res.end(err); 
 return; 
 }); 
};

Ici, la méthode fs.readFile() est utilisée pour charger le fichier. Il a 2 arguments __dirname et /samplePage.html. La variable __dirname représente ici le chemin absolu, où le code Node.js est actuellement en cours d’exécution. Nous pouvons ensuite ajouter /samplePage.html à ce chemin afin de pouvoir charger le fichier HTML que nous souhaitons servir.

Une fois la promesse fs.readFile() résolue avec succès, elle renverra les données correspondantes. Nous utilisons ensuite la méthode then() pour gérer ce cas de suivi. Le paramètre contents est celui qui contient les données réelles du fichier HTML.

Il est conseillé d’utiliser la méthode catch() en association avec une promesse, car lorsqu’une promesse rencontre une erreur, elle est rejetée, il est donc préférable de gérer également ces cas. Le bloc catch accepte l’erreur renvoyée par fs.readFile() et définit le code d’état sur 500, ce qui indique une erreur interne du serveur et le renvoie à l’utilisateur.

Nous pouvons voir le résultat une fois que nous exécutons le fichier :

Gestion des routes par objet de requête HTTP

La plupart des sites Web ou des API que nous visitons ou utilisons ont généralement plusieurs points de terminaison d’URL afin que nous puissions accéder à diverses ressources disponibles dans le même. Un exemple courant serait un cas de gestion des stocks, qui pourrait être utilisé dans un entrepôt. Il aurait non seulement besoin de gérer les données d’inventaire, mais il gérerait également la quantité, le nom du fabricant, etc., quelles que soient les données nécessaires aux processus de catalogage et de recherche pour plus de commodité.

Même si les données json ici, le nom de l’article et le nom du fabricant sont liés en termes d’inventaire qu’ils représentent, ce sont des objets différents. Dans ces cas, les informations de réponse de chaque objet sont généralement stockées sur différents points de terminaison. Cela permet d’indiquer facilement à l’utilisateur actuel de l’API avec quel type de données il interagit.

Jusqu’à présent, nous n’avons construit aucune logique de routage spéciale dans la fonction requestListener() pour gérer les requêtes dont l’URL contient d’autres chemins, donc si nous appelons http://localhost:8000/random, Node.js renverra la même réponse que celle-ci. de http://localhost:8000 qui est celui par défaut.

Dans l’exemple suivant, nous allons créer un nouveau serveur pour un petit système d’inventaire, qui peut renvoyer 2 types de données différents. Le point de terminaison de l’adresse du serveur à /items fournira une liste d’éléments avec leurs quantités respectives en JSON. Le point final /manufacturers fournira une liste d’informations sur les fabricants au format JSON. Commençons par stocker nos données JSON dans des variables avant la fonction requestListener() :

const items = JSON.stringify([ 
 { itemName: "Measuring Tape", manufacturer: "3M", quantity: 52 }, 
 { itemName: "DrillBit", manufacturer: "Bosch", quantity: 47 } 
]); 
const manufacturers = JSON.stringify([ 
 { name: "3M", countryOfOrigin: "America", partnerSince: 2019 }, 
 { name: "Bosch", countryOfOrigin: "Germany", partnerSince: 2014 } 
]);

La variable items est une chaîne qui contient du JSON pour un tableau d’objets item. Chaque article a un nom, le nom d’un fabricant et les quantités respectives. La variable Manufacturers est une chaîne qui contient le JSON d’un tableau d’objets Manufacturer. Chaque fabricant a un nom, un pays d’origine, et depuis quand ils sont partenaires.

Maintenant que nous avons ajouté les données aux réponses, nous les obtiendrons en retour. Donc pour cela, nous devons modifier la fonction requestListener() pour acheminer les requêtes vers les routes correctes, mais nous devons d’abord nous assurer que chaque réponse du serveur a le bon en-tête Content-Type respectif, dans notre cas, il s’agit de JSON. Après cela, nous devons renvoyer le bon JSON en fonction du chemin URL visité par l’utilisateur. Afin d’obtenir un chemin URL à partir de l’objet de requête, nous devons accéder à la propriété url. Sur la base de ce différenciateur, nous pouvons créer une instruction switch sur l’URL de la requête comme suit :

const requestListener = function (req, res) { 
 res.setHeader("Content-Type", "application/json"); 
 switch (req.url) { 
 case "/items": 
 res.writeHead(200); 
 res.end(items); 
 break 
 case "/manufacturers": 
 res.writeHead(200); 
 res.end(manufacturers); 
 break 
 default: 
 res.writeHead(404); 
 res.end(JSON.stringify({error:"Resource not found"})); 
 } 
}

Semblable à ce que nous avons fait précédemment, nous définissons un code de réponse sur 200, pour indiquer un appel réussi, et nous renvoyons le Json dans ce cas. Le cas par défaut peut être utilisé pour signifier une erreur pour le même. Ici, 404, qui signifie ressource non trouvée, a plus de sens.

Si nous testons cela par rapport à l’appel d’URL curl, nous pouvons voir différents retours pour les appels :

Nous pouvons voir que depuis que nous avons ajouté une valeur par défaut, elle est appelée dans le cas où aucun chemin n’est donné, cela vérifie les 3 cas d’itinéraires que nous avons mentionnés.

Conclusion

Le framework Node.js peut être utilisé de manière très extensible et flexible pour développer des serveurs Web à l’aide du module « http » intégré. Nous avons vu ci-dessus comment l’application peut être amenée à écouter sur un port particulier et à envoyer une réponse au client chaque fois qu’une requête est faite à l’application.

Le principal pouvoir de l’utilisation de Node.js pour créer un serveur Web Node est la flexibilité qu’il offre en termes de type de réponses que ce soit HTML, JSON, XML, CSV ou la possibilité de routage, etc. Nous avons également vu l’évolutivité d’un serveur Web Node. un simple serveur http et ce qu’il peut faire.

En dehors de cela, nous avons également vu comment créer une API capable d’utiliser les informations fournies dans la requête pour déterminer quelles données doivent être envoyées dans le cadre de sa réponse. Grâce à ces informations, nous pouvons créer des serveurs Web évolutifs capables de gérer une variété de demandes et de réponses également sur différents points de terminaison, ce qui est essentiel lors de la création d’API.

Foire aux questions (FAQ)

Comment puis-je créer un serveur HTTP ?

La plupart des langages fournissent un support de base pour exécuter un simple serveur http, basé sur certaines fonctions intégrées, comme dans Node.js, nous utilisons le module http et configurons l’hôte et le port, puis en utilisant la fonction createServer dans le module http, demandons au serveur de écoutez ce port et cet hôte, comme ceci ci-dessous :

const http = require("http"); 
const host = 'localhost'; 
const port = 8000; 
const requestListener = function (req, res) {}; 
const server = http.createServer(requestListener); 
server.listen(port, host, () => { 
 console.log(`Server is running on http://${host}:${port}`); 
});

Qu’est-ce qu’un serveur HTTP ?

Un serveur HTTP est un programme indépendant ou inclus dans tout autre composant, qui joue le rôle de serveur dans le modèle client-serveur en implémentant la partie serveur des protocoles réseau HTTP. Un serveur HTTP attend les requêtes client entrantes qui sont envoyées par des agents utilisateurs tels que les navigateurs, les robots d’exploration Web, etc., et à chaque requête, il répond en répondant avec les informations demandées, y compris l’envoi de la ressource Web demandée, des textes, des médias ou avec un Message d’erreur HTTP.

Comment démarrer un serveur Node.js ?

Prenons l’exemple où nous avons créé un serveur écoutant localhost sur le port 5000, le processus pour l’exécuter sera :

Dans le terminal, exécutez node <filename.js> puis accédez à http://localhost:5000 ou vous pouvez également utiliser curl http://localhost:5000 pour vérifier la réponse.

Node.js est-il asynchrone ?

Oui, Node.js est un environnement d’exécution JavaScript asynchrone basé sur des événements, conçu pour créer des applications réseau évolutives. Ici, asynchrone fait référence à toutes les fonctions JavaScript qui sont traitées en arrière-plan sans bloquer aucune autre requête.

Créer un corps de requête HTTP à l’aide de Node.js en étapes simples

📝 Ce post a été traduit à partir de l’article Create HTTP Request Body Using Node.js in Simple Steps.

Faire des requêtes HTTP est l’une des tâches quotidiennes effectuées à l’aide de Node.js. Vous obtiendrez un ensemble massif de bibliothèques composées de modules à des fins diverses. L’un des modules couramment utilisés de Node.js est le module HTTP/HTTPS. La plupart des développeurs recherchent ce module lors de la migration vers le nouvel environnement, car les requêtes HTTP/HTTPS constituent la fonctionnalité de base pour que toute application fonctionne correctement.

Si vous ne souhaitez pas utiliser le module HTTP/HTTPS, vous pouvez utiliser l’un des packages npm disponibles pour résoudre votre objectif de création d’une requête HTTP. Dans cet article, nous mettrons en évidence les étapes simples pour effectuer une requête HTTP à l’aide du module HTTP sur le serveur web Node. Ce module est un module intégré avec l’installation de Node.js et les packages npm, tels que Axios, Got SuperAgent et node-fetch.

Conditions préalables

Vous ne pouvez pas simplement commencer à travailler avec Node.js avec une configuration d’environnement de travail appropriée. Vous devez remplir certaines conditions préalables avant de vous lancer dans la partie codage. Voyons donc quelles conditions vous devez maintenir pour commencer à coder avec Node.js.

• Tout d’abord, avant de commencer à coder, vérifiez si la dernière version de Node.js est installée sur votre système. Si vous n’en avez pas, installez la version la plus récente. De plus, dans cet article, nous utiliserons des exemples exécutés dans Node.js version 14.x, le LTS actif.
• De plus, vous devez savoir comment exécuter des commandes npm dans node.js, telles que npm init. Assurez-vous d’installer les packages requis au préalable pour éviter les inconvénients lors de l’exécution du code réel.
• Vous devez savoir comment exécuter des fichiers JavaScript avec les commandes appropriées.
• Vous devez avoir une compréhension de base de Node.js, car vous devez gérer des éléments techniques ici.

Obtenir une requête HTTP(S)

Le module HTTP est le module par défaut de la bibliothèque standard de Node.js. Vous pouvez utiliser ce module et commencer à coder sans installer ni gérer les dépendances externes. Mais, en l’utilisant, vous serez confronté à certains défis car ce n’est pas un module convivial par rapport aux autres.

Nous avons utilisé quelques exemples de GitHub, le référentiel open source de tous les codes, pour votre meilleure compréhension. Ici, nous effectuons une requête GET à l’aide de l’option client HTTP en appelant les données stockées à partir de l’API fictive JSONPlaceholder. en réponse à la demande complétée, il enverra les données des dix utilisateurs ainsi que leurs noms et identifiants. dans cet article, nous avons mentionné différents types d’exemples montrant les appels basés sur les rappels, les promesses et les asynchrones/attentes.

Cinq méthodes différentes sont présentées pour effectuer l’appel HTTP GET vers l’API d’espace réservé. Node.js propose un module HTTP intégré pour effectuer plusieurs tâches liées à HTTP afin de faciliter votre travail.

Avant de poursuivre la discussion, vous devez considérer les points suivants concernant le module HTTP/HTTPS :

• Tout d’abord, les modules HTTP et HTTPS fournissent des fonctionnalités de bas niveau. Une fois la demande faite, vous obtiendrez la réponse requise par morceaux plutôt que d’obtenir tous les résultats. De plus, vous devez analyser manuellement la réponse reçue. Cela peut sembler simple pour le format JSON, mais vous devez néanmoins déployer des efforts supplémentaires pour analyser la réponse complète.
• Deuxièmement, votre module HTTP ne prendra pas en charge les requêtes HTTPS par défaut. Vous devez donc utiliser le module HTTPS si les requêtes HTTPS sont effectuées lors de la communication.

Malgré les défis ci-dessus, le module HTTP/HTTPS est utile car vous serez sauvé en éliminant la fiabilité de plusieurs dépendances.

Module de demande

Le module de requête est une option plus conviviale que le module HTTP pour effectuer des appels HTTPS. Même les gens de la communauté y réfléchissent. Mais contrairement au module HTTP, vous devez installer le module de requête en tant que package npm.

Appuyez sur la commande suivante depuis le terminal pour installer le module de requête à l’aide de npm :

npm install request

Mais ce module est obsolète après 2020 car aucune modification n’y a été apportée : pour plus de détails, consultez le site package request. Mais pour comprendre les rouages du module HTTP en node.js, il sera suffisant…

Après avoir installé le module de requête, exécutez la commande suivante pour vérifier la version :

npm version request

Ce module prend en charge les appels et les redirections HTTPS par défaut. Dans l’exemple ci-dessous, le code réside dans le corps de la requête du code.

Par exemple :

const request = require('request');  
//python requests body
request('https://raw.githubusercontent.com/webapps-conception/nodejs-requests/refs/heads/master/JSONPlaceholder/users', { json: true }, (err, res, body) => { if (err) {  
return console.log(err); }  
console.log(body.url);  
console.log(body.explanation);  
});

Poster le corps de la demande avec curl.

Si vous souhaitez publier les données dans le corps du message de demande à l’aide de curl, vous devez transmettre les données requises à Curl. En utilisant le commutateur de ligne de commande -d ou –data, vous pouvez le faire. À l’aide de l’en-tête Content-Type, vous pouvez spécifier le type de données du message que vous souhaitez inclure. Le serveur HTTP Node utilise cet en-tête pour interpréter et traiter les données dans le corps du message POST.

Par exemple, pour envoyer le JSON au serveur Web Node.js, vous devez spécifier le type de données dans le corps à l’aide de l’en-tête Content-Type: application/json.

Par exemple :

//curl post body
curl -X POST https://reqbin.com/echo/post/json  
   -H "Content-Type: application/json"
   -d '{"productId": 123456, "quantity": 100}'  
 Output-
{
    "success": "true"
}

HTTPS module

Node.js propose des modules HTTP et HTTPS dans sa bibliothèque standard pour effectuer des appels API HTTP/HTTPS. Pour commencer à transférer les données via HTTPS, vous devez inclure le module HTTPS. Ce module créera en outre le serveur Node HTTPS qui écoutera les ports du serveur pour générer la réponse à leurs clients.

const https = require(‘https’);

Eh bien, on sait que les requêtes HTTPS sont sécurisées. Il serait donc utile de créer également des certificats SSL (auto-signés), garantissant une communication sécurisée. Ici, nous sautons cette partie.

Ici, nous utilisons l’exemple fondamental montrant l’utilisation du module HTTPS pour effectuer l’appel GET.

Par exemple :

const https = require('https');
https.get('https://raw.githubusercontent.com/webapps-conception/nodejs-requests/refs/heads/master/JSONPlaceholder/users', res => {
let data = [];
  const headerDate = res.headers && res.headers.date ? res.headers.date : 'no response date';
  console.log('Status Code:', res.statusCode);
  console.log('Date in Response header:', headerDate);
 res.on('data', chunk => {
    data.push(chunk);
  });
 res.on('end', () => {
    console.log('Response ended: ');
    const users = JSON.parse(Buffer.concat(data).toString());
  for(user of users) {
      console.log(`Got user with id: ${user.id}, name: ${user.name}`);
    }
  });
}).on('error', err => {
  console.log('Error: ', err.message);
});

Résultat :

-> nodejs-requests git:(master) node native-https.js
Status Code: 200
Date in Response header: Sun, 10 Jan 2021 22:47:23 GMT
Response ended:
Got user with id: 1, name: Leanne Graham
Got user with id: 2, name: Ervin Howell
Got user with id: 3, name: Clementine Bauch
Got user with id: 4, name: Patricia Lebsack
Got user with id: 5, name: Chelsey Dietrich
Got user with id: 6, name: Mrs. Dennis Schulist
Got user with id: 7, name: Kurtis Weissnat
Got user with id: 8, name: Nicholas Runolfsdottir V
Got user with id: 9, name: Glenna Reichert
Got user with id: 10, name: Clementina DuBuque
-> nodejs-requests git:(master)

Nous verrons étape par étape ce qui se passe dans le code ci-dessus. Dans un premier temps, nous avons importé le module HTTPS en utilisant la fonction requise. Vous obtiendrez ce module avec l’installation de Node.js, il n’est donc pas nécessaire de créer un fichier json ou d’installer quoi que ce soit pour exécuter ce code.

Ensuite, nous avons appelé l’URL JSONPlaceholder à l’aide de la méthode get. La méthode GET a un rappel qui répondra à la variable res.

Ensuite, nous initialisons les données sous forme de tableau vide, puis utilisons le journal pour afficher le code d’état et la date de l’en-tête de la réponse. Après avoir reçu la réponse, les données seront stockées dans le tableau de données.

Ensuite, nous avons utilisé la fonction concat pour concaténer les données du tableau et les changer en chaîne. Ensuite, nous avons analysé le JSON pour obtenir le nom d’utilisateur et l’ID des 10 utilisateurs.

Axios Module

Axios est une autre bibliothèque Node.Js JavaScript populaire basée sur des promesses. Vous pouvez utiliser ce module sur tous les navigateurs modernes et son formidable support pour IE8 et supérieur. Il est également utilisé pour effectuer des requêtes HTTP qui peuvent fonctionner de manière transparente sur les plates-formes Browser et Node.js.

L’utilisation d’Axios peut être plus avantageuse par rapport à l’API Fetch native :

• Il prend en charge les anciens navigateurs.
• Il peut rapidement abandonner une demande.
• Il peut définir un délai de réponse.
• Il est livré avec une protection CSRF intégrée.
• Il prend également en charge la progression du téléchargement.
• Il effectue une transformation automatique des données JSON.

Pour utiliser le module Axios dans votre code, vous devez l’installer à l’aide de la commande suivante depuis le terminal.

npm install --save axios

Dans l’exemple mentionné ci-dessous, nous appelons l’API JSON des utilisateurs utilisant Axios.

const axios = require('axios');
//Axios get body
axios.get('https://raw.githubusercontent.com/webapps-conception/nodejs-requests/refs/heads/master/JSONPlaceholder/users')
.then(res => {
    const headerDate = res.headers && res.headers.date ? res.headers.date : 'no response date';
    console.log('Status Code:', res.status);
    console.log('Date in Response header:', headerDate);
 const users = res.data;
for(user of users) {
      console.log(`Got user with id: ${user.id}, name: ${user.name}`);
    }
  })
  .catch(err => {
    console.log('Error: ', err.message);
  });

En raison de sa nature basée sur des promesses, il nécessitera un code moins évident. En outre, vous pouvez transformer ce code au format async/wait chaque fois que nécessaire. Pour utiliser le corps axios, vous devez l’importer à l’aide de la fonction requise. Ensuite, nous avons utilisé axios.get (méthode basée sur la promesse) pour appeler l’API des utilisateurs JSONPlaceholder.

Ensuite, à l’aide de la méthode « then », nous avons reçu les données demandées et avons utilisé la variable res pour obtenir l’objet de réponse. Ensuite, à l’aide de la fonction de journalisation, nous avons affiché le code d’état et la date de l’en-tête de réponse.

Les données JSON seront reçues sous forme de tableau avec res. données en raison de la fonctionnalité de transformations automatiques. De plus, nous effectuons la boucle à travers les utilisateurs pour obtenir leur identifiant et leur nom.

L’exemple ci-dessus concerne Axios get. Maintenant, nous allons voir l’exemple de la publication Axios. Avec Axios, vous pouvez effectuer des demandes de publication en utilisant les données « post » sur un point de terminaison donné qui déclencheront les événements souhaités. Pour effectuer une requête HTTP POST dans Axios, vous devez appeler la fonction axios.post(). Lorsque vous effectuez une requête POST, vous devez utiliser deux paramètres : l’URI du point de terminaison du service et un objet contenant les propriétés que vous souhaitez envoyer au serveur HTTP Node.

Par exemple :

// Axios post body–POST request
axios({
  method: 'post',
  url: '/login',
  data: {
    firstName: 'Finn',
    lastName: 'Williams'
  }
});

Got Module

Node.js propose une autre bibliothèque de requêtes HTTP saine et couramment utilisée, Got. Il a été introduit comme une alternative légère au module Request mentionné ci-dessus (maintenant obsolète). Par défaut, Got n’analysera pas le JSON. C’est pourquoi nous avons ajouté le {json : true} comme argument dans le code ci-dessous pour inclure l’analyse JSON.

Comme Axios, Got est également une API basée sur des promesses, ce qui la rend plus populaire parmi les développeurs Node.js.

Pour utiliser le module Got, vous devez l’importer en utilisant la fonction requise ci-dessous.

npm install --save got
In the below example, we have used the Got module to get the users from the mock API.
const got = require('got');
got.get('https://raw.githubusercontent.com/webapps-conception/nodejs-requests/refs/heads/master/JSONPlaceholder/users', {responseType: 'json'})
  .then(res => {
    const headerDate = res.headers && res.headers.date ? res.headers.date : 'no response date';
    console.log('Status Code:', res.statusCode);
    console.log('Date in Response header:', headerDate);
   const users = res.body;
    for(user of users) {
      console.log(`Got user with id: ${user.id}, name: ${user.name}`);
    }
  })
  .catch(err => {
    console.log('Error: ', err.message);
  });

Si vous regardez attentivement un exemple, vous verrez que le code ci-dessus est en quelque sorte similaire au code Axios mais avec les différences mentionnées ci-dessous.

• Pour spécifier la réponse au format JSON, vous devez transmettre explicitement un deuxième paramètre : {responseType : ‘json’}.
• En outre, il existe une différence dans l’en-tête du code d’état, qui est mentionné comme statut.

SuperAgent Module

SuperAgent est l’un des modules les plus anciens et les plus populaires de Node.js introduit par VisionMedia en 2011. SuperAgent est bien connu comme une bibliothèque de requêtes HTTP progressive côté client. Vous pouvez utiliser ce module pour prendre en charge les fonctionnalités client HTTP de haut niveau. Vous pouvez l’utiliser à la fois pour les API de rappel et celles basées sur des promesses. Ce module est riche en plugins qui peuvent aider à des tâches telles que le no-cache, les timings HTTP, etc.

À l’aide du module SuperAgent, vous devez l’importer à l’aide de la commande suivante :

npm install --save superagent

Dans l’exemple suivant, nous utiliserons async/await pour effectuer l’appel API :

const superagent = require('superagent');
(async () => {
  try {
    const res = await superagent.get('https://raw.githubusercontent.com/webapps-conception/nodejs-requests/refs/heads/master/JSONPlaceholder/users');
    const headerDate = res.headers && res.headers.date ? res.headers.date : 'no response date';
    console.log('Status Code:', res.statusCode);
    console.log('Date in Response header:', headerDate);
 const users = res.body;
    for(user of users) {
      console.log(`Got user with id: ${user.id}, name: ${user.name}`);
    }
  } catch (err) {
    console.log(err.message); //can be console.error
  }
})();

Voyons ce qui se passe dans l’exemple ci-dessus.

Tout d’abord, nous avons utilisé la bibliothèque superagent en utilisant la fonction requise. Ensuite, nous avons utilisé l’IIFE avec async tout en utilisant l’attente.

Ensuite, nous avons ajouté le bloc try et appelé le superagent. get avec wait, dont le but est de résoudre la promesse et de générer la réponse des appels HTTP. Ensuite, en utilisant la variable res, nous avons obtenu la date de res.headers. Grâce à la fonction de journal, nous affichons l’état et la date sur la console.

Ensuite, nous avons utilisé la constante « user » pour stocker la réponse générée et avons parcouru ce tableau de 10 utilisateurs pour obtenir leur nom d’utilisateur et leur identifiant. Ensuite, le bloc catch suivant vérifiera les erreurs survenues et les gérera en affichant le message d’erreur sur la console.

Vous pouvez dire que le module SuperAgent est fiable car il est minutieusement testé à l’aide de SuperTest (bibliothèque Node.js).

Node-fetch

Node-fetch est une autre bibliothèque de requêtes HTTP pour Node.js. En raison de la récupération de nœud, vous n’avez pas besoin d’implémenter XMLHttpRequest dans Node.js pour exécuter Fetch polyfill spécifique au navigateur. Vous pouvez considérer node.fetch comme un code minimal pour l’API compatible window.fetch sur le runtime Node.js.

Pour utiliser le node.fetch dans votre code, vous devez l’importer à l’aide du code suivant :

npm install node-fetch
We will call our mock users API using the node in the code below.fetch module.
const fetch = require('node-fetch');
(async () => {
  try {
    const res = await fetch('https://raw.githubusercontent.com/webapps-conception/nodejs-requests/refs/heads/master/JSONPlaceholder/users');
    const headerDate = res.headers && res.headers.get('date') ? res.headers.get('date') : 'no response date';
    console.log('Status Code:', res.status);
    console.log('Date in Response header:', headerDate);
 const users = await res.json();
    for(user of users) {
      console.log(`Got user with id: ${user.id}, name: ${user.name}`);
    }
  } catch (err) {
    console.log(err.message); //can be console.error
  }
})();

Voyons en quoi le code ci-dessus est différent du code avec SuperAgent utilisant wait/async.

• Avec fetch, vous n’aurez pas besoin d’une méthode GET explicite et vous pourrez ajouter la clé de méthode dans le deuxième paramètre pour envoyer le verbe HTTP.
• Nous avons également utilisé la méthode get pour obtenir les valeurs d’en-tête. Nous avons appelé res.headers.get(‘date’) pour récupérer la valeur de l’en-tête de réponse date.
• Nous avons utilisé wait res.json() pour déballer une promesse d’obtenir le corps au format JSON.

HTTP Delete Request

Vous pouvez utiliser le corps de suppression HTTP pour supprimer les ressources spécifiques. Vous trouverez ci-dessous l’exemple de nodejs de corps de requête de suppression http qui supprimera les appels d’API de requête. Voyons le processus complet.

• Créer une application Node.js :

  mkdir my-request-app
  cd my-request-app
  npm init
  

• Installez Axios :

  npm install axios --save
  server.js
  const axios = require('axios');
   axios.delete('https://reqres.in/api/users/2')
   .then((res) => {
       console.log(`Status: ${res.status}`);
   }).catch((err) => {
       console.error(err);
   });
  

• Exécuter l’application :

  node server.js
  

• Résultat : Statut : 201

Conclusion

Nous avons utilisé des exemples de base pour expliquer le concept. Mais ce n’est pas tout, car sa portée est vaste et ne s’arrête pas là. Avec cet article, vous comprendrez comment effectuer la requête HTTP différemment. Node.js dispose d’une bibliothèque complète avec différentes fonctions et modules pour rendre chacune de vos étapes et processus plus accessibles.

Donc, si vous avez parcouru cet article, vous devez comprendre à quel point chaque méthode est légèrement différente des autres. Il n’est donc peut-être pas difficile de s’entendre, même pour les débutants.

Foire aux questions (FAQ)

Qu’est-ce qu’un corps de requête dans Node.js ?

Le corps de la requête stocke les informations supplémentaires que vous souhaitez envoyer au serveur. Le corps est essentiel car il précise le contenu que l’on souhaite transmettre. Vous pouvez utiliser le corps de la demande pour stocker des informations utiles, telles que le nom d’utilisateur et le mot de passe d’une personne essayant de se connecter à notre système.

Comment fonctionnent les requêtes HTTP dans Node.js ?

Tout d’abord, le client établit la connexion via une requête GET. En retour, le serveur répond avec un code d’état. Si le code d’état est 200, le serveur est prêt pour une connexion, appelée réponse HTTP.

Ensuite, le client envoie la requête (POST) composée des informations de connexion. Le serveur traite les informations après les avoir vérifiées par rapport à la base de données. Si le serveur correspond à celui trouvé, il l’autorisera et renverra la réponse au client.

Comment puis-je faire une requête HTTP ?

• GET
• POST
• HEAD
• PUT
• DELETE
• CONNECT
• OPTIONS
• TRACE

Quelles sont les cinq façons de créer un corps de requête dans Node.js ?

• AXIOS
• Node.fetch
• SuperAgent
• GOT

Autres projets intéressants

• Compilez un seul exécutable à partir de votre application Node avec Node.js 20 et ESBuild : webapps-conception/nodejs-server-compilation.

• Pour envoyer un mail avec Node.js : webapps-conception/nodemailer.

• tRPC garantit la sécurisation du typage de données dans le contexte d’une stack entièrement écrite en Typescript. Avec tRPC, le code source du client importe directement des éléments provenant du code source du serveur pour déterminer les nommages et le typage des procédures en question. Voici un exemple d’utilisation client-serveur : webapps-conception/tRPC-example.

• Test d’accès à des données sur la plateforme Redis : upstash-redis-node.

• graphql-node-server-basic @apollo/server.