list_object_versions 接口用于列举桶中多版本对象，支持分页、前缀过滤。本文介绍如何通过 Rust SDK 的 list_object_versions 接口获取多版本列表。

注意事项

您需要根据实际情况，填写示例代码中的地域和访问域名，详细介绍，请参见地域和访问域名。

为了防止密钥泄露，本文示例代码需要从环境变量中读取 Access Key ID 和 Secret Access Key。因此使用 SDK 前，您需要配置长期访问凭证，详细介绍，请参见配置长期访问凭证。

分层桶暂不支持 ListObjectVersions 接口。

单次请求最多返回 1000 个多版本对象。

权限说明

火山引擎主账号默认拥有全部权限，但是 IAM 用户默认没有任何权限。如果您需要使用子账号执行 list_object_versions 操作，火山引擎主账号需通过 IAM策略和桶策略为该子账号授予以下权限：

tos:ListObjectVersions

代码示例

简单列举

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::object::ObjectAPI;​
use ve_tos_rust_sdk::asynchronous::tos;​
use ve_tos_rust_sdk::asynchronous::tos::AsyncRuntime;​
use ve_tos_rust_sdk::object::ListObjectVersionsInput;​
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();​
​
    // List all object versions of specified bucket​
    let mut input = ListObjectVersionsInput::new("example-bucket-2");​
    input.set_max_keys(100);​
    let output = client.list_object_versions(&input).await;​
​
    match output {​
        Ok(output) => {​
            println!("name: {}", output.name());​
            println!("prefix: {}", output.prefix());​
            println!("key_marker: {}", output.key_marker());​
            println!("version_id_marker: {}", output.version_id_marker());​
            println!("max_keys: {}", output.max_keys());​
            println!("delimiter: {}", output.delimiter());​
            println!("is_truncated: {}", output.is_truncated());​
            println!("encoding_type: {}", output.encoding_type());​
            println!("next_key_marker: {}", output.next_key_marker());​
            println!("next_version_id_marker: {}", output.next_version_id_marker());​
​
            println!("common_prefixes:");​
            for (idx, prefix) in output.common_prefixes().iter().enumerate() {​
                println!("[{}]: prefix: {}, last_modified: {:?}",​
                         idx,​
                         prefix.prefix(),​
                         prefix.last_modified().map(|dt| dt.format("%Y-%m-%dT%H:%M:%SZ").to_string())​
                );​
            }​
​
            println!("versions:");​
            for (idx, version) in output.versions().iter().enumerate() {​
                println!("[{}]:", idx);​
                println!("  key: {}", version.key());​
                println!("  last_modified: {:?}", version.last_modified().map(|dt| dt.format("%Y-%m-%dT%H:%M:%SZ").to_string()));​
                println!("  etag: {}", version.etag());​
                println!("  is_latest: {}", version.is_latest());​
                println!("  size: {}", version.size());​
                println!("  owner:");​
                println!("    id: {}", version.owner().id());​
                println!("  storage_class: {:?}", version.storage_class());​
                println!("  version_id: {}", version.version_id());​
                println!("  hash_crc64ecma: {}", version.hash_crc64ecma());​
            }​
​
            println!("delete_markers:");​
            for (idx, marker) in output.delete_markers().iter().enumerate() {​
                println!("[{}]:", idx);​
                println!("  key: {}", marker.key());​
                println!("  last_modified: {:?}", marker.last_modified().map(|dt| dt.format("%Y-%m-%dT%H:%M:%SZ").to_string()));​
                println!("  is_latest: {}", marker.is_latest());​
                println!("  owner:");​
                println!("    id: {}", marker.owner().id());​
                println!("  version_id: {}", marker.version_id());​
            }​
        }​
        Err(err) => {​
            match err {​
                TosError::TosClientError { message, .. } => {​
                    println!("Client error: message: {}", message);​
                }​
                TosError::TosServerError { request_id, ec, code, .. } => {​
                    println!("Server error: request_id: {}, status_code: {}, code: {}", request_id, ec, code);​
                }​
                _ => println!("Unknown error: {:?}", err),​
            }​
        }​
    }​
}​

列举指定前缀的对象版本

对象存储