全部產品
Search
文件中心

Object Storage Service:Go使用簽名URL上傳

更新時間:Nov 26, 2024

預設情況下,OSS Bucket中的檔案是私人的,僅檔案擁有者擁有存取權限。您可以使用OSS Go SDK產生簽名URL,以允許他人通過該URL上傳檔案。在產生簽名URL時,可以自訂其到期時間以限制訪問持續時間長度。在簽名URL有效期間內,該URL可被多次訪問。超出有效期間後,將無法進行上傳,此時需要重建簽名URL。

注意事項

  • 本文以華東1(杭州)外網Endpoint為例。如果您希望通過與OSS同地區的其他阿里雲產品訪問OSS,請使用內網Endpoint。關於OSS支援的Region與Endpoint的對應關係,請參見OSS地區和訪問網域名稱

  • 本文以從環境變數讀取存取憑證為例。如何配置訪問憑證,請參見配置訪問憑證

  • 本文以OSS網域名稱建立OSSClient為例。如果您希望通過自訂網域名、STS等方式建立OSSClient,請參見建立OSSClient

  • 產生用於上傳或預覽檔案的簽名URL時,您必須具有oss:PutObject許可權。具體操作,請參見為RAM使用者授權自訂的權限原則

    說明

    產生簽名URL過程中,SDK利用本機存放區的密鑰資訊,根據特定演算法計算出簽名(signature),然後將其附加到URL上,以確保URL的有效性和安全性。這一系列計算和構造URL的操作都是在用戶端完成,不涉及網路請求到服務端。因此,產生簽名URL時不需要授予調用者特定許可權。但是,為避免第三方使用者無法對簽名URL授權的資源執行相關操作,需要確保調用產生簽名URL介面的身份主體被授予對應的許可權。

  • 本文以V4簽名URL為例,有效期間最大為7天。更多資訊,請參見簽名版本4(推薦)

使用過程

使用PUT方式的簽名URL上傳檔案的過程如下:

使用簽名URL簡單上傳檔案

  1. 檔案擁有者產生PUT方法的簽名URL。

    package main
    
    import (
    	"log"
    
    	"github.com/aliyun/aliyun-oss-go-sdk/oss"
    )
    
    func main() {
    	// 從環境變數中擷取訪問憑證。運行本程式碼範例之前,請確保已設定環境變數OSS_ACCESS_KEY_ID和OSS_ACCESS_KEY_SECRET。
    	provider, err := oss.NewEnvironmentVariableCredentialsProvider()
    	if err != nil {
    		log.Printf("Error: %v", err)
    	}
    
    	// 建立OSSClient執行個體。
    	// yourEndpoint填寫Bucket對應的Endpoint,以華東1(杭州)為例,填寫為https://oss-cn-hangzhou.aliyuncs.com。其它Region請按實際情況填寫。
    	// yourRegion填寫Bucket所在地區,以華東1(杭州)為例,填寫為cn-hangzhou。其它Region請按實際情況填寫。
    	clientOptions := []oss.ClientOption{oss.SetCredentialsProvider(&provider)}
    	clientOptions = append(clientOptions, oss.Region("cn-hangzhou"))
    	// 設定簽名版本
    	clientOptions = append(clientOptions, oss.AuthVersion(oss.AuthV4))
    	client, err := oss.New("https://oss-cn-hangzhou.aliyuncs.com", "", "", clientOptions...)
    	if err != nil {
    		log.Printf("Error: %v", err)
    	}
    
    	// 填寫Bucket名稱,例如examplebucket。
    	bucketName := "examplebucket"
    	// 填寫檔案完整路徑,例如exampleobject.txt。檔案完整路徑中不能包含Bucket名稱。
    	objectName := "exampleobject.txt"
    	bucket, err := client.Bucket(bucketName)
    	if err != nil {
    		log.Printf("Error: %v", err)
    	}
    
    	// 產生用於上傳的簽名URL,並指定簽名URL的有效時間為600秒。
    	signedURL, err := bucket.SignURL(objectName, oss.HTTPPut, 600)
    	if err != nil {
    		log.Printf("Error: %v", err)
    	}
    	log.Printf("Sign Url:%s\n", signedURL)
    }
  2. 使用擷取的URL簡單上傳檔案:

    import org.apache.http.HttpEntity;
    import org.apache.http.client.methods.CloseableHttpResponse;
    import org.apache.http.client.methods.HttpPut;
    import org.apache.http.entity.FileEntity;
    import org.apache.http.impl.client.CloseableHttpClient;
    import org.apache.http.impl.client.HttpClients;
    import java.io.*;
    import java.net.URL;
    import java.util.*;
    
    public class SignUrlUpload {
        public static void main(String[] args) throws Throwable {
            CloseableHttpClient httpClient = null;
            CloseableHttpResponse response = null;
    
            // 將<signedUrl>替換為授權URL。
            URL signedUrl = new URL("<signedUrl>");
    
            // 填寫本地檔案的完整路徑。如果未指定本地路徑,則預設從樣本程式所屬專案對應本地路徑中上傳檔案。
            String pathName = "C:\\Users\\demo.txt";
    
            try {
                HttpPut put = new HttpPut(signedUrl.toString());
                System.out.println(put);
                HttpEntity entity = new FileEntity(new File(pathName));
                put.setEntity(entity);
                httpClient = HttpClients.createDefault();
                response = httpClient.execute(put);
    
                System.out.println("返回上傳狀態代碼:"+response.getStatusLine().getStatusCode());
                if(response.getStatusLine().getStatusCode() == 200){
                    System.out.println("使用網路程式庫上傳成功");
                }
                System.out.println(response.toString());
            } catch (Exception e){
                e.printStackTrace();
            } finally {
                response.close();
                httpClient.close();
            }
        }
    }       
    curl -X PUT -T /path/to/local/file "https://exampleobject.oss-cn-hangzhou.aliyuncs.com/exampleobject.txt?x-oss-date=20241112T083238Z&x-oss-expires=3599&x-oss-signature-version=OSS4-HMAC-SHA256&x-oss-credential=LTAI5************%2F20241112%2Fcn-hangzhou%2Foss%2Faliyun_v4_request&x-oss-signature=ed5a939feb8d79a389572719f7e2939939936d0**********"
    import requests
    
    def upload_file(signed_url, file_path):
        try:
            # 開啟檔案
            with open(file_path, 'rb') as file:
                # 發送PUT請求上傳檔案
                response = requests.put(signed_url, data=file)
            
            print(f"返回上傳狀態代碼:{response.status_code}")
            if response.status_code == 200:
                print("使用網路程式庫上傳成功")
            print(response.text)
        
        except Exception as e:
            print(f"發生錯誤:{e}")
    
    if __name__ == "__main__":
        # 將<signedUrl>替換為授權URL。
        signed_url = "<signedUrl>"
        
        # 填寫本地檔案的完整路徑。如果未指定本地路徑,則預設從樣本程式所屬專案對應本地路徑中上傳檔案。
        file_path = "C:\\Users\\demo.txt"
    
        upload_file(signed_url, file_path)
    
    const fs = require('fs');
    const axios = require('axios');
    
    async function uploadFile(signedUrl, filePath) {
        try {
            // 建立讀取流
            const fileStream = fs.createReadStream(filePath);
            
            // 發送PUT請求上傳檔案
            const response = await axios.put(signedUrl, fileStream, {
                headers: {
                    'Content-Type': 'application/octet-stream' // 根據實際情況調整Content-Type
                }
            });
    
            console.log(`返回上傳狀態代碼:${response.status}`);
            if (response.status === 200) {
                console.log('使用網路程式庫上傳成功');
            }
            console.log(response.data);
        } catch (error) {
            console.error(`發生錯誤:${error.message}`);
        }
    }
    
    // 主函數
    (async () => {
        // 將<signedUrl>替換為授權URL。
        const signedUrl = '<signedUrl>';
        
        // 填寫本地檔案的完整路徑。如果未指定本地路徑,則預設從樣本程式所屬專案對應本地路徑中上傳檔案。
        const filePath = 'C:\\Users\\demo.txt';
    
        await uploadFile(signedUrl, filePath);
    })();
    #include <iostream>
    #include <fstream>
    #include <curl/curl.h>
    
    void uploadFile(const std::string& signedUrl, const std::string& filePath) {
        CURL *curl;
        CURLcode res;
    
        curl_global_init(CURL_GLOBAL_DEFAULT);
        curl = curl_easy_init();
    
        if (curl) {
            // 設定URL
            curl_easy_setopt(curl, CURLOPT_URL, signedUrl.c_str());
    
            // 佈建要求方法為PUT
            curl_easy_setopt(curl, CURLOPT_UPLOAD, 1L);
    
            // 開啟檔案
            FILE *file = fopen(filePath.c_str(), "rb");
            if (!file) {
                std::cerr << "無法開啟檔案: " << filePath << std::endl;
                return;
            }
    
            // 擷取檔案大小
            fseek(file, 0, SEEK_END);
            long fileSize = ftell(file);
            fseek(file, 0, SEEK_SET);
    
            // 設定檔案大小
            curl_easy_setopt(curl, CURLOPT_INFILESIZE_LARGE, (curl_off_t)fileSize);
    
            // 設定輸入檔案控制代碼
            curl_easy_setopt(curl, CURLOPT_READDATA, file);
    
            // 執行請求
            res = curl_easy_perform(curl);
    
            if (res != CURLE_OK) {
                std::cerr << "curl_easy_perform() 失敗: " << curl_easy_strerror(res) << std::endl;
            } else {
                long httpCode = 0;
                curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &httpCode);
                std::cout << "返回上傳狀態代碼: " << httpCode << std::endl;
    
                if (httpCode == 200) {
                    std::cout << "使用網路程式庫上傳成功" << std::endl;
                }
            }
    
            // 關閉檔案
            fclose(file);
    
            // 清理
            curl_easy_cleanup(curl);
        }
    
        curl_global_cleanup();
    }
    
    int main() {
        // 將<signedUrl>替換為授權URL。
        std::string signedUrl = "<signedUrl>";
    
        // 填寫本地檔案的完整路徑。如果未指定本地路徑,則預設從樣本程式所屬專案對應本地路徑中上傳檔案。
        std::string filePath = "C:\\Users\\demo.txt";
    
        uploadFile(signedUrl, filePath);
    
        return 0;
    }
    
    package main
    
    import (
    	"fmt"
    	"io"
    	"net/http"
    	"os"
    )
    
    func uploadFile(signedUrl, filePath string) error {
    	// 開啟檔案
    	file, err := os.Open(filePath)
    	if err != nil {
    		return fmt.Errorf("無法開啟檔案: %w", err)
    	}
    	defer file.Close()
    
    	// 建立一個新的HTTP用戶端
    	client := &http.Client{}
    
    	// 建立一個PUT請求
    	req, err := http.NewRequest("PUT", signedUrl, file)
    	if err != nil {
    		return fmt.Errorf("建立請求失敗: %w", err)
    	}
    
    	// 發送請求
    	resp, err := client.Do(req)
    	if err != nil {
    		return fmt.Errorf("發送請求失敗: %w", err)
    	}
    	defer resp.Body.Close()
    
    	// 讀取響應
    	body, err := io.ReadAll(resp.Body)
    	if err != nil {
    		return fmt.Errorf("讀取響應失敗: %w", err)
    	}
    
    	fmt.Printf("返回上傳狀態代碼: %d\n", resp.StatusCode)
    	if resp.StatusCode == 200 {
    		fmt.Println("使用網路程式庫上傳成功")
    	}
    	fmt.Println(string(body))
    
    	return nil
    }
    
    func main() {
    	// 將<signedUrl>替換為授權URL。
    	signedUrl := "<signedUrl>"
    
    	// 填寫本地檔案的完整路徑。如果未指定本地路徑,則預設從樣本程式所屬專案對應本地路徑中上傳檔案。
    	filePath := "C:\\Users\\demo.txt"
    
    	err := uploadFile(signedUrl, filePath)
    	if err != nil {
    		fmt.Println("發生錯誤:", err)
    	}
    }
    
    package com.example.signurlupload;
    
    import android.os.AsyncTask;
    import android.util.Log;
    
    import java.io.DataOutputStream;
    import java.io.FileInputStream;
    import java.io.IOException;
    import java.net.HttpURLConnection;
    import java.net.URL;
    
    public class SignUrlUploadActivity {
    
        private static final String TAG = "SignUrlUploadActivity";
    
        public void uploadFile(String signedUrl, String filePath) {
            new UploadTask().execute(signedUrl, filePath);
        }
    
        private class UploadTask extends AsyncTask<String, Void, String> {
    
            @Override
            protected String doInBackground(String... params) {
                String signedUrl = params[0];
                String filePath = params[1];
    
                HttpURLConnection connection = null;
                DataOutputStream dos = null;
                FileInputStream fis = null;
    
                try {
                    URL url = new URL(signedUrl);
                    connection = (HttpURLConnection) url.openConnection();
                    connection.setRequestMethod("PUT");
                    connection.setDoOutput(true);
                    connection.setRequestProperty("Content-Type", "application/octet-stream");
    
                    fis = new FileInputStream(filePath);
                    dos = new DataOutputStream(connection.getOutputStream());
    
                    byte[] buffer = new byte[1024];
                    int length;
    
                    while ((length = fis.read(buffer)) != -1) {
                        dos.write(buffer, 0, length);
                    }
    
                    dos.flush();
                    dos.close();
                    fis.close();
    
                    int responseCode = connection.getResponseCode();
                    Log.d(TAG, "返回上傳狀態代碼: " + responseCode);
    
                    if (responseCode == 200) {
                        Log.d(TAG, "使用網路程式庫上傳成功");
                    }
    
                    return "上傳完成,狀態代碼: " + responseCode;
    
                } catch (IOException e) {
                    e.printStackTrace();
                    return "上傳失敗: " + e.getMessage();
                } finally {
                    if (connection != null) {
                        connection.disconnect();
                    }
                }
            }
    
            @Override
            protected void onPostExecute(String result) {
                Log.d(TAG, result);
            }
        }
    
        public static void main(String[] args) {
            SignUrlUploadActivity activity = new SignUrlUploadActivity();
            // 將<signedUrl>替換為授權URL。
            String signedUrl = "<signedUrl>";
            // 填寫本地檔案的完整路徑。如果未指定本地路徑,則預設從樣本程式所屬專案對應本地路徑中上傳檔案。
            String filePath = "C:\\Users\\demo.txt";
            activity.uploadFile(signedUrl, filePath);
        }
    }
    

常見使用情境

使用簽名URL上傳指定要求標頭和自訂中繼資料的檔案

  1. 擷取簡單上傳的簽名URL:

    package main
    
    import (
    	"log"
    
    	"github.com/aliyun/aliyun-oss-go-sdk/oss"
    )
    
    func main() {
    	// 從環境變數中擷取訪問憑證。運行本程式碼範例之前,請確保已設定環境變數OSS_ACCESS_KEY_ID和OSS_ACCESS_KEY_SECRET。
    	provider, err := oss.NewEnvironmentVariableCredentialsProvider()
    	if err != nil {
    		log.Printf("Error: %v", err)
    	}
    
    	// 建立OSSClient執行個體。
    	// yourEndpoint填寫Bucket對應的Endpoint,以華東1(杭州)為例,填寫為https://oss-cn-hangzhou.aliyuncs.com。其它Region請按實際情況填寫。
    	// yourRegion填寫Bucket所在地區,以華東1(杭州)為例,填寫為cn-hangzhou。其它Region請按實際情況填寫。
    	clientOptions := []oss.ClientOption{oss.SetCredentialsProvider(&provider)}
    	clientOptions = append(clientOptions, oss.Region("cn-hangzhou"))
    	// 設定簽名版本
    	clientOptions = append(clientOptions, oss.AuthVersion(oss.AuthV4))
    	client, err := oss.New("https://oss-cn-hangzhou.aliyuncs.com", "", "", clientOptions...)
    	if err != nil {
    		log.Printf("Error: %v", err)
    	}
    
    	// 填寫Bucket名稱,例如examplebucket。
    	bucketName := "examplebucket"
    	// 填寫檔案完整路徑,例如exampleobject.txt。檔案完整路徑中不能包含Bucket名稱。
    	objectName := "exampleobject.txt"
    	bucket, err := client.Bucket(bucketName)
    	if err != nil {
    		log.Printf("Error: %v", err)
    	}
    	// 如果要在前端使用帶選擇性參數的簽名URL,請確保在服務端產生該簽名URL時設定的ContentType與在前端使用時設定的ContentType一致。
    	options := []oss.Option{
    		oss.Meta("key1", "value1"),
    		oss.Meta("key2", "value2"),
    		oss.ContentType("text/plain"),
    	}
    
    	// 產生用於上傳的簽名URL,並指定簽名URL的有效時間為600秒。
    	signedURL, err := bucket.SignURL(objectName, oss.HTTPPut, 600, options...)
    	if err != nil {
    		log.Printf("Error: %v", err)
    	}
    	log.Printf("Sign Url:%s\n", signedURL)
    }
    
  2. 使用擷取的URL簡單上傳檔案:

    import org.apache.http.HttpEntity;
    import org.apache.http.client.methods.CloseableHttpResponse;
    import org.apache.http.client.methods.HttpPut;
    import org.apache.http.entity.FileEntity;
    import org.apache.http.impl.client.CloseableHttpClient;
    import org.apache.http.impl.client.HttpClients;
    import java.io.*;
    import java.net.URL;
    import java.util.*;
    
    public class SignUrlUpload {
        public static void main(String[] args) throws Throwable {
            CloseableHttpClient httpClient = null;
            CloseableHttpResponse response = null;
    
            // 將<signedUrl>替換為授權URL。
            URL signedUrl = new URL("<signedUrl>");
    
            // 填寫本地檔案的完整路徑。如果未指定本地路徑,則預設從樣本程式所屬專案對應本地路徑中上傳檔案。
            String pathName = "C:\\Users\\demo.txt";
    
            // 佈建要求頭,這裡的要求標頭資訊需要與產生URL時的資訊一致。
            Map<String, String> headers = new HashMap<String, String>();
            /*// 指定Object的儲存類型。
            headers.put(OSSHeaders.STORAGE_CLASS, StorageClass.Standard.toString());
            // 指定ContentType。
            headers.put(OSSHeaders.CONTENT_TYPE, "text/txt");*/
    
            // 設定使用者自訂中繼資料,這裡的使用者自訂中繼資料需要與產生URL時的資訊一致。
            Map<String, String> userMetadata = new HashMap<String, String>();
            /*userMetadata.put("key1","value1");
            userMetadata.put("key2","value2");*/
    
            try {
                HttpPut put = new HttpPut(signedUrl.toString());
                System.out.println(put);
                HttpEntity entity = new FileEntity(new File(pathName));
                put.setEntity(entity);
                // 如果產生簽名URL時設定了header參數,例如使用者中繼資料,儲存類型等,則呼叫簽章URL上傳檔案時,也需要將這些參數發送至服務端。如果簽名和發送至服務端的不一致,會報簽名錯誤。
                for(Map.Entry header: headers.entrySet()){
                    put.addHeader(header.getKey().toString(),header.getValue().toString());
                }
                for(Map.Entry meta: userMetadata.entrySet()){
                    // 如果使用userMeta,sdk內部會為userMeta拼接"x-oss-meta-"首碼。當您使用其他方式產生簽名URL進行上傳時,userMeta也需要拼接"x-oss-meta-"首碼。
                    put.addHeader("x-oss-meta-"+meta.getKey().toString(), meta.getValue().toString());
                }
    
                httpClient = HttpClients.createDefault();
    
                response = httpClient.execute(put);
    
                System.out.println("返回上傳狀態代碼:"+response.getStatusLine().getStatusCode());
                if(response.getStatusLine().getStatusCode() == 200){
                    System.out.println("使用網路程式庫上傳成功");
                }
                System.out.println(response.toString());
            } catch (Exception e){
                e.printStackTrace();
            } finally {
                response.close();
                httpClient.close();
            }
        }
    }       
    import requests
    from requests.auth import HTTPBasicAuth
    import os
    
    def upload_file(signed_url, file_path, headers=None, metadata=None):
        """
        使用預簽名的URL上傳檔案到OSS。
    
        :param signed_url: 預簽名的URL。
        :param file_path: 要上傳的檔案的完整路徑。
        :param headers: 可選,自訂HTTP頭部。
        :param metadata: 可選,自訂中繼資料。
        :return: None
        """
        if not headers:
            headers = {}
        if not metadata:
            metadata = {}
    
        # 更新headers,添加中繼資料首碼
        for key, value in metadata.items():
            headers[f'x-oss-meta-{key}'] = value
    
        try:
            with open(file_path, 'rb') as file:
                response = requests.put(signed_url, data=file, headers=headers)
                print(f"返回上傳狀態代碼:{response.status_code}")
                if response.status_code == 200:
                    print("使用網路程式庫上傳成功")
                else:
                    print("上傳失敗")
                print(response.text)
        except Exception as e:
            print(f"發生錯誤:{e}")
    
    if __name__ == "__main__":
        # 將<signedUrl>替換為授權URL。
        signed_url = "<signedUrl>"
        
        # 填寫本地檔案的完整路徑。如果未指定本地路徑,則預設從指令碼所在目錄中上傳檔案。
        file_path = "C:\\Users\\demo.txt"
    
        # 佈建要求頭,這裡的要求標頭資訊需要與產生URL時的資訊一致。
        headers = {
            # "Content-Type": "text/txt",
            # "x-oss-storage-class": "Standard"
        }
    
        # 設定使用者自訂中繼資料,這裡的使用者自訂中繼資料需要與產生URL時的資訊一致。
        metadata = {
            # "key1": "value1",
            # "key2": "value2"
        }
    
        upload_file(signed_url, file_path, headers, metadata)
    
    import android.os.AsyncTask;
    import android.util.Log;
    
    import java.io.DataOutputStream;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.net.HttpURLConnection;
    import java.net.URL;
    import java.util.HashMap;
    import java.util.Map;
    import java.util.Map.Entry;
    
    public class SignUrlUploadActivity extends AppCompatActivity {
    
        private static final String TAG = "SignUrlUploadActivity";
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
    
            // 將<signedUrl>替換為授權URL。
            String signedUrl = "<signedUrl>";
    
            // 填寫本地檔案的完整路徑。如果未指定本地路徑,則預設從樣本程式所屬專案對應本地路徑中上傳檔案。
            String pathName = "/storage/emulated/0/demo.txt";
    
            // 佈建要求頭,這裡的要求標頭資訊需要與產生URL時的資訊一致。
            Map<String, String> headers = new HashMap<>();
            // headers.put("Content-Type", "text/txt");
            // headers.put("x-oss-storage-class", "Standard");
    
            // 設定使用者自訂中繼資料,這裡的使用者自訂中繼資料需要與產生URL時的資訊一致。
            Map<String, String> userMetadata = new HashMap<>();
            // userMetadata.put("key1", "value1");
            // userMetadata.put("key2", "value2");
    
            new UploadTask().execute(signedUrl, pathName, headers, userMetadata);
        }
    
        private class UploadTask extends AsyncTask<Object, Void, Integer> {
            @Override
            protected Integer doInBackground(Object... params) {
                String signedUrl = (String) params[0];
                String pathName = (String) params[1];
                Map<String, String> headers = (Map<String, String>) params[2];
                Map<String, String> userMetadata = (Map<String, String>) params[3];
    
                try {
                    URL url = new URL(signedUrl);
                    HttpURLConnection connection = (HttpURLConnection) url.openConnection();
                    connection.setRequestMethod("PUT");
                    connection.setDoOutput(true);
                    connection.setUseCaches(false);
    
                    // 佈建要求頭
                    for (Entry<String, String> header : headers.entrySet()) {
                        connection.setRequestProperty(header.getKey(), header.getValue());
                    }
    
                    // 設定使用者自訂中繼資料
                    for (Entry<String, String> meta : userMetadata.entrySet()) {
                        connection.setRequestProperty("x-oss-meta-" + meta.getKey(), meta.getValue());
                    }
    
                    // 讀取檔案
                    File file = new File(pathName);
                    FileInputStream fileInputStream = new FileInputStream(file);
                    DataOutputStream dos = new DataOutputStream(connection.getOutputStream());
    
                    byte[] buffer = new byte[1024];
                    int count;
                    while ((count = fileInputStream.read(buffer)) != -1) {
                        dos.write(buffer, 0, count);
                    }
    
                    fileInputStream.close();
                    dos.flush();
                    dos.close();
    
                    // 擷取響應
                    int responseCode = connection.getResponseCode();
                    Log.d(TAG, "返回上傳狀態代碼:" + responseCode);
                    if (responseCode == 200) {
                        Log.d(TAG, "使用網路程式庫上傳成功");
                    } else {
                        Log.d(TAG, "上傳失敗");
                    }
    
                    InputStream is = connection.getInputStream();
                    byte[] responseBuffer = new byte[1024];
                    StringBuilder responseStringBuilder = new StringBuilder();
                    while ((count = is.read(responseBuffer)) != -1) {
                        responseStringBuilder.append(new String(responseBuffer, 0, count));
                    }
                    Log.d(TAG, responseStringBuilder.toString());
    
                    return responseCode;
                } catch (IOException e) {
                    e.printStackTrace();
                    return -1;
                }
            }
    
            @Override
            protected void onPostExecute(Integer result) {
                super.onPostExecute(result);
                if (result == 200) {
                    Toast.makeText(SignUrlUploadActivity.this, "上傳成功", Toast.LENGTH_SHORT).show();
                } else {
                    Toast.makeText(SignUrlUploadActivity.this, "上傳失敗", Toast.LENGTH_SHORT).show();
                }
            }
        }
    }
    
    package main
    
    import (
    	"bytes"
    	"fmt"
    	"io/ioutil"
    	"net/http"
    	"os"
    )
    
    func uploadFile(signedUrl string, filePath string, headers map[string]string, metadata map[string]string) error {
    	// 開啟檔案
    	file, err := os.Open(filePath)
    	if err != nil {
    		return err
    	}
    	defer file.Close()
    
    	// 讀取檔案內容
    	fileBytes, err := ioutil.ReadAll(file)
    	if err != nil {
    		return err
    	}
    
    	// 建立請求
    	req, err := http.NewRequest("PUT", signedUrl, bytes.NewBuffer(fileBytes))
    	if err != nil {
    		return err
    	}
    
    	// 佈建要求頭
    	for key, value := range headers {
    		req.Header.Set(key, value)
    	}
    
    	// 設定使用者自訂中繼資料
    	for key, value := range metadata {
    		req.Header.Set(fmt.Sprintf("x-oss-meta-%s", key), value)
    	}
    
    	// 發送請求
    	client := &http.Client{}
    	resp, err := client.Do(req)
    	if err != nil {
    		return err
    	}
    	defer resp.Body.Close()
    
    	// 處理響應
    	fmt.Printf("返回上傳狀態代碼:%d\n", resp.StatusCode)
    	if resp.StatusCode == 200 {
    		fmt.Println("使用網路程式庫上傳成功")
    	} else {
    		fmt.Println("上傳失敗")
    	}
    	body, _ := ioutil.ReadAll(resp.Body)
    	fmt.Println(string(body))
    
    	return nil
    }
    
    func main() {
    	// 將<signedUrl>替換為授權URL。
    	signedUrl := "<signedUrl>"
    
    	// 填寫本地檔案的完整路徑。如果未指定本地路徑,則預設從樣本程式所屬專案對應本地路徑中上傳檔案。
    	filePath := "C:\\Users\\demo.txt"
    
    	// 佈建要求頭,這裡的要求標頭資訊需要與產生URL時的資訊一致。
    	headers := map[string]string{
    		// "Content-Type": "text/txt",
    		// "x-oss-storage-class": "Standard",
    	}
    
    	// 設定使用者自訂中繼資料,這裡的使用者自訂中繼資料需要與產生URL時的資訊一致。
    	metadata := map[string]string{
    		// "key1": "value1",
    		// "key2": "value2",
    	}
    
    	err := uploadFile(signedUrl, filePath, headers, metadata)
    	if err != nil {
    		fmt.Printf("發生錯誤:%v\n", err)
    	}
    }
    
    const fs = require('fs');
    const axios = require('axios');
    
    async function uploadFile(signedUrl, filePath, headers = {}, metadata = {}) {
        try {
            // 更新headers,添加中繼資料首碼
            for (const [key, value] of Object.entries(metadata)) {
                headers[`x-oss-meta-${key}`] = value;
            }
    
            // 讀取檔案流
            const fileStream = fs.createReadStream(filePath);
    
            // 發送PUT請求
            const response = await axios.put(signedUrl, fileStream, {
                headers: headers
            });
    
            console.log(`返回上傳狀態代碼:${response.status}`);
            if (response.status === 200) {
                console.log("使用網路程式庫上傳成功");
            } else {
                console.log("上傳失敗");
            }
            console.log(response.data);
        } catch (error) {
            console.error(`發生錯誤:${error.message}`);
        }
    }
    
    // 主函數
    (async () => {
        // 將<signedUrl>替換為授權URL。
        const signedUrl = "<signedUrl>";
    
        // 填寫本地檔案的完整路徑。如果未指定本地路徑,則預設從指令碼所在目錄中上傳檔案。
        const filePath = "C:\\Users\\demo.txt";
    
        // 佈建要求頭,這裡的要求標頭資訊需要與產生URL時的資訊一致。
        const headers = {
            // "Content-Type": "text/txt",
            // "x-oss-storage-class": "Standard"
        };
    
        // 設定使用者自訂中繼資料,這裡的使用者自訂中繼資料需要與產生URL時的資訊一致。
        const metadata = {
            // "key1": "value1",
            // "key2": "value2"
        };
    
        await uploadFile(signedUrl, filePath, headers, metadata);
    })();
    
    #include <iostream>
    #include <fstream>
    #include <curl/curl.h>
    #include <map>
    #include <string>
    
    // 回呼函數,用於處理HTTP響應
    size_t WriteCallback(void* contents, size_t size, size_t nmemb, std::string* output) {
        size_t totalSize = size * nmemb;
        output->append((char*)contents, totalSize);
        return totalSize;
    }
    
    void uploadFile(const std::string& signedUrl, const std::string& filePath, const std::map<std::string, std::string>& headers, const std::map<std::string, std::string>& metadata) {
        CURL* curl;
        CURLcode res;
        std::string readBuffer;
    
        curl_global_init(CURL_GLOBAL_DEFAULT);
        curl = curl_easy_init();
    
        if (curl) {
            // 設定URL
            curl_easy_setopt(curl, CURLOPT_URL, signedUrl.c_str());
    
            // 佈建要求方法為PUT
            curl_easy_setopt(curl, CURLOPT_UPLOAD, 1L);
    
            // 開啟檔案
            FILE* file = fopen(filePath.c_str(), "rb");
            if (!file) {
                std::cerr << "無法開啟檔案: " << filePath << std::endl;
                return;
            }
    
            // 設定檔案大小
            fseek(file, 0, SEEK_END);
            long fileSize = ftell(file);
            rewind(file);
    
            // 設定檔案讀取回調
            curl_easy_setopt(curl, CURLOPT_READDATA, file);
            curl_easy_setopt(curl, CURLOPT_INFILESIZE_LARGE, (curl_off_t)fileSize);
    
            // 佈建要求頭
            struct curl_slist* chunk = nullptr;
            for (const auto& header : headers) {
                std::string headerStr = header.first + ": " + header.second;
                chunk = curl_slist_append(chunk, headerStr.c_str());
            }
            for (const auto& meta : metadata) {
                std::string metaStr = "x-oss-meta-" + meta.first + ": " + meta.second;
                chunk = curl_slist_append(chunk, metaStr.c_str());
            }
            curl_easy_setopt(curl, CURLOPT_HTTPHEADER, chunk);
    
            // 設定響應處理回調
            curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
            curl_easy_setopt(curl, CURLOPT_WRITEDATA, &readBuffer);
    
            // 執行請求
            res = curl_easy_perform(curl);
    
            // 檢查響應
            if (res != CURLE_OK) {
                std::cerr << "curl_easy_perform() failed: " << curl_easy_strerror(res) << std::endl;
            } else {
                long responseCode;
                curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &responseCode);
                std::cout << "返回上傳狀態代碼: " << responseCode << std::endl;
                if (responseCode == 200) {
                    std::cout << "使用網路程式庫上傳成功" << std::endl;
                } else {
                    std::cout << "上傳失敗" << std::endl;
                }
                std::cout << readBuffer << std::endl;
            }
    
            // 清理
            fclose(file);
            curl_slist_free_all(chunk);
            curl_easy_cleanup(curl);
        }
    
        curl_global_cleanup();
    }
    
    int main() {
        // 將<signedUrl>替換為授權URL。
        std::string signedUrl = "<signedUrl>";
    
        // 填寫本地檔案的完整路徑。如果未指定本地路徑,則預設從樣本程式所屬專案對應本地路徑中上傳檔案。
        std::string filePath = "C:\\Users\\demo.txt";
    
        // 佈建要求頭,這裡的要求標頭資訊需要與產生URL時的資訊一致。
        std::map<std::string, std::string> headers = {
            // {"Content-Type", "text/txt"},
            // {"x-oss-storage-class", "Standard"}
        };
    
        // 設定使用者自訂中繼資料,這裡的使用者自訂中繼資料需要與產生URL時的資訊一致。
        std::map<std::string, std::string> metadata = {
            // {"key1", "value1"},
            // {"key2", "value2"}
        };
    
        uploadFile(signedUrl, filePath, headers, metadata);
    
        return 0;
    }
    
    curl -X PUT \
         -H "Content-Type: text/txt" \
         -H "x-oss-meta-key1: value1" \
         -H "x-oss-meta-key2: value2" \
         -T "C:\\Users\\demo.txt" \
         "https://exampleobject.oss-cn-hangzhou.aliyuncs.com/exampleobject.txt?x-oss-date=20241112T083238Z&x-oss-expires=3599&x-oss-signature-version=OSS4-HMAC-SHA256&x-oss-credential=LTAI5************%2F20241112%2Fcn-hangzhou%2Foss%2Faliyun_v4_request&x-oss-signature=ed5a939feb8d79a389572719f7e2939939936d0**********"
    

如何使用簽名URL分區上傳檔案

使用簽名URL分區上傳檔案需要配置分區大小並逐片產生簽名URL,範例程式碼如下:

package main

import (
	"crypto/md5"
	"encoding/base64"
	"fmt"
	"log"
	"os"
	"strconv"
	"strings"

	"github.com/aliyun/aliyun-oss-go-sdk/oss"
)

func main() {
	// 從環境變數中擷取訪問憑證。運行本程式碼範例之前,請確保已設定環境變數OSS_ACCESS_KEY_ID和OSS_ACCESS_KEY_SECRET。
	provider, err := oss.NewEnvironmentVariableCredentialsProvider()
	if err != nil {
		log.Printf("Error:%v", err)
	}
	// 建立OSSClient執行個體。
	// yourEndpoint填寫Bucket對應的Endpoint,以華東1(杭州)為例,填寫為https://oss-cn-hangzhou.aliyuncs.com。其它Region請按實際情況填寫。
	client, err := oss.New("yourEndpoint", "", "", oss.SetCredentialsProvider(&provider))
	if err != nil {
		log.Printf("Error:%v", err)
	}
	bucketName := "bucket_name"

	bucket, err := client.Bucket(bucketName)
	if err != nil {
		log.Printf("Error:%v", err)
	}
	// 填寫Object完整路徑。Object完整路徑中不能包含Bucket名稱。
	objectName := "example.txt"
	// 填寫本地檔案的完整路徑。如果未指定本地路徑,則預設從樣本程式所屬專案對應本地路徑中上傳檔案。
	localFile := "D:\\download\\demo.txt"

	// 將本地檔案分區,且指定分區數量為3。
	chunks, err := oss.SplitFileByPartNum(localFile, 3)
	fd, err := os.Open(localFile)
	defer fd.Close()
	// 步驟1:初始化一個分區上傳事件,並指定儲存類型為標準儲存。
	imur, err := bucket.InitiateMultipartUpload(objectName)
	// 步驟2:上傳分區。
	var options []oss.Option

	for _, chunk := range chunks {
		// MD5加密驗證。
		buf := make([]byte, chunk.Size)
		fd.ReadAt(buf, chunk.Size)
		sum := md5.Sum(buf)
		b64 := base64.StdEncoding.EncodeToString(sum[:])
		options = []oss.Option{
			oss.ContentMD5(b64),
		}

		options = append(options, oss.AddParam("partNumber", strconv.Itoa(chunk.Number)))
		options = append(options, oss.AddParam("uploadId", imur.UploadID))
		// 產生簽名URL。
		signedURL, err := bucket.SignURL(objectName, oss.HTTPPut, 60, options...)
		if err != nil {
			log.Printf("Error:%v", err)
		}
		fmt.Printf("簽名url:%s\n", signedURL)
		err = bucket.PutObjectWithURL(signedURL, strings.NewReader(string(buf)), options...)
		if err != nil {
			log.Printf("Error:%v", err)
		}
	}

	lsRes, err := bucket.ListUploadedParts(imur)
	if err != nil {
		log.Printf("Error:%v", err)
	}

	// 遍曆分區,並填充ETag值。
	var parts []oss.UploadPart
	for _, p := range lsRes.UploadedParts {
		parts = append(parts, oss.UploadPart{XMLName: p.XMLName, PartNumber: p.PartNumber, ETag: p.ETag})
	}

	// 步驟3:完成分區上傳。
	_, err = bucket.CompleteMultipartUpload(imur, parts)
	if err != nil {
		log.Printf("Error:%v", err)
	}
	fmt.Println("上傳成功")
}

常見問題

使用臨時簽名進行檔案上傳時,在上傳過程中籤名到期了,上傳中的檔案會失敗嗎?

上傳時不會失敗。

上傳時使用的是預簽名地址,該url只要是在有效期間裡(取token的有效期間和預簽名有效期間最小值),都可以使用。

如果我在產生URL時未佈建要求頭和自訂中繼資料,在使用URL上傳時還需要配置嗎?

不需要配置。

要求標頭和自訂中繼資料為非必要參數,如果不佈建要求頭和自訂中繼資料可以將樣本中相關代碼去掉。

相關文檔

  • 關於使用簽名URL上傳檔案的完整範例程式碼,請參見GitHub樣本

  • 關於使用簽名URL上傳檔案的API介面說明,請參見SignURL