Aller au contenu
English

Décisions d'architecture

  • Leçon 16
  • 65 min
  • Module 5 : Performance et capacité de croissance

Où nous en sommes

Dans les deux dernières leçons, nous avons mesuré le bureau et nous l'avons fait charger et dessiner moins. Chaque changement était petit. Maintenant, Kwame pose une question plus large : le serveur devrait-il dessiner le bureau plutôt que le navigateur? Dans cette leçon, nous comparons le rendu côté client, le rendu côté serveur et les pages statiques selon les besoins du produit, et nous notons la décision. Trois façons d'obtenir un souper montrent le choix.

Lue depuis YouTube. Rien ne se charge depuis YouTube avant que vous appuyiez sur lecture. Confidentialité

Ce que vous saurez faire

Kwame demande si le serveur devrait dessiner le bureau plutôt que le navigateur. Comparez les trois façons de créer une page selon les besoins du produit : rendu côté client, rendu côté serveur et pages statiques. Notez la décision et ses raisons, puis indiquez quand vous la changeriez.

Avant de commencerCe qu’il faut savoir et avoir sous la mainEnviron 65 minutes

Ce que vous devez savoir

Ce qu’il vous faut sur votre ordinateur

  • Votre projet après la dernière leçon : npm test affiche pass 21 et Tests 43 passed (43), et npm run build crée quatre fichiers JavaScript.
  • L’API simulée en cours d’exécution dans un premier terminal (npm run api).

Cette leçon se termine par l’exercice de tout le module, qui prend environ 25 minutes. Testé avec Node.js 24.18.0 sur macOS (Apple silicon), dans Chromium 156.

Il existe trois façons d’obtenir un souper. Une boîte-repas arrive chez vous avec des ingrédients et une fiche recette. La boîte arrive vite, mais vous cuisinez vous-même. Le repas est prêt seulement quand vous avez terminé. En échange, vous pouvez le préparer à votre façon, encore et encore, sans demander à personne.

Au restaurant, la cuisine prépare votre commande et vous apporte un repas prêt à manger. Vous mangez plus tôt, mais la cuisine travaille pour chaque commande. Quand le restaurant est plein, tout le monde attend la cuisine.

Un sandwich préparé le matin est prêt avant que quelqu’un le demande. On le remet immédiatement, et il coûte presque rien par client. Mais tout le monde reçoit le même sandwich, et sa fraîcheur date du matin.

Les pages Web se créent de ces trois mêmes façons. La question n’est jamais « quelle est la meilleure? ». C’est « de quoi ce produit a-t-il besoin? »

Kwame, l’architecte de solutions, ouvre les fichiers de production du bureau et trouve dist/index.html. Voici son contenu complet, soit 394 octets :

<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8" />
<meta name="viewport" content="width=device-width, initial-scale=1" />
<title>Ticket desk</title>
<script type="module" crossorigin src="/assets/index-DnbxJFGT.js"></script>
<link rel="stylesheet" crossorigin href="/assets/index-Cq7Ckq9E.css">
</head>
<body>
<div id="root"></div>
</body>
</html>

« Le corps contient un seul div vide, dit-il. Sans JavaScript, la page n’affiche rien. Un moteur de recherche ne voit rien. Sur le téléphone d’Omar, rien d’utile n’apparaît avant le téléchargement et l’exécution de 93 ko de JavaScript. Les grands sites dessinent leurs pages sur le serveur. On ne devrait pas faire pareil? »

Ses faits sont justes. Avec le profil semblable à un téléphone de la dernière leçon, le FCP arrivait à 872 ms. Les premières lignes apparaissaient à 1 102,1 ms. Le téléchargement du JavaScript occupait presque tout le temps avant le FCP. Mais « les grands sites le font » n’est pas une raison. Un tel choix est une décision d’architecture. Il est difficile à changer plus tard. Vous le faites donc volontairement, selon les besoins du produit, et vous le notez.

Le rendu transforme les données et les composants en HTML que l’écran affiche. Les trois choix diffèrent par le lieu et le moment de cette transformation.

  1. Rendu côté client. Le serveur envoie un petit fichier HTML et le JavaScript. Le navigateur, qui est le client, exécute les composants, demande les données à l’API et construit la page. C’est la boîte-repas, et c’est ainsi que le bureau fonctionne actuellement.
  2. Rendu côté serveur. Pour chaque requête, un serveur exécute les mêmes composants avec les données et envoie du HTML contenant déjà le contenu. Ensuite, le JavaScript arrive et attache ses gestionnaires d’événements à ce HTML. Les boutons et les formulaires commencent alors à fonctionner. Cette étape porte un nom : hydratation. Le HTML ressemble à des aliments déshydratés, et le JavaScript est l’eau qui leur redonne vie. C’est le restaurant.
  3. Pages statiques. Une construction produit le HTML de chaque page une seule fois, avant toute demande. Un simple serveur Web ou un réseau de diffusion de contenu (CDN) distribue les fichiers. C’est le sandwich préparé le matin. La page que vous lisez en est une : Nextia Learning construit ses leçons sous forme de pages statiques.
Trois lignes, une par choix, chacune présentant les étapes d'une visite. Rendu côté client (le bureau des billets) : le serveur envoie un petit fichier HTML et le JavaScript; le navigateur exécute JavaScript, interroge l'API, dessine; le contenu apparaît quand le navigateur a tout terminé. Rendu côté serveur (une page de suivi de commande) : le serveur obtient les données et écrit le HTML; le HTML contient le contenu; ensuite vient JavaScript, et la page fonctionne; le contenu apparaît à l'arrivée du HTML, les boutons fonctionnent plus tard. Pages statiques (un centre d'aide) : le HTML est écrit une seule fois, avant toute demande, lors d'une construction; le HTML contient le contenu; le contenu apparaît à l'arrivée du HTML, sans travail par visite.
L'ordre des événements pour une visite selon chaque choix. Pas à l'échelle : le cours a construit seulement le bureau avec rendu côté client, donc seuls ses temps sont mesurés.
Description textuelle du diagramme

Le diagramme comporte trois lignes. Avec le rendu côté client, le serveur envoie un petit fichier HTML et le JavaScript. Le navigateur exécute le JavaScript, interroge l’API et dessine. Le contenu apparaît seulement quand le navigateur a tout terminé. Avec le rendu côté serveur, le serveur obtient d’abord les données et écrit le HTML. Le HTML arrive avec le contenu. Ensuite, le JavaScript arrive, et la page commence à fonctionner. Pour les pages statiques, une construction a écrit le HTML une seule fois, avant toute demande. Il arrive avec le contenu, et aucun travail n’est effectué par visite. La longueur des étapes n’est pas à l’échelle.

Les vrais produits combinent aussi ces approches. Une structure de page statique peut récupérer ses données dans le navigateur. Un serveur peut produire le premier écran et laisser le navigateur produire tous les écrans suivants. Les trois choix simples suffisent pour réfléchir aux combinaisons.

Un petit exemple : une liste de billets, trois façons

Section intitulée « Un petit exemple : une liste de billets, trois façons »

Prenez les deux premières lignes de la liste de billets. Voici ce que le serveur envoie selon chaque choix.

Le rendu côté client envoie les 394 octets ci-dessus. Les lignes existent seulement après l’exécution du JavaScript dans le navigateur et la réponse de l’API.

Le rendu côté serveur envoie les lignes dans le HTML. Un programme serveur demande à l’API des billets la première page de cet agent et écrit, par exemple :

<ul class="rows">
<li><a class="row" href="#/tickets/T-80010">… Return label for my order LK-300210 …</a></li>
<li><a class="row" href="#/tickets/T-80009">… My order LK-55190 never arrived …</a></li>
</ul>

L’agent voit les lignes quand le HTML arrive, avant toute exécution de JavaScript. Mais le serveur doit exécuter React pour chaque requête, et les liens fonctionnent seulement après l’hydratation.

Les pages statiques écriraient le même HTML une seule fois, lors d’une construction. Mais quels billets? Ceux du moment de la construction. Un billet qui arrive une minute plus tard ne figure pas dans la page. Et chaque agent verrait la même page, y compris des billets qu’il n’a pas le droit de voir. Une page statique ne convient pas du tout aux données privées et actualisées du bureau.

Rendu côté client Rendu côté serveur Pages statiques
Qui produit le HTML Le navigateur, à chaque visite Un serveur, à chaque requête Une construction, une seule fois
Contenu visible Après le JavaScript et l’API À l’arrivée du HTML À l’arrivée du HTML
Sans JavaScript Rien Le contenu, mais les boutons ne fonctionnent pas Le contenu
Travail sur un serveur par visite Aucun (seulement l’API) Exécuter les composants Aucun
Données à jour Oui, depuis l’API Oui, au moment de la requête À jour seulement au moment de la dernière construction
Ce que vous devez exécuter Des fichiers statiques et l’API Un serveur qui exécute JavaScript, et l’API Des fichiers statiques

Teodor et Kwame examinent les besoins du bureau, un par un :

  • Qui l’utilise? Les agents de Larkfield, connectés, sur leurs ordinateurs de travail. Ils ouvrent le bureau le matin et le gardent ouvert toute la journée. Le premier chargement a lieu une fois par jour. Chaque changement d’écran suivant est rapide, car le code se trouve déjà dans le navigateur.
  • Les moteurs de recherche doivent-ils le voir? Jamais. Les billets contiennent les données personnelles des clients. Une page qu’un moteur de recherche pourrait lire constituerait une fuite.
  • À quelle fréquence les données changent-elles? Elles changent chaque minute, et chaque agent voit des billets différents. Une page statique ne peut pas les contenir.
  • Quel choix coûte le moins cher à exploiter? Le rendu côté client : les fichiers sont statiques, donc tout serveur Web ou CDN peut les distribuer. Seule l’API exécute du code.

Le bureau garde donc son rendu dans le navigateur. La plainte d’Omar concernant son téléphone est justifiée. Mais les deux dernières leçons y ont répondu à moindre coût : un premier fichier plus petit et une liste virtuelle. Le rendu côté serveur ajouterait un deuxième serveur qui exécute JavaScript pour chaque requête et qu’il faut sécuriser. Tout cela économiserait une partie d’un seul chargement par jour.

Kwame pose ensuite des questions sur deux autres pages que Larkfield prévoit créer. L’organigramme présente le raisonnement pour les trois :

Un organigramme. Question : les personnes sans l'application, ou les moteurs de recherche, doivent-ils voir le contenu? Non : utilisateurs connectés, données privées, mène au rendu côté client, le bureau des billets. Oui mène à une deuxième question : le contenu est-il identique pour tous, et change-t-il lentement? Oui mène aux pages statiques, un centre d'aide. Non, différent par personne ou chaque minute, mène au rendu côté serveur, une page de suivi de commande.
Deux questions sur le produit, trois réponses pour trois pages de Larkfield.
Description textuelle du diagramme

L’organigramme pose deux questions. Première question : les personnes sans l’application, ou les moteurs de recherche, doivent-ils voir le contenu? Sinon, parce que les utilisateurs sont connectés et les données sont privées, choisissez le rendu côté client, comme pour le bureau des billets. Si oui, posez la deuxième question : le contenu est-il identique pour tous, et change-t-il lentement? Si oui, choisissez les pages statiques, comme pour un centre d’aide. S’il diffère selon la personne ou change chaque minute, choisissez le rendu côté serveur, comme pour une page de suivi de commande.

  • Un centre d’aide public avec des articles pour les clients (« Comment retourner un article? »). Tous voient les mêmes articles, qui changent quelques fois par semaine. Les clients doivent les trouver avec un moteur de recherche. Pages statiques : construites quand un article change, distribuées par un CDN, rapides sur tout téléphone.
  • Une page de suivi de commande, ouverte depuis un lien dans un courriel, surtout sur téléphone. Chaque client voit sa propre commande, qui change au cours de la journée. Le contenu devrait apparaître immédiatement, sans téléchargement volumineux. Le rendu côté serveur est un choix raisonnable ici, avec une précaution. La page contient des données personnelles, donc aucun cache partagé ne doit la conserver. Le cas d’échec ci-dessous montre pourquoi.
  • Le rendu côté client convient aux outils auxquels les gens se connectent et qu’ils gardent ouverts : tableaux de bord, éditeurs, bureau des billets. C’est le moins cher à exploiter. En échange, le premier chargement est plus lent, surtout sur téléphone, et la page reste vide sans JavaScript.
  • Le rendu côté serveur convient aux pages qui doivent afficher immédiatement du contenu personnel ou changeant rapidement, souvent sur des appareils lents. Il exige un serveur qui exécute JavaScript pour chaque requête, avec sa propre mise à l’échelle, surveillance et sécurité. L’hydratation exige aussi le même JavaScript que le rendu côté client. Le téléchargement ne disparaît donc pas; il cesse seulement de bloquer le premier affichage.
  • Les pages statiques conviennent au contenu identique pour tous et qui change lentement : documentation, centres d’aide, pages marketing, ce cours. Elles sont les plus rapides et les moins chères. Elles exigent une nouvelle construction à chaque changement. Elles ne peuvent pas afficher de données privées ou actualisées sans code côté client.

Quel que soit votre choix, notez-le. Une fiche de décision d’architecture est un court document. Elle indique le choix, les raisons, les coûts que vous acceptez et les conditions qui le feraient changer. Six mois plus tard, personne n’a à deviner pourquoi le bureau fonctionne ainsi.

  1. Dans ~/projects/ticket-desk, créez un dossier docs.

  2. Dans ce dossier, créez un fichier rendering-choices.md en trois parties. D’abord, un tableau des trois choix : ce que le serveur envoie, les usages adaptés et les coûts de chacun. Ensuite, Notre décision, avec les raisons. Enfin, Quand nous la changerions.

  3. Pour chaque raison, écrivez le fait qui l’appuie. Utilisez vos propres mesures quand vous en avez : la taille du premier fichier obtenue avec npm run size, et les premières lignes avec le profil semblable à un téléphone.

  4. Comparez votre fichier à la version du cours : ../nextia-learning-labs/C22/snapshots/end-of-m05/docs/rendering-choices.md.

  5. Regardez ce que le bureau affiche sans JavaScript. Exécutez npm run build et npm run preview, puis ouvrez http://localhost:4173/. Dans DevTools, ouvrez le menu de commandes (Ctrl+Shift+P, ou Cmd+Shift+P sur Mac), tapez Disable JavaScript (désactiver JavaScript), appuyez sur Entrée et rechargez.

  6. Réactivez JavaScript : dans le menu de commandes, exécutez Enable JavaScript (activer JavaScript).

  7. Copiez les derniers fichiers de ce module depuis l’instantané. Le README répertorie maintenant npm run size, npm run build:profile et le dossier docs/. Le fichier package.json et le fichier de verrouillage passent à la version 0.5.0 :

    Fenêtre de terminal
    S=../nextia-learning-labs/C22/snapshots/end-of-m05
    cp "$S/README.md" "$S/package.json" "$S/package-lock.json" .

    Votre projet contient maintenant les mêmes fichiers que l’instantané end-of-m05, sauf vos propres mots dans docs/rendering-choices.md.

Afficher le résultat attendu

Étape 4 : la fiche de décision du cours contient les mêmes trois parties. Voici sa décision :

The ticket desk is rendered in the browser (Vite builds static files; the browser draws the screens).
- Its users are signed-in agents who keep it open all day. The first load happens once a day;
after that, every screen change is fast, because the code is already in the browser.
- Search engines must never see tickets. Server rendering for search is not needed.
- The data changes every minute and is different for each agent: a static page cannot hold it.
- The files are static, so any web server or CDN can serve them. Only the API runs code.

Elle se termine par Quand nous la changerions. Une page publique doit parfois apparaître vite sur des téléphones lents et être trouvée par les moteurs de recherche. Elle reçoit alors un rendu côté serveur ou des pages statiques, sur un site distinct. Le bureau reste tel quel. Vos mots peuvent différer. Vérifiez que chaque raison est un fait sur le produit, et non une tendance.

Étape 5 : une page blanche. Le titre de l’onglet reste « Ticket desk » (bureau des billets), car le titre se trouve dans le HTML. Tout le reste vient de JavaScript.

À vous de jouer : une page d’état pour les clients

Section intitulée « À vous de jouer : une page d’état pour les clients »

Prédisez d’abord, puis décidez. Larkfield veut une page publique « Le bureau de soutien est-il occupé? ». Elle affiche le délai prévu pour recevoir une réponse, mis à jour toutes les 5 minutes, identique pour chaque visiteur. Beaucoup de clients l’ouvrent sur téléphone. Une recherche de « Larkfield support » doit permettre de la trouver. Quel choix faire, et quel est son coût? Écrivez la décision en quatre lignes, comme dans la fiche de décision.

Afficher la réponse

Des pages statiques, reconstruites toutes les 5 minutes, ou une page statique avec une petite requête côté client pour le nombre. Le contenu est identique pour tous, donc rien ne justifie un rendu à chaque requête. Les moteurs de recherche doivent le trouver, et il doit apparaître vite sur téléphone. Le rendu côté client de toute la page convient donc mal. Une construction toutes les 5 minutes coûte peu, et un CDN distribue la page rapidement partout. Le coût : le nombre peut dater de 5 minutes, et quelqu’un doit surveiller la tâche qui reconstruit la page. Si le nombre devait être actualisé à la seconde, gardez la page statique et récupérez seulement le nombre dans le navigateur.

Erreur courante

Une page privée avec rendu côté serveur dans un cache partagé

C’est un exemple construit : le cours ne l’a pas réalisé, mais l’erreur est courante.

Symptôme : la page de suivi de commande de Larkfield utilise le rendu côté serveur. Un CDN placé devant conserve chaque page pendant 60 secondes pour réduire le travail du serveur. Une cliente ouvre le lien de son courriel et voit le nom et l’adresse d’un autre client.

Cause : l’adresse de la page est identique pour chaque client, /my-order. Le serveur identifie le client à partir d’un témoin (cookie). Le CDN conserve les pages selon leur adresse seulement. Il a donc donné le HTML du premier client à tous ceux qui l’ont demandé pendant les 60 secondes suivantes. Avec le rendu côté client, le HTML partagé serait la structure vide. Chaque navigateur récupérerait ses propres données avec sa propre connexion. Le rendu côté serveur place les données privées dans le HTML, donc le HTML lui-même devient privé.

Correction : envoyez l’en-tête Cache-Control: private, no-store avec chaque page contenant des données personnelles. Cache-Control est l’en-tête HTTP qui indique aux caches s’ils peuvent conserver une réponse, et pendant combien de temps. private, no-store signifie qu’aucun cache partagé ne peut la conserver. Laissez le CDN mettre en cache seulement les fichiers statiques et les pages identiques pour tous. Testez : connectez-vous avec deux comptes clients différents et comparez les pages.

Conséquence pour le travail en IA : les pages contenant des réponses d’IA sont souvent personnelles. Un brouillon de réponse, un résumé des billets d’un client, une réponse tirée de ses documents : tous sont des données privées. Si le serveur produit une telle page et qu’un cache la conserve comme une page publique, la réponse d’IA d’une personne parvient à une autre.

Exercice du module : mesurer et corriger un problème introduit

Section intitulée « Exercice du module : mesurer et corriger un problème introduit »

Voici l’exercice pour tout le module, avec sa vérification de réussite. D’abord, un exemple détaillé avec tous les chiffres, puis une tâche pour vous.

Tomás a une idée : « Les agents détestent attendre quand ils font défiler la liste. Chargeons toutes les pages à la fois et affichons toutes les lignes. Comme ça, le défilement ne les fera jamais attendre. » Cette version de TicketList.tsx fait exactement cela. C’est le problème introduit.

  1. Enregistrez votre fichier src/features/tickets/TicketList.tsx sous le nom TicketList.good.tsx dans le même dossier, pour pouvoir le restaurer.

  2. Remplacez le contenu de TicketList.tsx par la version de Tomás :

    import { useEffect, useState } from 'react';
    import type { TicketFilter } from '../../api/types';
    import { ErrorMessage } from '../../ui/ErrorMessage';
    import { useTicketList } from './queries';
    import { TicketFilters } from './TicketFilters';
    import { TicketRow } from './TicketRow';
    export const NO_FILTER: TicketFilter = { status: '', team: '', q: '' };
    /** SEEDED PROBLEM: loads every page at once and draws every row ("so that scrolling never waits"). */
    export function TicketList({ selectedId }: { selectedId: string | null }) {
    const [filter, setFilter] = useState<TicketFilter>(NO_FILTER);
    const list = useTicketList(filter);
    const tickets = list.data?.pages.flatMap((p) => p.items) ?? [];
    // Ask for the next page as soon as one arrives, until the server has no more.
    const { hasNextPage, isFetchingNextPage, fetchNextPage } = list;
    useEffect(() => {
    if (hasNextPage && !isFetchingNextPage) void fetchNextPage();
    }, [hasNextPage, isFetchingNextPage, fetchNextPage]);
    // A mark for the browser's performance tools: the first time that ticket rows are on the screen.
    const firstRows = tickets.length > 0;
    useEffect(() => {
    if (firstRows && performance.getEntriesByName('tickets:first-rows').length === 0) performance.mark('tickets:first-rows');
    }, [firstRows]);
    return (
    <section className="list" aria-labelledby="list-heading">
    <h2 id="list-heading">Tickets</h2>
    <TicketFilters value={filter} onChange={setFilter} />
    {list.isPending && <p className="muted">Loading tickets…</p>}
    {list.isError && <ErrorMessage error={list.error} onRetry={() => list.refetch()} />}
    {list.isSuccess && (
    <>
    <p className="muted" aria-live="polite">
    {tickets.length === 0
    ? 'No ticket matches.'
    : `Showing ${tickets.length} tickets${list.hasNextPage ? ' (more on the server)' : ''}.`}
    {list.isPlaceholderData && ' Updating…'}
    </p>
    <div className="scroller" tabIndex={0} role="region" aria-label="Ticket list">
    <ul className="rows">
    {tickets.map((t) => (
    <li key={t.ticket_id}>
    <TicketRow ticket={t} selected={t.ticket_id === selectedId} />
    </li>
    ))}
    </ul>
    </div>
    </>
    )}
    </section>
    );
    }
  3. Exécutez npm test. Regardez quel test échoue et pourquoi.

  4. Exécutez npm run build et npm run preview, puis ouvrez http://localhost:4173/ avec le panneau Network (réseau) ouvert, sans limitation. Observez la ligne « Showing … tickets » (nombre de billets affichés) et le nombre de requêtes au bas du panneau Network. Attendez que les deux cessent de changer.

  5. Dans la Console, comptez les éléments de la liste : document.querySelectorAll('.list *').length.

  6. Restaurez votre version : copiez TicketList.good.tsx dans TicketList.tsx, puis supprimez TicketList.good.tsx. Répétez les étapes 3 à 5.

Afficher les résultats de l’exemple détaillé

Étape 3 : un test échoue, celui de la liste virtuelle de la leçon précédente :

FAIL src/features/tickets/TicketList.test.tsx > draws only the rows in view, not every loaded ticket
AssertionError: expected 50 to be less than 25
Tests 1 failed | 42 passed (43)

Le test a détecté le problème avant même d’ouvrir un navigateur : 50 billets chargés produisaient 50 lignes dans la page.

Étapes 4 et 5, puis les mêmes étapes après la correction, sur le portable de l’équipe du cours. Les valeurs sont les médianes de 3 essais, sans limitation :

Requêtes de liste au premier chargement, liste problématique comparée à celle du bureau (médiane de 3 essais, sans limitation).
Description textuelle du graphique

Au premier chargement, la liste problématique a envoyé 200 requêtes de billets; celle du bureau en a envoyé 1.

Mesure prise de la même façon Liste problématique Liste du bureau (après la correction)
Requêtes de billets 200 1
Temps avant que la liste cesse de grandir 14 561 ms 109 ms
Éléments dans la liste 60 022 131
Lignes de billets dans la page 10 000 18
Premières lignes 96,6 ms 97,8 ms
Appui de touche le plus long en tapant « parcel » 40 ms 24 ms ou moins

La dernière ligne provient de l’API Event Timing du navigateur : le temps entre un appui de touche et le prochain affichage. Elle rapporte seulement les appuis de 16 ms ou plus, par intervalles de 8 ms.

Les premières lignes apparaissaient à peu près au même moment dans les deux versions. Le changement de Tomás n’apparaît donc pas dans cette mesure. Il apparaît dans tout ce qui suit : 200 requêtes pendant 14,6 secondes et une page de 60 022 éléments. Les appuis de touches prennent aussi plus de temps, car chacun oblige React à comparer 10 000 lignes. Sur un téléphone, le même travail prend environ quatre fois plus de temps. Les 10 000 billets consomment aussi les données mobiles. Voilà pourquoi un seul chiffre ne suffit jamais : mesurez aussi ce que l’agent fait ensuite.

La correction est la liste de la leçon précédente, sans memo et sans nouveau code. Elle demande d’abord une page, puis la suivante seulement à l’approche de la fin. Elle affiche seulement les lignes visibles. Le tableau montre l’amélioration : les mêmes mesures, avant et après, prises de la même façon.

Un membre de l’équipe voulait utiliser React Profiler en production et a changé une ligne de vite.config.ts :

resolve: { alias: { 'react-dom/client': 'react-dom/profiling' } },

Maintenant, toutes les constructions utilisent la version de profilage de React, pas seulement npm run build:profile. Votre tâche :

  1. Faites ce changement dans votre projet pour commencer avec le problème introduit.
  2. Mesurez-le : npm run build, npm run size et les premières lignes avec le profil simulant un téléphone (Slow 4G, CPU 4×), trois fois.
  3. Corrigez-le, sans ajouter d’autre code que la correction.
  4. Mesurez de nouveau, de la même façon.
  5. Rédigez une note de performance de cinq lignes ou moins : vos mesures, la méthode, les chiffres avant et après, et la correction.

Vérification de réussite. Montrez une amélioration observée : les mêmes mesures avant et après la correction, dans les mêmes conditions. Montrez que vous n’avez ajouté ni memo, ni nouvelle bibliothèque, ni autre code. Expliquez ensuite en deux phrases lequel des trois types d’attente la correction a changé.

Afficher une solution détaillée

Mesurer le problème introduit. Sur le portable de l’équipe du cours :

dist/assets/index-BZyjPyJL.js 319.77 kB │ gzip: 98.41 kB
assets/index-BZyjPyJL.js 312.3 KB 94.9 KB
JavaScript: 4 files, 100.8 KB gzip in all

Premières lignes avec le profil simulant un téléphone, 5 essais : médiane de 1 124,8 ms (de 1 123,5 à 1 130,8).

Trouver la cause. Le premier fichier a grossi de 5,4 ko, sans ajouter de fonctionnalité. npm run build:profile donnait la même taille avant le changement. Toutes les constructions utilisent donc maintenant la version de profilage de React. La correction est la ligne de Mesurer dans le navigateur :

resolve: mode === 'profile' ? { alias: { 'react-dom/client': 'react-dom/profiling' } } : {},

Mesurer de nouveau, de la même façon :

dist/assets/index-DnbxJFGT.js 302.28 kB │ gzip: 93.02 kB
assets/index-DnbxJFGT.js 295.2 KB 89.7 KB
JavaScript: 4 files, 95.6 KB gzip in all

Premières lignes avec le profil simulant un téléphone, 5 essais : médiane de 1 102,1 ms (de 1 094,4 à 1 123,5).

Une note de performance :

Problem: every production build used React's profiling build (vite.config.ts).
Measured: npm run build and npm run size; first rows, Slow 4G + CPU 4x, median of 5, preview build.
Before: index.js 98.41 kB gzip; first rows 1,124.8 ms (1,123.5-1,130.8).
After: index.js 93.02 kB gzip; first rows 1,102.1 ms (1,094.4-1,123.5).
Fix: the profiling alias only in --mode profile. No other change, no memo.

La correction a changé le téléchargement : 5,4 ko de moins sur le réseau. Le temps avant les premières lignes a diminué d’environ 23 ms, près de l’écart entre les essais. La taille constitue donc la preuve claire; le temps va simplement dans le même sens. C’est un résultat normal : présentez-le tel quel, sans affirmer davantage.

Vérifiez votre compréhension

Kwame dit : « Le rendu serveur est toujours plus rapide. Utilisons-le pour le bureau. » Qu'est-ce qui est vrai dans son affirmation, et pourquoi Larkfield garde-t-elle le rendu client pour le bureau?

Afficher la réponse

C’est vrai : avec le rendu serveur, le contenu arrive dans le HTML. La première vue n’attend donc ni le JavaScript ni l’API. Le bureau garde le rendu client à cause des besoins du produit. Ses agents sont connectés et le gardent ouvert toute la journée. Le premier chargement a donc lieu une fois par jour. Les moteurs de recherche ne doivent jamais voir les billets. Les données sont privées et changent chaque minute. Le rendu client nécessite seulement des fichiers statiques et l’API. Le rendu serveur nécessite un serveur qui exécute du JavaScript pour chaque requête. Un premier fichier plus petit et une liste virtuelle ont amélioré le premier chargement sur téléphone à moindre coût.

Vérifiez votre compréhension

Prédisez : Larkfield construit son centre d'aide sous forme de pages statiques, et un article change. Quand les clients voient-ils le changement, et que doit-il se passer d'abord?

Afficher la réponse

Seulement après qu’une nouvelle construction a recréé le HTML et que les nouveaux fichiers sont sur le serveur ou le CDN. Jusque-là, les clients voient l’ancien article. Un site statique nécessite une construction pour chaque changement de contenu. L’équipe la lance, ou un outil la démarre quand un article est enregistré.

Vérifiez votre compréhension

Pourquoi une page avec des données personnelles présente-t-elle plus de risques dans un cache partagé avec le rendu serveur qu'avec le rendu client?

Afficher la réponse

Le rendu serveur place les données personnelles dans le HTML, qui est donc privé. Un cache partagé qui conserve les pages par adresse peut donner le HTML d’une personne à la suivante. Avec le rendu client, le HTML est le même cadre vide pour tout le monde. Chaque navigateur récupère ses propres données avec sa propre connexion. Les pages contenant des données personnelles nécessitent Cache-Control: private, no-store.

Récapitulatif

  • Le rendu client envoie un petit fichier HTML et du JavaScript, puis le navigateur construit la page. Le rendu serveur envoie du HTML avec le contenu, puis l’hydrate. Les pages statiques sont du HTML créé une seule fois, par une construction.
  • Choisissez selon les besoins du produit : utilisateurs, visibilité dans les moteurs de recherche, fraîcheur et confidentialité des données, coût d’exploitation. Le bureau garde le rendu client; un centre d’aide convient aux pages statiques. Une page de suivi de commande peut utiliser le rendu serveur, mais jamais un cache partagé.
  • Consignez le choix dans un document de décision, avec ses raisons, ses coûts et les conditions qui vous feraient le changer.
  • Module 5 en un coup d’œil : mesurez d’abord avec le repère des premières lignes, la cascade, le rapport de taille et la version de profilage. Trouvez la plus longue attente. Chargez et affichez moins : une page de données, les lignes visibles, le code de l’écran ouvert. Mesurez de nouveau de la même façon. memo n’a jamais été la réponse ici.

Ensuite, le module 6 sécurise le bureau : les limites de sécurité du navigateur, le Markdown généré et les endroits interdits aux secrets.

Leçon suivante : Limites de sécurité du navigateur