gRPC
gRPC is an open-source remote procedure call framework for defining services and invoking them across process or network boundaries, commonly using Protocol Buffers and HTTP/2.
gRPC Microservices in Go
An open-source framework for implementing remote procedure calls with generated service bindings and protocol-buffer serialization, commonly transported over HTTP/2.
- How it is used
- Connects independently deployed microservices through generated client stubs and server bindings.
- How deep it goes
- Defines the framework and sketches its transport, serialization, trade-offs, and stub workflow; defers detailed generation and compatibility work.
- Examples
- Uses an e-commerce Checkout service calling Cart, Shipping, and Payment through generated Go stubs.
- What you can do after
- Build it from scratch as Go microservice communication using protocol-buffer definitions and generated stubs within a production-oriented workflow.
Learn Go with Pocket-Sized Projects
gRPC is a remote procedure call framework for communicating between distributed services.
- How it is used
- Connects services, devices, and applications through efficient remote procedure calls and lightweight serialized messages.
- How deep it goes
- Explains API definitions, code generation, contexts, endpoint layering, status errors, manual testing, and integration testing.
- Examples
- Uses a habits tracker with create, list, tick, and status endpoints, plus grpcurl commands for manual requests.
- What you can do after
- Builds and tests a Go gRPC service with generated APIs, domain validation, mapped errors, and grpcurl-based manual calls.
Read how Learn Go with Pocket-Sized Projects explains gRPC →
ASP.NET Core in Action, 3e
gRPC is a high-performance, language-independent remote procedure call framework for service-to-service communication.
- How it is used
- Positions gRPC as an efficient binary RPC option for server-to-server communication in ASP.NET Core.
- How deep it goes
- Defines gRPC and contrasts it with HTTP APIs and WCF, but does not explain contracts, transport, or implementation steps.
- Examples
- Shows server-to-server binary APIs and an ad hoc RPC service alongside HTML and REST API clients.
- What you can do after
- Evaluate whether gRPC fits an efficient server-to-server API or a contract-based RPC migration from WCF.
Troubleshooting Java, Second Edition
gRPC is a remote procedure call framework and protocol for invoking operations across services, commonly using HTTP/2 and Protocol Buffers.
- How it is used
- Uses gRPC as a communication pattern to investigate service failures, compatibility problems, and distributed outages.
- How deep it goes
- Explains gRPC tradeoffs, failure modes, and Protobuf contracts, emphasizing diagnosis rather than detailed framework implementation.
- Examples
- Uses Protobuf schemas, enum changes, deserialization errors, downstream delays, retry storms, logs, metrics, and tracing tools.
- What you can do after
- Diagnose gRPC failures with structured logs, distributed tracing, protocol debuggers, and compatibility checks.
Read how Troubleshooting Java, Second Edition explains gRPC →
Go in Practice, Second Edition
gRPC is a high-performance remote procedure call framework and protocol for defining services and invoking them across networks.
- How it is used
- Defines strongly contracted API communication for microservices and networked services as an alternative to REST.
- How deep it goes
- Moves from RPC rationale through protocol-buffer trade-offs to proto3 definitions, code generation, server setup, client calls, and streaming.
- Examples
- Uses a proto3 chat service, protoc generation, a Python server, a Go client, timestamps, and a streaming response declaration.
- What you can do after
- Build it from scratch by defining proto3 contracts, generating service code, registering a server, dialing it, and invoking RPCs.
Building Web APIs with ASP.NET Core
gRPC is a high-performance, cross-platform remote procedure call framework for communication between distributed applications.
- How it is used
- Positions high-speed, strongly typed communication among distributed applications and microservices as an alternative to REST and GraphQL.
- How deep it goes
- Defines transport and serialization choices, explains performance and limitations, and sketches protobuf and authorization changes without showing implementation code.
- Examples
- Uses board-game domain and mechanic operations, protobuf request and response messages, and Moderator-only update methods.
- What you can do after
- Implement gRPC service features in an ASP.NET Core application using Grpc.AspNetCore, protobuf message types, and role-based authorization.
Read how Building Web APIs with ASP.NET Core explains gRPC →
Quarkus in Action
gRPC is a high-performance, open-source remote procedure call framework for communication between distributed services with support for multiple programming languages.
- How it is used
- Supports efficient service-to-service communication in cloud-native and microservice applications.
- How deep it goes
- Explains latency mechanisms, contracts, Quarkus generation, stubs, and an inventory implementation without detailing wire-level internals.
- Examples
- Uses an InventoryService contract with add and remove operations, generated Java artifacts, and an inventory command-line client.
- What you can do after
- Build gRPC services in Quarkus from proto contracts and consume them through generated client stubs.
Designing Deep Learning Systems: A guide for software engineers
An open-source remote procedure call framework that enables communication between distributed services.
- How it is used
- Implements concise network interfaces for dataset management and remote model-training services.
- How deep it goes
- Defines RPC methods and traces dataset creation, but stops short of explaining gRPC internals or framework configuration.
- Examples
- Uses dataset creation, updates, summaries, listing streams, MinIO storage, and downloadable data URLs.
- What you can do after
- Apply gRPC by defining typed service methods for distributed APIs and returning structured responses or streams.
Read how Designing Deep Learning Systems: A guide for software engineers explains gRPC →
Logs and Telemetry
gRPC is a high-performance remote procedure call framework that commonly uses HTTP/2 and Protocol Buffers for communication.
- How it is used
- Carries OpenTelemetry telemetry between applications, collectors, aggregation points, and analysis services.
- How deep it goes
- Explains transport formats and ecosystem placement but does not descend into RPC service implementation.
- Examples
- Shows telemetry flowing from applications through Fluent Bit or another OpenTelemetry component to compliant services.
- What you can do after
- Evaluate gRPC as the preferred OTLP transport and recognize JSON as its fallback alternative.
LLMs in Production
gRPC is an open-source remote procedure call framework and protocol for invoking operations across process or network boundaries.
- How it is used
- Improves inference latency and throughput by reducing the bytes transmitted between clients and model services.
- How deep it goes
- Explains binary serialization and client setup, while deferring full API implementation and .proto design.
- Examples
- Uses a Python MLServer client that encodes a message, constructs an inference request, serializes it, and opens a gRPC channel.
- What you can do after
- Apply gRPC through an existing inference service or build an API with grpcio and .proto files.
Related concepts
- protocol bufferuses · Protocol Buffers is a language- and platform-neutral schema system and compact binary serialization format for structured data, with support for generated code.
- RESTalternative to · REST is an architectural style for distributed hypermedia systems that organizes interactions around resources and representations through constraints including a uniform interface, stateless communication, cacheability, and layered components.
- remote procedure callimplements · A remote procedure call is a communication technique in which a program invokes an operation executed in another process or system, typically through an interface resembling a local procedure call.
- http/2uses · HTTP/2 is a version of the Hypertext Transfer Protocol that uses binary framing to multiplex request and response streams over a connection.
- grpcurlused by · grpcurl is a command-line tool for inspecting gRPC service definitions and invoking methods on gRPC servers.
- HTTPuses · HTTP is a standardized application-layer protocol that defines request-and-response messages for transferring resource representations between networked systems.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.