Learn Rust Coding · Lektion

Einen gRPC-Server implementieren

Stellen Sie unäre RPC-Methoden bereit.

Einen gRPC-Server implementieren ist eine kostenlose Learn Rust Coding-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Learn Rust Coding-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Learn Rust Coding-Kurs umfasst insgesamt 4 Lektionen.

Teile dieser Lektion wurden noch nicht übersetzt und werden auf Englisch angezeigt.

The Generated Server Trait

For a service named Greeter, tonic generates a trait in greeter_server. You implement it on your own struct to provide behavior.

The trait is async via #[tonic::async_trait], so each method is an async fn returning a Result.

use greeter::v1::greeter_server::{Greeter, GreeterServer};
use greeter::v1::{HelloRequest, HelloReply};

Request and Response Wrappers

Methods take a tonic::Request<T> and return a tonic::Response<T>. These wrappers carry metadata, extensions, and the inner message.

Call .into_inner() to get the decoded message, and Response::new(..) to build a reply.

let req: HelloRequest = request.into_inner();
let reply = HelloReply { message: format!("Hi {}", req.name) };
Ok(Response::new(reply))

A Server Struct

Define a struct to hold any shared state, like a database pool. Often it derives Default when stateless.

You will implement the generated trait on this struct.

#[derive(Default)]
pub struct MyGreeter {}

Implementing a Unary Method

Annotate the impl block with #[tonic::async_trait] and implement each rpc as an async fn matching the generated signature.

Return Ok(Response::new(reply)) on success.

#[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;
        Ok(Response::new(HelloReply { message: format!("Hello {name}") }))
    }
}

Returning Errors with Status

Errors are returned as tonic::Status, which maps to a gRPC status code. Use constructors like Status::invalid_argument or Status::not_found.

The message string is sent to the client alongside the code.

if name.is_empty() {
    return Err(Status::invalid_argument("name must not be empty"));
}

Building and Serving

Use tonic::transport::Server in an async main. Add your service wrapped in its generated ...Server type, then call serve with a socket address.

The #[tokio::main] macro provides the runtime.

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let addr = "[::1]:50051".parse()?;
    Server::builder()
        .add_service(GreeterServer::new(MyGreeter::default()))
        .serve(addr)
        .await?;
    Ok(())
}

Server Streaming Responses

A server-streaming method returns a stream type. tonic uses an associated type plus a boxed stream; an mpsc channel is a common way to feed messages.

You return a ReceiverStream wrapped in a Response.

use tokio_stream::wrappers::ReceiverStream;
let (tx, rx) = tokio::sync::mpsc::channel(8);
tokio::spawn(async move { tx.send(Ok(reply)).await.ok(); });
Ok(Response::new(ReceiverStream::new(rx)))

Reading Metadata

Request metadata holds headers like auth tokens. Access it with request.metadata() before consuming the body.

Keys are ASCII and case-insensitive; values are returned as MetadataValue.

if let Some(token) = request.metadata().get("authorization") {
    // validate token
} else {
    return Err(Status::unauthenticated("missing token"));
}

Interceptors

An interceptor runs before each request, ideal for auth or logging. It receives the Request and returns it or a Status error.

Attach it with with_interceptor when adding the service.

fn auth(req: Request<()>) -> Result<Request<()>, Status> {
    match req.metadata().get("authorization") {
        Some(_) => Ok(req),
        None => Err(Status::unauthenticated("no token")),
    }
}
// .add_service(GreeterServer::with_interceptor(svc, auth))

Graceful Shutdown

Use serve_with_shutdown to stop accepting connections when a future resolves, such as a Ctrl-C signal.

In-flight requests finish before the server exits, avoiding abrupt drops.

Server::builder()
    .add_service(GreeterServer::new(MyGreeter::default()))
    .serve_with_shutdown(addr, async {
        tokio::signal::ctrl_c().await.ok();
    })
    .await?;

Shared State

To share mutable state across requests, store it behind Arc and a synchronization primitive like tokio::sync::Mutex inside your server struct.

tonic clones the service per connection, so cheap-to-clone shared handles are the right pattern.

use std::sync::Arc;
use tokio::sync::Mutex;

#[derive(Default)]
pub struct MyGreeter {
    hits: Arc<Mutex<u64>>,
}

Quick Check

How do gRPC methods report failures in tonic?

Recap

You implemented the generated server trait: unwrapping requests, returning responses and Status errors, serving with tokio, streaming responses, reading metadata, adding interceptors, graceful shutdown, and sharing state via Arc.

Next you will build a client to call this server.

Häufig gestellte Fragen

Ist die Lektion „Einen gRPC-Server implementieren“ kostenlos?

Ja — der vollständige Text von „Einen gRPC-Server implementieren“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Learn Rust Coding-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Learn Rust Coding-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Einen gRPC-Server implementieren“?

Stellen Sie unäre RPC-Methoden bereit. Du übst Learn Rust Coding mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Learn Rust Coding zu starten?

Keine Vorkenntnisse erforderlich. Learn Rust Coding auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „Einen gRPC-Server implementieren“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Learn Rust Coding-Lektion Code schreiben und ausführen?

Ja. Jede Learn Rust Coding-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Learn Rust Coding