5 méthodes de requête HTTP Node.js que tout développeur devrait maîtriser

Node.js a révolutionné le développement backend grâce à son modèle d'E/S non bloquant et piloté par les événements. La capacité à effectuer des requêtes HTTP de manière efficace et fiable est essentielle pour créer des applications web, des API et des microservices robustes. Qu'il s'agisse de récupérer des données à partir d'API externes, d'assurer la communication entre les services ou d'intégrer des plateformes tierces, la maîtrise des méthodes de requêtes HTTP dans Node.js est essentielle.

Bien qu'il existe de nombreuses bibliothèques destinées à simplifier les communications HTTP, la maîtrise des outils de base et de leurs avantages et inconvénients permet aux développeurs de choisir la méthode la mieux adaptée à chaque situation. Cet article passe en revue cinq méthodes de requête HTTP puissantes dans Node.js : la méthode native http/https modules, axios, node-fetch, got, et onze. Chacune présente des avantages propres en termes de performances, d'expérience de développement et d'ensemble de fonctionnalités.

1. Les modules HTTP et HTTPS natifs : Core Foundation

Au cœur de Node.js se trouve le moteur intégré http et https modules. Ceux-ci offrent un accès de bas niveau aux fonctionnalités du client HTTP sans dépendances externes. Bien que plus lourds, ils offrent un contrôle inégalé et sont parfaits pour les applications où les performances sont cruciales ou les environnements minimalistes.

Principaux avantages

• Aucune dépendance externe
• Contrôle total des en-têtes, des délais d'expiration et de la diffusion en continu
• Intégration native avec les flux Node.js
• Empreinte mémoire minimale

Effectuer une requête GET

javascript
const https = require('https');

const options = {
  hostname: 'api.github.com',
  path: '/repos/nodejs/node',
  headers: {
    'User-Agent': 'node-js-app'
  }
};

https.get(options, (res) => {
  let data = '';

  res.on('data', (chunk) => {
    data += chunk;
  });

  res.on('end', () => {
    const repo = JSON.parse(data);
    console.log(`Le dépôt Node.js compte ${repo.stargazers_count} étoiles`);
  });
}).on('error', (err) => {
  console.error('Échec de la requête :', err.message);
});

Requête POST avec une charge utile JSON

javascript
const https = require('https');

const postData = JSON.stringify({
  title: 'Nouvel article',
  body: 'Voici le contenu',
  userId: 1
});

const options = {
  hostname: 'jsonplaceholder.typicode.com',
  path: '/posts',
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Content-Length': Buffer.byteLength(postData)
  }
};

const req = https.request(options, (res) => {
  let response = '';

  res.on('data', (chunk) => {
    response += chunk;
  });

  res.on('end', () => {
    console.log('Réponse :', JSON.parse(response));
  });
});

req.on('error', (err) => {
  console.error('Erreur :', err.message);
});

req.write(postData);
req.end();

Les modules natifs sont particulièrement efficaces dans les scénarios de streaming. Pour les téléchargements ou les envois de fichiers volumineux, vous pouvez acheminer les flux directement :

javascript
const fs = require('fs');
const https = require('https');

const fileStream = fs.createReadStream('large-file.zip');
const req = https.request({
  hostname: 'example.com',
  path: '/upload',
  method: 'POST',
  headers: {
    'Content-Type': 'application/octet-stream'
  }
});

fileStream.pipe(req);

Bien que puissants, les modules natifs nécessitent une gestion manuelle des cas particuliers, tels que les redirections, les délais d'expiration et l'analyse JSON. Cela les rend moins adaptés au prototypage rapide, mais parfaits lorsque chaque octet et chaque milliseconde comptent.

2. Axios : une véritable force de frappe grâce à ses promesses

Axios est devenu la référence incontournable pour les requêtes HTTP dans Node.js et les environnements de navigateur. Son API basée sur les promesses, son analyse automatique du format JSON et ses nombreuses fonctionnalités en font un outil extrêmement convivial pour les développeurs.

Pourquoi les développeurs adorent Axios

• Transformation automatique des requêtes et réponses JSON
• Protection XSRF intégrée
• Intercepteurs de requêtes et de réponses
• Configuration du délai d'expiration
• Demandes annulables via CancelToken

Installation et utilisation de base

bash

npm install axios

javascript
const axios = require('axios');

// Requête GET
axios.get('https://api.github.com/repos/nodejs/node')
  .then(response => {
    console.log(`Étoiles : ${response.data.stargazers_count}`);
  })
  .catch(error => {
    console.error('Erreur :', error.message);
  });

// POST avec configuration
axios.post(
'https://jsonplaceholder.typicode.com/posts',
  {
    title: 'New Post',
    body: 'Content here',
    userId: 1
  },
  {
    headers: {
 'Authorization': 'Bearer token123',
 'Custom-Header': 'value'
    },
    timeout: 5000
  }
).then(res => {
  console.log('Créé :', res.data);
});

Fonctionnalités avancées : Intercepteurs

Les intercepteurs permettent de modifier les requêtes ou les réponses de manière globale :

javascript
// Intercepteur de requête
axios.interceptors.request.use(config => {
  config.headers['X-Request-ID'] = generateId();
  config.metadata = { startTime: new Date() };
  return config;
});

// Intercepteur de réponse
axios.interceptors.response.use(
  response => {
    const endTime = new Date();
    const duration = endTime - response.config.metadata.startTime;
    console.log(`La requête a pris ${duration} ms`);
    return response;
  },
  error => {
    console.error('Erreur API :', error.response?.status);
    return Promise.reject(error);
  }
);

Annulation des demandes

javascript
const CancelToken = axios.CancelToken;
const source = CancelToken.source();

axios.get('/data', {
  cancelToken: source.token
}).catch(thrown => {
  if (axios.isCancel(thrown)) {
    console.log('Requête annulée');
  }
});

// Annuler la requête
source.cancel('Opération annulée par l'utilisateur');

Axios excelle dans le domaine des applications d'entreprise, où la gestion cohérente des erreurs, la journalisation et la modification des requêtes sont essentielles. Sa compatibilité avec les navigateurs en fait également un outil idéal pour les applications isomorphiques.

3. node-fetch : intégrer l'API Fetch à Node.js

L'API Fetch, intégrée aux navigateurs modernes, offre une interface épurée, basée sur les promesses, pour les requêtes HTTP. node-fetch intègre cette API familière à Node.js, ce qui en fait un outil idéal pour les développeurs qui passent du front-end au back-end.

Principales caractéristiques

• Une API familière, similaire à celle d'un navigateur
• Léger (~4 Ko)
• Prise en charge des flux
• Conformité à la spécification Fetch du WHATWG

Installation

bash
npm install node-fetch

Utilisation de base (CommonJS)

javascript
const fetch = require('node-fetch');

// Requête GET
fetch('https://api.github.com/repos/nodejs/node')
  .then(res => res.json())
  .then(data => {
    console.log(`Étoiles : ${data.stargazers_count}`);
  })
  .catch(err => {
    console.error('Échec de la requête :', err);
  });

// POST avec JSON
fetch('https://jsonplaceholder.typicode.com/posts', {
  method: 'POST',
  body: JSON.stringify({
    title: 'fetch post',
    body: 'using node-fetch',
    userId: 1
  }),
  headers: {
    'Content-Type': 'application/json'
  }
})
.then(res => res.json())
.then(data => console.log(data));

Réponses en continu

javascript
fetch('https://example.com/large-file.zip')
  .then(res => {
    const dest = fs.createWriteStream('downloaded.zip');
    res.body.pipe(dest);
  });

AbortController pour l'annulation

javascript
const controller = new AbortController();
const timeout = setTimeout(() => controller.abort(), 5000);

fetch('https://slow-api.com/data', {
  signal: controller.signal
})
.then(res => res.json())
.catch(err => {
  if (err.name === 'AbortError') {
    console.log('Délai d'attente de la requête expiré');
  }
});

node-fetch est idéale pour les développeurs qui préfèrent la syntaxe moderne de l'API Fetch et souhaitent un niveau d'abstraction minimal. La version 3+ prend en charge ESM en natif, ce qui la rend évolutive pour les applications Node.js modernes.

4. Got : le client HTTP convivial

Got est une bibliothèque de requêtes HTTP riche en fonctionnalités et conviviale, spécialement conçue pour Node.js. Elle étend l'API Fetch native en proposant des paramètres par défaut judicieux et des extensions puissantes.

Caractéristiques phares

• Messages d'erreur compréhensibles par l'utilisateur
• Nouvelle tentative automatique avec délai d'attente exponentiel
• Demander la pagination
• Prise en charge du cache
• Rapport d'avancement
• Rappels pour le cycle de vie des requêtes

Installation

bash
npm install got

Utilisation de base

javascript
const got = require('got');

// GET simple
got('https://api.github.com/repos/nodejs/node').json()
  .then(data => {
    console.log(`Étoiles : ${data.stargazers_count}`);
  });

// POST avec nouvelle tentative
got.post('https://jsonplaceholder.typicode.com/posts', {
  json: {
    title: 'got request',
    body: 'content',
    userId: 1
  },
  retry: {
    limit: 3,
    methods: ['POST'],
    statusCodes: [413, 429]
  }
}).json().then(console.log);

Le streaming avec Progress

javascript
const stream = got.stream('https://example.com/large-file.zip');

stream.on('downloadProgress', progress => {
  console.log(`Téléchargement de ${progress.transferred} octets`);
});

const writeStream = fs.createWriteStream('file.zip');
stream.pipe(writeStream);

Points d'accrochage pour la personnalisation

javascript
const client = got.extend({
  hooks: {
    beforeRequest: [
 options => {
 options.headers['x-request-id'] = generateId();
      }
    ],
    afterResponse: [
 response => {
 response.requestDuration = Date.now() - response.requestStart;
 return response;
 }
    ]
  }
});

Got s'impose dans les environnements de production où la fiabilité, l'observabilité et l'expérience des développeurs sont primordiales. Ses paramètres par défaut bien pensés permettent de réduire les codes répétitifs tout en conservant une grande flexibilité.

5. Undici : un concurrent de haut niveau

Undici (qui signifie “ onze ” en italien) est un client HTTP/1.1 moderne développé pour Node.js par l'équipe principale de Node.js. Il met l'accent sur les performances, la fiabilité et le respect des normes.

Avantages en termes de performances

• Écrit en JavaScript, avec les parties critiques pour les performances en C++
• Pool de connexions
• Pipelining HTTP/1.1
• Flux en duplex intégral
• Aucun surcoût par rapport aux modules natifs

Installation

bash
npm install undici

Utilisation de base

javascript
const { request } = require('undici');

async function makeRequest() {
  const { statusCode, body } = await request('https://api.github.com/repos/nodejs/node');

  console.log('Statut :', statusCode);

  for await (const data of body) {
    console.log('Bloc de données :', data.toString());
  }
}

makeRequest();

Utilisation du client avec la mise en pool des connexions

javascript
const { Client } = require('undici');

const client = new Client('https://api.github.com');

async function concurrentRequests() {
  const promises = Array(10).fill().map(() =>
    client.request({
 path: '/repos/nodejs/node',
 method: 'GET'
    }).then(({ body }) => body.json())
  );

  const results = await Promise.all(promises);
  console.log('Requêtes simultanées terminées');
}

concurrentRequests();

Mise en ligne en continu

javascript
const { pipeline } = require('stream');
const fs = require('fs');

const client = new Client('https://httpbin.org');

pipeline(
  fs.createReadStream('data.json'),
  client.stream({
    path: '/post',
    method: 'POST',
    headers: { 'content-type': 'application/json' }
  }, ({ statusCode }) => {
    console.log('Statut de la réponse :', statusCode);
  }),
  (err) => {
    if (err) console.error('Échec du pipeline :', err);
  }
);

Undici incarne l'avenir des clients HTTP sous Node.js. Ses performances rivalisent avec celles des modules natifs, tout en offrant une API moderne. Il est particulièrement adapté aux applications à haut débit et aux microservices.

Comparaison et quand utiliser chacune

Indicateurs de performance (requêtes/seconde)

Undici : 18 500
Native : 16 200
Got : 12 800
node-fetch :    11 500
Axios : 9 800

Bonnes pratiques pour toutes les méthodes

1. Toujours gérer les erreurs — Les pannes de réseau sont inévitables
2. Définir les délais d'expiration — Empêcher les demandes de suspension
3. Valider les réponses — Vérifier les codes d'état et le contenu
4. Utiliser la mise en pool des connexions pour plusieurs requêtes adressées au même hôte
5. Mettre en place une logique de nouvelle tentative en cas de pannes passagères
6. Suivre les indicateurs de requêtes en cours de production
7. Respectez les limites de débit des API externes

javascript
// Generic error handling pattern
async function safeRequest(requestFn) {
  try {
    const response = await requestFn();
    if (response.status >= 400) {
      throw new Error(`HTTP ${response.status}`);
    }
    return response.data;
  } catch (error) {
    if (error.code === 'ENOTFOUND') {
      // DNS failure
    } else if (error.code === 'ECONNRESET') {
      // Connection reset
    }
    throw error;
  }
}

Conclusion

La maîtrise des méthodes de requête HTTP dans Node.js est essentielle pour développer des applications robustes. Chaque méthode répond à des besoins différents :

• Utilisation modules natifs lorsque vous avez besoin d'un contrôle total et d'aucune dépendance
• Choisissez Axios pour applications de l'entreprise nécessitant des fonctionnalités avancées et une grande cohérence
• Choisir node-fetch lorsque vous souhaitez utiliser l'API Fetch familière du navigateur
• Sélectionner J'ai pour les systèmes de production exigeant fiabilité et observabilité
• Adopter Onze pour des performances optimales dans les applications Node.js modernes

Les meilleurs développeurs Node.js ne se contentent pas de connaître une seule méthode : ils savent quand et pourquoi utiliser chacune d'entre elles. Commencez par celle qui répond aux besoins immédiats de votre projet, puis élargissez vos compétences au fil du temps. Vous-même (et vos systèmes de production) vous en remercierez plus tard.

À Carmatec, notre équipe expérimentée Développeurs Node.js Gardez une longueur d'avance en maîtrisant les dernières mises à jour de Node.js, notamment les avancées concernant Undici et la prise en charge native des protocoles HTTP/2 et HTTP/3. Recruter des développeurs Node.js avec Carmatec pour créer des applications efficaces, évolutives et prêtes pour l'avenir, qui tirent parti des meilleures pratiques en matière de développement web moderne.