The put_bucket_versioning interface enables or suspends version control for a bucket. This article explains how to use the put_bucket_versioning interface in the Rust SDK to set version control, retain multiple object versions, and prevent accidental deletion.

Notes

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

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

Put_bucket_versioning operations are not supported for tiered buckets.

Version control is disabled 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 use a sub-account to perform the put_bucket_versioning operation, the Volcengine primary account must grant the following permissions to the sub-account through IAM policies and bucket policies:

tos:PutBucketVersioning

Code example

Enable bucket versioning

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::PutBucketVersioningInput;​
use ve_tos_rust_sdk::enumeration::VersioningStatusType;​
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 bucket_name = "example-bucket";​
    let input = PutBucketVersioningInput::new_with_status(bucket_name, VersioningStatusType::VersioningStatusEnabled);​
    let output = client.put_bucket_versioning(&input).await;​
    match output {​
        Ok(_) => println!("Successfully enabled versioning for bucket {}", bucket_name),​
        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)​
        }​
    }​
}​

Suspend bucket versioning

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::PutBucketVersioningInput;​
use ve_tos_rust_sdk::enumeration::VersioningStatusType;​
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 bucket_name = "example-bucket";​
    let input = PutBucketVersioningInput::new_with_status(bucket_name, VersioningStatusType::VersioningStatusSuspended);​
    let output = client.put_bucket_versioning(&input).await;​
    match output {​
        Ok(_) => println!("Successfully suspended versioning for bucket {}", bucket_name),​
        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)​
        }​
    }​
}​