book

Microservices Communication in .NET Using gRPC

Name: Microservices Communication in .NET Using gRPC
Author: Fiodar Sazanavets
ISBN: 9781803236438

by Fiodar Sazanavets

February 2022

Intermediate to advanced

486 pages

9h 9m

English

Packt Publishing

Read now

Unlock full access

Microservices Communication in .NET Using gRPC
ContributorsAbout the authorAbout the reviewer
Preface
Who this book is forWhat this book coversTo get the most out of this bookDownload the example code filesCode in ActionDownload the color imagesConventions usedGet in touchShare Your Thoughts
Section 1: Basics of gRPC on .NET
Chapter 1: Creating a Basic gRPC Application on ASP.NET Core
Technical requirementsIntroduction to gRPCgRPC on ASP.NET CoreUsing gRPC in your own distributed ASP.NET Core applicationPreparing your systemSetting up your environment on WindowsSetting up your environment on MacSetting up your environment on LinuxDownloading the .NET SDK (all operating systems)Setting up a gRPC serverInitializing an ASP.NET Core project via an IDEAdding gRPC server components to an ASP.NET Core projectAdding some code to use gRPC componentsSetting up a gRPC clientInitializing the project for the client applicationAdding gRPC client components to the applicationApplying gRPC client components to the codeUnderstanding how proto files generate C# codeWhere is auto-generated code stored?Modifying Protobuf namespacesSharing a proto file between the client and the serverCreating a shared class libraryAdding shared gRPC components to the class librarySharing gRPC dependencies between different projectsRunning a gRPC service on MacConfiguring server-side componentsModifying the client-side configurationSummaryQuestionsFurther reading
Chapter 2: When gRPC Is the Best Tool and When It Isn't
Technical requirementsWhy gRPC is a great tool for microservicesSetting up a solution and shared dependenciesSetting up the status manager microserviceSetting up a REST API gateway serviceLaunching the distributed applicationHow gRPC can be a good tool for asynchronous communication Adding client-streaming and server-streaming gRPC endpointsConfiguring the gRPC client for asynchronous communicationTesting asynchronous gRPC endpointsWhy gRPC is not the best tool for browsersSetting up a Blazor WebAssembly gRPC clientModifying the gRPC server to enable gRPC-WebLaunching the gRPC-Web applicationWhere SignalR would beat gRPCSetting up a SignalR applicationAdding a SignalR client and launching the applicationSummaryQuestionsFurther reading
Chapter 3: Protobuf – the Communication Protocol of gRPC
Technical requirementsThe RPC types supported by gRPCThe RPC types that Protobuf supportsMaking comments in ProtobufReviewing the native Protobuf data typesInteger data typesNon-integer numeric typesNon-numeric data typesEnumsNested messagesUsing collections in ProtobufRepeated fieldsMap fieldsUsing special keywords in ProtobufHow the oneof keyword can make communication more efficientCustomizing the behavior with the option keywordReferencing other proto filesImporting external proto packagesReferencing internal proto filesUsing proto files as relaysSummaryQuestionsFurther reading
Section 2: Best Practices of Using gRPC
Chapter 4: Performance Best Practices for Using gRPC on .NET
Technical requirementsWhy you need to reuse a gRPC channel Setting up the server applicationSetting up the client applicationComparing the performance of different client typesHow to not get held up by a concurrent stream limitConfiguring connection concurrency on the gRPC clientComparing the performance between a single connection and multiple connectionsEnsuring that your connection remains aliveSetting up keep-alive pings on the gRPC clientWhen streaming is better than individual callsSetting up a bi-directional streaming RPCMonitoring the performance of the bi-directional streaming callUsing binary payloads to decrease the data's sizeAdding binary fields to ProtobufSummaryQuestionsFurther reading
Chapter 5: Applying Versioning to the gRPC API
Technical requirementsWhy an API versioning strategy is importantCreating a server applicationImplementing the server-side gRPC componentsCreating the gRPC client applicationImplementing the gRPC client logicVerifying that the client can talk to the serverWhat the sequence numbers in the proto file representModifying the Protobuf definition in the server applicationModifying the Protobuf definition in the client applicationLaunching modified applicationsWhy you must not modify existing fields in future Protobuf versionsModifying Protobuf definitions on the client sideLaunching the applicationsMaking further changes to the client applicationRe-launching the applicationsHow to deprecate old, unused fields in gRPCApplying the reserved keyword to the server-side Protobuf interfaceTesting the applicationHow to factor in API versioning at the design stageAdding multiple Protobuf versions to the server applicationAllowing the server application to use multiple Protobuf versionsMaking the gRPC client implementation version-specificMaking a gRPC call to a versioned endpointSummaryQuestionsFurther reading
Chapter 6: Scaling a gRPC Application
Technical requirementsIntroduction to load balancingAdding shared gRPC dependenciesCreating a shared library for server-side application instancesCreating multiple instances of the server-side applicationCreating a client applicationRunning a load-balanced applicationClient-side load balancing with gRPCUpdating the NuGet packageEnabling client-side load balancing componentsEnabling a DNS resolver for the load balancerUsing a static resolver for the load balancerCreating custom load balancers and resolversProxy load balancing with gRPCBuilding a web application to act as a proxyLaunching the HTTP/2 proxySummaryQuestionsFurther reading

Section 3: In-Depth Look at gRPC on .NET
Chapter 7: Using Different Call Types Supported by gRPC
Technical requirementsMaking unary calls on gRPCSetting up shared gRPC dependenciesCreating server-side implementations of the Protobuf definitionsBuilding the gRPC clientApplying different types of client-side call implementationsUsing gRPC dependencies in the client applicationTesting different types of unary call endpointsStreaming data from the clientAdding a client-streaming call to the server applicationAdding client logic for a client-streaming gRPC callReading streams from the serverAdding a server-streaming RPC to ProtobufSetting up a server-streaming call on the server sideMaking a server-streaming call from a gRPC clientEnabling bi-directional streamingEnabling server-side components for bi-directional streamingAdding a client-side implementation of a bi-directional streaming callTesting how to stream gRPC callsSummaryQuestionsFurther reading
Chapter 8: Using Well-Known Types to Make Protobuf More Handy
Technical requirementsUsing nullable types in ProtobufSetting up a gRPC server applicationExamining auto-generated code for wrapper fieldsAdding logic to gRPC server applicationSetting up shared dependenciesSetting up the gRPC clientRunning the applicationUsing dates and times in ProtobufAdding timestamp and duration to the serverApplying changes to the gRPC client and launching the appExchanging empty messagesAdding the Empty data type to the server-side applicationApplying an Empty object on the clientUsing loosely typed fields in a Protobuf messageAdding Any and Value data types to the gRPC serverPopulating the Any and Value fields from the gRPC clientSummaryQuestionsFurther reading
Chapter 9: Securing gRPC Endpoints in Your ASP.NET Core Application with SSL/TLS
Technical requirementsConfiguring the gRPC client and server for unencrypted communicationThe role of TLS certificatesSetting up a gRPC service applicationRemoving TLS on both HTTP/1.1 and HTTP/2Exposing Protobuf definitions to clientsBuilding the client for gRPC communicationAdding the remaining client logicCreating and trusting a self-signed certificateThe basics of a TLS certificateTrusting a default development certificateCreating a self-signed certificate on Windows using PowerShellCreating a self-signed certificate on Unix using OpenSSLApplying a certificate on ASP.NET CoreTesting custom certificates and HTTPS redirectionApplying certificate authentication on the gRPC client and serverConfiguring the gRPC server for certificate authenticationEnabling certificate authentication on the gRPC clientTesting certificate authenticationSummaryQuestionsFurther reading
Chapter 10: Applying Authentication and Authorization to gRPC Endpoints
Technical requirementsSetting up the authentication backendOpenID Connect and OAuth flowConfiguring IdentityServer4Adding SSO users, roles, and clientsForcing login redirect on a web applicationRestricting gRPC endpoints to authenticated usersSetting up shared gRPC dependenciesSetting up the gRPC serverEnabling gRPC client functionalityRestricting endpoints to authorized users onlyConfiguring SSO provider to insert role claim into the JWTApplying different authorization rules to different gRPC endpointsApplying gRPC client changesSummaryQuestionsFurther reading
Chapter 11: Using Logging, Metrics, and Debugging in gRPC on .NET
Technical requirementsDebugging gRPC client components inside a .NET applicationSetting up shared gRPC dependenciesAdding a gRPC service application and getting it to display detailed errorsAdding a gRPC client with additional debugging capabilitiesViewing gRPC error information on the clientDebugging gRPC server components inside a .NET applicationViewing the debug output on the gRPC server consoleApplying logs to gRPCConfiguring a logger on the gRPC clientApplying a logger on the gRPC serverTesting our log outputApplying metrics to gRPCConfiguring metrics on the gRPC serverEnabling metric collection on the gRPC clientViewing gRPC metricsSummaryQuestionsFurther reading
Assessments
Chapter 1, Creating a Basic gRPC Application on ASP.NET CoreChapter 2, When gRPC Is the Best Tool and When It Isn'tChapter 3, Protobuf – the Communication Protocol of gRPCChapter 4, Performance Best Practices for Using gRPC on .NETChapter 5, Applying Versioning to the gRPC APIChapter 6, Scaling a gRPC ApplicationChapter 7, Using Different Call Types Supported by gRPCChapter 8, Using Well-Known Types to Make Protobuf More HandyChapter 9, Securing gRPC Endpoints in Your ASP.NET Core Application with SSL/TLSChapter 10, Applying Authentication and Authorization to gRPC EndpointsChapter 11, Using Logging, Metrics, and Debugging in gRPC on .NET
Why subscribe?
Other Books You May EnjoyPackt is searching for authors like youShare Your Thoughts

Content preview from Microservices Communication in .NET Using gRPC

Chapter 1: Creating a Basic gRPC Application on ASP.NET Core

In this chapter, we will learn how to build a basic ASP.NET Core server application that uses gRPC. We will also build a basic console application that will act as a gRPC client.

The main objectives of this chapter are to introduce you to gRPC and to show you how easy it is to set up and use as a communication mechanism between separate services inside a distributed application. This would especially be relevant in a microservice architecture, where many different services act as one application with many moving components. You will see that using gRPC for communication between separate applications is almost as easy as calling methods inside the same application.

In this chapter, ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781803236438

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Microservices Communication in .NET Using gRPC

by Fiodar Sazanavets

Chapter 1: Creating a Basic gRPC Application on ASP.NET Core

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.