Codemotion Spain Meetup -Microservices: gRPC vs Rest

Construir APIs para microservicios puede ser un reto. Las nuevas tecnologías open source para el stack de APIs son HTTP/2, Profobuf y gRPC. Sin embargo, migrar a estas nuevas tecnologías es un reto, especialmente en el mundo de los microservicios para entender cómo funcionan y qué ganamos con dichas tecnologías. En esta charla mostraré cómo puedes construir APIs gRPC sobre HTTP/2 mientras simultáneamente sirves JSON/REST sobre HTTP/1.1 en el mismo puerto, con los benchmarks de dicha configuración. Además, de los costes que tiene migrar a estas nuevas tecnologías.

Transcript

1. Microservices vs Esteban Dorado Software Engineer @Mr_Esti
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. Who has heard of gRPC?
7. RPC!! BUT...
8. 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 • Secure Connection by default
10. gRPC Generates idiomatic client stubs and server interfaces in 10 languages:
11. Comparative
12. HTTP/2 & Protobuf 101
13. HTTP/2 - Binary 2015 1999
14. HTTP/2 - Multiplexed • multiple reqs/resps can be in-flight over one conn • avoid multiple TCP conns to make parallel requests
15. • '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
16. Protocol Buffers (a.k.a. protobuf) • Mechanism for serializing structured data • Interface Definition Language (IDL) • Binary, compact, fast • Versioned • strongly typed
18. Where does gRPC fit within the communication stack?
19. gRPC
20. Microservices Framework
21. Protobuf workflow Protobuf definitions Protoc compiler Python Golang Java gRPC server gRPC client 1 - Define 2 - Compile 3 - Implement Generate Stubs protoc --go_out=plugins=grpc
23. Example - Generate Server and Client • Download compiler protoc via Github releases and Install Go implementation of gRPC: $ go get -u google.golang.org/grpc • Build protos: $ protoc --go_out=plugins=grpc:. service.proto
24. Example - Implement server
25. Example - Implement client
26. Example - Generate Server and Client • Install Python of gRPC: $ pip install grpcio • Build protos: $ python -m grpc_tools.protoc -I . --python_out=. --grpc_python_out=. ./api.proto
27. Example - Implement server
28. Example - Implement client
29. gRCP Streaming gRCP supports streaming where client can stream data to server, server to client and bi-directionally
30. 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
31. IDL Stream
32. Example - Stream server Server sends data elements to client via a stream server.
33. Example - Stream client Client streams data elements from the server until io.EOF.
34. Secure gRCP Service The gRPC framework makes it easy to add secure TLS transport between client and servers.
35. TLS setup - server
36. TLS setup - client
37. Request Timeout Use gRPC request timeouts to prevent client make from waiting an excessively long time for responses
38. Request timeouts Specify timeouts using Go’s Context type
39. Error Handling gRPC Errors are structured and can return valuable information to clients with rich detail.
40. 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
41. gRPC errors - server
42. gRPC errors - client Use status code for smarter error handling
43. gRPC errors - complex values
44. gRPC errors - extract objects
45. Backwards (HTTP) Compatibility Use a reverse proxy JSON API in front of gRPC server
46. How to upgrade?
47. Backwards (HTTP) Compatibility • Run a reverse proxy JSON API in front of gRPC server • Generate via github.com/gengo/grpc-gateway
49. Update protos
50. Command generate gateway • Run a reverse proxy JSON API in front of gRPC server • Generate via github.com/gengo/grpc-gateway • Build steps: 1. Regenerate protos: $ protoc -I . --go_out=plugins=grpc:${GOPATH}/src proto/service.proto 2. Generate reverse-proxy: $ protoc -I . -I ${GOPATH}/src/github.com/grpc-ecosystem/grpc-gateway/third_part y/googleapis --go_out=plugins=grpc:${GOPATH}/src --grpc-gateway_out=logtostderr=true:${GOPATH}/src proto/service.proto
51. Proxy server
52. gRPC/REST API Swagger document • Generate a swagger.json • Build command: $ protoc -I . -I ${GOPATH}/src/github.com/grpc-ecosystem/grpc-gateway/th ird_party/googleapis --go_out=plugins=grpc:${GOPATH}/src --grpc-gateway_out=logtostderr=true:${GOPATH}/src --swagger_out=logtostderr=true:. proto/service.proto
53. Serving swagger.json with UI
54. 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
55. 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 • Add monitoring and metrics using interceptors (e.g. Prometheus)
56. Benchmark https://grpc.io/docs/guides/benchmarking.html
57. https://github.com/mresti/pycones18-grpc-vs-httpjson Python Microservices Comparing
60. LIVE DEMO TIME!!!
61. Performance Examples https://performance-dot-grpc-testing.appspot.com/explore?da shboard=5636470266134528
62. Source: https://twitter.com/mardibiase/status/872741766541316096
63. Source: https://twitter.com/lukaszkorecki/status/881101428277858304
64. Source: https://twitter.com/sadoperator/status/884475994500759553
67. Q&A
68. <thank-you> @Mr_Esti