Deutsch

Entfesseln Sie die Kraft der GraphQL Federation mit Schema Stitching. Erfahren Sie, wie Sie eine einheitliche GraphQL-API aus mehreren Diensten erstellen und so die Skalierbarkeit und Wartbarkeit verbessern.

GraphQL Federation: Schema Stitching – Ein umfassender Leitfaden

In der sich ständig weiterentwickelnden Landschaft der modernen Anwendungsentwicklung ist der Bedarf an skalierbaren und wartbaren Architekturen von größter Bedeutung geworden. Microservices, mit ihrer inhärenten Modularität und unabhängigen Bereitstellbarkeit, haben sich als eine beliebte Lösung erwiesen. Die Verwaltung zahlreicher Microservices kann jedoch zu Komplexität führen, insbesondere wenn es darum geht, Client-Anwendungen eine einheitliche API bereitzustellen. Hier kommen GraphQL Federation und insbesondere Schema Stitching ins Spiel.

Was ist GraphQL Federation?

GraphQL Federation ist eine leistungsstarke Architektur, die es Ihnen ermöglicht, eine einzige, einheitliche GraphQL-API aus mehreren zugrunde liegenden GraphQL-Diensten (oft Microservices repräsentierend) zu erstellen. Sie ermöglicht es Entwicklern, Daten über verschiedene Dienste hinweg abzufragen, als wäre es ein einziger Graph, was die Client-Erfahrung vereinfacht und die Notwendigkeit komplexer Orchestrierungslogik auf der Client-Seite reduziert.

Es gibt zwei primäre Ansätze für die GraphQL Federation:

Dieser Artikel konzentriert sich auf Schema Stitching und untersucht dessen Konzepte, Vorteile, Einschränkungen und praktische Umsetzung.

Grundlagen des Schema Stitching

Schema Stitching ist der Prozess des Zusammenführens mehrerer GraphQL-Schemas zu einem einzigen, zusammenhängenden Schema. Dieses einheitliche Schema fungiert als Fassade und verbirgt die Komplexität der zugrunde liegenden Dienste vor dem Client. Wenn ein Client eine Anfrage an das zusammengefügte Schema stellt, leitet das Gateway die Anfrage intelligent an den/die entsprechenden zugrunde liegenden Dienst(e) weiter, ruft die Daten ab und kombiniert die Ergebnisse, bevor sie an den Client zurückgegeben werden.

Stellen Sie es sich so vor: Sie haben mehrere Restaurants (Dienste), die jeweils auf unterschiedliche Küchen spezialisiert sind. Schema Stitching ist wie eine universelle Speisekarte, die alle Gerichte aus jedem Restaurant kombiniert. Wenn ein Kunde (Client) von der universellen Speisekarte bestellt, wird die Bestellung intelligent an die entsprechenden Restaurantküchen weitergeleitet, das Essen wird zubereitet und dann zu einer einzigen Lieferung für den Kunden zusammengefasst.

Schlüsselkonzepte beim Schema Stitching

Vorteile von Schema Stitching

Schema Stitching bietet mehrere überzeugende Vorteile für Organisationen, die eine Microservices-Architektur einführen:

Einschränkungen von Schema Stitching

Obwohl Schema Stitching zahlreiche Vorteile bietet, ist es wichtig, sich seiner Einschränkungen bewusst zu sein:

Praktische Umsetzung von Schema Stitching

Gehen wir ein vereinfachtes Beispiel durch, wie man Schema Stitching mit Node.js und der graphql-tools-Bibliothek (eine beliebte Wahl für Schema Stitching) implementiert. Dieses Beispiel umfasst zwei Microservices: einen User-Service und einen Product-Service.

1. Definieren der Remote-Schemas

Definieren Sie zuerst die GraphQL-Schemas für jeden der Remote-Dienste.

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

Product-Service (product-service.js):


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

const productSchema = buildSchema(`
  type Product {
    id: ID!
    name: String
    price: Float
    userId: ID!  # Fremdschlüssel zum 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. Erstellen des Gateway-Service

Erstellen Sie nun den Gateway-Service, der die beiden Schemas zusammenfügen wird.

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 läuft auf http://localhost:4000/graphql'));
}

main().catch(console.error);

3. Ausführen der Dienste

Sie müssen den User-Service und den Product-Service auf verschiedenen Ports ausführen. Zum Beispiel:

User-Service (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 läuft auf http://localhost:4001/graphql'));

Product-Service (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 läuft auf http://localhost:4002/graphql'));

4. Abfragen des zusammengefügten Schemas

Jetzt können Sie das zusammengefügte Schema über das Gateway (das auf Port 4000 läuft) abfragen. Sie können eine Abfrage wie diese ausführen:


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

Diese Abfrage ruft das Produkt mit der ID "101" ab und holt auch den zugehörigen Benutzer vom User-Service. Dies zeigt, wie Schema Stitching es Ihnen ermöglicht, Daten über mehrere Dienste hinweg in einer einzigen Anfrage abzufragen.

Fortgeschrittene Techniken für Schema Stitching

Über das einfache Beispiel hinaus gibt es einige fortgeschrittene Techniken, die zur Verbesserung Ihrer Schema-Stitching-Implementierung verwendet werden können:

Die Wahl zwischen Schema Stitching und Apollo Federation

Obwohl Schema Stitching eine praktikable Option für GraphQL Federation ist, hat sich Apollo Federation aufgrund seiner fortschrittlichen Funktionen und der verbesserten Entwicklererfahrung zur beliebteren Wahl entwickelt. Hier ist ein Vergleich der beiden Ansätze:

Merkmal Schema Stitching Apollo Federation
Schema-Definition Verwendet die bestehende GraphQL-Schema-Sprache Verwendet eine deklarative Schema-Sprache mit Direktiven
Abfrageplanung Erfordert manuelle Abfrage-Delegation Automatische Abfrageplanung durch das Apollo Gateway
Typ-Erweiterungen Begrenzte Unterstützung Integrierte Unterstützung für Typ-Erweiterungen
Key-Direktiven Nicht unterstützt Verwendet die @key-Direktive zur Identifizierung von Entitäten
Verteiltes Tracing Erfordert manuelle Implementierung Integrierte Unterstützung für verteiltes Tracing
Tooling und Ökosystem Weniger ausgereiftes Tooling Ausgereifteres Tooling und eine große Community
Komplexität Kann in großen Systemen komplex zu verwalten sein Für große und komplexe Systeme konzipiert

Wann Sie Schema Stitching wählen sollten:

Wann Sie Apollo Federation wählen sollten:

Praxisbeispiele und Anwendungsfälle

Hier sind einige Praxisbeispiele, wie GraphQL Federation, einschließlich Schema Stitching, verwendet werden kann:

Best Practices für Schema Stitching

Um eine erfolgreiche Implementierung von Schema Stitching zu gewährleisten, befolgen Sie diese Best Practices:

Fazit

GraphQL Federation mit Schema Stitching bietet einen leistungsstarken Ansatz zum Erstellen einheitlicher APIs aus mehreren Diensten in einer Microservices-Architektur. Indem Sie die Kernkonzepte, Vorteile, Einschränkungen und Implementierungstechniken verstehen, können Sie Schema Stitching nutzen, um den Datenzugriff zu vereinfachen, die Skalierbarkeit zu verbessern und die Wartbarkeit zu erhöhen. Obwohl sich Apollo Federation als eine fortschrittlichere Lösung herauskristallisiert hat, bleibt Schema Stitching eine praktikable Option für einfachere Szenarien oder bei der Integration bestehender GraphQL-Dienste. Berücksichtigen Sie sorgfältig Ihre spezifischen Bedürfnisse und Anforderungen, um den besten Ansatz für Ihre Organisation zu wählen.

GraphQL Federation: Schema Stitching – Ein umfassender Leitfaden | MLOG