When it comes to microservices, there’re a lot of things worth keeping in mind. Designing such fine-grained, loosely-coupled services requires paying lots of attention to various patterns and approaches to make them future-proof. A very important thing to consider, is the way those services will communicate with each-other in production. Usually the communication is done over the network using a technology-agnostic protocol. At the next level the service should provide an API for its friend services. Then, the data should be serialized without altering its meaning and transferred to the picked endpoint. Nowadays, exposing a REST API that operates with JSON over plain HTTP is a usual way to lay the grounds of communication for the services. It is easy to accomplish, but it has some drawbacks. First of all, JSON is a human readable format, and it’s not as other serialization approaches. Also, with JSON it’s not possible to natively enforce the schema, and evolving the API may be painful. This talk’s purpose is to describe in deep detail the benefits of protocol buffers, that offer us for free an easy way to define the API messages in the proto format, and then reuse them inside different services, without even being locked to use the same programming language for them. Moreover, with gRPC we can define the API’s endpoints easily in the same proto format. All these offer us a robust schema enforcement, compact binary serialization, and easy backward compatibility.

1. Teach your (micro)services speak
Protocol Buffers with gRPC.
Mihai Iachimovschi
@mishunika
mihai.iachimovschi@gmail.com

2. What’s inside?

3. What’s inside?
–Message serialization and deserialization

4. What’s inside?
–Message serialization and deserialization
–Message transport

5. What’s inside?
–Message serialization and deserialization
–Message transport
–Services diversity

6. How it works in real life
A
B
C
D

7. How it works in real life
A
B
C
D

8. In a nutshell
Client Service

9. In a nutshell
–Over HTTP
–Serialized to JSON
Client Service

10. In a nutshell
–Over HTTP
–Serialized to JSON
Client Service
–Proprietary protocol
–Remote objects

11. JSON advantages

12. JSON advantages
–Human readable

13. JSON advantages
–Human readable
–Schema-less

14. JSON advantages
–Human readable
–Schema-less
–Language agnostic

15. JSON disadvantages

16. JSON disadvantages
–Human readable

17. JSON disadvantages
–Human readable Isn’t it a benefit?

18. JSON disadvantages
–Human readable
–Schema-less
Isn’t it a benefit?

19. JSON disadvantages
–Human readable
–Schema-less
Isn’t it a benefit?
Isn’t it a benefit as well?

20. JSON disadvantages
–Human readable
–Schema-less
–Type-less
Isn’t it a benefit?
Isn’t it a benefit as well?

21. Protocol Buffers?
“Protocol buffers are Google's language-neutral,
platform-neutral, extensible mechanism for serializing
structured data – think XML, but smaller, faster, and
simpler.”
— https://developers.google.com/protocol-buffers/

22. Protocol Buffers?
“Protocol buffers are Google's language-neutral,
platform-neutral, extensible mechanism for serializing
structured data – think XML, but smaller, faster, and
simpler.”
— https://developers.google.com/protocol-buffers/

23. Protocol Buffers?
“Protocol buffers are Google's language-neutral,
platform-neutral, extensible mechanism for serializing
structured data – think XML, but smaller, faster, and
simpler.”
— https://developers.google.com/protocol-buffers/
JSON

24. Protocol Buffers example
message Person {
string name = 1;
int32 id = 2;
repeated string aliases = 3;
}

25. Protocol Buffers example
message Person {
string name = 1;
int32 id = 2;
repeated string aliases = 3;
}

26. Protocol Buffers example
message Person {
string name = 1;
int32 id = 2;
repeated string aliases = 3;
}

27. Protocol Buffers example
message Person {
string name = 1;
int32 id = 2;
repeated string aliases = 3;
}

28. Protocol Buffers example
message Person {
string name = 1;
int32 id = 2;
repeated string aliases = 3;
}

29. Protocol Buffers example
message Person {
string name = 1;
int32 id = 2;
repeated string aliases = 3;
}

30. Protocol Buffers example
message Person {
reserved 1, 2, 5;
reserved "name";
int32 id = 3;
repeated string aliases = 4;
}

31. Why protocol buffers
Binary format

32. Why protocol buffers
Enforcing the schema

33. Why protocol buffers
Language neutral

34. Out-of the box backward compatibility
Why protocol buffers

35. Out-of the box backward compatibility
Why protocol buffers

36. Out-of the box backward compatibility
if version == 3:
...
elif version > 4:
if (version == 5):
...
...
Why protocol buffers

37. Why protocol buffers
Generally faster

38. How to…
message Person {
string name = 1;
int32 id = 2;
repeated string aliases = 3;
}

39. How to…
message Person {
string name = 1;
int32 id = 2;
repeated string aliases = 3;
}
Proto message definition

40. How to…
message Person {
string name = 1;
int32 id = 2;
repeated string aliases = 3;
}
Person john = Person.newBuilder()
.setId(1234)
.setName("John Doe")
.addAliases("ionel")
.build();
Proto message definition

41. How to…
message Person {
string name = 1;
int32 id = 2;
repeated string aliases = 3;
}
Person john = Person.newBuilder()
.setId(1234)
.setName("John Doe")
.addAliases("ionel")
.build();
Proto message definition
Object creation

42. How to…
message Person {
string name = 1;
int32 id = 2;
repeated string aliases = 3;
}
john = Person()
john.id = 1234
john.name = 'John Doe'
john.aliases.add(‘ionel’)
Proto message definition
Object creation

43. How to…
message Person {
string name = 1;
int32 id = 2;
repeated string aliases = 3;
}
john = Person(id=1234,
name='John Doe',
aliases=['ionel'])
Proto message definition
Object creation

44. Communication (REST-ish)
1. URI: https://api.example.com/person/42
2. Make an HTTP GET Request
3. Receive a plaintext JSON
4. Parse it
5. …

45. Request
GET /person/42 HTTP/1.1
Accept: */*
Accept-Encoding: gzip, deflate
Connection: keep-alive
Host: api.example.com
...

46. Response headers
HTTP/1.1 200 OK
Access-Control-Allow-Credentials: true
Cache-Control: public, max-age=14400
Content-Encoding: gzip
Content-Type: application/json;
charset=utf-8
...

47. Response body
{
"name": "John Doe",
"id": 42,
"aliases": [
"ionel",
"honzík"
]
}

48. HTTP2
https://www.youtube.com/watch?v=DtTKF5OcpsU

49. Distributed objects
https://en.wikipedia.org/wiki/Distributed_object

50. Distributed objects
“First Law of Distributed Object Design:
don't distribute your objects”.
— Martin Fowler
https://martinfowler.com/articles/distributed-objects-microservices.html

51. The 8 Fallacies of distributed computing
1. The network is reliable.
2. Latency is zero.
3. Bandwidth is infinite.
4. The network is secure.
5. Topology doesn't change.
6. There is one administrator.
7. Transport cost is zero.
8. The network is homogeneous.
http://www.rgoarchitects.com/Files/fallacies.pdf

52. Keep in mind…
“Anything that can go wrong will go wrong.”
—Murphy’s Law

53. So, what’s next?

54. Services not Objects, Messages not References
http://www.grpc.io/blog/principles

55. Coverage & Simplicity
http://www.grpc.io/blog/principles

56. How does it work

57. Service definition
service RoutePlanner {
rpc GetRoutes (GetRoutesRequest)
returns (GetRoutesResponse) {}
}

58. Service definition
service RoutePlanner {
rpc GetRoutes (GetRoutesRequest)
returns (GetRoutesResponse) {}
}

59. Service definition
service RoutePlanner {
rpc GetRoutes (GetRoutesRequest)
returns (GetRoutesResponse) {}
}

60. Service definition
service RoutePlanner {
rpc GetRoutes (GetRoutesRequest)
returns (GetRoutesResponse) {}
}

61. Service definition
service RoutePlanner {
rpc GetRoutes (GetRoutesRequest)
returns (GetRoutesResponse) {}
}

62. Service definition
service RoutePlanner {
rpc GetRoutes (GetRoutesRequest)
returns (GetRoutesResponse) {}
}

63. Service definition
message GetRoutesRequest {
Location origin = 1;
Location destination = 2;
}
message GetRoutesResponse {
repeated Route routes = 1;
}

64. Generate server code
$ python -m grpc_tools.protoc
--proto_path=../protos
--python_out=.
--grpc_python_out=.
../protos/route_planner.proto

65. Generate server code
$ python -m grpc_tools.protoc
--proto_path=../protos
--python_out=.
--grpc_python_out=.
../protos/route_planner.proto

66. Generate server code
$ python -m grpc_tools.protoc
--proto_path=../protos
--python_out=.
--grpc_python_out=.
../protos/route_planner.proto

67. Generate server code
$ python -m grpc_tools.protoc
--proto_path=../protos
--python_out=.
--grpc_python_out=.
../protos/route_planner.proto

68. Generate server code
$ python -m grpc_tools.protoc
--proto_path=../protos
--python_out=.
--grpc_python_out=.
../protos/route_planner.proto

69. Generate server code
$ python -m grpc_tools.protoc
--proto_path=../protos
--python_out=.
--grpc_python_out=.
../protos/route_planner.proto

70. Generate server code
$ python -m grpc_tools.protoc
--proto_path=../protos
--python_out=.
--grpc_python_out=.
../protos/route_planner.proto

71. Generated code
$ tree
.
├── route_planner_pb2.py
└── route_planner_pb2_grpc.py
0 directories, 2 files

72. Implementing the service

73. Implementing the service

74. Service code
class Servicer(route_planner_pb2_grpc.RoutePlannerServicer):
"""Service implementation."""
def GetRoutes(self, request, context):
return process_magically_the_request(request)

75. Service code
server = grpc.server(
futures.ThreadPoolExecutor(max_workers=10))
route_planner_pb2_grpc.add_RoutePlannerServicer_to_server(
Servicer(), server)
server.add_insecure_port('[::]:12345')
server.start()

76. Service code
server = grpc.server(
futures.ThreadPoolExecutor(max_workers=10))
route_planner_pb2_grpc.add_RoutePlannerServicer_to_server(
Servicer(), server)
server.add_insecure_port('[::]:12345')
server.start()

77. Service code
server = grpc.server(
futures.ThreadPoolExecutor(max_workers=10))
route_planner_pb2_grpc.add_RoutePlannerServicer_to_server(
Servicer(), server)
server.add_insecure_port('[::]:12345')
server.start()

78. Service code
server = grpc.server(
futures.ThreadPoolExecutor(max_workers=10))
route_planner_pb2_grpc.add_RoutePlannerServicer_to_server(
Servicer(), server)
server.add_insecure_port('[::]:12345')
server.start()

79. Service code
server = grpc.server(
futures.ThreadPoolExecutor(max_workers=10))
route_planner_pb2_grpc.add_RoutePlannerServicer_to_server(
Servicer(), server)
server.add_insecure_port('[::]:12345')
server.start()

80. Implementing the client

81. Implementing the client

82. Client code
channel = grpc.insecure_channel(‘localhost:12345')
stub = route_planner_pb2_grpc.RoutePlannerStub(channel)
request = route_planner_pb2.GetRoutesRequest(
origin=CURRENT_LOCATION,
destination=DESTINATION_COORDS)
response = stub.GetRoutes(request)

83. Client code
channel = grpc.insecure_channel(‘localhost:12345')
stub = route_planner_pb2_grpc.RoutePlannerStub(channel)
request = route_planner_pb2.GetRoutesRequest(
origin=CURRENT_LOCATION,
destination=DESTINATION_COORDS)
response = stub.GetRoutes(request)

84. Client code
channel = grpc.insecure_channel(‘localhost:12345')
stub = route_planner_pb2_grpc.RoutePlannerStub(channel)
request = route_planner_pb2.GetRoutesRequest(
origin=CURRENT_LOCATION,
destination=DESTINATION_COORDS)
response = stub.GetRoutes(request)

85. Client code
channel = grpc.insecure_channel(‘localhost:12345')
stub = route_planner_pb2_grpc.RoutePlannerStub(channel)
request = route_planner_pb2.GetRoutesRequest(
origin=CURRENT_LOCATION,
destination=DESTINATION_COORDS)
response = stub.GetRoutes(request)

86. Client code
channel = grpc.insecure_channel(‘localhost:12345')
stub = route_planner_pb2_grpc.RoutePlannerStub(channel)
request = route_planner_pb2.GetRoutesRequest(
origin=CURRENT_LOCATION,
destination=DESTINATION_COORDS)
response = stub.GetRoutes(request)

87. Client code
channel = grpc.insecure_channel(‘localhost:12345')
stub = route_planner_pb2_grpc.RoutePlannerStub(channel)
request = route_planner_pb2.GetRoutesRequest(
origin=CURRENT_LOCATION,
destination=DESTINATION_COORDS)
response = stub.GetRoutes(request)

88. Client code (async)
response_future = stub.GetRoutes.future(request)
response_future.result()

89. grpc_cli
$ grpc_cli call localhost:12345
RoutePlanner.GetRoutes
<<- PROTO
origin: <long: 0.0 lat: 0.0>
destination: <long: 1.1 lat: 1.1>
PROTO

90. grpc_cli
$ grpc_cli call localhost:12345
RoutePlanner.GetRoutes
<<- PROTO
origin: <long: 0.0 lat: 0.0>
destination: <long: 1.1 lat: 1.1>
PROTO

91. grpc_cli
$ grpc_cli call localhost:12345
RoutePlanner.GetRoutes
<<- PROTO
origin: <long: 0.0 lat: 0.0>
destination: <long: 1.1 lat: 1.1>
PROTO

92. grpc_cli
$ grpc_cli call localhost:12345
RoutePlanner.GetRoutes
<<- PROTO
origin: <long: 0.0 lat: 0.0>
destination: <long: 1.1 lat: 1.1>
PROTO

93. grpc_cli
$ grpc_cli call localhost:12345
RoutePlanner.GetRoutes
<<- PROTO
origin: <long: 0.0 lat: 0.0>
destination: <long: 1.1 lat: 1.1>
PROTO

94. grpc_cli
Rpc succeeded with OK status
Response:
routes: <...>
routes: <...>
routes: <...>
routes: <...>

95. Service definition
service RoutePlanner {
rpc GetRoutes (GetRoutesRequest)
returns (GetRoutesResponse) {}
}

96. Service definition - response streaming
service RoutePlanner {
rpc GetRoutes (GetRoutesRequest)
returns (stream GetRoutesResponse) {}
}

97. Service definition
service RoutePlanner {
rpc GetRoutes (GetRoutesRequest)
returns (GetRoutesResponse) {}
}

98. Service definition - request streaming
service RoutePlanner {
rpc GetRoutes (stream GetRoutesRequest)
returns (GetRoutesResponse) {}
}

99. Request streaming? Response streaming?

100. Request streaming? Response streaming?

101. Service definition - bidirectional streaming
service RoutePlanner {
rpc GetRoutes (stream GetRoutesRequest)
returns (stream GetRoutesResponse) {}
}

102. Keep in mind…
Things will go wrong

103. Timeouts
Client Service B
A
C
D
E
? ms ? ms
? ms
? ms
? ms
? ms

104. Uniform timeout
Client Service A B

105. Uniform timeout
Client Service A B
500 ms timeout 500 ms timeout 500 ms timeout

106. Uniform timeout
Client Service A
20 ms
B
500 ms timeout 500 ms timeout 500 ms timeout

107. Uniform timeout
Client Service A
20 ms 30 ms
B
500 ms timeout 500 ms timeout 500 ms timeout

108. Uniform timeout
Client Service A
20 ms 30 ms
B
40 ms
500 ms timeout 500 ms timeout 500 ms timeout

109. Uniform timeout
Client Service A
20 ms 30 ms
B
40 ms
420 ms
500 ms timeout 500 ms timeout 500 ms timeout

110. Uniform timeout
Client Service A
20 ms 30 ms
B
40 ms
420 ms
500 ms timeout 500 ms timeout 500 ms timeout
X

111. Uniform timeout
Client Service A
20 ms 30 ms
B
40 ms
20 ms 420 ms
500 ms timeout 500 ms timeout 500 ms timeout
X X

112. Fine-tuned timeout
Client Service A B

113. Fine-tuned timeout
Client Service A B
300 ms timeout 280 ms timeout 50 ms timeout

114. Fine-tuned timeout
Client Service A
20 ms
B
300 ms timeout 280 ms timeout 50 ms timeout

115. Fine-tuned timeout
Client Service A
20 ms 30 ms
B
300 ms timeout 280 ms timeout 50 ms timeout

116. Fine-tuned timeout
Client Service A
20 ms 30 ms
B
15 ms
300 ms timeout 280 ms timeout 50 ms timeout

117. Fine-tuned timeout
Client Service A
20 ms 30 ms
B
15 ms
40 ms
300 ms timeout 280 ms timeout 50 ms timeout

118. Fine-tuned timeout
Client Service A
20 ms 30 ms
B
15 ms
40 ms
300 ms timeout 280 ms timeout 50 ms timeout
X

119. Adaptive timeout
Client Service A B

120. Adaptive timeout
Client Service A B
200 ms timeout

121. Adaptive timeout
Client Service A
20 ms
B
200 ms timeout

122. Adaptive timeout
Client Service A
20 ms
B
200 ms timeout
200ms - 20ms =
180 ms

123. Adaptive timeout
Client Service A
20 ms 30 ms
B
200 ms timeout
200ms - 20ms =
180 ms

124. Adaptive timeout
Client Service A
20 ms 30 ms
B
200 ms timeout
200ms - 20ms =
180 ms
180ms - 30ms =
150ms

125. Adaptive timeout
Client Service A
20 ms 30 ms
B
15 ms
200 ms timeout
200ms - 20ms =
180 ms
180ms - 30ms =
150ms

126. Adaptive timeout
Client Service A
20 ms 30 ms
B
15 ms
40 ms
200 ms timeout
200ms - 20ms =
180 ms
180ms - 30ms =
150ms

127. Adaptive timeout
Client Service A
20 ms 30 ms
B
15 ms
20 ms 40 ms
200 ms timeout
200ms - 20ms =
180 ms
180ms - 30ms =
150ms

128. Adaptive timeout
Client Service A
20 ms 30 ms
B
15 ms
40 ms 20 ms 40 ms
200 ms timeout
200ms - 20ms =
180 ms
180ms - 30ms =
150ms

129. gRPC: Deadlines

130. gRPC: Deadlines
–Timeout is relative

131. gRPC: Deadlines
–Timeout is relative
–Deadline is absolute

132. Deadline propagation
Client Service A B
Start TS: 3600000
Timeout: 200
Deadline: 3600200

133. Deadline propagation
Client Service A B
Start TS: 3600000
Timeout: 200
Deadline: 3600200
TS: 3600000

134. Deadline propagation
Client Service A
20 ms
B
Start TS: 3600000
Timeout: 200
Deadline: 3600200
TS: 3600000

135. Deadline propagation
Client Service A
20 ms
B
Start TS: 3600000
Timeout: 200
Deadline: 3600200
TS: 3600020TS: 3600000

136. Deadline propagation
Client Service A
20 ms 30 ms
B
Start TS: 3600000
Timeout: 200
Deadline: 3600200
TS: 3600020TS: 3600000

137. Deadline propagation
Client Service A
20 ms 30 ms
B
Start TS: 3600000
Timeout: 200
Deadline: 3600200
TS: 3600020 TS: 3600050TS: 3600000

138. Deadline propagation
Client Service A
20 ms 30 ms
B
15 ms
Start TS: 3600000
Timeout: 200
Deadline: 3600200
TS: 3600020 TS: 3600050TS: 3600000

139. Deadline propagation
Client Service A
20 ms 30 ms
B
15 ms
Start TS: 3600000
Timeout: 200
Deadline: 3600200
TS: 3600020 TS: 3600050 TS: 3600045TS: 3600000

140. Deadline propagation
Client Service A
20 ms 30 ms
B
15 ms
40 ms
Start TS: 3600000
Timeout: 200
Deadline: 3600200
TS: 3600020 TS: 3600050 TS: 3600045TS: 3600000

141. Deadline propagation
Client Service A
20 ms 30 ms
B
15 ms
40 ms
Start TS: 3600000
Timeout: 200
Deadline: 3600200
TS: 3600020 TS: 3600050 TS: 3600045
TS: 3600085
TS: 3600000

142. Deadline propagation
Client Service A
20 ms 30 ms
B
15 ms
20 ms 40 ms
Start TS: 3600000
Timeout: 200
Deadline: 3600200
TS: 3600020 TS: 3600050 TS: 3600045
TS: 3600085
TS: 3600000

143. Deadline propagation
Client Service A
20 ms 30 ms
B
15 ms
20 ms 40 ms
Start TS: 3600000
Timeout: 200
Deadline: 3600200
TS: 3600020 TS: 3600050 TS: 3600045
TS: 3600105 TS: 3600085
TS: 3600000

144. Deadline propagation
Client Service A
20 ms 30 ms
B
15 ms
40 ms 20 ms 40 ms
Start TS: 3600000
Timeout: 200
Deadline: 3600200
TS: 3600020 TS: 3600050 TS: 3600045
TS: 3600105 TS: 3600085
TS: 3600000

145. Deadline propagation
Client Service A
20 ms 30 ms
B
15 ms
40 ms 20 ms 40 ms
Start TS: 3600000
Timeout: 200
Deadline: 3600200
TS: 3600020 TS: 3600050 TS: 3600045
TS: 3600105 TS: 3600085TS: 3600145
TS: 3600000

146. Deadline propagation
Client Service A B
Start TS: 3600000
Timeout: 200
Deadline: 3600200

147. Deadline propagation
Client Service A B
Start TS: 3600000
Timeout: 200
Deadline: 3600200
TS: 3600000

148. Deadline propagation
Client Service A
150ms
B
Start TS: 3600000
Timeout: 200
Deadline: 3600200
TS: 3600000

149. Deadline propagation
Client Service A
150ms
B
Start TS: 3600000
Timeout: 200
Deadline: 3600200
TS: 3600150TS: 3600000

150. Deadline propagation
Client Service A
150ms 100 ms
B
Start TS: 3600000
Timeout: 200
Deadline: 3600200
TS: 3600150TS: 3600000

151. Deadline propagation
Client Service A
150ms 100 ms
B
Start TS: 3600000
Timeout: 200
Deadline: 3600200
TS: 3600150 TS: 3600250TS: 3600000

152. Deadline propagation
Client Service A
150ms 100 ms
B
Start TS: 3600000
Timeout: 200
Deadline: 3600200
TS: 3600150 TS: 3600250TS: 3600000
X

153. Deadline propagation
Client Service A
150ms 100 ms
B
DEADLINE_EXCEEDED
Start TS: 3600000
Timeout: 200
Deadline: 3600200
TS: 3600150 TS: 3600250TS: 3600000
X

154. Deadline propagation
Client Service A
150ms 100 ms
B
DEADLINE_EXCEEDED DEADLINE_EXCEEDED
Start TS: 3600000
Timeout: 200
Deadline: 3600200
TS: 3600150 TS: 3600250TS: 3600000
X

155. Cancellation

156. Cancellation
–Can be initiated by both client/server

157. Cancellation
–Can be initiated by both client/server
–Immediately terminates the RPC

158. Cancellation
–Can be initiated by both client/server
–Immediately terminates the RPC
–It is not a roll-back

159. Cancellation
–Can be initiated by both client/server
–Immediately terminates the RPC
–It is not a roll-back
–Automatically cascaded

160. Backward compatibility
https://github.com/grpc-ecosystem/grpc-gateway

161. gRPC language support
–C++
–Python
–Java
–Go
–Ruby
–C#
–JS (Node)
–Android Java
–Objective-C
–PHP

162. gRPC Platform support
–Linux
–macOS
–Windows
–Android
–iOS

163. Success stories

164. Success stories

165. Benefits

166. Benefits
–Focus on the API design & contract

167. Benefits
–Focus on the API design & contract
–HTTP2 is awesome

168. Benefits
–Focus on the API design & contract
–HTTP2 is awesome
–Bi-directional streaming

169. Benefits
–Focus on the API design & contract
–HTTP2 is awesome
–Bi-directional streaming
–Freedom to pick any language

170. Benefits
–Focus on the API design & contract
–HTTP2 is awesome
–Bi-directional streaming
–Freedom to pick any language
–Service-to-Service and Service-to-Mobile friendly

171. Benefits
–Focus on the API design & contract
–HTTP2 is awesome
–Bi-directional streaming
–Freedom to pick any language
–Service-to-Service and Service-to-Mobile friendly
–Production ready

172. Fin.
Thank you.