Protocol buffer
Protocol Buffers is a language- and platform-neutral schema system and compact binary serialization format for structured data, with support for generated code.
Kafka Streams in Action, Second Edition
Protocol Buffers is a language-neutral, platform-neutral mechanism for serializing structured data using defined message schemas.
- How it is used
- Serializes Kafka event records through schemas, generated objects, Schema Registry serializers, and ksqlDB formats.
- How deep it goes
- Explains proto3 messages, numbered fields, defaults, imports, generated types, and Kafka configuration; defers full specification details.
- Examples
- Uses Avenger messages, imported Person and Company schemas, multi-event wrappers, and user-activity ksqlDB tables.
- What you can do after
- Apply it via Kafka Protobuf serializers, generated Java types, Schema Registry, imports, and ksqlDB format settings.
Read how Kafka Streams in Action, Second Edition explains protocol buffer →
Logs and Telemetry
Protocol Buffers is a language-neutral, platform-neutral mechanism for serializing structured data using generated code and compact binary messages.
- How it is used
- Carries OTLP telemetry payloads compactly when gRPC communication uses HTTP/2.
- How deep it goes
- Explains Protobuf3 through transport choices, fallback behavior, and compatibility limits rather than payload-schema internals.
- Examples
- Uses Fluent Bit OpenTelemetry listeners for logs, traces, and metrics, with JSON-over-HTTP/1.1 requests for inspectable testing.
- What you can do after
- Operate/configure OTLP endpoints by selecting gRPC-Protobuf or HTTP/JSON according to receiver capabilities.
Learn Go with Pocket-Sized Projects
Protobuf is a language-neutral, platform-neutral mechanism for serializing structured data using defined message schemas.
- How it is used
- Defines the messages and service API for a Go habit tracker whose clients communicate through gRPC.
- How deep it goes
- Works through proto3 headers, numbered fields, and request-response declarations, but stops short of detailing the encoding internals.
- Examples
- Uses a Habit message, CreateHabit request and response, and a grpcurl call to a local server.
- What you can do after
- Apply it via protoc and grpcurl to define Go gRPC messages, generate code, and call an endpoint manually.
Read how Learn Go with Pocket-Sized Projects explains protocol buffer →
gRPC Microservices in Go
Protocol Buffers is a language- and platform-neutral mechanism for defining and serializing structured messages and service interfaces.
- How it is used
- Defines and serializes messages exchanged between microservices over gRPC.
- How deep it goes
- Works through .proto definitions, stub generation, and basic binary encoding, but does not detail compatibility rules here.
- Examples
- Uses Order-to-Payment requests and responses, generated Go structs, and an integer-field encoding example.
- What you can do after
- Apply it via protoc to generate Go stubs for a defined gRPC service interface.
Read how gRPC Microservices in Go explains protocol buffer →
Akka in Action, Second Edition
Protocol Buffers is a language-neutral schema format and serialization mechanism for structured data with generated language bindings.
- How it is used
- Defines portable data and RPC contracts for Akka gRPC services and serializes events or clustered messages.
- How deep it goes
- Explains .proto messages, scalar mappings, service RPCs, compilation, and generated Scala artifacts without detailing schema-evolution procedures.
- Examples
- Uses a Cargo/AddCargo container service and MarketClosed, MarketOpened, and MarketCancelled Kafka event messages.
- What you can do after
- Build it from scratch by defining .proto messages and services, then compiling generated Scala classes and gRPC interfaces.
Read how Akka in Action, Second Edition explains protocol buffer →
Building Web APIs with ASP.NET Core
Protocol Buffers is a language-neutral serialization format and interface-definition system for structured messages and service contracts.
- How it is used
- Defines gRPC message formats and service contracts for a board-game API.
- How deep it goes
- Defines proto3 services and messages, then defers detailed proto3 syntax.
- Examples
- Uses grpc.proto with GetBoardGame, BoardGameRequest, and BoardGameResponse.
- What you can do after
- Build it from scratch by defining a proto3 contract and wiring generated gRPC server types into ASP.NET Core.
Read how Building Web APIs with ASP.NET Core explains protocol buffer →
Quarkus in Action
Protocol Buffers is a language-neutral serialization format that represents structured data using schemas and generated types.
- How it is used
- Defines compact typed messages and gRPC contracts for cloud-oriented service communication.
- How deep it goes
- Explains proto3 schemas, field numbering, generated Java builders, serialization, and gRPC stubs without detailing wire encoding.
- Examples
- Uses Car messages, InventoryService RPC methods, generated builders, and an inventory.proto contract.
- What you can do after
- Build typed messages and gRPC service contracts, then generate and use Java serialization code and communication stubs.
Go in Practice, Second Edition
- How it is used
- Structures strongly typed, cross-language messages and RPC contracts for microservices and HTTP API communication.
- How deep it goes
- Explains schemas, generated bindings, commands, servers, clients, and trade-offs, but does not detail binary encoding internals.
- Examples
- Uses a proto3 chat schema, protoc generation, a Python gRPC server, and a Go client calling RouteComments.
- What you can do after
- Build cross-language gRPC messages and services, generate bindings, run a server, and invoke it from a client.
Read how Go in Practice, Second Edition explains protocol buffer →
Cloud Observability in Action
Protocol Buffers is a language-neutral, platform-neutral mechanism for serializing structured data using schema-defined messages.
- How it is used
- Structures profiling data for pprof tools and supports compact storage, transfer, decoding, and analysis.
- How deep it goes
- Explains schema-based representation, efficiency, readability trade-offs, and decoding, but does not detail protobuf serialization internals.
- Examples
- Uses the pprof Profile schema and a protoc command that finds main.slowTask in decoded profile data.
- What you can do after
- Diagnose protobuf-encoded profiling data with protoc and select supporting tools for inspection or API work.
Read how Cloud Observability in Action explains protocol buffer →
Latency
Protocol Buffers is a cross-platform binary serialization format commonly used for encoding messages in remote procedure calls.
- How it is used
- Uses binary message serialization at remote procedure call boundaries and in latency-sensitive application workflows.
- How deep it goes
- Explains serialization costs, memory representation, fields, precision, and byte order, but stops short of protocol-buffer encoding internals.
- Examples
- Uses an online-store order with order ID and quantity, represented as a Rust struct and serialized for JSON, RPC, or storage.
- What you can do after
- Evaluate serialization work as a source of latency, CPU consumption, and memory-copy overhead across application boundaries.
Related concepts
- gRPCused by · 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.
- JSONalternative to · JSON is a standardized, language-independent text format for representing structured data using objects, arrays, strings, numbers, Boolean values, and null.
- oneOfhas part · oneof is a Protocol Buffers field construct that allows at most one member of a set of alternative fields to be set in a message.
- pprof formatused by · The pprof format is a Protocol Buffers-encoded representation of software execution profiles for storage or transmission.
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.