Skip to content
This repository has been archived by the owner. It is now read-only.
Switch branches/tags

Latest commit

brpc-build: add path finder for `protoc-gen-brpc`

Git stats


Failed to load latest commit information.

brpc-rs: Apache BRPC library for Rust

Build Status Crate Documentation

Apache BRPC is an industrial-grade RPC framework for building reliable and high-performance services. brpc-rs enables BRPC clients and servers implemented in the Rust programming language.

brpc-rs is part of the MesaLock Linux Project.


This project is currently a prototype under active development. Many APIs are missing; the provided APIs are not guaranteed to be stable until 1.0.

Repository structure

  • Project root
    • src
      • brpc-rs crate, Rust APIs for brpc-rs
    • brpc-build
    • brpc-protoc-plugin
    • brpc-sys
      • brpc-sys crate, FFI bindings to Apache BRPC
    • examples
      • examples

This graph illustrates how the crates work together:



First build and install Apache BRPC. Instructions can be found in

Alternatively, you may use the prebuilt deb packages of Apache BRPC 0.9.6 for Ubuntu 16.04/18.04. These are NOT official packages.

Make sure these dependencies are already installed:

$ sudo apt-get install libprotobuf-dev libprotoc-dev protobuf-compiler
$ sudo apt-get install libssl-dev libgflags-dev libleveldb-dev

Install brpc-protoc-plugin from

$ cargo install brpc-protoc-plugin

Now we are ready to start a brpc-rs project.


Let's create a small crate, echo_service, that includes an echo_client and an echo_server.

$ cargo new echo_service && cd echo_service

In Cargo.toml , add brpc-rs, prost and bytes to the [dependencies] section; add brpc-build to the [build-dependencies] section. For example,

brpc-build = "0.1.0"

brpc-rs = "0.1.0"
prost = "0.5.0"
bytes = "0.4.12"

Define two binaries: echo_client and echo_server in Cargo.toml

name = "echo_client"
path = "src/"

name = "echo_server"
path = "src/"

Put a protobuf file echo.proto in src. This file defines EchoRequest, EchoResponse and EchoService.

package example;
message EchoRequest {
      required string message = 1;
message EchoResponse {
      required string message = 1;
service EchoService {
      rpc echo(EchoRequest) returns (EchoResponse);

Add a line build = "" in the [package] section in Cargo.toml. Then, create a file called to generate bindings from src/echo.proto.

fn main() {

Note the package name in echo.proto is example. So would generate two files named and


Next let's implement the echo server. Create src/ as follows:

use brpc_rs::{Server, ServerOptions, ServiceOwnership};

pub mod echo {
    include!(concat!(env!("OUT_DIR"), "/"));
    include!(concat!(env!("OUT_DIR"), "/"));

fn main() {
    let mut service = echo::EchoService::new();
    service.set_echo_handler(&mut move |request, mut response| {
        response.message = request.message.clone();

    let mut server = Server::new();
    let mut options = ServerOptions::new();
        .add_service(&service, ServiceOwnership::ServerDoesntOwnService)
        .expect("Failed to add service");
    server.start(50000, &options).expect("Failed to start service");; // Run until CTRL-C

Because EchoService defines a function called echo() in echo.proto, the brpc-protoc-plugin generates the Rust definition of set_echo_handler() for EchoService. set_echo_handler() accepts a closure which handles EchoRequest sent from clients and returns an EchoResponse with the same message. The remaining lines create a server that listens at


use brpc_rs::{Channel, ChannelOptions};

pub mod echo {
    include!(concat!(env!("OUT_DIR"), "/"));
    include!(concat!(env!("OUT_DIR"), "/"));

fn main() {
    let mut options = ChannelOptions::new();
    let addr = "".parse().expect("Invalid socket address");
    let ch = Channel::with_options(&addr, &options);
    let client = echo::EchoServiceStub::with_channel(&ch);
    let request = echo::EchoRequest {
        message: "hello".to_owned(),
    match client.echo(&request) {
        Ok(r) => println!("Response: {:?}", r),
        Err(e) => eprintln!("Error: {:?}", e),

The client first creates a Channel and initializes a service_stub with that channel. The client then calls service_stub.echo() to send a request..

Running the client and server

$ cargo run --bin echo_server &
$ cargo run --bin echo_client
Response: EchoResponse { message: "hello" }


  • Yiming Jing <> @kevinis


brpc-rs is provided under Apache License, Version 2.0. For a copy, see the LICENSE file.


Apache bRPC library for Rust





No packages published