NestJS Enterprise Backend APIs · Pelajaran

Menerapkan dan Menggunakan Metode gRPC

Hubungkan penangan @GrpcMethod dan proksi ClientGrpc untuk panggilan permintaan/respons tunggal.

Menerapkan dan Menggunakan Metode gRPC adalah pelajaran NestJS Enterprise Backend APIs gratis di CoddyKit. Ini adalah pelajaran 2 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar NestJS Enterprise Backend APIs, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus NestJS Enterprise Backend APIs mencakup 4 pelajaran total.

Bagian dari pelajaran ini belum diterjemahkan dan ditampilkan dalam bahasa Inggris.

Unary gRPC in NestJS

gRPC services in NestJS are defined by a .proto contract and implemented as ordinary providers decorated with gRPC handler metadata. The most common interaction is the unary call: the client sends a single request message and receives a single response message.

The server exposes handlers via @GrpcMethod (or @GrpcStreamMethod for streams).
The client obtains a typed proxy through ClientGrpc.getService() and calls methods that return Observables.

In this lesson we wire both ends of a unary request/response flow for an enterprise-style UsersService.

The .proto contract

Everything starts with the service contract. The package name and the service / rpc names are what NestJS uses to bind handlers and to resolve the client proxy.

package users maps to the transport option package: 'users'.
FindOne is the RPC NestJS will route to a matching handler.

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

Configuring the gRPC microservice

On the server, you start a microservice with the GRPC transport. The two critical options are package (must match the .proto package) and protoPath (where the contract lives).

url sets the bind address; default is localhost:5000.
You can pass an array of packages and proto paths for multi-service apps.

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

Implementing a @GrpcMethod handler

A controller method becomes a unary RPC handler when you annotate it with @GrpcMethod. The decorator takes the service name and optionally the method name.

If you omit the method name, NestJS uses the PascalCase of the handler method name (so a method named findOne binds to FindOne).
The first argument is the deserialized request message; you simply return the response object (or a Promise/Observable of it).

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

Method name resolution rules

Binding depends entirely on naming. Get this wrong and the call fails at runtime with an UNIMPLEMENTED error.

Service name in @GrpcMethod('UsersService') must match the service in the .proto.
Method name: explicit second arg wins; otherwise the handler method name is capitalized to PascalCase.

For clarity in enterprise code, prefer passing both arguments explicitly so renames of the TypeScript method cannot silently break the wire contract.

Registering the client with ClientsModule

To consume a gRPC service, register a client in the consuming module. Each entry gets a name (an injection token) and the same transport options as the server.

package and protoPath point at the same contract the server uses.
url targets the server's bind address.

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

Getting the typed proxy with ClientGrpc

The injected client is a ClientGrpc instance, not the service itself. You must call getService() once the module is ready to obtain the strongly-typed proxy.

Resolve the proxy in onModuleInit so it exists before any request is handled.
The generic argument (UsersServiceClient) gives you full type safety on method calls.

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

Calling a unary method returns an Observable

The proxy's methods are generated from the .proto and each returns an RxJS Observable, even for unary calls. NestJS can return the Observable directly from an HTTP handler, or you can convert it to a Promise.

Use firstValueFrom from RxJS when you need async/await ergonomics.
The proxy method name is the camelCase of the RPC (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) }));
  }
}

Why camelCase vs PascalCase matters

There are two distinct name transformations and mixing them up is a frequent bug source:

Server side: @GrpcMethod binds to the PascalCase RPC name (FindOne).
Client side: the proxy exposes the camelCase method (findOne) regardless of how the RPC is spelled in the proto.

So you call usersService.findOne(...) on the client even though the RPC and the server handler reference FindOne.

Mapping the Observable pipeline

Because unary calls return Observables, you can compose them with RxJS operators before exposing the result. This is idiomatic when you need to reshape or enrich the gRPC response.

This pure RxJS example mirrors the shape of a gRPC unary response without needing a running server, so it can execute standalone.

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

Handling errors with gRPC status codes

In enterprise services you should surface domain failures as proper gRPC statuses, not generic exceptions. Throw an RpcException with a numeric code from @grpc/grpc-js so callers can react deterministically.

status.NOT_FOUND (5) for a missing entity, status.INVALID_ARGUMENT (3) for bad input.
The client receives the status on the Observable's error channel.

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

Quick Check

You implemented a server handler with @GrpcMethod('UsersService', 'FindOne'). On the consuming side you injected a ClientGrpc and called getService<UsersServiceClient>('UsersService'). Which method name do you invoke on the returned proxy to trigger this RPC?

Recap

You wired a complete unary gRPC flow in NestJS:

Defined the contract in a .proto with a package, service, and rpc.
Started a Transport.GRPC microservice and implemented the handler with @GrpcMethod('UsersService', 'FindOne'), returning the response object.
Registered a client via ClientsModule.register, resolved the typed proxy in onModuleInit with ClientGrpc.getService().
Called the camelCase proxy method, which returns an Observable — convertible with firstValueFrom.
Reported failures with RpcException and proper gRPC status codes.

Remember the naming split: server binds PascalCase, client calls camelCase.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Menerapkan dan Menggunakan Metode gRPC” gratis?

Ya — teks lengkap “Menerapkan dan Menggunakan Metode gRPC” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus NestJS Enterprise Backend APIs, upgrade ke CoddyKit PRO. Kursus NestJS Enterprise Backend APIs mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Menerapkan dan Menggunakan Metode gRPC”?

Hubungkan penangan @GrpcMethod dan proksi ClientGrpc untuk panggilan permintaan/respons tunggal. Kamu berlatih NestJS Enterprise Backend APIs dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai NestJS Enterprise Backend APIs?

Tidak diperlukan pengalaman sebelumnya. NestJS Enterprise Backend APIs di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 4.

Berapa lama pelajaran “Menerapkan dan Menggunakan Metode gRPC” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran NestJS Enterprise Backend APIs ini?

Ya. Setiap pelajaran NestJS Enterprise Backend APIs menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

Mendefinisikan Layanan dan Pesan dalam Protobuf
Menerapkan dan Menggunakan Metode gRPC
RPC Streaming dan Tekanan Balik
Evolusi Kontrak dan Kompatibilitas Mundur

← Kembali ke NestJS Enterprise Backend APIs