九游平台/ 对象存储服务 obs/ sdk参考/ / 其他接口(c sdk)/ c sdk通过自定义域名访问obs(c sdk)
更新时间：2025-02-18 gmt 08:00

c sdk通过自定义域名访问obs(c sdk)-九游平台

开发过程中，您有任何问题可以在github上，或者在中发帖求助。

使用自定义域名访问服务端之前，需要先在console界面配置自定义域名。

自定义域名访问介绍与配置

当以自定义域名访问obs桶时，需要先将该自定义域名同对应obs桶访问域名进行绑定，相关配置请参见自定义域名绑定简介，自定义域名绑定配置。

当在自定义域名上配置了cdn加速服务，即自定义域名为cdn服务的加速域名时，需要额外对cdn服务进行配置，以保证可以正常使用自定义域名访问obs服务。

以华为云cdn服务为例，相关配置如下所示：

  1. 登录华为云cdn服务，从cdn服务左侧列表中选择域名管理项，在该项中可以查看到所有配置的cdn服务域名信息。
  2. 配置源站。单击要使用的自定义域名项，进入域名配置界面，编辑源站配置，选择主源站类型为源站域名类型，对应源站为要访问的obs桶域名。

  3. 配置回源host。回源host必须指定为加速域名即访问obs服务时访问的自定义域名，否则可能会出现回源鉴权失败的问题。

通过sdk，使用自定义域名访问obs，可以完全复用对应接口的示例，只需要注意在设置option的时候，按如下方式设置：

option.bucket_options.usecname = true;
option.bucket_options.host_name = "yourcustomdomain";

代码示例一：通过自定义域名上传对象

以下示例展示如何通过自定义域名上传对象： 
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
 
#include"esdkobs.h"
#include
#include
// 响应回调函数，可以在这个回调中把properties的内容记录到callback_data(用户自定义回调数据)中
obs_statusresponse_properties_callback(constobs_response_properties*properties,void*callback_data);
intput_file_data_callback(intbuffer_size,char*buffer,
void*callback_data);
voidput_file_complete_callback(obs_statusstatus,
constobs_error_details*error,
void*callback_data);
typedefstructput_file_object_callback_data
{
file*infile;
uint64_tcontent_length;
obs_statusret_status;
}put_file_object_callback_data;
uint64_topen_file_and_get_length(char*localfile,put_file_object_callback_data*data);
intmain()
{
// 以下示例展示如何在使用自定义域名时通过put_object函数上传本地文件：：
// 在程序入口调用obs_initialize方法来初始化网络、内存等全局资源。
obs_initialize(obs_init_all);
obs_optionsoptions;
// 创建并初始化options，该参数包括访问域名(host_name)、访问密钥（access_key_id和acces_key_secret）、桶名(bucket_name)、桶存储类别(storage_class)等配置信息
init_obs_options(&options);
// host_name填写桶所在的endpoint, 此处以华北-北京四为例，其他地区请按实际情况填写。
options.bucket_options.host_name="obs.cn-north-4.myhuaweicloud.com";
// 认证用的ak和sk硬编码到代码中或者明文存储都有很大的安全风险，建议在配置文件或者环境变量中密文存放，使用时解密，确保安全；
// 本示例以ak和sk保存在环境变量中为例，运行本示例前请先在本地环境中设置环境变量access_key_id和secret_access_key。
options.bucket_options.access_key=getenv("access_key_id");
options.bucket_options.secret_access_key=getenv("secret_access_key");
char*bucketname="";
options.bucket_options.bucket_name=bucketname;
// 设置自定义域名
options.bucket_options.usecname=true;
options.bucket_options.host_name="example.obs.test.cname.com";
// 初始化上传对象属性
obs_put_propertiesput_properties;
init_put_properties(&put_properties);
// 上传对象名
char*key="example_get_file_test";
// 上传的文件
charfile_name[256]="./example_local_file_test.txt";
uint64_tcontent_length=0;
// 初始化存储上传数据的结构体
put_file_object_callback_datadata;
memset(&data,0,sizeof(put_file_object_callback_data));
// 打开文件，并获取文件长度
content_length=open_file_and_get_length(file_name,&data);
// 设置回调函数
obs_put_object_handlerputobjecthandler=
{
{&response_properties_callback,&put_file_complete_callback},
&put_file_data_callback
};
put_object(&options,key,content_length,&put_properties,0,&putobjecthandler,&data);
if(obs_status_ok==data.ret_status){
printf("put object from file successfully. \n");
}
else
{
printf("put object failed(%s).\n",
obs_get_status_name(data.ret_status));
}
if(data.infile!=null){
fclose(data.infile);
}
// 释放分配的全局资源
obs_deinitialize();
}
// 响应回调函数，可以在这个回调中把properties的内容记录到callback_data(用户自定义回调数据)中
obs_statusresponse_properties_callback(constobs_response_properties*properties,void*callback_data)
{
if(properties==null)
{
printf("error! obs_response_properties is null!");
if(callback_data!=null)
{
obs_sever_callback_data*data=(obs_sever_callback_data*)callback_data;
printf("server_callback buf is %s, len is %llu",
data->buffer,data->buffer_len);
returnobs_status_ok;
}
else{
printf("error! obs_sever_callback_data is null!");
returnobs_status_ok;
}
}
// 打印响应信息
#define print_nonnull(name, field)                                 \
    do {                                                           \
        if (properties-> field) {                                  \
            printf("%s: %s\n", name, properties->field);          \
        }                                                          \
    } while (0)
print_nonnull("request_id",request_id);
print_nonnull("request_id2",request_id2);
print_nonnull("content_type",content_type);
if(properties->content_length){
printf("content_length: %llu\n",properties->content_length);
}
print_nonnull("server",server);
print_nonnull("etag",etag);
print_nonnull("expiration",expiration);
print_nonnull("website_redirect_location",website_redirect_location);
print_nonnull("version_id",version_id);
print_nonnull("allow_origin",allow_origin);
print_nonnull("allow_headers",allow_headers);
print_nonnull("max_age",max_age);
print_nonnull("allow_methods",allow_methods);
print_nonnull("expose_headers",expose_headers);
print_nonnull("storage_class",storage_class);
print_nonnull("server_side_encryption",server_side_encryption);
print_nonnull("kms_key_id",kms_key_id);
print_nonnull("customer_algorithm",customer_algorithm);
print_nonnull("customer_key_md5",customer_key_md5);
print_nonnull("bucket_location",bucket_location);
print_nonnull("obs_version",obs_version);
print_nonnull("restore",restore);
print_nonnull("obs_object_type",obs_object_type);
print_nonnull("obs_next_append_position",obs_next_append_position);
print_nonnull("obs_head_epid",obs_head_epid);
print_nonnull("reserved_indicator",reserved_indicator);
inti;
for(i=0;i<properties->meta_data_count;i){
printf("x-obs-meta-%s: %s\n",properties->meta_data[i].name,
properties->meta_data[i].value);
}
returnobs_status_ok;
}
intput_file_data_callback(intbuffer_size,char*buffer,
void*callback_data)
{
put_file_object_callback_data*data=
(put_file_object_callback_data*)callback_data;
intret=0;
if(data->content_length){
inttoread=((data->content_length>(unsigned)buffer_size)?
(unsigned)buffer_size:data->content_length);
ret=fread(buffer,1,toread,data->infile);
}
uint64_toriginalcontentlength=data->content_length;
data->content_length-=ret;
if(data->content_length){
printf("%llu bytes remaining ",(unsignedlonglong)data->content_length);
printf("(%d%% complete) ...\n",
(int)(((originalcontentlength-data->content_length)*100)/originalcontentlength));
}
returnret;
}
voidput_file_complete_callback(obs_statusstatus,
constobs_error_details*error,
void*callback_data)
{
put_file_object_callback_data*data=(put_file_object_callback_data*)callback_data;
data->ret_status=status;
}
uint64_topen_file_and_get_length(char*localfile,put_file_object_callback_data*data)
{
uint64_tcontent_length=0;
constchar*body=0;
if(!content_length)
{
structstatstatbuf;
if(stat(localfile,&statbuf)==-1)
{
fprintf(stderr,"\nerror: failed to stat file %s: ",
localfile);
return0;
}
content_length=statbuf.st_size;
}
if(!(data->infile=fopen(localfile,"rb")))
{
fprintf(stderr,"\nerror: failed to open input file %s: ",
localfile);
return0;
}
data->content_length=content_length;
returncontent_length;
}

代码示例二：通过自定义域名下载对象

以下示例展示如何通过自定义域名下载对象： 
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
 
#include"esdkobs.h"
#include
#include
// 响应回调函数，可以在这个回调中把properties的内容记录到callback_data(用户自定义回调数据)中
obs_statusresponse_properties_callback(constobs_response_properties*properties,void*callback_data);
obs_statusget_object_data_callback(intbuffer_size,constchar*buffer,
void*callback_data);
voidget_object_complete_callback(obs_statusstatus,
constobs_error_details*error,
void*callback_data);
typedefstructget_object_callback_data
{
file*outfile;
obs_statusret_status;
}get_object_callback_data;
file*write_to_file(char*localfile);
intmain()
{
// 以下示例展示如何在使用自定义域名时通过get_object函数下载对象到本地文件：
// 在程序入口调用obs_initialize方法来初始化网络、内存等全局资源。
obs_initialize(obs_init_all);
obs_optionsoptions;
// 创建并初始化options，该参数包括访问域名(host_name)、访问密钥（access_key_id和acces_key_secret）、桶名(bucket_name)、桶存储类别(storage_class)等配置信息
init_obs_options(&options);
// host_name填写桶所在的endpoint, 此处以华北-北京四为例，其他地区请按实际情况填写。
options.bucket_options.host_name="obs.cn-north-4.myhuaweicloud.com";
// 认证用的ak和sk硬编码到代码中或者明文存储都有很大的安全风险，建议在配置文件或者环境变量中密文存放，使用时解密，确保安全；
// 本示例以ak和sk保存在环境变量中为例，运行本示例前请先在本地环境中设置环境变量access_key_id和secret_access_key。
options.bucket_options.access_key=getenv("access_key_id");
options.bucket_options.secret_access_key=getenv("secret_access_key");
char*bucketname="";
options.bucket_options.bucket_name=bucketname;
// 设置自定义域名
options.bucket_options.usecname=true;
options.bucket_options.host_name="example.obs.test.cname.com";
// 设置对象下载到本地的文件名
char*file_name="./example_get_file_test";
obs_object_infoobject_info;
// 设置下载的对象
memset(&object_info,0,sizeof(obs_object_info));
object_info.key="example_get_file_test";
object_info.version_id=null;
//根据业务需要设置存放下载对象数据的结构
get_object_callback_datadata;
data.ret_status=obs_status_butt;
data.outfile=write_to_file(file_name);
// 定义范围下载参数
obs_get_conditionsgetcondition;
memset(&getcondition,0,sizeof(obs_get_conditions));
init_get_properties(&getcondition);
// 下载起始位置，默认0，从对象0字节位置开始下载
getcondition.start_byte=0;
// 下载长度，默认0，一直下载到对象尾
// getcondition.byte_count = 0;
// 定义下载的回调函数
obs_get_object_handlerget_object_handler=
{
{&response_properties_callback,
&get_object_complete_callback},
&get_object_data_callback
};
get_object(&options,&object_info,&getcondition,0,&get_object_handler,&data);
if(obs_status_ok==data.ret_status){
printf("get object successfully. \n");
}
else
{
printf("get object faied(%s).\n",obs_get_status_name(data.ret_status));
}
fclose(data.outfile);
// 释放分配的全局资源
obs_deinitialize();
}
// 响应回调函数，可以在这个回调中把properties的内容记录到callback_data(用户自定义回调数据)中
obs_statusresponse_properties_callback(constobs_response_properties*properties,void*callback_data)
{
if(properties==null)
{
printf("error! obs_response_properties is null!");
if(callback_data!=null)
{
obs_sever_callback_data*data=(obs_sever_callback_data*)callback_data;
printf("server_callback buf is %s, len is %llu",
data->buffer,data->buffer_len);
returnobs_status_ok;
}
else{
printf("error! obs_sever_callback_data is null!");
returnobs_status_ok;
}
}
// 打印响应信息
#define print_nonnull(name, field)                                 \
    do {                                                           \
        if (properties-> field) {                                  \
            printf("%s: %s\n", name, properties->field);          \
        }                                                          \
    } while (0)
print_nonnull("request_id",request_id);
print_nonnull("request_id2",request_id2);
print_nonnull("content_type",content_type);
if(properties->content_length){
printf("content_length: %llu\n",properties->content_length);
}
print_nonnull("server",server);
print_nonnull("etag",etag);
print_nonnull("expiration",expiration);
print_nonnull("website_redirect_location",website_redirect_location);
print_nonnull("version_id",version_id);
print_nonnull("allow_origin",allow_origin);
print_nonnull("allow_headers",allow_headers);
print_nonnull("max_age",max_age);
print_nonnull("allow_methods",allow_methods);
print_nonnull("expose_headers",expose_headers);
print_nonnull("storage_class",storage_class);
print_nonnull("server_side_encryption",server_side_encryption);
print_nonnull("kms_key_id",kms_key_id);
print_nonnull("customer_algorithm",customer_algorithm);
print_nonnull("customer_key_md5",customer_key_md5);
print_nonnull("bucket_location",bucket_location);
print_nonnull("obs_version",obs_version);
print_nonnull("restore",restore);
print_nonnull("obs_object_type",obs_object_type);
print_nonnull("obs_next_append_position",obs_next_append_position);
print_nonnull("obs_head_epid",obs_head_epid);
print_nonnull("reserved_indicator",reserved_indicator);
inti;
for(i=0;i<properties->meta_data_count;i){
printf("x-obs-meta-%s: %s\n",properties->meta_data[i].name,
properties->meta_data[i].value);
}
returnobs_status_ok;
}
obs_statusget_object_data_callback(intbuffer_size,constchar*buffer,
void*callback_data)
{
get_object_callback_data*data=(get_object_callback_data*)callback_data;
size_twrote=fwrite(buffer,1,buffer_size,data->outfile);
return((wrote<(size_t)buffer_size)?
obs_status_abortedbycallback:obs_status_ok);
}
voidget_object_complete_callback(obs_statusstatus,
constobs_error_details*error,
void*callback_data)
{
get_object_callback_data*data=(get_object_callback_data*)callback_data;
data->ret_status=status;
}
file*write_to_file(char*localfile)
{
file*outfile=0;
if(localfile){
structstatbuf;
if(stat(localfile,&buf)==-1){
outfile=fopen(localfile,"wb");
}
else{
outfile=fopen(localfile,"a");
}
if(!outfile){
fprintf(stderr,"\nerror: failed to open output file %s: ",
localfile);
returnoutfile;
}
}else{
fprintf(stderr,"\nerror: failed to open output file, it's null, write object to stdout.",
localfile);
outfile=stdout;
}
returnoutfile;
}
父主题： 其他接口(c sdk)

相关文档

网站地图