0Pricing
Learn Rust Coding · Leçon

Appeler depuis un client gRPC

Utilisez le service.

Appeler depuis un client gRPC est une leçon Learn Rust Coding gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Learn Rust Coding, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Learn Rust Coding comprend 4 leçons au total.

Le client généré

Pour chaque service, tonic génère une structure cliente, par exemple GreeterClient, dans le module greeter_client. Elle expose une méthode asynchrone par rpc.

Vous la construisez à partir d’un canal de transport ou en vous connectant directement à un point de terminaison.

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

Se connecter à un serveur

La méthode la plus simple est GreeterClient::connect, qui accepte une chaîne d’adresse et renvoie un client connecté.

Elle s’exécute dans un contexte asynchrone ; appelez-la donc sous #[tokio::main] avec .await.

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

Effectuer un appel unaire

Encapsulez votre message dans une tonic::Request (ou utilisez Request::new), puis appelez la méthode générée.

La réponse est une tonic::Response ; appelez .into_inner() pour lire le message.

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

Gérer les erreurs Status

Si le serveur renvoie une erreur, l’appel se résout en Err(Status). Examinez status.code() et status.message() pour réagir.

Cela reflète le fonctionnement côté serveur : des codes comme NotFound ou Unauthenticated sont transmis au client.

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

Construire un canal

Pour le réutiliser et le configurer, construisez explicitement un Channel avec Endpoint. Vous pouvez définir des délais d’attente, le maintien en vie TCP et les options de connexion.

Construisez ensuite le client avec 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);

Envoyer des métadonnées

Ajoutez des en-têtes tels que les jetons d’authentification en les insérant dans les métadonnées de la requête avant l’envoi.

Utilisez MetadataValue pour la valeur ; celle-ci doit être une valeur d’en-tête ASCII valide.

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);

Délais d’attente par appel

Définissez une échéance afin qu’un serveur lent ne bloque pas le client. set_timeout sur la requête l’interrompt avec un état DeadlineExceeded si l’échéance est dépassée.

Les échéances sont propagées au serveur, qui peut ainsi interrompre son travail plus tôt.

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?;

Consommer un flux serveur

Un appel en flux côté serveur renvoie un flux. Récupérez-le avec into_inner() et extrayez les messages avec message().await dans une boucle jusqu’à obtenir None.

Chaque itération fournit une réponse décodée.

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

Flux côté client

Pour un appel en flux côté client, transmettez un flux asynchrone de requêtes. Encapsulez un itérateur ou un canal avec tokio_stream, puis transmettez-le à la méthode.

La réponse unique arrive une fois l’envoi terminé.

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

Connexions TLS

Pour un transport chiffré, configurez un ClientTlsConfig avec un certificat CA et le domaine du serveur, puis connectez-vous via https.

Cela nécessite la fonctionnalité tls de la dépendance tonic.

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?;

Réutiliser le client

Le Channel sous-jacent est peu coûteux à cloner et multiplexe les requêtes sur une seule connexion HTTP/2. Clonez le client entre les tâches plutôt que de vous reconnecter.

Cela limite le coût d’établissement des connexions en situation de concurrence.

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

Vérification rapide

Comment lire le résultat d’un appel client unaire dans tonic ?

Récapitulatif

Vous avez connecté un client généré, effectué des appels unaires, géré les erreurs Status, construit des canaux configurés, envoyé des métadonnées, défini des échéances, consommé les flux serveur et client, activé TLS et réutilisé des clients faciles à cloner.

Vous pouvez maintenant construire des services gRPC complets basés sur tonic, de bout en bout.

Questions Fréquemment Posées

La leçon « Appeler depuis un client gRPC » est-elle gratuite ?

Oui — le texte complet de « Appeler depuis un client gRPC » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Learn Rust Coding, passe à CoddyKit PRO. Le cours Learn Rust Coding comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Appeler depuis un client gRPC » ?

Utilisez le service. Tu pratiques Learn Rust Coding avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Learn Rust Coding ?

Aucune expérience préalable n'est requise. Learn Rust Coding sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Appeler depuis un client gRPC » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Learn Rust Coding ?

Oui. Chaque leçon Learn Rust Coding inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Protobuf et définitions de services
  2. Générer du code avec tonic-build
  3. Implémenter un serveur gRPC
  4. Appeler depuis un client gRPC
← Retour à Learn Rust Coding