NestJS Enterprise Backend APIs · Lezione

Implementazione e consumo dei metodi gRPC

Colleghi gli handler @GrpcMethod e i proxy ClientGrpc per chiamate unarie richiesta/risposta.

Lezione 2 di 413 passaggi

Implementazione e consumo dei metodi gRPC è una lezione NestJS Enterprise Backend APIs gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento NestJS Enterprise Backend APIs, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso NestJS Enterprise Backend APIs include 4 lezioni in totale.

Parti di questa lezione non sono ancora state tradotte e vengono mostrate in inglese.

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?

Rispondi nella lezione interattiva

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.

Gratis per iniziare

Impara TypeScript con un tutor IA — gratis

Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.

Corsi: 20
Lezioni: 76

Inizia a imparare gratis Visualizza il corso completo

Domande Frequenti

La lezione «Implementazione e consumo dei metodi gRPC» è gratuita?

Sì — il testo completo di «Implementazione e consumo dei metodi gRPC» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso NestJS Enterprise Backend APIs, passa a CoddyKit PRO. Il corso NestJS Enterprise Backend APIs include 4 lezioni in totale.

Cosa imparerò in «Implementazione e consumo dei metodi gRPC»?

Colleghi gli handler @GrpcMethod e i proxy ClientGrpc per chiamate unarie richiesta/risposta. Eserciti NestJS Enterprise Backend APIs con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare NestJS Enterprise Backend APIs?

Non è richiesta alcuna esperienza precedente. NestJS Enterprise Backend APIs su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «Implementazione e consumo dei metodi gRPC»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione NestJS Enterprise Backend APIs?

Sì. Ogni lezione NestJS Enterprise Backend APIs include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

Definizione di servizi e messaggi in Protobuf
Implementazione e consumo dei metodi gRPC
RPC in streaming e backpressure
Evoluzione dei contratti e compatibilità all’indietro

← Torna a NestJS Enterprise Backend APIs