gRPC and Go: Membina Perkhidmatan Web Berprestasi Tinggi

pengenalan

Dalam dunia perkhidmatan mikro dan sistem teragih, komunikasi yang cekap antara perkhidmatan adalah penting. Di sinilah gRPC, rangka kerja RPC (Panggilan Prosedur Jauh) berprestasi tinggi yang dibangunkan oleh Google, berperanan. Digabungkan dengan Go, bahasa pengaturcaraan yang disusun secara statik dan direka bentuk untuk kesederhanaan dan kecekapan, gRPC boleh membantu anda membina perkhidmatan web yang mantap dan berskala.

Apakah gRPC?

gRPC bermaksud google Remote Procedure Csemua. Ia ialah rangka kerja sumber terbuka yang menggunakan HTTP/2 untuk pengangkutan, Penampan Protokol sebagai bahasa penerangan antara muka dan menyediakan ciri seperti pengesahan, pengimbangan beban dan banyak lagi. gRPC membolehkan anda menentukan kaedah perkhidmatan dan jenis mesej anda dalam fail .proto, yang kemudiannya boleh digunakan untuk menjana kod klien dan pelayan dalam berbilang bahasa.

Mengapa Menggunakan gRPC dengan Go?

1. Prestasi: gRPC menggunakan HTTP/2, yang membenarkan pemultipleksan berbilang permintaan melalui satu sambungan, mengurangkan kependaman dan meningkatkan prestasi.
2. Penjanaan Kod: Dengan Penampan Protokol, anda boleh menentukan perkhidmatan anda sekali dan menjana kod klien dan pelayan dalam Go, memastikan konsistensi dan mengurangkan kod boilerplate.
3. Penstriman: gRPC menyokong penstriman bahagian klien, bahagian pelayan dan dwiarah, menjadikannya sesuai untuk aplikasi masa nyata.
4. Saling kendali: Perkhidmatan gRPC boleh digunakan oleh pelanggan yang ditulis dalam bahasa berbeza, menjadikannya pilihan serba boleh untuk persekitaran polyglot.

Bermula dengan gRPC dalam Go

• ### Prasyarat

  Sebelum anda bermula, pastikan anda telah memasang yang berikut:

  • Pergi (mana-mana dua keluaran utama terbaharu)
  • Penyusun Penampan Protokol (protokok)
  • Pergi pemalam untuk Pengkompil Penampan Protokol

  Anda boleh memasang pemalam Go menggunakan arahan berikut:
  

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

  Kemas kini PATH anda supaya pengkompil protok boleh mencari pemalam:
  

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

  Sahkan bahawa protok dipasang dan dikonfigurasikan dalam sistem anda dengan membuka terminal dan menaip:
  

  protoc --version
  

  Anda sepatutnya melihat output yang serupa dengan ini
  

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

  Jika ia tidak mengenali arahan protoc, maka anda boleh menggunakan Chocolatey for windows untuk memasang penampan protokol:
  

  choco install protoc
  

  Jika ini tidak berlaku, apabila anda tidak memasang coklat atau anda menggunakan OS lain, anda boleh melalui dokumentasi pemasangan rasmi di sini.

  Mentakrifkan Perkhidmatan

  Buat fail .proto untuk menentukan perkhidmatan gRPC anda. Contohnya:

  helloworld.proto
  

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

  Kod Penjanaan

  Jana kod Go daripada fail .proto anda:
  

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

  Melaksanakan Pelayan

  Buat pelayan dalam 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
  }
  

  Mencipta Pelanggan

  Buat pelanggan dalam Go:

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

Kesimpulan

gRPC dan Go bersama-sama menyediakan gabungan yang hebat untuk membina perkhidmatan web berprestasi tinggi dan berskala. Dengan memanfaatkan kekuatan kedua-duanya, anda boleh mencipta aplikasi yang cekap dan boleh dipercayai yang mudah diselenggara dan dilanjutkan.

Pautan ke repo demo: Github.com

Atas ialah kandungan terperinci gRPC and Go: Membina Perkhidmatan Web Berprestasi Tinggi. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!