gRPC

Relación con otros conceptos

Definición

gRPC es un framework de comunicación RPC (Remote Procedure Call) de alto rendimiento desarrollado por Google. Permite que sistemas distribuidos se comuniquen como si estuvieran llamando a funciones locales, abstraiendo la complejidad de red, serialización y transporte.

Se utiliza principalmente en arquitecturas de microservicios y sistemas backend modernos donde el rendimiento, la tipificación fuerte y la compatibilidad entre lenguajes son críticos.

Características principales

  • Comunicación basada en HTTP/2
  • Uso de Protocol Buffers (Protobuf) como formato de serialización
  • Soporte nativo para múltiples lenguajes
  • Comunicación cliente-servidor fuertemente tipada
  • Soporte para streaming bidireccional
  • Baja latencia y alto throughput

Arquitectura

gRPC sigue un modelo cliente-servidor donde:

  • El servidor define un conjunto de servicios y métodos en un archivo .proto
  • El cliente consume estos servicios mediante código generado automáticamente

El contrato entre cliente y servidor está completamente definido por el archivo Protobuf, evitando ambigüedades y errores de integración.

Protocol Buffers (Protobuf)

Protobuf es el lenguaje de definición de interfaces (IDL) utilizado por gRPC.

Permite:

  • Definir mensajes estructurados
  • Definir servicios y métodos RPC
  • Generar código automáticamente para distintos lenguajes

Ventajas:

  • Más eficiente que JSON o XML
  • Tipado fuerte
  • Versionado explícito

Tipos de llamadas gRPC

  • Unary
    • Una petición → una respuesta
  • Server Streaming
    • Una petición → múltiples respuestas
  • Client Streaming
    • Múltiples peticiones → una respuesta
  • Bidirectional Streaming
    • Flujo continuo en ambos sentidos

Estos modelos permiten casos avanzados como eventos en tiempo real, colas, chats o sincronización de estados.

Transporte y rendimiento

gRPC se apoya en HTTP/2, lo que habilita:

  • Multiplexación de múltiples streams en una sola conexión
  • Compresión de headers
  • Control de flujo
  • Conexiones persistentes

Esto lo hace más eficiente que REST sobre HTTP/1.1 en escenarios de alta concurrencia.

Casos de uso comunes

  • Microservicios internos
  • Comunicación entre servicios backend
  • Sistemas distribuidos de baja latencia
  • APIs internas de alto rendimiento
  • Streaming de datos en tiempo real

Comparación con REST

  • gRPC
    • Binario (Protobuf)
    • HTTP/2
    • Contratos estrictos
    • Mejor rendimiento
  • REST
    • Texto (JSON)
    • HTTP/1.1 o HTTP/2
    • Contratos implícitos
    • Más fácil de depurar manualmente

Ambos pueden coexistir: REST para APIs públicas y gRPC para comunicación interna.

Seguridad

gRPC soporta:

  • TLS de forma nativa
  • Autenticación mediante tokens
  • Integración con sistemas de identidad

Esto lo hace adecuado para entornos productivos y cloud.

Herramientas y ecosistema

  • gRPC CLI
  • Protoc (compiler de Protobuf)
  • Integración con Kubernetes
  • Soporte en service meshes como Istio

Ventajas y desventajas

  • Ventajas
    • Alto rendimiento
    • Tipado fuerte
    • Multilenguaje
    • Streaming avanzado
  • Desventajas
    • Menos amigable para humanos
    • Mayor complejidad inicial
    • No ideal para navegadores sin proxy

Recursos

Conceptos avanzados no cubiertos

Versionado de APIs

gRPC gestiona el versionado principalmente a nivel de Protocol Buffers, no de endpoints como REST.

Buenas prácticas:

  • Añadir campos nuevos sin reutilizar identificadores numéricos
  • No eliminar campos existentes, solo marcarlos como deprecated
  • Versionar servicios completos (UserServiceV2)
  • Mantener compatibilidad hacia atrás (backward compatibility)

El versionado correcto es clave en sistemas distribuidos con múltiples clientes.

Manejo de errores

gRPC utiliza un sistema de status codes estandarizado distinto a HTTP.

Incluye:

  • Códigos (OK, INVALID_ARGUMENT, NOT_FOUND, UNAVAILABLE, etc.)
  • Mensajes descriptivos
  • Metadata adicional (headers/trailers)

Esto permite una semántica de errores clara y consistente entre servicios.

Deadlines y timeouts

Cada llamada gRPC puede incluir un deadline:

  • Tiempo máximo permitido para completar la llamada
  • Propagación automática entre servicios
  • Evita llamadas colgadas y cascadas de fallos

Es un concepto fundamental en arquitecturas resilientes.

Interceptors

Los interceptors permiten ejecutar lógica transversal antes o después de una llamada RPC.

Casos comunes:

  • Logging
  • Autenticación y autorización
  • Métricas
  • Tracing distribuido
  • Retry logic

Funcionan de forma similar a middlewares en frameworks web.

Load Balancing

gRPC soporta balanceo de carga a nivel de cliente.

Estrategias comunes:

  • Round-robin
  • Pick-first
  • Integración con service discovery (DNS, Kubernetes)

El cliente es responsable de seleccionar el backend adecuado, reduciendo carga en proxies externos.

Service Discovery

En entornos dinámicos:

  • gRPC se integra con DNS
  • Soporte nativo en Kubernetes
  • Compatible con service meshes

Esto permite escalar servicios sin reconfigurar clientes manualmente.

Observabilidad monitoreo

gRPC se integra con herramientas modernas de observabilidad.

Incluye:

  • Métricas (latencia, errores, throughput)
  • Tracing distribuido
  • Logs estructurados

Compatible con OpenTelemetry y stacks de monitoreo cloud-native.

Compresión

gRPC permite compresión de mensajes:

  • Reduce ancho de banda
  • Mejora rendimiento en redes lentas
  • Configuración por llamada o global

Útil en streaming y grandes volúmenes de datos.

Autenticación y autorización avanzada

Además de TLS, gRPC soporta:

  • Metadata headers para tokens
  • OAuth 2
  • JWT
  • mTLS (mutual TLS)

Frecuente en entornos zero-trust y microservicios internos.

gRPC en navegadores

Limitación clave:

  • Los navegadores no soportan gRPC nativo por restricciones de HTTP/2

Soluciones:

  • gRPC-Web
  • Proxies intermedios (Envoy)

Permite usar gRPC desde aplicaciones frontend modernas.

Streaming avanzado

Detalles importantes:

  • Backpressure automático
  • Control de flujo por HTTP/2
  • Manejo de streams largos
  • Cancelación de streams

Ideal para eventos en tiempo real y sincronización continua.

Testing

Estrategias comunes:

  • Tests unitarios sobre servicios
  • Mocks generados desde .proto
  • Tests de contrato
  • Tests de integración entre microservicios

El contrato Protobuf facilita pruebas consistentes.

Seguridad en producción

Consideraciones adicionales:

  • Rotación de certificados
  • Control de acceso por método
  • Auditoría de llamadas
  • Limitación de tasas (rate limiting)

Crítico en sistemas expuestos o multi-tenant.

Antipatrones

  • Usar gRPC como REST
  • Exponer gRPC directamente a clientes públicos sin proxy
  • No definir deadlines
  • Versionar rompiendo compatibilidad
  • Usar mensajes demasiado genéricos

Cuándo NO usar gRPC

  • APIs públicas simples
  • Integraciones con terceros sin soporte gRPC
  • Sistemas que requieren inspección manual frecuente
  • Entornos con tooling limitado

Relación con arquitectura

Temas relacionados para notas separadas

  • Protocol Buffers en profundidad
  • Service Mesh con gRPC
  • gRPC vs GraphQL
  • gRPC-Web
  • Observabilidad en microservicios

gRPC – Recursos Actualizados 2025–2026

Documentación y guías oficiales

  • Documentación oficial en gRPC.io – Referencia completa de conceptos, quickstarts por lenguaje, tutoriales y material de referencia actualizado constantemente por la comunidad oficial de gRPC.
    Documentación gRPC
  • Guides de gRPC – Documentación oficial orientada a casos de uso (autenticación, cancelación, compresión, debugging, salud del servidor, métricas, deadlines, interceptores, control de flujo, etc.).
    Guías gRPC

Eventos y comunidad

  • gRPConf 2025 (26 Ago 2025) – Conferencia oficial de gRPC con charlas, talleres y networking para desarrolladores y empresas.
    gRPConf 2025
  • Comunidad de gRPC – Foros, grupos, reuniones online, YouTube e interacción comunitaria para mantenerse actualizado y resolver dudas técnicas.
    Comunidad gRPC
  • Mailing list grpc-io-announce – Lista para recibir directamente actualizaciones críticas sobre seguridad, soporte de plataformas y noticias relevantes de gRPC.
    grpc-io-announce

Cursos, entrenamientos y formación

  • Arquitectura de Microservicios con .NET 9 y gRPC (Udemy) – Curso actualizado 12/2025 sobre diseño e implementación de microservicios gRPC con .NET 9.
    Curso Udemy .NET gRPC
  • ASP.NET Core 8 en Arquitectura gRPC (Udemy / Net University) – Curso actualizado 03/2025 orientado a proyectos gRPC con ASP.NET Core 7/8 y conexión a bases de datos, streaming y más.
    ASP.NET Core gRPC
  • Developing .NET services using gRPC (Info Support) – Formación presencial/remota con fechas disponibles en 2026 para desarrollar servicios gRPC en .NET.
    Info Support gRPC
  • Introduction to gRPC (Educative) – Curso interactivo que cubre fundamentos y ejemplos prácticos de gRPC, Protobuf y RPCs aplicados en Java.
    Educative gRPC
  • Cursos de gRPC con Go bonificados (Imagina Formación) – Formación práctica orientada a Go y gRPC, con posibilidad de financiación a través de FUNDAE.
    gRPC con Go

Repositorios y herramientas

  • Repositorio oficial de gRPC en GitHub (grpc/grpc) – Código fuente para múltiples lenguajes, ejemplos y guías de contribución siempre actualizados.
    GitHub grpc/grpc

Tendencias y temas emergentes

  • gRPC y AI – Artículo oficial sobre integración de LLMs para acelerar workflows de gRPC (por ejemplo conversión OpenAPI → Protobuf asistida por IA).
    gRPC and AI
  • Ecosistemas de lenguajes – Discusiones y estado del soporte gRPC en lenguajes como Rust (tonic, grpc-rust) y evolución del tooling a finales de 2025.
    Estado gRPC en Rust

Recursos comunitarios y adicionales

  • Foros y discusión técnica en Stack Overflow y Google Groups – Resolución de problemas reales, patrones de implementación y buenas prácticas gRPC.
    Comunidad técnica gRPC
  • Checklist de producción gRPC (2025 Edition) – Guía práctica no oficial con pasos y recomendaciones para desplegar gRPC en producción.
    Checklist gRPC Producción
  • Herramientas de testing y exploración de API – Herramientas como grpcui, grpcurl y clientes gráficos para inspeccionar y probar APIs gRPC.
    Herramientas gRPC

    gRPC – Tools y recursos open source en GitHub (2025–2026)

Herramientas CLI y utilidades

Integraciones y extensiones útiles

Bibliotecas y runtimes gRPC

  • grpc/grpc – Repositorio principal del framework gRPC con implementaciones core y bindings multilenguaje.
  • grpc/grpc-dotnet – Implementación oficial de gRPC para .NET y ASP.NET Core.
  • hyperium/tonic – Implementación gRPC idiomática para Rust, basada en async/await y ampliamente adoptada.

Ecosistema general

  • grpc-ecosystem – Organización que centraliza proyectos open source relacionados con gRPC: middlewares, gateways, observabilidad, tooling y extensiones.
  • Awesome gRPC – Listas curadas de herramientas, librerías, ejemplos y recursos gRPC mantenidas por la comunidad (habitualmente dentro del ecosistema gRPC).

Ideas de herramientas extra (comunidad)

Pueden tener repositorios open source o prototipos activos

  • Clientes TUI / GUI como Chiko – Cliente gRPC en terminal con interfaz interactiva.
  • Herramientas CLI como grpcmd – CLI inspirada en HTTPie para consumir servicios gRPC.
  • Proyectos de testing automatizado, generación de payloads y exploración visual de contratos .proto.

Cómo explorar más proyectos

  • Buscar en GitHub por etiquetas: grpc, grpc-tools, grpc-client, grpc-ui, grpc-ecosystem
  • Explorar repositorios destacados dentro de grpc-ecosystem
  • Revisar listas awesome relacionadas con gRPC por lenguaje o caso de uso

gRPC – Guía de casos de uso e implementación técnica

Microservicios internos

Caso de uso

Comunicación entre microservicios backend con alta frecuencia de llamadas, baja latencia y contratos estrictos.

Implementación técnica

  • Definir contratos en .proto por dominio
  • Usar Unary RPC para operaciones CRUD
  • Configurar deadlines obligatorios en cada llamada
  • Activar client-side load balancing
  • Usar mTLS para seguridad entre servicios
  • Desplegar con Kubernetes + DNS o service mesh

Buenas prácticas

  • Un servicio gRPC por bounded context
  • Evitar mensajes genéricos tipo Any
  • Versionar servicios, no métodos

Comunicación Backend ↔ Backend (polyglot)

Caso de uso

Servicios escritos en distintos lenguajes (Go, Java, .NET, Rust) que deben comunicarse sin fricción.

Implementación técnica

  • Protobuf como contrato único
  • Generación automática de clientes/servidores
  • Repositorio central de .proto
  • CI validando compatibilidad backward
  • Interceptors para auth, logging y métricas

Ventaja clave

El contrato elimina ambigüedades entre equipos y lenguajes.

Streaming de eventos en tiempo real

Caso de uso

Notificaciones, feeds en tiempo real, sincronización de estados, eventos de dominio.

Implementación técnica

  • Usar Server Streaming o Bidirectional Streaming
  • Manejar backpressure automáticamente vía HTTP/2
  • Cancelar streams cuando el cliente se desconecta
  • Definir mensajes pequeños y frecuentes
  • Usar keepalive para conexiones largas

Ejemplos

  • Chat interno
  • Actualización de dashboards
  • Procesamiento incremental de datos

APIs públicas híbridas (gRPC + REST)

Caso de uso

Exponer APIs públicas REST mientras se mantiene gRPC internamente.

Implementación técnica

  • gRPC como API principal
  • Usar grpc-gateway para generar REST
  • Mapear errores gRPC → HTTP status codes
  • Documentar REST con OpenAPI generado
  • Mantener una sola lógica de negocio

Ventaja

Un backend, dos interfaces de consumo.

Sistemas de alta performance

Caso de uso

Servicios con alto throughput y bajo uso de CPU/memoria.

Implementación técnica

  • Protobuf binario (evitar JSON)
  • Compresión selectiva (gzip)
  • Pooling de conexiones
  • Multiplexación HTTP/2
  • Evitar reflection en producción si no es necesario

Resultado

Mejor rendimiento que REST en escenarios intensivos.

Arquitecturas Event-Driven

Caso de uso

Publicación y consumo de eventos entre servicios sin usar brokers tradicionales.

Implementación técnica

  • Bidirectional streaming como canal de eventos
  • Mensajes de evento bien tipados
  • ACK explícito si es necesario
  • Retry y reconexión automática
  • Idempotencia en consumidores

Nota

No reemplaza completamente a Kafka, pero es útil en flujos directos.

gRPC en Kubernetes

Caso de uso

Servicios gRPC desplegados y escalados dinámicamente.

Implementación técnica

  • Kubernetes Services + DNS
  • Health checks gRPC (grpc-health-probe)
  • Readiness y liveness basados en gRPC
  • Client-side load balancing
  • Sidecars opcionales (Envoy)

Observación

El cliente gRPC debe conocer cambios de endpoints.

gRPC con Service Mesh

Caso de uso

Seguridad, observabilidad y control de tráfico sin tocar código.

Implementación técnica

  • Service mesh (Istio / Linkerd)
  • mTLS automático
  • Retries y circuit breaking a nivel mesh
  • Traffic shaping y canary releases
  • Observabilidad centralizada

Ventaja

Menos lógica cross-cutting en el código.

Frontend → Backend (gRPC-Web)

Caso de uso

Aplicaciones web modernas que consumen gRPC.

Implementación técnica

  • Usar gRPC-Web
  • Proxy (Envoy) entre browser y backend
  • Unary y server streaming soportados
  • Auth vía headers
  • Protobuf compartido con frontend

Limitación

No soporta bidirectional streaming completo.

Testing y QA

Caso de uso

Garantizar estabilidad de contratos y servicios.

Implementación técnica

  • Tests unitarios con mocks generados
  • Tests de contrato sobre .proto
  • Tests de integración entre servicios
  • grpcurl / grpcui para testing manual
  • Replay de tráfico en staging

Observabilidad en producción

Caso de uso

Monitorear latencia, errores y comportamiento del sistema.

Implementación técnica

  • Interceptors para métricas
  • Tracing distribuido (OpenTelemetry)
  • Logs estructurados por método RPC
  • Métricas por status code
  • Alertas por latency percentiles

Seguridad enterprise

Caso de uso

Entornos regulados o zero-trust.

Implementación técnica

  • mTLS entre servicios
  • JWT u OAuth2 en metadata
  • Auth por método RPC
  • Rotación de certificados
  • Auditoría de llamadas

Antipatrones de implementación

  • Usar gRPC como REST
  • No definir deadlines
  • Mensajes demasiado grandes
  • Versionar rompiendo compatibilidad
  • Exponer gRPC directo a internet sin proxy

Relación con otras notas

Definición de servicio (.proto)

syntax = "proto3";

package user.v1;

service UserService {
	rpc GetUser(GetUserRequest) returns (User);
	rpc ListUsers(Empty) returns (stream User);
	rpc CreateUsers(stream CreateUserRequest) returns (CreateUsersResponse);
	rpc Chat(stream ChatMessage) returns (stream ChatMessage);
}

message GetUserRequest {
	string id = 1;
}

message CreateUserRequest {
	string name = 1;
}

message User {
	string id = 1;
	string name = 2;
}

message ChatMessage {
	string from = 1;
	string message = 2;
}

message CreateUsersResponse {
	int32 count = 1;
}

message Empty {}

`

Generación de código

Protobuf compiler

protoc \
	--proto_path=. \
	--go_out=. \
	--go-grpc_out=. \
	user.proto

Servidor gRPC – Go

type UserServer struct {
	pb.UnimplementedUserServiceServer
}

func (s *UserServer) GetUser(
	ctx context.Context,
	req *pb.GetUserRequest,
) (*pb.User, error) {
	return &pb.User{
		Id:   req.Id,
		Name: "Alice",
	}, nil
}

func main() {
	lis, _ := net.Listen("tcp", ":50051")
	s := grpc.NewServer()
	pb.RegisterUserServiceServer(s, &UserServer{})
	s.Serve(lis)
}

Cliente gRPC – Go

conn, _ := grpc.Dial(
	"localhost:50051",
	grpc.WithTransportCredentials(insecure.NewCredentials()),
)

client := pb.NewUserServiceClient(conn)

res, _ := client.GetUser(
	context.Background(),
	&pb.GetUserRequest{Id: "123"},
)

Servidor gRPC – .NET

public class UserService : UserService.UserServiceBase
{
	public override Task<User> GetUser(
		GetUserRequest request,
		ServerCallContext context)
	{
		return Task.FromResult(new User {
			Id = request.Id,
			Name = "Alice"
		});
	}
}

Cliente gRPC – .NET

var channel = GrpcChannel.ForAddress("https://localhost:5001");
var client = new UserService.UserServiceClient(channel);

var user = await client.GetUserAsync(
	new GetUserRequest { Id = "123" });

Server Streaming – Cliente Go

stream, _ := client.ListUsers(ctx, &pb.Empty{})

for {
	user, err := stream.Recv()
	if err == io.EOF {
		break
	}
	fmt.Println(user.Name)
}

Client Streaming – Servidor Go

func (s *UserServer) CreateUsers(
	stream pb.UserService_CreateUsersServer,
) error {
	count := 0
	for {
		_, err := stream.Recv()
		if err == io.EOF {
			return stream.SendAndClose(
				&pb.CreateUsersResponse{Count: int32(count)},
			)
		}
		count++
	}
}

Bidirectional Streaming – Go

func (s *UserServer) Chat(
	stream pb.UserService_ChatServer,
) error {
	for {
		msg, err := stream.Recv()
		if err != nil {
			return err
		}
		stream.Send(&pb.ChatMessage{
			From: "server",
			Message: msg.Message,
		})
	}
}

Deadlines y timeouts

ctx, cancel := context.WithTimeout(
	context.Background(),
	time.Second,
)
defer cancel()

client.GetUser(ctx, req)

Manejo de errores gRPC

return nil, status.Errorf(
	codes.NotFound,
	"user not found",
)

Interceptor – Go

func LoggingInterceptor(
	ctx context.Context,
	req any,
	info *grpc.UnaryServerInfo,
	handler grpc.UnaryHandler,
) (any, error) {
	log.Println(info.FullMethod)
	return handler(ctx, req)
}

Seguridad – mTLS

creds, _ := credentials.NewServerTLSFromFile(
	"cert.pem",
	"key.pem",
)

grpc.NewServer(
	grpc.Creds(creds),
)

Health Check

service Health {
	rpc Check(HealthCheckRequest)
		returns (HealthCheckResponse);
}

grpc-health-probe -addr=:50051

Testing rápido con grpcurl

grpcurl -plaintext \
	-d '{"id":"123"}' \
	localhost:50051 user.v1.UserService/GetUser

gRPC-Web (concepto)

  • Backend gRPC normal
  • Proxy Envoy
  • Cliente JS generado desde .proto
  • Unary + server streaming

Convenciones rápidas

  • Siempre usar deadlines
  • Mensajes pequeños
  • Versionar servicios
  • Auth vía metadata
  • Streaming para flujos largos

Relación con otras notas

gRPC – Node.js y Spring Boot (uso real + ejemplos)

¿Se puede usar gRPC con Node.js y Spring Boot?

Sí. Ambos están soportados oficialmente, se usan en producción y encajan muy bien en arquitecturas de microservicios.

  • Node.js
    • Muy común para BFF, gateways y servicios I/O bound
    • Soporte oficial vía @grpc/grpc-js
  • Spring Boot (Java)
    • Muy usado en core backends enterprise
    • Integración madura con Spring Ecosystem

Node.js + gRPC

Stack habitual

  • Node.js 18+
  • @grpc/grpc-js
  • @grpc/proto-loader
  • Protobuf v3

Instalación

npm install @grpc/grpc-js @grpc/proto-loader

`

Servidor gRPC – Node.js

import grpc from "@grpc/grpc-js";
import protoLoader from "@grpc/proto-loader";

const packageDef = protoLoader.loadSync(
	"user.proto",
	{ keepCase: true }
);

const proto = grpc.loadPackageDefinition(packageDef);

function getUser(call, callback) {
	callback(null, {
		id: call.request.id,
		name: "Alice",
	});
}

const server = new grpc.Server();
server.addService(
	proto.user.v1.UserService.service,
	{ getUser }
);

server.bindAsync(
	"0.0.0.0:50051",
	grpc.ServerCredentials.createInsecure(),
	() => server.start()
);

Cliente gRPC – Node.js

const client = new proto.user.v1.UserService(
	"localhost:50051",
	grpc.credentials.createInsecure()
);

client.getUser({ id: "123" }, (err, res) => {
	console.log(res);
});

Server Streaming – Node.js

function listUsers(call) {
	call.write({ id: "1", name: "Alice" });
	call.write({ id: "2", name: "Bob" });
	call.end();
}

Uso típico de Node.js con gRPC

  • BFF (Backend for Frontend)
  • API Gateway interno
  • Servicios de agregación
  • Streaming de eventos hacia frontend (vía gRPC-Web)

Spring Boot + gRPC

Stack habitual

  • Java 17+
  • Spring Boot 3.x
  • grpc-spring-boot-starter
  • Netty

Dependencias (Gradle)

implementation "net.devh:grpc-server-spring-boot-starter:2.15.0.RELEASE"
implementation "net.devh:grpc-client-spring-boot-starter:2.15.0.RELEASE"

Servidor gRPC – Spring Boot

@GrpcService
public class UserServiceImpl
	extends UserServiceGrpc.UserServiceImplBase {

	@Override
	public void getUser(
		GetUserRequest request,
		StreamObserver<User> responseObserver
	) {
		User user = User.newBuilder()
			.setId(request.getId())
			.setName("Alice")
			.build();

		responseObserver.onNext(user);
		responseObserver.onCompleted();
	}
}

Cliente gRPC – Spring Boot

@GrpcClient("user-service")
private UserServiceGrpc.UserServiceBlockingStub client;

public User getUser(String id) {
	return client.getUser(
		GetUserRequest.newBuilder()
			.setId(id)
			.build()
	);
}

Configuración Spring

grpc:
	server:
		port: 50051

Streaming – Spring Boot

@Override
public void listUsers(
	Empty request,
	StreamObserver<User> responseObserver
) {
	responseObserver.onNext(user1);
	responseObserver.onNext(user2);
	responseObserver.onCompleted();
}

Comparación Node.js vs Spring Boot

  • Node.js
    • Excelente para I/O
    • Menor consumo de recursos
    • Más simple para gateways
    • Menos tooling enterprise
  • Spring Boot
    • Muy robusto
    • Excelente integración con seguridad
    • Observabilidad madura
    • Ideal para dominios complejos

Interoperabilidad real

Ejemplo común en producción:

  • Frontend → gRPC-Web → Node.js BFF
  • Node.js → gRPC → Spring Boot
  • Spring Boot → gRPC → otros servicios Java / Go

Todos comparten el mismo .proto.

Antipatrones específicos

  • Node.js
    • Bloquear el event loop
    • Usar gRPC para CPU-bound heavy tasks
  • Spring Boot
    • Usar DTOs duplicados fuera de Protobuf
    • No manejar backpressure en streaming

Casos reales donde encajan mejor

  • Node.js
    • BFF
    • API Gateway
    • Realtime feeds
  • Spring Boot
    • Core domain services
    • Sistemas financieros
    • Backends enterprise

Relación con otras notas