Using gRPC in Microservices Communication with .Net 5

Explore how to build gRPC in Asp.Net 5 projects by creating a HelloWorld api, developing a protobuf file for a contract-first api, and implementing a gRPC service with dependency injection.

Inherit the generated gRPC service class and override the SayHello method to implement server logic, using asp.net features and dependency injection, to return a HelloResponse with a Hello message.

Configure gRPC in an ASP.NET project by registering dependency injection with AddGrpc in Startup.ConfigureServices and mapping the gRPC service in Startup.Configure endpoints to run as a gRPC server.

Create a GrpcHelloWorldClient console application in C# to call a gRPC server, generating a client from proto definitions, configuring packages, and aligning target framework.

Consume the Grpc HelloService API from a client console application by creating a GrpcChannel and a HelloServiceClient. Send a HelloRequest via SayHelloAsync and display the server's response.

Scaffold a gRPC server quickly using Visual Studio's gRPC Service template, generating code from proto files, including greet.proto, and startup configurations for http2 with asp.net core.

Consume the Grpc GreeterService API from a client console application using GrpcChannel, connect to the server, send a hello request, and read the reply with debugging and breakpoints.

Perform service discovery using grpc reflection with the grpcurl command-line tool. Register the reflection package in startup, configure endpoints, and describe services and methods on the local server for testing.

Create a new solution and gRPC-based ASP.NET Core microservice project, configure dependencies, protoc, and Kestrel hosting, and verify endpoints expose the gRPC service on port 5001.

Set up a product database for a gRPC microservice using EF Core in-memory database in a .NET 5 project, define Product and ProductsContext, and configure use in-memory database named 'Products'.

Seed an in-memory product database in a .NET 5 gRPC microservice by creating a product context and seeding initial data at startup through dependency injection.

Develop a proto file to expose CRUD services for products using gRPC in .Net 5, defining product messages and server streaming to get all products with client streaming bulk inserts.

Generate the proto service class from the product proto file in the product gRPC microservice by importing google protobuf well-known types and configuring the proto.

Develop a gRPC product service class, inject the database context and logging, implement the get product method, and map data to a product model.

Explore how to consume the GetProductAsync method via gRPC from a client console app using a channel and product service client in a .NET 5 microservices setup.

Consume the get all products server streaming method from the client console app, iterating streaming responses from the product service and printing each product to the console.

Implement automapper in the product grpc microservice by mapping core product entities to product models, handling timestamp conversions, and configuring dependency injection in startup.

Develop and implement ProductService UpdateProductAsync and DeleteProductAsync methods in a gRPC microservices setup using .NET 5. Map product models, verify existence, apply updates or deletions, and return a status response.

Explore exception handling in gRPC service methods of a .NET 5 product microservice, including not-found errors in the get product, and enable tracing, logging, and startup configuration for DI.

Learn to implement and configure logging in gRPC service methods within .NET 5 microservices, including log level settings, injecting ILogger, and using a logger factory.

Demonstrate consuming updateProductAsync and deleteProductAsync server methods from a client console to update a product and remove one, showing success responses in the console.

Develop a client-streaming insert bulk product method in a ProductService using gRPC and .NET 5, read client stream models, convert to core products, save to database, and return insert result.

Learn to consume a client streaming insert bulk product server method from a .NET 5 gRPC microservices client console app, including streaming multiple products and handling the server response.

Build a product worker service to generate and insert products into ProductGrpc microservices, consume gRPC methods, configure appsettings.json, generate products with ProductFactory, and implement logging on both client and server.

Create a product worker service project in a gRPC microservices solution, featuring a local time-interval worker with dependency injection, configuration, and logging, using appsettings.json for settings.

Add a connected service and portable file to the product worker service project to generate a client for consuming product services.

Build a shopping cart gRPC server using a code-first microservice approach, with an in-memory EF database, proto service generation, AutoMapper, and client streaming to add items and expose CRUD operations.

Create a gRPC microservice shopping cart using .NET 5 with an Entity Framework in-memory database, modeling shopping cart and shopping cart item with a configured context and dependency injection.

Seed an in-memory database for shopping cart data using Entity Framework Core in a .NET 5 gRPC microservice. Initialize seeding at startup to populate carts and items.

Generate a proto service class from the shopping cart proto file in ShoppingCartGrpc to enable gRPC communication and generate service stubs for a .NET 5 project.

Implement AutoMapper in the ShoppingCartService to map cart entities to gRPC models, by creating a ShoppingCartProfile, configuring item and cart mappings, and registering AutoMapper via dependency injection in startup.

Develop and implement the AddItemIntoShoppingCart client-streaming gRPC server method to add items into a shopping cart, handling cart retrieval, item existence, quantity updates, discount checks, and persistence.

Build a discount gRPC microservice for inter-service communication to calculate each cart item price in the shopping cart, including creating proto definitions, implementing DiscountService, and wiring the client in startup.

Develop a discount data model and context for a gRPC microservice in .NET 5, creating a discount entity with id and code and storing discounts in a static in-memory list.

Develop a new discount.proto ProtoBuf file to expose the get discount service in the discount ERP SeaMicro microservice, defining the request with a discount code and returning the discount id.

Generate a proto service class from the discount proto file in discount grpc, then build the .NET 5 project to produce the generated class and base class for discount service.

Develop a DiscountService class to implement gRPC proto service methods, read from a static discount data store, map to a discount model, and log operations during startup configuration.

Learn to consume a discount gRPC service from a shopping cart microservice by configuring connected services, generating a client from the discount proto, and invoking discount methods.

Build a shopping cart worker service that retrieves products and adds items by consuming ProductGrpc and ShoppingCartGrpc microservices, using server and client streaming.

Create a shopping cart worker service in a gRPC microservices solution on .NET 5, running as a background service with dependency injection, configuration, and logging.

Add connected services and generate gRPC clients for the shopping cart worker service by integrating product and shopping cart services with portable proto files and client references.

Configure the shopping cart worker service with appsettings.json, inject configuration via Microsoft.Extensions.Configuration, and manage delay-based tasks for product and shopping cart integration.

Consume product and shopping cart gRPC server methods from a shopping cart worker by creating a channel and client, getting or creating a cart, retrieving products, and adding items.

Develop the shopping cart workflow by streaming products from the product service and streaming cart items into the cart service, creating the cart as needed.

Run grpc server microservices for product, shopping cart, and discount workloads, verify replication, and start multi project deployments to observe cart items and discounts.

Authenticate gRPC services with IdentityServer4 using OAuth 2.0 and JWT bearer tokens to secure ShoppingCartGrpc methods, and configure clients, resources, scopes, and test users.

Build a standalone identity server authentication microservice using IdentityServer4 to secure a shopping cart within a .NET 5 microservices setup, including project creation, port configuration, and launch settings.

Secure shopping cart gRPC services in a .NET 5 microservices setup by integrating IdentityServer4 OAuth 2.0 and JWT, configuring authentication and authorization in startup and protecting the API with authorization.

Test access to shopping cart gRPC services in a multi-project microservices setup, create a shopping cart, add items, and validate token-based authorization to prevent unauthorized access.

Learn how to pass a token in gRPC headers for shopping cart services in .NET 5, secure get-or-create operations, and add authorization metadata to gRPC calls.

Run an entire microservices application locally to see the big picture, starting the product, product worker, and shopping cart services, generating and consuming products to build a shopping cart.