Práctica: Desarrollar y probar la comunicación entre todos los servicios

Concepto clave

La comunicación entre microservicios con gRPC y Protocol Buffers es como un sistema de mensajería corporativa altamente especializado. Imagina una empresa multinacional donde cada departamento (servicio) necesita intercambiar información estructurada de forma rápida y sin ambigüedades. Protocol Buffers actúa como el formulario estandarizado que todos deben usar, definiendo exactamente qué datos se envían y en qué formato. gRPC es el sistema de entrega que garantiza que estos formularios lleguen rápido y de manera confiable entre departamentos, usando conexiones persistentes HTTP/2.

La ventaja clave es la eficiencia y tipado fuerte. A diferencia de REST/JSON donde cada servicio debe parsear y validar datos en tiempo de ejecución, con gRPC el contrato (.proto) se compila en código nativo para cada lenguaje. Esto elimina errores de serialización y reduce drásticamente el overhead de red. En un sistema distribuido avanzado, esta predictibilidad es crítica para mantener baja latencia y alta disponibilidad.

Cómo funciona en la práctica

Implementar comunicación completa entre servicios requiere coordinación en tres capas: definición de contrato, implementación de servidores/clientes, y configuración de red. Comenzamos con el archivo .proto que define todos los servicios y mensajes:

syntax = "proto3";

package ecommerce;

service OrderService {
  rpc CreateOrder(CreateOrderRequest) returns (OrderResponse);
  rpc GetOrder(GetOrderRequest) returns (OrderResponse);
}

service InventoryService {
  rpc CheckStock(StockRequest) returns (StockResponse);
  rpc UpdateStock(UpdateStockRequest) returns (StockResponse);
}

message CreateOrderRequest {
  string user_id = 1;
  repeated OrderItem items = 2;
  string payment_method = 3;
}

message OrderItem {
  string product_id = 1;
  int32 quantity = 2;
  float unit_price = 3;
}

Luego compilamos este contrato para cada lenguaje (Go, Python, Java) usando el compilador protoc. Cada servicio implementa su servidor gRPC exponiendo los métodos definidos, mientras que los clientes se generan automáticamente para consumir otros servicios. La magia ocurre cuando OrderService necesita verificar inventario: simplemente llama al cliente generado de InventoryService como si fuera una función local, pero internamente gRPC maneja la serialización binaria y la comunicación de red.

Caso de estudio

Consideremos un sistema de e-commerce con tres servicios: Orders (Go), Inventory (Python), y Payments (Java). Cuando un usuario realiza una compra:

1. Orders recibe la solicitud y llama sincrónicamente a Inventory.CheckStock() via gRPC
2. Si hay stock, Orders llama asincrónicamente a Payments.ProcessPayment() usando streaming bidireccional
3. Al confirmar el pago, Orders llama a Inventory.UpdateStock() y persiste la orden

La implementación real muestra cómo manejar diferentes patrones de comunicación:

Servicio	Lenguaje	Endpoint gRPC	Dependencias
Orders	Go	:50051	Inventory, Payments
Inventory	Python	:50052	Ninguna
Payments	Java	:50053	Ninguna

En producción, cada servicio debería usar balanceo de carga client-side con resolución DNS o service discovery.

Errores comunes

• Versionado incorrecto de .proto: Cambiar campos sin considerar backward compatibility rompe clientes existentes. Solución: Usar campos opcionales y nunca reutilizar números de campo.
• Timeout no configurados: Llamadas bloqueantes sin timeout pueden colgar servicios enteros. Configurar deadlines apropiadas según el percentil 99 de latencia esperada.
• Falta de manejo de errores gRPC: No todos los errores son excepciones; códigos como UNAVAILABLE o DEADLINE_EXCEEDED requieren lógica de retry específica.
• Serialización de tipos complejos
• Olvidar cerrar conexiones: Las conexiones HTTP/2 persistentes deben cerrarse explícitamente al terminar para evitar leaks de recursos.

Checklist de dominio

• Puedo definir un archivo .proto con múltiples servicios y mensajes anidados
• Sé compilar protos para al menos 2 lenguajes diferentes y generar código cliente/servidor
• Implemento servidores gRPC que exponen métodos unarios, streaming y bidireccionales
• Configuro timeouts, retries y manejo de errores específicos de gRPC
• Puedo depurar comunicación entre servicios usando herramientas como grpcurl o BloomRPC
• Entiendo cómo gRPC interactúa con service mesh (Istio/Linkerd) en Kubernetes
• Sé monitorear métricas gRPC específicas (latencia, error rates, mensajes/segundo)

Implementar flujo completo de orden con tres servicios gRPC

Objetivo

Crear un sistema donde tres servicios microservicios se comuniquen via gRPC para procesar una orden de e-commerce.

Pasos

1. Crea un archivo ecommerce.proto que defina:
   • Servicio OrderService con métodos CreateOrder y GetOrder
   • Servicio InventoryService con CheckStock y UpdateStock
   • Servicio PaymentService con ProcessPayment
   • Mensajes necesarios incluyendo Order, OrderItem, PaymentRequest
2. Genera código para Go (Orders), Python (Inventory) y Java (Payments)
3. Implementa OrderService en Go que:
   • Llama a InventoryService.CheckStock() sincrónicamente
   • Si hay stock, llama a PaymentService.ProcessPayment()
   • Al confirmar pago, llama a InventoryService.UpdateStock()
   • Persiste la orden localmente
4. Implementa InventoryService en Python que mantiene stock en memoria
5. Implementa PaymentService en Java que simula procesamiento de pago
6. Configura cada servicio para escuchar en puertos diferentes (50051-50053)
7. Crea un cliente de prueba que envíe una orden completa y valide el flujo
8. Agrega logging que muestre las llamadas entre servicios en tiempo real

Requisitos técnicos

• Usa deadlines de 5 segundos para todas las llamadas gRPC
• Implementa retry logic para códigos de error UNAVAILABLE
• Agrega manejo de errores granular (stock insuficiente, pago rechazado)
• Los servicios deben poder iniciarse independientemente

Pistas

• Usa el patrón de inyección de dependencias para los clientes gRPC en OrderService
• Considera usar context.WithTimeout para los deadlines en Go
• En Python, implementa __enter__ y __exit__ en el cliente para manejo automático de conexiones

Evalua tu comprension

Completa el quiz interactivo de arriba para ganar XP.