AzDev
NodeJSBackend

Aperçu sur le module HTTP de Node.js

Comment utiliser efficacement le module http de NodeJS

Publié le
Aperçu sur le module HTTP de Node.js

1. Introduction

Le module HTTP de Node.js est un outil puissant qui permet de créer des serveurs web et d’interagir avec des services en ligne. Que vous souhaitiez construire une API, un site web simple ou faire des requêtes à des services externes, ce module est la porte d’entrée vers le développement web avec Node.js. Grâce à son architecture non-bloquante, il est idéal pour gérer des requêtes réseau efficacement.

Objectifs de cet article :

  • Comprendre les bases du module HTTP.
  • Créer un serveur web simple.
  • Envoyer et recevoir des données via HTTP.

À la fin, vous serez capable de lancer un serveur qui répond "Hello, World!" et de gérer des requêtes personnalisées.

2. Prérequis

Avant de commencer, assurez-vous de :

  • Avoir Node.js installé (vérifiez avec node -v dans votre terminal).
  • Connaître les bases de JavaScript : fonctions, objets, et idéalement les callbacks et promesses.
  • Savoir utiliser un terminal pour exécuter des fichiers JavaScript (node fichier.js).

3. Concepts fondamentaux du module HTTP

Le module HTTP est intégré à Node.js, donc pas besoin de l’installer. Il permet deux choses principales :

  1. Créer un serveur : pour recevoir et répondre à des requêtes (comme un navigateur qui demande une page).
  2. Faire des requêtes : pour demander des données à d’autres serveurs (comme une API).

Objets clés :

  • http.Server : Le serveur que vous créez pour écouter les requêtes.
  • http.IncomingMessage : Représente une requête entrante (côté serveur) ou une réponse reçue (côté client).
  • http.ClientRequest : Une requête que vous envoyez en tant que client.

Requêtes et réponses :

Une requête (request) contient une méthode (GET, POST), une URL, des en-têtes, et parfois un corps (body).

Une réponse (response) renvoie un code de statut (200 pour OK, 404 pour not found), des en-têtes, et un contenu.

4. Création d’un serveur HTTP de base

Commençons par un exemple simple : un serveur qui renvoie "Hello, World!".

1const http = require('http'); // Importe le module HTTP
2
3const server = http.createServer((req, res) => {
4  res.statusCode = 200; // Code de statut : succès
5  res.setHeader('Content-Type', 'text/plain'); // Type de contenu : texte brut
6  res.end('Hello, World!\n'); // Envoie la réponse et termine
7});
8
9server.listen(3000, 'localhost', () => {
10  console.log('Serveur démarré sur http://localhost:3000/');
11});

Explication :

  • require('http') : Charge le module HTTP.
  • http.createServer : Crée un serveur avec une fonction qui gère chaque requête (req) et réponse (res).
  • res.statusCode : Définit le code HTTP (200 = OK).
  • res.setHeader : Ajoute un en-tête pour indiquer le type de contenu.
  • res.end : Envoie la réponse au client et ferme la connexion.
  • server.listen : Lance le serveur sur le port 3000.

Test :

  1. Sauvegardez dans server.js, exécutez node server.js.
  2. Ouvrez un navigateur à http://localhost:3000 ou utilisez curl http://localhost:3000.

5. Gestion des requêtes et réponses

Ajoutons de la logique pour gérer différentes URL.

1const http = require('http');
2
3const server = http.createServer((req, res) => {
4  res.setHeader('Content-Type', 'text/plain');
5  
6  if (req.url === '/home') {
7    res.statusCode = 200;
8    res.write('Bienvenue sur la page d’accueil !');
9  } else if (req.url === '/about') {
10    res.statusCode = 200;
11    res.write('À propos de nous');
12  } else {
13    res.statusCode = 404;
14    res.write('Page non trouvée');
15  }
16  res.end();
17});
18
19server.listen(3000, () => {
20  console.log('Serveur démarré sur http://localhost:3000/');
21});

Explication :

  • req.url : Contient le chemin demandé (ex. : /home).
  • res.write : Envoie du contenu au client (peut être appelé plusieurs fois).
  • Codes de statut : 200 pour succès, 404 pour "non trouvé".
  • Testez avec http://localhost:3000/home, /about, ou une URL invalide.

6. Envoi de données au serveur (POST)

Les requêtes POST permettent d’envoyer des données au serveur. Voici comment les gérer :

1const http = require('http');
2
3const server = http.createServer((req, res) => {
4  res.setHeader('Content-Type', 'text/plain');
5  
6  if (req.method === 'POST' && req.url === '/data') {
7    let body = '';
8    req.on('data', chunk => {
9      body += chunk.toString(); // Accumule les données reçues
10    });
11    req.on('end', () => {
12      res.statusCode = 200;
13      res.end(`Données reçues : ${body}`);
14    });
15  } else {
16    res.statusCode = 400;
17    res.end('Utilisez POST sur /data');
18  }
19});
20
21server.listen(3000, () => {
22  console.log('Serveur démarré sur http://localhost:3000/');
23});

Explication :

  • req.method : Vérifie si c’est un POST.
  • req.on('data') : Récupère les morceaux de données (stream).
  • req.on('end') : Exécuté quand toutes les données sont reçues.
  • **Testez ** avec curl -X POST -d "message=test" http://localhost:3000/data. (ou avec un client HTTP ex. RestClient extension de VSCode)

7. Utilisation du module HTTP comme client

Faisons une requête à une API externe.

1const http = require('http');
2
3http.get('http://jsonplaceholder.typicode.com/posts/1', (res) => {
4  let data = '';
5  res.on('data', chunk => {
6    data += chunk; // Accumule la réponse
7  });
8  res.on('end', () => {
9    console.log('Réponse reçue :', data);
10  });
11}).on('error', (err) => {
12  console.error('Erreur :', err.message);
13});

Explication :

  • http.get : Envoie une requête GET à l’URL spécifiée.
  • res.on('data') : Récupère les données en morceaux.
  • on('error') : Gère les erreurs (ex. : pas de connexion).
  • Résultat : Affiche les données JSON d’un post fictif.

8. Bonnes pratiques et limites

  • Gestion des erreurs : Ajoutez toujours un on('error') pour les requêtes client et vérifiez les entrées côté serveur.

  • Limites : Le module HTTP est basique. Pour des applications complexes (routing, middleware), utilisez plutôt Express.js.

  • Performance : Utilisez des buffers ou streams pour les gros volumes de données.

9. Exercices pratiques

  • Exercice 1 : Créez un serveur avec 3 routes : /, /users, /contact. Renvoyez un message différent pour chaque.
  • Exercice 2 : Ajoutez une route POST /submit qui renvoie les données envoyées en JSON.
  • Exercice 3 : Faites une requête GET à http://jsonplaceholder.typicode.com/users et affichez le résultat.
  • Exercice 4 : ajouter un fichier index.html à la racine de votre projet :
1<!DOCTYPE html>
2<html lang="en">
3<head>
4     <meta charset="UTF-8">
5     <title>Nodejs</title>
6     <style>/* ... */</style>
7</head>
8<body>
9     <form action="/demo" method="post" enctype="multipart/form-data">
10          <input type="text" name="nom" > <br>
11          <input type="file" name="cv" > <br>
12          <button>Envoyer</button>
13     </form>
14     <div>#placeholder#</div>
15</body>
16</html>
  • Dans un nouveau fichier server2.js, ajouter le code permettant de démarrer un serveur http. Quant l'URL de la requête est "/", utilisez le module fs pour lire le fichier "index.html et l'envoyer dans le corps de la réponse.
  • Si l'URL de la requête correspond à "/demo", récupérez le corps de la réponse, lire le fichier "index.html" et remplacer le contenu "#placeholder#" par le contenu du corps de la réponse et renvoyer ce contenu comme réponse.

10. Conclusion

Vous savez maintenant créer un serveur HTTP, gérer des requêtes et faire des appels à des API avec Node.js ! Pour aller plus loin :

Tags

FileSystem