rename_object 接口用于重命名对象并更新修改时间，本文介绍如何通过 Rust SDK 的 rename_object 接口完成对象重命名。

注意事项

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

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

rename 与版本控制功能互斥，已开启版本控制的扁平桶无法调用 rename_object。

rename 仅作用于功能开启后新上传的对象，不适用于存量对象（分层桶除外）。

归档、冷归档、深度冷归档类型对象需先恢复，方可调用 rename_object。

不支持并发对同一对象多次调用 rename_object。

权限说明

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

tos:RenameObject

代码示例

Basic object renaming

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::object::ObjectAPI;​
use ve_tos_rust_sdk::asynchronous::tos;​
use ve_tos_rust_sdk::asynchronous::tos::AsyncRuntime;​
use ve_tos_rust_sdk::object::RenameObjectInput;​
use ve_tos_rust_sdk::bucket::{PutBucketRenameInput, DeleteBucketRenameInput};​
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();​
​
    // Define parameters​
    let bucket = "example-bucket";​
    let old_key = "old-object.txt";​
    let new_key = "new-object.txt";​
​
    // Step 1: Enable bucket rename feature (required for flat buckets)​
    println!("Enabling bucket rename feature...");​
    let put_rename_input = PutBucketRenameInput::new(bucket, true);​
    let put_result = client.put_bucket_rename(&put_rename_input).await;​
    match put_result {​
        Ok(output) => {​
            println!("Bucket rename feature enabled successfully. Request ID: {}", output.request_id());​
        }​
        Err(err) => {​
            match err {​
                TosError::TosClientError { message, .. } => {​
                    println!("Client error when enabling bucket rename: {}", message);​
                }​
                TosError::TosServerError { request_id, ec, code, .. } => {​
                    println!("Server error when enabling bucket rename: Request ID: {}, EC: {}, Code: {}", request_id, ec, code);​
                }​
                _ => println!("Unexpected error when enabling bucket rename: {:?}", err),​
            }​
            return;​
        }​
    }​
​
    // Wait for feature propagation​
    println!("Waiting for bucket rename feature to take effect...");​
    tokio::time::sleep(Duration::from_secs(10)).await;​
​
    // Step 2: Perform basic object rename​
    println!("Performing basic object rename...");​
    let input = RenameObjectInput::new(bucket, old_key, new_key);​
    let rename_result = client.rename_object(&input).await;​
    match rename_result {​
        Ok(output) => {​
            println!("Object renamed successfully. Request ID: {}", output.request_id());​
        }​
        Err(err) => {​
            match err {​
                TosError::TosClientError { message, .. } => {​
                    println!("Client error when renaming object: {}", message);​
                }​
                TosError::TosServerError { request_id, ec, code, .. } => {​
                    println!("Server error when renaming object: Request ID: {}, EC: {}, Code: {}", request_id, ec, code);​
                }​
                _ => println!("Unexpected error when renaming object: {:?}", err),​
            }​
        }​
    }​
​
    // Step3: Cleanup - Disable bucket rename feature​
    println!("Disabling bucket rename feature...");​
    let delete_rename_input = DeleteBucketRenameInput::new(bucket);​
    let delete_result = client.delete_bucket_rename(&delete_rename_input).await;​
    match delete_result {​
        Ok(output) => {​
            println!("Bucket rename feature disabled successfully. Request ID: {}", output.request_id());​
        }​
        Err(err) => {​
            match err {​
                TosError::TosClientError { message, .. } => {​
                    println!("Client error when disabling bucket rename: {}", message);​
                }​
                TosError::TosServerError { request_id, ec, code, .. } => {​
                    println!("Server error when disabling bucket rename: Request ID: {}, EC: {}, Code: {}", request_id, ec, code);​
                }​
                _ => println!("Unexpected error when disabling bucket rename: {:?}", err),​
            }​
        }​
    }​
}​

对象存储