The document discusses the use of gRPC, a modern open-source RPC framework developed by Google, highlighting its advantages for building efficient APIs and microservices. It compares gRPC with REST and HTTP/1.1, showcasing its faster performance, lower latency, and support for bi-directional streaming. Additionally, it addresses the use of Protocol Buffers for data serialization, emphasizing their benefits over XML.

1. Presented By: Shivraj Singh
Software Consultant
Knoldus Inc.
Building API using
GRPC and Scala

2. 1. History.
2. gRPC: Introduction.
3. gRPC: Workflow.
4. Why gRPC.
5. Scenarios.
6. Core Features
7. Using an HTTP/1.1 transport and its limitations.
8. Difference b/w gRPC and REST.
9. gPRC helps Microservices.
10.gRPC: Powered by.
11.Why not jut use XML.
Our Agenda

3. History
● Google has been using a RPC infrastructure called Stubby to
connect the large number of microservices running within and
across their data centers for over a decade.
● RPC backbone behind every Google service that we use today.

4. gRPC: Introduction
● gRPC is a modern open source high performance RPC
framework that can run in any environment.
● It can efficiently connect services in and across data centers
with pluggable support for load balancing, tracing, health
checking and authentication.
● It is also applicable in last mile of distributed computing to
connect devices, mobile applications and browsers to backend
services.

6. Why gRPC?
● With gRPC we can define our service once in a .proto file and
implement clients and servers in any of gRPC’s supported
languages.
● gRPC is roughly 7 times faster than REST when receiving data
● It is 10 times faster than REST when sending data for this
specific payload.

7. Scenarios
● Efficiently connecting polyglot services in microservices style
architecture
● Connecting mobile devices, browser clients to backend services.
● Low latency(process a very high volume of data messages with
minimal delay).
● Highly scalable(it can handle a large increase in users, workload
or transactions without undue strain)

8. Core Features
● Idiomatic client libraries in 10 languages
● Highly efficient on wire and simple service definition framework
● Bi-directional streaming with http/2 based transport
● Pluggable auth(Use:Secure Socket Layer), tracing(opentracing),
load balancing and health checking(package grpc.health.v1;)

9. Microservices

10. Using HTTP/1.1 Limitations
● Request-Response protocol
○ Each connection supports pipelining... but not parallelism
(in-order only)
○ Content may be compressed... but headers are text format.
● Naturally supports single-direction streaming ... but not
bidirectional

11. HTTP/2 Advantages
● For HTTP/1.1 and HTTP/2 protocol with a slight difference.
Imagine that waiters are TCP connections and you want to order
your meal and a bottle of water. For HTTP/1.1 that would mean
that you ask one waiter for your meal and another one for
water, hence you would allocate two TCP connections.
● Request → Stream
○ Streams are multiplexed using framing
● Header compression
● Directly supports bidirectional streaming

12. HTTP/1 vs HTTP/2

13. Diff b/w gRPC and REST

14. Problems in Microservices

15. gRPC Help Microservices
● Distributed logging, tracing
● Ready to honor backward and forward compatibility, even
if you're the same person consuming this service on the
other side
● Provide Quality of service(QoS) - request deadline even if
it's propagated to many different services
● Provide request propagations/cancellations - stop
cascading failures

16. Use of Protocol Buffers
Protocol buffer data is structured as messages, where each
message is a small logical record of information containing a series
of name-value pairs called fields.
For example:
syntax = “proto3”;
message Person {
string name = 1;
int32 id = 2;
string email = 3;
}

17. Example of XML and Protobuf
In XML:
<person>
<name>John Doe</name>
<email>jdoe@example.com</email>
</person>
In Protobuf:
person {
name: "John Doe"
email: "jdoe@example.com"
}

18. Why not just use XML
Protocol buffers have many advantages over XML for serializing
structured data. Protocol buffers:
● are simpler
● are 3 to 10 times smaller
● are 20 to 100 times faster
● are less ambiguous
● generate data access classes that are easier to use
programmatically

19. gRPC : Powered by

20. ● https://grpc.io/docs/guides/
● https://grpc.io/docs/tutorials/basic/java/#client
● https://grpc.io/docs/talks/
● https://grpc.io/about/
● https://grpc.io/blog/
References

21. Thank You!
@Knolspeak
/KnoldusSoftware