gRPC en Rust: bibliotecas Tonic y Grpc-rs con ejemplos

gRPC para Rust: bibliotecas y ejemplos

gRPC es un framework de alto rendimiento para llamadas a procedimientos remotos (RPC) desarrollado por Google. Utiliza Protocol Buffers (protobuf) para la serialización de datos y HTTP/2 para el transporte. Gracias a su tipado estricto, transmisión bidireccional y baja latencia, gRPC se ha convertido en un estándar para la arquitectura de microservicios. En el ecosistema de Rust, existen dos bibliotecas principales para trabajar con gRPC: Tonic y grpc-rs. En este artículo, analizaremos sus características y proporcionaremos ejemplos prácticos.

1. Tonic — moderno y asíncrono

Tonic es la biblioteca gRPC más popular para Rust. Está construida sobre tokio y hyper, es completamente asíncrona y se integra perfectamente con el ecosistema de Rust. Tonic admite los cuatro tipos de llamadas gRPC: unarias, streaming del servidor, streaming del cliente y streaming bidireccional.

Instalación y configuración

Agregue las dependencias en Cargo.toml:

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

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

Definición del servicio protobuf

Cree el archivo proto/hello.proto:

syntax = "proto3";

package hello;

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

message HelloRequest {    string name = 1;}

message HelloReply {    string message = 1;}

Compilación de protobuf

En build.rs especifique:

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

Implementación del servidor

Ejemplo de un servidor gRPC simple con 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!("¡Hola, {}!", 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!("Respuesta del servidor: {}", response.into_inner().message);    Ok(())}

2. grpc-rs — una alternativa madura

grpc-rs es una biblioteca del equipo de TiKV, construida sobre la biblioteca C gRPC Core. Proporciona la máxima compatibilidad con el framework oficial gRPC en C, pero requiere la instalación de dependencias del sistema (cmake, protobuf). grpc-rs admite llamadas síncronas y asíncronas, pero es menos conveniente de usar que Tonic.

Ejemplo de servidor con grpc-rs

use grp