Grpc With .Net Core by Mangesh Gaherwar || Lightup Conference

We support this cause and

Help out the needy people. There. So this event wouldn't be possible

without these sponsors and we have plenty of sponsors. So thank you sponsors for the for for sponsoring

us this event and. Let's start the session so with with dotnet core 3.0 we have some exciting

We had some exciting upgrades. We have some exciting features and gRPC is one of them

so we'll try to explore what is gRPC. What are the basic concept of gRPC

How to create a service? How to create a client? And let's see how we can

We can call the call gRPC service using and let's let's create one demo app with

Blazor Web assembly as well as using some gRPC service as well

OK, so agenda for this session will be to to understand what is gRPC

Let's try to explore some gRPC concepts like protobuf how the things will how the client and

server communication occurs with the with gRPC. Then we will have one demo for creating a client and service

We will explore some gRPC types and then finally it would be a demo to do application with Blazor Web

Assembly and gRPC. OK, so. First thing, what is gRPC? So. Oh

I'm starting my video and. Yeah, so what is GRPC? Basically GRPC is open source RPC framework

which is been developed by Google. Actually Google uses Google Google has open sourced this in 2015

They Google has used this RPC framework into their internal for their

internal communication. Basically with the gRPC we can efficiently connect polyglot services

Big polyglot services are the services which are developed into two different languages or two

different completely environment environments in microservices architecture connecting mobile devices and some browser clients as well

It provides a way to it provides a way to the client app apps to call the server method as

local objects. This this this is basically a feature of the any

RPC any RPC framework. We can say that we use the client app or

client apps don't go into the details of what will be the

protocol or what will be? What will be the methods to call some

methods on onto the server like we use we do while while calling

the web API methods it would be simple. Simply it would be like

like calling the class method into into your like like like we do into our day to day development so

Next thing is to explore the gRPC core concept. Basically gRPC has two main parts. First one being the gRPC protocol that

is HTTP two and another one that is the data serialization form or data serialization method which which which is

nothing but which is nothing but the or we call it as an

protobuf protobuf either data is a data serialization format as well as the ideal which is ideal that is interface definition

language which is been used by gRPC so so as to communicate in

between your client and in between your service. So so these are the two main building block of of our gRPC service

So HTTP 2 it is an extension or our traditional HTTP, which provides some enormous features like performance or

streaming client side streaming, server side streaming, or as well as the bidirectional streaming

So these are so this is the main. So this is the main component of JRPG as well as the protobuf

So let's try to explore what is protobuf. Protobuf, which is also called as an protocol buffer

which is a flexible, efficient and structured mechanism for serializing the data

So in the same way that we use JSON into our web APIs or XML

we used to do XML like JSON or XML. This is the this is the mechanism to see for serializing

the data. Again, I just uh, coin one term that is ideal

It is used as an ideal ideal is nothing but an interface definition language

Generally, what is ideal ideal is ideal is the term which we used to or or it's it's

it's a mechanism to let a program written in one language to communicate

With another language like suppose my service is into a service has been returned into the C sharp then

There there my clients could be into the Android or into into

the job or it can be a Python Python client so protocol buffer

acts as an ideal so that and it it it means what it it allows

us or it it creates a platform so that these things these things

these things will be able to communicate with each other properly or without any hustle

This protocol buffer they are also used for service interface and message definitions as well So we see how what are the service interfaces and the message definitions are and these can be used to generate the source code for your choice of language using one compiler open source compiler is there which has been called as an proto see

So while demo we can see how to use the proto see or how we can generate the source code from this protobuf file

So. While dissecting the protobuf file, we can see. I'll just stick to the C-sharp protobuf file

So the first section is it tells us what is the syntax that is been used to generate the protobuf file

It is basically proto 3. So there are plenty of versions. There are like proto 2, proto 1, something like that

like that and currently we are using proto 3 and there is a C sharp namespace where all services

will be clubbed up that is the light up conference demo that I had created a demo next thing

is the service definition this is the sample service that we have created this service

this service is a greeter service. It contains the say hello method

and it accepts the hello request and returns the hello replies. Now, so to og with our web API things

this greeter is our controller and this say hello is our particular controller method

into our web API. And next these things like message hello request

and message hello reply are nothing but the models that we use into our web API

Basically what this service definition or what this protocol buffer file is telling us

is we are defining a greater service which have a say hello method

which accept a hello request object and it returns a hello reply

Okay, so let's. Let's try to dissect that more while while while I'll be I'll be doing one demo with you

OK, so basically how the communication between our grpc server and client occurs

So generally the grpc server implements a protobub service interface and runs a service

to handle call to its service methods. OK, generally what happens is at server end

gRPCs, at server end, the protocol buffer file provides some service interfaces

as well as some service methods which are implemented as a, which are implemented as a service

and which are implemented at the service end and at the gRPC server end

and it provides some service methods to be called by the client

On the other hand, this same protobuf file is used to create stubs

And this protobuf file can be distributed among any client, be it Android client

and it can be an Android client. We just give them our protofile

It will generate a stub. It will send a protorequest, and in return, it will get a protorespond

The same file can be distributed, distributed to another client that that can be a C++ client

Again, they will implement the stub from from our proto file again

They will send the proto request and they will get the proto response

So basically protobuf what protobuf allows us is it. It generates. Or we can develop a service into into

any language and we just distribute that particular protobuf to the different languages

To the different clients with the different languages basically. It can be an Android

client, it can be a C++ client or it can be a Python client or it can be a node client

So basically this is how the communication in between gRPC server and client occurs

So let's see how we can create our service and we can create a

We can create a client and how we can call the service from this client

So I'll just switch myself to my visual studio. I have one application already running over here

But what we will do is. We'll just add one new project

So you can see here there are there are templates. I mean G

This is the gRPC template which we use to create a gRPC server so when we click next

You will get the project name as usual. When you can you can you can

Light up service demos you can you can name it properly. Then this this box will open just

It will just ask us to create a. GRPC service. And here we go

Here our service. Is created so when we look at the folder structure and when we look at the the how the how the

how the things are arranged, you will see this protos file that is grid.proto

So basically this is the proto file and this is the service implementation

of that particular proto file. So again, like I have explained, this prototype uses the syntax

which is provided by proto3. This is our C sharp namespace. This is package which is being used internally

while creating a while generating a service interface for this. And this is our service definition

This is the messages and these two are these two are message types

These two are message types which have been which will be used into the service end

Okay, so. What we'll do is we'll just add one new service

and we'll see how we can consume it at the client's end

So I have one, I have created one. I have created, I have one demo already created

so we'll use that project to continue in this demo. So to add the protofile, just use the add new item option

item option Yes Click here proto file and let see it Let say it is

Hello world. Let's try to. Let's try to keep it as per the naming convention that proto

file name should be in lower case. Not sure why it is, but if you can, if you see this hello world dot proto file is been added

Now next thing that we need to do is we need to make sure that this proto file will be compiled

So in order to do that, this build action. Just go to the proto file

go to the protofile right click on it just click on the properties when we see the build action

here you can see the various options this is the protobuf compiler there is one action that is

which tells that this file should be compiled with this protobuf compiler and here we are saying

there are various options that how this file should be compiled as an client and server as a client

only as a server only or just don't do anything. So in this case, what we are going to do is we are going to compile this file as an server only so

With with. When we are done with these options, let's build the project once

The project is building might be my services are running. Into the background, so let me stop them

Yes. So it is stopped now I can build my projects. Yeah, here it is. We are successful with that now to define the service. The first step that we need to do is to define our according to me. I mean you can take whatever the approach you want. You can define the service first and then define your messages

but what will be the convenient way is to define our messages

Okay, so message my messages will be. Hello request. Which will return

Hello response. In this. Hello request, I will just say. I'll just create one

One so one thing interesting thing that that we can we can check here is

This this every field into this message had some numbering with it

That is one what what this number numbering is. So basically these numbers indicate the fields number which are used to identify fields in the binary encoded data

basically protocol protobuf encodes the data into the while sending into the wire

It is binary encoded. So these numbers are used to recognize that particular field

These numbers are used to recognize that particular field. So when we are done with this

so when we are done with this, then it's time to create

okay

i guess i misplaced it somewhere so let me add one proto file again

you okay oh it was there actually need to include this into the project

I'm not sure why it is not showing into this but and

So let's let's try to generate this service and into this service

What we'll do is we'll just say that RPC. Say hello. Which will accept this hello request and which will returns us the hello response. Comma

And let's try to build this again. So yes, this is getting build

Now. What we'll do is. We will add So This all this all has become our contract This this all has become our contract Now we are going to implement this contract into

Into the service. Hello world. Service

Now we have added this hello world service. Next step is. Make sure whatever

sure why it is let me do it again

i can do it something like this and

Yeah, here we can see. Dot hello base. So this is the C sharp our C sharp namespace

We can we can we can make it into this using statement maybe

And now. We know this is the hello world where it is

This is the now we can see this. Hello world is the is our service

definition and this is the hello world base. This is nothing but an abstract class

which implements all all the things and binds the binds the service call

to this proto proto file basically. So that that is the that that is

been achieved by using the service base. Now to use this method into this proto file

what we need to do is we need to. Override. This method into this service implementation

and what we will do is we will just return. So

Here we have implemented our service in which this this is the simple service which is which

is returning our hello response. It contains one property that is greeting

We are just appending some hello and whatever the request name that we will be sending from

the client it would be it would send us as an hello that particular client

OK or hello that particular name. So now next step is to generate the clients

So for that I have added one console application and this in this we will use to call this

Oh, before that, what we need to do is. Uh, before that, what we need to do is we just need

to map this service or map this endpoint into our. This middleware so to to to do that

There is one. Well, where for that? Just need to do this again

If you could see. If we try to access these services from the browser

then it will give us this message that communication with gRPC endpoints cannot be

Made it can be made only through a gRPC clients so in order to invoke

these services we need to have a gRPC client which will implement

these services or these protocol buffer files so now next step is

to create a client so how do we create a client we just need to do

is just copy this proto file. Spaced. In your protos folder or or

or whatever location you want and just go to the properties of it and just change the

step classes like how the step classes will be generated we want it to be generated as a client

only just apply this and click ok now this file or this service is ready to be consumed into our

client application so before that in order to make any client or i'm talking specifically about

the dot net client we need some three packages before that first one being google dot protobuf

second one is the grpc dot net dot client and third one is the grpc dot tools so these these things

are needed. So these these things will provide us the things like protocol proto C or or the orientation for the protobuf

files so. Now we have we have this proto file we have made it to compile

as an client. Now it's time to consume this file. And see how it will work

So I'll just close all of them. I will just go to the program dot CS

And. This is my older demo basically. Let's keep it. So first step into into this is to create a client so create a channel

So what channel does is it just creates a connection in between

your client and in between your server. So we are assuming that our services are running on this

That is 5001 so. To do that just just just do one thing

I'm using this dot net run. OK, there are some issues or runtime issues

Let me see what it is. Oh

There are some issues with this. OK. This endpoint will not be there because we have

commented that and let's try to run this again. uh yeah we have this also let's comment this all time and let's try to run this again

I mean. OK, yeah, our server is running with this and now

Let's go to our client. Let's let's build up our client first. Then this is how we create a channel

Now. Once we create a channel next next step is to create a

client, so the client is nothing but. This hello world that we have

And. We need to provide a connection for that, OK? So this client

is nothing but. This client is nothing but a this this client is nothing but a

client generated by our protobuf file. So when we when you go and when you

see into this so you will see that this all the class is been generated

from a protobuf file when we compiled it. So this is this is our client now

To get a. To get to get our or just to call a method from our server

What we need to do is. We just need to. Just come in this and

client dot say hello it accept

new hello request which has name we will call we will give it as an

abc for now and that's it so we'll add some for here and

Yeah, we're ready to go. And we can see this response has

When property called greetings and which will will be printing on the console app so maybe

So yeah, our service is running over here. Now let's try to run this this client and see what happens over here

So yeah, I will say this as my as my startup project and yeah

Here I'm running it. OK so. Yeah, now now you can see here the response from the services

Hello, ABC in the same way that we have implemented. With this hour

Hello world service it. What it is returning is it is returning the greetings with

this hello and whatever the name that we are passing. To this client from here

Here you can say if I change this to maybe. Maybe to Tony Stark

Then let's see what it will return. Yeah it is returning now Hello Tony Stark and on and at the server server end if you could see that this request is been finished

within this. Within this timeframe with status code 200 and with the content type as an application slash GRPC

So this is how we can create our services and this is how we can consume them

into our client application so. So coming coming back to. So coming back to our

They more power PPD. So a. So GRPC types. So basically there are four types of GRPC types

First one being the unary that is a simple request and response

format or the way we send the request server process the required request and it sends us back the responses. That is we

call it as an unary. Next one is the client streaming. What

happens in this case is client streams the request servers gets them, accept them all, process them and sends us the

response at once. Next one is the server streaming. The client the client initiates the request in return

Server holds that holds that request on on behalf of that request

It sends the stream of the responses to the client and client can act on that or client

can operate on that that that on that particular stream of the responses

Next one is the bi-directional streaming means what happens is client can send the streams

in response server also can send us the stream data. So these are the four types of the GRPCs, right

Next, we have one demo that demo, I have one ready-made demo with me

which is nothing but the integration of our WebAssembly and our GRPC service

Basically, there is one limitation with the GRPC service. What would that limitation is we cannot call our grpc service from the browser like I had

I had shown you that message while into the service definition So in in order to avoid that there is one package or there is one another form of grpc

That we call as an grpc web that this limitation is because of some some

HTTP to Compliances with the browser as well as browser is not ready to accept some

Or browser is not ready to Adopt with with some some some something some important things with the HTTP suit

So that's why the gRPC service cannot be directly consumed into the browser

So in order to you know in order to Overcome that there is one there is one way out for that that is gRPC web

So this application is basically developed into the Blazor WebAssembly and. Into the into the service side we are using

gRPC web and gRPC so as to implement the services. So let's again go back to the Visual Studio

And this is my. Ready readymade app. Now let me stop. This service service station because my service will be

running on the on the same port and yeah, this is shutting down

OK, so let me go back to my source code again and

Yeah, so this is my service application. This is a to do

application. Basically it has my to do data service. What it is taking is it it will it will just get us all the list

It will post or it will be to add the database to add the to do item into the database

This will get a particular data item to do data item deleted and updated

So I'm just you don't need to make it like put delete or get something like that

We don't need to use that terms. You can use whatever the terms you want to like post

I just made it to look like something like web APIs. OK, so

In this in this in this application I'm using some in memory database to to to try it out and this is my to do

service and these are the initializations Now And this is my WebAssembly app so I just start my to do applications once

Open power shell window open over here and I'll just click.net run

Yes, so now my service is running on this localhost 5001

Now it's time to start our. Client application, so this client application is completely built up on the Blazor web assembly

So in the same way, like we have developed the client, we have

The to do dot proto client it has all the methods or it has

all the methods, all the message definitions, imports. Syntax and I'm just making it to compile

As an client only. So when I start this application. It is starting

It is loading actually, yeah, so this is this is my this is my

seeded data that I had done while running the application and yeah, now you can see into into into the services

Uh, not here. Yeah, here. Uh

This this service is running. So let's. Now try to what what we'll try to do is just add one new item

Just say meetings. At. 10 AM tomorrow status is active. All good

OK, now maybe we can have some refinements. At 11am and the status is active

Good. Again, I can delete this. All good. I can edit this

Just make it closed that my particular to do item is done

So this is this is the application that that we have developed into the Blazor Web assembly and with

with gRPC web and gRPC services. If you if you. If you just yze

Some network calls with this like test and test and. Active. Here you can see

That this call. OK

traditional web API. So this is this is how we can. I mean this

this is how we can develop or we can use. gRPC web to to to just make sure that we could to build up the

browser apps into the web assembly or into the angular or in in in any other technologies also. So this is my blazer

This is my. This is my to do application now. Coming to this

So, some startup setups that we need to make before starting using jrpcweb

So this is adding some cores like we do into the web API but with the headers like jrpc

status, jrpc message, jrpc encoding and accept encoding. Next is to add services like services.addjrpc

This is usual. Next is to add or to configure a middleware into the pipeline to tell that we are going to use the gRPC web and to make sure that these endpoints just enabled with the course that that we have developed

or that we have that we have mentioned into this services services setting so this is how we can

can develop develop the. This is how we can integrate our web

assembly apps with our gRPC service. I mean, yeah. So coming back to our presentation. So

Just just just just few questions that there might be like why we

should use the gRPC instead of web API. Actually, yes, that's the most debatable point

It would develop debatable point like why we should. We should switch over to the gRPC if we have the way

API like excellent framework like web API. First thing or excellent framework like web API

where we are so used to it. We can develop the things quickly and why

why we should use the gRPC. First thing is the performance. With the HTTP to

The performance thing and the gRPC uses HTTP2 and with with HTTP2 there are some moderate

improvements or there are some considerable improvements into the performance of the application

or how the communication will be occur. Next is the code generation

Like the code generation is a little bit easy when we are using the protobuf

And means like we used to do for the WSDL into the WCF era that will just generate some

clients or stubs and we used to do that. In the same way, we can do that for the protobuf as well

But we cannot do that in case of Web APIs. Next is the strict specification

Though generally there is no formal specification for the rest. There is no like what verbs to be used for a particular method or what what what should

be the return types? What should be the output or how the output should be structured

So there is no formal specification is been defined with the rest, but with the GRPC with

the protobuf with the with the with with the protobuf we have some strict specification

which is been defined. Next is the streaming support. We have some we have streaming support like clients

client side streaming, server side streaming and bi-directional streaming, which is not possible with the traditional rest

This is well suited for the microservices for polyglot environments and again. Being

The less what we can say being lightweight than the rest response. This can be the alternative to the rest into the

network constraint areas. So for polyglot environment, yes, whenever there are two

different languages involved, then there are always issues. So JRP C or protobuf JRP C with protobuf can be the can can

be helpful in in that case into the inter services communication to use to use into the microservices

We can use the gRPC. So these are these are the. These are the plus points of the gRPC

but there are some negative points as well. Like there is no directly support

to the direct support on the browser. As far as the gRPC is concerned

so that that can make so that that is. That is something that that gRPC

needs to be matured on. So these are there are there are there are plenty of limitations

with the GR pieces as well, so. So any questions with this

I guess no. So yeah, thank you. And this is these are my contact details. You can email

me. On my email ID that one gauge dot care were at the

You can find me on LinkedIn as well. My GitHub ID is dotnet geek

All these samples that is been into the into the into the demo

are present on this GitHub GitHub repository and you can find me on the Twitter as well

I tweet on the name under the name of dotnet geek one and I blog at www.netgeek1