gRPC — Intermedio

Dirigido a desarrolladores Go que ya conocen los fundamentos de gRPC y quieren consolidar un dominio real del protocolo en proyectos productivos, este curso de 8 horas profundiza en el ciclo completo de diseño y operación de servicios gRPC: desde la modelización avanzada de contratos Protobuf con múltiples servicios y tipos de mensajes, pasando por la integración del código generado en servidor y cliente, la implementación de los distintos patrones de streaming y el manejo semántico de errores con status codes, hasta la propagación de metadatos transversales, la construcción de interceptores de logging y la depuración activa con herramientas como grpcurl. Al finalizar, el participante será capaz de diseñar, instrumentar y depurar un servicio gRPC completo en Go, tomando decisiones tecnológicas justificadas frente a alternativas REST/HTTP JSON.

1. Explicar las diferencias estructurales entre gRPC y REST/HTTP JSON, identificando criterios técnicos —latencia, tipo de cliente, contrato, entre otros— que guían la elección de uno u otro en un caso de uso concreto.
2. Diseñar archivos .proto con múltiples servicios y tipos de mensajes aplicando las convenciones de nomenclatura y tipos escalares de Protocol Buffers, e integrar el código generado por protoc en un servidor y cliente Go funcionales.
3. Implementar al menos un patrón de streaming (server-side, client-side o bidireccional) justificando su idoneidad para el caso de uso, y adaptar el manejo de errores para devolver status codes semánticos en lugar de errores genéricos.
4. Integrar metadatos gRPC en el flujo cliente-servidor para propagar información transversal sin alterar los mensajes Protobuf, y diseñar un interceptor unario que registre duración y status code de cada llamada.
5. Depurar un servicio gRPC en Go usando grpcurl o interceptores de logging, identificando y corrigiendo errores de contrato o de status code en escenarios simulados.

Bloque 1 — Modelización de contratos con Protocol Buffers. Se estudian las convenciones de nomenclatura de Protobuf, los tipos escalares y compuestos disponibles, y las buenas prácticas para estructurar un archivo .proto con múltiples servicios e interdependencias de mensajes. Se aborda también la comparación entre gRPC y REST/HTTP JSON, examinando criterios técnicos verificables —latencia esperada, naturaleza del cliente, rigidez del contrato, bidireccionalidad— que permiten argumentar la elección tecnológica con fundamento.

Bloque 2 — Generación de código e integración servidor-cliente. Se trabaja con el compilador protoc y los plugins de Go para generar stubs y skeletons, y se integra ese código en un servidor y un cliente Go reales, verificando la comunicación unaria en local. Se revisan las estructuras generadas, los patrones de registro del servidor y los modos de conexión del cliente, haciendo énfasis en los puntos de fallo más habituales durante la integración.

Bloque 3 — Patrones de streaming. Se exploran los tres modos de streaming que ofrece gRPC —server-side, client-side y bidireccional— analizando sus casos de uso canónicos. Los participantes implementan al menos uno de ellos en Go, documentando en el propio código la justificación de la elección, y comprueban el comportamiento del flujo de mensajes bajo distintas condiciones de carga y latencia simuladas.

Bloque 4 — Manejo de errores y status codes semánticos. Se profundiza en el modelo de errores de gRPC: diferencias entre errores de transporte y errores de aplicación, catálogo de status codes estándar y criterios para elegir entre NotFound, InvalidArgument, Unavailable u otros. Los participantes adaptan un servicio existente para sustituir errores genéricos por respuestas semánticas adecuadas a un conjunto de escenarios de fallo definidos.

Bloque 5 — Metadatos e interceptores. Se introduce el sistema de metadatos de gRPC como mecanismo para propagar información transversal —trace IDs, tokens de autenticación— sin contaminar los mensajes Protobuf. A continuación se diseña un interceptor unario en el servidor que registra duración y status code de cada llamada, integrándolo con un middleware o framework de logging existente, y se conecta este conocimiento con las técnicas de depuración activa mediante grpcurl y logging estructurado.

• Go 1.21 o superior instalado y configurado en el PATH.
• Compilador protoc (Protocol Buffers v3) con los plugins protoc-gen-go y protoc-gen-go-grpc instalados.
• grpcurl instalado y accesible desde la línea de comandos.
• Editor de código con soporte para Go (VS Code + extensión Go, GoLand o equivalente).
• Acceso a internet para descargar dependencias de módulos Go durante los ejercicios.
• Sistema operativo Linux, macOS o Windows con WSL2 (recomendado para paridad de entorno).

• Conocimiento de los fundamentos de gRPC equivalente al contenido cubierto en GRPC01: qué es gRPC, ciclo básico de definición Protobuf, generación de código y llamada unaria simple.
• Manejo fluido del lenguaje Go: tipos, interfaces, goroutines y gestión de errores.
• Familiaridad con herramientas de línea de comandos (terminal, gestión de módulos con go mod).
• Comprensión básica de HTTP/2 y del modelo cliente-servidor.