Presenters
Source
🚀 The Future of gRPC: AI, Rust, and the Proxyless Revolution
Welcome to the dawn of a new era for gRPC. At the first-ever gRPC Conf, Ashish Shravasa, Engineering Manager at Google, unveiled a roadmap that transforms gRPC from a high-performance RPC framework into the backbone of the modern cloud-native and AI-driven world.
The strategy rests on three pillars:
- Modernization: Evolving the core to align with cloud-native builds, including gRPC Rust and MCP transport.
- Service Mesh & XDS: Advancing a world of proxyless service meshes where discovery, load balancing, and security are policy-driven.
- Observability: Investing in the philosophy that you cannot improve what you cannot see through advanced metrics and tracing.
🤖 gRPC: The Heart of the AI Ecosystem
The AI landscape is exploding, and gRPC sits right at the intersection. Two protocols have recently dominated the conversation: the Model Context Protocol (MCP) and the Agent-to-Agent (A2A) protocol.
While A2A was built with gRPC as its foundation from day one, MCP—which allows LLMs to take actions via tools exported by servers—initially lacked gRPC support. Due to overwhelming community demand, gRPC is now a fully functional transport for MCP. The team is currently working with maintainers to make the transport layer pluggable, ensuring gRPC becomes a first-class member of the MCP family. This shift means gRPC is no longer just powering backends; it is a critical organ in the AI ecosystem.
🦀 The Arrival of gRPC Rust
The community asked, and Google delivered. gRPC Rust is officially joining the family! Built upon the popular Tonic implementation, this project aims for full feature parity with other languages.
Key Highlights:
- Collaborating with Lucia, the maintainer of Tonic, to ensure a top-notch developer experience.
- Implementing a native XDS implementation so you can run your service mesh natively in Rust.
- Focusing on a seamless transition for existing Tonic users.
🛠️ Advanced Service Mesh: Powering the Data Plane
The roadmap introduces powerful new tools for XDS-driven environments, moving beyond the traditional interceptor model to a more flexible callout pattern.
🔄 External Processing and Authorization
- ext_proc: Allows you to modify incoming requests and outgoing responses directly on the server.
- ext_authz: Centrally decides if a request is authorized. Instead of heavy manual coding, these features use a plugin model where the gRPC server calls an external service to make decisions. For platform teams, this means you can implement a standardized environment by simply wiring these services together via the service mesh. Expect the gRFC (request for comments) for these designs in early next year.
🌐 HTTP Connect & Dynamic Tunneling
Since 2017, gRPC has supported HTTP Connect for creating secure tunnels (allowing SSH or FTP over HTTP). However, configuration was manual and complex. We are now integrating this with XDS to make management dynamic. This simplifies connecting on-prem networks to isolated cloud servers, with experimental support already available in C++ and Java via feature flags.
🔐 Security and Identity with SPIFFE
Configuring Mutual TLS (mTLS) is notoriously difficult. To solve this, gRPC is expanding its SPIFFE support. While gRPC has supported SPIFFE-based identities since 2021, it is now adding support for SPIFFE Trust Bundles.
The Impact:
- Multi-domain management: Easily manage separate identities for testing, staging, and production.
- Isolation: Ensure less secure environments (like staging) cannot accidentally access production.
- Seamless Communication: Different teams can maintain their own domains while communicating securely. Look for this rollout in C++, Go, and Java in early next year.
☁️ Bridging the Gap: Serverless & Proxyless Mesh
Modern architectures often mix Kubernetes and Serverless workloads. Historically, joining these two to the same service mesh was a complex mess of workarounds. We are fixing this with three major enhancements:
- XDS Host Rewriting: Enables vanity URLs and simplifies discovery.
- JWT-based Authorization: For fine-grained, secure RPCs.
- mTLS with SPIFFE Identities: Ensuring every workload is verified.
🚦 Global Rate Limiting Without the Latency
Traditional rate limiting requires a proxy (like an API gateway or sidecar), which adds latency. We are introducing XDS Global Rate Limiting, where the logic lives inside the gRPC library itself.
This system uses the Rate Limit Quota Service (RLQS) to aggregate load across servers and dynamically adjust limits via the control plane. The result is a highly performant, globally coordinated rate-limiting system with a decentralized data plane. The first implementation arrives in GCP Cloud Service Mesh in early next year.
📊 Observability: Seeing is Improving
To round out the roadmap, gRPC is getting a massive boost in insights.
- ChannelZ v2: A more flexible, generic version of the debugging tool. It allows for custom implementation-specific metrics, such as tracking multiple TCP sockets over a single sub-channel.
- 12 New Metrics: Specifically for weighted round-robin load balancing, sub-channels, and XDS clients.
- Non-Per-Call Metrics Framework: A new way to capture data from components (like XDS clients) that persist across multiple calls, making it easier to troubleshoot proxyless service meshes.
🎯 Conclusion
From the core of the AI revolution to the efficiency of Rust and the security of SPIFFE, gRPC is evolving to meet the demands of the modern developer. The future of gRPC is strong, modern, and wide awake.
Ready to dive in?
- Explore more at gRPC.io.
- Watch the deep dives on the gRPC YouTube channel.
- Join the community at local meetups to stay ahead of the curve! 🚀💡👨💻✨