Rendimiento y Monitoreo de GraphQL

Rate this content
Bookmark

GraphQL abstrae las llamadas a la API de aguas abajo desde el frontend y todo lo que el frontend tiene que hacer es solicitar campos en una consulta que son necesarios para la representación del componente. El frontend no sabe que un campo correspondiente puede resultar en una llamada a la API o en cálculos pesados en el lado del backend. Esta abstracción afecta el rendimiento cuando el esquema de GraphQL no está estructurado correctamente. Veamos un ejemplo para entender más:

Aquí está la consulta para obtener las habitaciones disponibles para un hotel:

hotel (id: $hotelId) id rooms id type name

El frontend no sabe que el campo rooms dentro de la consulta hotel disparará otra llamada a la API incluso si el campo type se obtendrá de otro punto final de la API. Estas llamadas anidadas a la API empeoran el rendimiento si hay más habitaciones. Podemos resolver esto de manera efectiva estructurando bien el esquema y usando cargadores de datos.

32 min
09 Dec, 2021

Video Summary and Transcription

Esta Charla explora las implicaciones de rendimiento de usar GraphQL en un sistema de gestión de propiedades hoteleras. Se discute la optimización de las llamadas a la API de GraphQL, el diseño del esquema y el almacenamiento en caché utilizando Data Loader. El uso de consultas automáticas persistidas y almacenamiento en caché puede mejorar el rendimiento. También se aborda el impacto del tamaño de respuesta y la paginación en las consultas de GraphQL. Además, la Charla enfatiza la importancia de monitorear y probar las consultas, así como mejorar el rendimiento percibido a través de comentarios visuales.

Available in English

1. Introducción a la rendimiento y monitoreo de GraphQL

Short description:

Hablaré sobre el rendimiento y monitoreo de GraphQL. Entenderemos las implicaciones de usar GraphQL utilizando un caso de uso simple de un sistema de gestión de propiedades de hotel. Veamos las llamadas HTTP que tendrías que hacer desde el cliente frontend para renderizar esta interfaz de usuario y mostrar la lista de reservas en este hotel.

Hola a todos. Mi nombre es Ankita Masand. Soy una Arquitecta Asociada en Treebo. Trabajo en el producto SaaS de Treebo llamado Hotel Superhero. Hotel Superhero es un sistema de gestión de propiedades de hotel basado en la nube utilizado por varias cadenas hoteleras en todo el mundo. Proporciona una serie de funciones para crear, gestionar reservas, generar facturas, varios informes, configurar precios de habitaciones en un hotel. Hemos estado utilizando ampliamente GraphQL para esta aplicación.

Hoy hablaré sobre el rendimiento y monitoreo de GraphQL. Como lista de temas que veremos en esta charla, las implicaciones de rendimiento de usar GraphQL en el stack, el diseño de esquemas GraphQL, el agrupamiento y la caché a nivel de solicitud utilizando Data Loaders, la carga perezosa de algunos campos y la transmisión de respuestas en una consulta GraphQL utilizando las nuevas directivas diff y stream, la caché en GraphQL, y finalmente, el monitoreo de consultas GraphQL utilizando New Relic. Empecemos.

Entenderemos las implicaciones de usar GraphQL utilizando un caso de uso simple de un sistema de gestión de propiedades de hotel. Lo que ves en la pantalla es una representación del Big Bank Hotel. Tiene tres tipos de habitaciones, tipo de habitación 1, 2 y 3. 1A, 1B, 1C son las habitaciones para el tipo de habitación 1 y las reservas como las casillas en blanco indican reservas para habitaciones específicas. La reserva 1 y la reserva 2 son para la habitación 1A. La casilla más grande indica que la reserva se extiende durante más días.

¿Qué se necesita para renderizar esta interfaz de usuario utilizando un cliente frontend? Esta es una vista que un hotelero ve en una pantalla para comprender y gestionar las reservas de su hotel. Veamos las llamadas HTTP que tendrías que hacer desde el cliente frontend para renderizar esta interfaz de usuario y mostrar la lista de reservas en este hotel. Primero haremos llamadas paralelas para obtener datos del hotel como el nombre y la ubicación. Luego haremos una llamada para obtener los tipos de habitaciones, las habitaciones, las reservas. Y una vez que obtengamos una lista de reservas de los servicios de terceros, haremos llamadas para obtener las facturas. Porque cada reserva está asociada con una factura y también hay algunos archivos adjuntos en una reserva que tenemos que mostrar en esa interfaz de usuario. Así que por cada reserva obtendremos su factura correspondiente y los archivos adjuntos. Cada reserva se realiza para un usuario específico. Luego llamaremos a la API del usuario para obtener más detalles sobre ese usuario y también sus preferencias. Esto parece bien. Y no hay demasiadas llamadas. Así que esto es algo a lo que estamos acostumbrados. Estas son las llamadas a la API solo cuando hay tres reservas en un hotel. Si has observado con atención, estábamos obteniendo la API de facturas tres veces, lo que significa que hay tres reservas en un hotel.

2. Implicaciones de rendimiento al usar GraphQL

Short description:

Un hotel no puede permitirse un sistema de gestión de propiedades para gestionar tres reservas. Estábamos en la etapa inicial de construcción de esta aplicación y parecía bien experimentar con GraphQL y ver cómo resultaba. GraphQL proporcionaría la respuesta en una sola llamada a la API, no hay múltiples viajes de ida y vuelta al servidor. Es declarativo por naturaleza y el cliente especifica los datos que necesita, lo que reduce considerablemente el tamaño de la respuesta. Veamos la consulta de GraphQL que estamos utilizando para obtener colectivamente la respuesta de todas las llamadas a la API. Esto es genial porque no tenemos que escribir código en el lado del frontend para gestionar cuándo disparar API específicas. Entonces, ¿cuáles son las implicaciones de rendimiento al usar GraphQL? Después de todo el trabajo duro, sentimos que el rendimiento de la aplicación no mejoró mucho para reservas más grandes.

Un hotel no puede permitirse un sistema de gestión de propiedades para gestionar tres reservas. ¿Qué sucedería si hay cientos de reservas en un hotel? Así que tendríamos que hacer 100 llamadas a la API para obtener facturas, archivos adjuntos. Habría demasiados viajes de ida y vuelta desde el cliente del frontend al servidor. ¿Cómo resolvemos estos problemas?

Estábamos en la etapa inicial de construcción de esta aplicación y parecía bien experimentar con GraphQL y ver cómo resultaba. GraphQL proporcionaría la respuesta en una sola llamada a la API, no hay múltiples viajes de ida y vuelta al servidor. Es declarativo por naturaleza y el cliente especifica los datos que necesita y, por lo tanto, se reduce considerablemente el tamaño de la respuesta. No hay código repetido para diferentes aplicaciones de frontend. Y lo más importante de todo, tiene un sistema de tipos sólido. La presentación fue muy bien y el equipo de frontend tuvo la oportunidad de experimentar con GraphQL y agregarlo al stack.

Veamos la consulta de GraphQL que estamos utilizando para obtener colectivamente la respuesta de todas las llamadas a la API. Si observas, hay una consulta Hotel por ID. Dentro de HotelporID, estamos obteniendo tipos de habitaciones. Para cada tipo de habitación, estamos obteniendo habitaciones. También estamos obteniendo reservas en la misma consulta. Y dentro de las reservas, estamos obteniendo facturas. Factura para cada reserva, archivos adjuntos, clientes. Y para cada cliente, estamos obteniendo sus preferencias. Veamos cómo se resolvería cada una de estas consultas en el servidor de GraphQL. Para resolver la consulta HotelporID, hacemos una llamada al servicio de aguas abajo para obtener los detalles de un hotel. Para resolver los tipos de habitaciones, hacemos una llamada para obtener los tipos de habitaciones de un servicio de aguas abajo. Y para cada tipo de habitación, obtenemos habitaciones. Esta es la llamada que hacemos para obtener las reservas. Y para cada reserva, hacemos una llamada para obtener su factura correspondiente, archivos adjuntos, clientes, y para cada cliente, hacemos una llamada para obtener sus preferencias.

Esto es genial porque no tenemos que escribir código en el lado del frontend para gestionar cuándo disparar API específicas. Como Bill depende de la reserva. Una vez que obtengamos la respuesta de las reservas, solo entonces podemos disparar las API de Bill. Tampoco tenemos que ejecutar mapas en el frontend para mapear tipos de habitaciones a habitaciones, habitaciones a reservas, reservas a Bill. GraphQL hace todo eso. Entonces, ¿cuáles son las implicaciones de rendimiento al usar GraphQL? Después de todo el trabajo duro, sentimos que el rendimiento de la aplicación no mejoró mucho para reservas más grandes. Reservas que se extienden durante más días que tienen más clientes.

3. Optimización de las llamadas a la API de GraphQL

Short description:

En una consulta de GraphQL, realizamos múltiples llamadas a la API para obtener los datos necesarios para la interfaz de usuario. Esto puede resultar en un gran número de llamadas a servicios de terceros, especialmente cuando se trata de varios tipos de habitaciones, habitaciones, reservas y usuarios. Para optimizar el rendimiento, debemos reconsiderar cómo estructuramos nuestro esquema de GraphQL y las llamadas a la API. En lugar de obtener datos que no son inmediatamente necesarios, solo debemos recuperar la información esencial. Al alinear el esquema de GraphQL con el modelo de dominio y los requisitos de la interfaz de usuario, podemos reducir el número de llamadas a la API y mejorar el rendimiento general.

O para hoteles que tienen más tipos de habitaciones y más habitaciones. Entonces veamos una lista de llamadas a la API que estamos haciendo a los servicios de terceros. Consideremos un ejemplo de 25 reservas. Por ejemplo, en esa consulta, estamos obteniendo 25 reservas. Haremos una llamada para obtener los detalles de un hotel, una llamada para obtener los tipos de habitaciones. Digamos que devuelve seis tipos de habitaciones. Ahora, para cada tipo de habitación, obtendremos su habitación correspondiente. Por lo tanto, haremos seis llamadas a la API de habitaciones, una llamada para obtener las reservas. Esta API devuelve 25 reservas. Por eso haremos 25 llamadas para obtener las facturas y 25 llamadas para obtener los archivos adjuntos, que son para cada reserva. En total, hay 100 usuarios en todas estas reservas. Una reserva puede tener varios usuarios. Por lo tanto, haremos 100 llamadas para obtener los detalles del usuario, 100 llamadas para obtener sus preferencias. En total, hay 259 llamadas que tenemos que hacer para obtener 225 reservas y mostrarlo en la interfaz de usuario.

Sí, tenemos que hacer 259 llamadas a los servicios de terceros para resolver solo una consulta de GraphQL. ¿Qué sucedería si hay más tipos de habitaciones y habitaciones en un hotel? El número de llamadas a la API seguiría aumentando en función del número de tipos de habitaciones, habitaciones, reservas, y el número de usuarios en estas reservas. ¿Cómo solucionamos esto? Analicemos lo que realmente estamos haciendo en esta consulta. Estamos obteniendo la respuesta completa en una consulta de GraphQL, incluyendo a los usuarios y sus preferencias. Estamos obteniendo los tipos de habitaciones dentro del objeto de hotel, lo cual está bien. Pero para cada tipo de habitación, estamos llamando a la API de habitaciones para obtener las habitaciones porque esta es la estructura que espera la interfaz de usuario. Estamos haciendo esto porque no tenemos que ejecutar bucles en el frontend para obtener el objeto completo mapeado tal como lo requiere la interfaz de usuario. Estamos obteniendo las facturas dentro del objeto de reserva, lo que significa que llamaremos a la API de facturas para cada reserva. No tenemos que mostrar las preferencias del usuario al cargar. ¿Por qué obtenerlo y hacer la llamada inicial y mostrar un estado de carga al usuario? Esto no es justo para el usuario porque ni siquiera le importa ver las preferencias del usuario desde el principio. ¿Cómo solucionamos estos problemas? Entonces, ¿debería el esquema de GraphQL mapear uno a uno con su interfaz de usuario o con sus modelos de dominio? Si observas detenidamente, estamos obteniendo los tipos de habitaciones dentro del objeto de hotel porque los tipos de habitaciones son una propiedad de un hotel, lo cual está bien. Pero estamos obteniendo las habitaciones dentro de cada uno de estos tipos de habitaciones. Las habitaciones no son una propiedad de un tipo de habitación. Las habitaciones son una propiedad de un hotel. El modelo de dominio considera que las habitaciones son una propiedad de un hotel y no de un tipo de habitación. Estamos haciendo esto porque así es como la interfaz de usuario que estamos tratando de construir lo espera.

4. Optimización del esquema de GraphQL con Data Loader

Short description:

Debemos diseñar nuestro esquema de GraphQL de manera similar a nuestro modelo de dominio para satisfacer a diferentes clientes de frontend. El uso de Data Loader para agrupar y almacenar en caché puede reducir significativamente las llamadas a la API a servicios externos. Data Loader recopila las solicitudes de API dentro de un solo marco de ejecución y realiza llamadas de API en lote. Esto reduce el número de llamadas de 259 a 8 para obtener 25 reservas. Implementar Data Loader en el servidor de GraphQL no es difícil.

¿En qué nivel de la consulta deberíamos obtener las habitaciones? Deberíamos intentar diseñar nuestro esquema de GraphQL de manera similar a nuestro modelo de dominio, porque si lo diseñas basándote en tu interfaz de usuario, solo podrás satisfacer un caso de uso de tus clientes de frontend. Y el esquema de GraphQL debe diseñarse de manera robusta para que pueda ser utilizado por diferentes clientes de frontend.

El campo de habitaciones debería ser una propiedad del hotel y no de los tipos de habitaciones. Sigamos adelante. Aquí estamos obteniendo las preferencias dentro del objeto de usuario, y las preferencias son una propiedad de un usuario. Así es como también lo espera el modelo de dominio.

¿Cómo solucionamos este problema de múltiples llamadas a la API para el campo de preferencias del usuario, aunque esté mapeado correctamente? Aquí viene la parte interesante de la charla, agrupación y almacenamiento en caché utilizando Data Loader. Solo podrás entender la importancia de los data loaders, si has visto múltiples llamadas a tus servicios externos para resolver una sola consulta de GraphQL.

Data Loader básicamente recopila la solicitud de API dentro de un solo marco de ejecución. Lo que ves en la pantalla es el número de llamadas a la API antes de usar los data loaders, que es de 259 a los servicios externos. Ahora se reduce a dos llamadas a los servicios externos. ¿Cómo sucedió esto? Data Loader no realiza llamadas a la API de inmediato a los servicios externos. Recopilará todas las solicitudes de API y luego, dentro de un solo marco de ejecución, realizará una llamada de API en lote. Por ejemplo, para resolver cada factura, estábamos llamando a la API de facturas 25 veces. Aquí, si observas, esto es una llamada en lote. Data Loader está recopilando todos los ID de facturas y solo realizará una llamada a los servicios externos. Lo mismo ocurre con los archivos adjuntos, los ID de usuario y también con las preferencias. Por lo tanto, si cuentas esto, solo hay ocho llamadas que debes hacer a los servicios externos para obtener 25 reservas. Data Loader es una gran adición a la pila y no es muy difícil de implementar en el servidor de GraphQL.

Esto crea magia al reducir las 259 llamadas a los servicios externos a solo ocho y esto es un gran impulso para el rendimiento de tus aplicaciones. Veamos la implementación del cargador de facturas y el cargador de usuarios. Entonces, el cargador de facturas, esto toma algunas claves como los ID de las facturas y luego llama al cargador de facturas. Veremos la implementación de la función del cargador de facturas en un momento. Debes devolver estos data loaders desde los objetos de contexto para que estén disponibles en todos los resolutores. Así es como se ve una función del cargador de facturas. Recopila todos los ID de facturas dentro de un solo marco de ejecución y luego llama al servicio externo solo una vez. Devolverá una matriz de facturas. Entonces, desde tu resolutor, debes escribir cargador de facturas punto cargar. Este es el primer ID de factura, segundo ID de factura, todas estas facturas son diferentes, pero un servidor de GraphQL no llamará a la API de facturas de inmediato. Recopilará todos estos ID de facturas y luego realizará esta llamada agrupada de una vez.

5. Optimización de las llamadas a la API y aplazamiento de la ejecución

Short description:

Lo mismo ocurre con los usuarios. La agrupación mejora el rendimiento al reducir las llamadas a la API. Los Data Loaders ayudan a almacenar en caché las respuestas para solicitudes posteriores. Mediante una función agrupada UserProfileLoader, podemos obtener perfiles de usuario con menos llamadas a la API. Al aplazar la ejecución de campos no críticos, como las preferencias del usuario, podemos mejorar el rendimiento y cargar datos de forma asíncrona sin bloquear la vista principal.

Lo mismo ocurre con los usuarios. Esta es la API Badged que podemos usar para los usuarios y estos son todos usuarios diferentes, pero solo llamaríamos a la API secundaria una vez. La agrupación realmente mejora y ayuda mucho a mejorar el rendimiento de la aplicación.

Veamos cómo los Data Loaders ayudan en el almacenamiento en caché a nivel de solicitud. Si estás llamando a la misma clave, juguetes en un Data Loader en la misma solicitud, las respuestas posteriores se buscarían en la caché. Entendamos esto con la ayuda de un ejemplo.

Aquí tienes una consulta de GraphQL que estamos utilizando para obtener conferencias de JavaScript. Estamos obteniendo el nombre, la ubicación, los oradores de esa conferencia, sus charlas y el perfil de cada orador. Bob está hablando en cuatro conferencias, lo que significa que sin los Data Loaders, obviamente su perfil se obtendría cuatro veces, aunque tenga el mismo ID de perfil de usuario. Pero si usas Data Loaders para obtener este perfil de usuario, las llamadas posteriores para su perfil se servirían desde la caché.

Veamos la implementación. Esta es una función agrupada UserProfileLoader. Recopilará las claves y luego llamará a los servicios secundarios. Si ves userprofile.load, este es el mismo ID de usuario, ¿verdad? Este es el ID de usuario de Bob. En la primera llamada, llamaremos a los servicios secundarios. Estas son todas las mismas llamadas a la API. Por lo tanto, solo llamará a los servicios secundarios una vez. Perfecto. Parece que hemos logrado solucionar el desastre de las múltiples llamadas a la API mediante la agrupación y el almacenamiento en caché. Obviamente, se reducen las 259 llamadas a solo ocho. ¿Podemos hacer más? ¿Podemos mejorar aún más?

Si te has dado cuenta, el campo de preferencias en el objeto de usuario no está en el camino crítico de la interactividad de la interfaz de usuario. ¿Podemos aplazar la ejecución del resolvedor de preferencias de usuario? Sí, podemos. Podemos usar directivas diferidas para aplazar la ejecución del resolvedor de preferencias de usuario. Veamos cómo lo haríamos. Todo lo que tenemos que hacer es agregar la directiva diferida al campo de preferencias en tu consulta. La respuesta que obtendríamos, por lo tanto, las preferencias serían nulas en la respuesta inicial hasta que GraphQL las resuelva en el lado posterior. Y en la misma conexión HTTP, obtendríamos la respuesta de las preferencias como parches. Lo que ves aquí es la respuesta del objeto de reservas uno, clientes uno, y estas son las preferencias de ese cliente en particular. Las preferencias se cargarían de forma asíncrona en la interfaz de usuario, y no bloquearían la vista principal. Lo que hemos estado pensando hasta ahora es que las solicitudes se resuelven en una respuesta.

6. Optimización de las solicitudes GraphQL y almacenamiento en caché

Short description:

Enviamos una solicitud a un servidor GraphQL, te suscribes a un observable, la misma conexión HTTP sigue abierta y el servidor GraphQL sigue enviando respuestas y parches según la ejecución de los campos. Supongamos que tienes cien reservas para un hotel en particular. No quieres obtener todas las cientos de reservas en la misma consulta, ni siquiera podrías mostrar todas esas reservas en la vista del usuario. Los tipos de habitaciones y los números de habitación no cambian con frecuencia. Podemos almacenar en caché datos estáticos que no dependen de la identidad del usuario en Redis o Memcache durante algún tiempo fijo. Aunque los tipos de habitaciones y los campos de habitación no cambian con tanta frecuencia, seguimos consultando al servidor GraphQL. ¿Es posible obtener esta respuesta desde el servidor CDN más cercano sin tener que consultar al servidor GraphQL? Sí, estamos hablando de una solicitud GET aquí. El primer hito que debemos alcanzar es convertir POST en una solicitud GET. Podemos hacerlo utilizando consultas automáticas persistentes y es muy sencillo de implementar.

Entonces enviamos una solicitud en la conexión HTTP a un servidor GraphQL. El servidor GraphQL resuelve todos los campos en una consulta y envía la respuesta. Es fácil de entender si lo imaginas de esta manera.

Enviamos una solicitud a un servidor GraphQL, te suscribes a un observable, la misma conexión HTTP sigue abierta y el servidor GraphQL sigue enviando respuestas y parches según la ejecución de los campos. Veamos también cómo usaríamos los directores de transmisión.

Supongamos que tienes cien reservas para un hotel en particular. No quieres obtener todas las cientos de reservas en la misma consulta, ni siquiera podrías mostrar todas esas reservas en la vista del usuario. Entonces, en esta consulta le estamos diciendo a GraphQL que por favor nos envíe 10 reservas y transmita el resto de las reservas como parches en la misma conexión HTTP. Obtendremos 10 reservas en la respuesta inicial y las reservas posteriores se servirán como parches.

Todo esto funciona bien para una sola solicitud, pero hay algo importante que hemos pasado por alto. Los tipos de habitaciones y los números de habitación no cambian con frecuencia. ¿Podemos hacer algo al respecto? Veamos qué es el almacenamiento en caché a nivel de resolutor.

Podemos almacenar en caché datos estáticos que no dependen de la identidad del usuario en Redis o Memcache durante algún tiempo fijo. Los tipos de habitaciones y los campos de habitación de un hotel son estáticos y serán los mismos para todos los usuarios. Este es un buen ejemplo de almacenamiento en caché a nivel de resolutor. Veamos cómo lo haríamos.

Cuando un cliente de frontend solicita una consulta de reservas de hotel al servidor GraphQL. Mientras resolvemos los tipos de habitaciones, primero verificamos si los tipos de habitaciones están presentes en la caché de Redis. Si está presente, lo serviremos directamente desde la caché. Si no está presente, consultaremos al servidor de aguas abajo, almacenaremos la respuesta en Redis y luego la enviaremos de vuelta. Lo mismo ocurre con el resolutor de habitaciones. Verificaremos si las habitaciones están presentes en la caché de Redis. Si está presente, lo serviremos directamente desde la caché. De lo contrario, consultaremos al servicio de aguas abajo y almacenaremos la respuesta en Redis y luego la enviaremos de vuelta al resolutor.

Aquí, aunque los tipos de habitaciones y los campos de habitación no cambian con tanta frecuencia, seguimos consultando al servidor GraphQL. ¿Es posible obtener esta respuesta desde el servidor CDN más cercano sin tener que consultar al servidor GraphQL? Sí, estamos hablando de una solicitud GET aquí. En GraphQL, siempre hacemos una solicitud POST. Esto se debe a que enviamos la cadena de consulta a GraphQL como carga útil de la solicitud POST porque no se ajusta bien en una solicitud GET que se puede almacenar en caché. Entonces, el primer hito que debemos alcanzar es convertir POST en una solicitud GET. ¿Cómo lo hacemos? Podemos hacerlo utilizando consultas automáticas persistentes y es muy sencillo de implementar.

7. Consultas automáticas persistentes y almacenamiento en caché

Short description:

Con consultas automáticas persistentes, podemos enviar el hash de la cadena de consulta en una solicitud GET HTTP al servidor Apollo o al servidor GraphQL. Esto nos permite aprovechar los encabezados de control de caché y mejorar el rendimiento. Podemos utilizar el almacenamiento en caché por solicitud, el almacenamiento en caché a nivel de resolutor y los encabezados de control de caché en diferentes campos de la consulta. Una pregunta a considerar es si GraphQL admite el código de estado de respuesta HTTP 304 no modificado.

Con consultas automáticas persistentes, enviamos el hash de la cadena de consulta en una solicitud GET HTTP al servidor Apollo o al servidor GraphQL. Luego, el servidor determina que este hash en particular corresponde a esta cadena de consulta en particular. Resolverá esa consulta y enviará la respuesta de vuelta en el mismo formato de respuesta que el cliente esperaría. Así que aquí hemos logrado este objetivo de enviar una solicitud GET HTTP desde el cliente de frontend utilizando GraphQL.

¿Y ahora qué sigue? Una vez que podemos enviar una solicitud GET, lo que significa que podemos aprovechar todos los encabezados de control de caché disponibles. Podemos especificar la edad máxima de un campo en una consulta para el cual este campo en particular es válido. Y está bien resolver este campo desde el servicio CDN más cercano en lugar de golpear los servidores GraphQL. Sí, podemos aprovechar todos los encabezados de control de caché. Y esto mejoraría aún más el rendimiento.

Repasemos todo lo que aprendimos sobre el almacenamiento en caché. Aprendimos que podemos hacer almacenamiento en caché por solicitudes utilizando cargadores de datos. Podemos hacer almacenamiento en caché a nivel de resolutor para almacenar la respuesta de los servicios de aguas abajo en Redis o Memcache. Podemos utilizar consultas automáticas persistentes para enviar el hash de la cadena de consulta a GraphQL. Y podemos utilizar encabezados de control de caché en diferentes campos de la consulta. Hay una pregunta para reflexionar. Ahora que estamos utilizando una solicitud GET, ¿puede GraphQL admitir el código de estado de respuesta HTTP 304 no modificado? Pasaré al siguiente tema, que es monitorear las solicitudes de GraphQL en New Relic.

8. Detalles del seguimiento de consultas GraphQL

Short description:

Esta es una herramienta poderosa que proporciona detalles de seguimiento de consultas GraphQL, lo que nos permite identificar campos que consumen mucho tiempo y su impacto en el rendimiento.

Esto es realmente interesante. Y es una gran adición al conjunto de herramientas. Lo que ves en la captura de pantalla, son las 20 consultas GraphQL más lentas. También puedes ver el tiempo de respuesta promedio más lento, el tiempo de respuesta promedio más lento, las 20 consultas GraphQL principales. Puedes ver los tiempos P95, P99 de una consulta GraphQL en particular utilizando esta herramienta poderosa. La fuente de esta captura de pantalla, son las llamadas que estás haciendo a servicios externos, el porcentaje de llamadas que estás haciendo a tus diferentes microservicios.

Esto muestra los detalles de seguimiento de una consulta GraphQL. Entonces, cada vez que hay un nuevo requisito o una nueva característica en el cliente de frontend, todo lo que pensamos es que tenemos que agregar este campo en particular en una consulta y listo. Obtendríamos la respuesta y la mostraríamos en la interfaz de usuario. Ni siquiera pensamos que este campo en particular va a realizar una llamada a la API a un servicio aguas abajo o va a golpear la base de datos. Y eso afectaría el rendimiento de esta consulta en particular. Entonces, al ver estos detalles de seguimiento, nos damos cuenta de que este campo en particular tarda tanto tiempo en resolverse o este campo en particular golpea el servidor backend. Este campo en particular realiza, este campo en particular está golpeando tu base de datos. Entonces, al ver este seguimiento, al ver los detalles de seguimiento de una consulta en particular, es muy fácil entender qué está consumiendo tiempo en esta consulta GraphQL.

9. Analizando el rendimiento de GraphQL y los resultados de la encuesta

Short description:

Al analizar los detalles de seguimiento de una consulta GraphQL, podemos identificar fácilmente las partes que consumen mucho tiempo. En resumen, las consultas más grandes y anidadas pueden afectar el rendimiento. Debemos tener en cuenta la cantidad de solicitudes a la API y consultas a la base de datos que se realizan en una consulta GraphQL. Diseñar el esquema de GraphQL basado en el modelo de dominio, utilizar cargadores de datos para agrupar y almacenar en caché, diferir campos no críticos y aprovechar las consultas persistentes automáticas puede optimizar el rendimiento. Además, New Relic proporciona detalles valiosos de seguimiento para las consultas GraphQL.

Entonces, al analizar este seguimiento, al analizar los detalles de seguimiento de una consulta en particular, es muy fácil entender qué está consumiendo tiempo en esta consulta GraphQL.

Resumamos todo lo que aprendimos en esta charla. Los clientes pueden experimentar una disminución del rendimiento para consultas más grandes y más anidadas en GraphQL. Debemos estar atentos a la cantidad de solicitudes a la API o consultas a la base de datos que realizamos en una consulta GraphQL.

Debemos diseñar el esquema de GraphQL de manera más acorde a nuestro dominio y no mapearlo a la interfaz de usuario del frontend. Los cargadores de datos se utilizan para agrupar múltiples llamadas a la API al mismo punto final en una sola solicitud y así reducir la carga en tus servicios aguas abajo, como vimos para las API de facturas y usuarios. Los cargadores de datos también ayudan a almacenar en caché la misma solicitud a la API y llamar al servicio aguas abajo solo una vez para la misma clave de caché. Vimos que Bob, Bob habló en cuatro conferencias pero solo cargamos su perfil una vez porque su ID de perfil de usuario es el mismo.

Podemos utilizar diferentes directivas para diferir la respuesta de algunos campos en una consulta que no están en el camino crítico de la interactividad del usuario, que tardan más tiempo en resolverse o tienen un tamaño de respuesta más grande. Vimos que podemos diferir la ejecución del resolvedor de preferencias en un objeto de usuario. Podemos utilizar directivas de transmisión para transmitir la respuesta del campo de lista en una consulta. Podemos utilizar Redis o Memcached para almacenar en caché la respuesta de los servicios aguas abajo a nivel de resolvedor. Vimos que no es necesario llamar a los servicios backend para obtener datos estáticos como tipos de habitaciones y habitaciones de un hotel. Podemos obtenerlos directamente de Redis o Memcached. Por último, podemos utilizar consultas persistentes automáticas y realizar solicitudes GET desde el cliente del frontend a los servidores GraphQL. Aquí enviamos el hash de la consulta en una solicitud GET al servidor GraphQL. Utilizando esto, podemos aprovechar todas las cabeceras de control de caché especificando el TTL para algunos de los campos en esa consulta. Y luego podemos obtenerlos desde el servidor CDN más cercano. Por último, New Relic nos facilita la vida y muestra los detalles de seguimiento de una consulta GraphQL en particular. Realmente es una buena adición al conjunto de herramientas. Muchas gracias por escuchar. Que tengas un excelente día.

Entonces, al ver los resultados de la encuesta, solo como recordatorio, la pregunta fue si GraphQL admite un código de estado de respuesta 403. Y el 50% dice que no. Y luego entre sí y no estoy seguro, la división es del 25 al 25. Bueno, avísanos cuál es tu respuesta. Sí. Entonces es el código de estado de respuesta 304. Permíteme explicar qué es el código de estado de respuesta 304. Significa que es una respuesta de no modificada.

10. GraphQL y el código de estado de respuesta 304

Short description:

GraphQL no admite el código de estado de respuesta 304. A diferencia de REST, GraphQL recupera múltiples entidades en una sola consulta, por lo que no tiene sentido enviar una respuesta 304 para toda la consulta. Sin embargo, se pueden utilizar cabeceras de control de caché para optimizar el almacenamiento en caché. Actualmente, GraphQL siempre envía una respuesta 200, incluso si ninguno de los campos en la consulta ha cambiado.

Eso significa que una entidad en particular que estás solicitando al servidor no ha sido modificada desde la última vez que la solicitaste. Lo cual significa, digamos, consideremos un ejemplo de una API REST. Estás solicitando una entidad en particular y ya tienes, digamos, la versión uno de esa entidad en tu cliente y la estás solicitando nuevamente, ¿de acuerdo? Y esta entidad no ha sido modificada. Entonces, el servidor te devolverá un código de estado de respuesta 304, lo que significa que por favor utiliza la entidad que ya tienes, eso ahorraría tiempo. No necesitas... El tiempo para descargar ese objeto en particular y analizarlo se ahorraría. Mi pregunta fue, esto lo podemos usar fácilmente en REST y aprovecharlo. Mi pregunta fue, ¿podemos admitir el código de estado de respuesta 304 en GraphQL? Actualmente no, porque GraphQL, en realidad no recuperamos solo una entidad en particular. Es un conjunto de diferentes y muchas entidades que recuperamos en una consulta en particular. Por lo tanto, enviar un código de respuesta como 304 no tiene sentido porque estamos tratando de decir que la consulta en particular en su totalidad no ha cambiado, lo cual puede que no sea cierto. Por lo tanto, podemos aprovechar las cabeceras de control de caché pero actualmente GraphQL envía 200, incluso si ninguno de los campos en la consulta ha cambiado. Genial. De acuerdo.

QnA

Impacto del Tamaño de Respuesta y Paginación en GraphQL

Short description:

¿El tamaño de respuesta de una consulta GraphQL afecta el rendimiento? Sí, lo hace. Por ejemplo, si estás obteniendo cientos de objetos anidados, el tamaño de respuesta puede ser grande, lo que resulta en tiempos de descarga más largos. Para superar esto, se pueden aplicar filtros en el lado del servidor para enviar una respuesta filtrada al cliente, reduciendo la cantidad de datos descargados. La paginación también es una técnica útil para gestionar objetos grandes. En lugar de obtener todos los objetos de una vez, obténlos en lotes más pequeños.

Luego una pregunta de seguimiento. ¿Soporta el código de estado 418? El 418 es, es el código de estado Soy una tetera, lo que significa que el servidor rechaza el intento de hacer café con una tetera. Supongo que no lo soporta, pero no estoy completamente seguro. No lo he probado. Creo que deberíamos implementarlo. Así que si alguien tiene tiempo para implementarlo, es un código de estado importante que necesitamos en GraphQL. Sí. Sí.

Muy bien. Pasemos a las preguntas. Si aún tienes alguna pregunta, todavía tienes tiempo para escribirlas mientras hablamos. Así que asegúrate de unirte al canal de Discord, GraphQL Milky Way Q&A.

Primera pregunta. ¿El tamaño de respuesta de una consulta GraphQL puede afectar el rendimiento de la aplicación? Y si es así, ¿cómo? Sí. Entonces, el tamaño de respuesta realmente afecta el rendimiento de la aplicación. Consideremos un ejemplo. Ahora, estás obteniendo cientos de objetos en una lista y estos objetos están anidados, ¿de acuerdo? Entonces, hemos visto en nuestra propia aplicación, hemos visto que estás transportando más de dos a cinco MB de datos a través de la red porque el área es bastante grande. Hay demasiados objetos y están bastante anidados, ¿de acuerdo? Entonces, si observas el tiempo de descarga que lleva este objeto, también es más porque el objeto es bastante grande. Sí, afecta el rendimiento de la aplicación. Si quieres superar este problema, lo que hemos hecho es en lugar de tener demasiados filtros en el lado del cliente y obtener toda la respuesta de GraphQL y tener filtros en el lado del cliente, podríamos intentar tener filtros en el lado del servidor para enviar menos datos y la respuesta filtrada al cliente. De esa manera, estarías descargando un contenido más pequeño. Estoy tratando de entenderlo. Sí, tiene mucho sentido. Pero, ¿qué pasa con cosas como la paginación, por supuesto que también puede ayudar. Pero nuevamente, si tu objeto es simplemente grande, puedes aplicar paginación. Sí, la paginación es una buena idea. Creo que siempre deberíamos obtener, como dije en la charla también, siempre deberíamos obtener. Si tienes cientos de reservas no obtengas todas las cientos de ellas.

Optimización de Consultas GraphQL y Rendimiento de la Interfaz de Usuario

Short description:

En GraphQL, las consultas anidadas pueden afectar el rendimiento. Los campos diferentes no requeridos en el viewport pueden mejorar el rendimiento. Obtener más campos puede llevar a llamadas adicionales a la base de datos y servicios secundarios, aumentando el tiempo de consulta. Es importante monitorear y probar las consultas para evitar ralentizar la aplicación. El uso de pantallas de esqueleto con suspense en React puede mejorar el rendimiento percibido.

Ni siquiera podrás mostrarlos en el viewport del usuario. Estás obteniendo 25 reservas. En algunos casos, estas 25 reservas son objetos anidados porque en GraphQL tienes flexibilidad para consultar campos dentro de campos dentro de campos, ¿verdad? Entonces puede haber muchos campos anidados. Sí, eso podría afectar el rendimiento de tu aplicación. Y como dije, ya sabes, si lo ves en la URL como podrías entender. Sí, podrías entender que esta consulta anidada en particular también está afectando el rendimiento.

Me silencié y ahora me des-silencié. Bienvenido al mundo digital. Es como, es como, esto es algo nuevo, reunirse de forma remota. Entonces el rendimiento es, por supuesto, bueno, uno de los temas más importantes para hacer una buena aplicación web. Por supuesto, hay muchas cosas que hacen una buena aplicación web. Y, bueno, la paginación es una cosa que puedes hacer, pero ¿hay alguna otra cosa en la que puedas pensar que pueda ayudar, por supuesto, con GraphQL para mejorar el rendimiento?

Sí, de hecho, ya sabes, como usar, diferir algunos campos en particular que no necesitas en el viewport del usuario, vi una charla de Uri que diferentes directivas de transmisión son bastante poderosas y son compatibles con GraphQL Yuga. Entonces, con estos campos, realmente no obtenemos, ya sabes, lo que no se requería en la interfaz de usuario, en la carga inicial por el usuario. Así que eso es bastante bueno para mejorar el rendimiento de tu aplicación. Pero más que eso, en nuestra aplicación, lo que hemos visto es simplemente obtener, ya sabes, obtener menos campos. En el lado del frontend, creemos que deberíamos obtener cinco o seis campos más y habrás terminado con la tarea que te han asignado, ¿verdad? Pero no entendemos que estos cinco o seis campos van a todos tus servicios secundarios. Ahí es cuando te das cuenta, ahí es cuando entiendes que el costo de esta consulta está afectando dos o tres consultas a la base de datos, afectando dos o tres servicios secundarios. Ahí es cuando te das cuenta de que va a llevar más tiempo. Sí. Sí. A veces, si entiendo correctamente, agregas dos o tres campos más a tu consulta y piensas que son solo dos o tres campos más, pero en realidad puede ser una consulta muy pesada. Entonces, básicamente, el consejo sería siempre estar monitoreando. Cuando estás editando una consulta, estar monitoreando, estar atento a lo que está sucediendo, probar antes, probar después, y asegurarte de no ralentizar significativamente tu aplicación. Sí, sí, absolutamente. De acuerdo, genial. Entonces, bien. Eso es bueno. Y volviendo un poco al lado de la interfaz de usuario. Entonces estamos diciendo que solo obtengas lo que está en el viewport, pero ¿también estás usando algo como pantallas de esqueleto en la interfaz de usuario? Sí, sí. Entonces, mientras obtienes tus datos, puedes aprovechar, como estamos usando suspense, ¿vale? Suspense en React, donde puedes mostrar el esqueleto de tu interfaz de usuario hasta que obtengas los datos, obtienes una mejora en el rendimiento percibido en el lado de la interfaz de usuario.

Mejorando el Rendimiento Percibido

Short description:

Podemos mejorar el rendimiento percibido proporcionando retroalimentación visual a los usuarios mientras los datos se cargan. El término 'rendimiento percibido' es más importante que el rendimiento real porque la velocidad por sí sola no importa si no se siente rápida. Por ejemplo, el uso de una pantalla de esqueleto puede dar a los usuarios la impresión de que algo está sucediendo. Otro ejemplo es el escenario del aeropuerto, donde se creó una ruta más larga para que las personas sientan que no están esperando tanto tiempo. Eso es rendimiento percibido en el mundo real.

Sí, también podemos hacer muchas cosas en el lado del cliente para obtener mejoras en el rendimiento percibido para el usuario. El usuario siente que algo se está cargando, no hay una pantalla en blanco, o simplemente no le mostramos el cargador al usuario, hay algo que está ahí en la pantalla y el usuario tiene suficiente paciencia para esperar a que los datos lleguen.

Sí, me gusta ese término de rendimiento percibido. En mi opinión, es incluso más importante que el rendimiento real porque, bueno, si es rápido pero no se siente rápido, no importa, ¿verdad? Hmm, sí. Entonces, algo como una pantalla de esqueleto realmente puede ayudar al usuario a sentir que algo está sucediendo. Sí.

Recuerdo cuando todavía estaba en la escuela y estaba aprendiendo sobre el rendimiento y el rendimiento percibido, el ejemplo que dieron fue sobre un aeropuerto que tenía un largo recorrido, o un recorrido realmente corto desde que sales del avión hasta la cinta transportadora donde recoges tu equipaje. Y la gente se quejaba de que tenían que esperar 20 minutos por su equipaje. Y lo que hicieron fue crear una ruta más larga. Podría ser una caminata de dos minutos, pero la hicieron de 20 minutos. Así que la gente no está esperando 20 minutos. Solo están caminando por el aeropuerto durante 20 minutos. Y luego todos decían, oh Dios mío, no solo esperan, miro a la cámara aquí. Y me encanta ese ejemplo, pero sí, eso es rendimiento percibido en el mundo real para ti. Sí, fue un gran ejemplo.

Así que esas son todas las preguntas que tenemos por el momento. Ankita, muchas gracias por unirte a nosotros hoy. Vamos a tomar un breve descanso. Y si tienes más preguntas, Ankita estará en su chat especial, así que haz clic en el enlace en la línea de tiempo de abajo. Ankita, muchas gracias por unirte a nosotros y compartir tus conocimientos. Gracias. Muchas gracias. Adiós. Adiós.

Check out more articles and videos

We constantly think of articles and videos that might spark Git people interest / skill us up or help building a stellar career

React Advanced Conference 2022React Advanced Conference 2022
25 min
A Guide to React Rendering Behavior
Top Content
React is a library for "rendering" UI from components, but many users find themselves confused about how React rendering actually works. What do terms like "rendering", "reconciliation", "Fibers", and "committing" actually mean? When do renders happen? How does Context affect rendering, and how do libraries like Redux cause updates? In this talk, we'll clear up the confusion and provide a solid foundation for understanding when, why, and how React renders. We'll look at: - What "rendering" actually is - How React queues renders and the standard rendering behavior - How keys and component types are used in rendering - Techniques for optimizing render performance - How context usage affects rendering behavior| - How external libraries tie into React rendering
React Summit 2023React Summit 2023
32 min
Speeding Up Your React App With Less JavaScript
Too much JavaScript is getting you down? New frameworks promising no JavaScript look interesting, but you have an existing React application to maintain. What if Qwik React is your answer for faster applications startup and better user experience? Qwik React allows you to easily turn your React application into a collection of islands, which can be SSRed and delayed hydrated, and in some instances, hydration skipped altogether. And all of this in an incremental way without a rewrite.
React Summit 2023React Summit 2023
23 min
React Concurrency, Explained
React 18! Concurrent features! You might’ve already tried the new APIs like useTransition, or you might’ve just heard of them. But do you know how React 18 achieves the performance wins it brings with itself? In this talk, let’s peek under the hood of React 18’s performance features: - How React 18 lowers the time your page stays frozen (aka TBT) - What exactly happens in the main thread when you run useTransition() - What’s the catch with the improvements (there’s no free cake!), and why Vue.js and Preact straight refused to ship anything similar
JSNation 2022JSNation 2022
21 min
The Future of Performance Tooling
Top Content
Our understanding of performance & user-experience has heavily evolved over the years. Web Developer Tooling needs to similarly evolve to make sure it is user-centric, actionable and contextual where modern experiences are concerned. In this talk, Addy will walk you through Chrome and others have been thinking about this problem and what updates they've been making to performance tools to lower the friction for building great experiences on the web.
GraphQL Galaxy 2021GraphQL Galaxy 2021
32 min
From GraphQL Zero to GraphQL Hero with RedwoodJS
Top Content
We all love GraphQL, but it can be daunting to get a server up and running and keep your code organized, maintainable, and testable over the long term. No more! Come watch as I go from an empty directory to a fully fledged GraphQL API in minutes flat. Plus, see how easy it is to use and create directives to clean up your code even more. You're gonna love GraphQL even more once you make things Redwood Easy!
Vue.js London Live 2021Vue.js London Live 2021
24 min
Local State and Server Cache: Finding a Balance
Top Content
How many times did you implement the same flow in your application: check, if data is already fetched from the server, if yes - render the data, if not - fetch this data and then render it? I think I've done it more than ten times myself and I've seen the question about this flow more than fifty times. Unfortunately, our go-to state management library, Vuex, doesn't provide any solution for this.For GraphQL-based application, there was an alternative to use Apollo client that provided tools for working with the cache. But what if you use REST? Luckily, now we have a Vue alternative to a react-query library that provides a nice solution for working with server cache. In this talk, I will explain the distinction between local application state and local server cache and do some live coding to show how to work with the latter.

Workshops on related topic

React Summit 2023React Summit 2023
170 min
React Performance Debugging Masterclass
Featured WorkshopFree
Ivan’s first attempts at performance debugging were chaotic. He would see a slow interaction, try a random optimization, see that it didn't help, and keep trying other optimizations until he found the right one (or gave up).
Back then, Ivan didn’t know how to use performance devtools well. He would do a recording in Chrome DevTools or React Profiler, poke around it, try clicking random things, and then close it in frustration a few minutes later. Now, Ivan knows exactly where and what to look for. And in this workshop, Ivan will teach you that too.
Here’s how this is going to work. We’ll take a slow app → debug it (using tools like Chrome DevTools, React Profiler, and why-did-you-render) → pinpoint the bottleneck → and then repeat, several times more. We won’t talk about the solutions (in 90% of the cases, it’s just the ol’ regular useMemo() or memo()). But we’ll talk about everything that comes before – and learn how to analyze any React performance problem, step by step.
(Note: This workshop is best suited for engineers who are already familiar with how useMemo() and memo() work – but want to get better at using the performance tools around React. Also, we’ll be covering interaction performance, not load speed, so you won’t hear a word about Lighthouse 🤐)
GraphQL Galaxy 2021GraphQL Galaxy 2021
140 min
Build with SvelteKit and GraphQL
Top Content
Featured WorkshopFree
Have you ever thought about building something that doesn't require a lot of boilerplate with a tiny bundle size? In this workshop, Scott Spence will go from hello world to covering routing and using endpoints in SvelteKit. You'll set up a backend GraphQL API then use GraphQL queries with SvelteKit to display the GraphQL API data. You'll build a fast secure project that uses SvelteKit's features, then deploy it as a fully static site. This course is for the Svelte curious who haven't had extensive experience with SvelteKit and want a deeper understanding of how to use it in practical applications.

Table of contents:
- Kick-off and Svelte introduction
- Initialise frontend project
- Tour of the SvelteKit skeleton project
- Configure backend project
- Query Data with GraphQL
- Fetching data to the frontend with GraphQL
- Styling
- Svelte directives
- Routing in SvelteKit
- Endpoints in SvelteKit
- Deploying to Netlify
- Navigation
- Mutations in GraphCMS
- Sending GraphQL Mutations via SvelteKit
- Q&A
JSNation 2023JSNation 2023
170 min
Building WebApps That Light Up the Internet with QwikCity
Featured WorkshopFree
Building instant-on web applications at scale have been elusive. Real-world sites need tracking, analytics, and complex user interfaces and interactions. We always start with the best intentions but end up with a less-than-ideal site.
QwikCity is a new meta-framework that allows you to build large-scale applications with constant startup-up performance. We will look at how to build a QwikCity application and what makes it unique. The workshop will show you how to set up a QwikCitp project. How routing works with layout. The demo application will fetch data and present it to the user in an editable form. And finally, how one can use authentication. All of the basic parts for any large-scale applications.
Along the way, we will also look at what makes Qwik unique, and how resumability enables constant startup performance no matter the application complexity.
React Advanced Conference 2022React Advanced Conference 2022
95 min
End-To-End Type Safety with React, GraphQL & Prisma
Featured WorkshopFree
In this workshop, you will get a first-hand look at what end-to-end type safety is and why it is important. To accomplish this, you’ll be building a GraphQL API using modern, relevant tools which will be consumed by a React client.
Prerequisites: - Node.js installed on your machine (12.2.X / 14.X)- It is recommended (but not required) to use VS Code for the practical tasks- An IDE installed (VSCode recommended)- (Good to have)*A basic understanding of Node.js, React, and TypeScript
GraphQL Galaxy 2022GraphQL Galaxy 2022
112 min
GraphQL for React Developers
Featured Workshop
There are many advantages to using GraphQL as a datasource for frontend development, compared to REST APIs. We developers in example need to write a lot of imperative code to retrieve data to display in our applications and handle state. With GraphQL you cannot only decrease the amount of code needed around data fetching and state-management you'll also get increased flexibility, better performance and most of all an improved developer experience. In this workshop you'll learn how GraphQL can improve your work as a frontend developer and how to handle GraphQL in your frontend React application.
React Summit 2022React Summit 2022
173 min
Build a Headless WordPress App with Next.js and WPGraphQL
Top Content
WorkshopFree
In this workshop, you’ll learn how to build a Next.js app that uses Apollo Client to fetch data from a headless WordPress backend and use it to render the pages of your app. You’ll learn when you should consider a headless WordPress architecture, how to turn a WordPress backend into a GraphQL server, how to compose queries using the GraphiQL IDE, how to colocate GraphQL fragments with your components, and more.