如何使用表單上傳 - Object Storage Service

OSS表單上傳允許網頁應用通過標準HTML表單直接將檔案上傳至OSS。這種方式下，在前端頁面選擇檔案後，瀏覽器發起POST請求直接將檔案傳輸到OSS伺服器，而無需經過網站伺服器中轉，減輕了伺服器的壓力，提高了檔案上傳的效率和穩定性。

使用限制

通過表單上傳的方式上傳的Object大小不能超過5 GB。

使用情境

表單上傳廣泛應用於Web應用程式，包括但不限於以下幾個方面：

使用者資料上傳：註冊帳號時上傳頭像、身份證照片或其他身分識別驗證材料。在個人中心修改資訊時上傳新的頭像或背景圖。
檔案分享與儲存：在網盤服務、協同辦公平台等通過表單上傳各種格式的檔案，如文檔、圖片、音頻、視頻等至雲端進行儲存和共用。
內容創作與發布：在部落格、論壇、問答社區等平台編寫文章並通過表單上傳圖片、附件等作為內容補充。
電商管理：商家在電商平台後台上傳商品圖片、詳細描述檔案、資質認證等；買家在購買過程中上傳發票需求或其他證明材料。
線上教育平台：學生在提交作業或專案時上傳文檔、PPT、視頻等作業檔案；教師在課程建設時上傳教學資料、課件等。
求職招聘網站：求職者上傳簡曆、作品集等求職材料；企業發布職位時上傳公司LOGO、招聘資訊檔等。
問卷調查與反饋：填寫線上調查問卷時上傳附加的證據檔案或說明文檔。
軟體開發協作：在代碼託管平台如GitHub、GitLab等上傳代碼檔案或專案文檔。

方案概述

您可以在服務端產生PostObject所需的Post簽名、PostPolicy等資訊，然後用戶端可以憑藉這些資訊，在一定的限制下不依賴OSS SDK直接上傳檔案。您可以藉助服務端產生的PostPolicy限制用戶端上傳的檔案，例如限制檔案大小、檔案類型。此方案適用於通過HTML表單上傳的方式上傳檔案。需要注意的是，此方案不支援基於分區上傳大檔案、基於分區斷點續傳的情境。更多資訊，請參見PostObject。

服務端通過Post簽名和Post Policy授權用戶端上傳檔案到OSS的過程如下。

用戶端向商務服務器請求Post簽名和Post Policy等資訊。
商務服務器產生並返回Post簽名和Post Policy等資訊給用戶端。
用戶端使用Post簽名和Post Policy等資訊調用PostObject通過HTML表單的方式上傳檔案到OSS。
OSS返回成功響應給用戶端。

操作步驟

服務端產生Post簽名和Post Policy等資訊。

樣本工程：postsignature.zip

範例程式碼

服務端產生Post簽名和Post Policy等資訊的範例程式碼如下：

Python

import os
from hashlib import sha1 as sha
import json
import base64
import hmac
import datetime
import time

# 配置環境變數OSS_ACCESS_KEY_ID。
access_key_id = os.environ.get('OSS_ACCESS_KEY_ID')
# 配置環境變數OSS_ACCESS_KEY_SECRET。
access_key_secret = os.environ.get('OSS_ACCESS_KEY_SECRET')
# 將<YOUR_BUCKET>替換為Bucket名稱。
bucket = '<YOUR_BUCKET>'
# host的格式為bucketname.endpoint。將<YOUR_BUCKET>替換為Bucket名稱。將<YOUR_ENDPOINT>替換為OSS Endpoint，例如oss-cn-hangzhou.aliyuncs.com。
host = 'https://<YOUR_BUCKET>.<YOUR_ENDPOINT>'
# 指定上傳到OSS的檔案首碼。
upload_dir = 'user-dir-prefix/'
# 指定到期時間，單位為秒。
expire_time = 3600


def generate_expiration(seconds):
    """
    通過指定有效時間長度（秒）產生到期時間。
    :param seconds: 有效時間長度（秒）。
    :return: ISO8601 時間字串，如："2014-12-01T12:00:00.000Z"。
    """
    now = int(time.time())
    expiration_time = now + seconds
    gmt = datetime.datetime.utcfromtimestamp(expiration_time).isoformat()
    gmt += 'Z'
    return gmt


def generate_signature(access_key_secret, expiration, conditions, policy_extra_props=None):
    """
    產生簽名字串Signature。
    :param access_key_secret: 有許可權訪問目標Bucket的AccessKeySecret。
    :param expiration: 簽名到期時間，按照ISO8601標準表示，並需要使用UTC時間，格式為yyyy-MM-ddTHH:mm:ssZ。樣本值："2014-12-01T12:00:00.000Z"。
    :param conditions: 策略條件，用於限制上傳表單時允許設定的值。
    :param policy_extra_props: 額外的policy參數，後續如果policy新增參數支援，可以在通過dict傳入額外的參數。
    :return: signature，簽名字串。
    """
    policy_dict = {
        'expiration': expiration,
        'conditions': conditions
    }
    if policy_extra_props is not None:
        policy_dict.update(policy_extra_props)
    policy = json.dumps(policy_dict).strip()
    policy_encode = base64.b64encode(policy.encode())
    h = hmac.new(access_key_secret.encode(), policy_encode, sha)
    sign_result = base64.b64encode(h.digest()).strip()
    return sign_result.decode()

def generate_upload_params():
    policy = {
        # 有效期間。
        "expiration": generate_expiration(expire_time),
        # 約束條件。
        "conditions": [
            # 未指定success_action_redirect時，上傳成功後的返回狀態代碼，預設為 204。
            ["eq", "$success_action_status", "200"],
            # 表單域的值必須以指定首碼開始。例如指定key的值以user/user1開始，則可以寫為["starts-with", "$key", "user/user1"]。
            ["starts-with", "$key", upload_dir],
            # 限制上傳Object的最小和最大允許大小，單位為位元組。
            ["content-length-range", 1, 1000000],
            # 限制上傳的檔案為指定的圖片類型
            ["in", "$content-type", ["image/jpg", "image/png"]]
        ]
    }
    signature = generate_signature(access_key_secret, policy.get('expiration'), policy.get('conditions'))
    response = {
        'policy': base64.b64encode(json.dumps(policy).encode('utf-8')).decode(),
        'ossAccessKeyId': access_key_id,
        'signature': signature,
        'host': host,
        'dir': upload_dir
        # 可以在這裡再自行追加其他參數
    }
    return json.dumps(response)

Java

import com.aliyun.help.demo.uploading_to_oss_directly_postsignature.config.OssConfig;
import com.aliyun.oss.ClientException;
import com.aliyun.oss.OSS;
import com.aliyun.oss.OSSException;
import com.aliyun.oss.common.utils.BinaryUtil;
import com.aliyun.oss.model.MatchMode;
import com.aliyun.oss.model.PolicyConditions;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.codehaus.jettison.json.JSONObject;
import java.util.Date;
import com.aliyun.oss.OSSClientBuilder;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Bean;
import javax.annotation.PreDestroy;

@Controller
public class PostSignatureController {
    @Autowired
    private OSS ossClient;

    @Autowired
    private OssConfig ossConfig;

    @GetMapping("/get_post_signature_for_oss_upload")
    @ResponseBody
    public String generatePostSignature() {
        JSONObject response = new JSONObject();
        try {
            long expireEndTime = System.currentTimeMillis() + ossConfig.getExpireTime() * 1000;
            Date expiration = new Date(expireEndTime);
            PolicyConditions policyConds = new PolicyConditions();
            policyConds.addConditionItem(PolicyConditions.COND_CONTENT_LENGTH_RANGE, 0, 1048576000);
            policyConds.addConditionItem(MatchMode.StartWith, PolicyConditions.COND_KEY, ossConfig.getDir());
            String postPolicy = ossClient.generatePostPolicy(expiration, policyConds);
            byte[] binaryData = postPolicy.getBytes("utf-8");
            String encodedPolicy = BinaryUtil.toBase64String(binaryData);
            String postSignature = ossClient.calculatePostSignature(postPolicy);
            response.put("ossAccessKeyId", ossConfig.getAccessKeyId());
            response.put("policy", encodedPolicy);
            response.put("signature", postSignature);
            response.put("dir", ossConfig.getDir());
            response.put("host", ossConfig.getHost());
        } 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("HTTP Status Code: " + oe.getRawResponseError()); 
        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();
        }
        return response.toString();
    }
  }
}

@Configuration
public class OssConfig {
    /**
     * 將 <YOUR-ENDPOINT> 替換為 Endpoint，例如 oss-cn-hangzhou.aliyuncs.com
     */
    private String endpoint = "<YOUR-ENDPOINT>";
    /**
     * 將 <YOUR-BUCKET> 替換為 Bucket 名稱
     */
    private String bucket = "<YOUR-BUCKET>";
    /**
     * 指定上傳到 OSS 的檔案首碼
     */
    private String dir = "user-dir-prefix/";
    /**
     * 指定到期時間，單位為秒
     */
    private long expireTime = 3600;
    /**
     * 構造 host
     */
    private String host = "http://" + bucket + "." + endpoint;
    /**
     * 通過環境變數 ALIBABA_CLOUD_ACCESS_KEY_ID 設定 accessKeyId
     */
    private String accessKeyId = System.getenv("ALIBABA_CLOUD_ACCESS_KEY_ID");
    /**
     * 通過環境變數 ALIBABA_CLOUD_ACCESS_KEY_SECRET 設定 accessKeySecret
     */
    private String accessKeySecret = System.getenv("ALIBABA_CLOUD_ACCESS_KEY_SECRET");

    private OSS ossClient;
    @Bean
    public OSS getOssClient() {
        ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);
        return ossClient;
    }
    @Bean
    public String getHost() {
        return host;
    }
    @Bean
    public String getAccessKeyId() {
        return accessKeyId;
    }
    @Bean
    public long getExpireTime() {
        return expireTime;
    }
    @Bean
    public String getDir() {
        return dir;
    }

    @PreDestroy
    public void onDestroy() {
        ossClient.shutdown();
    }
}

Go

package main

import (
	"crypto/hmac"
	"crypto/sha1"
	"encoding/base64"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"os"
	"time"
)

var (
	// 配置環境變數OSS_ACCESS_KEY_ID。
	accessKeyId = os.Getenv("OSS_ACCESS_KEY_ID")
	// 配置環境變數OSS_ACCESS_KEY_SECRET。
	accessKeySecret = os.Getenv("OSS_ACCESS_KEY_SECRET")
	// host的格式為bucketname.endpoint。將${your-bucket}替換為Bucket名稱。將${your-endpoint}替換為OSS Endpoint，例如oss-cn-hangzhou.aliyuncs.com。
	host = "http://${your-bucket}.${your-endpoint}"
	// 指定上傳到OSS的檔案首碼。
	uploadDir = "user-dir-prefix/"
	// 指定到期時間，單位為秒。
	expireTime = int64(3600)
)

type ConfigStruct struct {
	Expiration string          `json:"expiration"`
	Conditions [][]interface{} `json:"conditions"`
}

type PolicyToken struct {
	AccessKeyId string `json:"ossAccessKeyId"`
	Host        string `json:"host"`
	Signature   string `json:"signature"`
	Policy      string `json:"policy"`
	Directory   string `json:"dir"`
}

func getGMTISO8601(expireEnd int64) string {
	return time.Unix(expireEnd, 0).UTC().Format("2006-01-02T15:04:05Z")
}

func getPolicyToken() string {
	now := time.Now().Unix()
	expireEnd := now + expireTime
	tokenExpire := getGMTISO8601(expireEnd)

	var config ConfigStruct
	config.Expiration = tokenExpire

	// 添加檔案首碼限制
	config.Conditions = append(config.Conditions, []interface{}{"starts-with", "$key", uploadDir})

	// 添加檔案大小限制，例如1KB到10MB
	minSize := int64(1024)
	maxSize := int64(10 * 1024 * 1024)
	config.Conditions = append(config.Conditions, []interface{}{"content-length-range", minSize, maxSize})

	result, err := json.Marshal(config)
	if err != nil {
		fmt.Println("callback json err:", err)
		return ""
	}

	encodedResult := base64.StdEncoding.EncodeToString(result)
	h := hmac.New(sha1.New, []byte(accessKeySecret))
	io.WriteString(h, encodedResult)
	signedStr := base64.StdEncoding.EncodeToString(h.Sum(nil))

	policyToken := PolicyToken{
		AccessKeyId: accessKeyId,
		Host:        host,
		Signature:   signedStr,
		Policy:      encodedResult,
		Directory:   uploadDir,
	}

	response, err := json.Marshal(policyToken)
	if err != nil {
		fmt.Println("json err:", err)
		return ""
	}

	return string(response)
}

func handler(w http.ResponseWriter, r *http.Request) {
	if r.URL.Path == "/" {
		http.ServeFile(w, r, "templates/index.html")
		return
	} else if r.URL.Path == "/get_post_signature_for_oss_upload" {
		policyToken := getPolicyToken()
		w.Header().Set("Content-Type", "application/json")
		w.Write([]byte(policyToken))
		return
	}
	http.NotFound(w, r)
}

func main() {
	http.HandleFunc("/", handler)
	http.ListenAndServe(":8080", nil)
}

PHP

<?php
function gmt_iso8601($time)
{
    return str_replace('+00:00', '.000Z', gmdate('c', $time));
}

// 從環境變數中擷取訪問憑證。運行本範例程式碼之前，請確保已設定環境變數ALIBABA_CLOUD_ACCESS_KEY_ID和ALIBABA_CLOUD_ACCESS_KEY_SECRET。
$accessKeyId = getenv("ALIBABA_CLOUD_ACCESS_KEY_ID");
$accessKeySecret = getenv("ALIBABA_CLOUD_ACCESS_KEY_SECRET");
// $host的格式為<YOUR-BUCKET>.<YOUR-ENDPOINT>'，請替換為您的真實資訊。
$host = 'http://<YOUR-BUCKET>.<YOUR-ENDPOINT>';
// 使用者上傳檔案時指定的首碼。
$dir = 'user-dir-prefix/';          

$now = time();
//設定該policy逾時時間是10s. 即這個policy過了這個有效時間，將不能訪問。
$expire = 30;  
$end = $now + $expire;
$expiration = gmt_iso8601($end);

//最大檔案大小.使用者可以自己設定。
$condition = array(0 => 'content-length-range', 1 => 0, 2 => 1048576000);
$conditions[] = $condition;

// 表示使用者上傳的資料，必須是以$dir開始，不然上傳會失敗，這一步不是必須項，只是為了安全起見，防止使用者通過policy上傳到別人的目錄。
$start = array(0 => 'starts-with', 1 => '$key', 2 => $dir);
$conditions[] = $start;


$arr = array('expiration' => $expiration, 'conditions' => $conditions);
$policy = json_encode($arr);
$base64_policy = base64_encode($policy);
$string_to_sign = $base64_policy;
$signature = base64_encode(hash_hmac('sha1', $string_to_sign, $accessKeySecret, true));

$response = array();
$response['ossAccessKeyId'] = $accessKeyId;
$response['host'] = $host;
$response['policy'] = $base64_policy;
$response['signature'] = $signature;
$response['dir'] = $dir;  
echo json_encode($response);

Node.js

const express = require("express");
const { Buffer } = require("buffer");
const OSS = require("ali-oss");
const app = express();
const path = require("path");
const config = {
  // 配置環境變數ALIBABA_CLOUD_ACCESS_KEY_ID。
  accessKeyId: process.env.ALIBABA_CLOUD_ACCESS_KEY_ID,
  // 配置環境變數ALIBABA_CLOUD_ACCESS_KEY_SECRET。
  accessKeySecret: process.env.ALIBABA_CLOUD_ACCESS_KEY_SECRET,
  // 將<YOUR-BUCKET>替換為Bucket名稱。
  bucket: "<YOUR-BUCKET>",
  // 指定上傳到OSS的檔案首碼。
  dir: "prefix/",
};

app.use(express.static(path.join(__dirname, "templates")));

app.get("/get_post_signature_for_oss_upload", async (req, res) => {
  const client = new OSS(config);
  const date = new Date();
  // 設定簽名的有效期間，單位為秒。
  date.setSeconds(date.getSeconds() + 3600);
  const policy = {
    expiration: date.toISOString(),
    conditions: [
      // 設定上傳檔案的大小限制。
      ["content-length-range", 0, 1048576000],
      // 限制可上傳的Bucket。
      { bucket: client.options.bucket },
    ],
  };
  const formData = await client.calculatePostSignature(policy);
  const host = `http://${config.bucket}.${
    (await client.getBucketLocation()).location
  }.aliyuncs.com`.toString();
  const params = {
    policy: formData.policy,
    signature: formData.Signature,
    ossAccessKeyId: formData.OSSAccessKeyId,
    host,
    dir: config.dir,
  };
  res.json(params);
});

app.get(/^(.+)*\.(html|js)$/i, async (req, res) => {
  res.sendFile(path.join(__dirname, "./templates", req.originalUrl));
});

app.listen(8000, () => {
  console.log("http://127.0.0.1:8000");
});

Ruby

require 'sinatra'
require 'base64'
require 'open-uri'
require 'cgi'
require 'openssl'
require 'json'
require 'sinatra/reloader'
require 'sinatra/content_for'

# 設定public檔案夾路徑為當前檔案夾下的templates檔案夾
set :public_folder, File.dirname(__FILE__) + '/templates'

# 配置環境變數ALIBABA_CLOUD_ACCESS_KEY_ID。
$access_key_id = ENV['ALIBABA_CLOUD_ACCESS_ID']
# 配置環境變數ALIBABA_CLOUD_ACCESS_KEY_SECRET。
$access_key_secret = ENV['ALIBABA_CLOUD_ACCESS_SECRET']

# $host的格式為<bucketname>.<endpoint>，請替換為您的真實資訊。
$host = 'http://<bucketname>.<endpoint>';

# 使用者上傳檔案時指定的首碼。
$upload_dir = 'user-dir-prefix/'
# 到期時間，單位為秒。
$expire_time = 30
$server_ip = "0.0.0.0"
$server_port = 8000

if ARGV.length == 1 
  $server_port = ARGV[0]
elsif ARGV.length == 2
  $server_ip = ARGV[0]
  $server_port = ARGV[1]
end

puts "App server is running on: http://#{$server_ip}:#{$server_port}"

def hash_to_jason(source_hash)
  jason_string = source_hash.to_json;    

  jason_string.gsub!("\":[", "\": [")
  jason_string.gsub!("\",\"", "\", \"")
  jason_string.gsub!("],\"", "], \"")
  jason_string.gsub!("\":\"", "\": \"")

  jason_string
end


def get_token()
  expire_syncpoint = Time.now.to_i + $expire_time
  expire = Time.at(expire_syncpoint).utc.iso8601()
  response.headers['expire'] = expire
  policy_dict = {}
  condition_arrary = Array.new
  array_item = Array.new
  array_item.push('starts-with')
  array_item.push('$key')
  array_item.push($upload_dir)
  condition_arrary.push(array_item)
  policy_dict["conditions"] = condition_arrary
  policy_dict["expiration"] = expire
  policy = hash_to_jason(policy_dict)
  policy_encode = Base64.strict_encode64(policy).chomp;
  h = OpenSSL::HMAC.digest('sha1', $access_key_secret, policy_encode)
  hs = Digest::MD5.hexdigest(h)
  sign_result = Base64.strict_encode64(h).strip()
  token_dict = {}
  token_dict['ossAccessKeyId'] = $access_key_id
  token_dict['host'] = $host
  token_dict['policy'] = policy_encode
  token_dict['signature'] = sign_result 
  token_dict['expire'] = expire_syncpoint
  token_dict['dir'] = $upload_dir
  result = hash_to_jason(token_dict)
  result
end

set :bind, $server_ip
set :port, $server_port

get '/get_post_signature_for_oss_upload' do
  token = get_token()
  puts "Token: #{token}"
  token
end

get '/*' do
  puts "********************* GET "
  send_file File.join(settings.public_folder, 'index.html')
end

end

if ARGV.length == 1 
  $server_port = ARGV[0]
elsif ARGV.length == 2
  $server_ip = ARGV[0]
  $server_port = ARGV[1]
end

$server_ip = "0.0.0.0"
$server_port = 8000

puts "App server is running on: http://#{$server_ip}:#{$server_port}"

set :bind, $server_ip
set :port, $server_port

get '/get_sts_token_for_oss_upload' do
  token = get_sts_token_for_oss_upload()
  response = {
    "accessKeyId" => token["Credentials"]["AccessKeyId"],
    "accessKeySecret" => token["Credentials"]["AccessKeySecret"],
    "securityToken" => token["Credentials"]["SecurityToken"]
  }
  response.to_json
end

get '/*' do
  puts "********************* GET "
  send_file File.join(settings.public_folder, 'index.html')
end

C#

using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.AspNetCore.Http;
using System.IO;
using System.Collections.Generic;
using System;
using System.Globalization;
using System.Text;
using System.Security.Cryptography;
using Newtonsoft.Json;
using Microsoft.AspNetCore.Http.Extensions;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;

namespace YourNamespace
{
    public class Program
    {
        private ILogger<Program> _logger;
        // 配置環境變數ALIBABA_CLOUD_ACCESS_KEY_ID。
        public string AccessKeyId { get; set; } = Environment.GetEnvironmentVariable("ALIBABA_CLOUD_ACCESS_KEY_ID");
        // 配置環境變數ALIBABA_CLOUD_ACCESS_KEY_SECRET。
        public string AccessKeySecret { get; set; } = Environment.GetEnvironmentVariable("ALIBABA_CLOUD_ACCESS_KEY_SECRET");
        // host的格式為bucketname.endpoint。將<YOUR-BUCKET>替換為Bucket名稱。將<YOUR-ENDPOINT>替換為OSS Endpoint，例如oss-cn-hangzhou.aliyuncs.com。
        public string Host { get; set; } = "<YOUR-BUCKET>.<YOUR-ENDPOINT>";
        // 指定上傳到OSS的檔案首碼。
        public string UploadDir { get; set; } = "user-dir-prefix/";
        // 指定到期時間，單位為秒。
        public int ExpireTime { get; set; } = 3600;
        public class PolicyConfig
        {
            public string expiration { get; set; }
            public List<List<object>> conditions { get; set; }
        }
        public class PolicyToken
        {
            public string Accessid { get; set; }
            public string Policy { get; set; }
            public string Signature { get; set; }
            public string Dir { get; set; }
            public string Host { get; set; }
            public string Expire { get; set; }
        }
        public static void Main(string[] args)
        {
            var builder = WebApplication.CreateBuilder(args);
            var app = builder.Build();

            builder.Logging.AddConsole();
            var logger = builder.Services.BuildServiceProvider().GetRequiredService<ILogger<Program>>();

            app.UseStaticFiles(); 

            app.MapGet("/", async (context) =>
            {
                var filePath = Path.Combine(Directory.GetCurrentDirectory(), "templates/index.html");
                var htmlContent = await File.ReadAllTextAsync(filePath);
                await context.Response.WriteAsync(htmlContent);
                logger.LogInformation("GET request to root path");
            });

            app.MapGet("/get_post_signature_for_oss_upload", async (context) =>
            {
                var program = new Program(logger);
                var token = program.GetPolicyToken();

                logger.LogInformation($"Token: {token}");

                context.Response.ContentType = "application/json";
                await context.Response.WriteAsync(token);
            });

            app.Run();
        }

        public Program(ILogger<Program> logger)
        {
            _logger = logger;
        }

        private string ToUnixTime(DateTime dateTime)
        {
            return ((DateTimeOffset)dateTime).ToUnixTimeSeconds().ToString();
        }

        private string GetPolicyToken()
        {
            var expireDateTime = DateTime.Now.AddSeconds(ExpireTime);
            var config = new PolicyConfig
            {
                expiration = FormatIso8601Date(expireDateTime),
                conditions = new List<List<object>>()
            };
            config.conditions.Add(new List<object>
            {
                "content-length-range", 0, 1048576000
            });
            var policy = JsonConvert.SerializeObject(config);
            var policyBase64 = EncodeBase64("utf-8", policy);
            var signature = ComputeSignature(AccessKeySecret, policyBase64);
            var policyToken = new PolicyToken
            {
                Accessid = AccessKeyId,
                Host = Host,
                Policy = policyBase64,
                Signature = signature,
                Expire = ToUnixTime(expireDateTime),
                Dir = UploadDir
            };
            return JsonConvert.SerializeObject(policyToken);
        }

        private string FormatIso8601Date(DateTime dtime)
        {
            return dtime.ToUniversalTime().ToString("yyyy-MM-dd'T'HH:mm:ss.fff'Z'",
                                    CultureInfo.CurrentCulture);
        }

        private string EncodeBase64(string codeType, string code)
        {
            string encode = "";
            byte[] bytes = Encoding.GetEncoding(codeType).GetBytes(code);
            try
            {
                encode = Convert.ToBase64String(bytes);
            }
            catch
            {
                encode = code;
            }
            return encode;
        }

        private string ComputeSignature(string key, string data)
        {
            using (var algorithm = new HMACSHA1(Encoding.UTF8.GetBytes(key)))
            {
                return Convert.ToBase64String(algorithm.ComputeHash(Encoding.UTF8.GetBytes(data)));
            }
        }
    }
}

用戶端使用Post簽名和Post Policy等資訊調用PostObject通過HTML表單的方式上傳檔案到OSS。

以js為例：

<!DOCTYPE html>
<html lang="zh-CN">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>上傳檔案到OSS</title>
</head>
<body>
  <div class="container">
    <form>
      <div class="mb-3">
        <label for="file" class="form-label">選擇檔案</label>
        <input type="file" class="form-control" id="file" name="file" required>
      </div>
      <button type="submit" class="btn btn-primary">上傳</button>
    </form>
  </div>
  <script type="text/javascript">
      const form = document.querySelector('form');
      const fileInput = document.querySelector('#file');
      form.addEventListener('submit', (event) => {
        event.preventDefault();
        let file = fileInput.files[0];
        let filename = fileInput.files[0].name;
        fetch('/get_post_signature_for_oss_upload', { method: 'GET' })
          .then(response => response.json())
          .then(data => {
            const formData = new FormData();
            formData.append('name',filename);
            formData.append('policy', data.policy);
            formData.append('OSSAccessKeyId', data.ossAccessKeyId);
            formData.append('success_action_status', '200');
            formData.append('signature', data.signature);
            formData.append('key', data.dir + filename);
            // file必須為最後一個表單域，除file以外的其他表單域無順序要求。
            formData.append('file', file);
            fetch(data.host, { method: 'POST', body: formData},).then((res) => {
              console.log(res);
              alert('檔案已上傳');
            });
          })
          .catch(error => {
            console.log('Error occurred while getting OSS upload parameters:', error);
          });
      });
  </script>
</body>
</html>

注意事項

資料安全

防止覆蓋同名Object

上傳時預設會覆蓋同名Object，您可以選擇以下任意方式防止Object被意外覆蓋。

開啟版本控制功能
開啟版本控制功能後，被覆蓋的Object會以歷史版本的形式儲存下來。您可以隨時恢複歷史版本Object。更多資訊，請參見版本控制介紹。
在上傳請求中攜帶禁止覆蓋同名Object的參數
在上傳請求的表單域中攜帶參數x-oss-forbid-overwrite，並指定其值為true。當您上傳的Object在OSS中存在同名Object時，該Object會上傳失敗，並返回FileAlreadyExists錯誤。當不攜帶此參數或此參數的值為false時，同名Object會被覆蓋。

授權上傳

為了防止第三方使用者未經授權在您的Bucket中上傳資料，OSS提供了Bucket和Object層級的存取權限控制。更多資訊，請參見存取控制。
使用簽名URL授權第三方使用者上傳指定檔案。簽名URL允許第三方使用者在沒有安全憑證或者授權的情況下進行上傳操作。第三方使用者使用簽名URL上傳檔案後，OSS將在指定的Bucket產生該檔案。使用預簽名URL上傳檔案。

降低PUT類請求費用

如果要上傳的檔案數量較多，直接指定上傳的檔案類型為深度冷歸檔類型會造成較高的PUT類請求費用。建議您先將檔案的儲存類型指定為標準儲存進行上傳，然後通過生命週期規則將其轉儲為深度冷歸檔類型，從而降低PUT類請求費用。

避免影響OSS-HDFS服務

為避免影響OSS-HDFS服務的正常使用或者引發資料丟失的風險，在開通了OSS-HDFS服務的Bucket中，禁止以非OSS-HDFS服務提供的方式在OSS-HDFS的資料存放區目錄.dlsdata/中上傳Object。

上傳效能調優

如果您在上傳大量Object時，在命名上使用了順序首碼（如時間戳記或字母順序），可能會出現大量Object索引集中儲存於儲存空間中某個特定分區的情況，進而導致請求速率下降。建議您在上傳大量Object時，不要使用順序首碼的Object名稱，而是將順序首碼改為隨機性首碼。具體操作，請參見OSS效能最佳實務。