Techniques permettant de charger rapidement une application Web, même sur un téléphone basique

Comment nous avons utilisé la division du code, l'intégration du code et l'affichage côté serveur dans PROXX.

Lors de la conférence Google I/O 2019, Mariko, Jake et moi avons lancé PROXX, un clone moderne du démineur pour le Web. Ce qui distingue PROXX, c'est l'accent mis sur l'accessibilité (vous pouvez y jouer avec un lecteur d'écran !) et la possibilité de l'exécuter aussi bien sur un feature phone que sur un ordinateur haut de gamme. Les feature phones sont limités de plusieurs façons :

  • Processeurs faibles
  • GPU peu performants ou inexistants
  • Petits écrans sans saisie tactile
  • Quantités de mémoire très limitées

Mais ils exécutent un navigateur récent et sont très abordables. C'est pourquoi les feature phones font leur grand retour sur les marchés émergents. Leur prix permet à un tout nouveau public, qui n'en avait pas les moyens auparavant, de se connecter et d'utiliser le Web moderne. En 2019, environ 400 millions de feature phones devraient être vendus en Inde. Les utilisateurs de feature phones pourraient donc représenter une part importante de votre audience. De plus, les vitesses de connexion de type 2G sont la norme sur les marchés émergents. Comment avons-nous réussi à faire fonctionner PROXX dans des conditions de feature phone ?

Gameplay de PROXX.

Les performances sont importantes, qu'il s'agisse des performances de chargement ou d'exécution. Il a été démontré que de bonnes performances sont corrélées à une augmentation de la rétention des utilisateurs, à une amélioration des conversions et, surtout, à une plus grande inclusivité. Jeremy Wagner dispose de beaucoup plus de données et d'insights sur l'importance des performances.

Il s'agit du premier volet d'une série en deux parties. La partie 1 est axée sur les performances de chargement, et la partie 2 sur les performances d'exécution.

Comprendre le statu quo

Il est essentiel de tester les performances de chargement sur un véritable appareil. Si vous n'avez pas d'appareil réel à portée de main, je vous recommande WebPageTest, en particulier la configuration "simple". WPT exécute une série de tests de chargement sur un véritable appareil avec une connexion 3G émulée.

La 3G est une bonne vitesse à mesurer. Même si vous êtes habitué à la 4G, à la LTE ou bientôt à la 5G, la réalité de l'Internet mobile est bien différente. Vous êtes peut-être dans un train, à une conférence, à un concert ou dans un avion. Vous aurez probablement une connexion plus proche de la 3G, voire pire.

Cela étant dit, nous allons nous concentrer sur la 2G dans cet article, car PROXX cible explicitement les feature phones et les marchés émergents dans son audience cible. Une fois que WebPageTest a exécuté son test, vous obtenez un graphique en cascade (semblable à celui que vous voyez dans DevTools) ainsi qu'un filmstrip en haut. La pellicule montre ce que l'utilisateur voit pendant le chargement de votre application. Sur un réseau 2G, l'expérience de chargement de la version non optimisée de PROXX est assez mauvaise :

La vidéo de la pellicule montre ce que l'utilisateur voit lorsque PROXX se charge sur un appareil réel d'entrée de gamme via une connexion 2G émulée.

Lorsqu'elle est chargée via une connexion 3G, l'utilisateur voit un écran blanc pendant quatre secondes. Sur un réseau 2G, l'utilisateur ne voit absolument rien pendant plus de huit secondes. Si vous avez lu Pourquoi les performances sont importantes, vous savez que nous avons perdu une bonne partie de nos utilisateurs potentiels à cause de l'impatience. L'utilisateur doit télécharger l'intégralité des 62 Ko de JavaScript pour que quelque chose s'affiche à l'écran. Le point positif dans ce scénario est que dès qu'un élément apparaît à l'écran, il est également interactif. ou presque…

Le [First Meaningful Paint][FMP] de la version non optimisée de PROXX est _techniquement_ [interactif][TTI], mais inutile pour l'utilisateur.

Une fois qu'environ 62 Ko de JS compressé ont été téléchargés et que le DOM a été généré, l'utilisateur peut voir notre application. L'application est techniquement interactive. Cependant, le visuel montre une réalité différente. Les polices Web sont toujours en cours de chargement en arrière-plan et, tant qu'elles ne sont pas prêtes, l'utilisateur ne peut pas voir le texte. Bien que cet état soit considéré comme un First Meaningful Paint (FMP), il n'est certainement pas considéré comme correctement interactif, car l'utilisateur ne peut pas savoir à quoi correspondent les entrées. Il faut une seconde de plus en 3G et trois secondes en 2G pour que l'application soit prête à l'emploi. En tout, l'application met six secondes en 3G et 11 secondes en 2G pour devenir interactive.

Analyse en cascade

Maintenant que nous savons ce que l'utilisateur voit, nous devons comprendre pourquoi. Pour cela, nous pouvons examiner le graphique en cascade et analyser pourquoi les ressources se chargent trop tard. Dans notre trace 2G pour PROXX, nous pouvons voir deux signaux d'alarme majeurs :

  1. Il y a plusieurs lignes fines multicolores.
  2. Les fichiers JavaScript forment une chaîne. Par exemple, la deuxième ressource ne commence à se charger qu'une fois la première ressource terminée, et la troisième ressource ne commence que lorsque la deuxième ressource est terminée.
Le graphique en cascade indique quelles ressources sont chargées, à quel moment et combien de temps cela prend.

Réduction du nombre de connexions

Chaque ligne fine (dns, connect, ssl) représente la création d'une connexion HTTP. La configuration d'une nouvelle connexion est coûteuse, car elle prend environ 1 s en 3G et environ 2,5 s en 2G. Dans notre cascade, nous voyons une nouvelle connexion pour :

  • Demande 1 : notre index.html
  • Requête 5 : Les styles de police de fonts.googleapis.com
  • Requête 8 : Google Analytics
  • Requête 9 : un fichier de police de fonts.gstatic.com
  • Requête 14 : fichier manifeste de l'application Web

La nouvelle connexion pour index.html est inévitable. Le navigateur doit créer une connexion à notre serveur pour obtenir le contenu. La nouvelle connexion pour Google Analytics pourrait être évitée en intégrant un élément tel que Minimal Analytics, mais Google Analytics n'empêche pas notre application d'afficher ou de devenir interactive. Nous ne nous soucions donc pas vraiment de la vitesse de chargement. Idéalement, Google Analytics doit être chargé pendant les temps d'inactivité, lorsque tout le reste a déjà été chargé. De cette façon, il n'occupera pas de bande passante ni de puissance de traitement lors du chargement initial. La nouvelle connexion pour le fichier manifeste de l'application Web est prescrite par la spécification de récupération, car le fichier manifeste doit être chargé via une connexion sans identifiants. Là encore, le fichier manifeste de l'application Web n'empêche pas l'affichage de notre application ni son interactivité. Nous n'avons donc pas à nous en soucier.

Cependant, les deux polices et leurs styles posent problème, car ils bloquent l'affichage et l'interactivité. Si nous examinons le CSS fourni par fonts.googleapis.com, il ne s'agit que de deux règles @font-face, une pour chaque police. Les styles de police sont si petits que nous avons décidé de les intégrer directement dans notre code HTML, ce qui nous a permis de supprimer une connexion inutile. Pour éviter le coût de la configuration de la connexion pour les fichiers de police, nous pouvons les copier sur notre propre serveur.

Paralléliser les chargements

En examinant le graphique en cascade, nous pouvons voir qu'une fois le premier fichier JavaScript chargé, de nouveaux fichiers commencent à se charger immédiatement. C'est le cas pour les dépendances de module. Notre module principal comporte probablement des importations statiques. Le code JavaScript ne peut donc pas s'exécuter tant que ces importations ne sont pas chargées. Il est important de comprendre que ces types de dépendances sont connus au moment de la compilation. Nous pouvons utiliser des balises <link rel="preload"> pour nous assurer que toutes les dépendances commencent à se charger dès que nous recevons notre code HTML.

Résultats

Voyons ce que nos modifications ont permis d'accomplir. Il est important de ne pas modifier d'autres variables de notre configuration de test qui pourraient fausser les résultats. Nous utiliserons donc la configuration simple de WebPageTest pour le reste de cet article et examinerons la pellicule :

Nous utilisons la pellicule de WebPageTest pour voir ce que nos modifications ont permis d'accomplir.

Ces modifications ont permis de réduire notre TTI de 11 à 8,5, ce qui correspond à peu près aux 2,5 secondes de temps de configuration de la connexion que nous voulions supprimer. Bravo à nous.

Prérendu

Bien que nous ayons réduit notre TTI, nous n'avons pas vraiment réduit la durée de l'écran blanc que l'utilisateur doit subir pendant 8,5 secondes. On peut dire que les améliorations les plus importantes pour le FMP peuvent être obtenues en envoyant un balisage stylisé dans votre index.html. Les techniques courantes pour y parvenir sont le prérendu et l'affichage côté serveur, qui sont étroitement liés et expliqués dans Affichage sur le Web. Ces deux techniques exécutent l'application Web dans Node et sérialisent le DOM obtenu au format HTML. Le rendu côté serveur effectue cette opération par requête, côté serveur, tandis que le prérendu effectue cette opération au moment de la compilation et stocke le résultat en tant que nouveau index.html. Comme PROXX est une application JAMStack et qu'elle n'a pas de côté serveur, nous avons décidé d'implémenter le prérendu.

Il existe de nombreuses façons d'implémenter un pré-rendu. Dans PROXX, nous avons choisi d'utiliser Puppeteer, qui démarre Chrome sans aucune interface utilisateur et vous permet de contrôler à distance cette instance avec une API Node. Nous l'utilisons pour injecter notre balisage et notre code JavaScript, puis pour lire le DOM sous forme de chaîne HTML. Comme nous utilisons des modules CSS, nous obtenons l'intégration CSS des styles dont nous avons besoin sans frais.

  const browser = await puppeteer.launch();
  const page = await browser.newPage();
  await page.setContent(rawIndexHTML);
  await page.evaluate(codeToRun);
  const renderedHTML = await page.content();
  browser.close();
  await writeFile("index.html", renderedHTML);

Une fois cette modification effectuée, nous pouvons nous attendre à une amélioration de notre FMP. Nous devons toujours charger et exécuter la même quantité de code JavaScript qu'auparavant. Nous ne devons donc pas nous attendre à ce que le TTI change beaucoup. En fait, notre index.html a augmenté et pourrait retarder un peu notre TTI. Il n'y a qu'une façon de le savoir : exécuter WebPageTest.

La pellicule montre une nette amélioration de notre métrique FMP. Le TTI n'est généralement pas affecté.

Notre First Meaningful Paint est passé de 8,5 secondes à 4,9 secondes, une amélioration considérable. Notre TTI est toujours d'environ 8,5 secondes.Il n'a donc pas été affecté par ce changement. Nous avons effectué ici un changement perceptuel. Certains pourraient même parler de tour de passe-passe. En affichant un visuel intermédiaire du jeu, nous améliorons la perception des performances de chargement.

Inlining

Une autre métrique fournie par DevTools et WebPageTest est le Time to First Byte (TTFB). Il s'agit du temps écoulé entre l'envoi du premier octet de la requête et la réception du premier octet de la réponse. Ce temps est également souvent appelé "délai aller-retour" (DAR), bien qu'il existe techniquement une différence entre ces deux nombres : le DAR n'inclut pas le temps de traitement de la requête côté serveur. DevTools et WebPageTest visualisent le TTFB avec une couleur claire dans le bloc de requête/réponse.

La section claire d'une requête signifie que la requête attend de recevoir le premier octet de la réponse.

En examinant notre graphique en cascade, nous pouvons voir que toutes les requêtes passent la majeure partie de leur temps à attendre l'arrivée du premier octet de la réponse.

C'est pour résoudre ce problème que la fonctionnalité Push de HTTP/2 a été conçue à l'origine. Le développeur d'applications sait que certaines ressources sont nécessaires et peut les transmettre. Lorsque le client se rend compte qu'il doit récupérer des ressources supplémentaires, celles-ci se trouvent déjà dans les caches du navigateur. La fonctionnalité Push de HTTP/2 s'est avérée trop difficile à implémenter correctement et est considérée comme déconseillée. Ce problème sera réexaminé lors de la standardisation de HTTP/3. Pour l'instant, la solution la plus simple consiste à intégrer toutes les ressources critiques au détriment de l'efficacité de la mise en cache.

Notre CSS critique est déjà intégré grâce aux modules CSS et à notre pré-rendu basé sur Puppeteer. Pour JavaScript, nous devons intégrer nos modules critiques et leurs dépendances. La difficulté de cette tâche varie en fonction du bundler que vous utilisez.

En intégrant notre code JavaScript, nous avons réduit notre TTI de 8,5 s à 7,2 s.

Cela a permis de réduire notre TTI d'une seconde. Nous avons maintenant atteint le point où notre index.html contient tout ce qui est nécessaire pour le rendu initial et pour devenir interactif. Le code HTML peut s'afficher pendant qu'il est encore en cours de téléchargement, ce qui crée notre FMP. Dès que l'analyse et l'exécution du code HTML sont terminées, l'application est interactive.

Division agressive du code

Oui, notre index.html contient tout ce dont nous avons besoin pour devenir interactif. Mais en y regardant de plus près, il s'avère qu'il contient également tout le reste. Notre index.html fait environ 43 Ko. Mettons cela en relation avec ce avec quoi l'utilisateur peut interagir au début : nous avons un formulaire pour configurer le jeu contenant quelques composants, un bouton de démarrage et probablement du code pour conserver et charger les paramètres utilisateur. C'est à peu près tout. 43 Ko, cela semble beaucoup.

Page de destination de PROXX. Seuls les composants essentiels sont utilisés ici.

Pour comprendre d'où vient la taille de notre bundle, nous pouvons utiliser un explorateur de mappage de sources ou un outil similaire pour décomposer le contenu du bundle. Comme prévu, notre bundle contient la logique du jeu, le moteur de rendu, l'écran de victoire, l'écran de défaite et un ensemble d'utilitaires. Seul un petit sous-ensemble de ces modules est nécessaire pour la page de destination. Déplacer tout ce qui n'est pas strictement requis pour l'interactivité dans un module à chargement différé réduira considérablement le TTI.

L'analyse du contenu du fichier "index.html" de PROXX révèle de nombreuses ressources inutiles. Les ressources critiques sont mises en évidence.

Pour cela, nous devons diviser le code. La division du code consiste à diviser votre bundle monolithique en parties plus petites qui peuvent être chargées de manière différée à la demande. Les bundlers populaires tels que Webpack, Rollup et Parcel sont compatibles avec la division du code à l'aide de import() dynamique. Le bundler analysera votre code et intégrera tous les modules importés statiquement. Tout ce que vous importez de manière dynamique sera placé dans son propre fichier et ne sera récupéré sur le réseau qu'une fois l'appel import() exécuté. Bien sûr, l'accès au réseau a un coût et ne doit être effectué que si vous avez du temps à y consacrer. Le principe est d'importer de manière statique les modules qui sont absolument nécessaires au moment du chargement et de charger tout le reste de manière dynamique. Toutefois, vous ne devez pas attendre le dernier moment pour charger de manière différée les modules qui seront certainement utilisés. Le modèle Idle Until Urgent de Phil Walton est un excellent compromis entre le chargement différé et le chargement hâtif.

Dans PROXX, nous avons créé un fichier lazy.js qui importe de manière statique tout ce dont nous n'avons pas besoin. Dans notre fichier principal, nous pouvons ensuite importer lazy.js de manière dynamique. Cependant, certains de nos composants Preact se sont retrouvés dans lazy.js, ce qui s'est avéré un peu compliqué, car Preact ne peut pas gérer les composants chargés de manière différée par défaut. C'est pourquoi nous avons écrit un petit wrapper de composant deferred qui nous permet d'afficher un espace réservé jusqu'à ce que le composant réel soit chargé.

export default function deferred(componentPromise) {
  return class Deferred extends Component {
    constructor(props) {
      super(props);
      this.state = {
        LoadedComponent: undefined
      };
      componentPromise.then(component => {
        this.setState({ LoadedComponent: component });
      });
    }

    render({ loaded, loading }, { LoadedComponent }) {
      if (LoadedComponent) {
        return loaded(LoadedComponent);
      }
      return loading();
    }
  };
}

Une fois cette opération effectuée, nous pouvons utiliser une promesse de composant dans nos fonctions render(). Par exemple, le composant <Nebula>, qui affiche l'image de fond animée, sera remplacé par un <div> vide pendant le chargement du composant. Une fois le composant chargé et prêt à être utilisé, <div> sera remplacé par le composant réel.

const NebulaDeferred = deferred(
  import("/components/nebula").then(m => m.default)
);

return (
  // ...
  <NebulaDeferred
    loading={() => <div />}
    loaded={Nebula => <Nebula />}
  />
);

Une fois toutes ces mesures en place, nous avons réduit notre index.html à seulement 20 Ko, soit moins de la moitié de la taille d'origine. Quel est l'impact sur le FMP et le TTI ? WebPageTest vous le dira !

La pellicule confirme que notre TTI est désormais de 5,4 s. Une amélioration considérable par rapport à nos 11 secondes d'origine.

Notre FMP et notre TTI ne sont séparés que de 100 ms, car il ne s'agit que d'analyser et d'exécuter le code JavaScript intégré. Après seulement 5,4 s sur un réseau 2G, l'application est entièrement interactive. Tous les autres modules, moins essentiels, sont chargés en arrière-plan.

Plus de tours de passe-passe

Si vous consultez notre liste de modules critiques ci-dessus, vous constaterez que le moteur de rendu n'en fait pas partie. Bien sûr, le jeu ne peut pas démarrer tant que nous n'avons pas de moteur de rendu pour l'afficher. Nous pourrions désactiver le bouton "Démarrer" jusqu'à ce que notre moteur de rendu soit prêt à lancer le jeu, mais d'après notre expérience, l'utilisateur met généralement suffisamment de temps à configurer les paramètres de son jeu pour que cela ne soit pas nécessaire. La plupart du temps, le moteur de rendu et les autres modules restants ont fini de se charger lorsque l'utilisateur appuie sur "Démarrer". Dans les rares cas où l'utilisateur est plus rapide que sa connexion réseau, nous affichons un simple écran de chargement qui attend que les modules restants se terminent.

Conclusion

Il est important de mesurer. Pour éviter de perdre du temps sur des problèmes qui n'en sont pas, nous vous recommandons de toujours mesurer avant d'implémenter des optimisations. De plus, les mesures doivent être effectuées sur des appareils réels avec une connexion 3G ou sur WebPageTest si aucun appareil réel n'est disponible.

La pellicule peut vous donner un aperçu de ce que l'utilisateur ressent lors du chargement de votre application. Le graphique en cascade peut vous indiquer quelles ressources sont responsables de temps de chargement potentiellement longs. Voici une checklist des actions que vous pouvez effectuer pour améliorer les performances de chargement :

  • Fournissez autant d'assets que possible via une seule connexion.
  • Préchargez ou intégrez les ressources nécessaires au premier rendu et à l'interactivité.
  • Prérendez votre application pour améliorer les performances de chargement perçues.
  • Utilisez la division du code de manière agressive pour réduire la quantité de code nécessaire à l'interactivité.

Restez à l'écoute pour la deuxième partie, où nous verrons comment optimiser les performances d'exécution sur les appareils hyper-contraints.