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

Step 1: Map a custom domain name

The process for mapping a custom domain name to a bucket varies depending on the domain registrar and the owning account. You can query the domain registrar on the Alibaba Cloud WHOIS page and check the associated owning account in the Alibaba Cloud DNS console.

Step 2: Verify the custom domain name

After you map a custom domain name to the bucket, any request made by using the custom domain name will be resolved to the default domain name of the bucket through DNS. To verify the DNS records of the custom domain name, you can run the nslookup or dig command.

nslookup -type=CNAME static.example.com

dig CNAME static.example.com

Step 3: Use the custom domain name

After the DNS records of a custom domain name take effect, you can construct a URL by using the HTTP protocol and the custom domain name, which includes the signature and validity period. The URL format is http://YourDomain/ObjectName?SignatureInformation. You can then use the URL to access the object in the OSS bucket.

1. Obtain a presigned 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.

   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 is 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 presigned URL. For information about how to download ossbrowser, see ossbrowser 1.0.

   1. Use the custom domain name to log on to ossbrowser.

   1. Obtain the URL of the object.

   Use OSS SDKs

   You can use the custom domain name to create an OssClient instance and generate a presigned URL.

   Java

   import com.aliyun.oss.*;
   import com.aliyun.oss.common.auth.*;
   import com.aliyun.oss.common.comm.SignVersion;
   
   import java.net.URL;
   import java.util.Date;
   
   public class Demo {
       public static void main(String[] args) throws Throwable {
           // Specify the custom domain name. Example: static.example.com.
           String endpoint = "http://static.example.com";
           // Specify the ID of the region that maps to the endpoint. Example: cn-hangzhou.
           String region = "cn-hangzhou";
   
           // 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 an OSSClient instance.
           ClientBuilderConfiguration clientBuilderConfiguration = new ClientBuilderConfiguration();
           // Set this parameter to true to enable CNAME.
           clientBuilderConfiguration.setSupportCname(true);
           // Explicitly declare the use of the V4 signature algorithm
           clientBuilderConfiguration.setSignatureVersion(SignVersion.V4);
           OSS ossClient = OSSClientBuilder.create()
                   .endpoint(endpoint)
                   .credentialsProvider(credentialsProvider)
                   .clientConfiguration(clientBuilderConfiguration)
                   .region(region)
                   .build();
   
           try {
               // Specify the validity period of the presigned URL. Unit: milliseconds. In this example, the validity period is set to 1 hour.
               Date expiration = new Date(new Date().getTime() + 3600 * 1000L);
               // Generate a presigned URL that allows HTTP GET requests.In this example, no additional request headers are specified. Other users can access relevant content directly by using the browser.
               String bucketName = "examplebucket";
               String objectName = "demo.png";
               URL url = ossClient.generatePresignedUrl(bucketName, objectName, expiration);
               System.out.println(url);
           } catch (OSSException oe) {
               System.out.println("Caught an OSSException, which means your request made it to OSS, "
                       + "but was rejected with an error response for some reason.");
               System.out.println("Error Message:" + oe.getErrorMessage());
               System.out.println("Error Code:" + oe.getErrorCode());
               System.out.println("Request ID:" + oe.getRequestId());
               System.out.println("Host ID:" + oe.getHostId());
           } catch (ClientException ce) {
               System.out.println("Caught an ClientException, which means the client encountered "
                       + "a serious internal problem while trying to communicate with OSS, "
                       + "such as not being able to access the network.");
               System.out.println("Error Message:" + ce.getMessage());
           } finally {
               if (ossClient != null) {
                   ossClient.shutdown();
               }
           }
       }
   }

   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 OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET environment variables are configured. 
   auth = oss2.ProviderAuthV4(EnvironmentVariableCredentialsProvider())
   
   # Specify the ID of the region that maps to the endpoint. Example: cn-hangzhou. This parameter is required if you use the signature algorithm V4.
   region = "cn-hangzhou"
   
   # Specify the custom domain name. Example: static.example.com.
   endpoint = 'http://static.example.com'
   
   # Specify the name of your bucket.
   bucket = oss2.Bucket(auth, endpoint, "yourBucketName", region=region, is_cname=True)
   
   
   # Specify the full path of the object. Do not include the bucket name in the full path. Example: exampledir/exampleobject.txt.
   object_name = 'exampledir/exampleobject.txt'
   
   # Generate a signed URL that is used to download the object. In this example, the validity period of the URL is 600 seconds.
   # By default, OSS identifies forward slashes (/) in the full path of an object as escape characters in the signing process. Therefore, the signed URL cannot be directly used.
   # Set the slash_safe parameter to True. This way, OSS does not identify the forward slashes (/) in the full path of the object as escape characters, and the signed URL can be directly used.
   url = bucket.sign_url('GET', object_name, 600, slash_safe=True, params=params)
   print('The signed URL is:', url)

   Node.js

   const OSS = require("ali-oss");
   
   // Specify a function used to generate a signed URL.
   async function generateSignatureUrl(fileName) {
     // Obtain the signed URL.
     const client = await new OSS({
         // Specify the custom domain name that you want to map to the bucket.
         endpoint: 'http://static.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,
         bucket: 'examplebucket',
         // Specify the region in which the bucket is located. For example, if your bucket is located in the China (Hangzhou) region, set the region to oss-cn-hangzhou.
         region: 'oss-cn-hangzhou',
         authorizationV4: true,
         cname: true
     });
   
     return await client.signatureUrlV4('GET', 3600, {
         headers: {} // Specify the request headers based on the actual request headers.
     }, fileName);
   }
   // Call the function and pass in the name of the object.
   generateSignatureUrl('yourFileName').then(url => {
     console.log('Generated Signature URL:', url);
   }).catch(err => {
     console.error('Error generating signature URL:', err);
   });

   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;
   use OSS\Http\RequestCore;
   use OSS\Http\ResponseCore;
   use OSS\Credentials\EnvironmentVariableCredentialsProvider;
   
   // 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 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 http://static.example.com.
   $endpoint = "http://static.example.com";
   // Specify the name of the bucket.
   $bucket= "examplebucket";
   // Specify the full path of the object. Do not include the bucket name in the full path.
   $object = "exampleobject.txt";
   // Set the validity period of the signed URL to 600 seconds. Maximum value: 32400.
   $timeout = 600;
   try {
       $config = array(  
           "provider" => $provider,
           "endpoint" => $endpoint,
           'signatureVersion'=>OssClient::OSS_SIGNATURE_VERSION_V4,
           "cname"	=> true,
           "region"=> "cn-hangzhou"
       );
       $ossClient = new OssClient($config);
       // Generate a signed URL.
       $signedUrl = $ossClient->signUrl($bucket, $object, $timeout, "GET");
       print_r($signedUrl);
   } catch (OssException $e) {
       printf(__FUNCTION__ . ": FAILED\n");
       printf($e->getMessage() . "\n");
       return;
   }

   Go

   package main
   
   import (
   	"context"
   	"flag"
   	"log"
   	"time"
   
   	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss"
   	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss/credentials"
   )
   
   // Specify the global variables.
   var (
   	region     string // Region in which the bucket is located.
   	bucketName string // Name of the bucket.
   	objectName string // Name of the object.
   )
   
   // Specify the init function used to initialize command line parameters.
   func init() {
   	flag.StringVar(&region, "region", "", "The region in which the bucket is located.")
   	flag.StringVar(&bucketName, "bucket", "", "The name of the bucket.")
   	flag.StringVar(&objectName, "object", "", "The name of the object.")
   }
   
   func main() {
   	// Parse command line parameters.
   	flag.Parse()
   
   	// Check whether the name of the bucket is specified.
   	if len(bucketName) == 0 {
   		flag.PrintDefaults()
   		log.Fatalf("invalid parameters, bucket name required")
   	}
   
   	// Check whether the region is specified.
   	if len(region) == 0 {
   		flag.PrintDefaults()
   		log.Fatalf("invalid parameters, region required")
   	}
   
   	// Check whether the object is specified.
   	if len(objectName) == 0 {
   		flag.PrintDefaults()
   		log.Fatalf("invalid parameters, object name required")
   	}
   
   	// Load the default configurations and specify the credential provider and region.
   	cfg := oss.LoadDefaultConfig().
   		WithCredentialsProvider(credentials.NewEnvironmentVariableCredentialsProvider()).
   		WithRegion(region).
   		WithEndpoint("http://static.example.com").
   		WithUseCName(true)
   
   	// Create an OSS client.
   	client := oss.NewClient(cfg)
   
   	// Generate a signed URL for the GetObject request.
   	result, err := client.Presign(context.TODO(), &oss.GetObjectRequest{
   		Bucket: oss.Ptr(bucketName),
   		Key:    oss.Ptr(objectName),
   		//RequestPayer: oss.Ptr("requester"), // 指定请求者身份
   	},
   		oss.PresignExpires(10*time.Minute),
   	)
   	if err != nil {
   		log.Fatalf("failed to get object presign %v", err)
   	}
   
   	log.Printf("request method:%v\n", result.Method)
   	log.Printf("request expiration:%v\n", result.Expiration)
   	log.Printf("request url:%v\n", result.URL)
   	if len(result.SignedHeaders) > 0 {
   		// If you specify request headers when you generate a signed URL that allows HTTP GET requests, make sure that the request headers are included in the GET request initiated by using the signed URL. This prevents request failures and signature errors.
   		log.Printf("signed headers:\n")
   		for k, v := range result.SignedHeaders {
   			log.Printf("%v: %v\n", k, v)
   		}
   	}
   }

   Use ossutil

   Use the custom domain name to generate a presigned URL for an object by running the presign command.

   ossutil presign oss://examplebucket/exampleobject.txt --endpoint "http://static.example.com” --addressing-style "cname"

   To enable the ossutil command to automatically use a custom domain name, instead of manually specifying it each time, add the custom domain name to the configuration file.

2. Access the presigned URL in a browser.