0Pricing
Learn Rust Coding · Lezione

Effettuare chiamate da un client gRPC

Utilizzi il servizio.

Effettuare chiamate da un client gRPC è una lezione Learn Rust Coding gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Learn Rust Coding, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Learn Rust Coding include 4 lezioni in totale.

Il client generato

Per ogni servizio tonic genera una struct client, ad esempio GreeterClient, nel modulo greeter_client. Questa espone un metodo async per ogni rpc.

Può costruirla a partire da un canale di trasporto oppure connettendosi direttamente a un endpoint.

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

Connessione a un server

Il percorso più semplice consiste nell'usare GreeterClient::connect, che riceve una stringa contenente l'indirizzo e restituisce un client connesso.

Viene eseguito in un contesto async, quindi lo chiami con .await all'interno di #[tokio::main].

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

Esecuzione di una chiamata unary

Racchiuda il messaggio in una tonic::Request (oppure utilizzi Request::new) e chiami il metodo generato.

La risposta è una tonic::Response; chiami .into_inner() per leggere il messaggio.

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

Gestione degli errori Status

Se il server restituisce un errore, la chiamata si risolve in Err(Status). Esamini status.code() e status.message() per reagire di conseguenza.

Questo rispecchia il lato server: codici come NotFound o Unauthenticated vengono restituiti al client.

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

Creazione di un Channel

Per poterlo riutilizzare e configurare, crei esplicitamente un Channel con Endpoint. Può impostare timeout, keepalive TCP e opzioni di connessione.

Quindi costruisca il client con 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);

Invio dei metadati

Alleghi intestazioni come i token di autenticazione inserendole nei metadati della richiesta prima dell'invio.

Utilizzi MetadataValue per il valore; deve essere un valore di intestazione ASCII valido.

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

Scadenze per singola chiamata

Imposti una scadenza per evitare che un server lento blocchi il client. set_timeout sulla richiesta la interrompe con uno stato DeadlineExceeded se la scadenza viene superata.

Le scadenze vengono propagate al server, che può interrompere anticipatamente l'elaborazione.

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

Consumo di uno stream del server

Una chiamata con streaming dal server restituisce uno stream. Lo estragga con into_inner() e recuperi i messaggi con message().await in un ciclo, finché non restituisce None.

Ogni iterazione fornisce una risposta decodificata.

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

Streaming dal client

Per una chiamata con streaming dal client, passi uno stream async di richieste. Racchiuda un iteratore o un canale con tokio_stream e lo passi al metodo.

L'unica risposta arriva dopo che ha terminato l'invio.

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

Connessioni TLS

Per un trasporto crittografato, configuri un ClientTlsConfig con un certificato CA e il dominio del server, quindi si connetta tramite https.

Questa configurazione richiede la funzionalità tls nella dipendenza 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?;

Riutilizzo del client

Il Channel sottostante è economico da clonare e multipla le richieste su un'unica connessione HTTP/2. Cloni il client tra i task invece di riconnettersi.

In questo modo i costi di configurazione della connessione restano contenuti in caso di concorrenza.

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

Verifica rapida

Come si legge il risultato di una chiamata client unary in tonic?

Riepilogo

Ha connesso un client generato, eseguito chiamate unary, gestito gli errori Status, creato canali configurati, inviato metadati, impostato scadenze, consumato stream del server e del client, abilitato TLS e riutilizzato client economici da clonare.

Ora è in grado di creare servizi gRPC completi basati su tonic, dall'inizio alla fine.

Domande Frequenti

La lezione «Effettuare chiamate da un client gRPC» è gratuita?

Sì — il testo completo di «Effettuare chiamate da un client gRPC» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Learn Rust Coding, passa a CoddyKit PRO. Il corso Learn Rust Coding include 4 lezioni in totale.

Cosa imparerò in «Effettuare chiamate da un client gRPC»?

Utilizzi il servizio. Eserciti Learn Rust Coding con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Learn Rust Coding?

Non è richiesta alcuna esperienza precedente. Learn Rust Coding su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Effettuare chiamate da un client gRPC»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Learn Rust Coding?

Sì. Ogni lezione Learn Rust Coding include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Protobuf e definizioni dei servizi
  2. Generare codice con tonic-build
  3. Implementare un server gRPC
  4. Effettuare chiamate da un client gRPC
← Torna a Learn Rust Coding