Introducción

En el mundo de los microservicios y los sistemas distribuidos, la comunicación eficiente entre servicios es crucial. Aquí es donde entra en juego gRPC, un marco RPC (llamada a procedimiento remoto) de alto rendimiento desarrollado por Google. Combinado con Go, un lenguaje de programación compilado y tipado estáticamente diseñado para brindar simplicidad y eficiencia, gRPC puede ayudarlo a crear servicios web sólidos y escalables.

¿Qué es gRPC?

gRPC significa google Remoticón Pprocedimiento Call. Es un marco de código abierto que utiliza HTTP/2 para el transporte, Protocol Buffers como lenguaje de descripción de la interfaz y proporciona funciones como autenticación, equilibrio de carga y más. gRPC le permite definir sus métodos de servicio y tipos de mensajes en un archivo .proto, que luego puede usarse para generar código de cliente y servidor en varios idiomas.

¿Por qué utilizar gRPC con Go?

1. Rendimiento: gRPC utiliza HTTP/2, lo que permite multiplexar múltiples solicitudes en una sola conexión, lo que reduce la latencia y mejora el rendimiento.
2. Generación de código: con Protocol Buffers, puede definir su servicio una vez y generar código de cliente y servidor en Go, lo que garantiza la coherencia y reduce el código repetitivo.
3. Transmisión: gRPC admite transmisión del lado del cliente, del lado del servidor y bidireccional, lo que lo hace ideal para aplicaciones en tiempo real.
4. Interoperabilidad: los servicios gRPC pueden ser consumidos por clientes escritos en diferentes idiomas, lo que los convierte en una opción versátil para entornos políglotas.

Introducción a gRPC en Go

• ### Requisitos previos

  Antes de comenzar, asegúrese de tener instalado lo siguiente:

  • Ir (cualquiera de los dos últimos lanzamientos principales)
  • Compilador de búfer de protocolo (protocolo)
  • Ir a complementos para el Compilador de búfer de protocolo

  Puedes instalar los complementos de Go usando los siguientes comandos:
  

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

  Actualiza tu RUTA para que el compilador de protocolos pueda encontrar los complementos:
  

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

  Confirme que el protocolo esté instalado y configurado en su sistema abriendo una terminal y escribiendo:
  

  protoc --version
  

  Deberías ver un resultado similar a este
  

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

  Si no reconoce el comando protoc, entonces puedes usar Chocolatey para Windows para instalar los buffers de protocolo:
  

  choco install protoc
  

  Si este no es el caso, si no tienes chocolatey instalado o estás en un sistema operativo diferente, puedes consultar la documentación de instalación oficial aquí.

  Definición del servicio

  Cree un archivo .proto para definir su servicio gRPC. Por ejemplo:

  holamundo.proto
  

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

  Generando código

  Genere el código Go desde su archivo .proto:
  

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

  Implementando el servidor

  Crear un servidor en Go:

  servidor.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
  }
  

  Creando el cliente

  Crear un cliente en Go:

  cliente.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)
  }
  

Conclusión

gRPC y Go juntos proporcionan una poderosa combinación para crear servicios web escalables y de alto rendimiento. Al aprovechar las fortalezas de ambos, puede crear aplicaciones eficientes y confiables que sean fáciles de mantener y ampliar.

Enlace al repositorio de demostración: Github.com