Docs

Torch Object Storage

Static website hosting

GetBucketWebsite（Rust SDK）

The get_bucket_website interface retrieves the static website configuration of a specified Bucket, including the homepage, error page, and redirect rules. This article explains how to query this configuration using the get_bucket_website interface of the Rust SDK.

Notes

You must 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, this article's 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.

Permissions required

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

tos:GetBucketWebsite

Code example

Get the website configuration for the specified storage space

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::GetBucketWebsiteInput;​
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_default();​
    let sk = env::var("TOS_SECRET_KEY").unwrap_or_default();​
    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 = "my-simple-bucket";​
    let input = GetBucketWebsiteInput::new(bucket_name);​
    let output = client.get_bucket_website(&input).await;​
    match output {​
        Ok(output) => {​
            println!("Request ID: {}", output.request_id());​
            println!("Index Document: {:?}", output.index_document());​
            println!("Error Document: {:?}", output.error_document());​
        },​
        Err(err) => match err {​
            TosError::TosClientError { message, .. } => println!("Client Error: {}", message),​
            TosError::TosServerError { request_id, ec, message, .. } => println!("Server Error: RequestID={}, EC={}, Message={}", request_id, ec, message),​
        }​
    }​
}​
​