すべてのプロダクト
Search

このプロダクト

    Object Storage Service:署名付き URL を使用したオブジェクトのアップロード (Java SDK V1)

    ドキュメントセンター

    Object Storage Service:署名付き URL を使用したオブジェクトのアップロード (Java SDK V1)

    最終更新日:Dec 17, 2025

    デフォルトでは、Object Storage Service (OSS) バケット内のオブジェクトは非公開です。オブジェクト所有者のみがオブジェクトをアップロードする権限を持っています。OSS SDK for Java を使用して署名付き URL を生成し、他のユーザーがオブジェクトをアップロードできるようにすることができます。署名付き URL を生成する際に、有効期限を指定してその有効性を制限できます。URL は有効期限が切れるまで複数回使用できます。複数のアップロード操作が実行された場合、オブジェクトが上書きされる可能性があります。URL の有効期限が切れると、アップロードには使用できなくなり、新しい署名付き URL を生成する必要があります。

    注意事項

    • このトピックでは、中国 (杭州) リージョンのパブリックエンドポイントを使用します。同じリージョン内の他の Alibaba Cloud サービスから OSS にアクセスするには、内部エンドポイントを使用します。サポートされているリージョンとエンドポイントの詳細については、「リージョンとエンドポイント」をご参照ください。

    • このトピックでは、アクセス認証情報は環境変数から取得されます。アクセス認証情報の設定方法の詳細については、「アクセス認証情報の設定」をご参照ください。

    • このトピックでは、OSS エンドポイントを使用して OSSClient インスタンスが作成されます。カスタムドメイン名またはセキュリティトークンサービス (STS) を使用して OSSClient インスタンスを作成する場合は、「一般的なシナリオの設定例」をご参照ください。

    • 署名付き URL の生成に権限は必要ありません。ただし、URL を生成したユーザーが oss:PutObject 権限を持っている場合にのみ、第三者は署名付き URL を使用してファイルを正常にアップロードできます。権限の付与方法の詳細については、「RAM ユーザーへのカスタム権限の付与」をご参照ください。

    • このトピックでは、V4 署名付き URL を例として使用します。最大有効期間は 7 日間です。詳細については、「署名バージョン 4 (推奨)」をご参照ください。

    プロセス

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

    コード例

    1. オブジェクト所有者が PUT リクエストの署名付き URL を生成します。

      import com.aliyun.oss.*;
import com.aliyun.oss.common.auth.*;
import com.aliyun.oss.common.comm.SignVersion;
import com.aliyun.oss.model.GeneratePresignedUrlRequest;
import java.net.URL;
import java.util.*;
import java.util.Date;

public class GetSignUrl {
    public static void main(String[] args) throws Throwable {
        // この例では、中国 (杭州) リージョンのパブリックエンドポイントを使用します。実際のエンドポイントを指定してください。
        String endpoint = "https://oss-cn-hangzhou.aliyuncs.com";
        // 環境変数からアクセス認証情報を取得します。サンプルコードを実行する前に、OSS_ACCESS_KEY_ID および OSS_ACCESS_KEY_SECRET 環境変数が設定されていることを確認してください。
        EnvironmentVariableCredentialsProvider credentialsProvider = CredentialsProviderFactory.newEnvironmentVariableCredentialsProvider();
        // バケット名を指定します (例: examplebucket)。
        String bucketName = "examplebucket";
        // オブジェクトの完全なパスを指定します (例: exampleobject.txt)。オブジェクトの完全なパスにバケット名を含めることはできません。
        String objectName = "exampleobject.txt";
        // バケットが配置されているリージョンを指定します。たとえば、バケットが中国 (杭州) リージョンにある場合、リージョンを cn-hangzhou に設定します。
        String region = "cn-hangzhou";

        // OSSClient インスタンスを作成します。
        // OSSClient インスタンスが不要になったら、shutdown メソッドを呼び出してリソースを解放します。
        ClientBuilderConfiguration clientBuilderConfiguration = new ClientBuilderConfiguration();
        clientBuilderConfiguration.setSignatureVersion(SignVersion.V4);
        OSS ossClient = OSSClientBuilder.create()
                .endpoint(endpoint)
                .credentialsProvider(credentialsProvider)
                .clientConfiguration(clientBuilderConfiguration)
                .region(region)
                .build();

        URL signedUrl = null;
        try {
            // 生成された署名付き URL の有効期限をミリ秒単位で指定します。この例では、有効期限を 1 時間に設定します。
            Date expiration = new Date(new Date().getTime() + 3600 * 1000L);

            // 署名付き URL を生成します。
            GeneratePresignedUrlRequest request = new GeneratePresignedUrlRequest(bucketName, objectName, HttpMethod.PUT);
            // 有効期限を設定します。
            request.setExpiration(expiration);
            // HTTP PUT リクエストの署名付き URL を生成します。
            signedUrl = ossClient.generatePresignedUrl(request);
            // 署名付き URL を出力します。
            System.out.println("signed url for putObject: " + signedUrl);

        } catch (OSSException oe) {
            System.out.println("Caught an OSSException, which means your request made it to OSS, "
                    + "but was rejected with an error response for some reason.");
            System.out.println("Error Message:" + oe.getErrorMessage());
            System.out.println("Error Code:" + oe.getErrorCode());
            System.out.println("Request ID:" + oe.getRequestId());
            System.out.println("Host ID:" + oe.getHostId());
        } catch (ClientException ce) {
            System.out.println("Caught an ClientException, which means the client encountered "
                    + "a serious internal problem while trying to communicate with OSS, "
                    + "such as not being able to access the network.");
            System.out.println("Error Message:" + ce.getMessage());
        }
    }
}

    2. 別のユーザーが 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 を使用して、指定されたリクエストヘッダーとカスタムメタデータでファイルをアップロードする

    1. オブジェクト所有者は、指定されたリクエストヘッダーとカスタムメタデータを含む PUT リクエストの署名付き URL を生成します。

      import com.aliyun.oss.*;
import com.aliyun.oss.common.auth.*;
import com.aliyun.oss.common.comm.SignVersion;
import com.aliyun.oss.internal.OSSHeaders;
import com.aliyun.oss.model.GeneratePresignedUrlRequest;
import com.aliyun.oss.model.StorageClass;

import java.net.URL;
import java.util.*;
import java.util.Date;

public class GetSignUrl {
    public static void main(String[] args) throws Throwable {
        // この例では、中国 (杭州) リージョンのパブリックエンドポイントを使用します。実際のエンドポイントを指定してください。
        String endpoint = "https://oss-cn-hangzhou.aliyuncs.com";
        // 環境変数からアクセス認証情報を取得します。サンプルコードを実行する前に、OSS_ACCESS_KEY_ID および OSS_ACCESS_KEY_SECRET 環境変数が設定されていることを確認してください。
        EnvironmentVariableCredentialsProvider credentialsProvider = CredentialsProviderFactory.newEnvironmentVariableCredentialsProvider();
        // バケット名を指定します (例: examplebucket)。
        String bucketName = "examplebucket";
        // オブジェクトの完全なパスを指定します (例: exampleobject.txt)。オブジェクトの完全なパスにバケット名を含めることはできません。
        String objectName = "exampleobject.txt";
        // バケットが配置されているリージョンを指定します。たとえば、バケットが中国 (杭州) リージョンにある場合、リージョンを cn-hangzhou に設定します。
        String region = "cn-hangzhou";

        // OSSClient インスタンスを作成します。
        // OSSClient インスタンスが不要になったら、shutdown メソッドを呼び出してリソースを解放します。
        ClientBuilderConfiguration clientBuilderConfiguration = new ClientBuilderConfiguration();
        clientBuilderConfiguration.setSignatureVersion(SignVersion.V4);
        OSS ossClient = OSSClientBuilder.create()
                .endpoint(endpoint)
                .credentialsProvider(credentialsProvider)
                .clientConfiguration(clientBuilderConfiguration)
                .region(region)
                .build();

        // リクエストヘッダーを設定します。
        Map<String, String> headers = new HashMap<String, String>();
        // StorageClass を指定します。
        headers.put(OSSHeaders.STORAGE_CLASS, StorageClass.Standard.toString());
        // ContentType を指定します。
        headers.put(OSSHeaders.CONTENT_TYPE, "text/plain; charset=utf8");

        // カスタムユーザーメタデータを設定します。
        Map<String, String> userMetadata = new HashMap<String, String>();
        userMetadata.put("key1","value1");
        userMetadata.put("key2","value2");

        URL signedUrl = null;
        try {
            // 生成された署名付き URL の有効期限をミリ秒単位で指定します。この例では、有効期限を 1 時間に設定します。
            Date expiration = new Date(new Date().getTime() + 3600 * 1000L);

            // 署名付き URL を生成します。
            GeneratePresignedUrlRequest request = new GeneratePresignedUrlRequest(bucketName, objectName, HttpMethod.PUT);
            // 有効期限を設定します。
            request.setExpiration(expiration);

            // リクエストにリクエストヘッダーを追加します。
            request.setHeaders(headers);
            // カスタムユーザーメタデータを追加します。
            request.setUserMetadata(userMetadata);

            // HTTP PUT リクエストの署名付き URL を生成します。
            signedUrl = ossClient.generatePresignedUrl(request);
            // 署名付き URL を出力します。
            System.out.println("signed url for putObject: " + signedUrl);

        } catch (OSSException oe) {
            System.out.println("Caught an OSSException, which means your request made it to OSS, "
                    + "but was rejected with an error response for some reason.");
            System.out.println("Error Message:" + oe.getErrorMessage());
            System.out.println("Error Code:" + oe.getErrorCode());
            System.out.println("Request ID:" + oe.getRequestId());
            System.out.println("Host ID:" + oe.getHostId());
        } catch (ClientException ce) {
            System.out.println("Caught an ClientException, which means the client encountered "
                    + "a serious internal problem while trying to communicate with OSS, "
                    + "such as not being able to access the network.");
            System.out.println("Error Message:" + ce.getMessage());
        }
    }
}

    2. 別のユーザーが 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

      重要

      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 (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 を生成する必要があります。次のサンプルコードは、その例を示しています。

    import com.aliyun.oss.*;
import com.aliyun.oss.common.auth.*;
import com.aliyun.oss.common.comm.SignVersion;
import com.aliyun.oss.common.utils.CRC64;
import com.aliyun.oss.internal.Mimetypes;
import com.aliyun.oss.model.*;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpPut;
import org.apache.http.entity.BufferedHttpEntity;
import org.apache.http.entity.InputStreamEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.DefaultHttpRequestRetryHandler;
import org.apache.http.impl.client.HttpClients;
import java.io.*;
import java.net.URL;
import java.util.*;
import java.util.Date;

public class MultipartUrl {
    public static void main(String[] args) throws Throwable {
        // この例では、中国 (杭州) リージョンのパブリックエンドポイントを使用します。実際のエンドポイントを指定してください。
        String endpoint = "https://oss-cn-hangzhou.aliyuncs.com";
        // 環境変数からアクセス認証情報を取得します。サンプルコードを実行する前に、OSS_ACCESS_KEY_ID および OSS_ACCESS_KEY_SECRET 環境変数が設定されていることを確認してください。
        EnvironmentVariableCredentialsProvider credentialsProvider = CredentialsProviderFactory.newEnvironmentVariableCredentialsProvider();
        // バケット名を指定します (例: examplebucket)。
        String bucketName = "examplebucket";
        // オブジェクトの完全なパスを指定します (例: exampleobject.txt)。オブジェクトの完全なパスにバケット名を含めることはできません。
        String objectName = "exampleobject.txt";
        // ローカルファイルの完全なパスを指定します。ローカルパスを指定しない場合、ファイルはデフォルトでサンプルプログラムのプロジェクトパスからアップロードされます。
        String pathName = "D:\\localpath\\examplefile.txt";
        // 生成された署名付き URL の有効期限をミリ秒単位で指定します。この例では、有効期限を 1 時間に設定します。
        long expireTime = 3600*1000L;
        // バケットが配置されているリージョンを指定します。たとえば、バケットが中国 (杭州) リージョンにある場合、リージョンを cn-hangzhou に設定します。
        String region = "cn-hangzhou";

        // OSSClient インスタンスを作成します。
        // OSSClient インスタンスが不要になったら、shutdown メソッドを呼び出してリソースを解放します。
        ClientBuilderConfiguration clientBuilderConfiguration = new ClientBuilderConfiguration();
        clientBuilderConfiguration.setSignatureVersion(SignVersion.V4);
        OSS ossClient = OSSClientBuilder.create()
                .endpoint(endpoint)
                .credentialsProvider(credentialsProvider)
                .clientConfiguration(clientBuilderConfiguration)
                .region(region)
                .build();

        // InitiateMultipartUploadRequest オブジェクトを作成します。
        InitiateMultipartUploadRequest initRequest = new InitiateMultipartUploadRequest(bucketName, objectName);
        ObjectMetadata metadata = new ObjectMetadata();
        // ファイルに基づいて ContentType を自動的に設定します。このパラメーターが設定されていない場合、ContentType はデフォルトで application/octet-stream になります。
        if (metadata.getContentType() == null) {
            metadata.setContentType(Mimetypes.getInstance().getMimetype(new File(pathName), objectName));
        }

        initRequest.setObjectMetadata(metadata);
        // マルチパートアップロードを初期化します。
        InitiateMultipartUploadResult upResult = ossClient.initiateMultipartUpload(initRequest);
        // uploadId が返されます。uploadId は、マルチパートアップロードイベントの一意の識別子です。この uploadId を使用して、マルチパートアップロードのキャンセルやクエリなどの関連操作を実行できます。
        String uploadId = upResult.getUploadId();

        // partETags は PartETag のコレクションです。PartETag は、パートの ETag とパート番号で構成されます。
        List<PartETag> partETags =  new ArrayList<PartETag>();
        // 各パートのサイズ (バイト単位)。ファイルのパート数を計算するために使用されます。
        long partSize = 1 * 100 * 1024L;   // 100 KB。

        // ローカルファイルの完全なパスを指定します。ローカルパスを指定しない場合、ファイルはデフォルトでサンプルプログラムのプロジェクトパスからアップロードされます。
        File sampleFile = new File(pathName);
        long fileLength = sampleFile.length();
        // パートが 1 つだけの場合は、パートサイズをファイルサイズに設定します。
        // long fileLength = sampleFile.length();
        int partCount = (int) (fileLength / partSize);
        if (fileLength % partSize != 0) {
            partCount++;
        }

        // 署名付き URL のリクエストヘッダーを設定します。
        Map<String, String> headers = new HashMap<String, String>();
        // ContentType を指定します。
        // headers.put(OSSHeaders.CONTENT_TYPE, "text/plain");


        // パートを走査して各パートの署名を取得し、パートをアップロードします。
        // すべてのパートの署名付き URL を一度に返してから、順次アップロードすることもできます。この例では、単一の署名付き URL を返し、その署名付き URL を使用して単一のパートをアップロードする方法を示します。
        for (int i = 0; i < partCount; i++) {
            long startPos = i * partSize;
            long curPartSize = (i + 1 == partCount) ? (fileLength - startPos) : partSize;

            /*// MD5 検証を設定します。MD5 検証は単一のパートでのみサポートされます。
            FileInputStream inStream = new FileInputStream(pathName);
            // アップロード済みのパートをスキップします。
            inStream.skip(startPos);
            BoundedInputStream entity = new BoundedInputStream(inStream, partSize);
            String md5 = BinaryUtil.toBase64String(DigestUtils.md5(entity));
            headers.put("Content-MD5", md5);*/

            String signUrl = getSignUrl(ossClient, bucketName, objectName, HttpMethod.PUT, expireTime, i + 1, uploadId, headers);

            // 署名付き URL を使用してファイルをアップロードします。この例では HttpClients を使用します。
            putObjectWithHttp(signUrl, pathName, startPos, curPartSize, headers);
        }

        // パートをマージする際に、パートをアップロードしたシステムとは異なるシステム上にいると仮定します。この場合、まずパートをリストアップしてからマージする必要があります。
        // アップロードされたパートをリストアップします。
        ListPartsRequest listPartsRequest = new ListPartsRequest(bucketName, objectName, uploadId);
        PartListing partListing = ossClient.listParts(listPartsRequest);

        // パートを走査し、partETags を設定します。
        for (PartSummary part : partListing.getParts()) {
            PartETag partETag = new PartETag(part.getPartNumber(), part.getETag());
            partETags.add(partETag);
        }

        // パートをマージします。
        CompleteMultipartUploadRequest completeMultipartUploadRequest =
                new CompleteMultipartUploadRequest(bucketName, objectName, uploadId, partETags);
        // String md5 = BinaryUtil.toBase64String(BinaryUtil.calculateMd5("aaa".getBytes()));
        // 同じ名前のオブジェクトの上書きを禁止します。
        // completeMultipartUploadRequest.addHeader("x-oss-forbid-overwrite", "true");

        // マルチパートアップロードを完了します。
        CompleteMultipartUploadResult completeMultipartUploadResult = ossClient.completeMultipartUpload(completeMultipartUploadRequest);
        System.out.println("The parts are merged and the multipart upload is complete.");


        // アップロードされたファイルの整合性を検証します。
        CRC64 crc = new CRC64();
        InputStream inStream = new FileInputStream(pathName);
        byte[] bytes = new byte[1024];
        int cnt;
        while ((cnt = inStream.read(bytes)) != -1) {
            crc.update(bytes, 0, cnt);
        }

        if(crc.getValue() == completeMultipartUploadResult.getServerCRC()){
            System.out.println("The uploaded file is complete.");
        } else {
            System.out.println("The uploaded file is incomplete. Handle the exception.");
        }
    }

    public static void putObjectWithHttp(String signedUrl, String pathName, long startPos, long partSize, Map<String, String> headers) throws IOException {
        CloseableHttpClient httpClient = null;
        CloseableHttpResponse response = null;
        try {
            HttpPut put = new HttpPut(signedUrl);

            FileInputStream inStream = new FileInputStream(pathName);
            // アップロード済みのパートをスキップします。
            inStream.skip(startPos);
            InputStreamEntity entity = new InputStreamEntity(inStream, partSize);
            BufferedHttpEntity byteArrayEntity = new BufferedHttpEntity(entity);
            put.setEntity(byteArrayEntity);

            // 署名付き URL を生成する際に、ユーザーメタデータやストレージクラスなどのヘッダーパラメーターを設定した場合、署名付き URL を使用してファイルをアップロードする際にもこれらのパラメーターをサーバーに送信する必要があります。サーバーに送信されたパラメーターが署名付きパラメーターと一致しない場合、署名エラーが報告されます。
            for(Map.Entry header: headers.entrySet()){
                put.addHeader(header.getKey().toString(),header.getValue().toString());
            }

            // リトライメカニズムを追加します。リトライ回数は 3 に設定されています。これは単なる例です。ビジネスニーズに応じてリトライ回数を設定してください。
            httpClient = HttpClients.custom().setRetryHandler(new DefaultHttpRequestRetryHandler(3, true)).build();

            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 {
            if(response != null){
                response.close();
            }
            if(httpClient != null){
                httpClient.close();
            }
        }
    }

    public static String getSignUrl(OSS ossClient, String bucketName, String objectName, HttpMethod method, long expireTime, int partNum, String uploadId, Map<String, String> headers){
        // 生成された署名付き URL の有効期限をミリ秒単位で指定します。
        Date expiration = new Date(new Date().getTime() + expireTime);

        // 署名付き URL を生成します。
        GeneratePresignedUrlRequest request = new GeneratePresignedUrlRequest(bucketName, objectName, method);
        // 有効期限を設定します。
        request.setExpiration(expiration);

        // リクエストにリクエストヘッダーを追加します。
        request.setHeaders(headers);

        request.addQueryParameter("partNumber", String.valueOf(partNum));

        request.addQueryParameter("uploadId", uploadId);


        // HTTP メソッドリクエストの署名付き URL を生成します。
        URL signedUrl = ossClient.generatePresignedUrl(request);
        // 署名付き URL を出力します。
        System.out.println("signed url: " + signedUrl);
        return signedUrl.toString();
    }
}

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

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

      import com.aliyun.oss.*;
import com.aliyun.oss.common.auth.CredentialsProviderFactory;
import com.aliyun.oss.common.auth.EnvironmentVariableCredentialsProvider;
import com.aliyun.oss.common.comm.SignVersion;
import com.aliyun.oss.internal.OSSHeaders;
import com.aliyun.oss.model.GeneratePresignedUrlRequest;

import java.net.URL;
import java.text.SimpleDateFormat;
import java.util.*;

public class OssPresignExample {
    public static void main(String[] args) throws Throwable {
        // この例では、中国 (杭州) リージョンのパブリックエンドポイントを使用します。実際のエンドポイントを指定してください。
        String endpoint = "https://oss-cn-hangzhou.aliyuncs.com";
        // 環境変数からアクセス認証情報を取得します。サンプルコードを実行する前に、OSS_ACCESS_KEY_ID および OSS_ACCESS_KEY_SECRET 環境変数が設定されていることを確認してください。
        EnvironmentVariableCredentialsProvider credentialsProvider = CredentialsProviderFactory.newEnvironmentVariableCredentialsProvider();
        // バケット名を指定します (例: examplebucket)。
        String bucketName = "examplebucket";
        // オブジェクトの完全なパスを指定します (例: exampleobject.txt)。オブジェクトの完全なパスにバケット名を含めることはできません。
        String objectName = "exampleobject.txt";
        // バケットが配置されているリージョンを指定します。たとえば、バケットが中国 (杭州) リージョンにある場合、リージョンを cn-hangzhou に設定します。
        String region = "cn-hangzhou";

        // OSSClient インスタンスを作成します。
        // OSSClient インスタンスが不要になったら、shutdown メソッドを呼び出してリソースを解放します。
        ClientBuilderConfiguration clientBuilderConfiguration = new ClientBuilderConfiguration();
        clientBuilderConfiguration.setSignatureVersion(SignVersion.V4);
        OSS ossClient = OSSClientBuilder.create()
                .endpoint(endpoint)
                .credentialsProvider(credentialsProvider)
                .clientConfiguration(clientBuilderConfiguration)
                .region(region)
                .build();

        URL signedUrl = null;
        try {
            // コールバックパラメーターを構築します。
            String callbackUrl = "http://www.example.com/callback";
            String callbackBody = "{\"callbackUrl\":\"" + callbackUrl + "\",\"callbackBody\":\"bucket=${bucket}&object=${object}&my_var_1=${x:var1}&my_var_2=${x:var2}\"}";
            String callbackBase64 = Base64.getEncoder().encodeToString(callbackBody.getBytes());

            String callbackVarJson = "{\"x:var1\":\"value1\",\"x:var2\":\"value2\"}";
            String callbackVarBase64 = Base64.getEncoder().encodeToString(callbackVarJson.getBytes());
            // リクエストヘッダーを設定します。
            Map<String, String> headers = new HashMap<String, String>();
            // CALLBACK を指定します。
            headers.put(OSSHeaders.OSS_HEADER_CALLBACK, callbackBase64);
            // CALLBACK-VAR を指定します。
            headers.put(OSSHeaders.OSS_HEADER_CALLBACK_VAR, callbackVarBase64);

            // 有効期限を設定します (3600 秒後)。
            Date expiration = new Date(new Date().getTime() + 3600 * 1000);

            // 有効期限をフォーマットします。
            SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
            dateFormat.setTimeZone(TimeZone.getTimeZone("UTC"));
            String expirationStr = dateFormat.format(expiration);

            // リクエストを構築します。
            GeneratePresignedUrlRequest request = new GeneratePresignedUrlRequest(bucketName, objectName);
            request.setMethod(HttpMethod.PUT);
            request.setExpiration(expiration);
            // リクエストにリクエストヘッダーを追加します。
            request.setHeaders(headers);

            // callback および callback-var パラメーターを出力します。
            System.out.println("callback:"+callbackBase64);
            System.out.println("callback-var:"+callbackVarBase64);

            // 署名付き URL を生成します。
            URL url = ossClient.generatePresignedUrl(request);

            // 結果を出力します。
            System.out.println("method: PUT,");
            System.out.println(" expiration: " + expirationStr + ",");
            System.out.println(" url: " + url);

        } catch (OSSException oe) {
            System.out.println("Caught an OSSException, which means your request made it to OSS, "
                    + "but was rejected with an error response for some reason.");
            System.out.println("Error Message:" + oe.getErrorMessage());
            System.out.println("Error Code:" + oe.getErrorCode());
            System.out.println("Request ID:" + oe.getRequestId());
            System.out.println("Host ID:" + oe.getHostId());
        } catch (ClientException ce) {
            System.out.println("Caught an ClientException, which means the client encountered "
                    + "a serious internal problem while trying to communicate with OSS, "
                    + "such as not being able to access the network.");
            System.out.println("Error Message:" + ce.getMessage());
        }
    }
}

    2. 別のユーザーが PUT リクエストの署名付き 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);

?>

    よくある質問

    ファイルのアップロード中に一時的な署名の有効期限が切れた場合、アップロードは失敗しますか？

    アップロードは成功します。

    アップロードには署名付き URL が使用されます。この URL は、トークンの有効期間と署名付き URL の有効期間のうち、短い方の期間内であれば使用できます。

    URL の生成時にリクエストヘッダーとカスタムメタデータを設定しなかった場合、アップロード時にそれらを設定する必要がありますか？

    設定は不要です。

    リクエストヘッダーとカスタムメタデータはオプションのパラメーターです。これらのパラメーターを設定しない場合は、例から関連するコードを削除できます。

    関連ドキュメント

    • V4 署名付き URL を生成するための完全なサンプルコードについては、GitHub の例をご参照ください。

    • 署名付き URL を使用したファイルのアップロードに関する API 操作の詳細については、「GeneratePresignedUrlRequest」をご参照ください。