gRPC Conf 2025

Dive into the world of gRPC, a modern, open-source Remote Procedure Call (RPC) framework that's transforming how distributed systems communicate. This session will provide a comprehensive overview of gRPC, highlighting its core principles, benefits, and practical use cases. We'll explore how gRPC leverages HTTP/2 for efficient, bi-directional streaming and Protocol Buffers for language-agnostic, strongly-typed data serialization. Whether you're building microservices, real-time applications, or polyglot environments, discover why gRPC is a powerful choice for high-performance, low-latency communication.

This session introduces Google Cloud's powerful compute and networking capabilities. We'll explore the latest VM families, from general-purpose to specialized, and how to choose the right fit for your workloads. Learn how to achieve high performance with advanced networking features, including optimized virtual NICs, low-latency interconnects, and IP management. We'll also cover how to leverage Google's global network to ensure your applications are fast, reliable, and globally accessible. Discover how to build a high-performance and scalable infrastructure that can handle any challenge.

While gRPC will run just about anywhere, it was designed from the ground up to be cloud-native. So you can get more out of it when run on a cloud native orchestration system like Kubernetes. Join this talk to learn the basics of Kubernetes and GKE (Google Kubernetes Engine) and how you can leverage GKE to make your software systems faster, more reliable, and more scalable.

You keep hearing about service meshes and think they will solve some of your problems. You look around and see the different mesh architectures and wonder why they matter, and whether it will matter to you.

We'll discuss how gRPC interacts with service meshes, and how knowing the problems you are solving helps identify the benefits and pain points you might experience. While Kubernetes will be the focus, meshes beyond k8s will also be discussed.

As the adoption of Rust continues to expand across various development domains, the gRPC team is committed to supporting its user base by providing robust tools. This session will offer a comprehensive introduction to gRPC-Rust. We will explore how Rust's characteristics, including its focus on performance, memory safety, and concurrency, can be utilized in conjunction with gRPC's efficient, language-agnostic RPC framework to develop microservices.

Attendees will learn the foundational aspects of defining gRPC services in Rust, implementing both clients and servers, handling common communication patterns such as streaming, and integrating with the broader Rust ecosystem. The session aims to provide a clear understanding of how gRPC-Rust can be applied in the development of scalable and efficient distributed systems.

Come take a look at what's in store for gRPC in 2025 and beyond. Discover the most impactful recent updates in the gRPC ecosystem and how you can take advantage of them.

Are you passionate about Artificial Intelligence? Join fellow AI enthusiasts in this interactive Birds of a Feather session! This isn't a typical presentation; instead, it's a unique opportunity to engage in open discussion, share your experiences, and get answers to your burning AI questions from the collective wisdom of the group. Come prepared to connect, learn, and contribute!

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.

In the world of microservices, maintaining robust and observable gRPC-based systems is paramount for ensuring production readiness and simplifying debugging efforts. When things go wrong, logging into individual machines and manually sifting through gigabytes of logs is not always practical nor convenient. This session will explore the current landscape and future horizons of gRPC observability.

We'll start with established tools like RPC metrics and distributed trace information, available through OpenTelemetry. Then, we'll expand to other vital gRPC ecosystem tools: channelz and health-checking for real-time diagnostics.

The session's latter half will focus on upcoming enhancements. We'll introduce new, more granular metrics and traces, leveraging TCP instrumentation for deeper application visibility. Additionally, we'll cover updates to systems like channelz and discuss ongoing collaboration between the gRPC and OpenTelemetry communities to improve out-of-the-box observability.