Book Image

Microservices Communication in .NET Using gRPC

By : Fiodar Sazanavets
Book Image

Microservices Communication in .NET Using gRPC

By: Fiodar Sazanavets

Overview of this book

Explore gRPC's capabilities for faster communication between your microservices using the HTTP/2 protocol in this practical guide that shows you how to implement gRPC on the .NET platform. gRPC is one of the most efficient protocols for communication between microservices that is also relatively easy to implement. However, its official documentation is often fragmented and.NET developers might find it difficult to recognize the best way to map between C# data types and fields in gRPC messages. This book will address these concerns and much more. Starting with the fundamentals of gRPC, you'll discover how to use it inside .NET apps. You’ll explore best practices for performance and focus on scaling a gRPC app. Once you're familiar with the inner workings of the different call types that gRPC supports, you'll advance to learning how to secure your gRPC endpoints by applying authentication and authorization. With detailed explanations, this gRPC .NET book will show you how the Protobuf protocol allows you to send messages efficiently by including only the necessary data. You'll never get confused again while translating between C# data types and the ones available in Protobuf. By the end of the book, you’ll have gained practical gRPC knowledge and be able to use it in .NET apps to enable direct communication between microservices.

Related Content you might be interested in

Current Title:

Small book image
Microservices Communication in .NET Using gRPC
Fiodar Sazanavets
Feb, 2022 | 486 pages
Small book image
Practical gRPC
Joshua B Humphries | Robert Ross | David Konsumer | David Muto | Carles Sistare
Nov, 2019 | 169 pages
Small book image
Building Blazor WebAssembly Applications with gRPC
Václav Pekárek
Nov, 2022 | 196 pages
Small book image
gRPC Go for Professionals
Clément Jean
Jul, 2023 | 260 pages
Table of Contents (17 chapters)
Preface
Preface
Who this book is for
What this book covers
To get the most out of this book
Download the example code files
Code in Action
Download the color images
Conventions used
Get in touch
Share Your Thoughts
1
Section 1: Basics of gRPC on .NET
Section 1: Basics of gRPC on .NET
Free Chapter
2
Chapter 1: Creating a Basic gRPC Application on ASP.NET Core
Chapter 1: Creating a Basic gRPC Application on ASP.NET Core
Technical requirements
Introduction to gRPC
Preparing your system
Setting up a gRPC server
Setting up a gRPC client
Understanding how proto files generate C# code
Sharing a proto file between the client and the server
Running a gRPC service on Mac
Summary
Questions
Further reading
3
Chapter 2: When gRPC Is the Best Tool and When It Isn't
Chapter 2: When gRPC Is the Best Tool and When It Isn't
Technical requirements
Why gRPC is a great tool for microservices
How gRPC can be a good tool for asynchronous communication
Why gRPC is not the best tool for browsers
Where SignalR would beat gRPC
Summary
Questions
Further reading
4
Chapter 3: Protobuf – the Communication Protocol of gRPC
Chapter 3: Protobuf – the Communication Protocol of gRPC
Technical requirements
The RPC types supported by gRPC
Reviewing the native Protobuf data types
Using collections in Protobuf
Using special keywords in Protobuf
Referencing other proto files
Summary
Questions
Further reading
5
Section 2: Best Practices of Using gRPC
Section 2: Best Practices of Using gRPC
6
Chapter 4: Performance Best Practices for Using gRPC on .NET
Chapter 4: Performance Best Practices for Using gRPC on .NET
Technical requirements
Why you need to reuse a gRPC channel
How to not get held up by a concurrent stream limit
Ensuring that your connection remains alive
When streaming is better than individual calls
Using binary payloads to decrease the data's size
Summary
Questions
Further reading
7
Chapter 5: Applying Versioning to the gRPC API
Chapter 5: Applying Versioning to the gRPC API
Technical requirements
Why an API versioning strategy is important
What the sequence numbers in the proto file represent
Why you must not modify existing fields in future Protobuf versions
How to deprecate old, unused fields in gRPC
How to factor in API versioning at the design stage
Summary
Questions
Further reading
8
Chapter 6: Scaling a gRPC Application
Chapter 6: Scaling a gRPC Application
Technical requirements
Introduction to load balancing
Client-side load balancing with gRPC
Proxy load balancing with gRPC
Summary
Questions
Further reading
9
Section 3: In-Depth Look at gRPC on .NET
Section 3: In-Depth Look at gRPC on .NET
10
Chapter 7: Using Different Call Types Supported by gRPC
Chapter 7: Using Different Call Types Supported by gRPC
Technical requirements
Making unary calls on gRPC
Streaming data from the client
Reading streams from the server
Enabling bi-directional streaming
Summary
Questions
Further reading
11
Chapter 8: Using Well-Known Types to Make Protobuf More Handy
Chapter 8: Using Well-Known Types to Make Protobuf More Handy
Technical requirements
Using nullable types in Protobuf
Using dates and times in Protobuf
Exchanging empty messages
Using loosely typed fields in a Protobuf message
Summary
Questions
Further reading
12
Chapter 9: Securing gRPC Endpoints in Your ASP.NET Core Application with SSL/TLS
Chapter 9: Securing gRPC Endpoints in Your ASP.NET Core Application with SSL/TLS
Technical requirements
Configuring the gRPC client and server for unencrypted communication
Creating and trusting a self-signed certificate
Applying certificate authentication on the gRPC client and server
Summary
Questions
Further reading
13
Chapter 10: Applying Authentication and Authorization to gRPC Endpoints
Chapter 10: Applying Authentication and Authorization to gRPC Endpoints
Technical requirements
Setting up the authentication backend
Restricting gRPC endpoints to authenticated users
Restricting endpoints to authorized users only
Summary
Questions
Further reading
14
Chapter 11: Using Logging, Metrics, and Debugging in gRPC on .NET
Chapter 11: Using Logging, Metrics, and Debugging in gRPC on .NET
Technical requirements
Debugging gRPC client components inside a .NET application
Debugging gRPC server components inside a .NET application
Applying logs to gRPC
Applying metrics to gRPC
Summary
Questions
Further reading
15
Assessments
Assessments
Chapter 1, Creating a Basic gRPC Application on ASP.NET Core
Chapter 2, When gRPC Is the Best Tool and When It Isn't
Chapter 3, Protobuf – the Communication Protocol of gRPC
Chapter 4, Performance Best Practices for Using gRPC on .NET
Chapter 5, Applying Versioning to the gRPC API
Chapter 6, Scaling a gRPC Application
Chapter 7, Using Different Call Types Supported by gRPC
Chapter 8, Using Well-Known Types to Make Protobuf More Handy
Chapter 9, Securing gRPC Endpoints in Your ASP.NET Core Application with SSL/TLS
Chapter 10, Applying Authentication and Authorization to gRPC Endpoints
Chapter 11, Using Logging, Metrics, and Debugging in gRPC on .NET
Why subscribe?
16
Other Books You May Enjoy
Other Books You May Enjoy
Packt is searching for authors like you
Share Your Thoughts

Restricting gRPC endpoints to authenticated users

gRPC is primarily designed for the backend; therefore, in most cases, it won't be possible to redirect to an SSO login. There simply won't be a UI that we will be able to do it from.

But because the OpenID Connect workflow obtains a token that is then stored in the application, we can simply reuse this token to get the user-facing application to authenticate into the gRPC application that it needs to communicate with. We will now demonstrate how to do this.

Setting up shared gRPC dependencies

We will start by creating a library that both the client and the server will share. As we did in the previous chapters, we will do so to ensure that both the client and the server use identical Protocol Buffers (Protobuf) definitions. Follow these next steps:

  1. Navigate to the GrpcAuthentication solution folder and execute the following command to create a class library project:
    dotnet new classlib -o GrpcDependencies
    2. ...
Previous Section
End of Section 4
Next Section