El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia

HOME

En este módulo, aprenderemos sobre dos técnicas cruciales para mejorar el rendimiento de nuestras aplicaciones GraphQL: la agrupación (batching) y el caché (caching). Estas técnicas nos permiten optimizar la obtención de datos y reducir la carga en nuestros servidores.

Agrupación (Batching)

¿Qué es la Agrupación?

La agrupación es una técnica que permite combinar múltiples solicitudes de datos en una sola operación. Esto es especialmente útil cuando se realizan múltiples consultas que podrían ser combinadas para reducir el número de llamadas a la base de datos o a otros servicios externos.

¿Cómo Funciona la Agrupación?

En GraphQL, la agrupación se puede implementar utilizando herramientas como DataLoader. DataLoader es una biblioteca que permite agrupar y almacenar en caché solicitudes de datos.

Ejemplo Práctico con DataLoader

Paso 1: Instalación de DataLoader

Primero, necesitamos instalar DataLoader en nuestro proyecto:

npm install dataloader

Paso 2: Configuración de DataLoader

A continuación, configuramos DataLoader en nuestro servidor GraphQL. Supongamos que tenemos un modelo de usuario y queremos agrupar las solicitudes de usuarios por ID.

const DataLoader = require('dataloader');
const { getUserById } = require('./dataSources');

const userLoader = new DataLoader(async (keys) => {
  const users = await getUserById(keys);
  return keys.map(key => users.find(user => user.id === key));
});

Paso 3: Uso de DataLoader en Resolvers

Finalmente, utilizamos DataLoader en nuestros resolvers para agrupar las solicitudes de datos.

const resolvers = {
  Query: {
    user: (parent, { id }, context) => context.userLoader.load(id),
  },
  User: {
    friends: (user, args, context) => context.userLoader.loadMany(user.friendIds),
  },
};

// En el contexto de Apollo Server
const server = new ApolloServer({
  typeDefs,
  resolvers,
  context: () => ({
    userLoader,
  }),
});

Ventajas de la Agrupación

Reducción de Llamadas a la Base de Datos: Agrupar solicitudes reduce el número de llamadas a la base de datos, mejorando el rendimiento.
Optimización de Recursos: Al combinar múltiples solicitudes en una sola operación, se optimizan los recursos del servidor.

Caché (Caching)

¿Qué es el Caché?

El caché es una técnica que almacena temporalmente los resultados de las consultas para que las solicitudes futuras puedan ser atendidas más rápidamente. Esto es especialmente útil para datos que no cambian con frecuencia.

Tipos de Caché

Caché en Memoria: Almacena los datos en la memoria del servidor.
Caché Distribuido: Utiliza sistemas externos como Redis para almacenar los datos en caché.

Implementación de Caché en GraphQL

Paso 1: Instalación de Redis

Para implementar un caché distribuido, podemos utilizar Redis. Primero, instalamos el cliente de Redis:

npm install redis

Paso 2: Configuración de Redis

Configuramos Redis en nuestro servidor GraphQL.

const redis = require('redis');
const client = redis.createClient();

client.on('error', (err) => {
  console.error('Error connecting to Redis', err);
});

Paso 3: Uso de Redis en Resolvers

Utilizamos Redis para almacenar y recuperar datos en caché.

const resolvers = {
  Query: {
    user: async (parent, { id }, context) => {
      const cacheKey = `user:${id}`;
      const cachedUser = await client.getAsync(cacheKey);

      if (cachedUser) {
        return JSON.parse(cachedUser);
      }

      const user = await getUserById(id);
      await client.setAsync(cacheKey, JSON.stringify(user), 'EX', 3600); // Expira en 1 hora
      return user;
    },
  },
};

Ventajas del Caché

Mejora del Rendimiento: Almacenar los resultados de las consultas reduce el tiempo de respuesta.
Reducción de la Carga del Servidor: Menos solicitudes a la base de datos o servicios externos.

Ejercicio Práctico

Ejercicio 1: Implementar DataLoader

Instalar DataLoader: Instala DataLoader en tu proyecto.
Configurar DataLoader: Configura DataLoader para agrupar solicitudes de datos de un modelo de tu elección.
Utilizar DataLoader en Resolvers: Modifica tus resolvers para utilizar DataLoader.

Ejercicio 2: Implementar Caché con Redis

Instalar Redis: Instala el cliente de Redis en tu proyecto.
Configurar Redis: Configura Redis en tu servidor GraphQL.
Utilizar Redis en Resolvers: Modifica tus resolvers para almacenar y recuperar datos en caché utilizando Redis.

Soluciones

Solución al Ejercicio 1

// Paso 1: Instalación de DataLoader
// npm install dataloader

// Paso 2: Configuración de DataLoader
const DataLoader = require('dataloader');
const { getUserById } = require('./dataSources');

const userLoader = new DataLoader(async (keys) => {
  const users = await getUserById(keys);
  return keys.map(key => users.find(user => user.id === key));
});

// Paso 3: Uso de DataLoader en Resolvers
const resolvers = {
  Query: {
    user: (parent, { id }, context) => context.userLoader.load(id),
  },
  User: {
    friends: (user, args, context) => context.userLoader.loadMany(user.friendIds),
  },
};

const server = new ApolloServer({
  typeDefs,
  resolvers,
  context: () => ({
    userLoader,
  }),
});

Solución al Ejercicio 2

// Paso 1: Instalación de Redis
// npm install redis

// Paso 2: Configuración de Redis
const redis = require('redis');
const client = redis.createClient();

client.on('error', (err) => {
  console.error('Error connecting to Redis', err);
});

// Paso 3: Uso de Redis en Resolvers
const resolvers = {
  Query: {
    user: async (parent, { id }, context) => {
      const cacheKey = `user:${id}`;
      const cachedUser = await client.getAsync(cacheKey);

      if (cachedUser) {
        return JSON.parse(cachedUser);
      }

      const user = await getUserById(id);
      await client.setAsync(cacheKey, JSON.stringify(user), 'EX', 3600); // Expira en 1 hora
      return user;
    },
  },
};

Conclusión

En esta sección, hemos aprendido sobre la agrupación y el caché, dos técnicas esenciales para optimizar el rendimiento de nuestras aplicaciones GraphQL. La agrupación nos permite combinar múltiples solicitudes en una sola operación, mientras que el caché nos ayuda a almacenar temporalmente los resultados de las consultas para mejorar el tiempo de respuesta. Con estas herramientas, podemos construir aplicaciones más eficientes y escalables.

Agrupación y Caché