Learn Rust Coding · บทเรียน

เรียกใช้จากไคลเอนต์ gRPC

เรียกใช้บริการ

เรียกใช้จากไคลเอนต์ gRPC เป็นบทเรียน Learn Rust Coding ฟรีบน CoddyKit นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Learn Rust Coding และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Learn Rust Coding มีบทเรียนทั้งหมด 4 บทเรียน

ไคลเอ็นต์ที่สร้างขึ้น

สำหรับแต่ละบริการ tonic จะสร้างโครงสร้างไคลเอ็นต์ เช่น GreeterClient ไว้ในโมดูล greeter_client โดยมีเมธอดแบบอะซิงโครนัสหนึ่งรายการต่อ rpc

คุณสร้างไคลเอ็นต์จากช่องทางการส่งข้อมูล หรือเชื่อมต่อโดยตรงกับปลายทางก็ได้

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

การเชื่อมต่อกับเซิร์ฟเวอร์

วิธีที่ง่ายที่สุดคือ GreeterClient::connect ซึ่งรับสตริงที่อยู่และคืนค่าไคลเอ็นต์ที่เชื่อมต่อแล้ว

เมธอดนี้ทำงานภายในบริบทแบบอะซิงโครนัส ดังนั้นให้เรียกภายใต้ #[tokio::main] พร้อม .await

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

การเรียกแบบเอกภาค

ห่อข้อความของคุณไว้ใน tonic::Request หรือใช้ Request::new แล้วเรียกเมธอดที่สร้างขึ้น

การตอบกลับเป็น tonic::Response ให้เรียก .into_inner() เพื่ออ่านข้อความ

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

การจัดการข้อผิดพลาดสถานะ

หากเซิร์ฟเวอร์คืนข้อผิดพลาด การเรียกจะได้ผลลัพธ์เป็น Err(Status) ตรวจสอบ status.code() และ status.message() เพื่อดำเนินการตอบสนอง

กลไกนี้เหมือนกับฝั่งเซิร์ฟเวอร์ โดยรหัสอย่าง NotFound หรือ Unauthenticated จะถูกส่งกลับมายังไคลเอ็นต์

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

การสร้างช่องทาง

หากต้องการนำกลับมาใช้ใหม่และกำหนดค่า ให้สร้าง Channel อย่างชัดเจนด้วย Endpoint คุณสามารถกำหนดเวลาหมดอายุ การคงการเชื่อมต่อ TCP และตัวเลือกการเชื่อมต่อได้

จากนั้นสร้างไคลเอ็นต์ด้วย 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);

การส่งข้อมูลเมตา

แนบส่วนหัว เช่น โทเค็นการยืนยันตัวตน โดยแทรกลงในข้อมูลเมตาของคำขอก่อนส่ง

ใช้ MetadataValue สำหรับค่า ซึ่งต้องเป็นค่าส่วนหัว 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);

กำหนดเวลาสิ้นสุดต่อการเรียก

กำหนดเวลาสิ้นสุดเพื่อไม่ให้เซิร์ฟเวอร์ที่ทำงานช้าทำให้ไคลเอ็นต์ค้าง set_timeout บนคำขอจะยกเลิกคำขอพร้อมสถานะ DeadlineExceeded หากเกินกำหนด

กำหนดเวลาสิ้นสุดจะถูกส่งต่อไปยังเซิร์ฟเวอร์ ซึ่งสามารถหยุดงานได้ก่อน

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

การรับสตรีมจากเซิร์ฟเวอร์

การเรียกแบบสตรีมจากเซิร์ฟเวอร์จะคืนสตรีม ให้รับสตรีมด้วย into_inner() แล้วดึงข้อความด้วย message().await ในลูปจนกว่าจะได้ค่า None

แต่ละรอบจะให้การตอบกลับที่ถอดรหัสแล้วหนึ่งรายการ

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

การสตรีมจากไคลเอ็นต์

สำหรับการเรียกแบบสตรีมจากไคลเอ็นต์ ให้ส่งสตรีมคำขอแบบอะซิงโครนัส ห่อตัววนซ้ำหรือช่องด้วย tokio_stream แล้วส่งให้เมธอด

การตอบกลับเพียงรายการเดียวจะมาถึงหลังจากส่งข้อมูลเสร็จแล้ว

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

สำหรับการส่งข้อมูลที่เข้ารหัส ให้กำหนดค่า ClientTlsConfig ด้วยใบรับรอง CA และโดเมนของเซิร์ฟเวอร์ จากนั้นเชื่อมต่อผ่าน https

การทำเช่นนี้ต้องเปิดคุณลักษณะ tls ในการพึ่งพา 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?;

การใช้ไคลเอ็นต์ซ้ำ

Channel พื้นฐานโคลนได้โดยมีต้นทุนต่ำ และรวมคำขอหลายรายการไว้บนการเชื่อมต่อ HTTP/2 เดียว ให้โคลนไคลเอ็นต์ข้ามงานแทนการเชื่อมต่อใหม่

วิธีนี้ช่วยให้ต้นทุนการตั้งค่าการเชื่อมต่อต่ำเมื่อทำงานพร้อมกัน

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

ตรวจสอบอย่างรวดเร็ว

คุณอ่านผลลัพธ์ของการเรียกไคลเอ็นต์แบบเอกภาคใน tonic อย่างไร

สรุปทบทวน

คุณเชื่อมต่อไคลเอ็นต์ที่สร้างขึ้น เรียกแบบเอกภาค จัดการข้อผิดพลาด Status สร้างช่องทางที่กำหนดค่าแล้ว ส่งข้อมูลเมตา กำหนดเวลาสิ้นสุด รับสตรีมจากเซิร์ฟเวอร์และไคลเอ็นต์ เปิดใช้ TLS และนำไคลเอ็นต์ที่โคลนได้โดยมีต้นทุนต่ำกลับมาใช้ใหม่

ตอนนี้คุณสามารถสร้างบริการ gRPC ที่ใช้ tonic ได้ครบวงจร

คำถามที่พบบ่อย

บทเรียน “เรียกใช้จากไคลเอนต์ gRPC” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “เรียกใช้จากไคลเอนต์ gRPC” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Learn Rust Coding ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Learn Rust Coding มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “เรียกใช้จากไคลเอนต์ gRPC”

เรียกใช้บริการ คุณปฏิบัติ Learn Rust Coding ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Learn Rust Coding หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Learn Rust Coding บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 4 จากทั้งหมด 4 บทเรียน

บทเรียน “เรียกใช้จากไคลเอนต์ gRPC” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Learn Rust Coding นี้ได้ไหม

ได้ บทเรียน Learn Rust Coding ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

← กลับไปที่ Learn Rust Coding