Tonic für Rust: Vollständiges Tutorial mit Beispielen

Was ist Tonic und warum wird es benötigt?

Tonic ist eine moderne, hochperformante Bibliothek zur Implementierung von gRPC-Servern und -Clients in Rust. Sie basiert auf der asynchronen Laufzeitumgebung Tokio und dem HTTP/2-Framework Hyper, was maximale Leistung und vollständige Kompatibilität mit dem gRPC-Standard gewährleistet.

Die wichtigsten Vorteile von Tonic:

• Native Asynchronität — vollständig async/await, ohne Blockierungen
• Typsicherheit — Codegenerierung aus Proto-Dateien zur Kompilierzeit
• Unterstützung aller gRPC-Muster — Unary, Server Streaming, Client Streaming, Bidirectional Streaming
• Integration in das Rust-Ökosystem — funktioniert mit Tokio, Tower, Hyper und anderen beliebten Crates
• Leistung — eines der schnellsten gRPC-Frameworks

Die Bibliothek wird in der Produktion von Unternehmen wie Discord, Microsoft, Amazon und vielen anderen eingesetzt. Tonic ist ideal für die Entwicklung von Microservices, API-Gateways und beliebigen verteilten Systemen, die eine effiziente Kommunikation zwischen Diensten erfordern.

Installation von Tonic

Um mit Tonic zu arbeiten, müssen Sie einige Abhängigkeiten installieren. Fügen Sie sie zu Ihrer Cargo.toml hinzu:

[dependencies]
tonic = "0.12"
prost = "0.13"
tokio = { version = "1.0", features = ["macros", "rt-multi-thread"] }

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

Erklärung der Abhängigkeiten:

• tonic — die Hauptbibliothek für die Arbeit mit gRPC
• prost — Generator für Protocol Buffers Code in Rust
• tokio — asynchrone Laufzeitumgebung
• tonic-build — wird während der Build-Phase zur Kompilierung von .proto-Dateien verwendet

Sie benötigen außerdem den Protocol Buffers Compiler protoc. Unter Ubuntu/Debian:

sudo apt install protobuf-compiler

Unter macOS:

brew install protobuf

Unter Windows laden Sie das Binary aus dem offiziellen Repository herunter und fügen es zu Ihrem PATH hinzu.

Schnellstart: Hello World mit gRPC

Wir erstellen einen einfachen Dienst, der einen Namen entgegennimmt und eine Begrüßung zurückgibt.

Schritt 1. Erstellen Sie die Datei proto/helloworld.proto:

syntax = "proto3";

package helloworld;

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

message HelloRequest {
    string name = 1;
}

message HelloReply {
    string message = 1;
}

Schritt 2. Erstellen Sie build.rs im Projektstamm:

fn main() -> Result<(), Box> {
    tonic_build::compile_protos("proto/helloworld.proto")?;
    Ok(())
}

Schritt 3. Implementieren Sie den Server (src/server.rs):

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

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

#[derive(Default)]
pub struct MyGreeter;

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

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

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

    Ok(())
}

Schritt 4. Erstellen Sie den Client