CRUD Operation And Microservice Communication Using gRPC In .NET Core 6 Web API

Introduction

In this example, we’re creating CRUD operations and microservice communication using gRPC in a .NET Core 6 Web API. gRPC is a high-performance, cross-platform communication framework that allows you to define and generate strongly-typed service contracts and APIs. In this example, we’ll create a simple gRPC service for CRUD operations and then communicate with it from a Web API microservice.

Step 1: Create the gRPC Service

1. Create a new .NET Core 6 Class Library project for your gRPC service.
2. Add the required NuGet packages:

• Grpc.AspNetCore for gRPC server-side functionality.
• Google.Protobuf for Protocol Buffers.
• Grpc.Tools for code generation.

1. Define your gRPC service contract in a .proto file. For example, let’s create a file named TodoService.proto:

syntax = "proto3";

service TodoService {
    rpc GetTodos (Empty) returns (TodoList);
    rpc AddTodo (Todo) returns (Todo);
    rpc UpdateTodo (UpdateTodoRequest) returns (Todo);
    rpc DeleteTodo (TodoId) returns (Empty);
}

message Empty {}

message Todo {
    int32 id = 1;
    string title = 2;
    bool completed = 3;
}

message TodoId {
    int32 id = 1;
}

message TodoList {
    repeated Todo todos = 1;
}

message UpdateTodoRequest {
    int32 id = 1;
    string title = 2;
    bool completed = 3;
}

4. Build the project. This will generate a C# code based on the .proto file.
5. Implement your gRPC service using the generated code. Create a class that inherits from TodoService.TodoServiceBase and implement the methods.

Step 2: Create the Web API Microservice

1. Create a new .NET Core 6 Web API project.
2. Add the required NuGet packages:

• Grpc.Net.Client for gRPC client-side functionality.

1. In your Startup.cs, configure gRPC service and clients:

using Grpc.Net.Client;

public void ConfigureServices(IServiceCollection services)
{
    // ... other configurations

    services.AddGrpc();
    services.AddSingleton(s => new GrpcChannel(GrpcChannel.ForAddress("https://localhost:5001")));
}

4. Create a controller for your Web API, and in the controller’s action methods, use the gRPC client to communicate with the gRPC service:

using Grpc.Net.Client;
using TodoService;

[ApiController]
[Route("api/[controller]")]
public class TodoController : ControllerBase
{
    private readonly GrpcChannel _grpcChannel;

    public TodoController(GrpcChannel grpcChannel)
    {
        _grpcChannel = grpcChannel;
    }

    [HttpGet]
    public async Task<ActionResult<TodoList>> Get()
    {
        var client = new TodoService.TodoServiceClient(_grpcChannel);
        var response = await client.GetTodosAsync(new Empty());
        return Ok(response);
    }

    // Implement other CRUD methods similarly
}

Step 3: Test the Microservices

1. Start your gRPC service.
2. Start your Web API microservice.
3. Use Postman or any other tool to send HTTP requests to your Web API endpoints.
4. Verify that your Web API methods are correctly communicating with the gRPC service to perform CRUD operations.

This is a basic example to demonstrate gRPC communication between microservices. In a real-world scenario, you’d implement proper error handling, data validation, authentication, and more. Additionally, gRPC also supports advanced features like streaming and custom authentication methods, which you can explore based on your application’s requirements.