ગુજરાતી

સ્કીમા સ્ટીચિંગ સાથે GraphQL ફેડરેશનની શક્તિને અનલોક કરો. બહુવિધ સેવાઓમાંથી એકીકૃત GraphQL API કેવી રીતે બનાવવું તે શીખો, જે સ્કેલેબિલીટી અને જાળવણીક્ષમતામાં સુધારો કરે છે.

GraphQL ફેડરેશન: સ્કીમા સ્ટીચિંગ - એક વ્યાપક માર્ગદર્શિકા

આધુનિક એપ્લિકેશન ડેવલપમેન્ટના સતત વિકસતા લેન્ડસ્કેપમાં, સ્કેલેબલ અને જાળવણીક્ષમ આર્કિટેક્ચરની જરૂરિયાત સર્વોપરી બની છે. માઇક્રોસર્વિસિસ, તેમની સહજ મોડ્યુલારિટી અને સ્વતંત્ર ડિપ્લોયબિલિટી સાથે, એક લોકપ્રિય ઉકેલ તરીકે ઉભરી આવી છે. જોકે, અસંખ્ય માઇક્રોસર્વિસિસનું સંચાલન જટિલતાઓ ઊભી કરી શકે છે, ખાસ કરીને જ્યારે ક્લાયંટ એપ્લિકેશન્સ માટે એકીકૃત API એક્સપોઝ કરવાની વાત આવે છે. આ તે સ્થાન છે જ્યાં GraphQL ફેડરેશન, અને ખાસ કરીને સ્કીમા સ્ટીચિંગ, ભૂમિકા ભજવે છે.

GraphQL ફેડરેશન શું છે?

GraphQL ફેડરેશન એ એક શક્તિશાળી આર્કિટેક્ચર છે જે તમને બહુવિધ અંતર્ગત GraphQL સેવાઓ (ઘણીવાર માઇક્રોસર્વિસિસનું પ્રતિનિધિત્વ કરે છે) માંથી એક, એકીકૃત GraphQL API બનાવવાની મંજૂરી આપે છે. તે ડેવલપર્સને વિવિધ સેવાઓમાંથી ડેટા ક્વેરી કરવાની સુવિધા આપે છે જાણે કે તે એક જ ગ્રાફ હોય, જે ક્લાયંટ અનુભવને સરળ બનાવે છે અને ક્લાયંટ-સાઇડ પર જટિલ ઓર્કેસ્ટ્રેશન લોજિકની જરૂરિયાત ઘટાડે છે.

GraphQL ફેડરેશનના બે મુખ્ય અભિગમો છે:

આ લેખ સ્કીમા સ્ટીચિંગ પર ધ્યાન કેન્દ્રિત કરે છે, તેના ખ્યાલો, ફાયદા, મર્યાદાઓ અને વ્યવહારુ અમલીકરણની શોધ કરે છે.

સ્કીમા સ્ટીચિંગને સમજવું

સ્કીમા સ્ટીચિંગ એ બહુવિધ GraphQL સ્કીમાને એક, સુસંગત સ્કીમામાં મર્જ કરવાની પ્રક્રિયા છે. આ એકીકૃત સ્કીમા એક ફેકેડ તરીકે કાર્ય કરે છે, જે ક્લાયંટથી અંતર્ગત સેવાઓની જટિલતાને છુપાવે છે. જ્યારે ક્લાયંટ સ્ટીચ્ડ સ્કીમાને વિનંતી કરે છે, ત્યારે ગેટવે બુદ્ધિપૂર્વક વિનંતીને યોગ્ય અંતર્ગત સેવા(ઓ) પર રૂટ કરે છે, ડેટા મેળવે છે અને પરિણામોને ક્લાયંટને પરત કરતા પહેલાં તેને જોડે છે.

તેને આ રીતે વિચારો: તમારી પાસે બહુવિધ રેસ્ટોરન્ટ્સ (સેવાઓ) છે, દરેક અલગ-અલગ વાનગીઓમાં વિશેષતા ધરાવે છે. સ્કીમા સ્ટીચિંગ એ એક યુનિવર્સલ મેનૂ જેવું છે જે દરેક રેસ્ટોરન્ટની તમામ વાનગીઓને જોડે છે. જ્યારે ગ્રાહક (ક્લાયંટ) યુનિવર્સલ મેનૂમાંથી ઓર્ડર કરે છે, ત્યારે ઓર્ડર બુદ્ધિપૂર્વક યોગ્ય રેસ્ટોરન્ટ કિચનમાં રૂટ કરવામાં આવે છે, ખોરાક તૈયાર કરવામાં આવે છે, અને પછી ગ્રાહક માટે એક જ ડિલિવરીમાં જોડવામાં આવે છે.

સ્કીમા સ્ટીચિંગમાં મુખ્ય ખ્યાલો

સ્કીમા સ્ટીચિંગના ફાયદા

સ્કીમા સ્ટીચિંગ માઇક્રોસર્વિસિસ આર્કિટેક્ચર અપનાવતી સંસ્થાઓ માટે ઘણા આકર્ષક ફાયદાઓ પ્રદાન કરે છે:

સ્કીમા સ્ટીચિંગની મર્યાદાઓ

જ્યારે સ્કીમા સ્ટીચિંગ અસંખ્ય ફાયદાઓ પ્રદાન કરે છે, ત્યારે તેની મર્યાદાઓથી વાકેફ રહેવું મહત્વપૂર્ણ છે:

સ્કીમા સ્ટીચિંગનું વ્યવહારુ અમલીકરણ

ચાલો Node.js અને graphql-tools લાઇબ્રેરી (સ્કીમા સ્ટીચિંગ માટે એક લોકપ્રિય પસંદગી) નો ઉપયોગ કરીને સ્કીમા સ્ટીચિંગ કેવી રીતે અમલમાં મૂકવું તેના એક સરળ ઉદાહરણમાંથી પસાર થઈએ. આ ઉદાહરણમાં બે માઇક્રોસર્વિસિસનો સમાવેશ થાય છે: એક વપરાશકર્તા સેવા અને એક ઉત્પાદન સેવા.

1. રિમોટ સ્કીમા વ્યાખ્યાયિત કરો

પ્રથમ, દરેક રિમોટ સેવા માટે GraphQL સ્કીમા વ્યાખ્યાયિત કરો.

વપરાશકર્તા સેવા (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.js):


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

const productSchema = buildSchema(`
  type Product {
    id: ID!
    name: String
    price: Float
    userId: ID!  # Foreign key to 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. ગેટવે સેવા બનાવો

હવે, ગેટવે સેવા બનાવો જે બે સ્કીમાને એકસાથે સ્ટીચ કરશે.

ગેટવે સેવા (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. સેવાઓ ચલાવો

તમારે વપરાશકર્તા સેવા અને ઉત્પાદન સેવાને અલગ-અલગ પોર્ટ પર ચલાવવાની જરૂર પડશે. ઉદાહરણ તરીકે:

વપરાશકર્તા સેવા (પોર્ટ 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'));

ઉત્પાદન સેવા (પોર્ટ 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. સ્ટીચ્ડ સ્કીમાને ક્વેરી કરો

હવે તમે ગેટવે દ્વારા સ્ટીચ્ડ સ્કીમાને ક્વેરી કરી શકો છો (પોર્ટ 4000 પર ચાલી રહ્યું છે). તમે આના જેવી ક્વેરી ચલાવી શકો છો:


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

આ ક્વેરી ID "101" સાથેનું ઉત્પાદન મેળવે છે અને વપરાશકર્તા સેવામાંથી સંકળાયેલ વપરાશકર્તાને પણ મેળવે છે, જે દર્શાવે છે કે સ્કીમા સ્ટીચિંગ તમને એક જ વિનંતીમાં બહુવિધ સેવાઓમાંથી ડેટા ક્વેરી કરવાની કેવી રીતે મંજૂરી આપે છે.

અદ્યતન સ્કીમા સ્ટીચિંગ તકનીકો

મૂળભૂત ઉદાહરણ ઉપરાંત, અહીં કેટલીક અદ્યતન તકનીકો છે જેનો ઉપયોગ તમારા સ્કીમા સ્ટીચિંગ અમલીકરણને વધારવા માટે કરી શકાય છે:

સ્કીમા સ્ટીચિંગ અને એપોલો ફેડરેશન વચ્ચે પસંદગી

જ્યારે સ્કીમા સ્ટીચિંગ GraphQL ફેડરેશન માટે એક સક્ષમ વિકલ્પ છે, ત્યારે એપોલો ફેડરેશન તેની અદ્યતન સુવિધાઓ અને સુધારેલ ડેવલપર અનુભવને કારણે વધુ લોકપ્રિય પસંદગી બની ગયું છે. અહીં બે અભિગમોની સરખામણી છે:

સુવિધા સ્કીમા સ્ટીચિંગ એપોલો ફેડરેશન
સ્કીમા વ્યાખ્યા હાલની GraphQL સ્કીમા ભાષાનો ઉપયોગ કરે છે ડાયરેક્ટિવ્સ સાથેની ડિક્લેરેટિવ સ્કીમા ભાષાનો ઉપયોગ કરે છે
ક્વેરી પ્લાનિંગ મેન્યુઅલ ક્વેરી ડેલિગેશનની જરૂર છે એપોલો ગેટવે દ્વારા સ્વચાલિત ક્વેરી પ્લાનિંગ
ટાઇપ એક્સ્ટેન્શન્સ મર્યાદિત સપોર્ટ ટાઇપ એક્સ્ટેન્શન્સ માટે બિલ્ટ-ઇન સપોર્ટ
કી ડાયરેક્ટિવ્સ સપોર્ટેડ નથી એન્ટિટીઝને ઓળખવા માટે @key ડાયરેક્ટિવનો ઉપયોગ કરે છે
ડિસ્ટ્રિબ્યુટેડ ટ્રેસિંગ મેન્યુઅલ અમલીકરણની જરૂર છે ડિસ્ટ્રિબ્યુટેડ ટ્રેસિંગ માટે બિલ્ટ-ઇન સપોર્ટ
ટૂલિંગ અને ઇકોસિસ્ટમ ઓછું પરિપક્વ ટૂલિંગ વધુ પરિપક્વ ટૂલિંગ અને મોટો સમુદાય
જટિલતા મોટી સિસ્ટમ્સમાં સંચાલન કરવું જટિલ હોઈ શકે છે મોટી અને જટિલ સિસ્ટમ્સ માટે રચાયેલ છે

સ્કીમા સ્ટીચિંગ ક્યારે પસંદ કરવું:

એપોલો ફેડરેશન ક્યારે પસંદ કરવું:

વાસ્તવિક-વિશ્વના ઉદાહરણો અને ઉપયોગના કેસો

અહીં કેટલાક વાસ્તવિક-વિશ્વના ઉદાહરણો છે કે GraphQL ફેડરેશન, સ્કીમા સ્ટીચિંગ સહિત, કેવી રીતે ઉપયોગમાં લઈ શકાય છે:

સ્કીમા સ્ટીચિંગ માટે શ્રેષ્ઠ પદ્ધતિઓ

એક સફળ સ્કીમા સ્ટીચિંગ અમલીકરણ સુનિશ્ચિત કરવા માટે, આ શ્રેષ્ઠ પદ્ધતિઓનું પાલન કરો:

નિષ્કર્ષ

સ્કીમા સ્ટીચિંગ સાથેનું GraphQL ફેડરેશન માઇક્રોસર્વિસિસ આર્કિટેક્ચરમાં બહુવિધ સેવાઓમાંથી એકીકૃત APIs બનાવવા માટે એક શક્તિશાળી અભિગમ પ્રદાન કરે છે. તેના મૂળભૂત ખ્યાલો, ફાયદા, મર્યાદાઓ અને અમલીકરણ તકનીકોને સમજીને, તમે ડેટા એક્સેસને સરળ બનાવવા, સ્કેલેબિલીટી સુધારવા અને જાળવણીક્ષમતા વધારવા માટે સ્કીમા સ્ટીચિંગનો લાભ લઈ શકો છો. જ્યારે એપોલો ફેડરેશન એક વધુ અદ્યતન ઉકેલ તરીકે ઉભરી આવ્યું છે, ત્યારે સ્કીમા સ્ટીચિંગ સરળ દૃશ્યો માટે અથવા હાલની GraphQL સેવાઓને એકીકૃત કરતી વખતે એક સક્ષમ વિકલ્પ રહે છે. તમારી સંસ્થા માટે શ્રેષ્ઠ અભિગમ પસંદ કરવા માટે તમારી વિશિષ્ટ જરૂરિયાતો અને આવશ્યકતાઓને કાળજીપૂર્વક ધ્યાનમાં લો.