-
Notifications
You must be signed in to change notification settings - Fork 1
/
grpc-intro.slide
164 lines (115 loc) · 6.4 KB
/
grpc-intro.slide
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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
gRPC Intro
Easy microservice RPC over HTTP/2
3 Nov 2015
Tags: grcp
Peter P. Gengler
Sr. Software Engineer, JumpCloud
https://github.com/ppg
https://go-talks.appspot.com/github.com/ppg/grpc-intro/grpc-intro.slide
* What is gRPC?
"general RPC over HTTP/2" - [[http://www.grpc.io/]]
- protobuf messages - DSL for describing messages, efficient binary serialization protocol, multiple language support.
- service - Interface Definition Language (IDL), multiple languages support.
- `*.proto` - write protobuf and service in this file, generate output files (for static languages) or consume directly (in dynamic language).
* Why gRPC?
- Define service in IDL; generate/consume for boiler-plate routing; *but* type-safe with Go still.
- Define message types one time, utilize pre-defined serialization.
- You've probably manually done this for REST services, now just let code generate.
- Break apart functionality into isolated function per service -> microservices.
- Support consistent interface between different languages.
* Getting Started
You'll need some pre-requisites installed:
*protoc:* [[https://github.com/google/protobuf#c-installation---unix]]
- compiles `*.proto` files into output language.
- supports plugin tools; gRPC is one as an example.
*grpc:* go get google.golang.org/grpc
- library for common Go code, like `grpc.Server` and `grpc.ClientConn`.
- works in conjuction with code generated from `protoc`.
* Our example proto file
.code proto/add.proto
- `syntax` calls out we're using proto3 (vs. proto2).
- `package`main` since our code will be generated in top-level directory.
- messages are composed of fields.
- fields are type, name, packing order; *don't*change*packing*order*once*released*.
- `rpc` defines methods to call within service.
* Generated code:
$ protoc --go_out=plugins=grpc:. add.proto
- protoc is the (C-compiled) binary that reads `*.proto` and helps generates output.
- `--go_out` means look for `protoc-gen-go` binary and pass in parsed `.proto` file to it.
- `protoc-gen-go` generates the actual Go code; in this case to `add.pb.proto`.
- `grpc` is a 'plugin' with options; but their loading system isn't extensible.
- However, `protoc`--foo_out=.`add.proto` will run `protoc-gen-foo`.
* Generated code (messages):
.code proto/add.pb.go /type NumericRequest struct/,/}/
.code proto/add.pb.go /type NumericResponse struct/,/}/
- Generates a struct for each message type.
- grpc-go library uses `protobuf` tag with details for serialization/deserialization.
- Makes sure all fields are exported.
* Generated code (service server):
.code proto/add.pb.go /type TestServer interface/,/}/
.code proto/add.pb.go /func RegisterTestServer/,/}/
- Defines the interface that any code implementing this service must meet.
- Defines a function to attach an implementation (`TestServer`) to the gRPC server.
- All calls take a [[https://godoc.org/golang.org/x/net/context][context]] for things like timeout, cancel, etc.
- All calls take the request, and return a response and an error.
- *NOTE:* This is fully type safe, no need to do interface conversions.
* Generated code (service client):
.code proto/add.pb.go /type TestClient interface/,/}/
.code proto/add.pb.go /func NewTestClient/,/[^c]}/
- Defines an interface any client must meet.
- Defines a client that will talk to the generated server.
- All calls take a [[https://godoc.org/golang.org/x/net/context][context]] for things like timeout, cancel, etc.
- All calls take optional `CallOption` to do things like before and after call handlers.
- *NOTE:* This is fully type safe, cannot call with wrong types.
* User Code (Service Implementation):
.code server.go /START SERVICE IMPLEMENTATION OMIT/,/END SERVICE IMPLEMENTATION OMIT/
- `context.Context` used for things like timeout, cancel, etc.
- `req.NumericRequest` and `red.NumericResponse` have type safe field values.
- However, can be zero value so must check that still.
- *NOTE:* protobuf v2 had an optional/required field, but v3 removed for some reason?
* User Code (Insecure Server):
.play server.go /func main/,/^}/
- `RegisterTestServer` is auto-generated and enforces that the service meets the interface described by the proto file.
* User Code (Insecure Client):
.play client.go /func main/,/^}/
- `NewTestClient` returns an interface that is auto-generated and therefore enforces type safety on all the RPC calls.
* User Code (Secure Server):
.play server_tls.go /func main/,/^}/
* User Code (Secure Client):
.play client_tls.go /func main/,/^}/
* User Code (Improved API proto):
.code proto/add_better.proto
- Shows how to use `enum`.
- Shows how to use `repeated`.
* User Code (Improved API Implementation):
.code server_better.go /START SERVICE IMPLEMENTATION OMIT/,/END SERVICE IMPLEMENTATION OMIT/
- Auto-generated code translates `repeated` to an array, `enum` to consts.
* User Code (Improved API Server):
.play server_better.go /func main/,/^}/
* User Code (Improved API Client):
.play client_better.go /func main/,/^}/
* User Code (Secure Server):
.play server_tls.go /func main/,/^}/
* User Code Summary:
- Lots more features: [[https://developers.google.com/protocol-buffers/docs/proto3]]
- [[https://github.com/grpc/grpc-go][grpc-go]] has okay documentation, but remember you generate a code file; try different things, see how they translate into Go code, pick what you like.
* Multi-language Support (Node.js)
*Install:* [[https://github.com/grpc/grpc/tree/master/src/node]]
*Generate:* N/A - dynamically reads `.proto` file.
*Client:*
.code client.js
$ node client.js 1 2
* Multi-language Support (Ruby)
*Install:* `gem`install`grpc`
*Generate:*
$ protoc --ruby_out=lib --grpc_out=lib --plugin=protoc-gen-grpc=`which grpc_ruby_plugin` add.proto
*Client:*
.code client.rb
$ ruby client.rb 1 2
* What Else?
- HTTP/2 has streaming support, gRPC supports natively; can reduce connection overhead; can use like channel communication, but external vs. internal.
- `protoc` is extensible; generate code vs. type unsafe hooks; i.e. [[https://github.com/gengo/grpc-gateway][grpc-gateway]] to provide HTTP RESTful JSON for service.
- Mostly stable, but active; i.e. [[https://github.com/grpc/grpc-java/issues/428][Client-side load balancing]] in the works.
*More*microservice*'things':*
- [[https://github.com/go-kit/kit][go-kit]] - less type-safe, more extensible; can use gRPC; could port concepts into gRPC needs.
- [[https://github.com/myodc/go-micro][go-micro]] - another flexible option, more REST like; again porting options.