The delete_bucket_mirror_back interface deletes a Bucket’s mirror back-to-origin rule. This article explains how to delete the mirror back-to-origin rule using the Rust SDK's delete_bucket_mirror_back interface.

Notes

You need to fill in the region and access domain name in the sample code according to your situation. For details, see Region and Access Domain Name.

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

Hierarchical buckets do not support the delete_bucket_mirror_back interface.

After deletion, the mirror back-to-origin rule becomes invalid immediately, but cached data remains unaffected.

Permissions required

The Volcano Engine main account has all permissions by default, while IAM users have no permissions by default. If you need to use a sub-account to perform the delete_bucket_mirror_back operation, the Volcengine main account must grant the following permissions to the sub-account through IAM policy and bucket policy:

tos:DeleteBucketMirrorBack

Code example

Delete the origin fetch rule of the specified 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::DeleteBucketCORSInput;​
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() {​
    // init log​
    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 bucket = "your-bucket-name";​
​
    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();​
​
    // Create DeleteBucketCORS input​
    let input = DeleteBucketCORSInput::new(bucket);​
​
    // Call delete_bucket_cors API​
    let output = client.delete_bucket_cors(&input).await;​
​
    match output {​
        Ok(output) => {​
            println!("Successfully deleted bucket CORS configuration. Request ID: {}", output.request_id());​
        }​
        Err(err) => {​
            match err {​
                TosError::TosClientError { message, .. } => {​
                    println!("Client error: {}", message);​
                }​
                TosError::TosServerError { request_id, ec, message, .. } => {​
                    println!("Server error: Request ID = {}, Error Code = {}, Message = {}", request_id, ec, message);​
                }​
            }​
        }​
    }​
}​