Quick Start

Quickly develop Dubbo services using Rust.

View the complete example here.

1 Prerequisites

  • Install the Rust development environment
  • Install the protoc tool

2 Define Dubbo Services Using IDL

The Greeter service is defined as follows, including a Dubbo service with a Unary (request-response) model.

  1. // ./proto/greeter.proto
  2. syntax = "proto3";
  4. option java_multiple_files = true;
  6. package org.apache.dubbo.sample.tri;
  9. // The request message containing the user's name.
  10. message GreeterRequest {
  11.   string name = 1;
  12. }
  14. // The response message containing the greetings
  15. message GreeterReply {
  16.   string message = 1;
  17. }
  19. service Greeter{
  20.   // unary
  21.   rpc greet(GreeterRequest) returns (GreeterReply);
  22. }
  1. # ./Cargo.toml
  2. [package]
  3. name = "example-greeter"
  4. version = "0.1.0"
  5. edition = "2021"
  7. [[bin]]
  8. name = "greeter-server"
  9. path = "src/greeter/server.rs"
  11. [[bin]]
  12. name = "greeter-client"
  13. path = "src/greeter/client.rs"
  15. [dependencies]
  16. http = "0.2"
  17. http-body = "0.4.4"
  18. futures-util = {version = "0.3", default-features = false}
  19. tokio = { version = "1.0", features = [ "rt-multi-thread", "time", "fs", "macros", "net", "signal"] }
  20. prost-derive = {version = "0.10", optional = true}
  21. prost = "0.10.4"
  22. async-trait = "0.1.56"
  23. tokio-stream = "0.1"
  25. dubbo = "0.1.0"
  26. dubbo-config = "0.1.0"
  28. [build-dependencies]
  29. dubbo-build = "0.1.0"

4 Configure dubbo-build to Compile IDL

Create a build.rs file in the project root directory (not /src) and add the following content:

  1. // ./build.rs
  2. fn main() {
  3.     dubbo_build::prost::configure()
  4.         .compile(&["proto/greeter.proto"], &["proto/"])
  5.         .unwrap();
  6. }

After this configuration, compiling the project will generate related Dubbo Stub code, usually located at ./target/debug/build/example-greeter-<id>/out/org.apache.dubbo.sample.tri.rs.

5 Write Dubbo Business Code

5.1 Write Dubbo Server

  1. // ./src/greeter/server.rs
  2. use ...
  4. #[tokio::main]
  5. async fn main() {
  6.     register_server(GreeterServerImpl {
  7.         name: "greeter".to_string(),
  8.     });
  10.     // Dubbo::new().start().await;
  11.     Dubbo::new()
  12.         .with_config({
  13.             let r = RootConfig::new();
  14.             match r.load() {
  15.                 Ok(config) => config,
  16.                 Err(_err) => panic!("err: {:?}", _err), // response was droped
  17.             }
  18.         })
  19.         .start()
  20.         .await;
  21. }
  23. #[allow(dead_code)]
  24. #[derive(Default, Clone)]
  25. struct GreeterServerImpl {
  26.     name: String,
  27. }
  29. // #[async_trait]
  30. #[async_trait]
  31. impl Greeter for GreeterServerImpl {
  32.     async fn greet(
  33.         &self,
  34.         request: Request<GreeterRequest>,
  35.     ) -> Result<Response<GreeterReply>, dubbo::status::Status> {
  36.         println!("GreeterServer::greet {:?}", request.metadata);
  38.         Ok(Response::new(GreeterReply {
  39.             message: "hello, dubbo-rust".to_string(),
  40.         }))
  41.     }
  42. }

5.2 Configure dubbo.yaml

The dubbo.yaml file specifies the server-side configuration, including the exposed service list, protocol configuration, listening configuration, etc.

  1. # ./dubbo.yaml
  2. name: dubbo
  3. service:
  4.   org.apache.dubbo.sample.tri.Greeter:
  5.     version: 1.0.0
  6.     group: test
  7.     protocol: triple
  8.     registry: ''
  9.     serializer: json
  10.     protocol_configs:
  11.       triple:
  12.         ip: 0.0.0.0
  13.         port: '8888'
  14.         name: triple
  15. protocols:
  16.   triple:
  17.     ip: 0.0.0.0
  18.     port: '8888'
  19.     name: triple

5.3 Write Dubbo Client

  1. // ./src/greeter/client.rs
  2. use ...
  4. #[tokio::main]
  5. async fn main() {
  6.     let mut cli = GreeterClient::new().with_uri("http://127.0.0.1:8888".to_string());
  8.     println!("# unary call");
  9.     let resp = cli
  10.         .greet(Request::new(GreeterRequest {
  11.             name: "message from client".to_string(),
  12.         }))
  13.         .await;
  14.     let resp = match resp {
  15.         Ok(resp) => resp,
  16.         Err(err) => return println!("{:?}", err),
  17.     };
  18.     let (_parts, body) = resp.into_parts();
  19.     println!("Response: {:?}", body);
  20. }

6 Run and Summarize

  1. Compile

Run cargo build to compile the server and client.

  1. Run the server

Run ./target/debug/greeter-server to start the server, which will listen on port 8888 and provide RPC services using the triple protocol as configured in dubbo.yaml:

  1. $ ./target/debug/greeter-server
  2. 2022-09-28T23:33:28.104577Z  INFO dubbo::framework: url: Some(Url { uri: "triple://0.0.0.0:8888/org.apache.dubbo.sample.tri.Greeter", protocol: "triple", location: "0.0.0.0:8888", ip: "0.0.0.0", port: "8888", service_key: ["org.apache.dubbo.sample.tri.Greeter"], params: {} })
  1. Run the client to verify successful invocation

Run ./target/debug/greeter-client to execute the client and call various methods under triple://127.0.0.1:8888/org.apache.dubbo.sample.tri.Greeter:

  1. $ ./target/debug/greeter-client
  2. Response: GreeterReply { message: "hello, dubbo-rust" }

7 More Examples

Streaming Communication Mode

Implement Streaming communication model using Dubbo Rust.

Interoperability with Dubbo Java

Implement interoperability with other Dubbo multi-language services.

Feedback

Was this page helpful?

Yes No

Last modified September 30, 2024: Update & Translate Overview Docs (#3040) (d37ebceaea7)