Object Storage Service：使用STS臨時訪問憑證訪問OSS

1. 建立RAM使用者

使用阿里雲主帳號或擁有存取控制（RAM）系統管理權限的RAM帳號建立RAM使用者。

1. 登入RAM控制台。

2. 在左側導覽列，選擇身份管理>使用者。

3. 單擊创建用户。

4. 輸入登录名称和顯示名稱。

5. 在访问方式地區下，選擇使用永久 AccessKey 訪問，然後單擊確定。

6. 根據介面提示，完成安全驗證。

7. 複製存取金鑰（AccessKey ID和AccessKey Secret）。

   重要

   RAM使用者的AccessKey Secret只在建立時顯示，後續不支援查看，請妥善保管。

2. 為RAM使用者授予請求AssumeRole的許可權

建立完RAM使用者後，使用阿里雲主帳號或擁有存取控制（RAM）系統管理權限的RAM帳號授予該RAM使用者通過扮演角色調用STS服務的許可權。

1. 單擊已建立RAM使用者右側對應的添加权限。

2. 在新增授權頁面，選擇AliyunSTSAssumeRoleAccess系統策略。

   說明

   授予RAM使用者調用STS服務AssumeRole介面的固定許可權是AliyunSTSAssumeRoleAccess，與後續擷取臨時訪問憑證以及通過臨時訪問憑證發起OSS請求要求的權限無關。

   

3. 單擊確認新增授權。

3. 建立RAM角色

使用阿里雲主帳號或擁有存取控制（RAM）系統管理權限的RAM帳號建立RAM角色。用於定義RAM角色被扮演時，可以獲得OSS服務的哪些存取權限。

1. 在左側導覽列，選擇身份管理>角色。

2. 單擊创建角色，選擇可信實體類型為阿里云账号，單擊下一步。

3. 在创建角色對話方塊，角色名称填寫為RamOssTest，选择信任的云账号為当前云账号。

4. 單擊完成。角色建立完成後，單擊關閉。

5. 在角色頁面，搜尋方塊輸入角色名稱RamOssTest，然後單擊RamOssTest。

6. 單擊ARN右側的複製，儲存角色的ARN。

4. 為RAM角色授予上傳檔案的許可權

建立完RAM角色後，使用阿里雲主帳號或擁有存取控制（RAM）系統管理權限的RAM帳號為RAM角色附加一個或多個權限原則，明確RAM角色在被扮演時所能擁有的OSS資源存取權限。例如，如果希望RAM使用者在扮演該角色後只能向OSS指定Bucket上傳檔案，則需要為角色添加寫入許可權的策略。

1. 建立上傳檔案的自訂權限原則。

   1. 在左側導覽列，選擇权限管理>权限策略。

   2. 在权限策略頁面，單擊创建权限策略。

   3. 在创建权限策略頁面，單擊指令碼編輯，然後在策略文檔輸入框中賦予角色上傳檔案到examplebucket的許可權。具體配置樣本如下。

      警告

      以下樣本僅供參考。您需要根據實際需求配置更細粒度的授權策略，防止出現許可權過大的風險。關於更細粒度的授權策略配置詳情，請參見通過RAM或STS服務向其他使用者授權。

      {
          "Version": "1",
          "Statement": [
           {
                 "Effect": "Allow",
                 "Action": [
                   "oss:PutObject"
                 ],
                 "Resource": [
                   "acs:oss:*:*:examplebucket/*"             
                 ]
           }
          ]
      }

      說明

      RAM角色所擁有的OSS許可權取決於Action的配置，例如授予oss:PutObject許可權，則RAM使用者在扮演RAM角色時可以對指定Bucket執行簡單上傳、表單上傳、追加上傳、分區上傳、斷點續傳上傳等操作。更多資訊，請參見OSS Action說明。

   4. 策略配置完成後，單擊繼續編輯基本資料。

   5. 在基本資料地區，填寫策略名稱為RamTestPolicy，然後單擊確定。

2. 為RAM角色RamOssTest授予自訂權限原則。

   1. 在左側導覽列，選擇身份管理 > 角色。

   2. 在角色頁面，找到目標RAM角色RamOssTest。

   3. 單擊RAM角色RamOssTest右側的新增授權。

   4. 在添加許可權頁面下的自訂策略頁簽，選擇已建立的自訂權限原則RamTestPolicy。

   5. 單擊確定。

5. 使用RAM使用者扮演RAM角色擷取臨時訪問憑證

• 為角色授予上傳檔案的許可權後，RAM使用者需要通過扮演角色來擷取臨時訪問憑證。臨時訪問憑證包括安全性權杖（SecurityToken）、臨時存取金鑰（AccessKeyId和AccessKeySecret）以及到期時間（Expiration）。您可以使用STS SDK擷取具有簡單上傳（oss:PutObject）許可權的臨時訪問憑證。有關更多語言的STS SDK樣本，請參見STS SDK概覽。

• 範例程式碼中的endpoint為STS服務存取點地址。為了獲得更快的STS服務響應速度，您可以根據伺服器所處地區，選擇對應的或相近的STS服務存取點地址進行填寫。有關STS服務存取點地址資訊，請參見服務存取點。

import com.aliyuncs.DefaultAcsClient;
import com.aliyuncs.exceptions.ClientException;
import com.aliyuncs.http.MethodType;
import com.aliyuncs.profile.DefaultProfile;
import com.aliyuncs.profile.IClientProfile;
import com.aliyuncs.auth.sts.AssumeRoleRequest;
import com.aliyuncs.auth.sts.AssumeRoleResponse;
public class StsServiceSample {
    public static void main(String[] args) { 
        // STS服務存取點，例如sts.cn-hangzhou.aliyuncs.com。您可以通過公網或者VPC接入STS服務。       
        String endpoint = "sts.cn-hangzhou.aliyuncs.com";
        // 從環境變數中擷取步驟1.1產生的RAM使用者的存取金鑰（AccessKey ID和AccessKey Secret）。
        String accessKeyId = System.getenv("ACCESS_KEY_ID");
        String accessKeySecret = System.getenv("ACCESS_KEY_SECRET");
        // 從環境變數中擷取步驟1.3產生的RAM角色的RamRoleArn。
        String roleArn = System.getenv("RAM_ROLE_ARN");
        // 自訂角色會話名稱，用來區分不同的令牌，例如可填寫為SessionTest。        
        String roleSessionName = "yourRoleSessionName";   
        // 臨時訪問憑證將獲得角色擁有的所有許可權。      
        String policy = null;
        // 臨時訪問憑證的有效時間，單位為秒。最小值為900，最大值以當前角色設定的最大會話時間為準。當前角色最大會話時間取值範圍為3600秒~43200秒，預設值為3600秒。
        // 在上傳大檔案或者其他較耗時的使用情境中，建議合理設定臨時訪問憑證的有效時間，確保在完成目標任務前無需反覆調用STS服務以擷取臨時訪問憑證。
        Long durationSeconds = 3600L;
        try {
            // 發起STS請求所在的地區。建議保留預設值，預設值為空白字串（""）。
            String regionId = "";
            // 添加endpoint。適用於Java SDK 3.12.0及以上版本。
            DefaultProfile.addEndpoint(regionId, "Sts", endpoint);
            // 添加endpoint。適用於Java SDK 3.12.0以下版本。
            // DefaultProfile.addEndpoint("",regionId, "Sts", endpoint);
            // 構造default profile。
            IClientProfile profile = DefaultProfile.getProfile(regionId, accessKeyId, accessKeySecret);
            // 構造client。
            DefaultAcsClient client = new DefaultAcsClient(profile);
            final AssumeRoleRequest request = new AssumeRoleRequest();
            // 適用於Java SDK 3.12.0及以上版本。
            request.setSysMethod(MethodType.POST);
            // 適用於Java SDK 3.12.0以下版本。
            // request.setMethod(MethodType.POST);
            request.setRoleArn(roleArn);
            request.setRoleSessionName(roleSessionName);
            request.setPolicy(policy); 
            request.setDurationSeconds(durationSeconds); 
            final AssumeRoleResponse response = client.getAcsResponse(request);
            System.out.println("Expiration: " + response.getCredentials().getExpiration());
            System.out.println("Access Key Id: " + response.getCredentials().getAccessKeyId());
            System.out.println("Access Key Secret: " + response.getCredentials().getAccessKeySecret());
            System.out.println("Security Token: " + response.getCredentials().getSecurityToken());
            System.out.println("RequestId: " + response.getRequestId());
        } catch (ClientException e) {
            System.out.println("Failed：");
            System.out.println("Error code: " + e.getErrCode());
            System.out.println("Error message: " + e.getErrMsg());
            System.out.println("RequestId: " + e.getRequestId());
        }
    }
}

# -*- coding: utf-8 -*-

from aliyunsdkcore import client
from aliyunsdkcore.request import CommonRequest
import json
import oss2
import os

# 從環境變數中擷取步驟1.1產生的RAM使用者的存取金鑰（AccessKey ID和AccessKey Secret）。
access_key_id = os.getenv("ACCESS_KEY_ID")
access_key_secret = os.getenv("ACCESS_KEY_SECRET")
# 從環境變數中擷取步驟1.3產生的RAM角色的RamRoleArn。
role_arn = os.getenv("RAM_ROLE_ARN")

# 建立權限原則。
clt = client.AcsClient(access_key_id, access_key_secret, 'cn-hangzhou')
request = CommonRequest(product="Sts", version='2015-04-01', action_name='AssumeRole')
request.set_method('POST')
request.set_protocol_type('https')
request.add_query_param('RoleArn', role_arn)
# 指定自訂角色會話名稱，用來區分不同的令牌，例如填寫為sessiontest。
request.add_query_param('RoleSessionName', 'sessiontest')
# 指定STS臨時訪問憑證到期時間為3600秒。
request.add_query_param('DurationSeconds', '3600')
request.set_accept_format('JSON')

body = clt.do_action_with_exception(request)

# 使用RAM使用者的AccessKey ID和AccessKey Secret向STS申請臨時訪問憑證。
token = json.loads(oss2.to_unicode(body))
# 列印STS返回的臨時存取金鑰（AccessKey ID和AccessKey Secret）、安全性權杖（SecurityToken）以及臨時訪問憑證到期時間（Expiration）。
print('AccessKeyId: ' + token['Credentials']['AccessKeyId'])
print('AccessKeySecret: ' + token['Credentials']['AccessKeySecret'])
print('SecurityToken: ' + token['Credentials']['SecurityToken'])
print('Expiration: ' + token['Credentials']['Expiration'])

const { STS } = require('ali-oss');
const express = require("express");
const app = express();

app.get('/sts', (req, res) => {
 let sts = new STS({
  // 從環境變數中擷取步驟1.1產生的RAM使用者的存取金鑰（AccessKey ID和AccessKey Secret）。
   accessKeyId : process.env.ACCESS_KEY_ID,
   accessKeySecret : process.env.ACCESS_KEY_SECRET
});
  // process.env.RAM_ROLE_ARN為從環境變數中擷取步驟1.3產生的RAM角色的RamRoleArn。
  // policy填寫自訂權限原則，用於進一步限制STS臨時訪問憑證的許可權。如果不指定Policy，則返回的STS臨時訪問憑證預設擁有指定角色的所有許可權。
  // 臨時訪問憑證最後獲得的許可權是步驟4設定的角色許可權和該Policy設定許可權的交集。
  // expiration用於設定臨時訪問憑證有效時間單位為秒，最小值為900，最大值以當前角色設定的最大會話時間為準。本樣本指定有效時間為3600秒。
  // sessionName用於自訂角色會話名稱，用來區分不同的令牌，例如填寫為sessiontest。
  sts.assumeRole('process.env.RAM_ROLE_ARN', ``, '3600', 'sessiontest').then((result) => {
    console.log(result);
    res.set('Access-Control-Allow-Origin', '*');
    res.set('Access-Control-Allow-METHOD', 'GET');
    res.json({
      AccessKeyId: result.credentials.AccessKeyId,
      AccessKeySecret: result.credentials.AccessKeySecret,
      SecurityToken: result.credentials.SecurityToken,
      Expiration: result.credentials.Expiration
    });
  }).catch((err) => {
    console.log(err);
    res.status(400).json(err.message);
  });
});
app.listen(8000,()=>{
   console.log("server listen on:8000")
})

package main

import (
    "fmt"
    "os"

    openapi "github.com/alibabacloud-go/darabonba-openapi/v2/client"
    sts20150401 "github.com/alibabacloud-go/sts-20150401/v2/client"
    util "github.com/alibabacloud-go/tea-utils/v2/service"
    "github.com/alibabacloud-go/tea/tea"
)

func main() {
    // 從環境變數中擷取步驟1.1產生的RAM使用者的存取金鑰（AccessKey ID和AccessKey Secret）。
    accessKeyId := os.Getenv("ACCESS_KEY_ID")
    accessKeySecret := os.Getenv("ACCESS_KEY_SECRET")
    // 從環境變數中擷取步驟1.3產生的RAM角色的RamRoleArn。
    roleArn := os.Getenv("RAM_ROLE_ARN")

    // 建立權限原則用戶端。
    config := &openapi.Config{
        // 必填，步驟1.1擷取到的 AccessKey ID。
        AccessKeyId: tea.String(accessKeyId),
        // 必填，步驟1.1擷取到的 AccessKey Secret。
        AccessKeySecret: tea.String(accessKeySecret),
    }
    // Endpoint 請參考 https://api.aliyun.com/product/Sts
    config.Endpoint = tea.String("sts.cn-hangzhou.aliyuncs.com")
    client, err := sts20150401.NewClient(config)
    if err != nil {
        fmt.Printf("Failed to create client: %v\n", err)
        return
    }

    // 使用RAM使用者的AccessKey ID和AccessKey Secret向STS申請臨時訪問憑證。
    request := &sts20150401.AssumeRoleRequest{
        // 指定STS臨時訪問憑證到期時間為3600秒。
        DurationSeconds: tea.Int64(3600),
        // 從環境變數中擷取步驟1.3產生的RAM角色的RamRoleArn。
        RoleArn: tea.String(roleArn),
        // 指定自訂角色會話名稱，這裡使用和第一段代碼一致的 examplename
        RoleSessionName: tea.String("examplename"),
    }
    response, err := client.AssumeRoleWithOptions(request, &util.RuntimeOptions{})
    if err != nil {
        fmt.Printf("Failed to assume role: %v\n", err)
        return
    }

    // 列印STS返回的臨時存取金鑰（AccessKey ID和AccessKey Secret）、安全性權杖（SecurityToken）以及臨時訪問憑證到期時間（Expiration）。
    credentials := response.Body.Credentials
    fmt.Println("AccessKeyId: " + tea.StringValue(credentials.AccessKeyId))
    fmt.Println("AccessKeySecret: " + tea.StringValue(credentials.AccessKeySecret))
    fmt.Println("SecurityToken: " + tea.StringValue(credentials.SecurityToken))
    fmt.Println("Expiration: " + tea.StringValue(credentials.Expiration))
}

<?php
require __DIR__ . '/vendor/autoload.php';

use AlibabaCloud\Client\AlibabaCloud;
use AlibabaCloud\Client\Exception\ClientException;
use AlibabaCloud\Client\Exception\ServerException;
use AlibabaCloud\Sts\Sts;

// 從環境變數中擷取步驟1.1產生的RAM使用者的存取金鑰（AccessKey ID和AccessKey Secret）。
$accessKeyId = getenv("ACCESS_KEY_ID");
$accessKeySecret = getenv("ACCESS_KEY_SECRET");
// 從環境變數中擷取步驟1.3產生的RAM角色的RamRoleArn。
$roleArn = getenv("RAM_ROLE_ARN");

// 初始化阿里雲用戶端。
AlibabaCloud::accessKeyClient($accessKeyId, $accessKeySecret)
    ->regionId('cn-hangzhou')
    ->asDefaultClient();

try {
    // 建立STS請求。
    $result = Sts::v20150401()
        ->assumeRole()
        // 設定角色ARN。
        ->withRoleArn($roleArn)
        // 指定自訂角色會話名稱，用來區分不同的令牌。
        ->withRoleSessionName('sessiontest')
        // 指定STS臨時訪問憑證到期時間為3600秒。
        ->withDurationSeconds(3600)
        ->request();

    // 擷取響應中的憑證資訊。
    $credentials = $result['Credentials'];

    // 列印STS返回的臨時存取金鑰（AccessKey ID和AccessKey Secret）、安全性權杖（SecurityToken）以及臨時訪問憑證到期時間（Expiration）。
    echo 'AccessKeyId: ' . $credentials['AccessKeyId'] . PHP_EOL;
    echo 'AccessKeySecret: ' . $credentials['AccessKeySecret'] . PHP_EOL;
    echo 'SecurityToken: ' . $credentials['SecurityToken'] . PHP_EOL;
    echo 'Expiration: ' . $credentials['Expiration'] . PHP_EOL;
} catch (ClientException $e) {
    // 處理用戶端異常。
    echo $e->getErrorMessage() . PHP_EOL;
} catch (ServerException $e) {
    // 處理服務端異常。
    echo $e->getErrorMessage() . PHP_EOL;
}

require 'sinatra'
require 'base64'
require 'open-uri'
require 'cgi'
require 'openssl'
require 'json'
require 'sinatra/reloader'
require 'sinatra/content_for'
require 'aliyunsdkcore'

# 設定public檔案夾路徑為當前檔案夾下的templates檔案夾。
set :public_folder, File.dirname(__FILE__) + '/templates'

def get_sts_token_for_oss_upload()
  client = RPCClient.new(
    # 從環境變數中擷取步驟1.1產生的RAM使用者的存取金鑰（AccessKey ID和AccessKey Secret）。
    access_key_id: ENV['ACCESS_KEY_ID'],
    access_key_secret: ENV['ACCESS_KEY_SECRET'],
    endpoint: 'https://sts.cn-hangzhou.aliyuncs.com',
    api_version: '2015-04-01'
  )
  response = client.request(
    action: 'AssumeRole',
    params: {
      # 從環境變數中擷取步驟1.3產生的RAM角色的RamRoleArn。
      "RoleArn": ENV['RAM_ROLE_ARN'],
      # 指定STS臨時訪問憑證到期時間為3600秒。
      "DurationSeconds": 3600,
      # sessionName用於自訂角色會話名稱，用來區分不同的令牌，例如填寫為sessiontest。
      "RoleSessionName": "sessiontest"
    },
    opts: {
      method: 'POST',
      format_params: true
    }
  )
end

if ARGV.length == 1 
  $server_port = ARGV[0]
elsif ARGV.length == 2
  $server_ip = ARGV[0]
  $server_port = ARGV[1]
end

$server_ip = "0.0.0.0"
$server_port = 8000

puts "App server is running on: http://#{$server_ip}:#{$server_port}"

set :bind, $server_ip
set :port, $server_port

get '/get_sts_token_for_oss_upload' do
  token = get_sts_token_for_oss_upload()
  response = {
    "AccessKeyId" => token["Credentials"]["AccessKeyId"],
    "AccessKeySecret" => token["Credentials"]["AccessKeySecret"],
    "SecurityToken" => token["Credentials"]["SecurityToken"],
    "Expiration" => token["Credentials"]["Expiration"]
  }
  response.to_json
end

get '/*' do
  puts "********************* GET "
  send_file File.join(settings.public_folder, 'index.html')
end