服务端签名直传

Python

• 执行以下命令安装依赖。

  pip install flask
  pip install alibabacloud_tea_openapi alibabacloud_sts20150401 alibabacloud_credentials

• 请参考如下代码来完成Python服务端获取临时访问凭证并构建上传策略以计算POST签名。

  # -*- coding: utf-8 -*-
  from flask import Flask, render_template, jsonify
  from alibabacloud_tea_openapi.models import Config
  from alibabacloud_sts20150401.client import Client as Sts20150401Client
  from alibabacloud_sts20150401 import models as sts_20150401_models
  from alibabacloud_credentials.client import Client as CredentialClient
  import os
  from hashlib import sha1 as sha
  import json
  import base64
  import hmac
  import datetime
  import time
  
  app = Flask(__name__)
  
  # 配置环境变量ALIBABA_CLOUD_ACCESS_KEY_ID。
  access_key_id = os.environ.get('OSS_ACCESS_KEY_ID')
  # 配置环境变量ALIBABA_CLOUD_ACCESS_SECRET。
  access_key_secret = os.environ.get('OSS_ACCESS_KEY_SECRET')
  # 配置环境变量OSS_STS_ROLE_ARN
  role_arn_for_oss_upload = os.environ.get('OSS_STS_ROLE_ARN')
  
  
  # 可以替换为您的Bucket名称。
  bucket = 'web-direct-upload'
  # 可以替换为您的region_id。
  region = 'cn-hangzhou'
  # host的格式为bucketname.endpoint，您可以根据您的实际场景修改
  host = 'http://{bucket}.oss-cn-hangzhou.aliyuncs.com'
  # 指定上传到OSS的文件前缀。
  upload_dir = 'user-dirs'
  # 指定过期时间，单位为秒。
  expire_time = 3600
  
  # 设置为自定义的会话，例如oss-role-session。
  role_session_name = 'role_session_name'
  
  def generate_expiration(seconds):
      """
      通过指定有效的时长（秒）生成过期时间。
      :param seconds: 有效时长（秒）。
      :return: ISO8601 时间字符串，如："2014-12-01T12:00:00.000Z"。
      """
      now = int(time.time())
      expiration_time = now + seconds
      gmt = datetime.datetime.utcfromtimestamp(expiration_time).isoformat()
      gmt += 'Z'
      return gmt
  
  def generate_signature(access_key_secret, expiration, conditions, policy_extra_props=None):
      """
      生成签名字符串Signature。
      :param access_key_secret: 有权限访问目标Bucket的AccessKeySecret。
      :param expiration: 签名过期时间，按照ISO8601标准表示，并需要使用UTC时间，格式为yyyy-MM-ddTHH:mm:ssZ。示例值："2014-12-01T12:00:00.000Z"。
      :param conditions: 策略条件，用于限制上传表单时允许设置的值。详细参考：https://help.aliyun.com/zh/oss/developer-reference/postobject 。
      :param policy_extra_props: 额外的policy参数，后续如果policy新增参数支持，可以在通过dict传入额外的参数。
      :return: signature，签名字符串。
      """
      policy_dict = {
          'expiration': expiration,
          'conditions': conditions
      }
      if policy_extra_props is not None:
          policy_dict.update(policy_extra_props)
      
      policy = json.dumps(policy_dict).strip()
      policy_encode = base64.b64encode(policy.encode())  
      h = hmac.new(access_key_secret.encode(), policy_encode, sha)
      sign_result = base64.b64encode(h.digest()).strip()
      return sign_result.decode()
  
  @app.route("/")
  def hello_world():
      return render_template('index.html')
  
  @app.route('/get_post_signature_for_oss_upload', methods=['GET'])
  def generate_upload_params():
      """
      获取STS临时凭证并生成上传所需参数。
      """
      # 初始化配置，直接传递凭据
      config = Config(
          region_id=region,
          access_key_id=access_key_id,
          access_key_secret=access_key_secret
      )
      
      # 创建STS客户端并获取临时凭证
      sts_client = Sts20150401Client(config=config)
      assume_role_request = sts_20150401_models.AssumeRoleRequest(
          role_arn=role_arn_for_oss_upload,
          role_session_name=role_session_name
      )
      response = sts_client.assume_role(assume_role_request)
      token_data = response.body.credentials.to_map()
      
      # 使用STS返回的临时凭据
      temp_access_key_id = token_data['AccessKeyId']
      temp_access_key_secret = token_data['AccessKeySecret']
      security_token = token_data['SecurityToken']
      
      # 构建Policy并生成签名
      policy = {
          "expiration": generate_expiration(expire_time),
          "conditions": [
              {"x-oss-security-token": security_token},
              ["eq", "$success_action_status", "200"],
              ["starts-with", "$key", upload_dir],
          ]
      }
    
      signature = generate_signature(temp_access_key_secret, policy.get('expiration'), policy.get('conditions'))
      
      # 组织返回数据
      response_data = {
          'policy': base64.b64encode(json.dumps(policy).encode('utf-8')).decode(),
          'ossAccessKeyId': temp_access_key_id,
          'signature': signature,
          'host': host,
          'dir': upload_dir,
          'securityToken': security_token
      }
      return jsonify(response_data)
  
  if __name__ == "__main__":
      app.run(host="0.0.0.0", port=8000)

Node.js

• 执行以下命令安装SDK

  • 如果您使用的是Node.js 8.0及以上版本，请安装SDK 6.x版本

    npm install ali-oss@^6.x --save

  • 如果您使用的是Node.js 8.0以下版本，请安装SDK 4.x版本

    npm install ali-oss@^4.x --save

• 在config.js文件中配置需要的参数。

  module.exports = {
    // 从环境变量中获取RAM用户的访问密钥和目标RAM角色的Arn.
    accessKeyId: process.env.OSS_ACCESS_KEY_ID,
    accessKeySecret: process.env.OSS_ACCESS_KEY_SECRET,
    roleArn: process.env.OSS_STS_ROLE_ARN,
    // region填写Bucket所在地域。以华东1（杭州）为例，Region填写为oss-cn-hangzhou。
    region: "oss-cn-hangzhou",
    // 指定Bucket名称,可以替换为您的Bucket名称。
    bucket: "web-direct-upload",
  };
  

• 服务端获取临时访问凭证并构建上传策略以计算POST签名：

  const { exec } = require("child_process");
  const path = require("path");
  const express = require("express");
  const cors = require("cors");
  
  const moment = require("moment");
  
  const OSS = require("ali-oss");
  const { STS } = require("ali-oss");
  
  const config = require("./config");
  
  const getToken = async () => {
    const { accessKeyId, accessKeySecret, roleArn, bucket } = config;
    const seconds = 3000; //3000秒，50分钟过期
    const date = new Date();
    date.setSeconds(date.getSeconds() + seconds);
    const dir = "user-dirs/";
    const policy = {
      expiration: date.toISOString(), // 请求有效期。
      conditions: [
        ["content-length-range", 0, 1048576000], // 设置上传文件的大小限制。
        ["starts-with", "$key", dir], // 限制文件只能上传到user-dirs目录下。
        { bucket }, // 限制文件只能上传至指定Bucket。
      ],
    };
    /* 使用stsToken上传。 */
    let stsToken;
    if (roleArn) {
      let sts = new STS({
        accessKeyId,
        accessKeySecret,
      });
      const {
        credentials: { AccessKeyId, AccessKeySecret, SecurityToken },
      } = await sts.assumeRole(roleArn, "", seconds, "sessiontest");
      stsToken = SecurityToken;
      client = new OSS({
        accessKeyId: AccessKeyId,
        accessKeySecret: AccessKeySecret,
        stsToken,
      });
    }
  
    // 计算签名。
    const formData = await client.calculatePostSignature(policy);
  
    // 返回参数。
    const params = {
      expire: moment(date).unix().toString(),
      policy: formData.policy,
      signature: formData.Signature,
      accessid: formData.OSSAccessKeyId,
      stsToken,
      host: `http://${config.bucket}.${config.region}.aliyuncs.com`,
      dir,
    };
  
    return params;
  };
  
  const app = express();
  app.use(cors());
  
  app.get("/token", async (req, res) => {
    const result = await getToken();
    res.header["Access-Control-Allow-Origin"] = "*";
    res.json(result);
  });
  
  app.get(/^(.+)*\.(html|js|ico)$/i, async (req, res) => {
    const pat = path.join(__dirname, "../", req.originalUrl);
    res.sendFile(pat);
  });
  
  const url = "http://127.0.0.1:3001/index.html";
  app.listen(3001, () => console.log("请打开：" + url));
  
  if (process.platform === "win32") {
    exec(`start ${url}`); // For Windows
  } else if (process.platform === "darwin") {
    exec(`open ${url}`); // For macOS
  } else {
    exec(`xdg-open ${url}`); // For Linux
  }