Rendimiento mejorado de carga de páginas de Next.js y Gatsby con fragmentación detallada

Una estrategia de fragmentación de webpack más reciente en Next.js y Gatsby minimiza el código duplicado para mejorar el rendimiento de la carga de página.

Chrome colabora con herramientas y frameworks en el ecosistema de código abierto de JavaScript. Recientemente, se agregaron varias optimizaciones nuevas para mejorar el rendimiento de carga de Next.js y Gatsby. En este artículo, se describe una estrategia mejorada de fragmentación detallada que ahora se incluye de forma predeterminada en ambos frameworks.

Introducción

Al igual que muchos frameworks web, Next.js y Gatsby usan webpack como su agrupador principal. webpack v3 introdujo CommonsChunkPlugin para permitir que se generen módulos compartidos entre diferentes puntos de entrada en un solo fragmento (o algunos) "común" (o fragmentos). El código compartido se puede descargar por separado y almacenar en la caché del navegador desde el principio, lo que puede mejorar el rendimiento de la carga.

Este patrón se volvió popular con muchos frameworks de aplicaciones de una sola página que adoptaron un punto de entrada y una configuración de paquete que se veía de la siguiente manera:

Configuración común de puntos de entrada y paquetes

Aunque es práctico, el concepto de agrupar todo el código del módulo compartido en un solo fragmento tiene sus limitaciones. Los módulos que no se comparten en cada punto de entrada se pueden descargar para las rutas que no los usan, lo que genera que se descargue más código del necesario. Por ejemplo, cuando page1 carga el fragmento common, carga el código para moduleC, aunque page1 no use moduleC. Por este motivo, junto con algunos otros, webpack v4 quitó el complemento y lo reemplazó por uno nuevo: SplitChunksPlugin.

División en fragmentos mejorada

La configuración predeterminada de SplitChunksPlugin funciona bien para la mayoría de los usuarios. Se crean varios fragmentos divididos según una serie de condiciones para evitar que se recupere código duplicado en varias rutas.

Sin embargo, muchos frameworks web que usan este complemento siguen un enfoque de "comunes únicos" para la división de fragmentos. Next.js, por ejemplo, generaría un paquete commons que contendría cualquier módulo que se use en más del 50% de las páginas y todas las dependencias del framework (react, react-dom, etcétera).

const splitChunksConfigs = {
  …
  prod: {
    chunks: 'all',
    cacheGroups: {
      default: false,
      vendors: false,
      commons: {
        name: 'commons',
        chunks: 'all',
        minChunks: totalPages > 2 ? totalPages * 0.5 : 2,
      },
      react: {
        name: 'commons',
        chunks: 'all',
        test: /[\\/]node_modules[\\/](react|react-dom|scheduler|use-subscription)[\\/]/,
      },
    },
  },

Aunque incluir código dependiente del framework en un fragmento compartido significa que se puede descargar y almacenar en caché para cualquier punto de entrada, la heurística basada en el uso de incluir módulos comunes que se usan en más de la mitad de las páginas no es muy eficaz. Modificar esta proporción solo generaría uno de los siguientes dos resultados:

  • Si reduces la proporción, se descargará más código innecesario.
  • Si aumentas la proporción, se duplicará más código en varias rutas.

Para resolver este problema, Next.js adoptó una configuración diferente para SplitChunksPlugin que reduce el código innecesario para cualquier ruta.

  • Cualquier módulo de terceros lo suficientemente grande (superior a 160 KB) se divide en su propio fragmento individual.
  • Se crea un fragmento frameworks independiente para las dependencias del framework (react, react-dom, etcétera).
  • Se crean tantos fragmentos compartidos como sea necesario (hasta 25).
  • El tamaño mínimo para que se genere un fragmento se cambia a 20 KB.

Esta estrategia de fragmentación detallada ofrece los siguientes beneficios:

  • Se mejoran los tiempos de carga de la página. Emitir varios fragmentos compartidos, en lugar de uno solo, minimiza la cantidad de código innecesario (o duplicado) para cualquier punto de entrada.
  • Se mejoró el almacenamiento en caché durante las navegaciones. Dividir las bibliotecas grandes y las dependencias de frameworks en fragmentos separados reduce la posibilidad de invalidación de la caché, ya que es poco probable que ambas cambien hasta que se realice una actualización.

Puedes ver toda la configuración que adoptó Next.js en webpack-config.ts.

Más solicitudes HTTP

SplitChunksPlugin definió la base para la fragmentación detallada, y aplicar este enfoque a un framework como Next.js no era un concepto completamente nuevo. Sin embargo, muchos frameworks siguieron usando una sola estrategia de paquete heurístico y "común" por algunas razones. Esto incluye la preocupación de que muchas más solicitudes HTTP puedan afectar negativamente el rendimiento del sitio.

Los navegadores solo pueden abrir una cantidad limitada de conexiones TCP a un solo origen (6 para Chrome), por lo que minimizar la cantidad de fragmentos que genera un empaquetador puede garantizar que la cantidad total de solicitudes se mantenga por debajo de este umbral. Sin embargo, esto solo se aplica a HTTP/1.1. La multiplexación en HTTP/2 permite que se transmitan varias solicitudes en paralelo con una sola conexión en un solo origen. En otras palabras, por lo general, no necesitamos preocuparnos por limitar la cantidad de fragmentos que emite nuestro empaquetador.

Todos los navegadores principales admiten HTTP/2. Los equipos de Chrome y Next.js querían ver si aumentar la cantidad de solicitudes dividiendo el paquete único de "commons" de Next.js en varios fragmentos compartidos afectaría el rendimiento de carga de alguna manera. Comenzaron midiendo el rendimiento de un solo sitio mientras modificaban la cantidad máxima de solicitudes paralelas con la propiedad maxInitialRequests.

Rendimiento de la carga de página con una mayor cantidad de solicitudes

En un promedio de tres ejecuciones de varias pruebas en una sola página web, los tiempos de load, inicio de renderización y First Contentful Paint se mantuvieron casi iguales cuando se varió el recuento máximo de solicitudes iniciales (de 5 a 15). Curiosamente, notamos una ligera sobrecarga de rendimiento solo después de dividir de forma agresiva en cientos de solicitudes.

Rendimiento de carga de página con cientos de solicitudes

Esto demostró que mantenerse por debajo de un umbral confiable (entre 20 y 25 solicitudes) lograba el equilibrio adecuado entre el rendimiento de carga y la eficiencia del almacenamiento en caché. Después de algunas pruebas de referencia, se seleccionó 25 como el recuento de maxInitialRequest.

Modificar la cantidad máxima de solicitudes que se realizan en paralelo generó más de un paquete compartido, y separarlos de forma adecuada para cada punto de entrada redujo significativamente la cantidad de código innecesario para la misma página.

Reducciones de la carga útil de JavaScript con un aumento de la fragmentación

Este experimento solo consistió en modificar la cantidad de solicitudes para ver si habría algún efecto negativo en el rendimiento de la carga de la página. Los resultados sugieren que establecer maxInitialRequests en 25 en la página de prueba fue óptimo porque redujo el tamaño de la carga útil de JavaScript sin ralentizar la página. La cantidad total de JavaScript que se necesitó para hidratar la página siguió siendo aproximadamente la misma, lo que explica por qué el rendimiento de la carga de la página no mejoró necesariamente con la cantidad reducida de código.

webpack usa 30 KB como tamaño mínimo predeterminado para que se genere un fragmento. Sin embargo, acoplar un valor de maxInitialRequests de 25 con un tamaño mínimo de 20 KB generó un mejor almacenamiento en caché.

Reducciones de tamaño con fragmentos detallados

Muchos frameworks, incluido Next.js, dependen del enrutamiento del cliente (controlado por JavaScript) para insertar etiquetas de script más recientes para cada transición de ruta. Pero ¿cómo predeterminan estos fragmentos dinámicos en el momento de la compilación?

Next.js usa un archivo de manifiesto de compilación del servidor para determinar qué fragmentos de salida usan los diferentes puntos de entrada. Para proporcionar esta información también al cliente, se creó un archivo de manifiesto de compilación abreviado del cliente para asignar todas las dependencias de cada punto de entrada.

// Returns a promise for the dependencies for a particular route
getDependencies (route) {
  return this.promisedBuildManifest.then(
    man => (man[route] && man[route].map(url => `/_next/${url}`)) || []
  )
}
Resultado de varios fragmentos compartidos en una aplicación de Next.js.

Esta estrategia de fragmentación detallada más reciente se lanzó por primera vez en Next.js detrás de una marca, donde se probó en una cantidad de usuarios pioneros. Muchos observaron reducciones significativas en el total de JavaScript que se usaba en todo el sitio:

Sitio web Cambio total de JS % de diferencia
https://www.barnebys.com/ -238 KB -23%
https://sumup.com/ -220 KB −30%
https://www.hashicorp.com/ -11 MB -71%
Reducciones del tamaño de JavaScript en todas las rutas (comprimido)

La versión final se envió de forma predeterminada en la versión 9.2.

Gatsby

Gatsby solía seguir el mismo enfoque de usar una heurística basada en el uso para definir módulos comunes:

config.optimization = {
  …
  splitChunks: {
    name: false,
    chunks: `all`,
    cacheGroups: {
      default: false,
      vendors: false,
      commons: {
        name: `commons`,
        chunks: `all`,
        // if a chunk is used more than half the components count,
        // we can assume it's pretty global
        minChunks: componentsCount > 2 ? componentsCount * 0.5 : 2,
      },
      react: {
        name: `commons`,
        chunks: `all`,
        test: /[\\/]node_modules[\\/](react|react-dom|scheduler)[\\/]/,
      },

Cuando optimizaron su configuración de webpack para adoptar una estrategia de fragmentación detallada similar, también notaron reducciones considerables de JavaScript en muchos sitios grandes:

Sitio web Cambio total de JS % de diferencia
https://www.gatsbyjs.org/ -680 KB -22%
https://www.thirdandgrove.com/ -390 KB 25%
https://ghost.org/ -1.1 MB -35%
https://reactjs.org/ -80 Kb -8%
Reducciones del tamaño de JavaScript en todas las rutas (comprimido)

Echa un vistazo a la PR para comprender cómo implementaron esta lógica en su configuración de webpack, que se envía de forma predeterminada en la versión 2.20.7.

Conclusión

El concepto de enviar fragmentos detallados no es específico de Next.js, Gatsby ni webpack. Todos deberían considerar mejorar la estrategia de fragmentación de su aplicación si sigue un enfoque de paquete "común" grande, independientemente del framework o del agrupador de módulos que se use.

  • Las mismas optimizaciones de fragmentación también se pueden aplicar a una aplicación de React básica con una versión simplificada de la estrategia de fragmentación detallada en su configuración de webpack, lo que puede ayudarte a comenzar a aplicar el mismo tipo de lógica a tu sitio.
  • En Rollup, los fragmentos se crean de forma detallada de forma predeterminada. Consulta manualChunks si quieres configurar el comportamiento de forma manual.