The delete_bucket_custom_domain API deletes a specific custom domain configuration of a bucket. This article explains how to perform this operation using the delete_bucket_custom_domain API in the Rust SDK.

Notes

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

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.

The caller must be the bucket owner or have DeleteBucketCustomDomain permission.

The customdomain parameter only supports a single domain name and does not support batch deletion.

If the customdomain value does not match any domain bound to the bucket, the API returns 404 NoSuchCustomDomain.

After successful deletion, the domain will stop resolving to the bucket within 1 minute.

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 delete_bucket_custom_domain operation, the Volcano Engine main account must grant the following permissions to that sub-account through IAM policies and bucket policies:

tos:DeleteBucketCustomDomain

Code example

Delete the custom domain configuration of a 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::asynchronous::bucket::BucketAPI;​
use ve_tos_rust_sdk::asynchronous::tos;​
use ve_tos_rust_sdk::asynchronous::tos::AsyncRuntime;​
use ve_tos_rust_sdk::bucket::DeleteBucketCustomDomainInput;​
​
#[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() {​
    // Initialize the TOS client​
    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>()​
        .ak(ak)​
        .sk(sk)​
        .region(region)​
        .endpoint(endpoint)​
        .build().unwrap();​
​
    // Create a request to delete a custom domain​
    let input = DeleteBucketCustomDomainInput::new("example-bucket", "example.com");​
​
    // Perform a deletion operation​
    match client.delete_bucket_custom_domain(&input).await {​
        Ok(output) => {​
            println!("Deletion successful. Requesting ID: {}", output.request_id());​
            println!("Status code: {}", output.status_code());​
        }​
        Err(err) => {​
            eprintln!("Deletion failed: {:?}", err);​
        }​
    }​
}​