Docs

Torch Object Storage

Access monitor

GetBucketAccessMonitor（Rust SDK）

The get_bucket_access_monitor interface retrieves the bucket access tracking configuration, returning either Enabled or Disabled status. This article explains how to query this configuration through the Rust SDK's get_bucket_access_monitor interface.

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 endpoints.

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 must configure long-term access credentials. For details, see Configuring long-term access credentials.

Only supports querying access tracking configurations for existing buckets. If the bucket does not exist, it returns 404 NoSuchBucket.

The returned Status field contains only Enabled or Disabled; any other value is considered an invalid response.

Permissions required

The Volcengine main account has all permissions by default, but IAM users have no permissions by default. If you need to use a subaccount to perform the get_bucket_access_monitor operation, the Volcengine main account must grant the following permissions to the subaccount through IAM policies and Bucket policies:

tos:GetBucketAccessMonitor

Code example

Obtain the access tracking configuration 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::{GetBucketAccessMonitorInput, GetBucketAccessMonitorOutput};​
use ve_tos_rust_sdk::enumeration::StatusType;​
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();​
​
    // Get access monitor config of an existing bucket​
    let bucket_name = "example-bucket";​
    let input = GetBucketAccessMonitorInput::new(bucket_name);​
    let output = client.get_bucket_access_monitor(&input).await;​
​
    match output {​
        Ok(output) => {​
            println!("status: {}", output.status().as_str());​
        },​
        Err(err) => {​
            match err {​
                TosError::TosClientError { message, .. } => {​
                    println!("Client error: message: {}", message);​
                },​
                TosError::TosServerError { request_id, ec, code, .. } => {​
                    println!("Server error: request_id: {}, ec: {}, code: {}", request_id, ec, code);​
                }​
            }​
        }​
    }​
}​