使用STS临时访问凭证访问OSS

1. 创建 RAM 用户

使用 阿里云主账号 或拥有 访问控制（RAM）管理权限的 RAM 账号 创建 RAM 用户 。

1. 登录 RAM 控制台 。

2. 在左侧导航栏，选择 身份管理 > 用户 。

3. 单击 创建用户 。

4. 输入 登录名称 和 显示名称 。

5. 在 访问方式 区域下，选择 使用永久 AccessKey 访问 ，然后单击 确定 。

6. 根据界面提示，完成安全验证。

7. 复制访问密钥（AccessKey ID 和 AccessKey Secret）。

   重要

   RAM 用户的 AccessKey Secret 仅在创建时显示，后续将无法查看。因此，强烈建议您及时下载包含访问密钥（AccessKey）的 CSV 文件，并妥善保存至本地。

   

2. 为 RAM 用户授予请求 AssumeRole 的权限

创建完 RAM 用户后，使用 阿里云主账号 或拥有 访问控制（RAM）管理权限的 RAM 账号 授予该 RAM 用户通过扮演角色调用 STS 服务的权限。

1. 登录 RAM 控制台 。

2. 在左侧导航栏，选择 身份管理 > 用户 ，单击已创建 RAM 用户右侧对应的 添加权限 。

3. 在 新增授权 页面，选择 AliyunSTSAssumeRoleAccess 系统策略。

   说明

   授予 RAM 用户调用 STS 服务 AssumeRole 接口的固定权限是 AliyunSTSAssumeRoleAccess ，与后续获取临时访问凭证以及通过临时访问凭证发起 OSS 请求所需权限无关。

   

4. 单击 确认新增授权 。

3. 创建 RAM 角色

使用 阿里云主账号 或拥有 访问控制（RAM）管理权限的 RAM 账号 创建 RAM 角色 。 用于定义 RAM 角色被扮演时，可以获得 OSS 服务的哪些访问权限。

1. 登录 RAM 控制台 。

2. 在左侧导航栏，选择 身份管理 > 角色 。

3. 在 角色 页面，单击 创建角色 。

4. 在 创建角色 页面，选择 信任主体类型 为 云账号 ，然后选择 信任主体名称 为 当前云账号 ，单击 确定 。

   

5. 在 创建角色 对话框，输入角色名称，然后单击 确定 。

6. 单击 ARN 右侧的 复制 ，保存角色的 ARN。

   

4. 为 RAM 角色授予上传文件的权限

创建完 RAM 角色后，使用 阿里云主账号 或拥有 访问控制（RAM）管理权限的 RAM 账号 为 RAM 角色附加一个或多个权限策略，明确 RAM 角色在被扮演时所能拥有的 OSS 资源访问权限。例如，如果希望 RAM 用户在扮演该角色后只能向 OSS 指定 Bucket 上传文件，则需要为角色添加写入权限的策略。

1. 创建上传文件的自定义权限策略。

   1. 登录 RAM 控制台 。

   2. 在左侧导航栏，选择 权限管理 > 权限策略 。

   3. 在 权限策略 页面，单击 创建权限策略 。

   4. 在 创建权限策略 页面，单击 脚本编辑 ，然后在策略文档输入框中赋予角色上传文件到 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 说明 。

   5. 策略配置完成后，请单击 确定 按钮，然后在 创建权限策略 弹出框中填写策略名称（例如 RamTestPolicy ），确认信息无误后再次单击 确定 。

2. 为 RAM 角色 RamOssTest 授予自定义权限策略。

   1. 登录 RAM 控制台 。

   2. 在左侧导航栏，选择 身份管理 > 角色 。

   3. 在 角色 页面，找到目标 RAM 角色 RamOssTest 。

   4. 单击 RAM 角色 RamOssTest 右侧的 新增授权 。

   5. 在 新增授权 页面的 权限策略 模块中，选择策略类型为 自定义策略 ，随后在策略列表中选取已创建的自定义权限策略 RamTestPolicy 。

   6. 单击 确认新增授权 。

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"
    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
if ARGV.length == 1 
  $server_port = ARGV[0]
elsif ARGV.length == 2
  $server_ip = ARGV[0]
  $server_port = ARGV[1]
$server_ip = "127.0.0.1"  #如果需要监听其他地址如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
get '/*' do
  puts "********************* GET "
  send_file File.join(settings.public_folder, 'index.html')
end