The put_bucket_inventory interface creates an inventory for a bucket. TOS outputs information such as object count, size, and storage type daily or weekly. This article explains how to create an inventory using the put_bucket_inventory interface in the Rust SDK.

Notes

You need to fill in the region and access domain in the sample code according to your situation. For details, see Regions and endpoints.

To prevent key leakage, the sample code reads the Access Key ID and Secret Access Key from environment variables. Therefore, before using the SDK, you need to configure long-term access credentials. For details, see Configure long-term access credentials.

You can configure each bucket with up to ten bucket inventory rules. Requests exceeding this limit will be rejected.

The source bucket and destination bucket must be in the same region; otherwise, the interface returns a 400 error.

The inventory file only supports CSV format and is compressed with GZIP by default.

Permissions required

The Volcano Engine main account has all permissions by default, but IAM users have no permissions by default. If you need to perform the put_bucket_inventory operation using a sub-account, the Volcano Engine main account must grant the following permissions to the sub-account through IAM policies and Bucket policies:

tos:PutBucketInventory

Code example

Create a basic bucket inventory for the storage bucket

use async_trait::async_trait; ​
use futures_core::future::BoxFuture;​
use std::env;​
use std::future::Future;​
use std::time::Duration;​
use tokio::runtime::Handle;​
use ve_tos_rust_sdk::common::init_tracing_log;​
use ve_tos_rust_sdk::asynchronous::bucket::BucketAPI;​
use ve_tos_rust_sdk::asynchronous::tos;​
use ve_tos_rust_sdk::asynchronous::tos::AsyncRuntime;​
use ve_tos_rust_sdk::bucket::{PutBucketInventoryInput, InventorySchedule, InventoryDestination, TOSBucketDestination };​
use ve_tos_rust_sdk::enumeration::{InventoryIncludedObjType, InventoryFormatType, InventoryFrequencyType};​
use ve_tos_rust_sdk::error::TosError;​
​
#[derive(Debug, Default)]​
pub struct TokioRuntime {}​
​
#[async_trait]​
impl AsyncRuntime for TokioRuntime {​
    type JoinError = tokio::task::JoinError;​
    async fn sleep(&self, duration: Duration) {​
        tokio::time::sleep(duration).await;​
    }​
​
    fn spawn<'a, F>(&self, future: F) -> BoxFuture<'a, Result<F::Output, Self::JoinError>>​
    where​
        F: Future + Send + 'static,​
        F::Output: Send + 'static,​
    {​
        Box::pin(Handle::current().spawn(future))​
    }​
​
    fn block_on<F: Future>(&self, future: F) -> F::Output {​
        Handle::current().block_on(future)​
    }​
}​
​
#[tokio::main]​
async fn main() {​
    let _guard = init_tracing_log("info", "temp/logs", "app.log");​
    let ak = env::var("TOS_ACCESS_KEY").unwrap_or("".to_string());​
    let sk = env::var("TOS_SECRET_KEY").unwrap_or("".to_string());​
    let endpoint = "https://tos-cn-beijing.volces.com";​
    let region = "cn-beijing";​
    let client = tos::builder::<TokioRuntime>()​
        .connection_timeout(3000)​
        .request_timeout(10000)​
        .max_retry_count(3)​
        .ak(ak)​
        .sk(sk)​
        .region(region)​
        .endpoint(endpoint)​
        .build().unwrap();​
​
    let mut input = PutBucketInventoryInput::new("example-bucket", "basic-inventory");​
    input.set_is_enabled(true);​
    input.set_schedule(InventorySchedule::new(InventoryFrequencyType::InventoryFrequencyDaily));​
​
    let mut tos_dest = TOSBucketDestination::new(InventoryFormatType::InventoryFormatCsv);​
    tos_dest.set_account_id("200000****");​
    tos_dest.set_role("provide your role");​
    tos_dest.set_bucket("destination-bucket");​
    let dest = InventoryDestination::new_with_tos_bucket_destination(tos_dest);​
    input.set_destination(dest);​
​
    input.set_included_object_versions(InventoryIncludedObjType::InventoryIncludedObjAll);​
​
    let output = client.put_bucket_inventory(&input).await;​
    match output {​
        Ok(output) => {​
            println!("request_id: {}", output.request_id());​
        }​
        Err(err) => {​
            match err {​
                TosError::TosClientError { message, .. } => {​
                    println!("Client error: {}", message);​
                }​
                TosError::TosServerError { request_id, ec, code, .. } => {​
                    println!("Server error: request_id: {}, ec: {}, code: {}", request_id, ec, code);​
                }​
                _ => println!("Unknown error: {:?}", err),​
            }​
        }​
    }​
}​