Learn Rust Coding · Pelajaran

Mengimplementasikan Server gRPC

Sediakan metode RPC satu arah.

Mengimplementasikan Server gRPC adalah pelajaran Learn Rust Coding gratis di CoddyKit. Ini adalah pelajaran 3 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.

Trait Server yang Dibuat

Untuk layanan bernama Greeter, tonic menghasilkan sebuah trait di greeter_server. Anda mengimplementasikannya pada struct Anda sendiri untuk menyediakan perilakunya.

Trait tersebut bersifat async melalui #[tonic::async_trait], sehingga setiap metode merupakan async fn yang mengembalikan Result.

use greeter::v1::greeter_server::{Greeter, GreeterServer};
use greeter::v1::{HelloRequest, HelloReply};

Pembungkus Request dan Response

Metode menerima tonic::Request<T> dan mengembalikan tonic::Response<T>. Pembungkus ini membawa metadata, ekstensi, dan pesan bagian dalam.

Panggil .into_inner() untuk mendapatkan pesan yang telah didekodekan, dan Response::new(..) untuk membuat balasan.

let req: HelloRequest = request.into_inner();
let reply = HelloReply { message: format!("Hi {}", req.name) };
Ok(Response::new(reply))

Struct Server

Definisikan sebuah struct untuk menyimpan keadaan bersama apa pun, seperti kumpulan koneksi basis data. Jika tidak memiliki keadaan, struct ini sering menurunkan Default.

Anda akan mengimplementasikan trait yang dibuat pada struct ini.

#[derive(Default)]
pub struct MyGreeter {}

Mengimplementasikan Metode Unary

Beri anotasi pada blok impl dengan #[tonic::async_trait], lalu implementasikan setiap rpc sebagai async fn yang sesuai dengan tanda tangan yang dibuat.

Kembalikan Ok(Response::new(reply)) jika berhasil.

#[tonic::async_trait]
impl Greeter for MyGreeter {
    async fn say_hello(&self, request: Request<HelloRequest>)
        -> Result<Response<HelloReply>, Status> {
        let name = request.into_inner().name;
        Ok(Response::new(HelloReply { message: format!("Hello {name}") }))
    }
}

Mengembalikan Galat dengan Status

Galat dikembalikan sebagai tonic::Status, yang dipetakan ke kode status gRPC. Gunakan konstruktor seperti Status::invalid_argument atau Status::not_found.

String pesan dikirim kepada klien bersama kodenya.

if name.is_empty() {
    return Err(Status::invalid_argument("name must not be empty"));
}

Membangun dan Menyajikan

Gunakan tonic::transport::Server di dalam main asinkron. Tambahkan layanan Anda yang dibungkus dalam tipe ...Server yang dibuat, lalu panggil serve dengan alamat soket.

Makro #[tokio::main] menyediakan runtime.

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let addr = "[::1]:50051".parse()?;
    Server::builder()
        .add_service(GreeterServer::new(MyGreeter::default()))
        .serve(addr)
        .await?;
    Ok(())
}

Respons Aliran dari Server

Metode dengan aliran dari server mengembalikan tipe aliran. tonic menggunakan tipe terkait bersama aliran yang dikotakkan; kanal mpsc merupakan cara umum untuk memasok pesan.

Anda mengembalikan ReceiverStream yang dibungkus dalam Response.

use tokio_stream::wrappers::ReceiverStream;
let (tx, rx) = tokio::sync::mpsc::channel(8);
tokio::spawn(async move { tx.send(Ok(reply)).await.ok(); });
Ok(Response::new(ReceiverStream::new(rx)))

Membaca Metadata

Metadata request menyimpan header seperti token auth. Akses metadata dengan request.metadata() sebelum menggunakan body.

Kunci menggunakan ASCII dan tidak membedakan huruf besar-kecil; nilainya dikembalikan sebagai MetadataValue.

if let Some(token) = request.metadata().get("authorization") {
    // validate token
} else {
    return Err(Status::unauthenticated("missing token"));
}

Interceptor

Interceptor berjalan sebelum setiap request, sehingga cocok untuk auth atau pencatatan. Interceptor menerima Request dan mengembalikannya, atau mengembalikan galat Status.

Lampirkan interceptor dengan with_interceptor saat menambahkan layanan.

fn auth(req: Request<()>) -> Result<Request<()>, Status> {
    match req.metadata().get("authorization") {
        Some(_) => Ok(req),
        None => Err(Status::unauthenticated("no token")),
    }
}
// .add_service(GreeterServer::with_interceptor(svc, auth))

Penghentian yang Mulus

Gunakan serve_with_shutdown untuk berhenti menerima koneksi ketika sebuah future selesai, misalnya saat menerima sinyal Ctrl-C.

Request yang sedang berlangsung diselesaikan sebelum server keluar, sehingga koneksi tidak terputus secara tiba-tiba.

Server::builder()
    .add_service(GreeterServer::new(MyGreeter::default()))
    .serve_with_shutdown(addr, async {
        tokio::signal::ctrl_c().await.ok();
    })
    .await?;

Keadaan Bersama

Untuk membagikan keadaan yang dapat diubah di antara berbagai request, simpan keadaan tersebut di balik Arc dan primitif sinkronisasi seperti tokio::sync::Mutex di dalam struct server Anda.

tonic menggandakan layanan untuk setiap koneksi, jadi pegangan bersama yang murah untuk digandakan merupakan pola yang tepat.

use std::sync::Arc;
use tokio::sync::Mutex;

#[derive(Default)]
pub struct MyGreeter {
    hits: Arc<Mutex<u64>>,
}

Pemeriksaan Singkat

Bagaimana metode gRPC melaporkan kegagalan dalam tonic?

Ringkasan

Anda telah mengimplementasikan trait server yang dibuat: membuka request, mengembalikan response dan galat Status, menyajikan layanan dengan tokio, mengalirkan response, membaca metadata, menambahkan interceptor, melakukan penghentian yang mulus, serta membagikan keadaan melalui Arc.

Berikutnya, Anda akan membuat klien untuk memanggil server ini.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Mengimplementasikan Server gRPC” gratis?

Ya — teks lengkap “Mengimplementasikan Server 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 “Mengimplementasikan Server gRPC”?

Sediakan metode RPC satu arah. 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 3 dari 4.

Berapa lama pelajaran “Mengimplementasikan Server 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