对象存储
对象存储
对象存储
文档指南
请输入
产品动态
产品公告
产品计费
快速入门
用户指南
存储桶管理
基础设置
容错与容灾
ObjectSet
文件管理
监控与告警
权限配置
IAM 策略管理
典型配置场景
IAM 子用户授权
使用工具及 SDK 的授权说明
接入点
单区域接入点（SRAP）
内容感知与处理（SenseFlow）
TOS Agent
数据处理
分层命名空间（HNS）
TOS Vectors
API 参考
向量桶
SDK 参考
Python-Vectors
向量桶
向量索引
Java-Vectors
向量桶
向量索引
Node.js-Vectors
向量桶
向量索引
工具指南
tosutil
常用命令
辅助命令
TOS Browser
FSX
TOS PyTorch Connector
tosfsspec
API 参考
签名机制
存储桶
桶基础操作
自定义域名
数据处理
媒体处理
视频转码
音频转码
ObjectSet
生命周期
对象
基础操作
分片上传
SDK 参考
Java
存储桶接口
管理桶配置
ObjectSet
对象接口
下载对象
数据处理
视频处理
日志配置
分层命名空间
Python
数据处理
存储桶接口
对象接口
上传对象
C++
存储桶接口
对象接口
Go
对象接口
存储桶接口
管理桶配置
ObjectSet
数据处理
日志配置
Node.js
存储桶接口
对象接口
上传对象
数据处理
Browser.js
上传对象
.NET
对象接口
PHP
对象接口
异常处理
Android
对象接口
iOS
对象接口
Harmony
存储桶接口
对象接口
上传对象
Rust
存储桶接口
桶基础操作
桶清单
自定义域名
对象接口
基础操作
错误码
01-SERVICE_ERROR
02-AUTH
03-ACCESS_CONTROL
04-QOS
05-REQUEST
06-BUCKET
07-LIFECYCLE
08-ACL
09-CORS
10-POLICY
11-MIRROR
12-REPLICATION
13-WEBSITE
14-NOTIFICATION
15-ENCRYPT
16-CUSTOMDOMAIN
17-OBJECT
18-TAG
19-MULTIPART
20-STORAGE_CLASS
21-CALLBACK
22-DATA_PROCESS
23-BATCH
24-STORAGE_LENS
25-INVENTORY
26-DIRECTORY_BUCKET
32-WORM
常见问题
最佳实践
AIGC-豆包大模型最佳实践
校验数据一致性
- 文档首页
对象存储SDK 参考Rust存储桶接口自定义域名PutBucketCustomDomain（Rust SDK）
复制全文
下载 pdfPutBucketCustomDomain（Rust SDK）
文档反馈
问问助手put_bucket_custom_domain 接口用于为存储桶绑定自定义域名，本文介绍如何通过 Rust SDK 的 put_bucket_custom_domain 接口完成绑定。绑定后需将域名 CNAME 指向桶外网域名。
注意事项
- 您需要根据实际情况，填写示例代码中的地域和访问域名，详细介绍，请参见 地域和访问域名。
- 为了防止密钥泄露，本文示例代码需要从环境变量中读取 Access Key ID 和 Secret Access Key。因此使用 SDK 前，您需要配置长期访问凭证，详细介绍，请参见 配置长期访问凭证。
- 每个存储桶最多可绑定 20 条自定义域名，超出后 put_bucket_custom_domain 将返回错误。
- 请求体中 domain 字段必须填写已通过 ICP 备案的域名，否则 put_bucket_custom_domain 不会生效。
- 若 cert_id 留空，put_bucket_custom_domain 将使用 HTTP 协议；提供 cert_id 后，系统强制使用 HTTPS 并校验证书有效性。
权限说明
火山引擎主账号默认拥有全部权限，但是 IAM 用户默认没有任何权限。如果您需要使用子账号执行 put_bucket_custom_domain 操作，火山引擎主账号需通过 IAM策略和桶策略为该子账号授予以下权限：
tos:PutBucketCustomDomain
代码示例
为存储桶绑定自定义域名
use async_trait::async_trait;
use futures_core::future::BoxFuture;
use std::env;
use std::future::Future;
use std::sync::Arc;
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::{CustomDomainRule, PutBucketCustomDomainInput};
use ve_tos_rust_sdk::enumeration::AuthProtocolType;
#[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 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 rule = CustomDomainRule::new("example.com", AuthProtocolType::AuthProtocolTos);
// 创建输入参数
let input = PutBucketCustomDomainInput::new("my-bucket", rule);
// 调用接口绑定自定义域名
let output = client.put_bucket_custom_domain(&input).await;
match output {
Ok(output) => {
println!("自定义域名绑定成功，请求ID: {}", output.request_id());
}
Err(err) => {
eprintln!("自定义域名绑定失败: {:?}", err);
}
}
}
为存储桶设置多条自定义域名
use async_trait::async_trait;
use futures_core::future::BoxFuture;
use std::env;
use std::future::Future;
use std::sync::Arc;
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::{CustomDomainRule, PutBucketCustomDomainInput};
use ve_tos_rust_sdk::enumeration::AuthProtocolType;
#[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 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 domains = vec![
("domain1.com", AuthProtocolType::AuthProtocolTos, ""),
("domain2.com", AuthProtocolType::AuthProtocolS3, "cert-1234567890"),
("domain3.com", AuthProtocolType::AuthProtocolTos, ""),
];
for (domain, protocol, cert_id) in domains {
// 创建自定义域名规则
let mut rule = CustomDomainRule::new(domain, protocol);
// 如果有证书ID则设置
if !cert_id.is_empty() {
rule.set_cert_id(cert_id);
}
// 创建输入参数
let input = PutBucketCustomDomainInput::new("my-bucket", rule);
// 调用接口绑定自定义域名
let output = client.put_bucket_custom_domain(&input).await;
match output {
Ok(output) => {
println!("域名 {} 绑定成功，请求ID: {}", domain, output.request_id());
}
Err(err) => {
eprintln!("域名 {} 绑定失败: {:?}", domain, err);
}
}
}
}
为自定义域名设置证书 ID
use async_trait::async_trait;
use futures_core::future::BoxFuture;
use std::env;
use std::future::Future;
use std::sync::Arc;
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::{CustomDomainRule, PutBucketCustomDomainInput};
use ve_tos_rust_sdk::enumeration::AuthProtocolType;
#[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 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 mut rule = CustomDomainRule::new("secure-domain.com", AuthProtocolType::AuthProtocolTos);
// 设置证书ID
rule.set_cert_id("cert-***");
// 创建输入参数
let input = PutBucketCustomDomainInput::new("my-bucket", rule);
// 调用接口绑定自定义域名
let output = client.put_bucket_custom_domain(&input).await;
match output {
Ok(output) => {
println!("带证书的自定义域名绑定成功，请求ID: {}", output.request_id());
}
Err(err) => {
eprintln!("带证书的自定义域名绑定失败: {:?}", err);
}
}
}
使用 S3 协议绑定自定义域名
use async_trait::async_trait;
use futures_core::future::BoxFuture;
use std::env;
use std::future::Future;
use std::sync::Arc;
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::{CustomDomainRule, PutBucketCustomDomainInput};
use ve_tos_rust_sdk::enumeration::AuthProtocolType;
#[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 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();
// 使用S3协议创建自定义域名规则
let rule = CustomDomainRule::new("s3-domain.com", AuthProtocolType::AuthProtocolS3);
// 创建输入参数
let input = PutBucketCustomDomainInput::new("my-bucket", rule);
// 调用接口绑定自定义域名
let output = client.put_bucket_custom_domain(&input).await;
match output {
Ok(output) => {
println!("S3协议自定义域名绑定成功，请求ID: {}", output.request_id());
}
Err(err) => {
eprintln!("S3协议自定义域名绑定失败: {:?}", err);
}
}
}
使用 TOS 协议绑定自定义域名
use async_trait::async_trait;
use futures_core::future::BoxFuture;
use std::env;
use std::future::Future;
use std::sync::Arc;
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::{CustomDomainRule, PutBucketCustomDomainInput};
use ve_tos_rust_sdk::enumeration::AuthProtocolType;
#[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 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();
// 使用TOS协议创建自定义域名规则
let rule = CustomDomainRule::new("my-domain.com", AuthProtocolType::AuthProtocolTos);
// 创建输入参数
let input = PutBucketCustomDomainInput::new("my-bucket", rule);
// 调用接口绑定自定义域名
let output = client.put_bucket_custom_domain(&input).await;
match output {
Ok(output) => {
println!(
"TOS协议自定义域名绑定成功，请求ID: {}",
output.request_id()
);
}
Err(err) => {
eprintln!("TOS协议自定义域名绑定失败: {:?}", err);
}
}
}
相关文档
最近更新时间：2025.12.22 16:33:48
这个页面对您有帮助吗？
有用
有用
无用
无用