gRPC 是 Google 開源的高性能、通用的 RPC 框架，它采用了基于 HTTP/2 協議的二進制傳輸協議，支持多種語言，包括 Rust。Rust 語言 GRPC 模塊是一個用于 Rust 語言的 gRPC 客戶端和服務器實現，它提供了一個簡單易用的 API，可以方便地創建和使用 gRPC 服務。

基礎用法

創建 gRPC 服務器

在 Rust 語言 GRPC 模塊中，可以使用ServerBuilder結構體來創建 gRPC 服務器。下面是一個簡單的示例：

use grpc::{Server, ServerBuilder};

fn main() {
    let mut server = ServerBuilder::new_plain();
    server.http.set_port(50051);
    server.add_service(proto::greeter_server::GreeterServer::new_service_def(GreeterImpl {}));
    let server = server.build().unwrap();
    server.start();
    server.wait();
}

struct GreeterImpl {}

impl proto::greeter_server::Greeter for GreeterImpl {
    fn say_hello(&self, _m: grpc::RequestOptions, req: proto::HelloRequest) - > grpc::SingleResponse< proto::HelloReply > {
        let mut r = proto::HelloReply::new();
        r.set_message(format!("Hello, {}!", req.get_name()));
        grpc::SingleResponse::completed(r)
    }
}

這個示例中，我們創建了一個ServerBuilder對象，并通過http字段設置了服務器的端口號。然后我們使用add_service方法將我們實現的Greeter服務添加到服務器中。最后，我們通過build方法構建了服務器，并通過start方法啟動了服務器。服務器啟動后，我們通過wait方法等待客戶端連接。

創建 gRPC 客戶端

在 Rust 語言 GRPC 模塊中，可以使用Client結構體來創建 gRPC 客戶端。下面是一個簡單的示例：

use grpc::{ChannelBuilder, Client};

fn main() {
    let ch = ChannelBuilder::new_plain();
    let client = Client::new(ch);
    let mut req = proto::HelloRequest::new();
    req.set_name("world".to_string());
    let resp = client.say_hello(grpc::RequestOptions::new(), req);
    println!("{}", resp.wait().unwrap().get_message());
}

這個示例中，我們創建了一個ChannelBuilder對象，并使用Client結構體創建了一個 gRPC 客戶端。然后我們創建了一個HelloRequest對象，并設置了它的name字段。最后，我們使用say_hello方法向服務器發送請求，并通過wait方法等待響應。響應對象是一個SingleResponse對象，我們通過unwrap方法獲取了它的值，并打印了它的message字段。

使用流式 RPC

在 Rust 語言 GRPC 模塊中，可以使用流式 RPC 來傳輸流數據。下面是一個簡單的示例：

use grpc::{Client, ClientStreamingSink, Server, ServerBuilder, ServerStreamingSink, WriteFlags};

fn main() {
    let mut server = ServerBuilder::new_plain();
    server.http.set_port(50051);
    server.add_service(proto::streaming::create_greeter_server(GreeterImpl {}));
    let server = server.build().unwrap();
    server.start();

    let ch = ChannelBuilder::new_plain();
    let client = Client::new(ch);

    let reqs = vec![
        proto::HelloRequest::new(),
        proto::HelloRequest::new(),
        proto::HelloRequest::new(),
    ];

    let (mut tx, rx) = client.say_hello_stream(grpc::RequestOptions::new()).unwrap();
    for req in reqs {
        tx = tx.send((req, WriteFlags::default())).unwrap();
    }
    tx.close().unwrap();

    for resp in rx.wait() {
        println!("{}", resp.unwrap().get_message());
    }
}

struct GreeterImpl {}

impl proto::streaming::Greeter for GreeterImpl {
    fn say_hello_stream(&self, _m: grpc::RequestOptions, _stream: grpc::StreamingRequest< proto::HelloRequest >) - > grpc::StreamingResponse< proto::HelloReply > {
        let (tx, rx) = grpc::channel::mpsc::channel(0);
        std::thread::spawn(move || {
            for req in _stream.into_iter() {
                let mut r = proto::HelloReply::new();
                r.set_message(format!("Hello, {}!", req.get_name()));
                tx.send((r, WriteFlags::default())).unwrap();
            }
            tx.close().unwrap();
        });
        grpc::StreamingResponse::new(rx)
    }
}

這個示例中，我們創建了一個Greeter服務，并實現了一個say_hello_stream方法，該方法接收一個StreamingRequest對象，并返回一個StreamingResponse對象。在該方法中，我們使用mpsc::channel方法創建了一個通道，用于傳輸流數據。然后我們使用std::thread::spawn方法創建了一個線程，該線程會將接收到的請求轉換成響應，并通過通道發送給客戶端。最后，我們使用StreamingResponse::new方法將通道包裝成一個StreamingResponse對象，并將其返回給客戶端。

在客戶端中，我們創建了一個say_hello_stream方法，并使用send方法向服務器發送請求。然后我們通過wait方法等待響應，并打印了響應的message字段。

使用雙向流式 RPC

在 Rust 語言 GRPC 模塊中，可以使用雙向流式 RPC 來傳輸雙向流數據。下面是一個簡單的示例：

use grpc::{Client, ClientStreamingSink, Server, ServerBuilder, ServerStreamingSink, StreamingSink, WriteFlags};

fn main() {
    let mut server = ServerBuilder::new_plain();
    server.http.set_port(50051);
    server.add_service(proto::streaming::create_greeter_server(GreeterImpl {}));
    let server = server.build().unwrap();
    server.start();

    let ch = ChannelBuilder::new_plain();
    let client = Client::new(ch);

    let (mut tx, rx) = client.say_hello_bidi(grpc::RequestOptions::new()).unwrap();
    let reqs = vec![
        proto::HelloRequest::new(),
        proto::HelloRequest::new(),
        proto::HelloRequest::new(),
    ];
    std::thread::spawn(move || {
        for req in reqs {
            tx = tx.send((req, WriteFlags::default())).unwrap();
            let resp = rx.into_future().wait().unwrap().0;
            println!("{}", resp.unwrap().get_message());
        }
        tx.close().unwrap();
    });
}

struct GreeterImpl {}

impl proto::streaming::Greeter for GreeterImpl {
    fn say_hello_bidi(&self, _m: grpc::RequestOptions, stream: grpc::StreamingRequest< proto::HelloRequest >) - > grpc::StreamingResponse< proto::HelloReply > {
        let (tx, rx) = grpc::channel::mpsc::channel(0);
        std::thread::spawn(move || {
            for req in stream.into_iter() {
                let mut r = proto::HelloReply::new();
                r.set_message(format!("Hello, {}!", req.get_name()));
                tx.send((r, WriteFlags::default())).unwrap();
            }
            tx.close().unwrap();
        });
        grpc::StreamingResponse::new(rx)
    }
}

這個示例中，我們創建了一個Greeter服務，并實現了一個say_hello_bidi方法，該方法接收一個StreamingRequest對象，并返回一個StreamingResponse對象。在該方法中，我們使用mpsc::channel方法創建了一個通道，用于傳輸流數據。然后我們使用std::thread::spawn方法創建了一個線程，該線程會將接收到的請求轉換成響應，并通過通道發送給客戶端。最后，我們使用StreamingResponse::new方法將通道包裝成一個StreamingResponse對象，并將其返回給客戶端。

在客戶端中，我們使用say_hello_bidi方法向服務器發送請求，并通過into_future方法獲取響應。然后我們通過println方法打印了響應的message字段。

進階用法

使用 tokio

在 Rust 語言 GRPC 模塊中，可以使用 tokio 來實現異步 RPC。下面是一個簡單的示例：

use grpc::{Client, ClientStreamingSink, Server, ServerBuilder, ServerStreamingSink, StreamingSink, WriteFlags};

#[tokio::main]
async fn main() {
    let mut server = ServerBuilder::new_plain();
    server.http.set_port(50051);
    server.add_service(proto::greeter_server::GreeterServer::new_service_def(GreeterImpl {}));
    let server = server.build().unwrap();
    server.start();

    let ch = ChannelBuilder::new_plain();
    let client = Client::new(ch);

    let mut req = proto::HelloRequest::new();
    req.set_name("world".to_string());
    let resp = client.say_hello_async(grpc::RequestOptions::new(), req).await.unwrap();
    println!("{}", resp.get_message());
}

struct GreeterImpl {}

impl proto::greeter_server::Greeter for GreeterImpl {
    fn say_hello(&self, _m: grpc::RequestOptions, req: proto::HelloRequest) - > grpc::SingleResponse< proto::HelloReply > {
        let mut r = proto::HelloReply::new();
        r.set_message(format!("Hello, {}!", req.get_name()));
        grpc::SingleResponse::completed(r)
    }
}

這個示例中，我們使用tokio::main宏來創建異步運行時。在服務器和客戶端中，我們使用async關鍵字來定義異步函數。在客戶端中，我們使用await關鍵字來等待異步響應。

tokio 使用流式 RPC

下面是一個使用 tokio 和流式 RPC 的示例：

use grpc::{Client, ClientStreamingSink, Server, ServerBuilder, ServerStreamingSink, StreamingSink, WriteFlags};
use tokio::sync::mpsc;

#[tokio::main]
async fn main() {
    let mut server = ServerBuilder::new_plain();
    server.http.set_port(50051);
    server.add_service(proto::streaming::create_greeter_server(GreeterImpl {}));
    let server = server.build().unwrap();
    server.start();

    let ch = ChannelBuilder::new_plain();
    let client = Client::new(ch);

    let (mut tx, rx) = mpsc::channel(10);
    let mut stream = client.say_hello_streaming(grpc::RequestOptions::new()).unwrap();
    tokio::spawn(async move {
        while let Some(req) = rx.recv().await {
            stream.send((req, WriteFlags::default())).unwrap();
        }
        stream.close().unwrap();
    });

    let reqs = vec![
        proto::HelloRequest::new(),
        proto::HelloRequest::new(),
        proto::HelloRequest::new(),
    ];
    for req in reqs {
        tx.send(req).await.unwrap();
    }

    for resp in stream.into_stream().await {
        println!("{}", resp.unwrap().get_message());
    }
}

struct GreeterImpl {}

impl proto::streaming::Greeter for GreeterImpl {
    fn say_hello_streaming(&self, _m: grpc::RequestOptions, _stream: grpc::StreamingRequest< proto::HelloRequest >) - > grpc::StreamingResponse< proto::HelloReply > {
        let (tx, rx) = grpc::channel::mpsc::channel(0);
        tokio::spawn(async move {
            for req in _stream.into_async_iter().await {
                let mut r = proto::HelloReply::new();
                r.set_message(format!("Hello, {}!", req.get_name()));
                tx.send((r, WriteFlags::default())).unwrap();
            }
            tx.close().unwrap();
        });
        grpc::StreamingResponse::new(rx)
    }
}

這個示例中，我們使用tokio::sync::mpsc庫來創建一個通道，用于傳輸流數據。在客戶端中，我們使用say_hello_streaming方法向服務器發送請求，并將請求通過通道發送給異步任務。在異步任務中，我們使用into_async_iter方法將請求流轉換成異步迭代器，并將響應通過通道發送給客戶端。在客戶端中，我們使用into_stream方法將響應流轉換成異步流，并等待響應。

使用 TLS 加密

在 Rust 語言 GRPC 模塊中，可以使用 TLS 加密來保護通信安全。下面是一個簡單的示例：

use grpc::{ChannelBuilder, Client};
use rustls::{Certificate, PrivateKey, ServerConfig};
use std::fs::File;
use std::io::BufReader;

fn main() {
    let mut config = ServerConfig::new(rustls::NoClientAuth::new());
    let cert_file = &mut BufReader::new(File::open("server.crt").unwrap());
    let key_file = &mut BufReader::new(File::open("server.key").unwrap());
    let cert_chain = rustls::internal::pemfile::certs(cert_file).unwrap();
    let mut keys = rustls::internal::pemfile::rsa_private_keys(key_file).unwrap();
    config.set_single_cert(cert_chain, keys.remove(0)).unwrap();
    let mut server = grpc_tls::ServerBuilder::new_plain();
    server.http.set_port(50051);
    server.http.set_tls(config);
    server.add_service(proto::greeter_server::GreeterServer::new_service_def(GreeterImpl {}));
    let server = server.build().unwrap();
    server.start();

    let mut config = rustls::ClientConfig::new();
    let cert_file = &mut BufReader::new(File::open("client.crt").unwrap());
    let key_file = &mut BufReader::new(File::open("client.key").unwrap());
    let cert_chain = rustls::internal::pemfile::certs(cert_file).unwrap();
    let mut keys = rustls::internal::pemfile::rsa_private_keys(key_file).unwrap();
    config.set_single_client_cert(cert_chain, keys.remove(0));
    let ch = ChannelBuilder::new_tls().rustls_config(config);
    let client = Client::new(ch);
    let mut req = proto::HelloRequest::new();
    req.set_name("world".to_string());
    let resp = client.say_hello(grpc::RequestOptions::new(), req);
    println!("{}", resp.wait().unwrap().get_message());
}

struct GreeterImpl {}

impl proto::greeter_server::Greeter for GreeterImpl {
    fn say_hello(&self, _m: grpc::RequestOptions, req: proto::HelloRequest) - > grpc::SingleResponse< proto::HelloReply > {
        let mut r = proto::HelloReply::new();
        r.set_message(format!("Hello, {}!", req.get_name()));
        grpc::SingleResponse::completed(r)
    }
}

這個示例中，我們使用rustls庫來創建 TLS 配置，并使用grpc_tls::ServerBuilder和ChannelBuilder::new_tls方法來創建帶有 TLS 加密的服務器和客戶端。在服務器中，我們使用set_single_cert方法來設置服務器證書和私鑰。在客戶端中，我們使用set_single_client_cert方法來設置客戶端證書和私鑰。

總結

本教程介紹了 GRPC 的基礎使用方法，并針對 tokio 結合 GRPC 的進階使用進入入門級的探討。希望能幫助同學們掌握 Rust 語言 GRPC 的應用。