HTTP and grPC Communication protocols used in Microservices

-

Microservices architecture is an approach to building distributed systems that involves breaking down a large application into smaller, loosely coupled services that communicate with each other through APIs. There are several communication protocols used in microservices architecture, including HTTP and gRPC.

HTTP: HTTP (Hypertext Transfer Protocol) is a widely used protocol for communication between web applications and servers. In microservices architecture, HTTP is used for communication between services as it's a well-established and reliable protocol that's widely supported. HTTP is simple and easy to use, and it supports a wide range of data formats like JSON, XML, and plain text, making it a popular choice for microservices communication.

gRPC: gRPC is a modern, high-performance, open-source protocol for communication between microservices. It uses Google's Protocol Buffers as a data format, which is a language-neutral, platform-neutral, and extensible serialization format that supports multiple languages. gRPC is designed to be fast and efficient, with support for streaming, flow control, and bi-directional communication. It also supports a wide range of programming languages, making it a popular choice for building polyglot microservices.

Summary, HTTP and gRPC are two of the most popular communication protocols used in microservices architecture. HTTP is a well-established and reliable protocol that's easy to use and widely supported, while gRPC is a modern and high-performance protocol that supports multiple languages and is designed for efficient communication between microservices. The choice of protocol depends on the specific needs of the microservices architecture and the performance requirements of the system.

Here's an example of how microservices can use HTTP communication protocol:

Suppose we have an e-commerce application that consists of several microservices, including a product catalog service, a shopping cart service, and a payment service.

HTTP: The product catalog service provides an API for retrieving product information, which can be accessed by other microservices through HTTP. When a user wants to view a product, the shopping cart service sends an HTTP request to the product catalog service, which returns the product information in JSON format. The shopping cart service can then use this information to display the product details to the user and add the product to the user's shopping cart.

Similarly, when the user wants to check out, the shopping cart service sends an HTTP request to the payment service, which processes the payment and returns a response to the shopping cart service.

Here's an example of how to implement a microservice in .NET Core using HTTP

First, let's create a .NET Core Web API project for the product catalog service: 

dotnet new webapi -n ProductCatalogService

Next, let's add a controller to the project to handle HTTP requests for product information:

C# 
using Microsoft.AspNetCore.Mvc;

[ApiController]
[Route("[controller]")]
public class ProductCatalogController : ControllerBase
{
    [HttpGet("{id}")]
    public IActionResult GetProduct(int id)
    {
        // Retrieve product information from database or external API
        var product = new Product
        {
            Id = id,
            Name = "Sample Product",
            Description = "This is a sample product",
            Price = 9.99m
        };

        return Ok(product);
    }
}

public class Product
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Description { get; set; }
    public decimal Price { get; set; }
}

This controller defines a GetProduct method that returns product information in JSON format when an HTTP GET request is made to the /productcatalog/{id} endpoint.

Finally, let's configure the HTTP service in the Startup.cs file:

C# 
public void ConfigureServices(IServiceCollection services)
{
    // add dependency injection for services
}

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }

    app.UseRouting();

    app.UseEndpoints();
}

Here's an example of how microservices can use gRPC communication protocol:

gRPC:

The product catalog service can also provide an API for retrieving product information using gRPC. The shopping cart service can use a gRPC client to communicate with the product catalog service over a gRPC channel. The shopping cart service sends a request message to the product catalog service, which processes the request and sends a response message back to the shopping cart service.

gRPC allows for bi-directional communication, which means that the shopping cart service can also send streaming requests to the product catalog service to receive updates when new products are added or when the stock of an existing product changes.

Here's an example of how to implement a microservice in .NET Core using gRPC 

Let's create a .NET Core gRPC service for the product catalog:

dotnet new grpc -n ProductCatalogGrpc

Next, let's define a gRPC service and message type in a proto file:

syntax = "proto3";

option csharp_namespace = "ProductCatalogGrpc.Protos";

service ProductCatalog {
  rpc GetProduct(ProductRequest) returns (ProductResponse);
}

message ProductRequest {
  int32 id = 1;
}

message ProductResponse {
  int32 id = 1;
  string name = 2;
  string description = 3;
  decimal price = 4;
}

This proto file defines a ProductCatalog service with a single GetProduct method that takes a ProductRequest message and returns a ProductResponse message.

Next, let's implement the gRPC service in a C# class:

C# 
using Grpc.Core;
using Microsoft.Extensions.Logging;
using ProductCatalogGrpc.Protos;

public class ProductCatalogService : ProductCatalog.ProductCatalogBase
{
    private readonly ILogger _logger;

    public ProductCatalogService(ILogger logger)
    {
        _logger = logger;
    }

    public override Task GetProduct(ProductRequest request, ServerCallContext context)
    {
        // Retrieve product information from database or external API
        var product = new ProductResponse
        {
            Id = request.Id,
            Name = "Sample Product",
            Description = "This is a sample product",
            Price = 9.99m
        };

        return Task.FromResult(product);
    }
}

This class implements the ProductCatalog service by overriding the GetProduct method. The method retrieves product information and returns a ProductResponse message.

Finally, let's configure the gRPC service in the Startup.cs file:

C# 
public void ConfigureServices(IServiceCollection services)
{
    services.AddGrpc();
}

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }

    app.UseRouting();

    app.UseEndpoints(endpoints =>
    {
        endpoints.MapGrpcService();

        endpoints.MapGet("/", async context =>
        {
            await context.Response.WriteAsync("This is a gRPC service. Use a gRPC client to call the methods.");
        });
    });
}

This code adds the ProductCatalogService gRPC service to the endpoint mapping and sets up a default endpoint to handle HTTP GET requests.

The MapGrpcService extension method maps the gRPC service implementation to the gRPC endpoint /ProductCatalog, which is defined in the proto file.

Now, the gRPC service is configured and ready to handle incoming requests.

Note: We also added a default endpoint to handle HTTP GET requests, which returns a simple message indicating that this is a gRPC service and to use a gRPC client to call the methods.

Summary: Microservices can use both HTTP and gRPC communication protocols to exchange data between services. HTTP is a widely used and well-established protocol that's easy to use and widely supported, while gRPC is a modern and high-performance protocol that supports multiple languages and is designed for efficient communication between microservices. The choice of protocol depends on the specific needs of the microservices architecture and the performance requirements of the system.

Comments

Post a Comment

Popular posts from this blog

Create Custom Form Control for ng-select in Angular

-
Image
How to Create Custom Form Control in Angular  Why we create custom form control ? Normally, we used to create custom form control for re-usability.  The best advantage is that to add common functionality and features in this custom form control and extend the functionality as per our need and requirement.  And we can use everywhere into the application. But this example will tell you how to create custom form control to extend the functionality of  angular ng-select component.  We are adding a feature for this control, multi selection along with checkbox. Before that, we need to know what is the basic syntax of creating custom form control in angular. So, we start by implementing the ControlValueAccessor interface from @angular/forms into the component. This interface has three functions that need to be implemented and one optional functional. writeValue(obj: any): void { } registerOnChange(fn: any): void { } registerOnTouched(f
Read more

Send API POST Request in MS SQL Server

-
To send an API POST request in MS SQL Server using multipart/form-data, you can use the following T-SQL code: Example of content type : multipart/form-data SQL DECLARE @url VARCHAR(200) = 'https://example.com/api'; DECLARE @boundary VARCHAR(50) = '---------------------------' + CAST(NEWID() AS VARCHAR(36)); DECLARE @param1Name VARCHAR(50) = 'name'; DECLARE @param1Value VARCHAR(50) = 'John Doe'; DECLARE @param2Name VARCHAR(50) = 'email'; DECLARE @param2Value VARCHAR(50) = 'johndoe@example.com'; DECLARE @param3Name VARCHAR(50) = 'file'; DECLARE @param3Value VARBINARY(MAX) = (SELECT BulkColumn FROM OPENROWSET(BULK 'C:\path\to\file.txt', SINGLE_BLOB) AS x); DECLARE @param4Name VARCHAR(50) = 'description'; DECLARE @param4Value VARCHAR(200) = 'This is a sample file'; DECLARE @formData NVARCHAR(MAX) = N'--' + @boundary + CHAR(13) + CHAR(10) +
Read more

Restrict Special Characters Using JavaScript By Copy,Paste

-
Restrict Special Characters using copy,paste events in JavaScript. Please follow these steps: 1. Create a textbox with the name of txtValidation and add event by the name of onpaste to that textbox. <asp:TextBox ID="txtValidation" runat="server" onpaste="return Validate(this.value);"></asp:TextBox> 2. Create a Function to that event.  <script type="text/javascript">         function Validate(Value) {             var pastedData = window.clipboardData.getData('Text');             var reg = /^[a-zA-Z0-9 ]*$/             if (!reg.test(pastedData)) {                 alert('Not Accept Special Characters');                 return false;             }         }     </script> Some of the special characters are hidden when you copy,paste it will not visible. If you want to restrict those special characters in sql database only, not in application. These Special Characters is not visible whe
Read more

Restrict Special Characters in Windows Application using c#

-
Image
Example : In this application it will remove all the special characters when we trying to copy paste the special characters. Lets see how it is possible with Copy,paste. Please follow these steps : 1. Create a New Windows Form with the name of 'Form1', and take one label with the name of 'lblName' and one textbox with the name of 'txtName' and one button with the name of 'btnValidate'. Please see below image. 2. Add a code in TextChanged event for that textbox. Here my textbox name is 'txtName' in that I have added a event like . private void txtName_TextChanged(object sender, EventArgs e) {       txtName.Text = RemoveSpecialCharacters(txtName.Text); } 3. In that event you observed method name of 'RemoveSpecialCharacters'.Basically it will remove all the special characters when you are copy paste in to the textbox.       private string RemoveSpecialCharacters(String inString)      
Read more

Delete Empty Rows or Null Rows in Datatable in C#

-
How to Delete Empty Rows or Null Rows in Datatable Example:  In this application we can see how to Delete Empty Rows or Null Rows in Datatable. Mostly this issue comes from while uploading the excel(.xls,.xlsx) file data into your sql table through datatable in windows application or web application. In rare cases,we can see while getting data from excel to datatable it will copies the empty rows also. Below Code. C# public DataTable DeleteEmptyRowsFromDataTable(DataTable dt) { for (int i = dt.Rows.Count - 1; i >= 0; i--) { if (dt.Rows[i][1] == DBNull.Value) dt.Rows[i].Delete(); } dt.AcceptChanges(); return dt; }
Read more

Angular CLI Commands - Cheat Sheet

-
Image
Angular CLI (Command Line Interface) is one of the powerful tool that allows you to perform a lot of actions in an Angular project by using simple commands. We can use the CLI tool directly in a command shell, or indirectly through an interactive UI such as Angular Console.  The Best Advantage is that, can avoid manual process to create lot of stuff like create components, directives, feature modules, services... etc.  It automatically recompiles the source code files and refreshes the app in the browser.  Let's see, how to install CLI tool and what are those CLI commands. Installing the CLI is very quite easy. All we need to do, is to run the below command in Terminal or Console. It will install the CLI tool globally with respective version. Here we need to know two things before installing the CLI tool. We can install latest version or any version released by angular team based on your project need. Check the Versions list.✋ Angular CLI Setup  1. Globally - To install CLI tool g
Read more

Difference of High-Level Design (HLD) and Low-Level Design (LLD)

-
High-Level Design (HLD) and Low-Level Design (LLD) are software design concepts that are not specific to any programming language. However, to illustrate the differences between HLD and LLD, we can use C# programming language examples. Suppose we are designing a software system that involves creating a payment gateway application in C#.  Here are examples of HLD and LLD for this system: High-Level Design (HLD): Define the functional requirements of the payment gateway system, such as processing payment transactions, handling errors, and providing a user interface. Identify the non-functional requirements, such as performance, scalability, and security. Identify the key components of the payment gateway system, such as payment processing engine, database, user interface, and error handling. Create an architecture diagram that shows how these components will fit together to form the payment gateway system. In HLD, the focus is on defining the system's overall structure and architectu
Read more

Clean Architecture in a C#

-
Clean Architecture is a software design pattern that separates the application into independent layers, where each layer has a specific responsibility and interacts with other layers through well-defined interfaces. The main goal of clean architecture is to create a flexible, testable, and maintainable software system. By following this architecture, we have created a flexible, testable, and maintainable software system. The domain layer is independent of any external dependencies and frameworks, making it easy to test and change without affecting other layers. The application layer contains the use cases or application-specific logic, which is decoupled from the infrastructure Here's an example of how to implement Clean Architecture in a C# project: 1. Domain Layer: This layer contains the business logic and domain-specific entities. It should be independent of any external dependencies and frameworks. C#
Read more