NestJS एंटरप्राइज़ बैकएंड API · पाठ

gRPC विधियों को लागू करना और उपयोग करना

यूनरी अनुरोध-प्रतिक्रिया कॉल के लिए @GrpcMethod हैंडलरों और ClientGrpc प्रॉक्सी को जोड़िए।

पाठ 2, कुल 4 में से13 चरण

gRPC विधियों को लागू करना और उपयोग करना, CoddyKit पर NestJS एंटरप्राइज़ बैकएंड API का एक निःशुल्क पाठ है। यह 4 में से 2वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह NestJS एंटरप्राइज़ बैकएंड API सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। NestJS एंटरप्राइज़ बैकएंड API पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

NestJS में यूनरी gRPC

NestJS में gRPC सेवाएँ .proto कॉन्ट्रैक्ट द्वारा परिभाषित की जाती हैं और gRPC हैंडलर मेटाडेटा से सजाए गए सामान्य प्रदाताओं के रूप में लागू की जाती हैं। सबसे आम इंटरैक्शन यूनरी कॉल है: क्लाइंट एक अनुरोध संदेश भेजता है और एक प्रतिक्रिया संदेश प्राप्त करता है।

सर्वर @GrpcMethod के माध्यम से हैंडलर उपलब्ध कराता है (स्ट्रीम के लिए @GrpcStreamMethod)।
क्लाइंट ClientGrpc.getService() के माध्यम से प्रकारयुक्त प्रॉक्सी प्राप्त करता है और ऐसी विधियाँ कॉल करता है, जो Observable लौटाती हैं।

इस पाठ में हम एंटरप्राइज़-शैली की UsersService के लिए यूनरी अनुरोध/प्रतिक्रिया प्रवाह के दोनों सिरों को जोड़ेंगे।

.proto कॉन्ट्रैक्ट

सब कुछ सेवा कॉन्ट्रैक्ट से शुरू होता है। package नाम और service / rpc नाम वे तत्व हैं, जिनका उपयोग NestJS हैंडलर को जोड़ने और क्लाइंट प्रॉक्सी का पता लगाने के लिए करता है।

package users, ट्रांसपोर्ट विकल्प package: 'users' से मैप होता है।
FindOne वह RPC है, जिसे NestJS संबंधित हैंडलर तक पहुँचाएगा।

syntax = "proto3";

package users;

service UsersService {
  rpc FindOne (UserById) returns (User) {}
}

message UserById {
  int32 id = 1;
}

message User {
  int32 id = 1;
  string name = 2;
  string email = 3;
}

gRPC माइक्रोसर्विस कॉन्फ़िगर करना

सर्वर पर आप GRPC ट्रांसपोर्ट के साथ माइक्रोसर्विस शुरू करते हैं। दो महत्वपूर्ण विकल्प हैं: package (जो .proto पैकेज से मेल खाना चाहिए) और protoPath (जहाँ कॉन्ट्रैक्ट मौजूद है)।

url बाइंड पता तय करता है; डिफ़ॉल्ट localhost:5000 है।
बहु-सेवा ऐप के लिए आप पैकेज और proto पथों की एक ऐरे दे सकते हैं।

import { NestFactory } from '@nestjs/core';
import { Transport, MicroserviceOptions } from '@nestjs/microservices';
import { join } from 'path';
import { AppModule } from './app.module';

async function bootstrap() {
  const app = await NestFactory.createMicroservice<MicroserviceOptions>(
    AppModule,
    {
      transport: Transport.GRPC,
      options: {
        package: 'users',
        protoPath: join(__dirname, 'users.proto'),
        url: '0.0.0.0:5000',
      },
    },
  );
  await app.listen();
}
bootstrap();

@GrpcMethod हैंडलर लागू करना

किसी नियंत्रक विधि को @GrpcMethod से एनोटेट करने पर वह यूनरी RPC हैंडलर बन जाती है। डेकोरेटर में सेवा नाम और वैकल्पिक रूप से विधि नाम दिया जाता है।

यदि आप विधि नाम छोड़ देते हैं, तो NestJS हैंडलर विधि नाम का PascalCase उपयोग करता है (इसलिए findOne नाम की विधि FindOne से जुड़ती है)।
पहला तर्क डिसीरियलाइज़ किया हुआ अनुरोध संदेश होता है; आप केवल प्रतिक्रिया ऑब्जेक्ट (या उसका Promise/Observable) लौटाते हैं।

import { Controller } from '@nestjs/common';
import { GrpcMethod } from '@nestjs/microservices';

interface UserById { id: number; }
interface User { id: number; name: string; email: string; }

@Controller()
export class UsersController {
  private readonly users: User[] = [
    { id: 1, name: 'Ada', email: 'ada@corp.io' },
    { id: 2, name: 'Linus', email: 'linus@corp.io' },
  ];

  @GrpcMethod('UsersService', 'FindOne')
  findOne(data: UserById): User {
    return this.users.find((u) => u.id === data.id);
  }
}

विधि नाम निर्धारित करने के नियम

बाइंडिंग पूरी तरह नामकरण पर निर्भर करती है। यदि यह गलत हुआ, तो रनटाइम में UNIMPLEMENTED त्रुटि के साथ कॉल विफल हो जाएगी।

सेवा नाम @GrpcMethod('UsersService') में दिया गया नाम .proto की service से मेल खाना चाहिए।
विधि नाम: स्पष्ट रूप से दिया गया दूसरा तर्क प्राथमिक होता है; अन्यथा हैंडलर विधि नाम को PascalCase में बदला जाता है।

एंटरप्राइज़ कोड में स्पष्टता के लिए दोनों तर्क स्पष्ट रूप से देना बेहतर है, ताकि TypeScript विधि का नाम बदलने से वायर कॉन्ट्रैक्ट चुपचाप न टूटे।

ClientsModule के साथ क्लाइंट पंजीकृत करना

किसी gRPC सेवा का उपयोग करने के लिए, उपयोग करने वाले मॉड्यूल में एक क्लाइंट पंजीकृत करें। हर प्रविष्टि में एक name (इंजेक्शन टोकन) और सर्वर जैसे ही ट्रांसपोर्ट विकल्प होते हैं।

package और protoPath उसी कॉन्ट्रैक्ट की ओर संकेत करते हैं, जिसका सर्वर उपयोग करता है।
url सर्वर के बाइंड पते को लक्ष्य बनाता है।

import { Module } from '@nestjs/common';
import { ClientsModule, Transport } from '@nestjs/microservices';
import { join } from 'path';
import { ApiController } from './api.controller';

@Module({
  imports: [
    ClientsModule.register([
      {
        name: 'USERS_PACKAGE',
        transport: Transport.GRPC,
        options: {
          package: 'users',
          protoPath: join(__dirname, 'users.proto'),
          url: 'users-svc:5000',
        },
      },
    ]),
  ],
  controllers: [ApiController],
})
export class ApiModule {}

ClientGrpc से प्रकारयुक्त प्रॉक्सी प्राप्त करना

इंजेक्ट किया गया क्लाइंट स्वयं सेवा नहीं, बल्कि ClientGrpc इंस्टेंस होता है। मॉड्यूल तैयार होने के बाद प्रकारयुक्त प्रॉक्सी प्राप्त करने के लिए आपको एक बार getService() कॉल करना होगा।

onModuleInit में प्रॉक्सी प्राप्त करें, ताकि किसी अनुरोध को संभालने से पहले वह मौजूद हो।
जेनेरिक तर्क (UsersServiceClient) विधि कॉल पर पूर्ण प्रकार सुरक्षा देता है।

import { Controller, Inject, OnModuleInit } from '@nestjs/common';
import { ClientGrpc } from '@nestjs/microservices';
import { Observable } from 'rxjs';

interface User { id: number; name: string; email: string; }
interface UsersServiceClient {
  findOne(data: { id: number }): Observable<User>;
}

@Controller('users')
export class ApiController implements OnModuleInit {
  private usersService: UsersServiceClient;

  constructor(@Inject('USERS_PACKAGE') private client: ClientGrpc) {}

  onModuleInit() {
    this.usersService = this.client.getService<UsersServiceClient>('UsersService');
  }
}

यूनरी विधि को कॉल करने पर Observable मिलता है

प्रॉक्सी की विधियाँ .proto से बनाई जाती हैं और प्रत्येक विधि एक RxJS ऑब्ज़र्वेबल लौटाती है, यहाँ तक कि एकल कॉल के लिए भी। NestJS HTTP हैंडलर से सीधे ऑब्ज़र्वेबल लौटा सकता है, या आप इसे प्रॉमिस में बदल सकते हैं।

जब आपको async/await की सुविधा चाहिए, तब RxJS से firstValueFrom का उपयोग करें।
प्रॉक्सी विधि का नाम RPC के camelCase रूप में होता है (FindOne → findOne)।

import { Controller, Get, Param, Inject, OnModuleInit } from '@nestjs/common';
import { ClientGrpc } from '@nestjs/microservices';
import { firstValueFrom, Observable } from 'rxjs';

interface User { id: number; name: string; email: string; }
interface UsersServiceClient {
  findOne(data: { id: number }): Observable<User>;
}

@Controller('users')
export class ApiController implements OnModuleInit {
  private usersService: UsersServiceClient;
  constructor(@Inject('USERS_PACKAGE') private client: ClientGrpc) {}

  onModuleInit() {
    this.usersService = this.client.getService<UsersServiceClient>('UsersService');
  }

  @Get(':id')
  async getUser(@Param('id') id: string): Promise<User> {
    return firstValueFrom(this.usersService.findOne({ id: Number(id) }));
  }
}

camelCase और PascalCase का महत्व

नाम बदलने की दो अलग-अलग प्रक्रियाएँ होती हैं और उन्हें आपस में मिला देना अक्सर बग का कारण बनता है:

सर्वर पक्ष: @GrpcMethod PascalCase वाले RPC नाम (FindOne) से जुड़ता है।
client पक्ष: प्रॉक्सी camelCase वाली विधि (findOne) उपलब्ध कराता है, भले ही proto में RPC का नाम किसी भी रूप में लिखा गया हो।

इसलिए client पर आप usersService.findOne(...) कॉल करते हैं, भले ही RPC और सर्वर हैंडलर में FindOne का संदर्भ दिया गया हो।

ऑब्ज़र्वेबल pipeline को मैप करना

क्योंकि एकल कॉल ऑब्ज़र्वेबल लौटाती हैं, इसलिए परिणाम उपलब्ध कराने से पहले आप उन्हें RxJS ऑपरेटरों के साथ संयोजित कर सकते हैं। जब आपको gRPC प्रतिक्रिया का आकार बदलना या उसमें अतिरिक्त जानकारी जोड़ना हो, तब यह प्रचलित तरीका है।

यह शुद्ध RxJS उदाहरण किसी चल रहे सर्वर की आवश्यकता के बिना gRPC एकल प्रतिक्रिया के स्वरूप को दर्शाता है, इसलिए इसे स्वतंत्र रूप से चलाया जा सकता है।

import { of, firstValueFrom } from 'rxjs';
import { map } from 'rxjs/operators';

interface User { id: number; name: string; email: string; }

// Simulates this.usersService.findOne({ id: 1 })
function findOne(data: { id: number }) {
  const row: User = { id: data.id, name: 'Ada', email: 'ada@corp.io' };
  return of(row);
}

async function main() {
  const dto = await firstValueFrom(
    findOne({ id: 1 }).pipe(
      map((u) => ({ userId: u.id, label: `${u.name} <${u.email}>` })),
    ),
  );
  console.log(JSON.stringify(dto));
}

main();

gRPC स्थिति कोड से त्रुटियों को संभालना

एंटरप्राइज़ सेवाओं में डोमेन-स्तरीय विफलताओं को सामान्य अपवादों के बजाय उचित gRPC स्थिति के रूप में सामने लाना चाहिए। @grpc/grpc-js से प्राप्त संख्यात्मक code के साथ RpcException फेंकें, ताकि कॉल करने वाले निश्चित तरीके से प्रतिक्रिया दे सकें।

गायब इकाई के लिए status.NOT_FOUND (5), और गलत input के लिए status.INVALID_ARGUMENT (3) का उपयोग करें।
client को यह स्थिति ऑब्ज़र्वेबल के error चैनल पर प्राप्त होती है।

import { Controller } from '@nestjs/common';
import { GrpcMethod, RpcException } from '@nestjs/microservices';
import { status } from '@grpc/grpc-js';

interface UserById { id: number; }
interface User { id: number; name: string; email: string; }

@Controller()
export class UsersController {
  private readonly users: User[] = [
    { id: 1, name: 'Ada', email: 'ada@corp.io' },
  ];

  @GrpcMethod('UsersService', 'FindOne')
  findOne(data: UserById): User {
    const found = this.users.find((u) => u.id === data.id);
    if (!found) {
      throw new RpcException({
        code: status.NOT_FOUND,
        message: `User ${data.id} not found`,
      });
    }
    return found;
  }
}

त्वरित जाँच

आपने @GrpcMethod('UsersService', 'FindOne') के साथ सर्वर हैंडलर लागू किया है। उपयोग करने वाली ओर आपने एक ClientGrpc इंजेक्ट किया और getService<UsersServiceClient>('UsersService') कॉल किया। इस RPC को शुरू करने के लिए लौटाए गए प्रॉक्सी पर आप किस विधि नाम का उपयोग करेंगे?

इंटरैक्टिव पाठ में इसका उत्तर दें

पुनरावलोकन

आपने NestJS में एक संपूर्ण एकल gRPC प्रवाह जोड़ा:

package, service और rpc के साथ .proto में अनुबंध परिभाषित किया।
Transport.GRPC माइक्रोसर्विस शुरू की और @GrpcMethod('UsersService', 'FindOne') के साथ हैंडलर लागू किया, जो प्रतिक्रिया ऑब्जेक्ट लौटाता है।
ClientsModule.register के माध्यम से client पंजीकृत किया और ClientGrpc.getService() से onModuleInit में प्रकारयुक्त प्रॉक्सी प्राप्त की।
camelCase वाली प्रॉक्सी विधि कॉल की, जो एक ऑब्ज़र्वेबल लौटाती है — इसे firstValueFrom से बदला जा सकता है।
RpcException और उचित gRPC status कोड के साथ विफलताओं की सूचना दी।

नामकरण का अंतर याद रखें: सर्वर PascalCase से जुड़ता है, जबकि client camelCase कॉल करता है।

शुरुआत निःशुल्क

एआई शिक्षक के साथ TypeScript सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम: 20
पाठ: 76

निःशुल्क सीखना शुरू करें पूरा पाठ्यक्रम देखें

अक्सर पूछे जाने वाले प्रश्न

क्या “gRPC विधियों को लागू करना और उपयोग करना” पाठ निःशुल्क है?

हाँ—“gRPC विधियों को लागू करना और उपयोग करना” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और NestJS एंटरप्राइज़ बैकएंड API पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। NestJS एंटरप्राइज़ बैकएंड API पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“gRPC विधियों को लागू करना और उपयोग करना” में मैं क्या सीखूँगा?

यूनरी अनुरोध-प्रतिक्रिया कॉल के लिए @GrpcMethod हैंडलरों और ClientGrpc प्रॉक्सी को जोड़िए। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ NestJS एंटरप्राइज़ बैकएंड API का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या NestJS एंटरप्राइज़ बैकएंड API शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर NestJS एंटरप्राइज़ बैकएंड API शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 2वाँ पाठ है।

“gRPC विधियों को लागू करना और उपयोग करना” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस NestJS एंटरप्राइज़ बैकएंड API पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर NestJS एंटरप्राइज़ बैकएंड API पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

Protobuf में सेवाएँ और संदेश निर्धारित करना
gRPC विधियों को लागू करना और उपयोग करना
स्ट्रीमिंग RPC और बैकप्रेशर
अनुबंध का विकास और पश्चगामी संगतता

← NestJS एंटरप्राइज़ बैकएंड API पर वापस जाएँ