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.

This talk will dive deep into the latest advancements in the now officially stable gRPC's Advanced TLS API. We'll explore practical techniques and examples for features such as implementing post-handshake verifications, customizing root trust and certificate behavior, and configuring certificate revocation, all focused on adding an extra customizable layer of security to your gRPC services. Whether you're a seasoned gRPC developer or just starting your journey, this talk will equip you with the knowledge and tools to leverage the full power of advanced TLS and will enable you to build functionality to align with your organization's unique security requirements.

ttRPC, a CNCF project by containerd, was built for low memory environments as an alternative of gRPC. It finds many applications such as: within containerd CRI itself, in the VM runtime by kata containers where the containerd shim communicates with kata agent via this protocol, confidential containers and over 4k projects GitHub wide, including ones from Elastic search, Google, Microsoft, Grafana, etc. While gRPC is well-supported with tools for analyzing critical metrics such as memory usage, latency, and CPU profiling, ttRPC lacks such comprehensive analytics tools. To optimize deployments using ttRPC, it is essential to benchmark its performance, security, and other characteristics rigorously. In this talk, we aim to explore different products that utilize ttRPC protocol for its low latency and memory, analyze its performance, security, and other characteristics against various benchmarks and discuss its limitations with respect to gRPC.

Over the past ten years, gRPC has become indispensable to a breathtaking array of engineering organizations. Join the maintainers look back at how gRPC got to where it is today, the way the software has grown, and the community along with it. Then, see what's in store for the future of gRPC in the decades to come.

With the rise of cloud-native development, organizations have been faced with a difficult decision: attempt to scale applications as monoliths (and cope with centralized, finicky, rollback-prone deploys) or break applications into microservices (and suffer from data/ownership siloes that make it difficult to transactionally manage state). We have been forced to make uncomfortable tradeoffs. This is a false choice, we're missing the right abstractions. It should be possible to write code with the simplicity of a monolith (straightforward function calls composed via transactions), but with the scalability of microservices (encapsulation of data and ownership, support for polyglot components, independent deploys, etc). In this talk, we’ll discuss how using microservices in anger led to the need for transactionality between calls. We’ll also discuss how gRPC and protobuf were obvious choices for implementing the network layer and schema language.

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.

Bazel is Google's monorepo build and test system. This talk will start with the Microservices architecture many args use, and how many source repositories make it difficult to collaborate across team boundaries, even with an agreed interface schema. We'll discuss how monorepo and trunk-based development addresses these problems, while creating new ones. Then we'll look at how Bazel can be configured to build gRPC services across many languages in a single repo, and then continuously deliver a full stack with fewer versioning footguns.

So, you've got these cool gRPC microservices, right? They're awesome for communication, but let's be real, setting them up securely can be a bit tricky. You've got to deal with stuff like key distribution, certificate management, and all that jazz.

But fear not! This talk is all about making it easier for you. We'll walk you through some simple yet effective ways to lock down your gRPC microservices without resorting to old-school solutions like JWT.

We'll chat about things like how to handle certificates, when they should expire, and how to reload them without breaking a sweat. Plus, we'll show you some neat tricks for making sure your services are talking to each other securely.

Forget about the headaches of managing JWT tokens. We'll show you why modern solutions like mTLS are where it's at. With real-life examples and stories from the trenches, you'll leave this talk ready to secure your gRPC microservices like a pro, no fancy jargon required!

In an environment where every microsecond of latency and every CPU cycle counts, how do we keep gRPC performant, stable, and feature-rich? We'll give you an overview of what goes into producing reliable, performance-tuned gRPC libraries. This maintainer talk covers the how and why we focus on performance, gRPC's testing infrastructure, and some of our testing and performance philosophies. You'll also get a sneak preview of improvements in the pipeline for future releases.