Introducción
Imagina un plano de control que necesita conversar continuamente con agentes instalados en varios hosts. La API envía comandos, cada agente publica heartbeats (señales periódicas de que sigue activo), informa cambios en el inventario y puede abrir un canal interactivo para una terminal. Una secuencia de llamadas HTTP independientes seguiría funcionando para operaciones puntuales, pero no expresaría con tanta naturalidad ese flujo persistente en ambos sentidos. Es en este tipo de problema donde gRPC en .NET 10 merece ser considerado.
gRPC es un framework de llamadas a procedimientos remotos (RPC, de Remote Procedure Call): el cliente invoca métodos definidos por contrato en un servidor, usando mensajes tipados que normalmente se serializan con Protocol Buffers y se transportan sobre HTTP/2. Yo lo elegiría cuando los participantes son servicios bajo el control del mismo equipo y necesitan compartir contratos generados o mantener un flujo de mensajes continuo, especialmente bidireccional. Eso no convierte a gRPC en un sustituto universal de REST, ni prueba que vaya a ser más rápido para cualquier aplicación.
En Dokpod, el navegador usa REST/OpenAPI para las operaciones de la interfaz y SignalR para las notificaciones. gRPC está en el canal interno entre la API y los agentes: el agente inicia una conexión saliente, se autentica con un certificado de cliente y mantiene un stream para intercambiar mensajes de control. Esa elección responde a una necesidad concreta del sistema, no a una regla para todos los productos.
Este es el primero de tres artículos de la serie APIs y Comunicación en .NET. La parte 2 será una guía introductoria de GraphQL; la parte 3 explicará SignalR en .NET, desde el primer Hub hasta producción. Ninguno de los dos se había publicado cuando escribí este artículo, por eso no incluyo enlaces que todavía no existían.
ℹ️ Información: En la fecha de esta consulta, el repositorio público de Dokpod no tenía releases ni tags publicados. Los enlaces de código de este artículo apuntan a la rama
mainy siguen su estado actual; por eso pueden cambiar y no representan una release estable.
RPC, REST y el papel de HTTP/2
Una llamada RPC empieza con una pregunta conocida: «¿qué operación quiero ejecutar y qué mensaje necesito enviar?». Un cliente llama a un método como GetInventory; el servidor recibe los datos, ejecuta la operación y devuelve una respuesta. La red queda oculta detrás de una interfaz parecida a una llamada local, pero la operación sigue siendo remota: puede tardar, fallar, cancelarse o perder la conexión. Esa distinción importa porque una red no ofrece las mismas garantías que una llamada dentro del proceso.
Para que exista una RPC, cliente y servidor deben ponerse de acuerdo sobre el nombre del método, los tipos de entrada y salida y cómo se representarán los datos. Ese acuerdo es el contrato. En gRPC suele describirse en archivos .proto; las herramientas generan código para construir mensajes e invocar el servicio. El código reduce diferencias de tipado y ayuda a detectar incompatibilidades durante el build, pero no elimina la necesidad de versionar y desplegar ambos lados con cuidado.
REST parte de otra organización mental. En lugar de preguntar «¿qué método remoto llamo?», el cliente interactúa con recursos identificados por URLs y usa la semántica HTTP, como GET, POST, PUT y DELETE. Una API REST normalmente expone representaciones, comúnmente JSON, que pueden inspeccionarse y consumirse por clientes diversos. gRPC describe operaciones y mensajes con más rigidez y suele priorizar clientes que conocen el contrato y pueden usar código generado. No es una división absoluta: ambos pueden transportar datos estructurados y ambos dependen de decisiones de diseño cuidadosas.
El gRPC tradicional usa HTTP/2. Esa versión de HTTP organiza los mensajes en frames y permite multiplexar varios streams sobre una conexión. Multiplexar significa que distintos intercambios pueden compartir la conexión sin abrir una conexión TCP por cada llamada. HTTP/2 también define control de flujo para limitar cuántos datos acepta un receptor. Esos recursos ofrecen una base adecuada para llamadas persistentes, pero no hacen automáticamente que una aplicación sea más rápida: la serialización, el tamaño de los mensajes, la red, el balanceo, la concurrencia y el trabajo en el servidor siguen determinando el resultado.
Un stream gRPC es una llamada lógica que puede contener un mensaje o varios. No debe confundirse con «una conexión TCP por método», ni debe suponerse que una conexión puede permanecer abierta para siempre en cualquier infraestructura. Proxies, firewalls, NATs, límites de duración, certificados y reinicios pueden interrumpir el flujo. La aplicación tiene que decidir cómo detectar la caída, abrir otra sesión y recuperar el estado que quedó incierto.
También hay una consecuencia práctica: un cliente gRPC tradicional en el navegador no es igual a un cliente C# o Go. Los navegadores no dan acceso irrestricto a las primitivas HTTP/2 que espera el gRPC convencional. Para escenarios web existen gRPC-Web y gateways que traducen protocolos, pero añaden componentes y restricciones. En Dokpod, la interfaz usa HTTP y SignalR, mientras que los agentes usan gRPC; separar a los consumidores evita obligar al navegador a hablar el protocolo interno.
⚠️ Atención: HTTP/2 multiplexa streams, pero la conexión sigue sujeta a fallos y límites de la red. Trata cada desconexión como una parte normal del diseño, no como un evento imposible.
Protocol Buffers, archivos .proto y código generado
Protocol Buffers, o Protobuf, es un formato de serialización y un lenguaje para describir mensajes. Serializar es transformar una estructura en bytes para transmitirla o almacenarla; deserializar es reconstruir la estructura del otro lado. Un archivo .proto declara mensajes, campos, números de campo, servicios y métodos. A partir de él, el compilador y los plugins del lenguaje generan tipos para el cliente y el servidor.
Un campo tiene tipo, nombre y número. El nombre ayuda a las personas que leen el contrato; el número identifica el campo en el formato binario. Esa diferencia es fundamental: una vez publicado y usado, un número no debe reutilizarse con otro significado. Si se elimina un campo, reserva su número y, cuando corresponda, su nombre. Añadir campos opcionales suele ser compatible en el formato binario, pero eso no garantiza compatibilidad de comportamiento. Un agente antiguo puede ignorar un campo nuevo; en cambio, un código de negocio puede depender de una capability (capacidad anunciada) que el agente no ofrece.
También es importante separar la compatibilidad del wire format (formato transmitido) de la compatibilidad de la aplicación. Un cambio puede seguir decodificándose y aun así romper un switch, una validación o una regla de negocio. El despliegue puede implicar varias versiones de la API y de los agentes activas al mismo tiempo. Por eso, los cambios de contrato necesitan una estrategia de rollout, pruebas con versiones consecutivas y observabilidad suficiente para identificar quién sigue usando el formato antiguo.
En Dokpod, AgentControl declara dos métodos de streaming. Connect recibe mensajes del agente y devuelve mensajes del plano de control. Exec usa otro stream, separado, para frames de terminal. Los mensajes de sobre transportan metadatos como la versión del protocolo, el identificador de la sesión, el fencing token y la secuencia. Un oneof agrupa tipos de payload alternativos, como AgentHello, Heartbeat, una página de inventario o un comando. Eso da al lector una visión explícita de los mensajes posibles sin convertir el canal en un proxy genérico hacia la API del engine.
El contrato también registra campos reservados y comentarios de evolución. Por ejemplo, los mensajes de inventario tienen revisiones y páginas, y las capabilities nuevas solo se aceptan cuando el servidor las reconoce. Esa disciplina forma parte del coste de un protocolo propio: el equipo pasa a ser responsable de documentar, probar y evolucionar los contratos que usa el producto.
Los cuatro modos de llamada gRPC
El tipo de una RPC se define por la cantidad de mensajes que cada lado puede enviar durante la llamada. El método unary recibe un mensaje y devuelve un mensaje. Es el modelo más simple: obtener los detalles de una configuración, validar un token o consultar una información puntual. Se parece a una llamada HTTP de request/response, aunque usa un método y mensajes tipados en el contrato.
En el streaming del servidor, el cliente envía una solicitud y el servidor responde con cero o más mensajes a lo largo del tiempo. Una exportación paginada, una secuencia de progreso o actualizaciones continuas que no necesitan respuesta del cliente son ejemplos posibles. El cliente puede cancelar el stream, y el servidor debe propagar el token de cancelación al trabajo asíncrono. Si el servidor intenta enviar una respuesta infinita sin límites, el coste de recursos también puede ser continuo.
En el streaming del cliente, el cliente envía varios mensajes y recibe una respuesta final. Eso puede tener sentido para enviar lotes, fragmentos de una tarea o muestras que el servidor consolida. El servidor lee hasta que el cliente cierra el stream y entonces responde. Este patrón no es solo «muchas llamadas unary»: mantiene una llamada abierta y una secuencia ordenada de mensajes.
En el streaming bidireccional, o duplex, ambos lados pueden enviar varios mensajes durante la misma llamada. No necesitan alternar un mensaje por lado: cliente y servidor pueden leer y escribir de forma independiente. Es útil cuando hay un intercambio continuo de comandos, respuestas, estados y confirmaciones. El protocolo de la aplicación todavía debe definir correlación, orden, control de flujo, prioridad y qué hacer cuando la llamada termina.
| Modo | Mensajes del cliente | Mensajes del servidor | Ejemplo de uso |
|---|---|---|---|
| Unary | Uno | Uno | Consulta puntual |
| Streaming del servidor | Uno | Muchos | Progreso o feed de lectura |
| Streaming del cliente | Muchos | Uno | Envío de lotes para consolidación |
| Bidireccional | Muchos | Muchos | Canal interactivo de control |
El Connect de Dokpod es bidireccional porque los agentes y la API necesitan enviar mensajes mientras la sesión está activa. Eso no significa que cada agente tenga que transmitir datos en todo momento. Heartbeats, inventario y comandos son mensajes de aplicación transportados en el stream; la aplicación sigue definiendo cuándo y por qué debe circular cada uno.
Por qué Dokpod eligió gRPC para los agentes
El contexto de Dokpod es distinto del de una API pública orientada a cualquier navegador. El producto necesita llegar a engines de contenedores instalados en hosts que pueden estar en redes privadas, detrás de NAT o protegidos por reglas que no permiten conexiones iniciadas desde fuera. Hacer que la API central iniciara una conexión hasta cada host exigiría direcciones accesibles y reglas de red por entorno.
Con una conexión saliente, el agente inicia la sesión hacia la API. Eso suele encajar mejor en redes restringidas porque el host solo necesita permitir una salida controlada, no publicar el socket de Docker, un endpoint de Podman o SSH en la red. El patrón no elimina la configuración de red ni todas las amenazas, pero reduce la necesidad de abrir la interfaz administrativa del engine a conexiones remotas.
El segundo motivo es el contrato de dominio. Un proxy genérico que reenviara cualquier llamada al Docker Engine ampliaría el impacto de un fallo de autorización: la API podría convertirse en un puente hacia operaciones arbitrarias del host. Dokpod envía comandos propios y versionados, como iniciar o detener un contenedor, y el agente valida lo que recibió antes de usar el adapter del engine. Eso limita la superficie en comparación con un proxy irrestricto. Aun así, el agente es un componente privilegiado; el protocolo necesita autorizar cada operación, validar las entradas y evitar exponer datos sensibles.
El streaming bidireccional permite que el servidor envíe comandos y que el agente informe aceptación, resultado, heartbeat y diferencias de inventario en el mismo canal de control. La elección también permite que el servidor negocie sesión, versión y capabilities. Eso es valioso para un producto que controla ambos extremos, pero trae el coste de mantener una especificación y garantizar la compatibilidad entre ellos.
Hay límites importantes. El plan actual empieza con una única instancia de la API. Escalar horizontalmente requiere decidir qué instancia es dueña de cada stream, cómo enrutar los comandos y cómo recuperar el ownership tras un fallo. Dokpod aplaza esa escala distribuida para una decisión futura. Las pruebas ejecutadas confirmaron el funcionamiento del adapter con Podman en Linux; eso no sustituye la validación de cada combinación de versiones y entorno. El agente de Windows todavía depende de gates de cualificación. La elección del protocolo no certifica automáticamente todos los engines ni sistemas operativos.
Cómo funciona el flujo gRPC de Dokpod
El agente abre AgentControl.Connect y envía AgentHello como primer mensaje. El hello informa la versión del agente, el engine y su versión, el sistema operativo, la arquitectura, el hostname y las capabilities. El servidor obtiene el certificado de cliente de la conexión TLS y entrega el certificado y el hello al negociador de sesión. Si la identidad o la negociación se rechazan, la llamada termina con un error gRPC; no existe una sesión válida solo porque el TCP se conectó.
Cuando acepta la sesión, el plano de control devuelve SessionEstablished: la versión de protocolo seleccionada, el identificador de la sesión, el fencing token, el intervalo de heartbeat, el límite de mensaje y las capabilities aceptadas. El agente valida esos metadatos antes de iniciar el trabajo de la sesión. El intervalo anunciado es de 15 segundos y el servicio usa un timeout de heartbeat de 90 segundos. Esos números describen el código consultado, no una recomendación universal para cualquier red.
Tras la negociación, el agente puede publicar snapshots paginados y deltas del inventario. El snapshot reconstruye el estado completo por partes; el delta representa cambios a partir de una revisión base. Los heartbeats incluyen la última secuencia de comando aplicada y las revisiones de inventario. La API también puede enviar solicitudes de reconciliación, consultas y comandos de dominio. Separar «aceptado» de «resultado concluido» permite representar que recibir la orden no significa que el engine ya haya terminado la operación.

El fragmento siguiente resume la forma del contrato, sin intentar reproducir todos los mensajes:
| |
📂 Código Fuente: El contrato completo está en la rama
mainde Dokpod:agent.proto.
En el cliente, el agente escribe el hello, espera la confirmación inicial y solo entonces considera la sesión establecida. El código generado proporciona los tipos y el proxy del servicio; la lógica de abajo muestra el punto de validación, no un cliente completo:
| |
📂 Código Fuente: El flujo de sesión y reconexión está en
AgentControlWorker.cs; el procesamiento en el servidor está enAgentControlService.cs.
La terminal usa AgentControl.Exec, un stream separado que empieza con un handshake vinculado a la identidad del certificado, la sesión activa, el fencing token y una sesión de terminal pendiente. Transporta frames de entrada, salida, redimensionamiento y estado. Un canal separado evita mezclar el flujo interactivo con heartbeats e inventario, pero exige límites, expiración y cierre coordinado.
Seguridad, reconexión y confiabilidad
gRPC no es una política de seguridad. TLS protege el canal y autentica al servidor; mTLS añade un certificado de cliente, que permite al servidor autenticar la identidad del agente. En el flujo de Dokpod, la API exige el certificado de cliente y negocia la sesión a partir de él y de la información del agente. Los certificados necesitan emisión, rotación, revocación, almacenamiento y alcance bien definidos. Un certificado válido identifica a un participante, pero no sustituye la autorización de negocio para cada comando.
Es útil separar cuatro preguntas: ¿quién estableció el canal? ¿A qué entorno pertenece esa identidad? ¿El protocolo acepta la versión y las capabilities anunciadas? ¿Puede la identidad ejecutar esta operación, sobre este recurso y en este momento? Resolver solo la primera pregunta con mTLS dejaría el resto sin respuesta. El servidor necesita validar la autorización antes de persistir o enviar comandos; el agente también debe rechazar payloads inválidos y operaciones que no implementa.
Las conexiones persistentes se caen. El proceso puede reiniciarse, la red puede cambiar, un NAT puede expirar el mapeo o el servidor puede cerrar una llamada. El agente intenta reconectar, pero la nueva conexión no debe continuar simplemente como si fuera la antigua. Una sesión recibe un identificador y un fencing token: un número creciente que permite distinguir la sesión vigente de una conexión antigua que reapareció con retraso. El servidor rechaza los mensajes que llegan con una sesión o un token obsoletos.
Las secuencias e identificadores de comando ayudan a detectar mensajes duplicados y huecos. Sin embargo, el transporte gRPC no ofrece entrega exactamente una vez. Si una respuesta se pierde después de que la operación se aplicó, el agente puede no saber si debe repetirla. Dokpod asume entrega at-least-once (al menos una vez) en algunos flujos y combina deduplicación, journal y reconciliación para reducir efectos duplicados y recuperar divergencias. Eso no es una garantía de exactly-once (exactamente una vez): el resultado debe diseñarse para lidiar con repeticiones y estados inciertos.
El tamaño de los mensajes también forma parte de la seguridad. Los mensajes grandes pueden consumir memoria y retrasar otras actividades. El servidor de Dokpod define un límite gRPC de 1 MiB, y las respuestas de consulta se fraccionan con un límite documentado de 256 KiB. La aplicación debe validar sus propios límites, acotar colas y tasas, y cancelar operaciones cuando dejan de ser necesarias. Un stream que permanece abierto no es una licencia para acumular mensajes sin control.
Por último, la alta disponibilidad no viene de una RPC duplex. El diseño actual empieza con una instancia de la API; el ownership distribuido de los streams y el enrutamiento duradero quedan aplazados. La revisión de preparación registra pendientes de compatibilidad N/N-1, carga y observabilidad de release, además de la cualificación del agente de Windows. Esa distinción impide que un ejemplo arquitectónico se confunda con una certificación de producción.
Cuándo elegir gRPC, REST, GraphQL o SignalR
Yo empezaría por la forma del consumidor y del flujo, no por una lista de «ventajas». Si los clientes son servicios controlados y el equipo puede distribuir contratos y código generado, gRPC puede simplificar una integración tipada. Si los clientes incluyen navegadores, scripts, socios o herramientas variadas, REST suele reducir la fricción y facilita la observación con herramientas HTTP conocidas. GraphQL atiende otro problema: permitir que los consumidores consulten campos y relaciones de un grafo de datos mediante una API orientada a consultas. SignalR atiende la comunicación en tiempo real con clientes web y abstracciones de alto nivel como hubs y grupos en el ecosistema ASP.NET Core.
| Opción | Consumidor típico | Dirección del flujo | Contrato y payload | Coste operativo |
|---|---|---|---|---|
| gRPC | Servicios y agentes controlados | Unary y streaming en ambos sentidos | .proto, código generado, Protobuf por defecto | HTTP/2, contratos coordinados y diagnóstico de streams |
| REST | Navegadores, apps e integraciones | Solicitud/respuesta; el streaming requiere un diseño específico | Recursos HTTP, OpenAPI y JSON frecuentes | Baja fricción y amplia compatibilidad de herramientas |
| GraphQL | Clientes con necesidades de lectura variables | Consulta/respuesta mediante schema | Schema GraphQL y selección de campos | Control del coste de consultas, resolvers y caché |
| SignalR | Navegadores y clientes conectados | Eventos y mensajes en tiempo real | Hubs, métodos y payloads de la aplicación | Conexiones persistentes, grupos y escala/backplane cuando sea necesario |
En Dokpod, el navegador consume REST/OpenAPI para las operaciones y SignalR para recibir notificaciones segmentadas por entorno. La relación entre navegador y API es distinta de la relación entre agente y API. Eso evita que la interfaz web dependa del canal interno gRPC. Si un producto necesita llamadas gRPC originadas en el navegador, se pueden evaluar gRPC-Web o un gateway; cada opción introduce requisitos de proxy, compatibilidad y soporte de streaming que deben comprobarse.
Tampoco elegiría gRPC solo porque el payload binario parezca más pequeño o porque HTTP/2 tenga multiplexación. Sin un benchmark representativo, no hay evidencia para afirmar una superioridad de rendimiento. Si una operación es puntual, simple y orientada a clientes heterogéneos, REST puede ser la elección más clara. Si el problema exige consultas flexibles sobre muchos recursos, investiga GraphQL. Si el navegador necesita recibir eventos, evalúa SignalR, SSE o WebSockets. Si servicios controlados necesitan intercambiar mensajes continuamente con un contrato explícito, gRPC merece un prototipo.
Ejemplo Práctico
Considera el ciclo de vida de un agente de Dokpod. Primero, abre una conexión saliente hacia la API y llama a Connect. A continuación, envía AgentHello con su identidad operativa y las capacidades que anuncia. El servidor valida el certificado, lo relaciona con un entorno y negocia la sesión. Si la negociación se aprueba, responde con SessionEstablished, que incluye el protocolo elegido, el fencing token, el intervalo de heartbeat, el límite de mensaje y las capabilities aceptadas.
A partir de ahí, el agente y la API pueden escribir en el stream. El agente envía heartbeats y publica inventario paginado o deltas; el plano de control envía comandos, consultas o solicitudes de reconciliación. Para una operación, el mensaje de comando lleva metadatos de sesión y secuencia. El agente valida la sesión activa, deduplica la operación cuando corresponde y devuelve estados separados para la aceptación y el resultado. Si la conexión cae antes de que llegue el resultado, la API no debe suponer que el comando falló ni repetirlo a ciegas: necesita consultar el estado persistido y reconciliarse con el agente tras reconectar.
Este fragmento del contrato ilustra cómo cambia el payload sin crear una llamada para cada tipo de evento:
| |
📂 Código Fuente: La definición completa, incluidos los payloads y la numeración de los campos, está en el contrato
agent.proto.
El valor didáctico del ejemplo está en los límites entre las partes. El protocolo define la forma de los mensajes; el cliente mantiene la conexión y coordina las colas; el servicio de la API negocia y procesa eventos; los adapters hablan con Docker o Podman. La API no reenvía una llamada arbitraria al socket del engine. Esa separación hace más explícito quién puede solicitar una operación y qué capacidad del agente se necesita.
El flujo de terminal es distinto. La API abre un Exec separado después de validar que la identidad del agente, la sesión y el fencing token corresponden a una sesión de terminal pendiente. Los frames transportan datos de entrada, salida, redimensionamiento y estado. No es un shell genérico ofrecido por gRPC: es una funcionalidad de dominio con autorización, expiración y condiciones de soporte propias. El repositorio documenta que ciertas acciones de terminal se limitan a agentes Linux y a capabilities anunciadas.
Para adaptar el patrón a otro sistema, empieza con un mensaje hello mínimo, una negociación explícita y un conjunto pequeño de tipos de evento. Define cómo se identificará una operación, cómo se tratarán los mensajes duplicados y cómo descubre el cliente el estado actual tras una interrupción. Añade streaming bidireccional solo si ambos lados realmente necesitan producir mensajes durante la misma sesión.
Consejos y Buenas Prácticas
- Define plazos y cancelación. Las llamadas unary deben tener un deadline adecuado al trabajo; las operaciones largas deben observar el token de cancelación. Los streams continuos necesitan una política clara de cierre y reconexión.
- Nunca reutilices números de Protobuf. Al eliminar un campo, reserva su número y evalúa reservar también el nombre. Los cambios en el
.protodeben pasar por una revisión de compatibilidad y pruebas entre versiones. - Limita mensajes, colas y frecuencia. Define el tamaño máximo, aplica paginación o fragmentación y usa colas acotadas. Sin límites, un cliente lento puede convertir un stream persistente en un crecimiento ilimitado de memoria.
- Autentica y autoriza por separado. TLS protege el transporte; mTLS identifica el certificado del agente. Sigue siendo necesario asociar la identidad a un alcance y autorizar cada comando y recurso.
- Diseña la repetición como comportamiento normal. Usa IDs idempotentes, deduplicación y reconciliación. No prometas exactamente una vez porque una RPC devolvió éxito o porque un canal permaneció abierto.
- Prueba versiones e interrupciones. Ejercita una caída durante el envío, una respuesta perdida, un reinicio del servidor, un certificado revocado y un agente antiguo. La compatibilidad teórica del wire format no sustituye las pruebas N/N-1.
- Mide antes de hablar de rendimiento. Compara una carga representativa, los mismos datos y la misma topología. Registra latencia, CPU, memoria, bytes, conexiones y tasa de errores para gRPC y las alternativas.
Conclusión
gRPC combina RPC, contratos definidos en .proto, código generado, mensajes Protobuf y un transporte normalmente basado en HTTP/2. Su modelo admite llamadas unary, streaming del servidor, streaming del cliente y streaming bidireccional. Ese conjunto es especialmente útil cuando servicios controlados necesitan intercambiar mensajes tipados de forma continua, pero también exige decisiones sobre la evolución del contrato, límites de recursos, autenticación, autorización, cancelación y recuperación.
El caso de Dokpod muestra una elección coherente con el problema: agentes en hosts privados inician conexiones salientes, se autentican mediante mTLS y mantienen un canal para control e inventario. La API no necesita exponer sockets de Docker ni SSH, y el protocolo transmite comandos de dominio, no llamadas arbitrarias al engine. La interfaz web usa REST/OpenAPI y SignalR, porque el navegador y el agente son consumidores distintos con necesidades distintas.
Esa elección no prueba que gRPC sea siempre más rápido, más simple o mejor que REST. Tampoco significa que la arquitectura ya esté cualificada para toda combinación de engine y sistema operativo: aunque las pruebas ejecutadas confirman el funcionamiento con Podman en Linux, todavía hay gates de carga, compatibilidad N/N-1, cualificación del agente de Windows y observabilidad de release. La conclusión correcta es más modesta y útil: usa gRPC cuando un contrato tipado y un flujo continuo justifiquen el coste operativo, valida las condiciones reales de la red y mantén alternativas adecuadas para otros clientes.
En la parte 2 de la serie APIs y Comunicación en .NET, trataré GraphQL para principiantes y los problemas que resuelve una API orientada a consultas. En la parte 3, me centraré en SignalR en .NET, incluidos hubs, clientes, reconexión y operación. Hasta entonces, el artículo publicado sobre tiempo real en Angular y .NET sigue siendo una lectura complementaria sobre WebSockets, SSE, SignalR y Long Polling, pero no forma parte de esta nueva serie.
Resumen Objetivo
- gRPC — framework de RPC que describe servicios y mensajes en contratos, genera código cliente/servidor y normalmente transporta las llamadas sobre HTTP/2.
- Protocol Buffers — lenguaje y formato binario asociados a gRPC; cada campo tiene un número estable que no debe reutilizarse tras su publicación.
- Streaming bidireccional — permite que cliente y servidor envíen varios mensajes durante una misma llamada, sin exigir que se alternen en cada envío.
- Dokpod — usa gRPC con mTLS en el canal interno entre la API y los agentes; el navegador usa REST/OpenAPI y SignalR.
- Confiabilidad — gRPC no ofrece por sí solo entrega exactamente una vez ni alta disponibilidad; la repetición, la deduplicación, el fencing y la reconciliación pertenecen al diseño de la aplicación.
- Adopción — gRPC es adecuado cuando los contratos tipados y los flujos continuos justifican su operación; REST, GraphQL y SignalR atienden necesidades distintas de cliente y tráfico.
Lee También
- Diseño de API REST: Verbos HTTP y Parameter Binding
- API Gateway, seguridad de SPA y JWT con BFF
- Tiempo real en Angular y .NET: WebSockets, SSE y SignalR
- Arquitectura de eventos sin caos con C#
Referencias
- Introduction to gRPC — visión general oficial de RPC, Protobuf, generación de código y streaming.
- Overview for gRPC on .NET — soporte de gRPC en ASP.NET Core y clientes .NET.
- Create gRPC services and methods — tipos de llamada e implementación de servicios en .NET.
- Protocol Buffers: Language Guide (proto3) — mensajes, campos, números, generación y evolución de contratos.
- RFC 9113: HTTP/2 — especificación de streams, multiplexación, conexión y control de flujo.
- Authentication and authorization in gRPC for ASP.NET Core — autenticación por certificado y autorización de llamadas.
- Reliable gRPC services with deadlines and cancellation — deadlines, cancelación y propagación en .NET.
- ADR 2026-0001 de Dokpod — motivación arquitectónica y trade-offs del canal entre la API y los agentes.

Al comentar, aceptas nuestra Política de Privacidad, Términos de Uso, Política de Eliminación de Datos.