Learn Rust Coding · Pelajaran

Memanggil dari Klien gRPC

Gunakan layanan tersebut.

Pelajaran 4 dari 413 langkah

Memanggil dari Klien gRPC adalah pelajaran Learn Rust Coding gratis di CoddyKit. Ini adalah pelajaran 4 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Learn Rust Coding, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Learn Rust Coding mencakup 4 pelajaran total.

Klien yang Dibuat

Untuk setiap layanan, tonic menghasilkan struct klien, misalnya GreeterClient, di dalam modul greeter_client. Struct ini menyediakan satu metode asinkron untuk setiap rpc.

Anda dapat membuatnya dari kanal transportasi atau dengan terhubung langsung ke endpoint.

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

Terhubung ke Server

Cara paling sederhana adalah GreeterClient::connect, yang menerima string alamat dan mengembalikan klien yang telah terhubung.

Proses ini berjalan di dalam konteks asinkron, jadi panggil di bawah #[tokio::main] dengan .await.

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

Melakukan Panggilan Unary

Bungkus pesan Anda dalam tonic::Request (atau gunakan Request::new), lalu panggil metode yang dibuat.

Response berupa tonic::Response; panggil .into_inner() untuk membaca pesannya.

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

Menangani Galat Status

Jika server mengembalikan galat, panggilan tersebut menghasilkan Err(Status). Periksa status.code() dan status.message() untuk menentukan tindakan.

Hal ini sama seperti di sisi server: kode seperti NotFound atau Unauthenticated dikirim kembali kepada klien.

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

Membangun Kanal

Untuk penggunaan ulang dan konfigurasi, bangun Channel secara eksplisit dengan Endpoint. Anda dapat menetapkan batas waktu, keepalive TCP, dan opsi koneksi.

Kemudian buat klien dengan 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);

Mengirim Metadata

Lampirkan header seperti token auth dengan menyisipkannya ke metadata request sebelum mengirimkannya.

Gunakan MetadataValue untuk nilainya; nilainya harus berupa nilai header ASCII yang valid.

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

Batas Waktu per Panggilan

Tetapkan batas waktu agar server yang lambat tidak membuat klien menunggu tanpa akhir. set_timeout pada request akan membatalkan request dengan status DeadlineExceeded jika batas waktu terlampaui.

Batas waktu diteruskan ke server, yang dapat menghentikan pekerjaannya lebih awal.

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

Menggunakan Aliran dari Server

Panggilan dengan aliran dari server mengembalikan sebuah aliran. Ambil aliran tersebut dengan into_inner(), lalu tarik pesan dengan message().await dalam perulangan sampai menghasilkan None.

Setiap iterasi memberikan satu balasan yang telah didekodekan.

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

Aliran dari Klien

Untuk panggilan dengan aliran dari klien, berikan aliran request asinkron. Bungkus iterator atau kanal dengan tokio_stream, lalu berikan hasilnya ke metode tersebut.

Satu response diterima setelah Anda selesai mengirim.

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

Koneksi TLS

Untuk transportasi terenkripsi, konfigurasi ClientTlsConfig dengan sertifikat CA dan domain server, lalu terhubung melalui https.

Hal ini memerlukan fitur tls pada dependensi 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?;

Menggunakan Ulang Klien

Channel yang mendasarinya murah untuk digandakan dan memultipleks permintaan melalui satu koneksi HTTP/2. Gandakan klien ke berbagai tugas alih-alih menghubungkan ulang.

Dengan demikian, biaya penyiapan koneksi tetap rendah saat terjadi konkurensi.

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

Pemeriksaan Singkat

Bagaimana Anda membaca hasil panggilan klien unary dalam tonic?

Jawab di pelajaran interaktif

Ringkasan

Anda telah menghubungkan klien yang dibuat, melakukan panggilan unary, menangani galat Status, membangun kanal yang dikonfigurasi, mengirim metadata, menetapkan batas waktu, menggunakan aliran dari server dan klien, mengaktifkan TLS, serta menggunakan ulang klien yang murah untuk digandakan.

Sekarang Anda dapat membangun layanan gRPC berbasis tonic secara lengkap dari awal hingga akhir.

Gratis untuk memulai

Belajar Rust dengan tutor AI — gratis

Tulis dan jalankan kode asli di browser kamu, dapatkan bantuan instan dari tutor AI 24/7, dan lanjutkan di mana kamu tinggalkan di web atau aplikasi.

Kursus: 39
Pelajaran: 144

Mulai belajar gratis Lihat kursus lengkapnya

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Memanggil dari Klien gRPC” gratis?

Ya — teks lengkap “Memanggil dari Klien gRPC” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Learn Rust Coding, upgrade ke CoddyKit PRO. Kursus Learn Rust Coding mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Memanggil dari Klien gRPC”?

Gunakan layanan tersebut. Kamu berlatih Learn Rust Coding dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Learn Rust Coding?

Tidak diperlukan pengalaman sebelumnya. Learn Rust Coding di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 4 dari 4.

Berapa lama pelajaran “Memanggil dari Klien gRPC” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Learn Rust Coding ini?

Ya. Setiap pelajaran Learn Rust Coding menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke Learn Rust Coding