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.
Designing AI Systems
gRPC is a high-performance remote procedure call framework that uses service definitions and serialized messages for communication between software components.
- How it is used
- Uses gRPC for internal service calls behind an SDK and gateway, while external clients communicate over HTTPS.
- How deep it goes
- Explains service schemas, generated clients, request conversion, gateway routing, and streaming across protocol boundaries.
- Examples
- Illustrates a session service contract and a model client that converts Python messages, calls a stub, and returns a dataclass.
- What you can do after
- Evaluate gRPC for internal service communication and understand how clients, gateways, and streaming fit together.
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.
Fast by Default
gRPC is a remote procedure call framework that uses service contracts, generated clients, and efficient network protocols for interservice communication.
- How it is used
- Optimizes data transmission between internal services and supports high-throughput microservice communication.
- How deep it goes
- Explains Protocol Buffers, HTTP/2, payload size, parsing, and migration pressures without detailing implementation code.
- Examples
- Uses LinkedIn’s Protocol Buffers rollout, Netflix’s RPC migration, and a REST–GraphQL–gRPC comparison.
- What you can do after
- Evaluate gRPC for internal services by comparing serialization efficiency, transport, contracts, compatibility, and tooling needs.
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.
Also covered in
- Microservices Patterns, Second EditionIn early access (MEAP)
- Pro ASP.NET Core 7, Tenth Edition
- Digital Twins in Action
- Akka in Action, Second Edition
- Kubernetes in Action, Second Edition
- Terraform in Depth: Infrastructure as Code with Terraform and OpenTofu
What to know first
- http/2HTTP/2 is a version of the Hypertext Transfer Protocol that uses binary framing to multiplex request and response streams over a connection.
- JSONJSON is a language-independent text-based data-interchange format that represents structured values using objects, arrays, strings, numbers, booleans, and null.
- RESTREST is an architectural style for distributed systems that organizes interactions around identifiable resources and their representations, using a uniform interface and constraints such as statelessness and cacheability.
- HTTPHTTP is an application-layer protocol that defines request-and-response communication for transferring resource representations and related metadata between networked systems.
Related concepts
- protobufuses · Protocol Buffers is a language- and platform-neutral system for defining structured data schemas and serializing messages in a compact binary format, with support for generated code.
- RESTalternative to · REST is an architectural style for distributed systems that organizes interactions around identifiable resources and their representations, using a uniform interface and constraints such as statelessness and cacheability.
- remote procedure callimplements · A remote procedure call is a communication mechanism in which a program invokes an operation executed by another process or system, often through an interface resembling a local 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.
- clientused by · A client is a person, organization, device, or software component that receives or uses a product, service, resource, or functionality provided by another party or system.
Questions about gRPC
What is 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.
Which Manning books explain gRPC?
gRPC Microservices in Go, Designing AI Systems, Learn Go with Pocket-Sized Projects, ASP.NET Core in Action, 3e, Fast by Default, Troubleshooting Java, Second Edition, Go in Practice, Second Edition, Building Web APIs with ASP.NET Core and 4 more.
What should I know before learning gRPC?
Manning books that teach gRPC usually introduce http/2, JSON, REST and HTTP first.
What is the difference between gRPC and REST?
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. REST is an architectural style for distributed systems that organizes interactions around identifiable resources and their representations, using a uniform interface and constraints such as statelessness and cacheability.
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.











