使用存储空间清单

import com.aliyun.oss.*;
import com.aliyun.oss.common.auth.*;
import com.aliyun.oss.common.comm.SignVersion;
import com.aliyun.oss.model.*;
import java.util.ArrayList;
import java.util.List;

public class Demo {

    public static void main(String[] args) throws Exception {
        // Endpoint以华东1（杭州）为例，其它Region请按实际情况填写。
        String endpoint = "https://oss-cn-hangzhou.aliyuncs.com";
        // 从环境变量中获取访问凭证。运行本代码示例之前，请确保已设置环境变量OSS_ACCESS_KEY_ID和OSS_ACCESS_KEY_SECRET。
        EnvironmentVariableCredentialsProvider credentialsProvider = CredentialsProviderFactory.newEnvironmentVariableCredentialsProvider();
        // 填写Bucket名称，例如examplebucket。
        String bucketName = "examplebucket";
        // 填写存放清单结果的Bucket名称。
        String destBucketName ="yourDestinationBucketName";
        // 填写Bucket所有者授予的账户ID。
        String accountId ="yourDestinationBucketAccountId";
        // 填写具有读取源Bucket所有文件和向目标Bucket写入文件权限的角色名称。
        String roleArn ="yourDestinationBucketRoleArn";
        // 填写Bucket所在地域。以华东1（杭州）为例，Region填写为cn-hangzhou。
        String region = "cn-hangzhou";

        // 创建OSSClient实例。
        // 当OSSClient实例不再使用时，调用shutdown方法以释放资源。
        ClientBuilderConfiguration clientBuilderConfiguration = new ClientBuilderConfiguration();
        clientBuilderConfiguration.setSignatureVersion(SignVersion.V4);        
        OSS ossClient = OSSClientBuilder.create()
        .endpoint(endpoint)
        .credentialsProvider(credentialsProvider)
        .clientConfiguration(clientBuilderConfiguration)
        .region(region)               
        .build();

        try {
            // 创建清单配置。
            InventoryConfiguration inventoryConfiguration = new InventoryConfiguration();

            // 设置清单规则名称。
            String inventoryId = "testid";
            inventoryConfiguration.setInventoryId(inventoryId);

            // 设置清单中包含的Object属性。
            List<String> fields = new ArrayList<String>();
            fields.add(InventoryOptionalFields.Size);
            fields.add(InventoryOptionalFields.LastModifiedDate);
            fields.add(InventoryOptionalFields.IsMultipartUploaded);
            fields.add(InventoryOptionalFields.StorageClass);
            fields.add(InventoryOptionalFields.ETag);
            fields.add(InventoryOptionalFields.EncryptionStatus);
            inventoryConfiguration.setOptionalFields(fields);

            // 设置清单的生成计划，以下示例为每周一次。其中，Weekly表示每周一次，Daily表示每天一次。
            inventoryConfiguration.setSchedule(new InventorySchedule().withFrequency(InventoryFrequency.Weekly));

            // 设置清单中包含的Object的版本为当前版本。如果设置为InventoryIncludedObjectVersions.All则表示Object的所有版本在版本控制状态下生效。
            inventoryConfiguration.setIncludedObjectVersions(InventoryIncludedObjectVersions.Current);

            // 清单配置是否启用的标识，取值为true或者false，设置为true表示启用清单配置，设置为false表示关闭清单配置。
            inventoryConfiguration.setEnabled(true);

            // 设置清单筛选规则，指定筛选Object的前缀。
            InventoryFilter inventoryFilter = new InventoryFilter().withPrefix("obj-prefix");
            inventoryConfiguration.setInventoryFilter(inventoryFilter);

            // 创建存放清单结果的目标Bucket配置。
            InventoryOSSBucketDestination ossInvDest = new InventoryOSSBucketDestination();
            // 设置存放清单结果的存储路径前缀。
            ossInvDest.setPrefix("destination-prefix");
            // 设置清单格式。
            ossInvDest.setFormat(InventoryFormat.CSV);
            // 设置目标Bucket的用户accountId。
            ossInvDest.setAccountId(accountId);
            // 设置目标Bucket的roleArn。
            ossInvDest.setRoleArn(roleArn);
            // 设置目标Bucket的名称。
            ossInvDest.setBucket(destBucketName);

            // 如果需要使用KMS加密清单，请参考如下设置。
            // InventoryEncryption inventoryEncryption = new InventoryEncryption();
            // InventoryServerSideEncryptionKMS serverSideKmsEncryption = new InventoryServerSideEncryptionKMS().withKeyId("test-kms-id");
            // inventoryEncryption.setServerSideKmsEncryption(serverSideKmsEncryption);
            // ossInvDest.setEncryption(inventoryEncryption);

            // 如果需要使用OSS服务端加密清单，请参考如下设置。
            // InventoryEncryption inventoryEncryption = new InventoryEncryption();
            // inventoryEncryption.setServerSideOssEncryption(new InventoryServerSideEncryptionOSS());
            // ossInvDest.setEncryption(inventoryEncryption);

            // 设置清单的目的地。
            InventoryDestination destination = new InventoryDestination();
            destination.setOssBucketDestination(ossInvDest);
            inventoryConfiguration.setDestination(destination);

            // 上传清单配置。
            ossClient.setBucketInventoryConfiguration(bucketName, inventoryConfiguration);
        } catch (OSSException oe) {
            System.out.println("Caught an OSSException, which means your request made it to OSS, "
                    + "but was rejected with an error response for some reason.");
            System.out.println("Error Message:" + oe.getErrorMessage());
            System.out.println("Error Code:" + oe.getErrorCode());
            System.out.println("Request ID:" + oe.getRequestId());
            System.out.println("Host ID:" + oe.getHostId());
        } catch (ClientException ce) {
            System.out.println("Caught an ClientException, which means the client encountered "
                    + "a serious internal problem while trying to communicate with OSS, "
                    + "such as not being able to access the network.");
            System.out.println("Error Message:" + ce.getMessage());
        } finally {
            if (ossClient != null) {
                ossClient.shutdown();
            }
        }
    }
}

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

const client = new OSS({
  // yourregion填写Bucket所在地域。以华东1（杭州）为例，Region填写为oss-cn-hangzhou。
  region: 'yourregion',
  // 从环境变量中获取访问凭证。运行本代码示例之前，请确保已设置环境变量OSS_ACCESS_KEY_ID和OSS_ACCESS_KEY_SECRET。
  accessKeyId: process.env.OSS_ACCESS_KEY_ID,
  accessKeySecret: process.env.OSS_ACCESS_KEY_SECRET,
  // 填写存储空间名称。
  bucket: 'yourbucketname'
});

const inventory = {
  // 设置清单配置ID。
  id: 'default', 
  // 清单配置是否启用的标识，取值为true或false。
  isEnabled: false, 
  //（可选）设置清单筛选规则，指定筛选object的前缀。
  prefix: 'ttt',
  OSSBucketDestination: {
     // 设置清单格式。
    format: 'CSV',
   // 目标Bucket拥有者的账号ID。
    accountId: '<Your AccountId>', 
   // 目标Bucket的角色名称。
    rolename: 'AliyunOSSRole',
    // 目标Bucket的名称。
    bucket: '<Your BucketName>',
    //（可选）清单结果的存储路径前缀。
    prefix: '<Your Prefix>',
    // 如果需要使用SSE-OSS加密清单，请参考以下代码。
    //encryption: {'SSE-OSS': ''},
    // 如果需要使用SSE-KMS加密清单，请参考以下代码。
           /*
            encryption: {
      'SSE-KMS': {
        keyId: 'test-kms-id',
      };, 
    */
  },
  // 设置清单的生成计划，WEEKLY对应每周一次，DAILY对应每天一次。
  frequency: 'Daily', 
  // 设置清单结果中包含了Object的所有版本, 如果设置为Current，则表示仅包含Object的当前版本。
  includedObjectVersions: 'All', 
  optionalFields: {
    //（可选）设置清单中包含的Object属性。
    field: ["Size", "LastModifiedDate", "ETag", "StorageClass", "IsMultipartUploaded", "EncryptionStatus"]
  },
}

async function putInventory(){
  // 需要添加清单配置的Bucket名称。
  const bucket = '<Your BucketName>'; 
        try {
    await client.putBucketInventory(bucket, inventory);
    console.log('清单配置添加成功')
  } catch(err) {
    console.log('清单配置添加失败: ', err);
  }
}

putInventory()

import argparse
import alibabacloud_oss_v2 as oss

# 创建命令行参数解析器，并描述脚本用途：设置存储空间清单（Inventory）
parser = argparse.ArgumentParser(description="put bucket inventory sample")

# 定义命令行参数，包括必需的区域、存储空间名称、endpoint、用户ID、角色ARN以及清单名称
parser.add_argument('--region', help='The region in which the bucket is located.', required=True)
parser.add_argument('--bucket', help='The name of the bucket.', required=True)
parser.add_argument('--endpoint', help='The domain names that other services can use to access OSS')
parser.add_argument('--user_id', help='User account ID.', required=True)
parser.add_argument('--arn', help='The Alibaba Cloud Resource Name (ARN) of the role that has the permissions to read all objects from the source bucket and write objects to the destination bucket. Format: `acs:ram::uid:role/rolename`.', required=True)
parser.add_argument('--inventory_id', help='The name of the inventory.', required=True)

def main():
    # 解析命令行参数，获取用户输入的值
    args = parser.parse_args()

    # 从环境变量中加载访问凭证信息，用于身份验证
    credentials_provider = oss.credentials.EnvironmentVariableCredentialsProvider()

    # 使用SDK默认配置创建配置对象，并设置认证提供者
    cfg = oss.config.load_default()
    cfg.credentials_provider = credentials_provider

    # 设置配置对象的区域属性，根据用户提供的命令行参数
    cfg.region = args.region

    # 如果提供了自定义endpoint，则更新配置对象中的endpoint属性
    if args.endpoint is not None:
        cfg.endpoint = args.endpoint

    # 使用上述配置初始化OSS客户端，准备与OSS交互
    client = oss.Client(cfg)

    # 发送请求以配置指定存储空间的清单设置
    result = client.put_bucket_inventory(oss.PutBucketInventoryRequest(
            bucket=args.bucket,  # 存储空间名
            inventory_id=args.inventory_id,  # 存储空间清单ID
            inventory_configuration=oss.InventoryConfiguration(
                included_object_versions='All',  # 包含所有版本的对象
                optional_fields=oss.OptionalFields(
                    fields=[  # 可选字段，如大小和最后修改日期
                        oss.InventoryOptionalFieldType.SIZE,
                        oss.InventoryOptionalFieldType.LAST_MODIFIED_DATE,
                    ],
                ),
                id=args.inventory_id,  # 存储空间清单ID
                is_enabled=True,  # 启用存储空间清单
                destination=oss.InventoryDestination(
                    oss_bucket_destination=oss.InventoryOSSBucketDestination(
                        format=oss.InventoryFormatType.CSV,  # 输出格式为CSV
                        account_id=args.user_id,  # 用户账户ID
                        role_arn=args.arn,  # 角色ARN，具有读取源存储空间和写入目标存储空间的权限
                        bucket=f'acs:oss:::{args.bucket}',  # 目标存储空间
                        prefix='aaa',  # 清单文件前缀
                    ),
                ),
                schedule=oss.InventorySchedule(
                    frequency=oss.InventoryFrequencyType.DAILY,  # 清单频率，这里设置为每天
                ),
                filter=oss.InventoryFilter(
                    lower_size_bound=1024,  # 对象大小下限（字节）
                    upper_size_bound=1048576,  # 对象大小上限（字节）
                    storage_class='ColdArchive',  # 存储类别筛选条件
                    prefix='aaa',  # 对象前缀筛选条件
                    last_modify_begin_time_stamp=1637883649,  # 最后修改时间戳开始范围
                    last_modify_end_time_stamp=1638347592,  # 最后修改时间戳结束范围
                ),
            ),
    ))

    # 打印操作结果的状态码和请求ID，以便确认请求状态
    print(f'status code: {result.status_code},'
          f' request id: {result.request_id},'
    )

# 当此脚本被直接执行时，调用main函数开始处理逻辑
if __name__ == "__main__":
    main()  # 脚本入口点，控制程序流程从这里开始

using Aliyun.OSS;
using Aliyun.OSS.Common;

// yourEndpoint填写Bucket所在地域对应的Endpoint。以华东1（杭州）为例，Endpoint填写为https://oss-cn-hangzhou.aliyuncs.com。
var endpoint = "yourEndpoint";
// 从环境变量中获取访问凭证。运行本代码示例之前，请确保已设置环境变量OSS_ACCESS_KEY_ID和OSS_ACCESS_KEY_SECRET。
var accessKeyId = Environment.GetEnvironmentVariable("OSS_ACCESS_KEY_ID");
var accessKeySecret = Environment.GetEnvironmentVariable("OSS_ACCESS_KEY_SECRET");
// 填写Bucket名称。
var bucketName = "examplebucket";
// 填写Bucket所有者授予的账户ID。
var accountId ="yourDestinationBucketAccountId";
// 填写具有读取源Bucket所有文件和向目标Bucket写入文件权限的角色名称。
var roleArn ="yourDestinationBucketRoleArn";
// 填写存放清单结果的Bucket名称。
var destBucketName ="yourDestinationBucketName";
// 填写Bucket所在地域对应的Region。以华东1（杭州）为例，Region填写为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
{
    // 添加Bucket清单。
    var config = new InventoryConfiguration();
    // 设置清单规则名称。
    config.Id = "report1";
    // 清单配置是否启用的标识，取值为true或false。设置为true，表示启用清单配置。
    config.IsEnabled = true;
    // 设置清单筛选规则，指定筛选Object的前缀。
    config.Filter = new InventoryFilter("filterPrefix");
    // 创建清单的bucket目的地配置。
    config.Destination = new InventoryDestination();
    config.Destination.OSSBucketDestination = new InventoryOSSBucketDestination();
    // 设置清单格式。
    config.Destination.OSSBucketDestination.Format = InventoryFormat.CSV;
    // 存放清单结果的目标Bucket的用户accountId。
    config.Destination.OSSBucketDestination.AccountId = accountId;
    // 存放清单结果的目标Bucket的roleArn。
    config.Destination.OSSBucketDestination.RoleArn = roleArn;
    // 存放清单结果的目标Bucket名称。
    config.Destination.OSSBucketDestination.Bucket = destBucketName;
    // 设置存放清单结果的存储路径前缀。
    config.Destination.OSSBucketDestination.Prefix = "prefix1";
    
    // 设置清单的生成计划，以下示例为每周一次。其中，Weekly对应每周一次，Daily对应每天一次。
    config.Schedule = new InventorySchedule(InventoryFrequency.Daily);
    // 设置清单中包含的object的版本为当前版本。如果设置为InventoryIncludedObjectVersions.All则表示object的所有版本，在版本控制状态下生效。
    config.IncludedObjectVersions = InventoryIncludedObjectVersions.All;
    
    // 设置清单中包含的Object属性。
    config.OptionalFields.Add(InventoryOptionalField.Size);
    config.OptionalFields.Add(InventoryOptionalField.LastModifiedDate);
    config.OptionalFields.Add(InventoryOptionalField.StorageClass);
    config.OptionalFields.Add(InventoryOptionalField.IsMultipartUploaded);
    config.OptionalFields.Add(InventoryOptionalField.EncryptionStatus);
    config.OptionalFields.Add(InventoryOptionalField.ETag);
    var req = new SetBucketInventoryConfigurationRequest(bucketName, config);
    client.SetBucketInventoryConfiguration(req);
    Console.WriteLine("Set bucket:{0} InventoryConfiguration succeeded", bucketName);
}
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);
}

#include <alibabacloud/oss/OssClient.h>
using namespace AlibabaCloud::OSS;

int main(void)
{
    /* 初始化OSS账号信息。*/
            
    /* yourEndpoint填写Bucket所在地域对应的Endpoint。以华东1（杭州）为例，Endpoint填写为https://oss-cn-hangzhou.aliyuncs.com。*/
    std::string Endpoint = "yourEndpoint";
    /* yourRegion填写Bucket所在地域对应的Region。以华东1（杭州）为例，Region填写为cn-hangzhou。*/
    std::string Region = "yourRegion";
    /* 填写Bucket名称，例如examplebucket。*/
    std::string BucketName = "examplebucket";

    /* 初始化网络等资源。*/
    InitializeSdk();

    ClientConfiguration conf;
    conf.signatureVersion = SignatureVersionType::V4;
    /* 从环境变量中获取访问凭证。运行本代码示例之前，请确保已设置环境变量OSS_ACCESS_KEY_ID和OSS_ACCESS_KEY_SECRET。*/
    auto credentialsProvider = std::make_shared<EnvironmentVariableCredentialsProvider>();
    OssClient client(Endpoint, credentialsProvider, conf);
    client.SetRegion(Region);

    InventoryConfiguration inventoryConf;
    /* 指定清单规则名称，该名称在当前Bucket下必须全局唯一。*/
    inventoryConf.setId("inventoryId");

    /* 清单配置是否启用的标识，可选值为true或false。*/
    inventoryConf.setIsEnabled(true);

    /* (可选)清单筛选的前缀。指定前缀后，清单将筛选出符合前缀的Object。*/
    inventoryConf.setFilter(InventoryFilter("objectPrefix"));

    InventoryOSSBucketDestination dest;
    /* 导出清单文件的文件格式。*/
    dest.setFormat(InventoryFormat::CSV);
    /* 存储空间拥有者的账户UID。*/
    dest.setAccountId("10988548********");
    /* 指定角色名称，该角色需要拥有读取源存储空间所有文件以及向目标存储空间写入文件的权限，格式为acs:ram::uid:role/rolename。*/
    dest.setRoleArn("acs:ram::10988548********:role/inventory-test");
    /* 存放导出的清单文件的存储空间。*/
    dest.setBucket("yourDstBucketName");
    /* 清单文件的存储路径前缀。*/
    dest.setPrefix("yourPrefix");
    /* (可选)清单文件的加密方式, 可选SSEOSS或者SSEKMS方式加密。*/
    //dest.setEncryption(InventoryEncryption(InventorySSEOSS()));
    //dest.setEncryption(InventoryEncryption(InventorySSEKMS("yourKmskeyId")));
    inventoryConf.setDestination(dest);

    /* 清单文件导出的周期, 可选为Daily或者Weekly。*/
    inventoryConf.setSchedule(InventoryFrequency::Daily);

    /* 是否在清单中包含Object版本信息, 可选为All或者Current。*/
    inventoryConf.setIncludedObjectVersions(InventoryIncludedObjectVersions::All);

    /* (可选)设置清单结果中应包含的配置项, 请按需配置。*/
    InventoryOptionalFields field { 
        InventoryOptionalField::Size, InventoryOptionalField::LastModifiedDate, 
        InventoryOptionalField::ETag, InventoryOptionalField::StorageClass, 
        InventoryOptionalField::IsMultipartUploaded, InventoryOptionalField::EncryptionStatus
    };
    inventoryConf.setOptionalFields(field);

    /* 设置清单配置。*/
    auto outcome = client.SetBucketInventoryConfiguration(
        SetBucketInventoryConfigurationRequest(BucketName, inventoryConf));

    if (!outcome.isSuccess()) {
        /* 异常处理。*/
        std::cout << "Set Bucket Inventory fail" <<
        ",code:" << outcome.error().Code() <<
        ",message:" << outcome.error().Message() <<
        ",requestId:" << outcome.error().RequestId() << std::endl;
        return -1;
    }

    /* 释放网络等资源。*/
    ShutdownSdk();
    return 0;
}

package main

import (
	"context"
	"flag"
	"log"

	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss"
	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss/credentials"
)

// 定义全局变量
var (
	region     string // 存储区域
	bucketName string // 存储空间名称
)

// init函数用于初始化命令行参数
func init() {
	flag.StringVar(&region, "region", "", "The region in which the bucket is located.")
	flag.StringVar(&bucketName, "bucket", "", "The name of the bucket.")
}

func main() {
	// 解析命令行参数
	flag.Parse()

	var (
		accountId   = "account id of the bucket" // 存储空间所有者授予的账户ID，例如109885487000****
		inventoryId = "inventory id"             // 由用户指定的清单名称，清单名称在当前Bucket下必须全局唯一
	)

	// 检查bucket名称是否为空
	if len(bucketName) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, bucket name required")
	}

	// 检查region是否为空
	if len(region) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, region required")
	}

	// 加载默认配置并设置凭证提供者和区域
	cfg := oss.LoadDefaultConfig().
		WithCredentialsProvider(credentials.NewEnvironmentVariableCredentialsProvider()).
		WithRegion(region)

	// 创建OSS客户端
	client := oss.NewClient(cfg)

	// 创建设置存储空间清单的请求
	putRequest := &oss.PutBucketInventoryRequest{
		Bucket:      oss.Ptr(bucketName),  // 存储空间名称
		InventoryId: oss.Ptr(inventoryId), // 由用户指定的清单名称
		InventoryConfiguration: &oss.InventoryConfiguration{
			Id:        oss.Ptr(inventoryId), // 由用户指定的清单名称
			IsEnabled: oss.Ptr(true),        // 启用清单配置
			Filter: &oss.InventoryFilter{
				Prefix:                   oss.Ptr("filterPrefix"),    // 设置清单筛选规则，指定筛选Object的前缀
				LastModifyBeginTimeStamp: oss.Ptr(int64(1637883649)), // 最后修改开始时间戳
				LastModifyEndTimeStamp:   oss.Ptr(int64(1638347592)), // 最后修改结束时间戳
				LowerSizeBound:           oss.Ptr(int64(1024)),       // 文件大小下限（字节）
				UpperSizeBound:           oss.Ptr(int64(1048576)),    // 文件大小上限（字节）
				StorageClass:             oss.Ptr("Standard,IA"),     // 存储类型
			},
			Destination: &oss.InventoryDestination{
				OSSBucketDestination: &oss.InventoryOSSBucketDestination{
					Format:    oss.InventoryFormatCSV,                                   // 导出清单文件的文件格式
					AccountId: oss.Ptr(accountId),                                       // 存储空间所有者授予的账户ID，例如109885487000****
					RoleArn:   oss.Ptr("acs:ram::" + accountId + ":role/AliyunOSSRole"), // 存储空间所有者授予操作权限的角色名，比如acs:ram::109885487000****:role/ram-test
					Bucket:    oss.Ptr("acs:oss:::" + bucketName),                       // 存放导出的清单结果的Bucket名称
					Prefix:    oss.Ptr("export/"),                                       // 存放清单结果的存储路径前缀
				},
			},
			Schedule: &oss.InventorySchedule{
				Frequency: oss.InventoryFrequencyDaily, // 清单文件导出的周期（每天）
			},
			IncludedObjectVersions: oss.Ptr("All"), // 是否在清单中包含Object的所有版本信息
		},
	}

	// 执行设置存储空间清单的请求
	putResult, err := client.PutBucketInventory(context.TODO(), putRequest)
	if err != nil {
		log.Fatalf("failed to put bucket inventory %v", err)
	}

	// 打印设置存储空间清单的结果
	log.Printf("put bucket inventory result:%#v\n", putResult)
}