Le module http : bases de la communication HTTP

Introduction au module `http` de Node.js

Le protocole HTTP (HyperText Transfer Protocol) est le fondement de la communication de données sur le World Wide Web. Pour interagir avec ce protocole essentiel, Node.js fournit un module intégré puissant et de bas niveau : le module `http`. Ce module est au coeur de toute application web ou service réseau développé avec Node.js, car il fournit les fonctionnalités nécessaires pour créer des serveurs HTTP et pour effectuer des requêtes HTTP en tant que client.

Comprendre le fonctionnement du module `http` est fondamental, même si vous prévoyez d'utiliser des frameworks de plus haut niveau comme Express.js. Ces frameworks sont construits sur les bases fournies par le module `http`. En saisissant les mécanismes sous-jacents, vous acquerrez une meilleure compréhension de la manière dont les requêtes et les réponses sont traitées, ce qui vous permettra de déboguer plus efficacement et de prendre des décisions architecturales plus éclairées.

Ce module vous donne un contrôle direct sur le cycle de vie des requêtes et des réponses HTTP, vous permettant de gérer les en-têtes, les corps de message, les codes de statut et d'autres aspects essentiels du protocole, le tout en exploitant le modèle asynchrone et événementiel de Node.js.

Le cycle fondamental : requete et reponse

La communication HTTP repose sur un modèle simple de requête/réponse initié par un client (par exemple, un navigateur web) vers un serveur. Le client envoie une requête HTTP demandant une ressource ou une action, et le serveur traite cette requête puis renvoie une réponse HTTP contenant le résultat ou le statut de l'opération.

Le module `http` de Node.js modélise ce cycle de manière très directe. Lorsque vous créez un serveur avec `http.createServer(listener)`, la fonction `listener` est exécutée pour chaque requête entrante. Cette fonction reçoit deux objets cruciaux :

• L'objet `request` (instance de `http.IncomingMessage`) : Représente la requête du client. Il contient toutes les informations envoyées par le client : l'URL demandée, la méthode HTTP (GET, POST, etc.), les en-têtes (headers), et potentiellement un corps de requête (pour POST, PUT). Cet objet est un Readable Stream, ce qui signifie que vous pouvez lire le corps de la requête de manière asynchrone si nécessaire.
• L'objet `response` (instance de `http.ServerResponse`) : Représente la réponse que votre serveur va renvoyer au client. Vous utilisez cet objet pour définir le code de statut (200 OK, 404 Not Found, etc.), les en-têtes de la réponse, et pour écrire le corps de la réponse. Cet objet est un Writable Stream, vous permettant d'envoyer des données au client, potentiellement en plusieurs morceaux.

La gestion de ces deux objets est la tâche principale de votre code serveur lors de l'utilisation directe du module `http`.

Anatomie d'une transaction via le module `http`

Décortiquons les éléments clés d'une transaction HTTP gérée par ce module :

• Méthode et URL (Requête) : Accédées via `request.method` (ex: `'GET'`) et `request.url` (ex: `'/users?id=10'`). Ces informations sont essentielles pour le routage, c'est-à-dire déterminer quelle action effectuer en fonction de la demande.
• En-têtes de la Requête : Disponibles dans l'objet `request.headers`. C'est un objet JavaScript où les clés sont les noms des en-têtes en minuscules (ex: `request.headers['user-agent']`, `request.headers['content-type']`).
• Corps de la Requête : Si la requête a un corps (méthodes POST, PUT, PATCH), il doit être lu à partir du stream `request` en écoutant les événements `data` et `end`. Les données arrivent sous forme de Buffers qu'il faut assembler et potentiellement parser (selon le `Content-Type`).
• Code de Statut (Réponse) : Défini via `response.statusCode = 200` ou directement dans `response.writeHead(200, {...})`. Indique le résultat du traitement au client.
• En-têtes de la Réponse : Définis individuellement avec `response.setHeader('Content-Type', 'application/json')` ou en groupe avec `response.writeHead(statusCode, headers)`. Crucial pour informer le client sur le type de contenu retourné, la mise en cache, les redirections, etc.
• Corps de la Réponse : Ecrit dans le stream `response` via `response.write(data)` (peut être appelée plusieurs fois pour des réponses volumineuses) et obligatoirement terminé par `response.end([data])`. `response.end()` signale la fin de la réponse et envoie les éventuelles données restantes.

Le module `http` gère l'encapsulation de ces éléments dans des messages HTTP valides qui sont envoyés sur le réseau TCP sous-jacent.

Asynchronisme intrinseque

Il est fondamental de se rappeler que toutes les opérations liées au module `http` sont conçues pour être asynchrones. La fonction `listener` de `createServer` est appelée de manière asynchrone à chaque nouvelle connexion/requête. La lecture du corps d'une requête via les événements `data`/`end` est asynchrone. L'écriture de la réponse via `write`/`end` est également asynchrone.

Cette nature non bloquante est la clé de la performance de Node.js. Pendant qu'une opération d'entrée/sortie (lecture du corps de requête, écriture de la réponse) est en cours, la boucle d'événements de Node.js est libre de traiter d'autres requêtes entrantes. Un serveur écrit avec le module `http` peut ainsi gérer un grand nombre de connexions concurrentes de manière très efficace avec une faible empreinte mémoire, comparativement aux modèles bloquants traditionnels où chaque connexion pourrait nécessiter un thread dédié.

Maîtriser la gestion de cet asynchronisme (via callbacks, Promesses, ou async/await couplé aux streams) est donc essentiel lorsqu'on travaille directement avec le module `http`.