gRPC para Go (Golang): bibliotecas, exemplos e guia

gRPC para Go (Golang): bibliotecas e exemplos

O que é gRPC e por que é necessário em Go?

gRPC é um framework de chamada de procedimento remoto (RPC) de alto desempenho, desenvolvido pelo Google. Ele usa Protocol Buffers (protobuf) para serialização de dados e HTTP/2 para transporte. No ecossistema Go, o gRPC se tornou o padrão para construção de arquitetura de microsserviços devido a:

• Alto desempenho (protocolo binário, multiplexação HTTP/2)
• Tipagem forte (código gerado em Go)
• Suporte a streaming (cliente, servidor e bidirecional)
• Autenticação e balanceamento de carga integrados

Neste artigo, abordaremos as principais bibliotecas, ferramentas e escreveremos um exemplo completo de servidor e cliente em Golang.

Bibliotecas e ferramentas necessárias

Para trabalhar com gRPC em Go, você precisará de:

• google.golang.org/grpc — biblioteca principal do gRPC para Go
• google.golang.org/protobuf — trabalho com Protocol Buffers
• protoc — compilador de arquivos .proto
• protoc-gen-go — plugin para geração de código Go a partir de .proto
• protoc-gen-go-grpc — plugin para geração de código de servidor/cliente gRPC

Instalação das ferramentas

# Instalação do protoc (Linux/macOS)sudo apt install protobuf-compiler  # ou brew install protobuf

# Instalação dos plugins Gogo install google.golang.org/protobuf/cmd/protoc-gen-go@latestgo install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest

# Verificaçãoprotoc --versionprotoc-gen-go --version

Criação do arquivo .proto

Vamos começar definindo o serviço e as mensagens no arquivo 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;}

Geração do código Go

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

Após a execução, dois arquivos serão gerados:

• hello.pb.go — estruturas das mensagens
• hello_grpc.pb.go — interfaces do servidor e cliente

Implementação do servidor gRPC em Go

Crie o arquivo 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)    }}

Implementação do cliente gRPC em Go

Crie o arquivo client.go:

package main

import (    "context"    "log"    "time"

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