book

Microservices Communication in .NET Using gRPC

by Fiodar Sazanavets

February 2022

Intermediate to advanced

486 pages

9h 9m

English

Packt Publishing

Read now

Unlock full access

ContributorsAbout the authorAbout the reviewer
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
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
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
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
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
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
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

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
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
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
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
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
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
Other Books You May EnjoyPackt is searching for authors like youShare Your Thoughts

Content preview from Microservices Communication in .NET Using gRPC

Preface

This book explains how to use all the fundamental components of gRPC on .NET. As well as covering the core technical functionality of gRPC, this book also explains the best practices of using it.

gRPC is an efficient mechanism of communication over the web that was originally developed by Google. It has now been accepted as one of the web standards. As it runs over HTTP/2, it is much faster than the standard HTTP communication. gRPC is especially suitable for facilitating direct communication between microservices inside a distributed application.

RPC stands for remote procedure call, so applying it in the code to call endpoints on a remote server is just as easy as calling functions and methods inside an application. gRPC is standardized, ...

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.

Start your free trial

Pro Microservices in .NET 6: With Examples Using ASP.NET Core 6, MassTransit, and Kubernetes

Publisher Resources

ISBN: 9781803236438Supplemental Content

Microservices Communication in .NET Using gRPC

by Fiodar Sazanavets

Preface

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.

You might also like

Pro Microservices in .NET 6: With Examples Using ASP.NET Core 6, MassTransit, and Kubernetes

Microservices .NET Core Masterclass

Building Microservices with ASP.NET Core

Web API Development with ASP.NET Core 8

Publisher Resources

Preface

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.

You might also like

Pro Microservices in .NET 6: With Examples Using ASP.NET Core 6, MassTransit, and Kubernetes

Microservices .NET Core Masterclass

Building Microservices with ASP.NET Core

Web API Development with ASP.NET Core 8

Publisher Resources

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.