Bind the custom domain name to the bucket default domain name

Step 1: Bind a custom domain name

According to the service provider and account of the domain name, refer to the corresponding steps to bind the domain name to the OSS bucket.

Step 2: Verify the custom domain name

After binding a custom domain name, you can use the nslookup or dig Command to check the result of CNAME resolution. If the domain name resolution result shows the external network access domain name of the bucket you bind, the CNAME resolution of the custom domain name has taken effect.

 nslookup -type=CNAME example.com

 dig CNAME example.com

Step 3: Use a custom domain name

After the custom domain name takes effect, you can access the file directly through the HTTP protocol.

1. Upload files.

   See Simple upload 。

2. Get the file URL.

   Temporary file URL

   The steps to obtain a temporary valid file URL are as follows:

   1. Set the file read/write permission ACL to private.

      See Set Object ACL 。

   2. The format of the private file URL is http://YourDomain/ObjectName? Signature parameters 。 You can obtain the file URL and set the effective duration of the URL by the following methods.

   Using the OSS Console

   1. Sign in OSS Management Console 。

   2. single click Bucket List , and then click the target bucket name.

   3. In the left navigation bar, select file management > File List 。

   4. On the file list page, click the target file name.

   5. stay details Panel Own domain name , select the bound custom domain name, keep the other default values, and then click Copy File URL 。

      

   Use the graphical management tool ossbrowser

   The ossbrowser supports operations at the object level similar to those supported by the console. Please follow the ossbrowser interface instructions to complete the operation of obtaining the signature URL. For how to use ossbrowser, see Quickly use ossbrowser 。

   Using the AliCloud SDK

   1. Create a new OssClient using a custom domain name.

   Java

    //YourEndpoint fills in the custom domain name. String endpoint = "yourEndpoint"; //Get access credentials from environment variables. Please configure the environment variables before running this code example. EnvironmentVariableCredentialsProvider credentialsProvider = CredentialsProviderFactory.newEnvironmentVariableCredentialsProvider(); //Create a ClientBuilderConfiguration instance, and you can modify the default parameters according to the actual situation. ClientBuilderConfiguration conf = new ClientBuilderConfiguration(); //Set whether CNAME is supported. CNAME is used to bind a custom domain name to the target bucket. conf.setSupportCname(true); //Create an OSSClient instance. OSS ossClient = new OSSClientBuilder().build(endpoint,  credentialsProvider, conf); //Close the OSSClient. ossClient.shutdown();

   PHP

    <? php if (is_file(__DIR__ . '/../autoload.php')) { require_once __DIR__ . '/../autoload.php'; } if (is_file(__DIR__ . '/../vendor/autoload.php')) { require_once __DIR__ . '/../vendor/autoload.php'; } use OSS\Credentials\EnvironmentVariableCredentialsProvider; use OSS\OssClient; use OSS\CoreOssException; //Get access credentials from environment variables. Before running this code example, make sure that the environment variables OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET have been set. $provider = new EnvironmentVariableCredentialsProvider(); //Fill in the custom domain name, for example http://example.com 。 $endpoint = " http://example.com "; try { $config = array( "provider" => $provider, "endpoint" => $endpoint, "cname"	=> true ); $ossClient = new OssClient($config);     } catch (OssException $e) { print $e->getMessage(); }

   Node.js

    const OSS = require('ali-oss') const client = new OSS({ //Use a custom domain name as the endpoint. endpoint: ' http://img.example.com ',  //Get access credentials from environment variables. Before running this code example, make sure that the environment variables OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET have been set. accessKeyId: process.env.OSS_ACCESS_KEY_ID, accessKeySecret: process.env.OSS_ACCESS_KEY_SECRET, cname: true });

   Python

    # -*- coding: utf-8 -*- import oss2 from oss2.credentials import EnvironmentVariableCredentialsProvider #Get access credentials from environment variables. Please configure the environment variables before running this code example. auth = oss2.ProviderAuth(EnvironmentVariableCredentialsProvider()) #Fill in a custom domain name, such as example.com. cname = ' http://example.com ' #Fill in the bucket name and set is_cname=True to enable CNAME. CNAME refers to binding a custom domain name to the storage space. bucket = oss2.Bucket(auth,  cname, 'examplebucket', is_cname=True)

   Browser.js

    <! DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8" /> <meta name="viewport" content="width=device-width, initial-scale=1.0" /> <title>Document</title> <script src=" https://gosspublic.alicdn.com/aliyun-oss-sdk-6.18.0.min.js "></script> </head> <body> <script> const client = new OSS({ //Fill in a custom domain name, such as example.com. endpoint: "example.com", //The temporary access key (AccessKey ID and AccessKey Secret) obtained from the STS service. accessKeyId: "yourAccessKeyId", accessKeySecret: "yourAccessKeySecret", //The security token (SecurityToken) obtained from the STS service. stsToken: 'yourSecurityToken', //Fill in the bucket name, such as examplebucket. bucket: "examplebucket", cname: true, });     </script> </body> </html>

   .NET

    using Aliyun.OSS; using Aliyun.OSS.Common; //Get access credentials from environment variables. Before running this code example, make sure that the environment variables OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET have been set. var accessKeyId = Environment.GetEnvironmentVariable("OSS_ACCESS_KEY_ID"); var accessKeySecret = Environment.GetEnvironmentVariable("OSS_ACCESS_KEY_SECRET"); //Fill in the custom domain name. const string endpoint = "yourDomain"; //Create a ClientConfiguration instance and modify the default parameters according to your needs. var conf = new ClientConfiguration(); //Turn on the CNAME switch. CNAME refers to the process of binding a custom domain name to a storage space. conf.IsCname = true; //Create an OssClient instance. var client = new OssClient(endpoint,  accessKeyId, accessKeySecret, conf);

   Android

    //YourEndpoint fills in the custom domain name. String endpoint = "yourEndpoint"; //The temporary access key (AccessKey ID and AccessKey Secret) obtained from the STS service. String accessKeyId = "yourAccessKeyId"; String accessKeySecret = "yourAccessKeySecret"; //The security token (SecurityToken) obtained from the STS service. String securityToken = "yourSecurityToken"; OSSCredentialProvider credentialProvider = new OSSStsTokenCredentialProvider(accessKeyId,  accessKeySecret, securityToken); //Create an OSSClient instance. OSSClient oss = new OSSClient(getApplicationContext(),  endpoint, credentialProvider);

   Go

    package main import ( "fmt" "github.com/aliyun/aliyun-oss-go-sdk/oss" "os" ) func main(){ //Get access credentials from environment variables. Please configure the environment variables before running this code example. provider, err := oss.NewEnvironmentVariableCredentialsProvider() if err != nil { fmt.Println("Error:", err) os.Exit(-1) }     //YourEndpoint fills in the user-defined domain name corresponding to the bucket. // oss. UseCname (true) is used to enable CNAME. CNAME is used to bind a custom domain name to the storage space. client, err := oss.New("yourEndpoint", "", "", oss.SetCredentialsProvider(&provider),oss.UseCname(true)) if err != nil { fmt.Println("Error:", err) os.Exit(-1) } fmt.Printf("client:%#v\n", client) }

   iOS

    //YourEndpoint fills in the custom domain name. NSString *endpoint = @"yourEndpoint"; //The temporary access key (AccessKey ID and AccessKey Secret) obtained from the STS service. NSString *accessKeyId = @"yourAccessKeyId"; NSString *accessKeySecret = @"yourAccessKeySecret"; //The security token (SecurityToken) obtained from the STS service. NSString *securityToken = @"yourSecurityToken"; id<OSSCredentialProvider> credentialProvider = [[OSSStsTokenCredentialProvider alloc] initWithAccessKeyId:accessKeyId secretKeyId:accessKeySecret securityToken:securityToken]; OSSClient *client = [[OSSClient alloc] initWithEndpoint:endpoint credentialProvider:credentialProvider];

   C++

    #include <alibabacloud/oss/OssClient.h> using namespace AlibabaCloud::OSS; int main(void) { /*Initialize OSS account information*/ /*YourEndpoint fills in the endpoint corresponding to the bucket's region. Taking East China 1 (Hangzhou) as an example, the Endpoint is filled in as https://oss-cn-hangzhou.aliyuncs.com 。*/ std::string Endpoint = "yourEndpoint"; /*Initialize network and other resources*/ InitializeSdk(); ClientConfiguration conf; /*Get access credentials from environment variables. Before running this code example, make sure that the environment variables OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET have been set*/ auto credentialsProvider = std::make_shared<EnvironmentVariableCredentialsProvider>(); OssClient client(Endpoint,  credentialsProvider, conf);    /*Release network and other resources*/ ShutdownSdk(); return 0; }

   C

    #include "oss_api.h" #include "aos_http_io.h" /*Fill in the custom domain name*/ const char *endpoint = "yourCustomEndpoint"; void init_options(oss_request_options_t *options) { options->config = oss_config_create(options->pool); /*Initialize the aos_string_t type with a string of char * type*/ aos_str_set(&options->config->endpoint, endpoint); /*Get access credentials from environment variables. Before running this code example, make sure that the environment variables OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET have been set*/ aos_str_set(&options->config->access_key_id, getenv("OSS_ACCESS_KEY_ID")); aos_str_set(&options->config->access_key_secret, getenv("OSS_ACCESS_KEY_SECRET")); /*Turn on CNAME and bind the custom domain name to the storage space*/ options->config->is_cname = 1; options->ctl = aos_http_controller_create(options->pool, 0); } int main() { aos_pool_t *p; oss_request_options_t *options; /*Initialize global variables, which only need to be called once in the program life cycle*/ if (aos_http_io_initialize(NULL, 0) !=  AOSE_OK) { return -1; } /*Initialize the memory pool and options*/ aos_pool_create(&p, NULL); options = oss_request_options_create(p); init_options(options); /*Logic code, omitted here*/ /*Releasing the memory pool is equivalent to releasing the memory allocated by each resource during the request process*/ aos_pool_destroy(p); /*The global resources allocated before release only need to be called once in the program life cycle*/ aos_http_io_deinitialize(); return 0; }

   Ruby

    require 'aliyun/oss' client = Aliyun::OSS::Client.new( #Use a custom domain name as the endpoint. endpoint: ' http://example.com ', #Get access credentials from environment variables. Before running this code example, make sure that the environment variables OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET have been set. access_key_id: ENV['OSS_ACCESS_KEY_ID'], access_key_secret: ENV['OSS_ACCESS_KEY_SECRET'] cname: true) )

   2. Use OssClient to call the generatePresignedUrl interface to obtain the signature URL.

      For SDK examples in different languages, see Signature Version 1 。

   Using the command line tool ossutil

   1. Set the mapping relationship between bucket and user-defined domain name through configuration file. For details, see Configure ossutil 。

   2. adopt sign Generate a signed file URL. For details, see Sign (generate signature URL) 。

   Long term file URL

   warning

   To obtain a long-term valid file URL, there is no expiration time. You need to set the read/write permission ACL of the read file to public read. After the file is set to public reading, any user on the Internet can access the object, which may cause the leakage of your data and the surge of costs. It is recommended that you use the temporary file URL.

   The steps to obtain a long-term valid file URL are as follows:

   1. Set the file read/write permission ACL to public read.

      See Set Object ACL 。

   2. Splice file URL.

      After binding a custom domain name, if the file read/write permission ACL is public read, no signature operation is required. The format of public read file URL is https://YourDomainName/ObjectName 。

      For example, if you bind the custom domain name static.example.com to the examplebucket in East China 1 (Hangzhou) region, and the bucket contains the file example.jpg, the file URL is https://static.example.com/example.jpg 。

3. In the browser, access the generated file URL.