Federación GraphQL: Schema Stitching - Una Guía Completa

En el panorama en constante evolución del desarrollo de aplicaciones modernas, la necesidad de arquitecturas escalables y mantenibles se ha vuelto primordial. Los microservicios, con su modularidad inherente y su capacidad de despliegue independiente, han surgido como una solución popular. Sin embargo, gestionar numerosos microservicios puede introducir complejidades, especialmente cuando se trata de exponer una API unificada a las aplicaciones cliente. Aquí es donde entran en juego la Federación GraphQL y, específicamente, el Schema Stitching.

¿Qué es la Federación GraphQL?

La Federación GraphQL es una arquitectura potente que le permite construir una única API GraphQL unificada a partir de múltiples servicios GraphQL subyacentes (que a menudo representan microservicios). Permite a los desarrolladores consultar datos a través de diferentes servicios como si fuera un único grafo, simplificando la experiencia del cliente y reduciendo la necesidad de una lógica de orquestación compleja en el lado del cliente.

Existen dos enfoques principales para la Federación GraphQL:

• Schema Stitching: Esto implica combinar múltiples esquemas GraphQL en un único esquema unificado en la capa de la pasarela (gateway). Es un enfoque más antiguo y depende de bibliotecas para gestionar la combinación de esquemas y la delegación de consultas.
• Apollo Federation: Este es un enfoque más reciente y robusto que utiliza un lenguaje de esquema declarativo y un planificador de consultas dedicado para gestionar el proceso de federación. Ofrece características avanzadas como extensiones de tipos, directivas de clave y seguimiento distribuido.

Este artículo se centra en el Schema Stitching, explorando sus conceptos, beneficios, limitaciones e implementación práctica.

Entendiendo el Schema Stitching

El Schema Stitching es el proceso de fusionar múltiples esquemas GraphQL en un único esquema cohesivo. Este esquema unificado actúa como una fachada, ocultando la complejidad de los servicios subyacentes al cliente. Cuando un cliente realiza una solicitud al esquema "cosido" (stitched), la pasarela enruta inteligentemente la solicitud al servicio o servicios subyacentes apropiados, recupera los datos y combina los resultados antes de devolverlos al cliente.

Piénselo de esta manera: tiene varios restaurantes (servicios), cada uno especializado en diferentes cocinas. El Schema Stitching es como un menú universal que combina todos los platos de cada restaurante. Cuando un cliente (cliente) ordena del menú universal, el pedido se enruta inteligentemente a las cocinas de los restaurantes apropiados, la comida se prepara y luego se combina en una sola entrega para el cliente.

Conceptos Clave en Schema Stitching

• Esquemas Remotos (Remote Schemas): Estos son los esquemas GraphQL individuales de cada servicio subyacente. Cada servicio expone su propio esquema, que define los datos y operaciones que proporciona.
• Pasarela (Gateway): La pasarela es el componente central responsable de "coser" los esquemas remotos y exponer el esquema unificado al cliente. Recibe las solicitudes del cliente, las enruta a los servicios apropiados y combina los resultados.
• Fusión de Esquemas (Schema Merging): Este es el proceso de combinar los esquemas remotos en un solo esquema. A menudo implica renombrar tipos y campos para evitar conflictos y definir relaciones entre tipos de diferentes esquemas.
• Delegación de Consultas (Query Delegation): Cuando un cliente realiza una solicitud al esquema "cosido", la pasarela necesita delegar la solicitud al servicio o servicios subyacentes apropiados para recuperar los datos. Esto implica traducir la consulta del cliente a una consulta que el servicio remoto pueda entender.
• Agregación de Resultados (Result Aggregation): Después de que la pasarela ha recuperado datos de los servicios subyacentes, necesita combinar los resultados en una única respuesta que se pueda devolver al cliente. Esto a menudo implica transformar los datos para que coincidan con la estructura del esquema "cosido".

Beneficios del Schema Stitching

El Schema Stitching ofrece varios beneficios convincentes para las organizaciones que adoptan una arquitectura de microservicios:

• API Unificada: Proporciona una API única y consistente para los clientes, simplificando el acceso a los datos y reduciendo la necesidad de que los clientes interactúen directamente con múltiples servicios. Esto resulta en una experiencia de desarrollador más limpia e intuitiva.
• Reducción de la Complejidad del Cliente: Los clientes solo necesitan interactuar con el esquema unificado, protegiéndolos de las complejidades de la arquitectura de microservicios subyacente. Esto simplifica el desarrollo del lado del cliente y reduce la cantidad de código requerido en el cliente.
• Mayor Escalabilidad: Permite escalar servicios individuales de forma independiente según sus necesidades específicas. Esto mejora la escalabilidad y la resiliencia general del sistema. Por ejemplo, un servicio de usuario que experimenta una alta carga puede escalarse sin afectar a otros servicios como el catálogo de productos.
• Mantenibilidad Mejorada: Promueve la modularidad y la separación de responsabilidades, lo que facilita el mantenimiento y la evolución de los servicios individuales. Es menos probable que los cambios en un servicio afecten a otros servicios.
• Adopción Gradual: Puede implementarse de forma incremental, lo que le permite migrar gradualmente de una arquitectura monolítica a una de microservicios. Puede comenzar "cosiendo" las API existentes y luego descomponer gradualmente el monolito en servicios más pequeños.

Limitaciones del Schema Stitching

Aunque el Schema Stitching ofrece numerosas ventajas, es importante ser consciente de sus limitaciones:

• Complejidad: Implementar y gestionar el "schema stitching" puede ser complejo, especialmente en sistemas grandes y complejos. Es esencial una planificación y un diseño cuidadosos.
• Sobrecarga de Rendimiento: La pasarela introduce cierta sobrecarga de rendimiento debido a la capa adicional de indirección y la necesidad de delegar consultas y agregar resultados. Una optimización cuidadosa es crucial para minimizar esta sobrecarga.
• Conflictos de Esquema: Pueden surgir conflictos al fusionar esquemas de diferentes servicios, especialmente si usan los mismos nombres de tipos o campos. Esto requiere un diseño de esquema cuidadoso y, potencialmente, renombrar tipos y campos.
• Funcionalidades Avanzadas Limitadas: En comparación con Apollo Federation, Schema Stitching carece de algunas funcionalidades avanzadas como extensiones de tipo y directivas de clave, lo que puede dificultar la gestión de las relaciones entre tipos de diferentes esquemas.
• Madurez de las Herramientas: Las herramientas y el ecosistema en torno a Schema Stitching no son tan maduros como los de Apollo Federation. Esto puede dificultar la depuración y la resolución de problemas.

Implementación Práctica de Schema Stitching

Veamos un ejemplo simplificado de cómo implementar Schema Stitching usando Node.js y la biblioteca graphql-tools (una opción popular para "schema stitching"). Este ejemplo involucra dos microservicios: un Servicio de Usuarios y un Servicio de Productos.

1. Definir los Esquemas Remotos

Primero, defina los esquemas GraphQL para cada uno de los servicios remotos.

Servicio de Usuarios (user-service.js):

            
const { buildSchema } = require('graphql');

const userSchema = buildSchema(`
  type User {
    id: ID!
    name: String
    email: String
  }

  type Query {
    user(id: ID!): User
  }
`);

const users = [
  { id: '1', name: 'Alice Smith', email: 'alice@example.com' },
  { id: '2', name: 'Bob Johnson', email: 'bob@example.com' },
];

const userRoot = {
  user: (args) => users.find(user => user.id === args.id),
};

module.exports = {
  schema: userSchema,
  rootValue: userRoot,
};

            

              
                Copy
              
            
          

Servicio de Productos (product-service.js):

            
const { buildSchema } = require('graphql');

const productSchema = buildSchema(`
  type Product {
    id: ID!
    name: String
    price: Float
    userId: ID!  # Clave foránea al Servicio de Usuarios
  }

  type Query {
    product(id: ID!): Product
  }
`);

const products = [
  { id: '101', name: 'Laptop', price: 1200, userId: '1' },
  { id: '102', name: 'Smartphone', price: 800, userId: '2' },
];

const productRoot = {
  product: (args) => products.find(product => product.id === args.id),
};

module.exports = {
  schema: productSchema,
  rootValue: productRoot,
};

            

              
                Copy
              
            
          

2. Crear el Servicio de Pasarela (Gateway)

Ahora, cree el servicio de pasarela que "coserá" los dos esquemas.

Servicio de Pasarela (gateway.js):

            
const { stitchSchemas } = require('@graphql-tools/stitch');
const { makeRemoteExecutableSchema } = require('@graphql-tools/wrap');
const { graphqlHTTP } = require('express-graphql');
const express = require('express');
const { introspectSchema } = require('@graphql-tools/wrap');
const { printSchema } = require('graphql');
const fetch = require('node-fetch');

async function createRemoteSchema(uri) {
  const fetcher = async (params) => {
    const response = await fetch(uri, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify(params),
    });
    return response.json();
  };

  const schema = await introspectSchema(fetcher);
  return makeRemoteExecutableSchema({
    schema,
    fetcher,
  });
}

async function main() {
  const userSchema = await createRemoteSchema('http://localhost:4001/graphql');
  const productSchema = await createRemoteSchema('http://localhost:4002/graphql');

  const stitchedSchema = stitchSchemas({
    subschemas: [
      { schema: userSchema },
      { schema: productSchema },
    ],
    typeDefs: `
      extend type Product {
        user: User
      }
    `,
    resolvers: {
      Product: {
        user: {
          selectionSet: `{ userId }`,
          resolve(product, args, context, info) {
            return info.mergeInfo.delegateToSchema({
              schema: userSchema,
              operation: 'query',
              fieldName: 'user',
              args: {
                id: product.userId,
              },
              context,
              info,
            });
          },
        },
      },
    },
  });

  const app = express();
  app.use('/graphql', graphqlHTTP({
    schema: stitchedSchema,
    graphiql: true,
  }));

  app.listen(4000, () => console.log('Servidor de pasarela ejecutándose en http://localhost:4000/graphql'));
}

main().catch(console.error);

            

              
                Copy
              
            
          

3. Ejecutar los Servicios

Tendrá que ejecutar el Servicio de Usuarios y el Servicio de Productos en diferentes puertos. Por ejemplo:

Servicio de Usuarios (puerto 4001):

            
const express = require('express');
const { graphqlHTTP } = require('express-graphql');
const { schema, rootValue } = require('./user-service');

const app = express();
app.use('/graphql', graphqlHTTP({
  schema: schema,
  rootValue: rootValue,
  graphiql: true,
}));

app.listen(4001, () => console.log('Servicio de usuarios ejecutándose en http://localhost:4001/graphql'));

            

              
                Copy
              
            
          

Servicio de Productos (puerto 4002):

            
const express = require('express');
const { graphqlHTTP } = require('express-graphql');
const { schema, rootValue } = require('./product-service');

const app = express();
app.use('/graphql', graphqlHTTP({
  schema: schema,
  rootValue: rootValue,
  graphiql: true,
}));

app.listen(4002, () => console.log('Servicio de productos ejecutándose en http://localhost:4002/graphql'));

            

              
                Copy
              
            
          

4. Consultar el Esquema "Cosido"

Ahora puede consultar el esquema "cosido" a través de la pasarela (ejecutándose en el puerto 4000). Puede ejecutar una consulta como esta:

            
query {
  product(id: "101") {
    id
    name
    price
    user {
      id
      name
      email
    }
  }
}

            

              
                Copy
              
            
          

Esta consulta recupera el producto con ID "101" y también obtiene el usuario asociado del Servicio de Usuarios, demostrando cómo el Schema Stitching le permite consultar datos de múltiples servicios en una sola solicitud.

Técnicas Avanzadas de Schema Stitching

Más allá del ejemplo básico, aquí hay algunas técnicas avanzadas que se pueden usar para mejorar su implementación de Schema Stitching:

• Delegación de Esquemas: Esto le permite delegar partes de una consulta a diferentes servicios según los datos que se solicitan. Por ejemplo, puede delegar la resolución de un tipo User al Servicio de Usuarios y la resolución de un tipo Product al Servicio de Productos.
• Transformación de Esquemas: Esto implica modificar el esquema de un servicio remoto antes de que se "cosa" en el esquema unificado. Esto puede ser útil para renombrar tipos y campos, agregar nuevos campos o eliminar campos existentes.
• Resolvers Personalizados: Puede definir resolvers personalizados en la pasarela para manejar transformaciones de datos complejas o para obtener datos de múltiples servicios y combinarlos en un único resultado.
• Compartir Contexto: A menudo es necesario compartir información de contexto entre la pasarela y los servicios remotos, como tokens de autenticación o ID de usuario. Esto se puede lograr pasando la información de contexto como parte del proceso de delegación de consultas.
• Manejo de Errores: Implemente un manejo de errores robusto para gestionar con gracia los errores que ocurren en los servicios remotos. Esto puede implicar registrar errores, devolver mensajes de error amigables para el usuario o reintentar solicitudes fallidas.

Elegir entre Schema Stitching y Apollo Federation

Aunque Schema Stitching es una opción viable para la Federación GraphQL, Apollo Federation se ha convertido en la opción más popular debido a sus características avanzadas y una mejor experiencia de desarrollador. Aquí hay una comparación de los dos enfoques:

Cuándo elegir Schema Stitching:

• Tiene servicios GraphQL existentes y desea combinarlos rápidamente.
• Necesita una solución de federación simple y no requiere características avanzadas.
• Tiene recursos limitados y quiere evitar la sobrecarga de configurar Apollo Federation.

Cuándo elegir Apollo Federation:

• Está construyendo un sistema grande y complejo con múltiples equipos y servicios.
• Necesita características avanzadas como extensiones de tipo, directivas de clave y seguimiento distribuido.
• Desea una solución de federación más robusta y escalable.
• Prefiere un enfoque más declarativo y automatizado para la federación.

Ejemplos del Mundo Real y Casos de Uso

Aquí hay algunos ejemplos del mundo real de cómo se puede utilizar la Federación GraphQL, incluido el Schema Stitching:

• Plataforma de E-commerce: Una plataforma de e-commerce podría usar la Federación GraphQL para combinar datos de múltiples servicios, como un servicio de catálogo de productos, un servicio de usuarios, un servicio de pedidos y un servicio de pagos. Esto permite a los clientes recuperar fácilmente toda la información que necesitan para mostrar detalles de productos, perfiles de usuario, historial de pedidos e información de pago.
• Plataforma de Redes Sociales: Una plataforma de redes sociales podría usar la Federación GraphQL para combinar datos de servicios que gestionan perfiles de usuario, publicaciones, comentarios y "me gusta". Esto permite a los clientes obtener de manera eficiente toda la información necesaria para mostrar el perfil de un usuario, sus publicaciones y los comentarios y "me gusta" asociados a esas publicaciones.
• Aplicación de Servicios Financieros: Una aplicación de servicios financieros podría usar la Federación GraphQL para combinar datos de servicios que gestionan cuentas, transacciones e inversiones. Esto permite a los clientes recuperar fácilmente toda la información que necesitan para mostrar saldos de cuentas, historial de transacciones y carteras de inversión.
• Sistema de Gestión de Contenidos (CMS): Un CMS puede aprovechar la Federación GraphQL para integrar datos de diversas fuentes como artículos, imágenes, videos y contenido generado por el usuario. Esto permite una API unificada para obtener todo el contenido relacionado con un tema o autor específico.
• Aplicación de Salud: Integrar datos de pacientes de diferentes sistemas como registros de salud electrónicos (EHR), resultados de laboratorio y programación de citas. Esto ofrece a los médicos un único punto de acceso a información completa del paciente.

Mejores Prácticas para Schema Stitching

Para garantizar una implementación exitosa de Schema Stitching, siga estas mejores prácticas:

• Planifique su Esquema Cuidadosamente: Antes de comenzar a "coser" esquemas, planifique cuidadosamente la estructura del esquema unificado. Esto incluye definir las relaciones entre tipos de diferentes esquemas, renombrar tipos y campos para evitar conflictos y considerar los patrones generales de acceso a datos.
• Use Convenciones de Nomenclatura Consistentes: Adopte convenciones de nomenclatura consistentes para tipos, campos y operaciones en todos los servicios. Esto ayudará a evitar conflictos y facilitará la comprensión del esquema unificado.
• Documente su Esquema: Documente exhaustivamente el esquema unificado, incluyendo descripciones de tipos, campos y operaciones. Esto facilitará que los desarrolladores entiendan y usen el esquema.
• Monitoree el Rendimiento: Monitoree el rendimiento de la pasarela y los servicios remotos para identificar y abordar cualquier cuello de botella de rendimiento. Use herramientas como el seguimiento distribuido para rastrear las solicitudes a través de múltiples servicios.
• Implemente Seguridad: Implemente medidas de seguridad apropiadas para proteger la pasarela y los servicios remotos de accesos no autorizados. Esto puede implicar el uso de mecanismos de autenticación y autorización, así como la validación de entradas y la codificación de salidas.
• Versione su Esquema: A medida que evolucione sus esquemas, versiónelos apropiadamente para asegurar que los clientes puedan continuar usando versiones más antiguas del esquema sin interrupciones. Esto ayudará a evitar cambios disruptivos y a garantizar la retrocompatibilidad.
• Automatice el Despliegue: Automatice el despliegue de la pasarela y los servicios remotos para asegurar que los cambios se puedan desplegar de manera rápida y confiable. Esto ayudará a reducir el riesgo de errores y a mejorar la agilidad general del sistema.

Conclusión

La Federación GraphQL con Schema Stitching ofrece un enfoque potente para construir API unificadas a partir de múltiples servicios en una arquitectura de microservicios. Al comprender sus conceptos básicos, beneficios, limitaciones y técnicas de implementación, puede aprovechar el Schema Stitching para simplificar el acceso a los datos, mejorar la escalabilidad y aumentar la mantenibilidad. Aunque Apollo Federation ha surgido como una solución más avanzada, Schema Stitching sigue siendo una opción viable para escenarios más simples o al integrar servicios GraphQL existentes. Considere cuidadosamente sus necesidades y requisitos específicos para elegir el mejor enfoque para su organización.