NestJS Enterprise Backend APIs · Lección

Implementación y consumo de métodos gRPC

Conecte handlers @GrpcMethod y proxies ClientGrpc para llamadas unarias de solicitud y respuesta.

Implementación y consumo de métodos gRPC es una lección gratuita de NestJS Enterprise Backend APIs en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de NestJS Enterprise Backend APIs, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de NestJS Enterprise Backend APIs incluye 4 lecciones en total.

Partes de esta lección aún no han sido traducidas y se muestran en inglés.

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.

Preguntas frecuentes

¿La lección «Implementación y consumo de métodos gRPC» es gratis?

Sí — el texto completo de «Implementación y consumo de métodos gRPC» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de NestJS Enterprise Backend APIs, actualiza a CoddyKit PRO. El curso de NestJS Enterprise Backend APIs incluye 4 lecciones en total.

¿Qué aprenderé en «Implementación y consumo de métodos gRPC»?

Conecte handlers @GrpcMethod y proxies ClientGrpc para llamadas unarias de solicitud y respuesta. Practicas NestJS Enterprise Backend APIs con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar NestJS Enterprise Backend APIs?

No se requiere experiencia previa. NestJS Enterprise Backend APIs en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «Implementación y consumo de métodos gRPC»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de NestJS Enterprise Backend APIs?

Sí. Cada lección de NestJS Enterprise Backend APIs incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

Definición de servicios y mensajes en Protobuf
Implementación y consumo de métodos gRPC
RPC de streaming y control de presión
Evolución de contratos y compatibilidad con versiones anteriores

← Volver a NestJS Enterprise Backend APIs