Abstract:

Richard Belleville, a gRPC project maintainer, presents the roadmap for gRPC's second decade, driven by three strategic pillars: service mesh enhancements, observability improvements, and continuous modernization. The roadmap introduces advanced proxyless service mesh features such as ExtProc for request modification, ExtAuth for authorization, and dynamic HTTP Connect proxy support via XDS, alongside integration for multiple Spiffy trust domains. Observability is boosted with Channel Z v2 for flexible debugging, streamlined Istio integration, and new OpenTelemetry metrics for load balancing and XDS clients. Modernization efforts include XDS global rate limiting, first-class serverless platform integration (e.g., Google Cloud Run), the adoption of gRPC as a primary transport for burgeoning AI protocols like MCP, and the addition of official, fully-featured support for the Rust programming language. This ambitious plan underscores gRPC's commitment to evolving as a performant, flexible, and integrated solution for distributed systems.

gRPC's Second Decade: Roadmap for Service Mesh, Observability, and Modernization

• 0:00 Introduction to gRPC's Future Roadmap: Richard Belleville, a gRPC maintainer, outlines the project's roadmap for its second decade, focusing on planned features and projects.
• 0:37 Three Core Pillars Driving gRPC's Evolution: The roadmap is built upon Service Mesh (continuing the proxyless service mesh trend), Observability (enhancing OpenTelemetry integration), and Modernization (keeping up with language and platform advancements).
• 1:41 New Proxyless Service Mesh Features: ExtProc & ExtAuth:
  • ExtProc allows modifying incoming requests and outgoing responses via a separate, preconfigured gRPC server (similar to interceptors but external).
  • ExtAuth enables authorization of incoming requests by an external gRPC server.
  • Key Takeaway: These features offer platform teams unprecedented flexibility to enforce system-wide policies without requiring application recompilation. Currently in the design phase, a GRFC (gRPC Request for Comment) will detail them later this year.
• 3:04 Dynamic HTTP Connect Proxy Support via XDS:
  • Extends existing HTTP Connect tunneling support by integrating with XDS, allowing the control plane to dynamically configure clients to use HTTP Connect proxies.
  • Key Takeaway: Simplifies creating a unified service mesh across on-premise and cloud environments by facilitating ingress/egress through proxies. Expected to be released cross-language later this year.
• 4:29 Support for Multiple Spiffy Trust Domains:
  • Adds support for Spiffy trust bundles, building on existing Spiffy-based MTLS via XDS.
  • Key Takeaway: Enhances workload identity management, crucial for isolating environments (e.g., dev, staging, prod) or enabling per-product identity control. Expected to land in C++, Go, and Java this year.
• 5:41 Channel Z v2 for Advanced Debugging:
  • The next iteration of Channel Z, providing detailed, flexible, and generic information about gRPC resources (channels, sub-channels, sockets).
  • Key Takeaway: Allows for faster and more flexible debugging of gRPC applications, with the first C++ implementation anticipated later this year.
• 6:50 Streamlined Istio Integration:
  • Removes the requirement for an insecure connection to the Istio agent proxy, improving security and simplicity.
  • Key Takeaway: Makes Istio and proxyless gRPC an even more seamless and secure combination.
• 7:17 New OpenTelemetry Metrics for Service Mesh:
  • Introduces 12 new metrics for load balancing policies (weighted round robin, pick first) and the XDS client, along with cross-cutting labels for XDS locality (cloud zone).
  • Leverages a new framework for non-per-call metrics to enrich observability.
  • Key Takeaway: Significantly improves the observability and reliability of running gRPC proxyless service mesh deployments.
• 8:12 XDS Global Rate Limiting:
  • A new capability enabling gRPC servers to natively implement global rate limiting in conjunction with a control plane.
  • Utilizes the XDS protocol and a new RLQS (Rate Limit Query Service) protocol for load aggregation and policy programming.
  • Key Takeaway: Offers a highly performant, globally aware, and decentralized system for managing high-volume software. Protocols and library implementations are open source, with a GCP cloud service mesh control plane coming soon.
• 9:19 First-Class Serverless Integrations:
  • Introduces features like XDS host rewriting, JWT token-based authorization for outgoing RPCs, and MTLS based on Spiffy identities.
  • Key Takeaway: Achieves a truly first-class integration between gRPC proxyless service mesh and serverless platforms like Google Cloud Run.
• 10:24 gRPC's Expanding Role in AI Protocols:
  • gRPC is becoming a cornerstone for AI models, especially with the growing popularity of MCP (Model Context Protocol) and A2A (Agent-to-Agent Protocol).
  • While A2A was built on gRPC from the start, MCP (originally JSON RPC) will now support gRPC as a first-class transport.
  • Key Takeaway: gRPC is solidifying its position as a key enabler for new AI applications due to its robust and feature-rich transport capabilities.
• 11:31 Official Support for Rust Language:
  • Rust is the newest officially supported gRPC language, building upon the popular Tonic implementation.
  • Aims for feature parity with C++, Java, and Go, including a full XDS implementation to support proxyless service mesh deployments.
  • Key Takeaway: Delivers official gRPC support for Rust, leveraging its safety and zero-cost abstractions, with a preview release expected soon.
• 12:27 Conclusion: The gRPC project is accelerating into its second decade, continuously delivering innovative features across service mesh, observability, and modernization, showing no signs of slowing down.