The get_object_tagging interface retrieves an object's tag information and supports specifying a version. This article explains how to use the Rust SDK's get_object_tagging interface to get tags.

Notes

You need to fill in the region and endpoint in the sample code according to your actual situation. For details, see Region and Endpoint.

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.

When the object version that version_id points to is a delete_marker, get_object_tagging returns 404 Not Found.

If version_id is not provided, get_object_tagging reads the current version's tags by default.

Permissions required

The Volcengine main account has all permissions by default, but IAM users have no permissions by default. If you need to perform the get_object_tagging operation using a sub-account, the Volcengine main account must grant the following permissions to the sub-account through IAM policies and bucket policies:

tos:GetObjectTagging

Code example

Retrieve object tag information

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::object::ObjectAPI;​
use ve_tos_rust_sdk::asynchronous::tos;​
use ve_tos_rust_sdk::asynchronous::tos::AsyncRuntime;​
use ve_tos_rust_sdk::object::{GetObjectTaggingInput, GetObjectTaggingOutput};​
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 = "example-bucket";​
    let key = "example-object.txt";​
    let input = GetObjectTaggingInput::new(bucket, key);​
    let output = client.get_object_tagging(&input).await;​
​
    match output {​
        Ok(output) => {​
            println!("version_id: {}", output.version_id());​
            let tags = output.tag_set().tags();​
            for (index, tag) in tags.iter().enumerate() {​
                println!("[{}] key: {}, value: {}", index, tag.key(), tag.value());​
            }​
        },​
        Err(err) => {​
            match err {​
                TosError::TosClientError { message, .. } => {​
                    println!("message: {}", message);​
                }​
                TosError::TosServerError { request_id, ec, code ,.. } =>  {​
                    println!("Server error: request_id: {}, ec: {}, code: {}", request_id, ec, code);​
                }​
            }​
        }​
    }​
}​