gRPC, ¿qué es y cómo funciona?

gRPC es un marco de trabajo de comunicación remota altamente eficiente y escalable que se utiliza para implementar servicios API, se basa en el protocolo de transmisión de mensajes Protocol Buffers y utiliza la serialización binaria en lugar de la serialización de texto tradicional para mejorar la velocidad y la eficiencia de la transmisión de datos.

Permite a los desarrolladores crear servicios de forma fácil y eficiente y brinda una amplia gama de funciones, como autenticación, detección de errores, gestión de la congestión y más. Además, es compatible con múltiples lenguajes de programación, lo que permite a los desarrolladores crear servicios unificados en una amplia variedad de plataformas.

Principales ventajas

1. Velocidad y eficiencia: gRPC utiliza Protocol Buffers para serializar y transmitir datos, lo que es más rápido y eficiente en términos de ancho de banda y recursos que otros formatos de serialización como JSON o XML.
2. Interoperabilidad: gRPC es compatible con múltiples lenguajes de programación, incluidos Go, Java, Python, Ruby y otros, lo que permite a los desarrolladores crear servicios unificados en una amplia variedad de plataformas.
3. Facilidad de uso: gRPC ofrece una interfaz de programación de aplicaciones (API) fácil de usar para crear servicios y realizar llamadas remotas, lo que simplifica el desarrollo y la mantenimiento de servicios API.
4. Soporte para stream: gRPC ofrece un soporte nativo para stream de datos, lo que permite a los desarrolladores crear servicios que procesen grandes cantidades de datos en tiempo real.
5. Seguridad: gRPC ofrece una amplia gama de características de seguridad, como la autenticación, la cifrado de datos y más, que pueden proteger los servicios API y los datos sensibles.

Fuente: https://grpc.io/

Ejemplo de código de un servicio en Go:

Definir el esquema de la solicitud y la respuesta en Protocol Buffers:

syntax = "proto3";

service GreetService {
  rpc Greet(GreetRequest) returns (GreetResponse) {}
}

message GreetRequest {
  string name = 1;
}

message GreetResponse {
  string message = 1;
}

Generar código de servidor y cliente en Go a partir del esquema de Protocol Buffers

protoc --go_out=plugins=grpc:. greet.proto

Implementar el servidor gRPC

package main

import (
	"context"
	"log"
	"net"

	"google.golang.org/grpc"
)

type server struct{}

func (s *server) Greet(ctx context.Context, req *GreetRequest) (*GreetResponse, error) {
	return &GreetResponse{Message: "Hello " + req.Name}, nil
}

func main() {
	lis, err := net.Listen("tcp", ":50051")
	if err != nil {
		log.Fatalf("Failed to listen: %v", err)
	}

	s := grpc.NewServer()
	RegisterGreetServiceServer(s, &server{})

	if err := s.Serve(lis); err != nil {
		log.Fatalf("Failed to serve: %v", err)
	}
}

Implementar el cliente gRPC

package main

import (
	"context"
	"log"

	"google.golang.org/grpc"
)

func main() {
	conn, err := grpc.Dial("localhost:50051", grpc.WithInsecure())
	if err != nil {
		log.Fatalf("Could not connect: %v", err)
	}
	defer conn.Close()

	client := NewGreetServiceClient(conn)
	req := &GreetRequest{Name: "John Doe"}
	res, err := client.Greet(context.Background(), req)
	if err != nil {
		log.Fatalf("Error while calling Greet: %v", err)
	}
	log.Printf("Response from Greet: %s", res.Message)
}