gRPC - 概述

1
2
3
4
5
6
7
8
9

// 客户端
conn, _ := grpc.Dial("localhost:50051", grpc.WithInsecure())
// error handling omitted
client := pb.NewGreeterClient(conn)
// 服务端
s := grpc.NewServer()
lis, _ := net.Listen("tcp", "localhost:50051")
// error handling omitted
s.Serve(lis)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

// 客户端
creds, _ := credentials.NewClientTLSFromFile(certFile, "")
conn, _ := grpc.Dial("localhost:50051", grpc.WithTransportCredentials(creds))
// error handling omitted
client := pb.NewGreeterClient(conn)

// 服务端
creds, _ := credentials.NewServerTLSFromFile(certFile, keyFile)
s := grpc.NewServer(grpc.Creds(creds))
lis, _ := net.Listen("tcp", "localhost:50051")
// error handling omitted
s.Serve(lis)

1
2
3

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: user/addressbook.proto
...

1
2
3
4
5
6
7
8

protoc [OPTION] PROTO_FILES

--version 版本信息

-I PATH, --proto_path=PATH: 指定proto源文件(支持多次指定、默认当前路径)
-o FILE: 编译好的二进制文件输出目标
--encode=MESSAGE_TYPE 基于文本消息，写成二进制消息(标准输入和输出)
--decode=MESSAGE_TYPE 基于二进制消息，解码成文本消息(标准输入和输出)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// 基于子目录生成
cd /data/github.com/tkstorm/go-gRPC/api/protobuf/idl/search
protoc --go_out=paths=source_relative:. ./serach_result.proto

// 基于上层目录，编译生成
cd ../search
protoc --go_out=paths=source_relative:. ./search/serach_result.proto

// 任意目录生成
cd data/github.com/tkstorm/go-gRPC
protoc -I=./api/protobuf/idl --gofast_out=./api/protobuf/generate ./api/protobuf/idl/search/serach_result.proto

1
2
3
4
5

message Person {
  string name = 1;
  int32 id = 2;
  bool has_ponycopter = 3;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

// The greeter service definition.
service Greeter {
  // Sends a greeting
  rpc SayHello (HelloRequest) returns (HelloReply) {}
}

// The request message containing the user's name.
message HelloRequest {
  string name = 1;
}

// The response message containing the greetings
message HelloReply {
  string message = 1;
}

1
2

rpc SayHello(HelloRequest) returns (HelloResponse){
}

1
2

rpc LotsOfReplies(HelloRequest) returns (stream HelloResponse){
}

1
2

rpc LotsOfGreetings(stream HelloRequest) returns (HelloResponse) {
}

1
2

rpc BidiHello(stream HelloRequest) returns (stream HelloResponse){
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

syntax = "proto3";

package helloworld;

// The greeting service definition.(服务定义，指定rpc请求和响应类型，以下都是简单RPC请求和响应，还有流式等RPC模式支持)
service Greeter {
    // Sends a greeting
    rpc SayHello (HelloRequest) returns (HelloReply) {
    }

    // Sends another greeting
    rpc SayHelloAgain (HelloRequest) returns (HelloReply) {
    }
}

// The request message containing the user's name.
message HelloRequest {
    string name = 1;
}

// The response message containing the greetings
message HelloReply {
    string message = 1;
}

1

$ protoc -I helloworld/ helloworld/helloworld.proto --go_out=plugins=grpc:helloworld

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

//go:generate protoc -I ../helloworld --go_out=plugins=grpc:../helloworld ../helloworld/helloworld.proto

// Package main implements a server for Greeter service.
package main

import (
    "context"
    "log"
    "net"

    pb "go-grpc/examples/helloworld/helloworld"
    "google.golang.org/grpc"
)

const (
    port = ":50051"
)

// 实现一个GreeterServer服务
type server struct{}

func (s *server) SayHello(ctx context.Context, in *pb.HelloRequest) (*pb.HelloReply, error) {
    log.Printf("Received: %v", in.Name)
    return &pb.HelloReply{Message: "Hello " + in.Name}, nil
}

func (s *server) SayHelloAgain(ctx context.Context, in *pb.HelloRequest) (*pb.HelloReply, error) {
    return &pb.HelloReply{Message: "Hello again " + in.GetName()}, nil
}

func main() {
    // TCP网络监听
    lis, err := net.Listen("tcp", port)
    if err != nil {
        log.Fatalf("failed to listen: %v", err)
    }
    // grpc服务创建
    s := grpc.NewServer()
    // Greeter服务注册
    pb.RegisterGreeterServer(s, &server{})
    // 服务绑定&提供服务，等待gRPC客户端的请求
    if err := s.Serve(lis); err != nil {
        log.Fatalf("failed to serve: %v", err)
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

// Package main implements a client for Greeter service.
package main

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

    "google.golang.org/grpc"
    pb "go-grpc/examples/helloworld/helloworld"
)

const (
    address     = "localhost:50051"
    defaultName = "world"
)

func main() {
    // 初始化一个gRPC通路
    conn, err := grpc.Dial(address, grpc.WithInsecure())
    if err != nil {
        log.Fatalf("did not connect: %v", err)
    }
    defer conn.Close()
    // 初始化一个Greeter客户端
    c := pb.NewGreeterClient(conn)

    // 请求参数
    name := defaultName
    if len(os.Args) > 1 {
        name = os.Args[1]
    }
    // 设定gRPC服务请求的上下设定(超时设定)
    ctx, cancel := context.WithTimeout(context.Background(), time.Second)
    defer cancel()
    // Greeter客户端发起SayHello RPC调用，同步阻塞得到响应
    r, err := c.SayHello(ctx, &pb.HelloRequest{Name: name})
    if err != nil {
        log.Fatalf("could not greet: %v", err)
    }
    // 打印响应内容Message
    log.Printf("Greeting: %s", r.Message)
    // Greeter客户端调用另一个RPC请求调用，串行化的同步阻塞
    r, err = c.SayHelloAgain(ctx, &pb.HelloRequest{Name: name})
    if err != nil {
        log.Fatalf("could not greet: %v", err)
    }
    log.Printf("Greeting: %s", r.GetMessage())
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

// 版本
syntax = "proto3";

// 附加属性
option java_multiple_files = true;
option java_package = "io.grpc.examples.routeguide";
option java_outer_classname = "RouteGuideProto";

package routeguide;

// 路线导航服务接口(4类)
service RouteGuide {
  // 第一类: A simple RPC.
  //
  // 获取给定位置特征描述，如果指定位置没有特征描述，则返回空
  rpc GetFeature(Point) returns (Feature) {}

  // 第二类，服务端流下发：A server-to-client streaming RPC.
  // 
  // 在矩形区域内(可能包含大量特征)，获取可用的特征，结果是流(stream关键字说明)，而非一次返回
  rpc ListFeatures(Rectangle) returns (stream Feature) {}

  // 第三类，客户端流上报：A client-to-server streaming RPC.
  //
  // 服务接受一个位置点的流移动，当形成结束时候返回路径汇总
  rpc RecordRoute(stream Point) returns (RouteSummary) {}

  // 第四类，双向流：A Bidirectional streaming RPC.
  //
  // Accepts a stream of RouteNotes sent while a route is being traversed,
  // while receiving other RouteNotes (e.g. from other users).
  rpc RouteChat(stream RouteNote) returns (stream RouteNote) {}
}

// Points are represented as latitude-longitude pairs in the E7 representation
// (degrees multiplied by 10**7 and rounded to the nearest integer).
// Latitudes should be in the range +/- 90 degrees and longitude should be in
// the range +/- 180 degrees (inclusive).
message Point {
  int32 latitude = 1;
  int32 longitude = 2;
}

// A latitude-longitude rectangle, represented as two diagonally opposite
// points "lo" and "hi".
message Rectangle {
  // One corner of the rectangle.
  Point lo = 1;

  // The other corner of the rectangle.
  Point hi = 2;
}

// A feature names something at a given point.
//
// If a feature could not be named, the name is empty.
message Feature {
  // The name of the feature.
  string name = 1;

  // The point where the feature is detected.
  Point location = 2;
}

// A RouteNote is a message sent while at a given point.
message RouteNote {
  // The location from which the message is sent.
  Point location = 1;

  // The message to be sent.
  string message = 2;
}

// A RouteSummary is received in response to a RecordRoute rpc.
//
// It contains the number of individual points received, the number of
// detected features, and the total distance covered as the cumulative sum of
// the distance between each point.
message RouteSummary {
  // The number of points received.
  int32 point_count = 1;

  // The number of known features passed while traversing the route.
  int32 feature_count = 2;

  // The distance covered in metres.
  int32 distance = 3;

  // The duration of the traversal in seconds.
  int32 elapsed_time = 4;
}