すべてのプロダクト
Search

このプロダクト

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

    ドキュメントセンター

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

    最終更新日:Dec 17, 2025

    デフォルトでは、Object Storage Service (OSS) バケット内のファイルは非公開であり、ファイル所有者のみがアクセスできます。OSS C# software development kit (SDK) を使用して、他のユーザーにファイルのアップロード権限を付与する署名付き URL を生成できます。署名付き URL を生成する際に、カスタムの有効期限を設定してアクセス期間を制限できます。署名付き URL は、有効期限が切れるまで複数回使用できます。ただし、複数回のアップロード操作によりファイルが上書きされる可能性があります。URL の有効期限が切れると、アップロードには使用できなくなります。新しい署名付き URL を生成する必要があります。

    注意事項

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

    • この Topic では、環境変数からアクセス認証情報を読み取る例を示します。アクセス認証情報の設定方法の詳細については、「アクセス認証情報の設定 (C# SDK V1)」をご参照ください。

    • アップロード用の署名付き URL を生成するには、oss:PutObject 権限が必要です。詳細については、「RAM ユーザーへのカスタムアクセスポリシーの付与」をご参照ください。

      説明

      署名付き URL が生成される際、SDK はローカルに保存されたキーを使用して特定のアルゴリズムに基づいて署名を計算します。その後、SDK はその署名を URL に追加して、その有効性とセキュリティを確保します。これらの計算と URL の構築操作はクライアント側で実行され、サーバーへのネットワークリクエストは送信されません。したがって、呼び出し元は署名付き URL を生成するために特定の権限を必要としません。ただし、第三者のユーザーが署名付き URL によって承認されたリソースに対して操作を実行できるようにするには、署名付き URL を生成するために API を呼び出すエンティティに必要な権限が付与されていることを確認する必要があります。

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

    • 以下の例から生成された署名付き URL にプラス記号 (+) が含まれている場合、URL にアクセスできない可能性があります。この問題を解決するには、URL 内のプラス記号 (+) を %2B に置き換えてください。

    • HTTPS プロトコルを使用する署名付き URL を生成するには、エンドポイントの通信プロトコルを HTTPS に設定します。

    操作手順

    以下の手順は、PUT メソッドで署名付き URL を使用してファイルをアップロードする方法を示しています：

    image

    コード例

    1. アップロード用の署名付き URL を生成

      using Aliyun.OSS;
using Aliyun.OSS.Common;
// バケットが配置されているリージョンのエンドポイントを指定します。たとえば、バケットが中国 (杭州) リージョンにある場合、エンドポイントを https://oss-cn-hangzhou.aliyuncs.com に設定します。
var endpoint = "https://oss-cn-hangzhou.aliyuncs.com";
// 環境変数からアクセス認証情報を取得します。このコードを実行する前に、OSS_ACCESS_KEY_ID および OSS_ACCESS_KEY_SECRET 環境変数が設定されていることを確認してください。
var accessKeyId = Environment.GetEnvironmentVariable("OSS_ACCESS_KEY_ID");
var accessKeySecret = Environment.GetEnvironmentVariable("OSS_ACCESS_KEY_SECRET");
// バケット名を指定します (例: examplebucket)。
var bucketName = "examplebucket";
// オブジェクトの完全なパスを指定します。完全なパスにはバケット名は含まれません (例: exampledir/exampleobject.txt)。
var objectName = "exampledir/exampleobject.txt";
var objectContent = "More than just cloud.";
// バケットが配置されているリージョンを指定します。たとえば、バケットが中国 (杭州) リージョンにある場合、リージョンを cn-hangzhou に設定します。
const string region = "cn-hangzhou";

// ClientConfiguration インスタンスを作成し、必要に応じてデフォルトのパラメーターを変更します。
var conf = new ClientConfiguration();

// 署名バージョンを V4 に設定します。
conf.SignatureVersion = SignatureVersion.V4;

// OssClient インスタンスを作成します。
var client = new OssClient(endpoint, accessKeyId, accessKeySecret, conf);
client.SetRegion(region);
try
{
    // 署名付き URL を生成します。
    var generatePresignedUriRequest = new GeneratePresignedUriRequest(bucketName, objectName, SignHttpMethod.Put)
    {
        // 署名付き URL の有効期限を設定します。デフォルト値は 3600 秒です。
        Expiration = DateTime.Now.AddHours(1),
    };
    var signedUrl = client.GeneratePresignedUri(generatePresignedUriRequest);
}
catch (OssException ex)
{
    Console.WriteLine("Failed with error code: {0}; Error info: {1}. \nRequestID:{2}\tHostID:{3}",
        ex.ErrorCode, ex.Message, ex.RequestId, ex.HostId);
}
catch (Exception ex)
{
    Console.WriteLine("Failed with error info: {0}", ex.Message);
}

    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 が使用されます。URL の有効期間は、トークンの有効期間と署名付き URL の有効期間のうち、短い方になります。

    署名付き URL の生成時に POST メソッドはサポートされますか？

    いいえ、違います。

    署名付き URL は、PUT および GET メソッドに対してのみ生成できます。POST メソッドを使用してファイルをアップロードするには、POST リクエストを構築する必要があります。詳細については、「PostObject」をご参照ください。