Microservices: grpc vs rest

Charla impartida en la TLP Innova 2018: https://tlp-tenerife.com/agenda/evento/grpc-rest/

Transcript

1. MICROSERVICES: Esteban Dorado Software Engineer @Mr_Esti vs
2. Esteban Dorado @Mr_Esti
3. Scenario - A currency service Currency Service Currency Lookup Mobile Android Mobile iOS Backend Processes Desktop Report tool Website Backend Android Java/Kotlin Objective-C Java, Python, Scala C#, Java NodeJS
4. The Problem • Multiple business systems • Bandwidth-constrained access (mobile) • Real-time data access • Different platforms and languages • Need to feature-scale with versioning • Maintain backward compatibility Mobile Android Mobile iOS Backend Processes Desktop Report tool Website Backend Android Java/Kotlin Objective-C Java, Python, Scala C#, Java NodeJS
5. RESTful API non-RESTful API GET /user/69 { “Id” : 123456, “name” : ”Esteban”, . . . } GET /last_user?page=15 { “items” : [ . . . ] . . . }
6. REST • HTTP-JSON-REST APIs/Microservices • Transport: HTTP/1.1 • Wire format: JSON (Text) • Service definition: ◦ REST, Swagger, API BluePrint ◦ JSON Schema
7. Who has heard of gRPC?
8. RPC!! BUT...
9. What is gRPC? • Google open sourced in Feb 2015 • Transport: HTTP/2 • Wire format: Protocol Buffers v3 (Binary) • Service definition: Protocol Buffers IDL • Libraries in ~10 languages (native C, Go, Java) • Microservices framework • Part of Cloud Native Computing Foundation cncf.io • Pre-defined error status codes
10. gRPC Generates idiomatic client stubs and server interfaces in 10 languages:
11. Go uses a native Go driver Java uses a native Java driver Python, Ruby, NodeJS… uses a C driver for gRPC
13. https://github.com/frees-io/freestyle
14. https://github.com/frees-io/freestyle-rpc/tree/master/modules/exa mples
15. Comparative solutions Idiomatic Client/Server Curl Friendly Framework Serialization Efficient Predictable SOAP via Frameworks No By language XML No Somewhat RPC over HTTP/JSON No Yes Custom None No No Custom REST No Yes Custom * No No REST via Frameworks Yes Swagger, others Likely JSON No Somewhat gRPC Yes No Included Binary Yes Yes
16. gRPC is basically Protobuf over HTTP/2
17. REST is basically JSON over HTTP 1.1
18. JSON -> Protobuf HTTP 1.1 -> HTTP/2
19. JSON vs Protobuf Plaintext vs binary Human readable vs machine readable Repetitive vs compressed Fast (de)serialization vs faster (de)serialization* Everything supports it vs limited support
20. HTTP 1.1 vs HTTP/2 Plaintext vs binary No pipelining vs native pipelining New connection per request vs persistent TCP connection Repetitive vs compressed Polling vs streaming Non-secure by default vs TLS by default Everything supports it vs limited support
21. Comparative
22. Benchmark https://grpc.io/docs/guides/benchmarking.html
24. Performance Examples https://performance-dot-grpc-testing.appspot.com/explore?da shboard=5636470266134528
25. Performance Examples https://performance-dot-grpc-testing.appspot.com/explore?da shboard=5636470266134528
26. Performance Examples https://public.tableau.com/profile/sandeep.dinesh#!/vizhome /gRPCvsRest-SameDatacenter/Sheet2 Cheating
27. Performance Examples https://public.tableau.com/profile/sandeep.dinesh#!/vizhome /gRPCGateway-2016/Sheet1
28. HTTP/2 & Protobuf 101
29. HTTP/2 - Binary
30. HTTP/2 - Multiplexed • multiple reqs/resps can be in-flight over one conn • avoid multiple TCP conns to make parallel requests
31. • 'independent, bidirectional sequence of frames exchanged between the client and server within an HTTP/2 connection' • beyond request/response • effectively supersedes 'websockets' HTTP/2 - Streams
32. • 'independent, bidirectional sequence of frames exchanged between the client and server within an HTTP/2 connection' • beyond request/response • effectively supersedes 'websockets' HTTP/2 - Streams
33. Protocol Buffers (a.k.a. protobuf) • Mechanism for serializing structured data • Interface Definition Language (IDL) • Binary, compact, fast • Versioned
34. Protocol Buffers • strongly typed. .proto type -> Go type: ◦ float -> float32 ◦ bool -> bool ◦ string -> string • defaults, enums, nested types, Any, OneOf, maps • proto3 easily transformed to JSON (for debugging!) • https://developers.google.com/protocol-buffers/
35. Where does gRPC fit within the communication stack?
36. Protobuf workflow Protobuf definitions Protoc compiler Python Golang Java gRPC server gRPC client 1 - Define 2 - Compile 3 - Implement Code generated protoc --go_out=plugins=grpc
37. gRPC Features A walkthrough of the many features of gRPC
38. gRPC
39. Microservices Framework
40. Example - Generate Server and Client • Download compiler protoc via Github releases • Install Go implementation of gRPC: • go get -u google.golang.org/grpc • protoc --go_out=plugins=grpc:. service.proto
41. Example - Implement server
42. Example - Implement client
43. gRCP Streaming gRCP supports streaming where client can stream data to server, server to client and bi-directionally
44. Streaming • Large request can be streamed to server • Server can stream large response to client • Strategy to keep client or server from running out of memory • Easy to declare in the IDL • Framework provides API support to use stream
45. IDL Stream
46. Example - Stream server Server sends data elements to client via a stream server.
47. Example - Stream client Client streams data elements from the server until io.EOF.
48. Secure gRCP Service The gRPC framework makes it easy to add secure TLS transport between client and servers.
49. TLS setup - server
50. TLS setup - client
51. Request Timeout Use gRPC request timeouts to prevent client make from waiting an excessively long time for responses
52. Request timeouts Specify timeouts using Go’s Context type
53. Error Handling gRPC Errors are structured and can return valuable information to clients with rich detail.
54. gRPC errors • All errors have an associated numeric status code • Errors can contain complex objects • Wrap your server errors in status.Error() • Server-side anti-pattern: don’t return naked errors
55. gRPC errors - server
56. gRPC errors - client Use status code for smarter error handling
57. gRPC errors - complex values
58. gRPC errors - extract objects
59. Backwards Compatibility Use a reverse proxy JSON API in front of gRPC server
61. Backwards Compatibility • Run a reverse proxy JSON API in front of gRPC server • Generate via github.com/gengo/grpc-gateway
62. Update protos
63. Other features
64. Additional gRPC Features • Extensible middleware API using interceptors and tap handlers • Intercept requests to implement retry/backoff logic • Add tracing using interceptors • Add HTTP stream taps to implement rate limits • Support for pluggable authorization • Add monitoring and metrics using interceptors (e.g. Prometheus)
65. Rate limits options • Using interceptors • Limit numbers of connections for unary and stream calls • Limit numbers of connections for grpc-gateway • Ability to limit message size for both request and response
66. Load balancing options • Proxy (support limited) • Client side? (Custom pool connections) • Lookaside Load Balancing (Custom) • Service mesh ◦ Use built-in LB with Istio, or Envoy https://grpc.io/blog/loadbalancing
67. Architecture - Example
68. Architecture - Example
69. Research & Development
70. Q&A
71. <thank-you> @Mr_Esti