penempatan grpc golang

gRPC ialah rangka kerja RPC (Panggilan Prosedur Jauh) berprestasi tinggi Google, yang menyokong berbilang bahasa, termasuk Golang. Di Golang, kod gRPC sangat mudah untuk ditulis dan digunakan, tetapi mungkin menghadapi beberapa cabaran apabila benar-benar digunakan.

Artikel ini akan memperkenalkan cara menggunakan gRPC di Golang dan mengaturkannya ke pelayan.

1. Pasang gRPC

Di Golang, anda perlu memasang gRPC dan perpustakaan protobuf yang berkaitan. Anda boleh menggunakan arahan berikut untuk memasang perpustakaan gRPC dan protobuf:

$ go get -u google.golang.org/grpc
$ go get -u github.com/golang/protobuf/{proto,protoc-gen-go}

2. Tentukan fail proto

Dalam gRPC, anda perlu menentukan fail proto untuk menerangkan perkara yang anda mahukan perkhidmatan. Sebagai contoh, anda mungkin mahu menentukan perkhidmatan Echo yang menerima mesej dan mengembalikannya kepada pelanggan.

Berikut ialah contoh fail proto untuk perkhidmatan Echo ringkas:

syntax = "proto3";

option go_package = "echo";

service EchoService {
  rpc Echo (EchoMessage) returns (EchoMessage);
}

message EchoMessage {
  string message = 1;
}

Dalam contoh ini, kami mentakrifkan perkhidmatan Echo yang mempunyai jenis mesej EchoMessage, yang mengandungi rentetan aksara mesej , dan kaedah Echo yang menerima mesej EchoMessage dan mengembalikan mesej itu sebagai respons.

3. Jana kod golang

Setelah anda menentukan fail proto, anda boleh menggunakan pengkompil protobuf untuk menjana kod Golang yang sepadan. Untuk menjana kod Golang, anda perlu menjalankan arahan berikut:

$ protoc --go_out=. echo.proto

Ini akan menjana fail bernama echo.pb.go yang mengandungi kod untuk perkhidmatan Echo anda.

4. Melaksanakan perkhidmatan

Seterusnya, anda perlu melaksanakan perkhidmatan Echo anda. Dalam perkhidmatan Echo anda, anda perlu melaksanakan kaedah Echo untuk menerima mesej EchoMessage dan mengembalikan mesej kepada pelanggan.

Berikut ialah contoh pelaksanaan perkhidmatan Echo yang mudah:

type server struct{}

func (s *server) Echo(ctx context.Context, message *EchoMessage) (*EchoMessage, error) {
  return &EchoMessage{
    Message: message.Message,
  }, nil
}

func main() {
  s := grpc.NewServer()
  RegisterEchoServiceServer(s, &server{})
  lis, err := net.Listen("tcp", ":50051")
  if err != nil {
    log.Fatalf("failed to listen: %v", err)
  }
  if err := s.Serve(lis); err != nil {
    log.Fatalf("failed to serve: %v", err)
  }
}

Dalam contoh ini, kami melaksanakan jenis pelayan, yang mengandungi kaedah Echo. Apabila pelanggan memanggil kaedah Echo, ia mengembalikan mesej yang diterima.

Kami juga mencipta pelayan gRPC dalam fungsi utama dan menyerahkan pelaksanaan kami kepada fungsi pendaftaran RegisterEchoServiceServer. Kemudian kita mula mendengar pada port 50051 dan memulakan pelayan.

5. Kompilasi dan gunakan

Selepas melengkapkan pelaksanaan perkhidmatan gRPC, anda perlu menyusun dan menggunakan perkhidmatan tersebut ke pelayan. Anda boleh menggunakan arahan berikut untuk menyusun kod anda:

$ go build .

Ini akan mencipta fail boleh laku yang boleh anda gunakan ke pelayan anda. Pada pelayan anda, anda boleh menjalankan arahan berikut untuk memulakan perkhidmatan gRPC anda:

$ ./your-program

Dalam contoh ini, nama program anda ialah "your-program". Ambil perhatian bahawa sebelum menjalankan program anda, anda perlu memastikan pelayan anda boleh mengakses port 50051.

6. Menguji kod

Selepas penggunaan, anda boleh menggunakan klien gRPC untuk menguji kod anda. Anda boleh memasang klien gRPC menggunakan arahan berikut:

$ go get -u google.golang.org/grpc/cmd/protoc-gen-go-grpc

Untuk menggunakan klien gRPC, anda perlu membuat sambungan dan kemudian menggunakan sambungan itu untuk memanggil perkhidmatan Echo anda.

Berikut ialah contoh klien gRPC yang mudah:

func main() {
  conn, err := grpc.Dial(":50051", grpc.WithInsecure())
  if err != nil {
    log.Fatalf("did not connect: %v", err)
  }
  defer conn.Close()

  c := NewEchoServiceClient(conn)
  message := &EchoMessage{Message: "hello world"}
  res, err := c.Echo(context.Background(), message)
  if err != nil {
    log.Fatalf("echo failed: %v", err)
  }
  log.Printf("echo response: %s", res.Message)
}

Dalam contoh ini, kami membuat sambungan dan kemudian menggunakan sambungan itu untuk menghubungi perkhidmatan Echo kami. Kami menghantar mesej EchoMessage dan kemudian menguji sama ada kod kami berfungsi dengan betul dengan mencetak respons pelayan.

7. Kesimpulan

gRPC ialah rangka kerja RPC yang cekap Sangat mudah untuk menggunakannya di Golang, tetapi anda mungkin menghadapi beberapa cabaran semasa proses penggunaan sebenar. Artikel ini menerangkan cara memasang gRPC dan perpustakaan protobuf yang berkaitan, cara mentakrif fail proto dan cara menjana kod Golang. Kami juga menunjukkan cara untuk melaksanakan perkhidmatan Echo dan cara untuk menggunakan perkhidmatan itu pada pelayan. Akhir sekali, kami juga menunjukkan cara menggunakan klien gRPC untuk menguji kod.

Atas ialah kandungan terperinci penempatan grpc golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!