0Pricing
Learn Rust Coding · Lektion

Von einem gRPC-Client aufrufen

Nutzen Sie den Dienst.

Von einem gRPC-Client aufrufen ist eine kostenlose Learn Rust Coding-Lektion auf CoddyKit. Dies ist Lektion 4 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.

Der generierte Client

Für jeden Service generiert tonic eine Client-Struktur, zum Beispiel GreeterClient, im Modul greeter_client. Sie stellt für jeden RPC eine asynchrone Methode bereit.

Sie erstellen sie aus einem Transportkanal oder verbinden sie direkt mit einem Endpunkt.

use greeter::v1::greeter_client::GreeterClient;
use greeter::v1::HelloRequest;

Mit einem Server verbinden

Am einfachsten verwenden Sie GreeterClient::connect. Diese Methode nimmt eine Adresszeichenfolge entgegen und gibt einen verbundenen Client zurück.

Sie wird in einem asynchronen Kontext ausgeführt. Rufen Sie sie daher unter #[tokio::main] mit .await auf.

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

Einen unären Aufruf durchführen

Verpacken Sie Ihre Nachricht in einen tonic::Request (oder verwenden Sie Request::new) und rufen Sie die generierte Methode auf.

Die Antwort ist ein tonic::Response; rufen Sie .into_inner() auf, um die Nachricht zu lesen.

let request = tonic::Request::new(HelloRequest { name: "Ada".into() });
let response = client.say_hello(request).await?;
println!("{}", response.into_inner().message);

Statusfehler behandeln

Wenn der Server einen Fehler zurückgibt, wird der Aufruf zu Err(Status) aufgelöst. Prüfen Sie status.code() und status.message(), um entsprechend zu reagieren.

Das entspricht der Serverseite: Codes wie NotFound oder Unauthenticated werden an den Client zurückübertragen.

match client.say_hello(req).await {
    Ok(resp) => println!("{}", resp.into_inner().message),
    Err(status) => eprintln!("{}: {}", status.code(), status.message()),
}

Einen Channel erstellen

Für Wiederverwendung und Konfiguration erstellen Sie mit Endpoint explizit einen Channel. Sie können Timeouts, TCP-Keepalive und Verbindungsoptionen festlegen.

Erstellen Sie den Client anschließend mit GreeterClient::new(channel).

use tonic::transport::{Channel, Endpoint};
let channel = Endpoint::from_static("http://[::1]:50051")
    .timeout(std::time::Duration::from_secs(5))
    .connect()
    .await?;
let mut client = GreeterClient::new(channel);

Metadaten senden

Fügen Sie Header wie Authentifizierungstokens hinzu, indem Sie sie vor dem Senden in die Request-Metadaten eintragen.

Verwenden Sie für den Wert MetadataValue; er muss ein gültiger ASCII-Headerwert sein.

use tonic::metadata::MetadataValue;
let mut req = tonic::Request::new(HelloRequest { name: "Ada".into() });
let token: MetadataValue<_> = "Bearer abc123".parse()?;
req.metadata_mut().insert("authorization", token);

Deadlines pro Aufruf

Legen Sie eine Deadline fest, damit ein langsamer Server den Client nicht blockiert. set_timeout für den Request bricht ihn bei Überschreitung mit einem DeadlineExceeded-Status ab.

Deadlines werden an den Server weitergegeben, der die Arbeit vorzeitig beenden kann.

let mut req = tonic::Request::new(HelloRequest { name: "Ada".into() });
req.set_timeout(std::time::Duration::from_secs(2));
let resp = client.say_hello(req).await?;

Einen Server-Stream verarbeiten

Ein Aufruf mit Server-Streaming gibt einen Stream zurück. Holen Sie ihn mit into_inner() heraus und rufen Sie in einer Schleife message().await auf, bis None zurückgegeben wird.

Jede Schleifeniteration liefert eine dekodierte Antwort.

let mut stream = client.server_stream(req).await?.into_inner();
while let Some(item) = stream.message().await? {
    println!("{:?}", item);
}

Client-Streaming

Bei einem Aufruf mit Client-Streaming übergeben Sie einen asynchronen Stream von Requests. Verpacken Sie einen Iterator oder Kanal mit tokio_stream und übergeben Sie ihn an die Methode.

Die einzelne Antwort kommt, nachdem Sie das Senden abgeschlossen haben.

use tokio_stream::iter;
let outbound = iter(vec![msg1, msg2, msg3]);
let response = client.client_stream(Request::new(outbound)).await?;
println!("{:?}", response.into_inner());

TLS-Verbindungen

Konfigurieren Sie für einen verschlüsselten Transport einen ClientTlsConfig mit einem CA-Zertifikat und der Server-Domain und verbinden Sie sich anschließend über https.

Dafür muss das tls-Feature der tonic-Abhängigkeit aktiviert sein.

use tonic::transport::{ClientTlsConfig, Endpoint};
let tls = ClientTlsConfig::new().domain_name("example.com");
let channel = Endpoint::from_static("https://example.com:50051")
    .tls_config(tls)?
    .connect()
    .await?;

Den Client wiederverwenden

Der zugrunde liegende Channel lässt sich kostengünstig klonen und multiplexed Anfragen über eine HTTP/2-Verbindung. Klonen Sie den Client für mehrere Tasks, statt die Verbindung erneut herzustellen.

So bleiben die Kosten für den Verbindungsaufbau bei gleichzeitigen Aufrufen gering.

let client = GreeterClient::new(channel);
let mut c1 = client.clone();
let mut c2 = client.clone();
// use c1 and c2 in separate tokio tasks

Kurze Überprüfung

Wie lesen Sie in tonic das Ergebnis eines unären Client-Aufrufs?

Zusammenfassung

Sie haben einen generierten Client verbunden, unäre Aufrufe durchgeführt, Status-Fehler behandelt, konfigurierte Channels erstellt, Metadaten gesendet, Deadlines festgelegt, Server- und Client-Streams verarbeitet, TLS aktiviert und kostengünstig geklonte Clients wiederverwendet.

Nun können Sie vollständige, auf tonic basierende gRPC-Services von Anfang bis Ende erstellen.

Häufig gestellte Fragen

Ist die Lektion „Von einem gRPC-Client aufrufen“ kostenlos?

Ja — der vollständige Text von „Von einem gRPC-Client aufrufen“ 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 „Von einem gRPC-Client aufrufen“?

Nutzen Sie den Dienst. 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 4 von 4.

Wie lange dauert die Lektion „Von einem gRPC-Client aufrufen“?

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

  1. Protobuf- und Servicedefinitionen
  2. Code mit tonic-build generieren
  3. Einen gRPC-Server implementieren
  4. Von einem gRPC-Client aufrufen
← Zurück zu Learn Rust Coding