Object Storage Service:Map custom domain names

Step 1: Map a custom domain name

The steps of 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 the custom domain name to the bucket, use the nslookup or dig command to check CNAME resolution. If the output shows that the CNAME is the public domain name of the bucket, the CNAME record takes effect.

nslookup -type=CNAME example.com

dig CNAME example.com

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

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

1. Upload an object to the bucket.

   For more information, see Simple upload.

2. Generate object URLs.

   Generate 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. Use the following methods to obtain the object URL that has a validity period. The URL of a private object is in the http://YourDomain/ObjectName?Signature format.

   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 the other parameters, and 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. For more information about how to use ossbrowser, see Use ossbrowser.

   Use OSS SDKs

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

   Java

   // Replace yourEndpoint with the custom domain name that you want to use. 
   String endpoint = "yourEndpoint";
   
   // Obtain the access credentials from the environment variables. You need to configure environment variables before you run the sample code. 
   EnvironmentVariableCredentialsProvider credentialsProvider = CredentialsProviderFactory.newEnvironmentVariableCredentialsProvider();
   
   // Create a ClientBuilderConfiguration instance and modify the default 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\OssClient;
   use OSS\Core\OssException;
   // 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 = getenv("OSS_ACCESS_KEY_ID"); 
   $accessKeySecret = getenv("OSS_ACCESS_KEY_SECRET");
   // In this example, the endpoint of the China (Hangzhou) region is used. Specify your actual endpoint. 
   $endpoint = "https://oss-cn-hangzhou.aliyuncs.com";
   
   try {
       // true indicates that CNAME is enabled. If CNAME is enabled, a custom domain name is mapped to a bucket. 
       $ossClient = new OssClient($accessKeyId, $accessKeySecret, $endpoint, true);
   } 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', 
     // The AccessKey pair of an Alibaba Cloud account has permissions on all API operations. Using these credentials to perform operations in OSS is a high-risk operation. We recommend that you use a RAM user to call API operations or perform routine O&M. To create a RAM user, log on to the RAM console. 
     accessKeyId: 'yourAccessKeyId',  
     accessKeySecret: 'yourAccessKeySecret',
     cname: true
   });

   Python

   # -*- coding: utf-8 -*-
   import oss2
   from oss2.credentials import EnvironmentVariableCredentialsProvider
   
   # Obtain access credentials from environment variables. You need to configure environment variables before you run the sample code. 
   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. 
           endpoint: "example.com",
           // 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. Modify parameters as required. 
   var conf = new ClientConfiguration();
   
   // Specify that a CNAME record can be used. 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 a 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";
   
   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(){
       // Obtain access credentials from environment variables. You need to configure environment variables before you run the sample code. 
       provider, err := oss.NewEnvironmentVariableCredentialsProvider()
       if err != nil {
           fmt.Println("Error:", err)
           os.Exit(-1)
       }    
   
       // Set yourEndpoint to the custom domain name of the bucket. 
       // oss.UseCname(true) indicates that CNAME is enabled. CNAME is used to map a custom domain name to a bucket. 
       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

   // 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 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 data of the aos_string_t type. */
       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 a signed URL of the object.

      For more information, see Add signatures to URLs.

   Use ossutil

   1. Use the configuration file to configure the mapping between a bucket and a custom domain name. For more information, see Configure ossutil.

   2. Use the sign command to generate a signed URL of an object. For more information, see sign (generate signed object URLs).

   Generate a permanent object URL

   Warning

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

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

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

      For more information, see 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 by using the custom domain name that is mapped to the bucket that contains the object. The URL of a public-read object based on a custom domain name is in the https://YourDomainName/ObjectName format.

      For example, if you map static.example.com to the examplebucket bucket in the China (Hangzhou) region, you can use the http://static.example.com/demo.png URL to access the example.jpg in the bucket.

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