68 Gateway Server dan Remote Schema Stitching: Langkah Futuristik untuk API Grafana

API modern membutuhkan fleksibilitas, skalabilitas, dan integrasi yang seamless. Dengan semakin populernya arsitektur microservices, muncul tantangan baru: bagaimana mengintegrasikan berbagai layanan yang masing-masing memiliki GraphQL schema sendiri? Di sinilah konsep gateway server dan remote schema stitching menjadi krusial. Pada artikel ini, saya akan membahas konsep 68 Gateway Server, mengapa Remote Schema Stitching penting, dan bagaimana mengimplementasikannya, dilengkapi dengan contoh kode, diagram alur, dan simulasi sederhana.

Apa itu 68 Gateway Server?

Istilah “68 Gateway Server” merujuk pada sebuah arsitektur gateway yang dapat menghubungkan hingga 68 sumber (source) schema berbeda—baik monolitik maupun microservice—dalam satu GraphQL API yang terintegrasi secara seamless. Walaupun angka 68 hanya metafora, konsep dasarnya adalah memberikan satu pintu depan bagi banyak layanan di belakang layar.

Manfaat utamanya antara lain:

• Single entry point: Satu endpoint GraphQL untuk semua layanan.
• Centralized authentication & authorization: Satu layer untuk otentikasi dan otorisasi.
• Schema federation & composition: Menggabungkan banyak schema GraphQL secara dinamis.

Memahami Remote Schema Stitching

Schema stitching adalah teknik untuk menggabungkan beberapa GraphQL schema yang terpisah menjadi satu schema besar. Dengan remote schema stitching, proses ini dilakukan secara dinamis ke sumber-sumber schema eksternal (remote).

Contoh kasus:

• Service A (User Service): Mengelola data user.
• Service B (Product Service): Mengelola data produk.

Dengan schema stitching, klien bisa meng-query data user dan data produk melalui satu endpoint.

Perbedaan Schema Stitching dan Federation

Sebelum implementasi, kamu perlu tahu perbedaan skema terkenal dalam GraphQL gateway:

Diagram Arsitektur dengan Schema Stitching

Mari lihat diagram alur bagaimana 68 Gateway Server melakukan schema stitching:

graph TD
    subgraph Gateway Server
        GWS(Gateway)
    end
    subgraph Microservices
        SVC1[User Service]
        SVC2[Product Service]
        SVC3[Inventory Service]
        SVCx[Service 68...]
    end
    Client --> GWS
    GWS --> SVC1
    GWS --> SVC2
    GWS --> SVC3
    GWS --> SVCx

Dalam arsitektur ini, Gateway menjadi satu-satunya interface ke banyak backend services.

Implementasi: Remote Schema Stitching dengan Node.js & @graphql-tools

Untuk implementasi memungkinkan remote stitching, kita akan gunakan package @graphql-tools/stitch yang sangat powerful.

Contoh: Stitching User dan Product Service

Step 1: Persiapkan Remote Executable Schema

Asumsikan dua service utama telah online di endpoint masing-masing.

• User Service: http://localhost:4001/graphql
• Product Service: http://localhost:4002/graphql

Step 2: Gateway Code (server.js)

const { stitchSchemas } = require('@graphql-tools/stitch');
const { makeRemoteExecutableSchema } = require('@graphql-tools/wrap');
const { introspectSchema } = require('@graphql-tools/wrap');
const { ApolloServer } = require('apollo-server');
const { HttpLink } = require('apollo-link-http');
const fetch = require('node-fetch');

async function buildGatewaySchema() {
    // Create link to remote services
    const userLink = new HttpLink({ uri: 'http://localhost:4001/graphql', fetch });
    const productLink = new HttpLink({ uri: 'http://localhost:4002/graphql', fetch });

    // Introspect and wrap remote schemas
    const userSchema = makeRemoteExecutableSchema({
        schema: await introspectSchema(userLink),
        link: userLink,
    });

    const productSchema = makeRemoteExecutableSchema({
        schema: await introspectSchema(productLink),
        link: productLink,
    });

    // Stitch schemas with custom resolvers if needed
    return stitchSchemas({
        subschemas: [
            { schema: userSchema },
            { schema: productSchema }
        ],
        // Optionally, define merge logic or resolvers di sini
    });
}

async function startServer() {
    const schema = await buildGatewaySchema();

    const server = new ApolloServer({ schema });

    server.listen(4000).then(({ url }) => {
        console.log(`🚀 Gateway ready at ${url}`);
    });
}
startServer();

Dengan kode ini, server menerima permintaan ke satu endpoint (localhost:4000) tapi data diambil dari dua service berbeda.

Simulasi Query Gateway

Anda bisa melakukan query gabungan seperti berikut ini pada gateway:

query {
  userById(id: "u123") {
    id
    name
  }
  products {
    id
    name
    stock
  }
}

Gateway akan meneruskan query ke masing-masing service, mengambil hasilnya, dan mengembalikannya ke klien seolah-olah semua data diambil dari satu schema terintegrasi.

Manajemen Skala: Bagaimana Jika Ada 68 Service?

Realitanya, dalam dunia enterprise, layanan bisa sangat banyak. Kode di atas sudah scalable untuk menambah service baru:

const services = [
  'http://localhost:4001/graphql',
  'http://localhost:4002/graphql',
  // ... hingga 68 endpoint
];
const schemas = [];
for (const uri of services) {
    const link = new HttpLink({ uri, fetch });
    const schema = await makeRemoteExecutableSchema({
        schema: await introspectSchema(link),
        link
    });
    schemas.push({ schema });
}
return stitchSchemas({ subschemas: schemas });

Catatan: Sesuaikan koneksi, memory, dan timeouts agar tidak overfetching.

Best Practices dan Tantangan

Kesimpulan

Arsitektur 68 Gateway Server with Remote Schema Stitching membuka jalan untuk API masa depan dengan mengintegrasikan banyak sistem secara elegan, mudah, dan scalable. Dengan teknik ini, maintenance, scaling, dan iterasi menjadi jauh lebih mudah. Contoh di atas menunjukkan betapa powerful-nya GraphQL dan ekosistem JavaScript dalam menyatukan data tanpa mengorbankan fleksibilitas atau keamanan.

Jika perusahaan Anda sedang menuju arsitektur microservices, cobalah beri kesempatan pada pattern ini—siapa tahu, Anda akan menjadi tim selanjutnya yang sukses membawa legacy services ke masa depan!

Jangan lupa share dan diskusikan pengalaman kamu membangun API Gateway di kolom komentar! 🚀