Client HTTP en JavaScript : techniques avancées de requêtes dans Node.js

Client HTTP en JavaScript : effectuer des requêtes correctement — niveau avancé

Les requêtes HTTP de base avec fetch ou axios ne sont que la partie émergée de l'iceberg. Dans les applications de production réelles sous Node.js, on rencontre des dizaines de nuances : pools de connexions, tentatives répétées en cas d'échec, intercepteurs pour la journalisation, streaming de grandes données et réglage fin des timeouts. Dans cet article, nous allons explorer les techniques avancées de travail avec les clients HTTP en JavaScript. Vous apprendrez à gérer le keep-alive, à implémenter un mécanisme de retry fiable, à utiliser des intercepteurs et à créer des agents personnalisés. Ce contenu s'adresse aux développeurs qui connaissent déjà les bases de HTTP et souhaitent écrire un code plus efficace et résilient.

1. Gestion des connexions : Keep-Alive et agents personnalisés

Par défaut, Node.js utilise un pool global d'agents HTTP. Cependant, pour les systèmes à forte charge, il est important de contrôler le nombre de connexions simultanées et leur réutilisation. Examinons la configuration du keep-alive à l'aide du module http et de la bibliothèque undici.

Exemple avec un agent personnalisé (Node.js intégré) :

const http = require('http');const https = require('https');

// Création d'un agent personnalisé avec un pool de connexionsconst agent = new http.Agent({  keepAlive: true,  maxSockets: 50,        // Maximum 50 sockets simultanés  maxFreeSockets: 10,    // Pas plus de 10 sockets libres dans le pool  timeout: 60000,        // Timeout d'inactivité du socket (ms)});

const options = {  hostname: 'api.example.com',  port: 80,  path: '/data',  agent: agent,};

const req = http.get(options, (res) => {  let data = '';  res.on('data', (chunk) => { data += chunk; });  res.on('end', () => console.log('Réponse reçue :', data));});

req.on('error', (e) => console.error('Erreur :', e.message));

Approche moderne avec undici (plus rapide et plus légère) :

const { Client, Pool } = require('undici');

// Création d'un pool avec keep-aliveconst client = new Pool('https://api.example.com', {  connections: 100,  pipelining: 10,  keepAliveTimeout: 30000,});

// Exécution de la requêteclient.request({  method: 'GET',  path: '/data',}).then(({ statusCode, body }) => {  console.log('Statut :', statusCode);  body.setEncoding('utf8');  body.on('data', console.log);}).catch(err => console.error(err));

L'utilisation d'agents personnalisés permet d'éviter les problèmes de fuites de sockets et améliore les performances grâce à la réutilisation des connexions.

2. Mécanisme fiable de tentatives répétées (Retry)

Les réseaux sont instables. Même des pannes temporaires peuvent entraîner une perte de données. Une stratégie de retry correcte doit prendre en compte le type d'erreur, le nombre de tentatives et un délai exponentiel. Implémentons un décorateur de retry universel pour tout client HTTP.

const axios = require('axios');const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));

async function withRetry(requestFn, retries = 3, baseDelay = 1000) {  for (let attempt = 1; attempt <= retries; attempt++) {    try {      return await requestFn();    } catch (error) {      // Ne pas répéter pour les erreurs client (4xx)      if (error.response && error.response.status >= 400 && error.response.status < 500) {        throw error;      }      if (attempt === retries) {        throw error; // Toutes les tentatives épuisées      }      const delay = baseDelay * Math.pow(2, attempt - 1) + Math.random() * 1000;      console.log(`Tentative ${attempt} échouée. Attente de ${delay}ms...`);      await sleep(delay);    }  }}

// Utilisationasync function fetchData() {  const response = await withRetry(() => axios.get('https://api.example.com/data'), 5, 500);  return response.data;}

fetchData().then(console.log).catch(console.error);

Points clés : exclusion des erreurs 4xx-