Einführung

In der Welt der Microservices und verteilten Systeme ist eine effiziente Kommunikation zwischen Diensten von entscheidender Bedeutung. Hier kommt gRPC ins Spiel, ein von Google entwickeltes leistungsstarkes RPC-Framework (Remote Procedure Call). In Kombination mit Go, einer statisch typisierten, kompilierten Programmiersprache, die auf Einfachheit und Effizienz ausgelegt ist, kann gRPC Ihnen beim Aufbau robuster und skalierbarer Webdienste helfen.

Was ist gRPC?

gRPC steht für google Remote Procedure Call. Es handelt sich um ein Open-Source-Framework, das HTTP/2 für den Transport und Protokollpuffer als Schnittstellenbeschreibungssprache verwendet und Funktionen wie Authentifizierung, Lastausgleich und mehr bereitstellt. Mit gRPC können Sie Ihre Dienstmethoden und Nachrichtentypen in einer .proto-Datei definieren, die dann zum Generieren von Client- und Servercode in mehreren Sprachen verwendet werden kann.

Warum gRPC mit Go verwenden?

1. Leistung: gRPC verwendet HTTP/2, was das Multiplexen mehrerer Anfragen über eine einzige Verbindung ermöglicht, wodurch die Latenz reduziert und die Leistung verbessert wird.
2. Codegenerierung: Mit Protocol Buffers können Sie Ihren Dienst einmal definieren und Client- und Servercode in Go generieren, um Konsistenz sicherzustellen und Boilerplate-Code zu reduzieren.
3. Streaming: gRPC unterstützt clientseitiges, serverseitiges und bidirektionales Streaming und ist somit ideal für Echtzeitanwendungen.
4. Interoperabilität: gRPC-Dienste können von Clients genutzt werden, die in verschiedenen Sprachen geschrieben sind, was sie zu einer vielseitigen Wahl für mehrsprachige Umgebungen macht.

Erste Schritte mit gRPC in Go

• ### Voraussetzungen

  Bevor Sie beginnen, stellen Sie sicher, dass Folgendes installiert ist:

  • Go (eine der beiden neuesten Hauptversionen)
  • Protokollpuffer-Compiler (Protokoll)
  • Go-Plugins für den Protocol Buffer Compiler

  Sie können die Go-Plugins mit den folgenden Befehlen installieren:
  

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

  Aktualisieren Sie Ihren PATH, damit der Protokoll-Compiler die Plugins finden kann:
  

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

  Bestätigen Sie, dass das Protokoll in Ihrem System installiert und konfiguriert ist, indem Sie ein Terminal öffnen und Folgendes eingeben:
  

  protoc --version
  

  Sie sollten eine Ausgabe ähnlich dieser sehen
  

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

  Wenn der Befehl protoc nicht erkannt wird, können Sie Chocolatey für Windows verwenden, um die Protokollpuffer zu installieren:
  

  choco install protoc
  

  Wenn dies nicht der Fall ist, weil Sie Chocolatey nicht installiert haben oder ein anderes Betriebssystem verwenden, können Sie hier die offizielle Installationsdokumentation durchsehen.

  Definieren des Dienstes

  Erstellen Sie eine .proto-Datei, um Ihren gRPC-Dienst zu definieren. Zum Beispiel:

  helloworld.proto
  

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

  Code generieren

  Generieren Sie den Go-Code aus Ihrer .proto-Datei:
  

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

  Implementierung des Servers

  Erstellen Sie einen Server in 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
  }
  

  Erstellen des Clients

  Erstellen Sie einen Kunden in 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)
  }
  

Abschluss

gRPC und Go bilden zusammen eine leistungsstarke Kombination zum Aufbau leistungsstarker, skalierbarer Webdienste. Indem Sie die Stärken beider nutzen, können Sie effiziente und zuverlässige Anwendungen erstellen, die einfach zu warten und zu erweitern sind.

Link zum Demo-Repo: Github.com