Accueil › Node.js › Performance et montée en charge
Performance et montée en charge — entretien Node.js
10 questions posées en entretien sur 4 sujets, avec la bonne réponse et son explication.
Mesure
Pourquoi publie-t-on des centiles de latence plutôt qu'une moyenne ?
- Parce que la moyenne écrase les extrêmes et cache les requêtes très lentes ✓
- Parce que la moyenne est plus coûteuse à calculer
- Parce que les centiles s'additionnent entre instances
- Parce que la moyenne n'est pas disponible dans les outils de métriques
Pourquoi : Une moyenne de 80 ms est parfaitement compatible avec un dernier centile à 4 secondes, et c'est ce dernier centile que vivent les clients qui ouvrent un ticket. En entretien, la bonne réponse ajoute que les centiles ne se moyennent justement pas entre instances : pour agréger, il faut garder la répartition sous forme d'histogramme et recalculer.
Niveau junior
Pourquoi le retard de la boucle d'événements est-il la métrique la plus informative d'un service Node ?
- Parce qu'il dit si le fil unique est occupé, ce que la charge processeur ne dit pas ✓
- Parce qu'il remplace la mesure de la latence par route
- Parce qu'il détecte les requêtes lentes vers la base de données
- Parce qu'il est exprimé en pourcentage, donc comparable entre machines
Pourquoi : Un processus qui sature son unique cœur affiche douze pour cent de charge sur une machine à huit cœurs : la métrique système dit que tout va bien pendant que le service ne répond plus. Le retard de boucle regarde la ressource réellement rare dans Node. Et il ne détecte pas les requêtes lentes vers la base — au contraire, une latence haute avec un retard de boucle bas signifie qu'on attend quelqu'un d'autre.
Niveau confirme
Montée en charge
Que gagne-t-on en déplaçant un service Node d'une machine à 4 cœurs vers une machine à 16 cœurs, sans rien changer d'autre ?
- Presque rien : un processus Node n'utilise qu'un cœur ✓
- Quatre fois plus de débit
- Une latence divisée par quatre
- Rien du tout, dans tous les cas
Pourquoi : Un processus Node exécute votre JavaScript sur un fil, donc sur un cœur ; les douze cœurs supplémentaires restent inoccupés tant qu'on ne lance pas d'autres processus. Le gain n'est pas nul pour autant — la réserve de fils de libuv et le ramasse-miettes profitent de cœurs libres — mais il est marginal face au fait de lancer plusieurs instances.
Niveau junior
Qu'est-ce qui interdit de passer de une à huit instances d'un service ?
- Une session en mémoire, un cache local qui fait autorité, un minuteur à exécution unique ✓
- L'absence d'affinité de session sur le répartiteur de charge
- Une réserve de connexions trop petite
- L'absence de cache partagé
Pourquoi : Les trois sont des formes d'état local, et la troisième est la plus sournoise : un `setInterval` qui envoie les factures quotidiennes les envoie huit fois. Le réflexe de l'affinité de session n'est pas une solution mais un contournement — il tient jusqu'au premier redéploiement, où toutes les sessions disparaissent, et il interdit de retirer une instance sans déconnecter ses utilisateurs.
Niveau senior
Dimensionnement
Un service doit tenir 600 requêtes par seconde avec une latence moyenne de 200 ms. Combien de requêtes sont en vol simultanément ?
- 120 ✓
- 600
- 200
- 3
Pourquoi : La loi de Little donne 600 × 0,200 = 120 requêtes en vol. Le chiffre sert directement au dimensionnement : s'il faut une connexion à la base par requête en vol et que la réserve est de vingt connexions par instance, il faut au moins six instances. Le résultat est un plancher, pas une prévision, puisqu'il suppose la latence stable sous charge.
Niveau confirme
Le processeur des instances est à 20 %, la mémoire est stable, et la latence double quand le trafic double. Quelle est la cause la plus probable ?
- Une ressource bornée fait file d'attente, typiquement la réserve de connexions à la base ✓
- Le fil unique de Node est saturé
- Le ramasse-miettes consomme tout le temps restant
- La bande passante entre le client et le répartiteur de charge
Pourquoi : Une latence qui croît proportionnellement à la charge sans qu'aucune ressource visible ne sature est la signature d'une file d'attente devant une ressource comptée. La réserve de connexions est la première suspecte et la plus trompeuse : l'attente se produit avant la requête SQL, donc les métriques de la base montrent des requêtes rapides pendant que les clients attendent. Le chiffre à instrumenter est le nombre de demandes en attente de connexion.
Niveau confirme
Les requêtes attendent une connexion à la base. Pourquoi augmenter `max` de la réserve ne règle-t-il pas toujours le problème ?
- Parce que la file se déplace simplement côté base, qui n'a pas plus de cœurs ni de disques ✓
- Parce que Node limite le nombre de connexions sortantes à dix
- Parce que la réserve ne sert qu'aux requêtes en écriture
- Parce que les connexions supplémentaires ne sont pas réutilisées
Pourquoi : Au-delà de la capacité réelle du serveur de base, des connexions supplémentaires allongent la file là-bas au lieu d'ici, et dégradent le débit global par contention. Il faut aussi compter le total : huit instances avec `max` à cinquante demandent quatre cents connexions, ce que la base refusera par une erreur de connexion. La vraie correction est en amont — moins de requêtes par requête HTTP, ou un cache.
Niveau senior
Mémoire
Pourquoi la mémoire limite-t-elle une instance Node avant le processeur, dans la plupart des services ?
- Parce qu'un processus plafonne à un cœur, alors que rien ne plafonne sa consommation de mémoire ✓
- Parce que V8 réserve toute la mémoire disponible au démarrage
- Parce que le ramasse-miettes empêche la charge processeur de monter
- Parce que les entrées-sorties ne consomment pas de processeur
Pourquoi : Un processus Node ne dépassera jamais cent pour cent d'un cœur, donc la charge processeur d'un conteneur correctement dimensionné reste basse ; en face, le moindre cache sans borne fait croître la mémoire jusqu'à la limite. C'est pourquoi le dépassement de mémoire est l'incident le plus fréquent d'un service Node, et pourquoi il se présente comme un redémarrage inexpliqué toutes les quelques heures.
Niveau confirme
La mémoire résidente d'un service de transfert de fichiers grandit, mais `heapUsed` reste stable. Où chercher ?
- Des tampons accumulés hors du tas, faute de contre-pression entre la lecture et l'écriture ✓
- Une fermeture qui retient des objets JavaScript
- Un écouteur d'événement jamais retiré
- Une fragmentation du tas de V8
Pourquoi : Un `Buffer` est alloué hors du tas V8 : une accumulation de morceaux non écrits reste invisible dans `heapUsed` tout en provoquant un arrêt pour dépassement de mémoire, et un instantané du tas ne montrera rien. Les champs à regarder sont `external` et `arrayBuffers`. La cause est presque toujours un `write()` dont on ignore la valeur de retour, ce que `pipeline()` évite.
Niveau senior
Pourquoi régler `--max-old-space-size` un peu en dessous de la limite de mémoire du conteneur ?
- Pour obtenir une erreur JavaScript lisible plutôt qu'un processus tué sans trace ✓
- Pour accélérer le ramasse-miettes en réduisant le nombre de cycles
- Parce que V8 ignore la limite du conteneur et plante au démarrage sinon
- Pour que la mémoire résidente ne dépasse jamais le tas
Pourquoi : Si la limite de V8 est au-dessus de celle du conteneur, V8 continue d'allouer et c'est le système qui tue le processus : on perd l'erreur explicite et la pile d'appels qui l'accompagne. Second effet, moins connu et de sens inverse : plus le tas autorisé est grand, plus les pauses du ramasse-miettes sont longues — ce qui se lit dans le dernier centile de latence, jamais dans la moyenne.
Niveau senior