gRPC Conf 2025

Protocol Buffers are the backbone of gRPC. They're how you define, evolve, and govern your APIs. But Protocol Buffers can be a pain. They have to be shared across source code repositories and they require an extra step in the build process that might not fit into your build system. Come hear about exciting new ways to improve the management of your Protocol Buffers.

Netflix scales gRPC services by reducing call volume through caching and batching, applied through client and server interceptors and automatically wired into services. Over half of all Java-client gRPC traffic is served through on-box (Google/Guava, OHCache) and distributed (Netflix/EVcache) caches. We present how integrating caching directives directly into the proto specification allow us to automatically inject cache support into the stubs with minimal developer overhead. We also present our request batching technique to aggregate multiple stub invocations into a single remote call. This allows service owners to reduce call volume even when consuming applications apply suboptimal fetch patterns.

This talk covers why many of Swift's features make it a great fit for the server before diving into the gRPC Swift library. We'll review the current state of the library and our journey towards gRPC Swift v2. We'll describe how the new version takes advantage of some of Swift's latest features, such as its concurrency model, and compile-time data race checking. You'll also see how we leveraged Swift to build simple and expressive new APIs, as well as how easy it is to get started with gRPC Swift on both the server and client.

gRPC metadata is a useful mechanism for implementing authentication, tracing, and application-specific features. It is important that applications configure a limit on received metadata size, since metadata is not flow-controlled and large amounts can severely degrade performance. But configuring metadata limits can be tricky - what if the client accidentally starts sending too much metadata? Or worse, what if some proxy between client and server configures a lower metadata limit than the server? This talk will explore these questions and more, including how applications can learn to protect against such issues in the future.

Please note that this talk will focus on the C++ stack.

Have you ever wished there was something like Apollo Federation, but for gRPC services? Your search ends here. At Mercari, we recently released "gRPC Federation", a straightforward open-source tool that brings together multiple gRPC APIs into one consolidated Backend for Frontends (BFFs), with simple Protocol Buffer notations.

In this session, we will explore gRPC Federation, showcasing how it enables easier adoption of a federation architecture for gRPC services. We will touch on everything from the basics—like utilizing Protocol Buffers notation and CEL (Common Expression Language)—to more complex features like our secure and scalable plugin system made possible through WebAssembly. This session will provide the comprehensive insights needed to leverage gRPC Federation effectively.

By the end, you will understand why you should use gRPC Federation when adopting federation architecture at scale, and how it simplifies building, deploying, and managing BFFs on your platform.

In this session, we will cover the following: - Basics of client-side load balancing support in gRPC: - Here, we will cover the interaction between the gRPC channel and the load balancing policy. We will also go over the load balancing API in gRPC that allows our users to implement their own policies. - Overview of supported load balancing policies: - gRPC ships with a bunch of load balancing policy implementations. We will go through a subset of them and talk about ideal deployment scenarios for each of them. - Custom load balancing policy support in gRPC: - gRPC supports configuration of custom load balancing policies on the client by the control plane.