Čeština

Objevte sílu federace GraphQL pomocí Schema Stitching. Naučte se, jak vytvořit jednotné GraphQL API z více služeb a zlepšit tak škálovatelnost a udržovatelnost.

Federace GraphQL: Schema Stitching - Komplexní průvodce

V neustále se vyvíjejícím světě moderního vývoje aplikací se stala potřeba škálovatelných a udržitelných architektur prvořadou. Mikroslužby se svou inherentní modularitou a nezávislou nasaditelností se ukázaly jako populární řešení. Správa mnoha mikroslužeb však může přinést komplikace, zejména pokud jde o vystavení jednotného API klientským aplikacím. A právě zde přichází na řadu federace GraphQL, konkrétně Schema Stitching.

Co je federace GraphQL?

Federace GraphQL je výkonná architektura, která vám umožňuje vytvořit jedno, jednotné GraphQL API z více podkladových GraphQL služeb (často reprezentujících mikroslužby). Umožňuje vývojářům dotazovat se na data napříč různými službami, jako by se jednalo o jediný graf, což zjednodušuje klientskou zkušenost a snižuje potřebu složité orchestrační logiky na straně klienta.

Existují dva hlavní přístupy k federaci GraphQL:

Tento článek se zaměřuje na Schema Stitching, zkoumá jeho koncepty, výhody, omezení a praktickou implementaci.

Porozumění Schema Stitching

Schema Stitching je proces sloučení více schémat GraphQL do jednoho, koherentního schématu. Toto jednotné schéma funguje jako fasáda, která před klientem skrývá složitost podkladových služeb. Když klient odešle požadavek na spojené schéma, brána inteligentně směruje požadavek na příslušnou podkladovou službu (nebo služby), získá data a zkombinuje výsledky před jejich vrácením klientovi.

Představte si to takto: Máte několik restaurací (služeb), z nichž každá se specializuje na jinou kuchyni. Schema Stitching je jako univerzální menu, které kombinuje všechna jídla z každé restaurace. Když si zákazník (klient) objedná z univerzálního menu, objednávka je inteligentně směrována do příslušných kuchyní restaurací, jídlo je připraveno a poté spojeno do jedné dodávky pro zákazníka.

Klíčové koncepty v Schema Stitching

Výhody Schema Stitching

Schema Stitching nabízí několik přesvědčivých výhod pro organizace, které přijímají architekturu mikroslužeb:

Omezení Schema Stitching

Ačkoliv Schema Stitching nabízí četné výhody, je důležité si být vědom jeho omezení:

Praktická implementace Schema Stitching

Projděme si zjednodušený příklad, jak implementovat Schema Stitching pomocí Node.js a knihovny graphql-tools (oblíbená volba pro schema stitching). Tento příklad zahrnuje dvě mikroslužby: Službu pro uživatele a Službu pro produkty.

1. Definujte vzdálená schémata

Nejprve definujte schémata GraphQL pro každou ze vzdálených služeb.

Služba pro uživatele (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,
};

Služba pro produkty (product-service.js):


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

const productSchema = buildSchema(`
  type Product {
    id: ID!
    name: String
    price: Float
    userId: ID!  # Cizí klíč ke službě 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. Vytvořte službu brány (Gateway)

Nyní vytvořte službu brány, která spojí obě schémata dohromady.

Služba brány (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. Spusťte služby

Budete muset spustit službu User Service a Product Service na různých portech. Například:

Služba pro uživatele (port 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'));

Služba pro produkty (port 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. Dotaz na spojené schéma

Nyní se můžete dotazovat na spojené schéma prostřednictvím brány (běžící na portu 4000). Můžete spustit dotaz jako tento:


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

Tento dotaz načte produkt s ID "101" a také načte přidruženého uživatele ze služby User Service, což ukazuje, jak Schema Stitching umožňuje dotazovat se na data napříč více službami v jediném požadavku.

Pokročilé techniky Schema Stitching

Kromě základního příkladu zde jsou některé pokročilé techniky, které lze použít k vylepšení vaší implementace Schema Stitching:

Volba mezi Schema Stitching a Apollo Federation

Ačkoliv je Schema Stitching životaschopnou možností pro federaci GraphQL, Apollo Federation se stala populárnější volbou díky svým pokročilým funkcím a vylepšené vývojářské zkušenosti. Zde je srovnání obou přístupů:

Funkce Schema Stitching Apollo Federation
Definice schématu Používá existující jazyk schématu GraphQL Používá deklarativní jazyk schématu s direktivami
Plánování dotazů Vyžaduje ruční delegování dotazů Automatické plánování dotazů bránou Apollo Gateway
Rozšíření typů Omezená podpora Vestavěná podpora pro rozšíření typů
Klíčové direktivy Není podporováno Používá direktivu @key k identifikaci entit
Distribuované trasování Vyžaduje ruční implementaci Vestavěná podpora pro distribuované trasování
Nástroje a ekosystém Méně zralé nástroje Zralejší nástroje a velká komunita
Složitost Může být složité spravovat ve velkých systémech Navrženo pro velké a komplexní systémy

Kdy zvolit Schema Stitching:

Kdy zvolit Apollo Federation:

Příklady z praxe a případy použití

Zde jsou některé příklady z reálného světa, jak lze využít federaci GraphQL, včetně Schema Stitching:

Osvědčené postupy pro Schema Stitching

Chcete-li zajistit úspěšnou implementaci Schema Stitching, dodržujte tyto osvědčené postupy:

Závěr

Federace GraphQL se Schema Stitching nabízí výkonný přístup k budování jednotných API z více služeb v architektuře mikroslužeb. Porozuměním jejím klíčovým konceptům, výhodám, omezením a implementačním technikám můžete využít Schema Stitching ke zjednodušení přístupu k datům, zlepšení škálovatelnosti a zvýšení udržovatelnosti. Ačkoli se Apollo Federation ukázala jako pokročilejší řešení, Schema Stitching zůstává životaschopnou volbou pro jednodušší scénáře nebo při integraci stávajících služeb GraphQL. Pečlivě zvažte své specifické potřeby a požadavky, abyste si vybrali nejlepší přístup pro vaši organizaci.