![\"RPC\"](\"https:\/\/www.aegissofttech.com\/insights\/wp-content\/uploads\/2024\/01\/RPC.png\" "\\"\\"")
<\/p>\n
History of gRPC:<\/h2>\n
Google created Stubby, which has a single general-purpose RPC infrastructure to link numerous microservices that operate within and across its data centers. In March 2015, Google decided to develop the next iteration of Stubby and release it as an open-source project. This led to the creation of gRPC.<\/p>\n
gRPC has already gained widespread adoption among organizations and products such as Netflix, Cloudflare, Google, Docker & Slack etc. Its ability to offer Bi-directional streaming with HTTP\/2<\/strong> in a consistent yet language-idiomatic manner has been a key factor in its adoption.<\/p>\n gRPC 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.<\/p>\n REST APIs, or Representational State Transfer Application Programming Interfaces, are a set of architectural principles and constraints used for designing networked applications. It is completely different than that of gRPC which runs on HTTP verbs like GET, POST, PUT, DELETE, etc., and takes serialized text-based parameters as input (either JSON or XML). However, for a very simple straightforward API, REST is more suitable, but in real-world applications where tons of data are involved gRPC is way ahead of REST. Let\u2019s find out the reasons behind that.<\/p>\n Opting for gRPC proves advantageous when constructing microservices that demand high performance, optimal speed, minimal latency, and scalability in communication between client and server. This technology excels in scenarios necessitating real-time data streaming, bidirectional communication, and high-throughput requirements.<\/p>\n However, gRPC is not the ideal choice for scenarios seeking a straightforward and lightweight API or those aiming for extensive interoperability with systems using diverse protocols. Similarly, it is not recommended for situations demanding a high level of flexibility concerning message formats and data types. Also due to the proto configuration, a learning curve will be there for developers.<\/p>\n As we already know gRPC has two modules.<\/p>\n .NET Core supports both of these from Visual Studio 2019. So, let\u2019s see how we create and consume gRPC services using .NET Core.<\/p>\n To start a gRPC project in Visual Studio\/Visual Studio Code, you have to select the gRPC template while creating a new project. Or you can run the below command to create a new gRPC service.<\/p>\n Once the project is created, install three NuGet packages from the Package Manager Console.<\/p>\n Now your project is ready to act as a gRPC service. It is time to add your first service in gRPC.<\/p>\n Let\u2019s say you have to build a Customer Service where you need to expose a procedure to create customers. So, create a proto file and set the Service name, request & response over there.<\/p>\n While you are adding this proto file, make sure it is included in your project (.csproj) file.<\/p>\n Now implement the actual service. Create a new C# file named CustomerService.cs and add a class named CustomerService. Implement the class from CustomerServiceBase.<\/p>\n Don\u2019t forget to build your project after creating the proto file and before creating the service class. If you don\u2019t build your solution, CustomerSeviceBase won\u2019t be available to inherit.<\/p>\n Please note, that CustomerSeviceBase is an auto-generated class stored in your obj folder in the bin. Every time it\u2019s recreated by the .NET compiler whenever there are any changes in the proto file. The same is happening for gRPC clients also.<\/p>\n To enable the gRPC service, in your Program.cs file add the gRPC service.<\/p>\n And create an endpoint for the gRPC CustomerService.<\/p>\n Now build your code and run. In the console, you will get the endpoint (https:\/\/localhost:5001) where your gRPC service is running.<\/p>\n And add the below-mentioned NuGet packages. These are specially for gRPC clients.<\/p>\n Once the installation of these NuGet packages is done, create the proto file using the server file. It will be an exact replica of the server one.<\/p>\n Build your project and run the below dotnet command to generate a gRPC client using the proto file.<\/p>\n Now create the client file from where you are going to consume the CreateCustomer method of Customer Service.<\/p>\n Run both your projects (set the server as a top priority) and in the console, you will get the desired result.<\/p>\n In summary, gRPC is a good choice for building high-performance, low-latency, and scalable microservices that require efficient communication between client and server. It is especially well-suited for use cases that involve real-time data streaming, bi-directional communication, and high-throughput scenarios. However, it is not recommended for use cases that require a simple and lightweight API, or for use cases that require a high degree of interoperability with other systems that use different protocols. It is also not recommended for use cases that require a high degree of flexibility in terms of message formats and data types.<\/p>\n\n\n Read More:<\/p>\n\n\n\nHow is it better than REST?<\/h2>\n
\n
\n\n
\n Type<\/strong><\/td>\n 1000 Requests<\/strong><\/td>\n 2000 Requests<\/strong><\/td>\n 3000 Requests<\/strong><\/td>\n 4000 Requests<\/strong><\/td>\n 5000 Requests<\/strong><\/td>\n<\/tr>\n \n gRPC<\/td>\n 14.478 sec<\/td>\n 25.239 sec<\/td>\n 37.823 sec<\/td>\n 53.073 sec<\/td>\n 62.624 sec<\/td>\n<\/tr>\n \n REST<\/td>\n 16.451 sec<\/td>\n 30.181 sec<\/td>\n 43.996 sec<\/td>\n 58.221 sec<\/td>\n 71.300 sec<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n Where should you use gRPC and where not?<\/h2>\n
Implementation of gRPC service using .NET Core<\/h3>\n
\n
gRPC Server<\/h3>\n
dotnet add package Grpc.AspNetCore \n dotnet add package Google.Protobuf \n dotnet add package Grpc.Tools \n<\/code><\/pre>\n syntax = \"proto3\"; \n option csharp_namespace = \"GrpcCustomerService\"; \n \/\/ exposed service \n service CustomerService { \n rpc CreateCustomer (CustomerRequest) returns (CustomerResponse); \n } \n \/\/ request \n message CustomerRequest { \n string name = 1; \n string email = 2; \n string mobile = 3; \n } \n \/\/ response \n message CustomerResponse { \n string message = 1; \n } \n<\/code><\/pre>\n using Grpc.Core \n using Microsoft.Extensions.Logging; \n using System.Threading.Tasks; \n public class CustomerService : CustomerServiceBase \n { \n private readonly ILogger<CustomerService> _logger; \n public CustomerService(ILogger<CustomerService> logger) \n { \n _logger = logger; \n } \n public override Task<CustomerResponse> CreateCustomer(CustomerRequest request, ServerCallContext context) \n { \n \/\/ TODO - Your logic to create a customer goes here \n return Task.FromResult(new CustomerResponse \n { \n Message = $\"Customer {request.Name} created successfully!\" \n }); \n } \n } \n<\/code><\/pre>\n services.AddGrpc(); \n<\/code><\/pre>\n app.UseEndpoints(endpoints => \n { \n endpoints.MapGrpcService<CustomerService>(); \n }); \n<\/code><\/pre>\ngRPC Client<\/h3>\n
dotnet add package Grpc.Net.Client \n dotnet add package Google.Protobuf \n dotnet add package Grpc.Tools \n<\/code><\/pre>\n dotnet grpc compile \n<\/code><\/pre>\n static async Task Main(string[] args) \n { \n \/\/ Specify the gRPC server address \u2013 Need to set this from applicationSettings.json \n var channel = GrpcChannel.ForAddress(\"https:\/\/localhost:5001\"); \n \/\/ Create a gRPC client for the CustomerService \n var client = new CustomerService.CustomerServiceClient(channel); \n \/\/ Your customer data \n var request = new CustomerRequest \n { \n Name = \"Test Name\", \n Email = \"test.name@example.com\", \n Mobile = \"987654310\" \n }; \n \/\/ Call the CreateCustomer method on the gRPC service \n var response = await client.CreateCustomerAsync(request); \n \/\/ Display the response \n Console.WriteLine($\"Server says: {response.Message}\"); \n } \n<\/code><\/pre>\nConclusion<\/h2>\n