In this article, we will learn about the basics of gRPC and its usage and, finally, implement the Server and Client using .NET Core 8.0.
gRPC explained:
gRPC (Google Remote Procedure Calls) was initially created by Google, which has used a single general-purpose RPC infrastructure called Stubby to connect the large number of microservices running within and across its data centers for over a decade.
In March 2015, Google decided to build the next version of Stubby and make it open source and the result was gRPC.
- gRPC is a modern open-source high-performance Remote Procedure Call (RPC) framework.
- It implements APIs using HTTP/2 which can run in any environment.
- gRPC has two parts
- gRPC Protocol - As mentioned above it uses HTTP/2 which provides a lot of advantages over traditional HTTP1.x
- Data Serialization - by default gRPC uses Protobuf for the serialization and as an intermediator between client and server.
- gRPC clients and servers intercommunicate using a variety of environments and machines.
- It supports many languages like Java, C#, Go, Ruby, and Python, check the full list here.
- It supports pluggable auth, tracing, load balancing, and health checking.
Different scenarios in which we use gRPC
- When we use microservice architecture, and we use that for internal communication from one or more servers.
- gRPC is handy when performance is on high priority with low latency.
- It is useful when we require duplex communication between services with different types of data.
- gRPC is useful in the last mile of distributed computing to connect devices, mobile applications, and browsers to backend services.
gRPC vs REST:
REST has been one of the highly used API frameworks and with gRPC grabbing the limelight, let's see the comparison on various parameters.
REST | gRPC | |
---|---|---|
Protocol | HTTP/1.1 | HTTP/2.0 |
Request-Response Model | Only supports Request Response as based on HTTP/1.1 | Supports All Types Of Streaming as based on HTTP/2 |
Serialization | JSON/XML | protobuf |
Payload Format | Serialization like JSON/XML | Strong Typing |
Browser Support | Yes | No |
Pros and Cons of gRPC:
Pros
- With duplex communication, it supports bi-directional streaming with HTTP/2-based transport.
- Performance is one of the talking points of gRPC and it is faster than REST and SOAP.
- gRPC services are highly efficient on wire and with a simple service definition framework.
- gRPC messages are lightweight compared to other types such as JSON.
- Client libraries supporting the 11 languages.
Cons
- Browser support is very limited.
- Since it uses binary data which is not easily readable compared to JSON or XML.
gRPC Implementation
Prerequisites
- Visual Studio 2022
- .NET 8.0
Set Up gRPC Service:
- Open Visual Studio 2022 and create a new gRPC project with the name GrpcCoreService and select
.NET 8.0
under the Framework option. -
Review the default project folder structure.
-
Protos: contains all the gRPC server asset files, such as
greet.proto
- Services: Contains the implementation of the gRPC services.
-
Root Folder:
appSettings.json
contains the service configuration andProgram.cs
contains code configuring app behavior.
-
Protos: contains all the gRPC server asset files, such as
Right-click on the
greet.proto
and click on Properties, and verify that gRPC Stub Classes is set to Server only.
Set Up Client Application:
- Add a Console App Project with the name GrpcClientApp and select the required configurations.
- Add the required packages to the client app project. ```
Install-Package Grpc.Net.Client
Install-Package Google.Protobuf
Install-Package Grpc.Tools
- Create a **Protos** folder and copy the `Protos\greet.proto` file from the **GrpcCoreService** under this folder.
- Update the namespace inside the `greet.proto` file to the project's namespace:
option csharp_namespace = "GrpcClientApp";
- After that right-click on `greet.proto` and click on **Properties**, and set the gRPC Stub Classes to **Client only**.
![Proto_Client_Prop](https://raw.githubusercontent.com/sandeepkumar17/td-dev.to/master/blog-posts/grpc-server-and-client-implementation/assets/gprc_09.png 'Proto Client Properties')
- Finally, edit the **GrpcClientApp.csproj** project file:
- Once this is completed update the `Program.cs` file to call the greeter service.
> Make sure to use the port number mentioned in the launchSettings.json
files of the GrpcCoreService project.
Run and Test:
-
Set Up StartUp Project: Configure both projects as startup projects in the proper order.
- Run the project and review the output of both the gRPC service and the client in the Console window.
- gRPC Service Window:
- gRPC Client Window:
Setup new service and client:
So far we have tested the default greeter service and client.
Now let's move ahead and set up a new service and client that consumes this new service.
Setup employee service:
- To start with add the
employee.proto
file under the Protos
folder and add the following code.
- Under the
Services
folder add the EmployeeService.cs
and implement it as shown below.
- Inject this new service under the
Program.cs
.
app.MapGrpcService();
#### Update the client app to consume the employee service:
- Copy the `employee.proto` file from the **GrpcCoreService** and update the namespace:
option csharp_namespace = "GrpcClientApp";
- After that right-click on the `employee.proto` and click on **Properties** and set the gRPC Stub Classes to **Client only**
- And make sure the proto file is added in the **GrpcClientApp.csproj** project file:
- Finally, update the `Program.cs` file to call the `employee` service.
- Once you are done with changes, you can verify the folders and files under Solution Explorer.
Run and Test the new service:
- Run the project and search for the employee by passing the Employee ID in the Console Window
NOTE:
Check the source code here.
sandeepkumar17
/
GrpcCoreService
.NET 8.0 - gRPC implementation
.NET8.0 - gRPC Service and Client implementation
Introduction
- gRPC (Google Remote Procedure Calls) is a modern open-source high-performance Remote Procedure Call (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 the last mile of distributed computing to connect devices, mobile applications, and browsers to backend services.
Solution and Project setup:
Set Up gRPC Service:
-
Open Visual Studio 2022 and create a new gRPC project, and name it to GrpcCoreService and select .NET 8.0 under the Framework option.
-
-
Right-click on greet.proto and click on Properties and verify that gRPC Stub Classes is set to Server only.
Set Up Client Application:
If you have any comments or suggestions, please leave them behind in the comments section below.
Top comments (0)