Object Storage Service:Map a custom domain name to the default domain name of a bucket

Step 1: Map a custom domain name

The steps for mapping a custom domain name to a bucket vary based on the owner account and domain registrar.

Step 2: Verify the domain name mapping

After you map a custom domain name to the default domain name of a bucket, you can run the nslookup or dig command to check whether domain resolution takes effects. If the output shows that the CNAME is the public domain name of the bucket, the CNAME record takes effect.

nslookup -type=CNAME static.example.com

dig CNAME static.example.com

Step 3: Use the custom domain name to access the bucket

After the domain mapping takes effect, you can use the custom domain name to access objects in the bucket over HTTP.

1. Upload an object to the bucket.

   For more information, see Simple upload.

2. Obtain the URL of the object.

   Obtain a temporary object URL

   To obtain a temporary URL of an object, perform the following steps:

   1. Set the access control list (ACL) of the object to private.

      For more information, see Object ACLs.

   2. The private object URL is in the following format: http://YourDomain/ObjectName?signature parameters. You can use one of the following methods to obtain the private object URL and specify the validity period of the URL:

   Use the OSS console

   1. Log on to the OSS console.

   2. In the left-side navigation pane, click Buckets. On the Buckets page, click the name of the bucket in which the private object is stored.

   3. In the left-side navigation tree, choose Object Management > Objects.

   4. On the Objects page, click the name of the object.

   5. In the View Details panel, select the custom domain name that you mapped to the bucket in the Custom Domain Name field, retain the default settings for other parameters, and then click Copy Object URL.

      

   Use ossbrowser

   You can use ossbrowser to perform the same object-level operations that you can perform in the OSS console. You can follow the on-screen instructions in ossbrowser to obtain a signed URL.

   Use OSS SDKs

   1. Use a custom domain name to create an OSSClient instance.

   Java

   // Specify a custom domain name. 
   String endpoint = "yourEndpoint";
   
   // Obtain access credentials from environment variables. Before you run the sample code, make sure that the environment variables are configured. 
   EnvironmentVariableCredentialsProvider credentialsProvider = CredentialsProviderFactory.newEnvironmentVariableCredentialsProvider();
   
   // Create ClientBuilderConfiguration and change the default values of the parameters based on your business requirements. 
   ClientBuilderConfiguration conf = new ClientBuilderConfiguration();
   
   // Specify whether to use CNAME. CNAME is used to map the custom domain name to the bucket. 
   conf.setSupportCname(true);
   
   // Create an OSSClient instance. 
   OSS ossClient = new OSSClientBuilder().build(endpoint, credentialsProvider, conf);
   
   // Shut down the OSSClient instance. 
   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;
   
   // Obtain access credentials from environment variables. Before you run the sample code, make sure that the OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET environment variables are configured.  
   $provider = new EnvironmentVariableCredentialsProvider();
   // Specify the custom domain name. 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 of a bucket to access the bucket. 
     endpoint: 'http://img.example.com', 
     // Obtain access credentials from environment variables. Before you run the sample code, make sure that the OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET environment variables are configured. 
     accessKeyId: process.env.OSS_ACCESS_KEY_ID,
     accessKeySecret: process.env.OSS_ACCESS_KEY_SECRET,
     authorizationV4: true,
     // Specify the region in which the bucket is located. For example, if the bucket is located in the China (Hangzhou) region, set the region to cn-hangzhou.
     region: 'yourRegion',
     cname: true
   });

   Python

   # -*- coding: utf-8 -*-
   import oss2
   from oss2.credentials import EnvironmentVariableCredentialsProvider
   
   # Obtain access credentials from environment variables. Before you run the sample code, make sure that the environment variables are configured. 
   auth = oss2.ProviderAuth(EnvironmentVariableCredentialsProvider())
   
   # Specify the custom domain name that is mapped to the bucket. Example: example.com. 
   cname = 'http://example.com'
   
   # Specify the name of the bucket and set is_cname to True to enable CNAME. CNAME is used to map a custom domain name to a bucket. 
   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({
           // Enter a custom domain name. Example: example.com. 
           // Specify the region in which the bucket is located. For example, if the bucket is located in the China (Hangzhou) region, set the region to oss-cn-hangzhou.
           region: 'yourRegion',
           endpoint: "example.com",
           authorizationV4: true,
           // Specify the temporary AccessKey pair obtained from Security Token Service (STS). The AccessKey pair consists of an AccessKey ID and an AccessKey secret. 
           accessKeyId: "yourAccessKeyId",
           accessKeySecret: "yourAccessKeySecret",
           // Specify the security token obtained from STS. 
           stsToken: 'yourSecurityToken',
           // Specify the name of the bucket. Example: examplebucket. 
           bucket: "examplebucket",
           cname: true,
         });    
             
       </script>
     </body>
   </html>
   

   .NET

   using Aliyun.OSS;
   using Aliyun.OSS.Common;
   // Obtain access credentials from environment variables. Before you run the sample code, make sure that the OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET environment variables are configured. 
   var accessKeyId = Environment.GetEnvironmentVariable("OSS_ACCESS_KEY_ID");
   var accessKeySecret = Environment.GetEnvironmentVariable("OSS_ACCESS_KEY_SECRET");
   // Specify the custom domain name. 
   const string endpoint = "yourDomain";
   
   // Create a ClientConfiguration instance and modify the default parameters based on your requirements. 
   var conf = new ClientConfiguration();
   
   // Specify that a CNAME can be used as an endpoint to create the OssClient instance. A CNAME record specifies the mapping relationship between a custom domain name and a bucket. 
   conf.IsCname = true;
   
   // Create an OSSClient instance. 
   var client = new OssClient(endpoint, accessKeyId, accessKeySecret, conf);                    

   Android

   // Specify the custom domain name. 
   String endpoint = "yourEndpoint";
   // Specify the temporary AccessKey pair obtained from STS. 
   String accessKeyId = "yourAccessKeyId";
   String accessKeySecret = "yourAccessKeySecret";
   // Specify the security token obtained from STS. 
   String securityToken = "yourSecurityToken";
   // Specify the region in which the bucket is located. For example, if the bucket is located in the China (Hangzhou) region, set the region to cn-hangzhou.
   String region = "yourRegion";
   
   OSSCredentialProvider credentialProvider = new OSSStsTokenCredentialProvider(accessKeyId, accessKeySecret, securityToken);
   ClientConfiguration config = new ClientConfiguration();
   config.setSignVersion(SignVersion.V4);
   // Create an OSSClient instance. 
   OSSClient oss = new OSSClient(getApplicationContext(), endpoint, credentialProvider);
   oss.setRegion(region);

   Go

   package main
   
   import (
   	"log"
   
   	"github.com/aliyun/aliyun-oss-go-sdk/oss"
   )
   
   // Call handleError to handle unrecoverable errors and terminate the program after recording the error messages.
   func handleError(err error) {
   	log.Fatalf("Error: %v", err)
   }
   
   // Use setupClient to create and configure an OSSClient instance and use CNAME as an endpoint.
   // Parameters:
   //
   //	endpoint: the custom domain name that you want to map to the bucket.
   //
   // Return the created OSSClient instance.
   func setupClient(endpoint string) (*oss.Client, error) {
   	// Obtain access credentials from environment variables.
   	provider, err := oss.NewEnvironmentVariableCredentialsProvider()
   	if err != nil {
   		return nil, err
   	}
   
   	// Create an OSSClient instance and use CNAME as an endpoint.
   	// Specify the region in which the bucket is located. For example, if the bucket is located in the China (Hangzhou) region, set the region to cn-hangzhou. Specify the actual region.
   	clientOptions := []oss.ClientOption{oss.SetCredentialsProvider(&provider)}
   	clientOptions = append(clientOptions, oss.Region("yourRegion"))
   	clientOptions = append(clientOptions, oss.UseCname(true))
   	// Specify the version of the signature algorithm.
   	clientOptions = append(clientOptions, oss.AuthVersion(oss.AuthV4))
   	client, err := oss.New(endpoint, "", "", clientOptions...)
   	if err != nil {
   		return nil, err
   	}
   
   	return client, nil
   }
   
   func main() {
   	// Specify the endpoint of the region in which the bucket is located.
   	// Example: custom-domain-for-your-bucket.com.
   	endpoint := "yourEndpoint"
   
   	// Check whether the environment variables are configured.
   	if endpoint == "" {
   		log.Fatal("Please set yourEndpoint.")
   	}
   
   	// Create and configure an OSSClient instance and use CNAME as an endpoint.
   	client, err := setupClient(endpoint)
   	if err != nil {
   		handleError(err)
   	}
   
   	// Display the client information.
   	log.Printf("Client: %#v\n", client)
   }
   

   iOS

   // Specify a custom domain name. 
   NSString *endpoint = @"yourEndpoint";
   // Specify the temporary AccessKey pair obtained from STS. An AccessKey pair consists of an AccessKey ID and an AccessKey secret. 
   NSString *accessKeyId = @"yourAccessKeyId";
   NSString *accessKeySecret = @"yourAccessKeySecret";
   // Specify the security token obtained from STS. 
   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 the information about the account that is used to access OSS. */
               
       /* Specify the endpoint of the region in which the bucket is located. For example, if the bucket is located in the China (Hangzhou) region, set the endpoint to https://oss-cn-hangzhou.aliyuncs.com. */
       std::string Endpoint = "yourEndpoint";
       
       /* Initialize resources, such as network resources. */
       InitializeSdk();
   
       ClientConfiguration conf;
       /* Obtain access credentials from environment variables. Before you run the sample code, make sure that the OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET environment variables are configured. */
       auto credentialsProvider = std::make_shared<EnvironmentVariableCredentialsProvider>();
       OssClient client(Endpoint, credentialsProvider, conf);   
   
       /* Release resources, such as network resources. */
       ShutdownSdk();
       return 0;
   }

   C

   #include "oss_api.h"
   #include "aos_http_io.h"
   # Specify the custom domain name. */
   const char *endpoint = "yourCustomEndpoint";
   
   void init_options(oss_request_options_t *options) {
       options->config = oss_config_create(options->pool);
       /* Use a char* string to initialize aos_string_t. */
       aos_str_set(&options->config->endpoint, endpoint);
       /* Obtain access credentials from environment variables. Before you run the sample code, make sure that the OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET environment variables are configured. */  
       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"));
       /* Enable CNAME and map the custom domain name to your bucket. */
       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. You need to initialize global variables only once in the program lifecycle. */
       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);
       /* The logic code. In this example, the logic code is omitted. */
       /* Release the memory pool. This operation releases the memory resources allocated for the request. */
       aos_pool_destroy(p);
       /* Release global resources that are allocated. You need to release global resources only once in the program lifecycle. */
       aos_http_io_deinitialize();
       return 0;
   }

   Ruby

   require 'aliyun/oss'
   
   client = Aliyun::OSS::Client.new(
     # Specify the custom domain name that you want to map to the bucket. 
     endpoint: 'http://example.com',
     # Obtain access credentials from environment variables. Before you run the sample code, make sure that the OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET environment variables are configured. 
     access_key_id: ENV['OSS_ACCESS_KEY_ID'],
     access_key_secret: ENV['OSS_ACCESS_KEY_SECRET']
     cname: true)
   )

   2. Use the OSSClient instance to call the GeneratePresignedUrl operation to obtain the signed URL of the object.

      Include a V1 signature in a URL

   Use ossutil

   1. Configure ossutil

   2. sign

   Obtain a permanent object URL

   Warning

   To obtain a permanent object URL that never expires, set the ACL of the object to public-read. After you set the ACL of an object to public-read, all users can access the object over the Internet, which may cause data leaks and high OSS bills. We recommend that you use temporary URLs.

   To obtain a permanent URL of an object, perform the following steps:

   1. Set the ACL of the object to public-read.

      Object ACLs

   2. Generate the object URL by concatenating the custom domain name and object name.

      You do not need to include signature information in the URL of a public-read object. The URL of a public-read object is in the following format: http://YourDomainName/ObjectName.

      For example, the examplebucket bucket in the China (Hangzhou) region contains the example.jpg object and is mapped to static.example.com, the URL of the object is https://static.example.com/example.jpg.

3. Use the object URL to access the object from a browser.