#rpc-framework #rpc #grpc #thrift #protobuf #async

volo

Volo is a high-performance and strong-extensibility Rust RPC framework that helps developers build microservices

19 unstable releases (8 breaking)

0.10.0 Apr 7, 2024
0.9.0 Dec 22, 2023
0.8.0 Oct 23, 2023
0.5.3 Jun 9, 2023
0.0.0 May 11, 2022

#100 in Network programming

Download history 2200/week @ 2024-01-03 2147/week @ 2024-01-10 3087/week @ 2024-01-17 2543/week @ 2024-01-24 2384/week @ 2024-01-31 581/week @ 2024-02-07 1164/week @ 2024-02-14 2327/week @ 2024-02-21 2913/week @ 2024-02-28 2232/week @ 2024-03-06 2783/week @ 2024-03-13 3073/week @ 2024-03-20 2793/week @ 2024-03-27 2058/week @ 2024-04-03 1785/week @ 2024-04-10 1663/week @ 2024-04-17

8,771 downloads per month
Used in 12 crates (9 directly)

MIT/Apache

140KB
3.5K SLoC

Volo

Crates.io Documentation Website License Build Status

English | 中文

Volo is a high-performance and strong-extensibility Rust RPC framework that helps developers build microservices.

Volo uses Motore as its middleware abstraction, which is powered by AFIT and RPITIT.

Overview

Crates

Volo mainly consists of six crates:

  1. The volo crate, which contains the common components of the framework.
  2. The volo-thrift crate, which provides the Thrift RPC implementation.
  3. The volo-grpc crate, which provides the gRPC implementation.
  4. The volo-build crate, which generates thrift and protobuf code.
  5. The volo-cli crate, which provides the CLI interface to bootstrap a new project and manages the idl files.
  6. The volo-macros crate, which provides the macros for the framework.

Features

Powered by AFIT and RPITIT

Volo uses Motore as its middleware abstraction, which is powered by AFIT and RPITIT.

Through RPITIT, we can avoid many unnecessary Box memory allocations, improve ease of use, and provide users with a more friendly programming interface and a more ergonomic programming paradigm.

High Performance

Rust is known for its high performance and safety. We always take high performance as our goal in the design and implementation process, reduce the overhead of each place as much as possible, and improve the performance of each implementation.

First of all, it is very unfair to compare the performance with the Go framework, so we will not focus on comparing the performance of Volo and Kitex, and the data we give can only be used as a reference, I hope everyone can view it objectively; at the same time, due to the open source community has not found another mature Rust async version Thrift RPC framework, and performance comparison is always easy to lead to war, so we hope to weaken the comparison of performance data as much as possible, and we'll only publish our own QPS data.

Under the same test conditions as Kitex (limited to 4C), the Volo QPS is 350k; at the same time, we are internally verifying the version based on Monoio (CloudWeGo's open source Rust async runtime), and the QPS can reach 440k.

From the flame graph of our online business, thanks to Rust's static distribution and excellent compilation optimization, the overhead of the framework part is basically negligible (excluding syscall overhead).

Easy to Use

Rust is known for being hard to learn and hard to use, and we want to make it as easy as possible for users to use the Volo framework and write microservices in the Rust language, providing the most ergonomic and intuitive coding experience possible. Therefore, we make ease of use one of our most important goals.

For example, we provide the volo command line tool for bootstraping projects and managing idl files; at the same time, we split thrift and gRPC into two independent(but share some components) frameworks to provide programming paradigms that best conform to different protocol semantics and interface.

We also provide the #[service] macro (which can be understood as the async_trait that does not require Box) to enable users to write service middleware using async rust without psychological burden.

Strong Extensibility

Benefiting from Rust's powerful expression and abstraction capabilities, through the flexible middleware Service abstraction, developers can process RPC meta-information, requests and responses in a very unified form.

For example, service governance functions such as service discovery and load balancing can be implemented in the form of services without the need to implement Trait independently.

We have also created an organization Volo-rs, any contributions are welcome.

For more information, you may refer to our guide.

Tutorial

Volo-Thrift: https://www.cloudwego.io/zh/docs/volo/volo-thrift/getting-started/

Volo-gRPC: https://www.cloudwego.io/zh/docs/volo/volo-grpc/getting-started/

Examples

See Examples.

  • Volo-rs: The volo ecosystem which contains a lot of useful components.
  • Motore: Middleware abstraction layer powered by AFIT and RPITIT.
  • Pilota: A thrift and protobuf implementation in pure rust with high performance and extensibility.
  • Metainfo: Transmissing metainfo across components.

RoadMap

See ROADMAP.md for more information.

Contributing

See CONTRIBUTING.md for more information.

License

Volo is dual-licensed under the MIT license and the Apache License (Version 2.0).

See LICENSE-MIT and LICENSE-APACHE for details.

Credits

We have used some third party components, and we thank them for their work.

For the full list, you may refer to the CREDITS.md file.

Community

Dependencies

~9–24MB
~330K SLoC