Node.js を使用して署名付き URL でオブジェクトをアップロードする - Object Storage Service

デフォルトでは、Object Storage Service (OSS) バケット内のオブジェクトは非公開です。オブジェクト所有者のみがオブジェクトをアップロードする権限を持っています。OSS の Node.js SDK を使用して、他のユーザーがオブジェクトをアップロードできる署名付き URL を生成できます。URL を生成する際に、カスタムの有効期限を設定できます。URL は有効期間内に複数回使用できます。同じ URL を使用して複数回アップロードを実行すると、オブジェクトが上書きされる可能性があります。URL の有効期限が切れると、使用できなくなります。アップロードを実行するには、新しい署名付き URL を生成する必要があります。

注意事項

このトピックでは、中国 (杭州) リージョンのパブリックエンドポイントを使用します。同じリージョン内の他の Alibaba Cloud サービスから OSS にアクセスするには、内部エンドポイントを使用します。サポートされているリージョンとエンドポイントの詳細については、「リージョンとエンドポイント」をご参照ください。
このトピックでは、環境変数から読み取られたアクセス認証情報を例として使用します。アクセス認証情報の設定方法の詳細については、「アクセス認証情報の設定 (Node.js SDK)」をご参照ください。
アップロード用の署名付き URL を生成するには、oss:PutObject 権限が必要です。詳細については、「RAM ユーザーへのカスタムポリシーの付与」をご参照ください。
説明
署名付き URL を生成する際、SDK はローカルに保存されたキーを使用して特定のアルゴリズムに基づいて署名を計算します。その後、SDK はその署名を URL に追加して、その有効性とセキュリティを保証します。この計算と URL の構築プロセスはクライアント側で行われ、サーバーへのネットワークリクエストは伴いません。したがって、呼び出し元は署名付き URL を生成するために特定の権限を必要としません。ただし、URL を生成する ID は、リソースに対して必要な権限を持っている必要があります。これにより、サードパーティのユーザーがリソースに対して権限付与された操作を実行できるようになります。
このトピックでは、V4 署名付き URL を例として使用します。最大有効期間は 7 日間です。詳細については、「署名 V4 (推奨)」をご参照ください。

プロセス

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

サンプルコード

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

const OSS = require("ali-oss");

// 署名付き URL を生成する関数を定義します。
async function generateSignatureUrl(fileName) {
  // 署名付き URL を取得します。
  const client = await new OSS({
      accessKeyId: 'yourAccessKeyId',
      accessKeySecret: 'yourAccessKeySecret',
      bucket: 'examplebucket',
      region: 'oss-cn-hangzhou',
      authorizationV4: true
  });

  return await client.signatureUrlV4('PUT', 3600, {
      headers: {} // 実際のリクエストヘッダーに基づいてリクエストヘッダーを設定します。
  }, fileName);
}
// 関数を呼び出し、ファイル名を渡します。
generateSignatureUrl('yourFileName').then(url => {
  console.log('Generated Signature URL:', url);
}).catch(err => {
  console.error('Error generating signature URL:', err);
});

別のユーザーが 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="ja">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>ファイルアップロードの例</title>
</head>
<body>
    <h1>ファイルアップロードの例</h1>

    <!-- ファイルを選択 -->
    <input type="file" id="fileInput" />
    <button id="uploadButton">ファイルをアップロード</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('アップロードするファイルを選択してください。');
                return;
            }

            try {
                await upload(file, signedUrl);
                alert('ファイルが正常にアップロードされました！');
            } catch (error) {
                console.error('Error during upload:', error);
                alert('アップロードに失敗しました: ' + 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 の生成

const OSS = require("ali-oss");

const client = await new OSS({
  accessKeyId: 'yourAccessKeyId',
  accessKeySecret: 'yourAccessKeySecret',
  stsToken: 'yourSecurityToken',
  bucket: 'yourBucket',
  region: 'yourRegion',
  // secure を true に設定して HTTPS を使用し、ブラウザが生成されたダウンロードリンクをブロックしないようにします。
  secure: true,
});


// 署名付き URL を生成します。
const signedUrl = await client.signatureUrlV4('GET', 3600, {
  queries:{
    // 画像処理パラメーターを設定します。
    "x-oss-process": 'image/resize,w_200',
  }
}, 'demo.pdf');

バージョン ID を含む署名付き URL の生成

const OSS = require("ali-oss");

const client = await new OSS({
  accessKeyId: 'yourAccessKeyId',
  accessKeySecret: 'yourAccessKeySecret',
  stsToken: 'yourSecurityToken',
  bucket: 'yourBucket',
  region: 'yourRegion',
  // secure を true に設定して HTTPS を使用し、ブラウザが生成されたダウンロードリンクをブロックしないようにします。
  secure: true,
});


// 署名付き URL を生成します。
const signedUrl = await client.signatureUrlV4('GET', 3600, {
  queries:{
    // オブジェクトの versionId を指定します。
    "versionId":'yourVersionId'
  }
}, 'demo.pdf');

よくある質問

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

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

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

署名付き URL を生成する際に POST メソッドはサポートされていますか？

いいえ、違います。

署名付き URL を生成する際にサポートされているのは、PUT メソッドと GET メソッドのみです。POST メソッドを使用してオブジェクトをアップロードするには、POST リクエストを構築する必要があります。詳細については、「PostObject」をご参照ください。

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