Go で署名付き URL を使用してファイルをアップロードする - Object Storage Service

デフォルトでは、Object Storage Service (OSS) バケット内のオブジェクトは非公開であり、オブジェクト所有者のみがアクセスできます。このトピックでは、OSS Go SDK V2 を使用して、PUT メソッド用の生存時間 (TTL) 付きの署名付き URL を生成する方法について説明します。これにより、他のユーザーが一時的にオブジェクトをアップロードできるようになります。URL は有効期限が切れるまで複数回使用できます。URL の有効期限が切れた後は、新しい URL を生成する必要があります。

注意事項

このトピックのサンプルコードでは、cn-hangzhou リージョン ID と中国 (杭州) リージョンのパブリックエンドポイントを使用します。同じリージョン内の他の Alibaba Cloud プロダクトから OSS にアクセスする場合は、内部ネットワークエンドポイントを使用してください。OSS リージョンとエンドポイントのマッピングに関する詳細については、リージョンとエンドポイントをご参照ください。
このトピックの例では、環境変数からアクセス認証情報を取得する方法を示しています。アクセス認証情報の設定方法の詳細については、アクセス認証情報の設定をご参照ください。
署名付き URL の生成に権限は必要ありません。ただし、URL を生成したユーザーが oss:PutObject 権限を持っている場合にのみ、第三者は署名付き URL を使用してファイルを正常にアップロードできます。権限の付与方法の詳細については、RAM ユーザーへのカスタム権限の付与をご参照ください。
このトピックのサンプルコードでは、署名バージョン 4 の署名付き URL を使用します。この URL の最大 TTL は 7 日間です。詳細については、署名バージョン 4 (推奨)をご参照ください。

プロセス

次の図は、PUT リクエストの署名付き URL を使用してファイルをアップロードするプロセスを示しています。

メソッド定義

presign 操作を呼び出して、署名付き URL を生成できます。この操作により、バケット内のオブジェクトへの一時的なアクセスが許可されます。署名付き URL は、有効期限が切れるまで複数回使用できます。

presign 操作は次のように定義されます：

func (c *Client) Presign(ctx context.Context, request any, optFns ...func(*PresignOptions)) (result *PresignResult, err error)

リクエストパラメーター

パラメーター	タイプ	説明
ctx	context.Context	リクエストのコンテキスト。
request	*PutObjectRequest	署名付き URL を生成する操作の名前。
optFns	...func(*PresignOptions)	(オプション) TTL。このパラメーターを指定しない場合、デフォルトの TTL は 15 分です。

PresignOptions は以下の通りです：

オプション	タイプ	説明
Expires	time.Duration	現在時刻から URL が失効するまでの期間。例えば、TTL を 30 分に設定するには、30 * time.Minute を使用します。
Expiration	time.Time	絶対的な有効期限。

重要

署名バージョン 4 の場合、最大 TTL は 7 日間です。Expiration と Expires の両方を設定した場合、Expiration が優先されます。

戻り値

戻り値	タイプ	説明
result	*PresignResult	結果。署名付き URL、HTTP メソッド、有効期限、署名付きリクエストヘッダーが含まれます。
err	error	リクエストのステータス。リクエストが失敗した場合、err は nil ではありません。

PresignResult の戻り値は以下の通りです：

パラメーター	タイプ	説明
Method	string	操作に対応する HTTP メソッド。例えば、PutObject 操作の場合、PUT が返されます。
URL	string	署名付き URL
Expiration	time.Time	署名付き URL の有効期限。
SignedHeaders	map[string]string	署名付きリクエストヘッダー。例えば、PutObject 操作で Content-Type を設定した場合、Content-Type に関する情報が返されます。

サンプルコード

オブジェクト所有者が PUT メソッドの署名付き URL を生成します。

重要

PUT メソッドの署名付き URL を生成する際にリクエストヘッダーを指定した場合、その署名付き URL を使用して PUT リクエストを送信する際にも同じヘッダーを含める必要があります。ヘッダーが一致しない場合、リクエストは失敗し、署名エラーが返されます。

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"
)

// グローバル変数を定義します。
var (
	region     string // ストレージリージョン。
	bucketName string // バケット名。
	objectName string // オブジェクト名。
)

// init 関数は、コマンドラインパラメーターを初期化するために使用されます。
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() {
	// コマンドラインパラメーターを解析します。
	flag.Parse()

	// バケット名が空かどうかを確認します。
	if len(bucketName) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, bucket name required")
	}

	// リージョンが空かどうかを確認します。
	if len(region) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, region required")
	}

	// オブジェクト名が空かどうかを確認します。
	if len(objectName) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, object name required")
	}

	// デフォルトの構成をロードし、認証情報プロバイダーとリージョンを設定します。
	cfg := oss.LoadDefaultConfig().
		WithCredentialsProvider(credentials.NewEnvironmentVariableCredentialsProvider()).
		WithRegion(region)

	// OSS クライアントを作成します。
	client := oss.NewClient(cfg)

	// PutObject の署名付き URL を生成します。
	result, err := client.Presign(context.TODO(), &oss.PutObjectRequest{
		Bucket: oss.Ptr(bucketName),
		Key:    oss.Ptr(objectName),
	},
		oss.PresignExpires(10*time.Minute),
	)
	if err != nil {
		log.Fatalf("failed to put 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 {
		// 結果に署名付きヘッダーが含まれている場合は、署名付き URL を使用して PUT リクエストを送信する際に、対応するリクエストヘッダーを設定する必要があります。
		log.Printf("signed headers:\n")
		for k, v := range result.SignedHeaders {
			log.Printf("%v: %v\n", k, v)
		}
	}
}

別のユーザーが PUT メソッドの署名付き URL を使用してオブジェクトをアップロードします。

curl

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=LTAI****************%2F20241112%2Fcn-hangzhou%2Foss%2Faliyun_v4_request&x-oss-signature=ed5a******************************************************"

Java

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("Status code returned for the upload:"+response.getStatusLine().getStatusCode());
            if(response.getStatusLine().getStatusCode() == 200){
                System.out.println("Upload successful using network library.");
            }
            System.out.println(response.toString());
        } catch (Exception e){
            e.printStackTrace();
        } finally {
            response.close();
            httpClient.close();
        }
    }
}

Go

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("Unable to open file: %w", err)
	}
	defer file.Close()

	// 新しい HTTP クライアントを作成します。
	client := &http.Client{}

	// PUT リクエストを作成します。
	req, err := http.NewRequest("PUT", signedUrl, file)
	if err != nil {
		return fmt.Errorf("Failed to create request: %w", err)
	}

	// リクエストを送信します。
	resp, err := client.Do(req)
	if err != nil {
		return fmt.Errorf("Failed to send request: %w", err)
	}
	defer resp.Body.Close()

	// 応答を読み取ります。
	body, err := io.ReadAll(resp.Body)
	if err != nil {
		return fmt.Errorf("Failed to read response: %w", err)
	}

	fmt.Printf("Status code returned for the upload: %d\n", resp.StatusCode)
	if resp.StatusCode == 200 {
		fmt.Println("Upload successful using network library.")
	}
	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("An error occurred:", err)
	}
}

python

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"Status code returned for the upload: {response.status_code}")
        if response.status_code == 200:
            print("Upload successful using network library.")
        print(response.text)
 
    except Exception as e:
        print(f"An error occurred: {e}")

if __name__ == "__main__":
    # <signedUrl> を承認された URL に置き換えます。
    signed_url = "<signedUrl>"
    
    // ローカルファイルの完全なパスを指定します。ローカルパスを指定しない場合、ファイルはデフォルトでサンプルプログラムのプロジェクトパスからアップロードされます。
    file_path = "C:\\Users\\demo.txt"

    upload_file(signed_url, file_path)

Node.js

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(`Status code returned for the upload: ${response.status}`);
        if (response.status === 200) {
            console.log('Upload successful using network library.');
        }
        console.log(response.data);
    } catch (error) {
        console.error(`An error occurred: ${error.message}`);
    }
}

// メイン関数。
(async () => {
    // <signedUrl> を承認された URL に置き換えます。
    const signedUrl = '<signedUrl>';
    
    // ローカルファイルの完全なパスを指定します。ローカルパスを指定しない場合、ファイルはデフォルトでサンプルプログラムのプロジェクトパスからアップロードされます。
    const filePath = 'C:\\Users\\demo.txt';

    await uploadFile(signedUrl, filePath);
})();

browser.js

重要

Browser.js を使用してファイルをアップロードする際に 403 署名の不一致エラーが発生した場合、通常はブラウザが自動的に Content-Type リクエストヘッダーを追加するものの、署名付き URL の生成時にこのヘッダーが指定されていなかったことが原因です。これにより、署名検証が失敗します。この問題を解決するには、署名付き URL を生成する際に Content-Type リクエストヘッダーを指定する必要があります。

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>File Upload Example</title>
</head>
<body>
    <h1>File Upload Example</h1>

    <!-- ファイルを選択 -->
    <input type="file" id="fileInput" />
    <button id="uploadButton">Upload File</button>

    <script>
        // これをステップ 1 で生成された署名付き URL に置き換えます。
        const signedUrl = "<signedUrl>"; 


        document.getElementById('uploadButton').addEventListener('click', async () => {
            const fileInput = document.getElementById('fileInput');
            const file = fileInput.files[0];

            if (!file) {
                alert('Please select a file to upload.');
                return;
            }

            try {
                await upload(file, signedUrl);
                alert('File uploaded successfully!');
            } catch (error) {
                console.error('Error during upload:', error);
                alert('Upload failed: ' + error.message);
            }
        });

        /**
         * ファイルを OSS にアップロードします。
         * @param {File} file - アップロードするファイル。
         * @param {string} presignedUrl - 署名付き URL。
         */
        const upload = async (file, presignedUrl) => {
            const response = await fetch(presignedUrl, {
                method: 'PUT',
                body: file,  // ファイル全体を直接アップロードします。
            });

            if (!response.ok) {
                throw new Error(`Upload failed, status: ${response.status}`);
            }

            console.log('File uploaded successfully');
        };
    </script>
</body>
</html>

C#

using System.Net.Http.Headers;

// ローカルファイルの完全なパスを指定します。ローカルパスを指定しない場合、ファイルはデフォルトでサンプルプログラムのプロジェクトパスからアップロードされます。
var filePath = "C:\\Users\\demo.txt";
// <signedUrl> を承認された URL に置き換えます。
var presignedUrl = "<signedUrl>";

// HTTP クライアントを作成し、ローカルファイルストリームを開きます。
using var httpClient = new HttpClient(); 
using var fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read);
using var content = new StreamContent(fileStream);
            
// PUT リクエストを作成します。
var request = new HttpRequestMessage(HttpMethod.Put, presignedUrl);
request.Content = content;

// リクエストを送信します。
var response = await httpClient.SendAsync(request);

// 応答を処理します。
if (response.IsSuccessStatusCode)
{
    Console.WriteLine($"Upload successful! Status code: {response.StatusCode}");
    Console.WriteLine("Response headers:");
    foreach (var header in response.Headers)
    {
        Console.WriteLine($"{header.Key}: {string.Join(", ", header.Value)}");
    }
}
else
{
    string responseContent = await response.Content.ReadAsStringAsync();
    Console.WriteLine($"Upload failed! Status code: {response.StatusCode}");
    Console.WriteLine("Response content: " + responseContent);
}

C++

#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 << "Unable to open file: " << 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() failed: " << curl_easy_strerror(res) << std::endl;
        } else {
            long httpCode = 0;
            curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &httpCode);
            std::cout << "Status code returned for the upload: " << httpCode << std::endl;

            if (httpCode == 200) {
                std::cout << "Upload successful using network library." << 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;
}

Android

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, "Status code returned for the upload: " + responseCode);

                if (responseCode == 200) {
                    Log.d(TAG, "Upload successful using network library.");
                }

                return "Upload complete. Status code: " + responseCode;

            } catch (IOException e) {
                e.printStackTrace();
                return "Upload failed: " + 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 を使用して、指定されたリクエストヘッダーとカスタムメタデータでファイルをアップロード

オブジェクト所有者が PUT メソッドの署名付き URL を生成します。

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"
)

// グローバル変数を定義します。
var (
	region     string // ストレージリージョン。
	bucketName string // バケット名。
	objectName string // オブジェクト名。
)

// init 関数は、コマンドラインパラメーターを初期化するために使用されます。
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() {
	// コマンドラインパラメーターを解析します。
	flag.Parse()

	// バケット名が空かどうかを確認します。
	if len(bucketName) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, bucket name required")
	}

	// リージョンが空かどうかを確認します。
	if len(region) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, region required")
	}

	// オブジェクト名が空かどうかを確認します。
	if len(objectName) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, object name required")
	}

	// デフォルトの構成をロードし、認証情報プロバイダーとリージョンを設定します。
	cfg := oss.LoadDefaultConfig().
		WithCredentialsProvider(credentials.NewEnvironmentVariableCredentialsProvider()).
		WithRegion(region)

	// OSS クライアントを作成します。
	client := oss.NewClient(cfg)

	// PutObject の署名付き URL を生成します。
	result, err := client.Presign(context.TODO(), &oss.PutObjectRequest{
		Bucket:      oss.Ptr(bucketName),
		Key:         oss.Ptr(objectName),
		ContentType:  oss.Ptr("text/plain;charset=utf8"),                    // サーバーで署名付き URL を生成する際に設定した ContentType が、URL を使用する際に設定した ContentType と同じであることを確認してください。
		StorageClass: oss.StorageClassStandard,                              // サーバーで署名付き URL を生成する際に設定した StorageClass が、URL を使用する際に設定した StorageClass と同じであることを確認してください。
		Metadata:    map[string]string{"key1": "value1", "key2": "value2"}, // サーバーで署名付き URL を生成する際に設定したメタデータが、URL を使用する際に設定したメタデータと同じであることを確認してください。
	},
		oss.PresignExpires(10*time.Minute),
	)
	if err != nil {
		log.Fatalf("failed to put 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 {
		// 結果に署名付きヘッダーが含まれている場合は、署名付き URL を使用して PUT リクエストを送信する際に、対応するリクエストヘッダーを設定する必要があります。
		log.Printf("signed headers:\n")
		for k, v := range result.SignedHeaders {
			log.Printf("%v: %v\n", k, v)
		}
	}
}

別のユーザーが PUT メソッドの署名付き URL を使用してオブジェクトをアップロードします。

curl

curl -X PUT \
     -H "Content-Type: text/plain;charset=utf8" \
     -H "x-oss-storage-class: Standard" \
     -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=LTAI****************%2F20241112%2Fcn-hangzhou%2Foss%2Faliyun_v4_request&x-oss-signature=ed5a******************************************************"

Java

import com.aliyun.oss.internal.OSSHeaders;
import com.aliyun.oss.model.StorageClass;
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>();
        //オブジェクトのストレージクラスを指定します。
        headers.put(OSSHeaders.STORAGE_CLASS, StorageClass.Standard.toString());
        //ContentType を指定します。
        headers.put(OSSHeaders.CONTENT_TYPE, "text/plain;charset=utf8");

        // カスタムユーザーメタデータを設定します。カスタムユーザーメタデータは、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 を生成する際に、ユーザーメタデータやストレージクラスなどのヘッダーパラメーターを設定した場合、署名付き URL を使用してファイルをアップロードする際にもこれらのパラメーターをサーバーに送信する必要があります。サーバーに送信されるパラメーターが署名付きパラメーターと一致しない場合、署名エラーが報告されます。
            for(Map.Entry header: headers.entrySet()){
                put.addHeader(header.getKey().toString(),header.getValue().toString());
            }
            for(Map.Entry meta: userMetadata.entrySet()){
                // userMeta を使用する場合、SDK は内部的に '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("Status code returned for the upload:"+response.getStatusLine().getStatusCode());
            if(response.getStatusLine().getStatusCode() == 200){
                System.out.println("Upload successful using network library.");
            }
            System.out.println(response.toString());
        } catch (Exception e){
            e.printStackTrace();
        } finally {
            response.close();
            httpClient.close();
        }
    }
}

Go

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("Status code returned for the upload: %d\n", resp.StatusCode)
	if resp.StatusCode == 200 {
		fmt.Println("Upload successful using network library.")
	} else {
		fmt.Println("Upload failed.")
	}
	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/plain;charset=utf8",
		"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("An error occurred: %v\n", err)
	}
}

Python

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 = {}

    # ヘッダーを更新し、メタデータプレフィックスを追加します。
    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"Status code returned for the upload: {response.status_code}")
            if response.status_code == 200:
                print("Upload successful using network library.")
            else:
                print("Upload failed.")
            print(response.text)
    except Exception as e:
        print(f"An error occurred: {e}")

if __name__ == "__main__":
    // <signedUrl> を承認された URL に置き換えます。
    signed_url = "<signedUrl>"
   
    // ローカルファイルの完全なパスを指定します。指定しない場合、ファイルはデフォルトでスクリプトが置かれているディレクトリからアップロードされます。
    file_path = "C:\\Users\\demo.txt"

    // リクエストヘッダーを設定します。リクエストヘッダーの情報は、URL が生成されたときに使用された情報と同じでなければなりません。
    headers = {
         "Content-Type": "text/plain;charset=utf8",
         "x-oss-storage-class": "Standard"
    }

    // カスタムユーザーメタデータを設定します。カスタムユーザーメタデータは、URL が生成されたときに使用された情報と同じでなければなりません。
    metadata = {
         "key1": "value1",
         "key2": "value2"
    }

    upload_file(signed_url, file_path, headers, metadata)

Node.js

const fs = require('fs');
const axios = require('axios');

async function uploadFile(signedUrl, filePath, headers = {}, metadata = {}) {
    try {
        // ヘッダーを更新し、メタデータプレフィックスを追加します。
        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(`Status code returned for the upload: ${response.status}`);
        if (response.status === 200) {
            console.log("Upload successful using network library.");
        } else {
            console.log("Upload failed.");
        }
        console.log(response.data);
    } catch (error) {
        console.error(`An error occurred: ${error.message}`);
    }
}

// メイン関数。
(async () => {
    // <signedUrl> を承認された URL に置き換えます。
    const signedUrl = "<signedUrl>";

    // ローカルファイルの完全なパスを指定します。指定しない場合、ファイルはデフォルトでスクリプトが置かれているディレクトリからアップロードされます。
    const filePath = "C:\\Users\\demo.txt";

    // リクエストヘッダーを設定します。リクエストヘッダーの情報は、URL が生成されたときに使用された情報と同じでなければなりません。
    const headers = {
         "Content-Type": "text/plain;charset=utf8",
         "x-oss-storage-class": "Standard"
    };

    // カスタムユーザーメタデータを設定します。カスタムユーザーメタデータは、URL が生成されたときに使用された情報と同じでなければなりません。
    const metadata = {
         "key1": "value1",
         "key2": "value2"
    };

    await uploadFile(signedUrl, filePath, headers, metadata);
})();

Browser.js

重要

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>File Upload Example</title>
</head>
<body>
    <h1>File Upload Example (Java SDK)</h1>

    <input type="file" id="fileInput" />
    <button id="uploadButton">Upload File</button>

    <script>
        // これを実際の署名付き URL に置き換えます。
        const signedUrl = "<signedUrl>"; 

        document.getElementById('uploadButton').addEventListener('click', async () => {
            const fileInput = document.getElementById('fileInput');
            const file = fileInput.files[0];

            if (file) {
                try {
                    await upload(file, signedUrl);
                } catch (error) {
                    console.error('Error during upload:', error);
                    alert('Upload failed: ' + error.message);
                }
            } else {
                alert('Please select a file to upload.');
            }
        });

        const upload = async (file, presignedUrl) => {
            const headers = {
                "Content-Type": "text/plain;charset=utf8",
                'x-oss-storage-class': 'Standard',
                'x-oss-meta-key1': 'value1',
                'x-oss-meta-key2': 'value2'
            };

            const response = await fetch(presignedUrl, {
                method: 'PUT',
                headers: headers,
                body: file
            });

            if (!response.ok) {
                throw new Error(`Upload failed, status: ${response.status}`);
            }

            alert('File uploaded successfully');
            console.log('File uploaded successfully');
        };
    </script>
</body>
</html>

C#

using System.Net.Http.Headers;

// ローカルファイルの完全なパスを指定します。ローカルパスを指定しない場合、ファイルはデフォルトでサンプルプログラムのプロジェクトパスからアップロードされます。
var filePath = "C:\\Users\\demo.txt";
// <signedUrl> を承認された URL に置き換えます。
var presignedUrl = "<signedUrl>";

// HTTP クライアントを作成し、ローカルファイルストリームを開きます。
using var httpClient = new HttpClient(); 
using var fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read);
using var content = new StreamContent(fileStream);
            
// PUT リクエストを作成します。
var request = new HttpRequestMessage(HttpMethod.Put, presignedUrl);
request.Content = content;

// 署名付き URL を生成する際に、ユーザーメタデータやストレージクラスなどのヘッダーパラメーターを設定した場合、署名付き URL を使用してファイルをアップロードする際にもこれらのパラメーターをサーバーに送信する必要があります。サーバーに送信されるパラメーターが署名付きパラメーターと一致しない場合、署名エラーが報告されます。
// リクエストヘッダーを設定します。リクエストヘッダーの情報は、URL が生成されたときに使用された情報と同じでなければなりません。
request.Content.Headers.ContentType = new MediaTypeHeaderValue("text/plain") { CharSet = "utf8" };  // ContentType を指定します。       
// カスタムユーザーメタデータを設定します。カスタムユーザーメタデータは、URL が生成されたときに使用された情報と同じでなければなりません。
request.Content.Headers.Add("x-oss-meta-key1", "value1");
request.Content.Headers.Add("x-oss-meta-key2", "value2");
// オブジェクトのストレージクラスを指定します。
request.Content.Headers.Add("x-oss-storage-class", "Standard");

// リクエストヘッダーを出力します。
Console.WriteLine("Request headers:");
foreach (var header in request.Content.Headers)
{
    Console.WriteLine($"{header.Key}: {string.Join(", ", header.Value)}");
}

// リクエストを送信します。
var response = await httpClient.SendAsync(request);

// 応答を処理します。
if (response.IsSuccessStatusCode)
{
    Console.WriteLine($"Upload successful! Status code: {response.StatusCode}");
    Console.WriteLine("Response headers:");
    foreach (var header in response.Headers)
    {
        Console.WriteLine($"{header.Key}: {string.Join(", ", header.Value)}");
    }
}
else
{
    string responseContent = await response.Content.ReadAsStringAsync();
    Console.WriteLine($"Upload failed! Status code: {response.StatusCode}");
    Console.WriteLine("Response content: " + responseContent);
}

C++

#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 << "Unable to open file: " << 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 << "Status code returned for the upload: " << responseCode << std::endl;
            if (responseCode == 200) {
                std::cout << "Upload successful using network library." << std::endl;
            } else {
                std::cout << "Upload failed." << 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/plain;charset=utf8"},
         {"x-oss-storage-class", "Standard"}
    };

    // カスタムユーザーメタデータを設定します。カスタムユーザーメタデータは、URL が生成されたときに使用された情報と同じでなければなりません。
    std::map<std::string, std::string> metadata = {
         {"key1", "value1"},
         {"key2", "value2"}
    };

    uploadFile(signedUrl, filePath, headers, metadata);

    return 0;
}

Android

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/plain;charset=utf8");
        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, "Status code returned for the upload: " + responseCode);
                if (responseCode == 200) {
                    Log.d(TAG, "Upload successful using network library.");
                } else {
                    Log.d(TAG, "Upload failed.");
                }

                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, "Upload successful.", Toast.LENGTH_SHORT).show();
            } else {
                Toast.makeText(SignUrlUploadActivity.this, "Upload failed.", Toast.LENGTH_SHORT).show();
            }
        }
    }
}

署名付き URL を使用したマルチパートアップロードの実行

署名付き URL を使用してマルチパートアップロードを実行するには、パートサイズを設定し、各パートに対して署名付き URL を生成する必要があります。以下のサンプルコードに例を示します：

package main

import (
	"bytes"
	"context"
	"flag"
	"fmt"
	"log"
	"net/http"
	"time"

	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss"
	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss/credentials"
)

var (
	region     string                     // リージョン。
	bucketName string                     // バケット名。
	objectName string                     // オブジェクト名。
	length     = int64(5000 * 1024)       // 合計ファイルサイズ (バイト単位)。
	partSize   = int64(200 * 1024)        // 各パートのサイズ (バイト単位)。
	partsNum   = int(length/partSize + 1) // パート数。
	data       = make([]byte, length)     // アップロード用のシミュレートされたデータ。
)

// コマンドラインパラメーターを初期化します。
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() {
	// コマンドラインパラメーターを解析します。
	flag.Parse()

	// 必須パラメーターが設定されているか確認します。
	if len(bucketName) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, bucket name required")
	}

	if len(region) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, region required")
	}

	if len(objectName) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, object name required")
	}

	// OSS クライアントを設定します。
	cfg := oss.LoadDefaultConfig().
		WithCredentialsProvider(credentials.NewEnvironmentVariableCredentialsProvider()).
		WithRegion(region)

	// OSS クライアントを作成します。
	client := oss.NewClient(cfg)

	// マルチパートアップロードを初期化します。
	initResult, err := client.InitiateMultipartUpload(context.TODO(), &oss.InitiateMultipartUploadRequest{
		Bucket: oss.Ptr(bucketName),
		Key:    oss.Ptr(objectName),
	})
	if err != nil {
		log.Fatalf("failed InitiateMultipartUpload %v", err)
	}

	// 各パートを走査し、署名付き URL を生成してパートをアップロードします。
	for i := 0; i < partsNum; i++ {
		start := int64(i) * partSize
		end := start + partSize
		if end > length {
			end = length
		}
		signedResult, err := client.Presign(context.TODO(), &oss.UploadPartRequest{
			Bucket:     oss.Ptr(bucketName),
			Key:        oss.Ptr(objectName),
			PartNumber: int32(i + 1),
			Body:       bytes.NewReader(data[start:end]),
			UploadId:   initResult.UploadId,
		}, oss.PresignExpiration(time.Now().Add(1*time.Hour))) // TTL が 1 時間の署名付き URL を生成します。
		if err != nil {
			log.Fatalf("failed to generate presigned URL %v", err)
		}
		fmt.Printf("signed url:%#v\n", signedResult.URL) // 生成された署名付き URL を出力します。

		// HTTP リクエストを作成し、パートをアップロードします。
		req, err := http.NewRequest(signedResult.Method, signedResult.URL, bytes.NewReader(data[start:end]))
		if err != nil {
			log.Fatalf("failed to create HTTP request %v", err)
		}

		c := &http.Client{} // HTTP クライアントを作成します。
		_, err = c.Do(req)
		if err != nil {
			log.Fatalf("failed to upload part by signed URL %v", err)
		}
	}

	// アップロードされたパートをリストします。
	partsResult, err := client.ListParts(context.TODO(), &oss.ListPartsRequest{
		Bucket:   oss.Ptr(bucketName),
		Key:      oss.Ptr(objectName),
		UploadId: initResult.UploadId,
	})
	if err != nil {
		log.Fatalf("failed to list parts %v", err)
	}

	// アップロードされたパートの情報を収集します。
	var parts []oss.UploadPart
	for _, p := range partsResult.Parts {
		parts = append(parts, oss.UploadPart{PartNumber: p.PartNumber, ETag: p.ETag})
	}

	// マルチパートアップロードを完了します。
	result, err := client.CompleteMultipartUpload(context.TODO(), &oss.CompleteMultipartUploadRequest{
		Bucket:   oss.Ptr(bucketName),
		Key:      oss.Ptr(objectName),
		UploadId: initResult.UploadId,
		CompleteMultipartUpload: &oss.CompleteMultipartUpload{
			Parts: parts,
		},
	})
	if err != nil {
		log.Fatalf("failed to complete multipart upload %v", err)
	}

	// 完了したマルチパートアップロードの結果を出力します。
	log.Printf("complete multipart upload result:%#v\n", result)
}

署名付き URL を使用したファイルのアップロードとアップロードコールバックパラメーターの設定

オブジェクト所有者が、指定されたアップロードコールバックパラメーターを持つ PUT メソッドの署名付き URL を生成します。

package main

import (
	"context"
	"encoding/base64"
	"encoding/json"
	"flag"
	"log"
	"time"

	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss"
	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss/credentials"
)

// グローバル変数を定義します。
var (
	region     string // ストレージリージョン。
	bucketName string // バケット名。
	objectName string // オブジェクト名。
)

// init 関数は、コマンドラインパラメーターを初期化するために使用されます。
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() {
	// コマンドラインパラメーターを解析します。
	flag.Parse()

	// バケット名が空かどうかを確認します。
	if len(bucketName) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, bucket name required")
	}

	// リージョンが空かどうかを確認します。
	if len(region) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, region required")
	}

	// オブジェクト名が空かどうかを確認します。
	if len(objectName) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, object name required")
	}

	// デフォルトの構成をロードし、認証情報プロバイダーとリージョンを設定します。
	cfg := oss.LoadDefaultConfig().
		WithCredentialsProvider(credentials.NewEnvironmentVariableCredentialsProvider()).
		WithRegion(region)

	// OSS クライアントを作成します。
	client := oss.NewClient(cfg)

	// コールバックパラメーターを定義します。
	callbackMap := map[string]string{
		"callbackUrl":      "http://example.com:23450",                                                                   // コールバックサーバーの URL を設定します。例：https://example.com:23450。
		"callbackBody":     "bucket=${bucket}&object=${object}&size=${size}&my_var_1=${x:my_var1}&my_var_2=${x:my_var2}", // コールバックリクエストボディを設定します。
		"callbackBodyType": "application/x-www-form-urlencoded",                                                          // コールバックリクエストボディのタイプを設定します。
	}

	// コールバックパラメーターを JSON に変換し、Base64 エンコードしてコールバックパラメーターとして渡します。
	callbackStr, err := json.Marshal(callbackMap)
	if err != nil {
		log.Fatalf("failed to marshal callback map: %v", err)
	}
	callbackBase64 := base64.StdEncoding.EncodeToString(callbackStr)

	callbackVarMap := map[string]string{}
	callbackVarMap["x:my_var1"] = "this is var 1"
	callbackVarMap["x:my_var2"] = "this is var 2"
	callbackVarStr, err := json.Marshal(callbackVarMap)
	if err != nil {
		log.Fatalf("failed to marshal callback var: %v", err)
	}
	callbackVarBase64 := base64.StdEncoding.EncodeToString(callbackVarStr)

	// PutObject の署名付き URL を生成します。
	result, err := client.Presign(context.TODO(), &oss.PutObjectRequest{
		Bucket:      oss.Ptr(bucketName),
		Key:         oss.Ptr(objectName),
		Callback:    oss.Ptr(callbackBase64),    // コールバックパラメーターを設定します。これは Base64 エンコードされた JSON 文字列です。
		CallbackVar: oss.Ptr(callbackVarBase64), // カスタムコールバックパラメーターを設定します。これは Base64 エンコードされた JSON 文字列です。
	},
		oss.PresignExpires(10*time.Minute),
	)
	if err != nil {
		log.Fatalf("failed to put 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 {
		// 結果に署名付きヘッダーが含まれている場合は、署名付き URL を使用して PUT リクエストを送信する際に、対応するリクエストヘッダーを設定する必要があります。
		log.Printf("signed headers:\n")
		for k, v := range result.SignedHeaders {
			log.Printf("%v: %v\n", k, v)
		}
	}
}

署名付き URL を使用してオブジェクトをアップロードします。

curl

curl -X PUT \
     -H "x-oss-callback: eyJjYWxsYmFja1VybCI6Imh0dHA6Ly93d3cuZXhhbXBsZS5jb20vY2FsbGJhY2siLCJjYWxsYmFja0JvZHkiOiJidWNrZXQ9JHtidWNrZXR9Jm9iamVjdD0ke29iamVjdH0mbXlfdmFyXzE9JHt4OnZhcjF9Jm15X3Zhcl8yPSR7eDp2YXIyfSJ9" \
     -H "x-oss-callback-var: eyJ4OnZhcjEiOiJ2YWx1ZTEiLCJ4OnZhcjIiOiJ2YWx1ZTIifQ==" \
     -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=LTAI****************%2F20241112%2Fcn-hangzhou%2Foss%2Faliyun_v4_request&x-oss-signature=ed5a******************************************************"

Python

import requests

def upload_file(signed_url, file_path, headers=None):
    """
    署名付き URL を使用してオブジェクトを OSS にアップロードします。

    :param signed_url: 署名付き URL。
    :param file_path: アップロードするローカルファイルの完全なパス。
    :param headers: リクエストヘッダー。このパラメーターはオプションです。
    :return: None
    """
    if not headers:
        headers = {}

    try:
        with open(file_path, 'rb') as file:
            response = requests.put(signed_url, data=file, headers=headers)
            print(f"Status code: {response.status_code}")
            if response.status_code == 200:
                print("The object is uploaded by using the library.")
            else:
                print("Upload failed.")
            print(response.text)
    except Exception as e:
        print(f"An error occurred: {e}")

if __name__ == "__main__":
    # <signedUrl> を署名付き URL に置き換えます。
    signed_url = "<signedUrl>"

    # ローカルファイルの完全なパスを指定します。デフォルトでは、ローカルファイルの完全なパスを指定しない場合、ローカルファイルはスクリプトが保存されているディレクトリからアップロードされます。
    file_path = "C:\\Users\\demo.txt"

    headers = {
        "x-oss-callback": "eyJjYWxsYmFja1VybCI6Imh0dHA6Ly93d3cuZXhhbXBsZS5jb20vY2FsbGJhY2siLCJjYWxsYmFja0JvZHkiOiJidWNrZXQ9JHtidWNrZXR9Jm9iamVjdD0ke29iamVjdH0mbXlfdmFyXzE9JHt4OnZhcjF9Jm15X3Zhcl8yPSR7eDp2YXIyfSJ9",
        "x-oss-callback-var": "eyJ4OnZhcjEiOiJ2YWx1ZTEiLCJ4OnZhcjIiOiJ2YWx1ZTIifQ==",
    }

    upload_file(signed_url,  file_path, headers)

Go

package main

import (
	"bytes"
	"fmt"
	"io"

	"net/http"
	"os"
)

func uploadFile(signedUrl string, filePath string, headers map[string]string) error {
	// ファイルを開きます。
	file, err := os.Open(filePath)
	if err != nil {
		return err
	}
	defer file.Close()

	// コンテンツを読み取ります。
	fileBytes, err := io.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.Add(key, value)
	}

	// リクエストを送信します。
	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		return err
	}
	defer resp.Body.Close()

	// 応答を処理します。
	fmt.Printf("Status code: %d\n", resp.StatusCode)
	if resp.StatusCode == 200 {
		fmt.Println("The object is uploaded by using the library.")
	} else {
		fmt.Println("Upload failed.")
	}
	body, _ := io.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{
		"x-oss-callback":     "eyJjYWxsYmFja1VybCI6Imh0dHA6Ly93d3cuZXhhbXBsZS5jb20vY2FsbGJhY2siLCJjYWxsYmFja0JvZHkiOiJidWNrZXQ9JHtidWNrZXR9Jm9iamVjdD0ke29iamVjdH0mbXlfdmFyXzE9JHt4OnZhcjF9Jm15X3Zhcl8yPSR7eDp2YXIyfSJ9",
		"x-oss-callback-var": "eyJ4OnZhcjEiOiJ2YWx1ZTEiLCJ4OnZhcjIiOiJ2YWx1ZTIifQ==",
	}

	err := uploadFile(signedUrl, filePath, headers)
	if err != nil {
		fmt.Printf("An error occurred: %v\n", err)
	}
}

Java

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";

        // x-oss-callback および x-oss-callback-var を含むリクエストヘッダーを指定します。
        Map<String, String> headers = new HashMap<String, String>();
        headers.put("x-oss-callback", "eyJjYWxsYmFja1VybCI6Imh0dHA6Ly93d3cuZXhhbXBsZS5jb20vY2FsbGJhY2siLCJjYWxsYmFja0JvZHkiOiJidWNrZXQ9JHtidWNrZXR9Jm9iamVjdD0ke29iamVjdH0mbXlfdmFyXzE9JHt4OnZhcjF9Jm15X3Zhcl8yPSR7eDp2YXIyfSJ9");
        headers.put("x-oss-callback-var", "eyJ4OnZhcjEiOiJ2YWx1ZTEiLCJ4OnZhcjIiOiJ2YWx1ZTIifQ==");

        try {
            HttpPut put = new HttpPut(signedUrl.toString());
            System.out.println(put);
            HttpEntity entity = new FileEntity(new File(pathName));
            put.setEntity(entity);
            // 署名付き URL が生成されたときにヘッダーを設定した場合、署名付き URL を使用してファイルをアップロードする際にこれらのヘッダーをサーバーに送信する必要があります。署名計算のためにサーバーに送信されるヘッダーが、署名付き URL が生成されたときに指定されたヘッダーと異なる場合、署名エラーが報告されます。
            for(Map.Entry header: headers.entrySet()){
                put.addHeader(header.getKey().toString(),header.getValue().toString());
            }

            httpClient = HttpClients.createDefault();

            response = httpClient.execute(put);

            System.out.println("Status code: "+response.getStatusLine().getStatusCode());
            if(response.getStatusLine().getStatusCode() == 200){
                System.out.println("The object is uploaded by using the library.");
            }
            System.out.println(response.toString());
        } catch (Exception e){
            e.printStackTrace();
        } finally {
            response.close();
            httpClient.close();
        }
    }
}

PHP

<?php

function uploadFile($signedUrl, $filePath, $headers = []) {
    // ファイルが存在するかどうかを確認します。
    if (!file_exists($filePath)) {
        echo "The file does not exist: $filePath\n";
        return;
    }

    // cURL セッションを初期化します。
    $ch = curl_init();

    // cURL オプションを設定します。
    curl_setopt($ch, CURLOPT_URL, $signedUrl);
    curl_setopt($ch, CURLOPT_PUT, true);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_INFILE, fopen($filePath, 'rb'));
    curl_setopt($ch, CURLOPT_INFILESIZE, filesize($filePath));
    curl_setopt($ch, CURLOPT_HTTPHEADER, array_map(function($key, $value) {
        return "$key: $value";
    }, array_keys($headers), $headers));

    // cURL リクエストを実行します。
    $response = curl_exec($ch);

    // HTTP ステータスコードを照会します。
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);

    // cURL セッションを閉じます。
    curl_close($ch);

    // 結果を出力します
    echo "Status code: $httpCode\n";
    if ($httpCode == 200) {
        echo "The object is uploaded by using the library.\n";
    } else {
        echo "Upload failed.\n";
    }
    echo $response . "\n";
}

// <signedUrl> を署名付き URL に置き換えます。
$signedUrl = "<signedUrl>";

// ローカルファイルの完全なパスを指定します。デフォルトでは、ローカルファイルの完全なパスを指定しない場合、ローカルファイルはスクリプトが保存されているディレクトリからアップロードされます。
$filePath = "C:\\Users\\demo.txt";

$headers = [
    "x-oss-callback" => "eyJjYWxsYmFja1VybCI6Imh0dHA6Ly93d3cuZXhhbXBsZS5jb20vY2FsbGJhY2siLCJjYWxsYmFja0JvZHkiOiJidWNrZXQ9JHtidWNrZXR9Jm9iamVjdD0ke29iamVjdH0mbXlfdmFyXzE9JHt4OnZhcjF9Jm15X3Zhcl8yPSR7eDp2YXIyfSJ9",
    "x-oss-callback-var" => "eyJ4OnZhcjEiOiJ2YWx1ZTEiLCJ4OnZhcjIiOiJ2YWx1ZTIifQ==",
];

uploadFile($signedUrl, $filePath, $headers);

?>

Object Storage Service:署名付き URL を使用したファイルのアップロード (Go SDK V2)

注意事項

プロセス

メソッド定義

リクエストパラメーター

戻り値

サンプルコード

curl

Java

Go

python

Node.js

browser.js

C#

C++

Android

一般的なシナリオ

署名付き URL を使用して、指定されたリクエストヘッダーとカスタムメタデータでファイルをアップロード

curl

Java

Go

Python

Node.js

Browser.js

C#

C++

Android

署名付き URL を使用したマルチパートアップロードの実行

署名付き URL を使用したファイルのアップロードとアップロードコールバックパラメーターの設定

curl

Python

Go

Java

PHP

関連ドキュメント