Wywoływanie z klienta gRPC
Skorzysta Pan/Pani z usługi.
Wywoływanie z klienta gRPC to bezpłatna lekcja Learn Rust Coding na CoddyKit. To lekcja 4 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Learn Rust Coding, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Learn Rust Coding zawiera 4 lekcji w sumie.
Wygenerowany klient
Dla każdej usługi tonic generuje strukturę klienta, na przykład GreeterClient, w module greeter_client. Udostępnia ona jedną metodę asynchroniczną dla każdej procedury rpc.
Możesz ją utworzyć na podstawie kanału transportowego albo połączyć ją bezpośrednio z endpointem.
use greeter::v1::greeter_client::GreeterClient;
use greeter::v1::HelloRequest;Łączenie z serwerem
Najprostszym rozwiązaniem jest GreeterClient::connect, które przyjmuje adres w postaci ciągu znaków i zwraca połączonego klienta.
Działa ono w kontekście asynchronicznym, dlatego wywołaj je pod #[tokio::main], używając .await.
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let mut client = GreeterClient::connect("http://[::1]:50051").await?;
Ok(())
}Wykonywanie wywołania unarnego
Owiń komunikat w tonic::Request (albo użyj Request::new) i wywołaj wygenerowaną metodę.
Odpowiedź ma typ tonic::Response; wywołaj .into_inner(), aby odczytać komunikat.
let request = tonic::Request::new(HelloRequest { name: "Ada".into() });
let response = client.say_hello(request).await?;
println!("{}", response.into_inner().message);Obsługa błędów Status
Jeśli serwer zwróci błąd, wywołanie zakończy się wynikiem Err(Status). Sprawdź status.code() i status.message(), aby odpowiednio zareagować.
Działa to tak samo jak po stronie serwera: kody takie jak NotFound lub Unauthenticated są przekazywane z powrotem do klienta.
match client.say_hello(req).await {
Ok(resp) => println!("{}", resp.into_inner().message),
Err(status) => eprintln!("{}: {}", status.code(), status.message()),
}Budowanie kanału
Aby móc ponownie używać kanału i konfigurować jego działanie, utwórz jawnie obiekt Channel za pomocą Endpoint. Możesz ustawić limity czasu, podtrzymywanie połączenia TCP oraz opcje połączenia.
Następnie utwórz klienta za pomocą 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);Wysyłanie metadanych
Dołącz nagłówki, takie jak tokeny uwierzytelniania, wstawiając je do metadanych żądania przed jego wysłaniem.
Użyj MetadataValue jako wartości; musi ona być prawidłową wartością nagłówka ASCII.
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);Limity czasu dla poszczególnych wywołań
Ustaw limit czasu, aby wolny serwer nie blokował klienta. set_timeout w żądaniu przerywa je i zwraca status DeadlineExceeded, jeśli limit zostanie przekroczony.
Limity czasu są przekazywane do serwera, który może wcześniej przerwać pracę.
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?;Odbieranie strumienia serwera
Wywołanie strumieniowane przez serwer zwraca strumień. Pobierz go za pomocą into_inner() i pobieraj komunikaty metodą message().await w pętli, aż zwróci None.
Każda iteracja dostarcza jedną zdekodowaną odpowiedź.
let mut stream = client.server_stream(req).await?.into_inner();
while let Some(item) = stream.message().await? {
println!("{:?}", item);
}Strumieniowanie klienta
W przypadku wywołania strumieniowanego przez klienta przekaż asynchroniczny strumień żądań. Owiń iterator lub kanał za pomocą tokio_stream i przekaż go do metody.
Pojedyncza odpowiedź nadejdzie po zakończeniu wysyłania.
use tokio_stream::iter;
let outbound = iter(vec![msg1, msg2, msg3]);
let response = client.client_stream(Request::new(outbound)).await?;
println!("{:?}", response.into_inner());Połączenia TLS
Aby skonfigurować szyfrowany transport, utwórz ClientTlsConfig z certyfikatem CA i domeną serwera, a następnie połącz się przez https.
Wymaga to funkcji tls w zależności 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?;Ponowne używanie klienta
Bazowy Channel można tanio klonować, a on sam multipleksuje żądania w ramach jednego połączenia HTTP/2. Klonuj klienta między zadaniami zamiast nawiązywać połączenie ponownie.
Dzięki temu koszty nawiązywania połączeń pozostają niskie przy współbieżności.
let client = GreeterClient::new(channel);
let mut c1 = client.clone();
let mut c2 = client.clone();
// use c1 and c2 in separate tokio tasksSzybkie sprawdzenie
Jak odczytać wynik unarnego wywołania klienta w tonic?
Podsumowanie
Połączyłeś wygenerowanego klienta, wykonałeś wywołania unarne, obsłużyłeś błędy Status, utworzyłeś skonfigurowane kanały, wysłałeś metadane, ustawiłeś limity czasu, odebrałeś strumienie serwera i klienta, włączyłeś TLS oraz ponownie wykorzystałeś tanio klonowanych klientów.
Możesz teraz tworzyć kompletne usługi gRPC oparte na tonic — od początku do końca.
Ucz się Rust dzięki korepetycjom AI — za darmo
Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.
- Kursy
- 39
- Lekcje
- 144
Często zadawane pytania
Czy lekcja „Wywoływanie z klienta gRPC” jest bezpłatna?
Tak — pełny tekst „Wywoływanie z klienta gRPC” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Learn Rust Coding, przejdź na CoddyKit PRO. Kurs Learn Rust Coding zawiera 4 lekcji w sumie.
Co nauczysz się w „Wywoływanie z klienta gRPC”?
Skorzysta Pan/Pani z usługi. Ćwiczysz Learn Rust Coding z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.
Czy potrzebuję doświadczenia, aby zacząć Learn Rust Coding?
Nie wymagamy żadnego doświadczenia. Learn Rust Coding w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 4 z 4.
Ile czasu zajmuje lekcja „Wywoływanie z klienta gRPC”?
Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.
Czy mogę pisać i uruchamiać kod w tej lekcji Learn Rust Coding?
Tak. Każda lekcja Learn Rust Coding zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.
Wszystkie lekcje w tym kursie
- Protobuf i definicje usług
- Generowanie kodu za pomocą tonic-build
- Implementowanie serwera gRPC
- Wywoływanie z klienta gRPC