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:

• Schema Stitching: Ini melibatkan penggabungan beberapa skema GraphQL menjadi satu skema terpadu di lapisan gateway. Ini adalah pendekatan yang lebih awal dan mengandalkan pustaka untuk mengelola kombinasi skema dan delegasi kueri.
• Apollo Federation: Ini adalah pendekatan yang lebih baru dan kuat yang menggunakan bahasa skema deklaratif dan perencana kueri khusus untuk mengelola proses federasi. Ini menawarkan fitur-fitur canggih seperti ekstensi tipe, direktif kunci, dan pelacakan terdistribusi.

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

• Skema Jarak Jauh (Remote Schemas): Ini adalah skema GraphQL individu dari setiap layanan yang mendasarinya. Setiap layanan mengekspos skemanya sendiri, yang mendefinisikan data dan operasi yang disediakannya.
• Gateway: Gateway adalah komponen sentral yang bertanggung jawab untuk menggabungkan skema jarak jauh dan mengekspos skema terpadu ke klien. Ia menerima permintaan klien, merutekannya ke layanan yang sesuai, dan menggabungkan hasilnya.
• Penggabungan Skema (Schema Merging): Ini adalah proses menggabungkan skema jarak jauh menjadi satu skema tunggal. Ini sering kali melibatkan penggantian nama tipe dan bidang untuk menghindari konflik dan mendefinisikan hubungan antar tipe di berbagai skema.
• Delegasi Kueri (Query Delegation): Ketika klien membuat permintaan ke skema yang digabungkan, gateway perlu mendelegasikan permintaan ke layanan yang sesuai untuk mengambil data. Ini melibatkan penerjemahan kueri klien menjadi kueri yang dapat dipahami oleh layanan jarak jauh.
• Agregasi Hasil (Result Aggregation): Setelah gateway mengambil data dari layanan yang mendasarinya, ia perlu menggabungkan hasilnya menjadi satu respons yang dapat dikembalikan ke klien. Ini sering kali melibatkan transformasi data agar sesuai dengan struktur skema yang digabungkan.

Manfaat Schema Stitching

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

• API Terpadu: Menyediakan satu API yang konsisten untuk klien, menyederhanakan akses data dan mengurangi kebutuhan klien untuk berinteraksi dengan banyak layanan secara langsung. Ini menghasilkan pengalaman pengembang yang lebih bersih dan intuitif.
• Mengurangi Kompleksitas Klien: Klien hanya perlu berinteraksi dengan skema terpadu, melindungi mereka dari kompleksitas arsitektur layanan mikro yang mendasarinya. Ini menyederhanakan pengembangan sisi klien dan mengurangi jumlah kode yang diperlukan pada klien.
• Peningkatan Skalabilitas: Memungkinkan Anda untuk menskalakan layanan individu secara independen berdasarkan kebutuhan spesifik mereka. Ini meningkatkan skalabilitas dan ketahanan sistem secara keseluruhan. Misalnya, layanan pengguna yang mengalami beban tinggi dapat diskalakan tanpa memengaruhi layanan lain seperti katalog produk.
• Peningkatan Kemudahan Pemeliharaan: Mendorong modularitas dan pemisahan masalah, membuatnya lebih mudah untuk memelihara dan mengembangkan layanan individu. Perubahan pada satu layanan cenderung tidak berdampak pada layanan lain.
• Adopsi Bertahap: Dapat diimplementasikan secara bertahap, memungkinkan Anda untuk bermigrasi secara bertahap dari arsitektur monolitik ke arsitektur layanan mikro. Anda dapat memulai dengan menggabungkan API yang ada dan kemudian secara bertahap mengurai monolit menjadi layanan yang lebih kecil.

Keterbatasan Schema Stitching

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

• Kompleksitas: Mengimplementasikan dan mengelola schema stitching bisa jadi rumit, terutama pada sistem yang besar dan kompleks. Perencanaan dan desain yang cermat sangat penting.
• Overhead Kinerja: Gateway memperkenalkan beberapa overhead kinerja karena lapisan tambahan indireksi dan kebutuhan untuk mendelegasikan kueri dan mengagregasi hasil. Optimisasi yang cermat sangat penting untuk meminimalkan overhead ini.
• Konflik Skema: Konflik dapat muncul saat menggabungkan skema dari layanan yang berbeda, terutama jika mereka menggunakan nama tipe atau nama bidang yang sama. Ini memerlukan desain skema yang cermat dan berpotensi mengganti nama tipe dan bidang.
• Fitur Lanjutan Terbatas: Dibandingkan dengan Apollo Federation, Schema Stitching kekurangan beberapa fitur canggih seperti ekstensi tipe dan direktif kunci, yang dapat membuatnya lebih menantang untuk mengelola hubungan antar tipe di berbagai skema.
• Kematangan Perkakas: Perkakas dan ekosistem di sekitar Schema Stitching tidak sematang yang ada di sekitar Apollo Federation. Ini bisa membuatnya lebih menantang untuk men-debug dan memecahkan masalah.

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

            

              
                Copy
              
            
          

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

            

              
                Copy
              
            
          

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);

            

              
                Copy
              
            
          

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'));

            

              
                Copy
              
            
          

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'));

            

              
                Copy
              
            
          

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

            

              
                Copy
              
            
          

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:

• Delegasi Skema: Ini memungkinkan Anda untuk mendelegasikan bagian dari kueri ke layanan yang berbeda berdasarkan data yang diminta. Misalnya, Anda mungkin mendelegasikan resolusi tipe `User` ke Layanan Pengguna dan resolusi tipe `Product` ke Layanan Produk.
• Transformasi Skema: Ini melibatkan modifikasi skema layanan jarak jauh sebelum digabungkan ke dalam skema terpadu. Ini dapat berguna untuk mengganti nama tipe dan bidang, menambahkan bidang baru, atau menghapus bidang yang ada.
• Resolver Kustom: Anda dapat mendefinisikan resolver kustom di gateway untuk menangani transformasi data yang kompleks atau untuk mengambil data dari beberapa layanan dan menggabungkannya menjadi satu hasil.
• Berbagi Konteks: Seringkali perlu untuk berbagi informasi konteks antara gateway dan layanan jarak jauh, seperti token otentikasi atau ID pengguna. Ini dapat dicapai dengan meneruskan informasi konteks sebagai bagian dari proses delegasi kueri.
• Penanganan Kesalahan: Implementasikan penanganan kesalahan yang kuat untuk menangani kesalahan yang terjadi di layanan jarak jauh dengan anggun. Ini mungkin termasuk mencatat kesalahan, mengembalikan pesan kesalahan yang ramah pengguna, atau mencoba kembali permintaan yang gagal.

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:

Kapan Memilih Schema Stitching:

• Anda memiliki layanan GraphQL yang ada dan ingin menggabungkannya dengan cepat.
• Anda memerlukan solusi federasi sederhana dan tidak memerlukan fitur canggih.
• Anda memiliki sumber daya terbatas dan ingin menghindari overhead pengaturan Apollo Federation.

Kapan Memilih Apollo Federation:

• Anda sedang membangun sistem yang besar dan kompleks dengan banyak tim dan layanan.
• Anda memerlukan fitur canggih seperti ekstensi tipe, direktif kunci, dan pelacakan terdistribusi.
• Anda menginginkan solusi federasi yang lebih kuat dan dapat diskalakan.
• Anda lebih menyukai pendekatan federasi yang lebih deklaratif dan otomatis.

Contoh Dunia Nyata dan Kasus Penggunaan

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

• Platform E-commerce: Platform e-commerce mungkin menggunakan Federasi GraphQL untuk menggabungkan data dari beberapa layanan, seperti layanan katalog produk, layanan pengguna, layanan pesanan, dan layanan pembayaran. Ini memungkinkan klien untuk dengan mudah mengambil semua informasi yang mereka butuhkan untuk menampilkan detail produk, profil pengguna, riwayat pesanan, dan informasi pembayaran.
• Platform Media Sosial: Platform media sosial dapat menggunakan Federasi GraphQL untuk menggabungkan data dari layanan yang mengelola profil pengguna, postingan, komentar, dan suka. Ini memungkinkan klien untuk secara efisien mengambil semua informasi yang diperlukan untuk menampilkan profil pengguna, postingan mereka, serta komentar dan suka yang terkait dengan postingan tersebut.
• Aplikasi Layanan Keuangan: Aplikasi layanan keuangan mungkin menggunakan Federasi GraphQL untuk menggabungkan data dari layanan yang mengelola akun, transaksi, dan investasi. Ini memungkinkan klien untuk dengan mudah mengambil semua informasi yang mereka butuhkan untuk menampilkan saldo akun, riwayat transaksi, dan portofolio investasi.
• Sistem Manajemen Konten (CMS): CMS dapat memanfaatkan Federasi GraphQL untuk mengintegrasikan data dari berbagai sumber seperti artikel, gambar, video, dan konten buatan pengguna. Ini memungkinkan API terpadu untuk mengambil semua konten yang terkait dengan topik atau penulis tertentu.
• Aplikasi Perawatan Kesehatan: Mengintegrasikan data pasien dari sistem yang berbeda seperti rekam medis elektronik (EHR), hasil lab, dan penjadwalan janji temu. Ini menawarkan dokter satu titik akses ke informasi pasien yang komprehensif.

Praktik Terbaik untuk Schema Stitching

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

• Rencanakan Skema Anda dengan Cermat: Sebelum Anda mulai menggabungkan skema, rencanakan struktur skema terpadu dengan cermat. Ini termasuk mendefinisikan hubungan antar tipe di berbagai skema, mengganti nama tipe dan bidang untuk menghindari konflik, dan mempertimbangkan pola akses data secara keseluruhan.
• Gunakan Konvensi Penamaan yang Konsisten: Adopsi konvensi penamaan yang konsisten untuk tipe, bidang, dan operasi di semua layanan. Ini akan membantu menghindari konflik dan membuatnya lebih mudah untuk memahami skema terpadu.
• Dokumentasikan Skema Anda: Dokumentasikan skema terpadu secara menyeluruh, termasuk deskripsi tipe, bidang, dan operasi. Ini akan memudahkan pengembang untuk memahami dan menggunakan skema.
• Pantau Kinerja: Pantau kinerja gateway dan layanan jarak jauh untuk mengidentifikasi dan mengatasi setiap hambatan kinerja. Gunakan alat seperti pelacakan terdistribusi untuk melacak permintaan di beberapa layanan.
• Terapkan Keamanan: Terapkan langkah-langkah keamanan yang sesuai untuk melindungi gateway dan layanan jarak jauh dari akses yang tidak sah. Ini mungkin melibatkan penggunaan mekanisme otentikasi dan otorisasi, serta validasi input dan pengkodean output.
• Versikan Skema Anda: Saat Anda mengembangkan skema Anda, versikan dengan tepat untuk memastikan bahwa klien dapat terus menggunakan versi skema yang lebih lama tanpa merusaknya. Ini akan membantu menghindari perubahan yang merusak dan memastikan kompatibilitas mundur.
• Otomatiskan Penerapan: Otomatiskan penerapan gateway dan layanan jarak jauh untuk memastikan bahwa perubahan dapat diterapkan dengan cepat dan andal. Ini akan membantu mengurangi risiko kesalahan dan meningkatkan kelincahan sistem secara keseluruhan.

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.