gRPC em Rust: bibliotecas Tonic e Grpc-rs com exemplos

gRPC para Rust: bibliotecas e exemplos

gRPC é um framework de chamada de procedimento remoto (RPC) de alto desempenho, desenvolvido pelo Google. Ele usa Protocol Buffers (protobuf) para serialização de dados e HTTP/2 para transporte. Graças à tipagem estrita, transmissão bidirecional e baixa latência, o gRPC se tornou um padrão para arquitetura de microsserviços. No ecossistema Rust, existem duas bibliotecas principais para trabalhar com gRPC: Tonic e grpc-rs. Neste artigo, analisaremos suas características e daremos exemplos práticos.

1. Tonic — moderno e assíncrono

Tonic é a biblioteca gRPC mais popular para Rust. Ela é construída sobre tokio e hyper, é totalmente assíncrona e se integra perfeitamente ao ecossistema Rust. O Tonic suporta todos os quatro tipos de chamadas gRPC: unárias, streaming do servidor, streaming do cliente e streaming bidirecional.

Instalação e configuração

Adicione as dependências ao Cargo.toml:

[dependencies]tonic = "0.12"prost = "0.13"tokio = { version = "1", features = ["full"] }

[build-dependencies]tonic-build = "0.12"

Definição do serviço protobuf

Crie o arquivo proto/hello.proto:

syntax = "proto3";

package hello;

service Greeter {    rpc SayHello (HelloRequest) returns (HelloReply);}

message HelloRequest {    string name = 1;}

message HelloReply {    string message = 1;}

Compilação do protobuf

No build.rs, especifique:

fn main() -> Result<(), Box<dyn std::error::Error>> {    tonic_build::compile_protos("proto/hello.proto")?;    Ok(())}

Implementação do servidor

Exemplo de um servidor gRPC simples com Tonic:

use tonic::{transport::Server, Request, Response, Status};use hello::greeter_server::{Greeter, GreeterServer};use hello::{HelloRequest, HelloReply};

pub mod hello {    tonic::include_proto!("hello");}

#[derive(Default)]pub struct MyGreeter;

#[tonic::async_trait]impl Greeter for MyGreeter {    async fn say_hello(        &self,        request: Request<HelloRequest>,    ) -> Result<Response<HelloReply>, Status> {        let name = request.into_inner().name;        let reply = HelloReply {            message: format!("Olá, {}!", name),        };        Ok(Response::new(reply))    }}

#[tokio::main]async fn main() -> Result<(), Box<dyn std::error::Error>> {    let addr = "[::1]:50051".parse()?;    let greeter = MyGreeter::default();

    Server::builder()        .add_service(GreeterServer::new(greeter))        .serve(addr)        .await?;

    Ok(())}

Cliente

use hello::greeter_client::GreeterClient;use hello::HelloRequest;

pub mod hello {    tonic::include_proto!("hello");}

#[tokio::main]async fn main() -> Result<(), Box<dyn std::error::Error>> {    let mut client = GreeterClient::connect("http://[::1]:50051").await?;

    let request = tonic::Request::new(HelloRequest {        name: "Mundo".into(),    });

    let response = client.say_hello(request).await?;    println!("Resposta do servidor: {}", response.into_inner().message);    Ok(())}

2. grpc-rs — alternativa madura

grpc-rs é uma biblioteca da equipe TiKV, construída sobre a biblioteca C gRPC Core. Ela oferece máxima compatibilidade com o framework gRPC C oficial, mas requer a instalação de dependências do sistema (cmake, protobuf). grpc-rs suporta chamadas síncronas e assíncronas, mas é inferior ao Tonic em facilidade de uso.

Exemplo de servidor com grpc-rs

use grp