gRPC para Go (Golang): bibliotecas, ejemplos y guía

gRPC para Go (Golang): bibliotecas y ejemplos

¿Qué es gRPC y por qué es necesario en Go?

gRPC es un framework de alto rendimiento para llamadas a procedimientos remotos (RPC), desarrollado por Google. Utiliza Protocol Buffers (protobuf) para la serialización de datos y HTTP/2 para el transporte. En el ecosistema de Go, gRPC se ha convertido en el estándar para construir arquitecturas de microservicios gracias a:

• Alto rendimiento (protocolo binario, multiplexación HTTP/2)
• Tipado estricto (código generado en Go)
• Soporte de streaming (cliente, servidor y bidireccional)
• Autenticación y balanceo de carga integrados

En este artículo, revisaremos las bibliotecas principales, las herramientas y escribiremos un ejemplo completo de servidor y cliente en Golang.

Bibliotecas y herramientas necesarias

Para trabajar con gRPC en Go necesitarás:

• google.golang.org/grpc — biblioteca principal de gRPC para Go
• google.golang.org/protobuf — trabajo con Protocol Buffers
• protoc — compilador de archivos .proto
• protoc-gen-go — plugin para generar código Go a partir de .proto
• protoc-gen-go-grpc — plugin para generar código de servidor/cliente gRPC

Instalación de herramientas

# Instalación de protoc (Linux/macOS)sudo apt install protobuf-compiler  # o brew install protobuf

# Instalación de plugins Gogo install google.golang.org/protobuf/cmd/protoc-gen-go@latestgo install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest

# Verificaciónprotoc --versionprotoc-gen-go --version

Creación del archivo .proto

Empecemos definiendo el servicio y los mensajes en el archivo hello.proto:

syntax = "proto3";

package hello;

option go_package = "github.com/youruser/grpc-example/hello";

service Greeter {  rpc SayHello (HelloRequest) returns (HelloReply);  rpc SayHelloStream (HelloRequest) returns (stream HelloReply);}

message HelloRequest {  string name = 1;}

message HelloReply {  string message = 1;}

Generación de código Go

protoc --go_out=. --go-grpc_out=. hello.proto

Después de la ejecución, aparecerán dos archivos:

• hello.pb.go — estructuras de mensajes
• hello_grpc.pb.go — interfaces de servidor y cliente

Implementación del servidor gRPC en Go

Creemos el archivo server.go:

package main

import (    "context"    "log"    "net"

    "google.golang.org/grpc"    pb "github.com/youruser/grpc-example/hello")

type server struct {    pb.UnimplementedGreeterServer}

func (s *server) SayHello(ctx context.Context, req *pb.HelloRequest) (*pb.HelloReply, error) {    log.Printf("Received: %v", req.GetName())    return &pb.HelloReply{Message: "Hello, " + req.GetName()}, nil}

func (s *server) SayHelloStream(req *pb.HelloRequest, stream pb.Greeter_SayHelloStreamServer) error {    for i := 0; i < 5; i++ {        if err := stream.Send(&pb.HelloReply{            Message: "Hello " + req.GetName() + " - " + fmt.Sprint(i),        }); err != nil {            return err        }    }    return nil}

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

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

    log.Println("Server listening on :50051")    if err := s.Serve(lis); err != nil {        log.Fatalf("failed to serve: %v", err)    }}

Implementación del cliente gRPC en Go

Creemos el archivo client.go:

package main

import (    "context"    "log"    "time"

    "google.golang.org/grpc"    "google.golang.org/grpc/credentials/insecure"    pb "git