Bahasa Indonesia

Buka kekuatan Federasi GraphQL dengan Schema Stitching. Pelajari cara membangun API GraphQL terpadu dari berbagai layanan, meningkatkan skalabilitas dan pemeliharaan.

Federasi GraphQL: Schema Stitching - Panduan Komprehensif

Dalam lanskap pengembangan aplikasi modern yang terus berkembang, kebutuhan akan arsitektur yang dapat diskalakan dan dipelihara telah menjadi hal terpenting. Microservices, dengan modularitas bawaan dan kemampuan penerapan independennya, telah muncul sebagai solusi populer. Namun, mengelola banyak layanan mikro dapat menimbulkan kompleksitas, terutama dalam hal mengekspos API terpadu ke aplikasi klien. Di sinilah Federasi GraphQL, dan khususnya Schema Stitching, berperan.

Apa itu Federasi GraphQL?

Federasi GraphQL adalah arsitektur canggih yang memungkinkan Anda membangun satu API GraphQL terpadu dari beberapa layanan GraphQL yang mendasarinya (sering kali mewakili layanan mikro). Ini memungkinkan pengembang untuk meminta data di berbagai layanan seolah-olah itu adalah satu grafik tunggal, menyederhanakan pengalaman klien dan mengurangi kebutuhan akan logika orkestrasi yang kompleks di sisi klien.

Ada dua pendekatan utama untuk Federasi GraphQL:

Artikel ini berfokus pada Schema Stitching, menjelajahi konsep, manfaat, batasan, dan implementasi praktisnya.

Memahami Schema Stitching

Schema Stitching adalah proses menggabungkan beberapa skema GraphQL menjadi satu skema yang kohesif dan terpadu. Skema terpadu ini bertindak sebagai fasad, menyembunyikan kompleksitas layanan yang mendasarinya dari klien. Ketika klien membuat permintaan ke skema yang digabungkan, gateway secara cerdas merutekan permintaan ke layanan yang sesuai, mengambil data, dan menggabungkan hasilnya sebelum mengembalikannya ke klien.

Bayangkan seperti ini: Anda memiliki beberapa restoran (layanan) yang masing-masing berspesialisasi dalam masakan yang berbeda. Schema Stitching seperti menu universal yang menggabungkan semua hidangan dari setiap restoran. Ketika pelanggan (klien) memesan dari menu universal, pesanan tersebut secara cerdas dirutekan ke dapur restoran yang sesuai, makanan disiapkan, dan kemudian digabungkan menjadi satu pengiriman untuk pelanggan.

Konsep Kunci dalam Schema Stitching

Manfaat Schema Stitching

Schema Stitching menawarkan beberapa manfaat menarik bagi organisasi yang mengadopsi arsitektur layanan mikro:

Keterbatasan Schema Stitching

Meskipun Schema Stitching menawarkan banyak keuntungan, penting untuk menyadari keterbatasannya:

Implementasi Praktis Schema Stitching

Mari kita lihat contoh sederhana tentang cara mengimplementasikan Schema Stitching menggunakan Node.js dan pustaka graphql-tools (pilihan populer untuk schema stitching). Contoh ini melibatkan dua layanan mikro: Layanan Pengguna (User Service) dan Layanan Produk (Product Service).

1. Definisikan Skema Jarak Jauh

Pertama, definisikan skema GraphQL untuk setiap layanan jarak jauh.

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

Layanan Produk (product-service.js):


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

const productSchema = buildSchema(`
  type Product {
    id: ID!
    name: String
    price: Float
    userId: ID!  # Kunci asing ke Layanan Pengguna
  }

  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. Buat Layanan Gateway

Sekarang, buat layanan gateway yang akan menggabungkan kedua skema tersebut.

Layanan Gateway (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('Server gateway berjalan di http://localhost:4000/graphql'));
}

main().catch(console.error);

3. Jalankan Layanan

Anda perlu menjalankan Layanan Pengguna dan Layanan Produk di port yang berbeda. Contohnya:

Layanan Pengguna (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('Layanan pengguna berjalan di http://localhost:4001/graphql'));

Layanan Produk (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('Layanan produk berjalan di http://localhost:4002/graphql'));

4. Kueri Skema yang Digabungkan

Sekarang Anda dapat membuat kueri pada skema yang digabungkan melalui gateway (berjalan di port 4000). Anda dapat menjalankan kueri seperti ini:


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

Kueri ini mengambil produk dengan ID "101" dan juga mengambil pengguna terkait dari Layanan Pengguna, menunjukkan bagaimana Schema Stitching memungkinkan Anda untuk meminta data di beberapa layanan dalam satu permintaan.

Teknik Schema Stitching Tingkat Lanjut

Di luar contoh dasar, berikut adalah beberapa teknik canggih yang dapat digunakan untuk meningkatkan implementasi Schema Stitching Anda:

Memilih Antara Schema Stitching dan Apollo Federation

Meskipun Schema Stitching adalah pilihan yang layak untuk Federasi GraphQL, Apollo Federation telah menjadi pilihan yang lebih populer karena fitur-fitur canggih dan pengalaman pengembang yang lebih baik. Berikut perbandingan kedua pendekatan tersebut:

Fitur Schema Stitching Apollo Federation
Definisi Skema Menggunakan bahasa skema GraphQL yang ada Menggunakan bahasa skema deklaratif dengan direktif
Perencanaan Kueri Memerlukan delegasi kueri manual Perencanaan kueri otomatis oleh Apollo Gateway
Ekstensi Tipe Dukungan terbatas Dukungan bawaan untuk ekstensi tipe
Direktif Kunci Tidak didukung Menggunakan direktif @key untuk mengidentifikasi entitas
Pelacakan Terdistribusi Memerlukan implementasi manual Dukungan bawaan untuk pelacakan terdistribusi
Perkakas dan Ekosistem Perkakas kurang matang Perkakas lebih matang dan komunitas besar
Kompleksitas Bisa rumit untuk dikelola dalam sistem besar Dirancang untuk sistem besar dan kompleks

Kapan Memilih Schema Stitching:

Kapan Memilih Apollo Federation:

Contoh Dunia Nyata dan Kasus Penggunaan

Berikut adalah beberapa contoh dunia nyata tentang bagaimana Federasi GraphQL, termasuk Schema Stitching, dapat digunakan:

Praktik Terbaik untuk Schema Stitching

Untuk memastikan implementasi Schema Stitching yang sukses, ikuti praktik terbaik berikut:

Kesimpulan

Federasi GraphQL dengan Schema Stitching menawarkan pendekatan yang kuat untuk membangun API terpadu dari beberapa layanan dalam arsitektur layanan mikro. Dengan memahami konsep inti, manfaat, batasan, dan teknik implementasinya, Anda dapat memanfaatkan Schema Stitching untuk menyederhanakan akses data, meningkatkan skalabilitas, dan meningkatkan kemudahan pemeliharaan. Meskipun Apollo Federation telah muncul sebagai solusi yang lebih canggih, Schema Stitching tetap menjadi pilihan yang layak untuk skenario yang lebih sederhana atau saat mengintegrasikan layanan GraphQL yang ada. Pertimbangkan dengan cermat kebutuhan dan persyaratan spesifik Anda untuk memilih pendekatan terbaik bagi organisasi Anda.

Federasi GraphQL: Schema Stitching - Panduan Komprehensif | MLOG