Introdução

No mundo dos microsserviços e sistemas distribuídos, a comunicação eficiente entre serviços é crucial. É aqui que entra em ação o gRPC, uma estrutura RPC (Remote Procedure Call) de alto desempenho desenvolvida pelo Google. Combinado com Go, uma linguagem de programação compilada e digitada estaticamente, projetada para simplicidade e eficiência, o gRPC pode ajudá-lo a construir serviços da web robustos e escaláveis.

O que é gRPC?

gRPC significa google Remote Procedure Call. É uma estrutura de código aberto que usa HTTP/2 para transporte, buffers de protocolo como linguagem de descrição de interface e fornece recursos como autenticação, balanceamento de carga e muito mais. O gRPC permite que você defina seus métodos de serviço e tipos de mensagens em um arquivo .proto, que pode então ser usado para gerar código de cliente e servidor em vários idiomas.

Por que usar gRPC com Go?

1. Desempenho: gRPC usa HTTP/2, que permite multiplexar várias solicitações em uma única conexão, reduzindo a latência e melhorando o desempenho.
2. Geração de código: Com buffers de protocolo, você pode definir seu serviço uma vez e gerar código de cliente e servidor em Go, garantindo consistência e reduzindo código clichê.
3. Streaming: gRPC suporta streaming do lado do cliente, do lado do servidor e bidirecional, tornando-o ideal para aplicativos em tempo real.
4. Interoperabilidade: os serviços gRPC podem ser consumidos por clientes escritos em diferentes idiomas, tornando-os uma escolha versátil para ambientes poliglotas.

Primeiros passos com gRPC em Go

• ### Pré-requisitos

  Antes de começar, certifique-se de ter o seguinte instalado:

  • Go (qualquer um dos dois últimos lançamentos importantes)
  • Compilador de buffer de protocolo (protoc)
  • Plug-ins Go para o compilador de buffer de protocolo

  Você pode instalar os plug-ins Go usando os seguintes comandos:
  

  go install google.golang.org/protobuf/cmd/protoc-gen-go@latest
  go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest
  

  Atualize seu PATH para que o compilador protoc possa encontrar os plugins:
  

  export PATH="$PATH:$(go env GOPATH)/bin"
  

  Confirme se o protoc está instalado e configurado em seu sistema abrindo um terminal e digitando:
  

  protoc --version
  

  Você deverá ver uma saída semelhante a esta
  

  C:\Users\Guest>protoc --version
  ~ libprotoc 27.3
  

  Se ele não reconhecer o comando protoc, você pode usar o Chocolatey para Windows para instalar os buffers de protocolo:
  

  choco install protoc
  

  Se este não for o caso, onde você não tem o chocolatey instalado ou está em um sistema operacional diferente, você pode consultar a documentação oficial de instalação aqui.

  Definindo o Serviço

  Crie um arquivo .proto para definir seu serviço gRPC. Por exemplo:

  helloworld.proto
  

  syntax = "proto3";
  package helloworld;
  
  message HelloRequest {
      string name = 1;
  }
  message HelloResponse {
      string message = 1;
  }
  
  service Greeter {
      rpc SayHello (HelloRequest) returns (HelloResponse) {}
  }
  

  Gerando Código

  Gere o código Go do seu arquivo .proto:
  

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

  Implementando o Servidor

  Crie um servidor em Go:

  server.go
  

  package main
  
  import (
      "context"
      "log"
      "net"
  
      "google.golang.org/grpc"
      pb "path/to/your/proto"
  )
  
  type server struct {
      pb.GreeterServer
  }
  
  func main() {
      lis, err := net.Listen("tcp", ":8080")
      if err != nil {
          log.Fatalf("failed to listen: %v", err)
      }
  
      log.Printf("Server started at %v", lis.Addr())
  
      grpcServer := grpc.NewServer()
      pb.RegisterGreeterServer(grpcServer, &server{})
      if err := grpcServer.Serve(lis); err != nil {
          log.Fatalf("failed to serve: %v", err)
      }
  }
  
  // SayHello name should be the same RPC name as defined in your proto file
  func (s *server) SayHello(ctx context.Context, in *pb.HelloRequest) (*pb.HelloResponse, error) {
      return &pb.HelloResponse{Message: "Hello "   in.Name}, nil
  }
  

  Criando o Cliente

  Criar um cliente no Go:

  client.go
  

  package main
  
  import (
      "context"
      "log"
      "os"
      "time"
  
      "google.golang.org/grpc"
      pb "path/to/your/proto"
  )
  
  func main() {
      conn, err := grpc.NewClient("localhost:8080", grpc.WithTransportCredentials(insecure.NewCredentials()))
      if err != nil {
          log.Fatalf("did not connect: %v", err)
      }
      defer conn.Close()
      client := pb.NewGreeterClient(conn)
  
      name := "John Doe"
      if len(os.Args) > 1 {
          name = os.Args[1]
      }
  
      callSayHello( client, name )
  }
  
  func callSayHello(client pb.GrpcServiceClient, name string) {
      ctx, cancel := context.WithTimeout(context.Background(), time.Second)
      defer cancel()
  
      res, err := client.SayHello(ctx, &pb.HelloRequest{Name: name})
      if err != nil {
          log.Fatalf("Failed to called: %v", err)
      }
      log.Printf("%v", res)
  }
  

Conclusão

gRPC e Go juntos fornecem uma combinação poderosa para a construção de serviços da Web escalonáveis ​​e de alto desempenho. Ao aproveitar os pontos fortes de ambos, você pode criar aplicativos eficientes e confiáveis ​​que são fáceis de manter e estender.

Link para repositório de demonstração: Github.com