Nederlands

Ontgrendel de kracht van GraphQL Federatie met Schema Stitching. Leer hoe u een uniforme GraphQL API bouwt vanuit meerdere services, voor een betere schaalbaarheid en onderhoudbaarheid.

GraphQL Federatie: Schema Stitching - Een Uitgebreide Gids

In het steeds evoluerende landschap van moderne applicatieontwikkeling is de behoefte aan schaalbare en onderhoudbare architecturen van het grootste belang geworden. Microservices, met hun inherente modulariteit en onafhankelijke inzetbaarheid, zijn een populaire oplossing geworden. Het beheren van talrijke microservices kan echter complexiteiten met zich meebrengen, vooral als het gaat om het aanbieden van een uniforme API aan clientapplicaties. Dit is waar GraphQL Federatie, en specifiek Schema Stitching, een rol speelt.

Wat is GraphQL Federatie?

GraphQL Federatie is een krachtige architectuur waarmee u één enkele, uniforme GraphQL API kunt bouwen vanuit meerdere onderliggende GraphQL-services (die vaak microservices vertegenwoordigen). Het stelt ontwikkelaars in staat om gegevens over verschillende services te bevragen alsof het één enkele graph is, wat de clientervaring vereenvoudigt en de noodzaak voor complexe orkestratielogica aan de clientzijde vermindert.

Er zijn twee primaire benaderingen voor GraphQL Federatie:

Dit artikel richt zich op Schema Stitching, en verkent de concepten, voordelen, beperkingen en praktische implementatie ervan.

Schema Stitching Begrijpen

Schema Stitching is het proces van het samenvoegen van meerdere GraphQL-schema's tot één enkel, samenhangend schema. Dit uniforme schema fungeert als een façade, die de complexiteit van de onderliggende services voor de client verbergt. Wanneer een client een verzoek doet aan het gestiched schema, stuurt de gateway het verzoek intelligent door naar de juiste onderliggende service(s), haalt de gegevens op en combineert de resultaten voordat ze aan de client worden geretourneerd.

Zie het zo: u heeft meerdere restaurants (services) die elk gespecialiseerd zijn in verschillende keukens. Schema Stitching is als een universeel menu dat alle gerechten van elk restaurant combineert. Wanneer een klant (client) bestelt van het universele menu, wordt de bestelling intelligent doorgestuurd naar de juiste restaurantkeukens, wordt het eten bereid en vervolgens gecombineerd tot één enkele levering voor de klant.

Sleutelconcepten in Schema Stitching

Voordelen van Schema Stitching

Schema Stitching biedt verschillende overtuigende voordelen voor organisaties die een microservices-architectuur adopteren:

Beperkingen van Schema Stitching

Hoewel Schema Stitching tal van voordelen biedt, is het belangrijk om op de hoogte te zijn van de beperkingen:

Praktische Implementatie van Schema Stitching

Laten we een vereenvoudigd voorbeeld doorlopen van hoe u Schema Stitching kunt implementeren met Node.js en de graphql-tools bibliotheek (een populaire keuze voor schema stitching). Dit voorbeeld omvat twee microservices: een Gebruikersservice en een Productservice.

1. Definieer de Remote Schema's

Definieer eerst de GraphQL-schema's voor elk van de remote services.

Gebruikersservice (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,
};

Productservice (product-service.js):


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

const productSchema = buildSchema(`
  type Product {
    id: ID!
    name: String
    price: Float
    userId: ID!  # Foreign key to User Service
  }

  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,
};

2. Creëer de Gateway Service

Creëer nu de gateway service die de twee schema's aan elkaar zal stitchen.

Gateway Service (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('Gateway server running on http://localhost:4000/graphql'));
}

main().catch(console.error);

3. Start de Services

U moet de Gebruikersservice en Productservice op verschillende poorten draaien. Bijvoorbeeld:

Gebruikersservice (poort 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('User service running on http://localhost:4001/graphql'));

Productservice (poort 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('Product service running on http://localhost:4002/graphql'));

4. Query het Gestiched Schema

Nu kunt u het gestiched schema bevragen via de gateway (die op poort 4000 draait). U kunt een query als volgt uitvoeren:


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

Deze query haalt het product met ID "101" op en haalt ook de bijbehorende gebruiker op van de Gebruikersservice, wat aantoont hoe Schema Stitching u in staat stelt om gegevens over meerdere services te bevragen in één enkele aanvraag.

Geavanceerde Schema Stitching Technieken

Naast het basisvoorbeeld zijn hier enkele geavanceerde technieken die kunnen worden gebruikt om uw Schema Stitching-implementatie te verbeteren:

Kiezen tussen Schema Stitching en Apollo Federation

Hoewel Schema Stitching een haalbare optie is voor GraphQL Federatie, is Apollo Federation de populairdere keuze geworden vanwege de geavanceerde functies en verbeterde ontwikkelaarservaring. Hier is een vergelijking van de twee benaderingen:

Functie Schema Stitching Apollo Federation
Schema Definitie Gebruikt bestaande GraphQL schemataal Gebruikt een declaratieve schemataal met directieven
Query Planning Vereist handmatige query-delegatie Automatische query-planning door de Apollo Gateway
Type Extensies Beperkte ondersteuning Ingebouwde ondersteuning voor type-extensies
Key Directieven Niet ondersteund Gebruikt @key directief om entiteiten te identificeren
Gedistribueerde Tracing Vereist handmatige implementatie Ingebouwde ondersteuning voor gedistribueerde tracing
Tooling en Ecosysteem Minder volwassen tooling Meer volwassen tooling en een grote community
Complexiteit Kan complex zijn om te beheren in grote systemen Ontworpen voor grote en complexe systemen

Wanneer kiezen voor Schema Stitching:

Wanneer kiezen voor Apollo Federation:

Praktijkvoorbeelden en Gebruiksscenario's

Hier zijn enkele praktijkvoorbeelden van hoe GraphQL Federatie, inclusief Schema Stitching, kan worden gebruikt:

Best Practices voor Schema Stitching

Volg deze best practices om een succesvolle Schema Stitching-implementatie te garanderen:

Conclusie

GraphQL Federatie met Schema Stitching biedt een krachtige aanpak voor het bouwen van uniforme API's vanuit meerdere services in een microservices-architectuur. Door de kernconcepten, voordelen, beperkingen en implementatietechnieken te begrijpen, kunt u Schema Stitching benutten om de gegevenstoegang te vereenvoudigen, de schaalbaarheid te verbeteren en de onderhoudbaarheid te vergroten. Hoewel Apollo Federation is uitgegroeid tot een meer geavanceerde oplossing, blijft Schema Stitching een haalbare optie voor eenvoudigere scenario's of bij het integreren van bestaande GraphQL-services. Overweeg zorgvuldig uw specifieke behoeften en vereisten om de beste aanpak voor uw organisatie te kiezen.