Node.js mesure le temps passé sur HTTP

Comprendre et mesurer les temps HTTP nous aide à identifier les goulots d'étranglement des performances dans la communication client-serveur ou serveur-serveur. Cet article explique la surcharge temporelle des requêtes HTTP et montre comment la mesurer dans Node.js.

Avant de commencer à comprendre la surcharge de temps HTTP, examinons quelques concepts de base :

• IP (Internet Protocol) : IP est un protocole de couche réseau qui implique le réseau Adressage et routage. IP est responsable de la transmission des paquets de l'hôte source à l'hôte de destination en fonction des en-têtes de paquets sur un ou plusieurs réseaux IP. Il définit également la structure des paquets qui encapsule les données à transmettre.

• DNS (Domain Name Server) : DNS est un système de dénomination hiérarchique décentralisé utilisé pour résoudre des noms d'hôtes lisibles par l'homme tels queisingstack.com en adresses IP lisibles par machine.

• TCP (Transmission Control Protocol) : La norme TCP définit comment établir et maintenir des conversations réseau entre applications pour échanger des données. TCP fournit un flux d'octets fiable, ordonné et vérifié contre les erreurs entre les applications exécutées sur des hôtes communiquant sur des réseaux IP. Les clients HTTP lancent des requêtes en établissant une connexion TCP.

• SSL/TLS (Transport Layer Security) : TLS est un protocole de cryptage qui assure la sécurité des communications sur un réseau informatique. SSL (Secure Sockets Layer) est le prédécesseur obsolète de TLS. TLS et SSL utilisent tous deux des certificats pour établir des connexions sécurisées. Les certificats SSL ne reposent pas sur des protocoles de chiffrement (tels que TLS) et le certificat contient une paire de clés : une clé publique et une clé privée. Ces clés fonctionnent ensemble pour établir une connexion cryptée.

Regardons maintenant la chronologie d'une requête HTTP typique :

• Recherche DNS : Le temps passé à effectuer des recherches DNS. Les recherches DNS résolvent les noms de domaine en adresses IP. Chaque nouveau domaine nécessite un aller-retour complet pour une recherche DNS. Lorsque la destination est déjà une adresse IP, il n'y a pas de recherche DNS.

• Connexion TCP : Le temps nécessaire pour établir une connexion TCP entre l'hôte source et l'hôte de destination. La connexion doit être établie correctement lors de la négociation en plusieurs étapes. Les connexions TCP sont gérées par le système d'exploitation, et si la connexion TCP sous-jacente ne peut pas être établie, les délais d'attente de connexion TCP à l'échelle du système d'exploitation seront intégrés dans la configuration du délai d'attente de notre application.

• Poignée de main TLS : il est temps de terminer la poignée de main TLS. Lors de la prise de contact, les points de terminaison échangent des clés d'authentification et des clés pour établir ou reprendre une session sécurisée. Aucune négociation TLS n’est requise pour les requêtes HTTPS.

• Time to First Byte (TTFB) : le temps d'attente pour la réponse initiale. Ce temps capture la latence vers et depuis le serveur, en plus du temps passé à attendre que le serveur traite la demande et fournisse la réponse.

• Transfert de contenu : le temps nécessaire pour recevoir les données de réponse. La taille des données de réponse et la bande passante réseau disponible déterminent sa durée.

Comment aider à découvrir les goulots d'étranglement des performances grâce à la surcharge de temps HTTP ?

Par exemple, si vos requêtes DNS prennent plus de temps que prévu, le problème peut provenir de votre fournisseur DNS ou des paramètres du cache DNS.

La lenteur de la diffusion du contenu peut être causée par un mécanisme réactif inefficace, comme le renvoi d'un trop grand nombre de données (attributs JSON inutilisés, etc.) ou une connexion lente.

Mesure de la surcharge de temps HTTP dans Node.js

Afin de mesurer la surcharge de temps HTTP dans Node.js, nous devons nous abonner à des événements de requête, de réponse et de socket spécifiques. Voici un court extrait de code montrant comment procéder dans Node.js, cet exemple se concentre uniquement sur le timing :

const timings = {
 // use process.hrtime() as it's not a subject of clock drift
 startAt: process.hrtime(),
 dnsLookupAt: undefined,
 tcpConnectionAt: undefined,
 tlsHandshakeAt: undefined,
 firstByteAt: undefined,
 endAt: undefined
 }

 const req = http.request({ ... }, (res) => {
 res.once('readable', () => {
  timings.firstByteAt = process.hrtime()
 })
 res.on('data', (chunk) => { responseBody += chunk })
 res.on('end', () => {
  timings.endAt = process.hrtime()
 })
 })
 req.on('socket', (socket) => {
 socket.on('lookup', () => {
  timings.dnsLookupAt = process.hrtime()
 })
 socket.on('connect', () => {
  timings.tcpConnectionAt = process.hrtime()
 })
 socket.on('secureConnect', () => {
  timings.tlsHandshakeAt = process.hrtime()
 })
 })

Une recherche DNS n'aura lieu que s'il existe un nom de domaine :

/ There is no DNS lookup with IP address
const dnsLookup = dnsLookupAt !== undefined ? 
 getDuration(startAt, dnsLookupAt) : undefined

La connexion TCP s'effectue immédiatement après la résolution de l'hôte :

const tcpConnection = getDuration((dnsLookupAt || startAt), tcpConnectionAt)

La prise de contact TLS (SSL) ne peut utiliser que le protocole https :

// There is no TLS handshake without https 
const tlsHandshake = tlsHandshakeAt !== undefined ? 
  getDuration(tcpConnectionAt, tlsHandshakeAt) : undefined

Nous attendons que le serveur commence à envoyer en premier octets :

const firstByte = getDuration((tlsHandshakeAt || tcpConnectionAt), firstByteAt)

Durée totale calculée à partir des dates de début et de fin :

const total = getDuration(startAt, endAt)

Pour voir l'exemple complet, consultez notre https://github.com/RisingStac ... entrepôt.

Outils pour mesurer le temps

Maintenant que nous savons comment mesurer le temps HTTP à l'aide de Node, discutons des outils existants qui peuvent être utilisés pour comprendre les requêtes HTTP.

module de requête

Le célèbre module de requête dispose de méthodes intégrées pour mesurer le timing HTTP. Vous pouvez l'activer en utilisant l'attribut time.

const request = require('request')

request({ 
 uri: 'https://risingstack.com',
 method: 'GET',
 time: true
}, (err, resp) => {
 console.log(err || resp.timings)
})

Traçage distribué

Vous pouvez utiliser des outils de traçage distribués pour collecter les timings HTTP et les visualiser sur une chronologie. De cette façon, vous pouvez obtenir une image complète de ce qui se passe dans les coulisses et du coût réel de la construction d'un système distribué.

La bibliothèque opentracing-auto de RisingStack possède des indicateurs intégrés pour collecter toutes les heures HTTP via OpenTracing.

Synchronisation des requêtes HTTP à l'aide d'opentracing-auto dans Jaeger.

Résumé

Mesurer le temps HTTP à l'aide de Node.js peut vous aider à détecter les goulots d'étranglement en matière de performances. L'écosystème Node fournit d'excellents outils pour extraire ces métriques des applications.

Recommandations associées :

Partagez plusieurs façons d'envoyer des requêtes HTTP en PHP

Analyse des similitudes et des différences dans les principales fonctionnalités des différentes versions de HTTP

Introduction au module http et au module url dans node.js

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!