Lightning Talk: Rust Here, Rust There, Rust Everywhere! How a Crab Conquers the Cl... Sascha Grunert

Lightning Talk: Rust Here, Rust There, Rust Everywhere! How a Crab Conquers the Cloud Native Landscape

Speakers: Sascha Grunert

Conference: KubeCon EU

YouTube: https://www.youtube.com/watch?v=20eoMgq5lbY

Overview

Sascha Grunert's KubeCon EU lightning talk, "Rust Here, Rust There, Rust Everywhere! How a Crab Conquers the Cloud Native Landscape," provides a compelling overview of Rust's burgeoning presence and increasing importance within the Cloud Native Computing Foundation (CNCF) ecosystem. Grunert, a maintainer of multiple CNCF projects, systematically explores how the memory-safe and performance-oriented programming language is carving out a significant niche, challenging the established dominance of Golang in various critical components. The talk highlights not just the raw adoption statistics but also the practical challenges and successful strategies for integrating Rust into complex, multi-language cloud-native architectures.

This presentation is particularly significant for anyone involved in cloud-native development, operations, or security. It offers a glimpse into the future of infrastructure programming, where Rust's unique attributes—such as its strong emphasis on memory safety without a garbage collector, performance comparable to C/C++, and robust support for various architectures—are becoming increasingly attractive for building foundational components. Grunert's insights are crucial for understanding how new projects are leveraging Rust and how existing projects are selectively integrating it to enhance performance, reliability, and security across the cloud-native stack.

The talk serves as both an endorsement and a practical guide, detailing how the community is overcoming integration hurdles and demonstrating tangible successes with projects like Yuki, an OCI-compatible container runtime written entirely in Rust. By showcasing the practical application of Rust in production-grade cloud-native software, Grunert underscores why this "crab" is not just a passing trend but a strategic asset poised to profoundly influence the future of the cloud.

Background

▶ Watch: Rust's growing presence in CNCF projects (0:00)

The cloud-native landscape has historically been dominated by Golang, especially for critical infrastructure components like Kubernetes, containerd, and runC. Golang's simplicity, concurrency model, and fast compilation times made it an ideal choice for building distributed systems. However, as cloud-native applications scale and demand for performance and security intensifies, alternative languages with different strengths are gaining traction. Rust, with its focus on memory safety, performance, and concurrency without sacrificing control, has emerged as a strong contender.

Rust's core value proposition lies in its ability to deliver C/C++ level performance while eliminating entire classes of common bugs related to memory management, such as buffer overflows, null pointer dereferences, and use-after-free errors. This is achieved through its unique ownership and borrowing system, enforced at compile time, which guarantees memory safety without the runtime overhead of a garbage collector. This makes Rust particularly appealing for low-level systems programming where reliability and efficiency are paramount, such as container runtimes, networking components, and operating system kernels.

The challenge, however, lies in integrating a relatively newer language like Rust into an ecosystem largely built on Golang. This involves navigating different tooling, ecosystem maturity levels, and communication mechanisms between components written in different languages. A significant hurdle, as highlighted by Grunert, is the Open Container Initiative (OCI) specification, which defines the runtime and image formats for containers. The OCI specification itself is primarily defined and implemented in Golang, creating a natural barrier for projects aiming to build OCI-compliant tools in other languages. Overcoming this requires either rewriting core specifications or developing robust language bindings and interoperability layers. The talk aims to illustrate how the cloud-native community is addressing these challenges, paving the way for Rust's broader adoption.

Key Findings

▶ Watch: Crossing language borders: CLI, RPC, WebAssembly (1:55)

Sascha Grunert's talk reveals several key findings that underscore Rust's accelerating integration and impact within the CNCF ecosystem:

Firstly, Rust's presence in the CNCF is substantial and growing rapidly. The ecosystem currently boasts over 250 million lines of Rust code spread across more than 370 repositories. This makes Rust the sixth topmost programming language in the entire cloud-native landscape, a remarkable achievement given its relative youth compared to languages like C, C++, Java, Python, and Golang. This adoption isn't limited to niche projects; it includes prominent initiatives like TiKV, WasmEdge, WasmCloud, and the policy engine Kube Warden, which is written completely in Rust. Even established Golang projects like CRI-O and containerd are starting to partially utilize Rust, indicating a strategic shift towards leveraging its specific strengths.

Secondly, successful integration of Rust often necessitates a fundamental architectural rethink rather than a direct, line-by-line rewrite. Grunert emphasizes that simply "rewriting something in Rust is probably not the right solution" in isolation. Instead, the process often forces a restructuring of the codebase to be more modular and extendable. This refactoring can lead to temporary challenges, such as changes in testing methodologies and expected outputs, but ultimately results in a more robust and maintainable system. The experience of refactoring a dedicated tool within CRI-O serves as a prime example, where architectural changes became a prerequisite for a successful Rust migration.

Thirdly, interoperability across different programming languages is crucial for Rust's adoption in a multi-language ecosystem. The talk highlights the importance of good interfaces to "cross those language borders." Command Line Interfaces (CLIs) are presented as the most natural and robust method for inter-process communication on Linux. Beyond CLIs, Remote Procedure Call (RPC) systems like gRPC and Captain Proto are vital. While gRPC previously faced performance issues with its Rust implementation compared to Golang, these have largely been resolved, though minor challenges with Unix domain sockets persist. This signifies the maturing tooling and ecosystem around Rust for enterprise-grade distributed systems.

Finally, the talk underlines the community-driven effort to fill critical ecosystem gaps. The creation of OCI Spec RS, a Rust-native implementation of the OCI specification, is a testament to this. Initiated due to the lack of an official Rust crate for OCI, this project received endorsement from existing OCI maintainers, allowing the Rust community to take ownership and maintenance. Since its inception in 2021, OCI Spec RS has garnered more than 700 users, demonstrating its vital role in enabling Rust-based container tooling. This collaborative approach to building foundational components is key to Rust's continued expansion.

Technical Deep Dive

▶ Watch: Rust toolchain and distribution maturity issues (2:40)

The technical deep dive into Rust's integration within the cloud-native landscape, as presented by Sascha Grunert, illuminates both the strategies employed and the challenges encountered when bridging the gap between Rust and existing Golang-centric systems. The core message is that while Rust offers significant advantages, its successful adoption requires careful architectural consideration and robust interoperability mechanisms.

One of the primary strategies for integrating Rust components into a multi-language environment is through well-defined interfaces. Grunert identifies the Command Line Interface (CLI) as the "most natural one when we speak about Linux." This approach allows Rust programs to function as standalone utilities that can be invoked by other applications or scripts, regardless of their programming language. This loose coupling promotes modularity and allows developers to leverage Rust's performance benefits for specific tasks without requiring a full system rewrite.

Beyond CLIs, Remote Procedure Call (RPC) systems play a critical role in facilitating more complex interactions between services. The talk specifically mentions gRPC and Captain Proto. gRPC, a high-performance, open-source universal RPC framework, is widely used in cloud-native environments. Grunert notes that in the past, the Rust implementation of gRPC suffered from performance disparities compared to its Golang counterpart. However, this issue has largely been resolved, indicating significant advancements in the Rust gRPC ecosystem. Despite this progress, "some small issues open," particularly concerning the handling of Unix domain sockets, which are crucial for inter-process communication on a single host. Developers planning to use gRPC with Rust in such scenarios need to be aware of these subtle differences. Captain Proto, an alternative RPC system, also offers a viable option, known for its focus on efficiency and schema evolution.

Another significant integration point for Rust is through WebAssembly (Wasm) runtimes. WebAssembly is gaining traction in cloud-native for its sandboxing capabilities, portability, and near-native performance. Rust is an excellent language for compiling to Wasm, making it a natural fit for developing Wasm modules. Grunert highlights that "WebAssembly runtimes are more or less like awesome to handle Rust code." This enables Rust code to be executed in various environments, including serverless functions and edge computing, with strong isolation and performance guarantees. However, he cautions that the maturity of different libraries and toolchains for Wasm can vary significantly when compared to more established ecosystems like Golang.

A recurring challenge identified is the rapid evolution of Rust's toolchain and the potential for version incompatibilities. Grunert recounts an experience where implementing new features in Rust required a newer toolchain version, but major Linux distributions were not updated quickly enough. This necessitated making the application backwards compatible to function with older Rust versions, adding complexity to the development process. This highlights the tension between leveraging the latest language features and ensuring broad compatibility in production environments.

A pivotal technical contribution discussed is the creation of OCI Spec RS. Recognizing the absence of a robust, maintained Rust crate for the OCI specification—which is predominantly defined in Golang—Grunert and his team took the initiative to develop one. This involved direct collaboration with existing OCI spec maintainers, who "said, 'Hey, yeah, you can take over the crate, but you have to maintain it.'" This community-driven effort resulted in a critical piece of infrastructure, providing Rust projects with a native way to interact with OCI concepts like container images and runtimes. Since its inception in 2021, OCI Spec RS has seen significant adoption, with "more than like 700 users," validating its necessity and impact. This project serves as a prime example of how the Rust community is actively building foundational libraries to enable its ecosystem to thrive in traditionally Golang-dominated spaces.

Demo / Proof of Concept

▶ Watch: Yuki: A successful OCI-compatible Rust runtime (3:00)

The quintessential proof of concept highlighted in Sascha Grunert's talk is Yuki, an OCI-compatible container runtime written entirely in Rust. Yuki stands as a direct competitor to established runtimes like runC and crun, which are primarily implemented in Golang and C, respectively. Its development and subsequent entry into the CNCF sandbox in 2024 underscore the maturity and capability of Rust for building critical cloud-native infrastructure components.

Yuki's significance lies in several key aspects. Firstly, it demonstrates that Rust is fully capable of implementing complex, low-level system software that adheres to industry standards like the OCI specification. This is a direct consequence of projects like OCI Spec RS, which provide the necessary building blocks for Rust developers to interact with OCI concepts natively. The existence of a complete Rust-based OCI runtime validates the efforts to create language bindings and foster a robust Rust ecosystem for containers.

Secondly, Yuki offers tangible performance benefits. Grunert explicitly states that Yuki "is way faster than runC." This performance advantage is a compelling reason for its adoption, especially in environments where container startup times and resource efficiency are critical. Rust's zero-cost abstractions and compile-time memory safety contribute directly to its ability to achieve such high performance, making it an attractive alternative for core runtime components.

Finally, Yuki's acceptance into the CNCF Sandbox is a strong endorsement from the cloud-native community. This status signifies that Yuki is considered a promising project with potential for broader impact and adoption. It provides a clear pathway for developers and organizations to explore and integrate a Rust-native container runtime, further diversifying the technological stack available for container orchestration. For those looking to understand the intricacies of container runtimes and the practical application of Rust in this domain, Grunert recommends, "I can just recommend you to check out Yuki."

Defensive Implications

▶ Watch: Key recommendations for using Rust in cloud-native (4:10)

The increasing adoption of Rust in critical cloud-native infrastructure, as evidenced by projects like Yuki and the OCI Spec RS, carries significant defensive implications for security professionals. Rust's core design principles, particularly its emphasis on memory safety, directly address a large class of vulnerabilities that have plagued software for decades.

Firstly, the most immediate defensive benefit of Rust is the compile-time elimination of common memory errors. Traditional languages like C and C++ are notorious for buffer overflows, use-after-free, double-free, and null pointer dereferences, which frequently lead to critical security vulnerabilities, many of which are exploited for remote code execution. Rust's ownership and borrowing system prevents these issues at compile time, drastically reducing the attack surface related to memory corruption. For defenders, this means a significantly lower likelihood of encountering certain types of critical exploits in Rust-based components, potentially shifting focus to logical vulnerabilities, configuration errors, or supply chain risks.

Secondly, the introduction of new runtimes like Yuki means that security teams must adapt their tooling and processes. While the memory safety benefits are clear, new codebases require thorough security auditing, static analysis, and dynamic testing. Existing security scanners and vulnerability databases may be heavily geared towards Golang, Python, or Java. Defenders need to ensure that their Software Composition Analysis (SCA) tools, Static Application Security Testing (SAST) solutions, and Dynamic Application Security Testing (DAST) frameworks are capable of effectively analyzing Rust code and its dependencies. This includes understanding the specific security implications of Rust's concurrency primitives, its FFI (Foreign Function Interface) for interacting with C libraries, and its dependency management system (Cargo).

Thirdly, the talk's emphasis on "isolated functionality" as a good starting point for Rust integration also has security advantages. By encapsulating specific, high-performance, or security-critical functions in Rust, organizations can limit the blast radius of potential vulnerabilities. If a Rust component is designed to perform a single, well-defined task, any compromise might be contained to that specific function, rather than impacting a broader system. This aligns with the principle of least privilege and contributes to a more resilient system architecture.

Finally, the shift towards Rust for performance-critical components means that defenders should pay close attention to the supply chain security of Rust crates. The crates.io ecosystem, while robust, requires the same scrutiny as any other package manager. This includes verifying the integrity of downloaded crates, managing dependencies carefully, and being aware of potential malicious package injections or vulnerabilities in widely used libraries. Organizations should implement strong dependency management policies, regularly audit their dependencies, and consider using private registries for critical components.

In essence, while Rust offers significant security advantages by design, its growing presence necessitates an evolution in defensive strategies to ensure comprehensive coverage and understanding of the evolving cloud-native security landscape.

Key Takeaways

• Rust's Rapid Growth in CNCF: Rust is now the sixth most used programming language in the cloud-native ecosystem, with over 250 million lines of code across 370+ repositories, indicating a significant and growing adoption trend.
• Architectural Rethink for Migration: Simply rewriting code in Rust is often insufficient; successful integration typically requires a fundamental restructuring of applications for greater modularity and extensibility, leading to more robust systems.
• Robust Interoperability is Key: Good interfaces, including CLIs and RPC systems like gRPC (with largely resolved performance issues, though minor Unix domain socket challenges persist), are essential for seamless communication between Rust and other language components.
• Community-Driven Infrastructure Development: Projects like OCI Spec RS, a Rust-native implementation of the OCI specification with over 700 users since 2021, demonstrate the community's proactive efforts to build foundational libraries enabling Rust's expansion into core cloud-native domains.
• Yuki as a Performance-Oriented Rust Runtime: Yuki, an OCI-compatible container runtime written entirely in Rust and accepted into the CNCF sandbox in 2024, showcases Rust's ability to deliver high-performance, memory-safe alternatives to established Golang/C runtimes, proving "way faster than runC."
• Strategic Use of Rust for Performance and Security: Rust's memory safety, performance, and cross-architecture targeting make it ideal for new projects, especially in hot topics like AI/ML, and for challenging existing Golang implementations where efficiency and security are paramount.

About the Speaker(s)

Sascha Grunert is a prominent figure in the cloud-native community, actively involved in maintaining multiple projects within the Cloud Native Computing Foundation (CNCF). His work often involves delving into the intricacies of system-level programming and container technologies, bringing a deep technical understanding to the challenges and opportunities within the cloud-native ecosystem. Grunert's presentation on Rust's increasing influence reflects his hands-on experience and expertise in leveraging modern programming languages to build robust and performant infrastructure components, many of which he humorously describes as "a bit rusty."