Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Mengonfigurasi kebijakan polling

Pelajari cara mengonfigurasi kebijakan polling untuk operasi yang berjalan lama.Google Cloud Library klien untuk Rust menyediakan fungsi bantuan untuk menyederhanakan pemantauan progres operasi yang berjalan lama (LRO). Helper ini menggunakan kebijakan untuk mengonfigurasi frekuensi polling dan menentukan error polling mana yang bersifat sementara (dan dapat dicoba lagi dengan aman) dan error mana yang tidak dapat dipulihkan.

Dua kebijakan mengontrol perilaku loop LRO:

Kebijakan backoff polling mengontrol durasi waktu tunggu loop sebelum melakukan polling status LRO yang masih dalam proses.
Kebijakan error polling mengontrol tindakan yang harus dilakukan saat terjadi error polling. Beberapa error polling tidak dapat dipulihkan dan menunjukkan bahwa operasi dibatalkan atau pemanggil tidak memiliki izin untuk memeriksa status LRO. Error polling lainnya bersifat sementara dan menunjukkan masalah sementara di jaringan klien atau layanan.

Anda dapat menetapkan setiap kebijakan ini secara terpisah. Selain itu, Anda dapat menerapkan kebijakan ke semua LRO yang dimulai di klien atau mengubah kebijakan untuk satu permintaan.

Prasyarat

Panduan ini menggunakan layanan Cloud Storage untuk menjaga agar cuplikan kode tetap konkret, tetapi konsep yang sama berlaku untuk layanan lain yang menggunakan LRO.

Sebelum menggunakan panduan ini, ikuti Menggunakan Cloud Storage dengan Rust untuk mengaktifkan dan mengautentikasi Cloud Storage API.

Untuk mengetahui petunjuk penyiapan lengkap untuk library Rust, lihat Menyiapkan lingkungan pengembangan Anda.

Dependensi

Tambahkan dependensi berikut ke file Cargo.toml Anda:

cargo add google-cloud-storage google-cloud-lro

Mengonfigurasi frekuensi polling untuk semua permintaan di klien

Jika Anda berencana menggunakan kebijakan penundaan polling yang sama untuk sebagian besar permintaan dengan klien yang sama, pertimbangkan untuk menetapkan kebijakan sebagai opsi klien. Contoh kode ini mengonfigurasi frekuensi polling untuk semua permintaan ke layanan Cloud Storage.

pub async fn client_backoff(bucket: &str, folder: &str, dest: &str) -> Result<()> {
    // Use a type that implements the `PollingBackoffPolicy` trait, in this case
    // `ExponentialBackoffBuilder`.
    use google_cloud_gax::exponential_backoff::ExponentialBackoffBuilder;
    use google_cloud_lro::Poller;
    use std::time::Duration;

    let client = StorageControl::builder()
        // Initialize the policy with a chosen delay duration.
        .with_polling_backoff_policy(
            ExponentialBackoffBuilder::new()
                .with_initial_delay(Duration::from_millis(250))
                .with_maximum_delay(Duration::from_secs(10))
                .build()?,
        )
        .build()
        .await?;

    // Initiate an LRO using polling.
    let response = client
        .rename_folder()
        .set_name(format!("projects/_/buckets/{bucket}/folders/{folder}"))
        .set_destination_folder_id(dest)
        .poller()
        .until_done()
        .await?;

    println!("LRO completed, response={response:?}");

    Ok(())
}

Kecuali jika Anda mengganti kebijakan dengan setelan per permintaan, kebijakan akan tetap berlaku untuk operasi yang berjalan lama yang dimulai oleh klien.

Misalnya, panggilan berikut akan menggunakan kebijakan ini:

    let mut operation = client
        .rename_folder()
        /* more stuff */
        .send()
        .await?;

Dalam panggilan contoh ini, library klien menunggu selama 250 md setelah upaya polling pertama, lalu selama 500 md untuk upaya kedua. Upaya berikutnya menunggu selama 1 dtk, 2 dtk, 4 dtk, dan 8 dtk, lalu semua upaya selanjutnya menunggu selama 10 dtk.

Mengonfigurasi frekuensi polling untuk permintaan tertentu

Anda dapat mengonfigurasi frekuensi polling untuk setiap permintaan, yang menggantikan kebijakan yang ditetapkan di tingkat klien. Contoh:

pub async fn rpc_backoff(bucket: &str, folder: &str, dest: &str) -> Result<()> {
    // Use a type that implements the `PollingBackoffPolicy` trait, in this case
    // `ExponentialBackoffBuilder`.
    use google_cloud_gax::exponential_backoff::ExponentialBackoffBuilder;
    use std::time::Duration;

    // To configure the request, bring the RequestOptionsBuilder trait into
    // scope.
    use google_cloud_gax::options::RequestOptionsBuilder;
    use google_cloud_lro::Poller;

    let client = StorageControl::builder().build().await?;
    // Create the request builder.
    let response = client
        .rename_folder()
        // Configure the polling backoff policy.
        .with_polling_backoff_policy(
            ExponentialBackoffBuilder::new()
                .with_initial_delay(Duration::from_millis(250))
                .with_maximum_delay(Duration::from_secs(10))
                .build()?,
        )
        .set_name(format!("projects/_/buckets/{bucket}/folders/{folder}"))
        .set_destination_folder_id(dest)
        // Issue the polling request as normal.
        .poller()
        .until_done()
        .await?;

    println!("LRO completed, response={response:?}");

    Ok(())
}

Mengonfigurasi error polling yang dapat dicoba ulang untuk semua permintaan di klien

Untuk mengonfigurasi error yang dapat dicoba lagi, gunakan jenis yang menerapkan trait PollingErrorPolicy. Library klien menyediakan beberapa kebijakan; pilihan yang konservatif adalah Aip194Strict. Jika Anda berencana menggunakan kebijakan polling yang sama untuk sebagian besar permintaan dengan klien yang sama, pertimbangkan untuk menetapkan kebijakan sebagai opsi klien.

Contoh kode ini mengonfigurasi error polling yang dapat dicoba lagi untuk semua permintaan ke layanan Cloud Storage:

pub async fn client_error_policy(bucket: &str, folder: &str, dest: &str) -> Result<()> {
    // Use a type that implements the `PollingErrorPolicy` trait, in this case
    // `Aip194Strict`.
    use google_cloud_gax::polling_error_policy::Aip194Strict;
    use google_cloud_gax::polling_error_policy::PollingErrorPolicyExt;
    use google_cloud_lro::Poller;
    use std::time::Duration;

    // Add the polling policy that you want to use for all long-running
    // operations.
    let client = StorageControl::builder()
        .with_polling_error_policy(
            Aip194Strict
                .with_attempt_limit(100)
                .with_time_limit(Duration::from_secs(300)),
        )
        .build()
        .await?;

    // Initiate an LRO using polling.
    let response = client
        .rename_folder()
        .set_name(format!("projects/_/buckets/{bucket}/folders/{folder}"))
        .set_destination_folder_id(dest)
        .poller()
        .until_done()
        .await?;

    println!("LRO completed, response={response:?}");

    Ok(())
}

Meskipun kebijakan error polling menangani error selama loop tunggu LRO, Anda juga dapat menambahkan kebijakan coba lagi standar untuk menangani error sementara yang mungkin terjadi saat mengirim permintaan awal untuk memulai LRO:

    let client = StorageControl::builder()
        .with_retry_policy(
            retry_policy::Aip194Strict
                .with_attempt_limit(100)
                .with_time_limit(Duration::from_secs(300)),
        )
        .build()
        .await?;

Kecuali jika Anda mengganti kebijakan dengan setelan per permintaan, kebijakan ini akan tetap berlaku untuk operasi yang berjalan lama yang dimulai oleh klien. Misalnya, jika Anda melakukan panggilan berikut:

    let mut operation = client
        .rename_folder()
        /* more stuff */
        .send()
        .await?;

Catatan: Library klien hanya memperlakukan UNAVAILABLE (lihat AIP-194) sebagai error yang dapat dicoba lagi dan menghentikan polling setelah 100 upaya atau 300 detik, mana pun yang terjadi lebih dulu.

Mengonfigurasi error polling yang dapat dicoba lagi untuk permintaan tertentu

Anda dapat mengonfigurasi error polling yang dapat dicoba lagi untuk permintaan tertentu menggunakan jenis yang menerapkan trait PollingErrorPolicy dan membawa trait RequestOptionsBuilder ke dalam cakupan.

Contoh kode ini mengonfigurasi error polling yang dapat dicoba lagi untuk permintaan tertentu ke layanan Cloud Storage.

pub async fn rpc_error_policy(bucket: &str, folder: &str, dest: &str) -> Result<()> {
    // Use a type that implements the `PollingErrorPolicy` trait, in this case
    // `Aip194Strict`.
    use google_cloud_gax::polling_error_policy::Aip194Strict;
    use google_cloud_gax::polling_error_policy::PollingErrorPolicyExt;
    // Bring `RequestOptionsBuilder` into scope.
    use google_cloud_gax::options::RequestOptionsBuilder;
    use std::time::Duration;
    use google_cloud_lro::Poller;

    let client = StorageControl::builder().build().await?;

    // Create the request builder.
    let response = client
        .rename_folder()
        // Configure the polling error policy.
        .with_polling_error_policy(
            Aip194Strict
                .with_attempt_limit(100)
                .with_time_limit(Duration::from_secs(300)),
        )
        .set_name(format!("projects/_/buckets/{bucket}/folders/{folder}"))
        .set_destination_folder_id(dest)
        // Initialize the request.
        .poller()
        .until_done()
        .await?;

    println!("LRO completed, response={response:?}");

    Ok(())
}

Anda juga dapat mempertimbangkan untuk menambahkan kebijakan percobaan ulang, jika permintaan awal untuk memulai LRO gagal:

    let client = StorageControl::builder()
        .with_retry_policy(
            retry_policy::Aip194Strict
                .with_attempt_limit(100)
                .with_time_limit(Duration::from_secs(300)),
        )
        .build()
        .await?;

Mengonfigurasi kebijakan polling Tetap teratur dengan koleksi Simpan dan kategorikan konten berdasarkan preferensi Anda.