Cara melaksanakan antara muka RPC menggunakan Go

Dalam beberapa tahun kebelakangan ini, dengan perkembangan pesat teknologi Internet dan peningkatan pengkomputeran awan, panggilan prosedur jauh (RPC) telah menarik lebih banyak perhatian daripada pembangun. Bahasa Go itu sendiri adalah ringan dan dengan sokongan perpustakaan dan rangka kerja yang kaya, perkhidmatan RPC boleh dilaksanakan dengan mudah. Dalam artikel ini, kami akan memperkenalkan cara melaksanakan antara muka RPC menggunakan Go.

1. Gambaran Keseluruhan RPC

RPC (Remote Procedure Call) ialah protokol yang membolehkan proses atau komputer yang berbeza berkomunikasi antara satu sama lain untuk memanggil proses atau komputer lain mesin. Prinsip asas RPC adalah untuk merangkum panggilan fungsi atau kaedah ke dalam proses komunikasi rangkaian, supaya pengguna (pemanggil) boleh memanggil perkhidmatan pada mesin jauh seperti panggilan tempatan.

Pada masa ini, rangka kerja RPC biasa termasuk gRPC, Thrift, Dubbo, dsb. Antaranya, gRPC ialah rangka kerja RPC berprestasi tinggi berdasarkan HTTP/2 sumber terbuka oleh Google dan menyokong berbilang bahasa pengaturcaraan, termasuk C++, Java, Python, Go, dll. gRPC menggunakan Protocol Buffers sebagai protokol bersiri, yang boleh digunakan untuk membina aplikasi teragih berprestasi tinggi dan berskala seperti sistem teragih dan perkhidmatan mikro.

2. Gunakan Go untuk melaksanakan antara muka RPC

1. Pasang dan muat turun kebergantungan

Sebelum menggunakan Go untuk melaksanakan antara muka RPC, kita perlu memasang Pergi dahulu Persekitaran pembangunan dan sokongan rangka kerja RPC. Di sini kami memilih untuk menggunakan rangka kerja gRPC.

Pertama, kita perlu memasang pemalam bahasa gRPC Go dan alat protobuf:

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

Selepas pemasangan selesai, kita boleh menggunakan protobuf2.0 atau lebih tinggi untuk menulis fail .proto untuk menerangkan perkhidmatan dan struktur mesej. Sebagai contoh, kami menulis fail .proto yang mudah:

syntax = "proto3";

package helloworld;

// 定义 HelloService
service HelloService {
  // 定义 SayHello 方法
  rpc SayHello (HelloRequest) returns (HelloResponse) {}
}

// 定义入参结构体: HelloRequest
message HelloRequest {
  string name = 1;
}

// 定义出参结构体: HelloResponse
message HelloResponse {
  string message = 1;
}

2. Jana kod

Kami boleh menggunakan arahan berikut untuk menjana kod Go berdasarkan fail .proto:

$ protoc --go_out=plugins=grpc:. *.proto

Selepas melaksanakan arahan di atas, kita boleh mendapatkan fail kod Go yang sepadan, sebagai contoh:

syntax = "proto3";

package helloworld;

// 定义 HelloService
service HelloService {
  // 定义 SayHello 方法
  rpc SayHello (HelloRequest) returns (HelloResponse) {}
}

// 定义入参结构体: HelloRequest
message HelloRequest {
  string name = 1;
}

// 定义出参结构体: HelloResponse
message HelloResponse {
  string message = 1;
}

3. Melaksanakan pelayan

Seterusnya, kita perlu untuk melaksanakan akhir perkhidmatan. Pertama, kita perlu mentakrifkan struktur HelloServiceImpl untuk melaksanakan antara muka HelloService di atas:

package main

import (
  "context"
  pb "github.com/user/helloworld"
)

type HelloServiceImpl struct {
}

func (s *HelloServiceImpl) SayHello(ctx context.Context, req *pb.HelloRequest) (*pb.HelloResponse, error) {
  return &pb.HelloResponse{Message: "Hello, " + req.Name + "!"}, nil
}

Dalam kod di atas, kami mentakrifkan struktur HelloServiceImpl dan melaksanakan kaedah SayHello dalam antara muka HelloService. Kaedah ini menerima objek konteks dan objek HelloRequest sebagai parameter, dan mengembalikan objek HelloResponse sebagai hasilnya. Antaranya, ctx ialah objek konteks yang digunakan untuk mengawal proses permintaan. req ialah objek HelloRequest, yang mengandungi parameter permintaan apabila memanggil kaedah SayHello.

Seterusnya, kita perlu mencipta pelayan gRPC dan mendaftarkan objek HelloServiceImpl ke pelayan:

package main

import (
  "log"
  "net"
  pb "github.com/user/helloworld"
  "google.golang.org/grpc"
)

func main() {
  listenPort, err := net.Listen("tcp", ":4300")
  if err != nil {
    log.Fatalf("failed to listen: %v", err)
  }

  grpcServer := grpc.NewServer()

  // 注册服务实现
  pb.RegisterHelloServiceServer(grpcServer, &HelloServiceImpl{})

  // 启动服务
  if err := grpcServer.Serve(listenPort); err != nil {
    log.Fatalf("failed to serve: %v", err)
  }
}

Dalam kod di atas, kita mula-mula mentakrifkan port mendengar dan kemudian mencipta pelayan gRPC Dan mendaftar objek HelloServiceImpl ke pelayan. Akhir sekali, kami memulakan perkhidmatan gRPC dan mendengar permintaan HTTP2.

4. Melaksanakan klien

Sekarang kami telah melaksanakan pelayan gRPC, seterusnya kami perlu melaksanakan klien gRPC. Dalam Go, kami boleh mengakses pelayan gRPC dengan menghubungi kaedah klien yang sepadan. Sebagai contoh, kami boleh mencipta fail klien bernama utama dan melaksanakan kod berikut:

package main

import (
  "context"
  "log"
  "os"
  "time"

  pb "github.com/user/helloworld"
  "google.golang.org/grpc"
)

func main() {
  // 连接服务器
  conn, err := grpc.Dial(":4300", grpc.WithInsecure(), grpc.WithTimeout(5*time.Second))
  if err != nil {
    log.Fatalf("Failed to connect: %v", err)
  }
  defer conn.Close()

  // 创建客户端
  c := pb.NewHelloServiceClient(conn)

  // 组装请求参数
  name := "go grpc"
  req := &pb.HelloRequest{Name: name}

  // 调用 SayHello 方法
  resp, err := c.SayHello(context.Background(), req)
  if err != nil {
    log.Fatalf("[ERROR] SayHello err: %v
", err)
    os.Exit(1)
  }
  log.Printf("[INFO] SayHello resp: %s
", resp.Message)
}

Dalam kod di atas, kami mula-mula membuat sambungan gRPC dan menyambung ke pelayan, kemudian mencipta objek HelloServiceClient dan permintaan Assemble parameter. Akhir sekali, kami memanggil kaedah SayHello dan mengeluarkan respons. Selepas kod di atas dilaksanakan, kita boleh melihat output:

INFO: SayHello resp: "Hello, go grpc!"

5. Jalankan perkhidmatan

Akhir sekali, kita perlu menyusun kod pelayan dan klien, dan kemudian Mulakan perkhidmatan tersebut. Anda boleh mengikuti langkah di bawah:

$ cd $GOPATH/src/github.com/user/helloworld
$ go run serve/main.go  // 启动gRPC服务端
$ go run client/main.go  // 启动gRPC客户端

Jika semuanya berjalan lancar, kita boleh melihat output klien: "Hello, go grpc!".

3. Ringkasan

Dalam artikel ini, kami memperkenalkan cara menggunakan Go untuk melaksanakan antara muka RPC Antaranya, kami menggunakan rangka kerja gRPC klasik dan melaksanakan contoh Hello World yang mudah. Perlu dinyatakan bahawa sebagai tambahan kepada gRPC, Go juga mempunyai banyak rangka kerja RPC lain, termasuk Thrift, Dubbo dan JSON-RPC, dsb., dan pembangun boleh memilih secara fleksibel mengikut keperluan sebenar.

Apabila menggunakan rangka kerja RPC, kita perlu memilih protokol bersiri dan protokol penghantaran yang sesuai berdasarkan keperluan sebenar. Biasanya, kami mengesyorkan menggunakan Protocol Buffers dan protokol HTTP/2 untuk melaksanakan panggilan RPC yang cekap bagi memenuhi keperluan sistem teragih berskala besar.

Atas ialah kandungan terperinci Cara melaksanakan antara muka RPC menggunakan Go. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!