您可以通过OSS的PutBucketLifecycle接口创建基于最后一次修改时间(Last Modified Time)的生命周期规则(Lifecycle),定期将对象(Object)转储为低频访问、归档存储或冷归档存储类型,或者将过期的Object和碎片删除,从而节省存储费用。

使用场景

生命周期规则可以定期将非热门数据转换为低频访问、归档存储或冷归档存储,将不再需要访问的数据删除,让您更高效地管理您存储的数据,节省大量人力及存储成本。例如:
  • 某医疗机构的医疗档案,上传至OSS后半年内需要偶尔访问,半年后基本不再访问。可以通过设置生命周期规则,将已上传180天的医疗档案转为归档存储。
  • 某公司服务热线的录音文件,上传至OSS后2个月内,需要作为数据统计及核查的依据,2个月后偶尔访问,半年后基本不再访问,2年后数据不再需要存储。可以通过设置生命周期规则,设置录音文件上传60天后转为低频访问存储,180天后转为归档存储,730天后删除。
  • 某存储空间内有大量文件需要全部删除,但是手动删除每次仅可以删除最多1000个文件,比较麻烦。此时可以配置一条匹配整个Bucket的生命周期规则,设置一天后删除所有文件。此Bucket内的数据会在第二天被全部删除。

使用限制

  • 匹配条件

    生命周期规则目前仅支持根据前缀和标签进行匹配,不支持通配符匹配、后缀匹配以及正则匹配。

  • 碎片过期限制
    不支持对重叠前缀的Object设置两条或两条以上包含碎片过期策略的生命周期规则。示例如下:
    • 示例一

      您对整个Bucket设置了一条包含碎片过期策略的生命周期规则,则不支持对Bucket中任意前缀的Object再设置一条包含碎片过期策略的生命周期规则。

    • 示例二

      您对某个Bucket中前缀为dir1设置了一条包含碎片过期策略的生命周期规则,则不支持对该Bucket中包含重叠前缀(例如dir1/dir2)的Object再设置一条包含碎片过期策略的生命周期规则。

  • 存储类型转换限制
    • 不支持通过生命周期规则将追加上传生成的Appendable类型的Object转换为冷归档存储类型。
    • 不支持通过生命周期规则将软链接(symlink)转换为低频访问、归档以及冷归档存储类型。
  • 24小时内执行的删除或转换存储类型操作次数
    • 对于未配置标签的生命周期规则,通过生命周期规则24小时内执行的删除或者转换存储类型操作次数不低于10亿次。
    • 对于配置了标签的生命周期规则,通过生命周期规则24小时内执行与标签匹配的删除或转换存储类型操作次数不低于5亿次。
    说明 如果存储空间开启了版本控制,则对Object的每个版本均记为一次操作。

注意事项

  • 覆盖语义

    PutBucketLifecycle为覆盖语义。当您需要追加生命周期规则时,请先调用GetBucketLifecycle接口获取当前生命周期规则配置,然后追加新的生命周期规则配置,最后调用PutBucketLifecycle接口更新生命周期规则配置。

  • 数量

    通过控制台最多可配置100条生命周期规则,通过SDK或者命令行工具ossutil最多可配置1000条生命周期规则。

  • 生效时间

    生命周期规则创建后的24小时内,OSS会加载规则。规则加载完成后,OSS会在每天的北京时间8:00开始执行规则。

    Object的最后修改时间与生命周期规则开始执行时间(8:00)必须间隔24小时以上。例如生命周期规则指定Object上传1天后删除,则2020年7月20日上传的文件删除时间如下:

    • 北京时间8:00前上传的文件会在2020年7月21日8:00开始删除,并在7月22日8:00前删除完毕。
    • 北京时间8:00后上传的文件会在2020年7月22日8:00开始删除,并在7月23日8:00前删除完毕。
    重要 更新生命周期规则会中止当天的生命周期任务,请不要频繁更新生命周期规则。
  • 在开通了OSS-HDFS服务的Bucket中配置生命周期规则

    如果您对开通了OSS-HDFS服务的Bucket设置或更新为匹配整个Bucket的生命周期规则,需通过NOT元素排除.dlsdata/,避免因生命周期规则触发的Object删除或存储类型转换行为影响OSS-HDFS数据读写。

    lifecycle

组成元素

生命周期规则由以下元素组成:
  • 策略:生命周期规则匹配的Object和碎片。
    • 按前缀匹配:按指定前缀匹配Object和碎片。可创建多条规则匹配不同的前缀,前缀不能重复。前缀的命名规范与Object命名规范相同,详情请参见对象(Object)
    • 按标签匹配:按指定标签的Key和Value匹配Object。单条规则可配置多个标签,OSS对所有拥有这些标签的对象执行生命周期规则。标签匹配规则不作用于碎片。
      说明 对象标签功能详情请参见对象标签
    • 按前缀+标签匹配:按指定前缀和标签的筛选条件匹配对象。
    • 配置到整个Bucket:匹配整个Bucket内的所有Object和碎片。
    • NOT元素:如果您希望按照生命周期规则对与前缀和标签匹配的Object进行相应处理的同时,跳过不需要处理的Object,您可以通过NOT元素对不需要处理的Object指定前缀和标签。关于NOT元素的配置示例,请参见NOT示例
      重要 一条生命周期规则仅允许配置一个NOT元素。NOT元素下必须配置且仅允许配置一个前缀。此外,NOT元素下可以配置至多一个Object标签,也可以置空。
  • 文件过期策略:设置Object的过期时间及操作。
    • 过期天数:指定一个过期天数N,并指定非版本状态下的所有Object、以及版本控制状态下的当前版本Object过期后执行什么操作。Object会在其最后修改时间的N天后过期,并执行指定的操作。
    • 过期日期:指定一个过期日期,并指定非版本状态下的所有Object、以及版本控制状态下的当前版本Object过期后执行什么操作。最后修改时间在该日期之前的Object全部过期,并执行指定的操作。
    • Object成为非当前版本天数:指定一个过期天数N,并指定非当前版本Object过期后执行什么操作。Object会在其成为非当前版本的N天后过期,并执行指定的操作。

    您可以转换过期Object的存储类型或将其删除。详情请参见生命周期配置元素

  • 碎片过期策略:设置碎片的过期时间及操作。
    • 过期天数:可指定一个过期天数N,文件碎片会在其最后修改时间的N天后被删除。
    • 过期日期:指定一个过期日期,最后修改时间在该日期之前的文件碎片会被全部删除。

规则说明

  • 不同前缀
    例如,某个Bucket有如下几个Object:
    logs/programl/log1.txt
    logs/program2/log2.txt
    logs/program3/log3.txt
    doc/readme.txt

    如果生命周期规则指定的前缀是logs/,那么此规则仅作用于前三个以logs/开头的Object;如果指定的前缀是doc/readme.txt,则此规则则只对doc/readme.txt起作用。

    对过期策略匹配的Object执行GET或HEAD操作时,OSS会在响应Header中加入x-oss-expiration头。其中expiry-date的值表示Object的过期日期;rule-id的值表示相匹配的规则ID。

  • 相同前缀和标签

    当不同生命周期规则作用于相同前缀和标签的Object时,删除操作优先于存储类型转换操作。rule1用于指定所有前缀为abc,标签为a=1的Object 20天后删除,rule2规则不生效。

    rule prefix tag action
    rule1 abc a=1 20天后删除
    rule2 abc a=1 20天后转为Archive
  • 前缀重叠+标签相同

    rule1用于指定所有标签为a=1的Object 10天后转为IA。rule2用于指定前缀为abc且标签为a=1的Object 120天后删除。

    rule prefix tag action
    rule1 - a=1 10天后转为IA
    rule2 abc a=1 120天后被删除

    rule3用于指定所有标签为a=1的Object 20天后转为Archive。由于Archive类型文件无法转换为IA类型,因此rule4指定的前缀为abc且标签为a=1的Object 30天后转为IA的规则不生效。

    rule prefix tag action
    rule3 - a=1 20天后转为Archive
    rule4 abc a=1 30天后转为IA
  • NOT

    对同一个Bucket配置多条生命周期规则,且某条生命周期规则涉及NOT元素时,NOT元素指定的行为只对本条生命周期规则生效。具体示例如下:

    • 示例一
      • 通过生命周期规则1,指定examplebucket中前缀为dir/的Object 100天后删除。
      • 通过生命周期规则2,通过NOT元素指定examplebucket中除前缀为dir/以外的所有Object 50天后删除。

      以生命周期规则生效时间为起点,examplebucket中Object的删除行为如下表所示。

      Object 删除行为
      前缀为dir/的Object 100天后删除
      前缀不为dir/的Object 50天后删除
    • 示例二
      • 通过生命周期规则1,通过NOT元素指定examplebucket内除标签(key1:value1)以外的所有Object 30天后删除。
      • 通过生命周期规则2,指定examplebucket内包含标签(key2:value2)的所有Object 50天后删除。

      以生命周期规则生效时间为起点,examplebucket内Object的删除行为如下表所示:

      Object 删除行为
      对于未包含以上标签的所有Object 30天后删除
      对于仅包含key1:value1标签的Object 不删除
      对于仅包含key2:value2标签的Object 30天后删除
      对于同时包含key1:value1以及key2:value2标签的Object 50天后删除

使用OSS控制台

  1. 登录OSS管理控制台
  2. 单击Bucket列表,然后单击目标Bucket名称。
  3. 在左侧导航栏, 选择数据管理 > 生命周期
  4. 可选:如果您需要创建基于最后一次访问时间策略的生命周期规则,请在生命周期页面,打开启用访问追踪开关。
  5. 生命周期页面,单击创建规则
  6. 创建生命周期规则面板,按如下说明配置生命周期规则。
    • 存储空间未开启版本控制
      区域 配置项 说明
      基础设置 状态

      设置生命周期规则的状态,可选择启动禁用

      策略

      选择生命周期规则作用的Object。您可以选择按前缀匹配配置到整个Bucket

      是否允许前缀重叠
      OSS默认会检查各个生命周期规则的前缀是否重叠。例如,您设置了以下两条包含重叠前缀的生命周期规则:
      • 规则1

        指定该Bucket内所有前缀为dir1/的Object在距离最后一次修改时间180天后删除。

      • 规则2

        指定该Bucket内所有前缀为dir1/dir2/的Object在距离最后一次修改时间30天后转低频访问类型,60天后删除。

      在未选中该选项的情况下,因后台检测到dir1/dir2/目录下的Object同时匹配两条删除规则,因此会拒绝设置以上两条生命周期规则,并报错Overlap for same action type Expiration.

      在选中该选项的情况下,dir1/dir2/下的Object会在30天后转低频访问类型,60天后删除。dir1/下的其他Object会在180天删除。

      前缀
      输入规则要匹配的Object名称的前缀。
      • 前缀设置为img,表示匹配名称以img开头的所有Object,例如imgtest.png、img/example.jpg等。
      • 前缀设置为img/,表示匹配名称以img/开头的所有Object,例如img/example.jpg、img/test.jpg等。
      标签

      生命周期规则仅针对拥有指定标签Object生效。例如选择了按前缀匹配,设置前缀为img,并设置标签的key为a,value为1。则该规则将匹配所有名称以img开头,标签为a=1的Object。关于对象标签的更多信息,请参见对象标签

      NOT

      NOT选项用于设置生命周期规则对指定前缀和标签的Object不生效。

      重要
      • 开启NOT选项时,前缀和标签必须至少存在一项,即同时设置前缀和标签或者只设置前缀或标签。
      • NOT语义定义标签中的key不支持与标签配置项中定义的key相同。
      • 开启NOT选项后,不支持设置碎片过期策略。
      文件执行策略设置 文件过期策略

      选择Object过期策略,可选择过期天数过期日期不启用。选择不启用时,文件过期策略不生效。

      生命周期管理规则

      配置转换Object存储类型或者删除过期Object的规则。

      配置示例1:当您选择了最后一次访问时间策略,然后将过期天数设置为30,并指定数据在超出指定过期天数后将自动转换为低频存储类型(数据被访问后,依旧保留在低频档),则最后访问日期为2021年09月01日的Object会在2021年10月01日被转换为指定的存储类型。

      说明 当您选择基于最后一次访问时间的生命周期管理规则时,允许指定该规则仅对大于64 KB的文件生效,也可以指定为对所有文件生效。

      配置示例2:当您选择了最后一次修改时间策略,然后将过期日期设置为2021年9月24日,并指定在指定日期前的数据自动删除,则最后修改日期在2021年9月24日之前的Object会被自动删除,且删除后不可恢复。

      碎片执行策略设置 碎片过期策略

      设置对过期碎片执行的操作。如果选中了标签,则无法配置该选项。您可以选择碎片过期策略的过期天数过期日期,也可以选择不启用碎片过期策略。当选择不启用时,碎片过期策略不生效。

      重要 生命周期规则至少包含文件过期策略或碎片过期策略。
      碎片规则

      根据碎片过期策略选择的过期天数或过期日期设定碎片何时过期,碎片过期后会被自动删除,且删除后不可恢复。

    • 存储空间已开启版本控制

      开启版本控制后,基本设置碎片执行策略设置区域涉及的配置项,与未开启版本控制的配置方法相同。以下表格仅介绍与未开启版本控制相比,开启版本控制后配置项存在的差异。

      区域 配置项 说明
      当前版本文件执行策略设置 清理对象删除标记

      开启版本控制后,清除策略中增加了清理对象删除标记选项,其他选项与未开启版本控制时相同。

      选择此选项后,如果当前Object仅有一个版本且为删除标记时,则OSS将删除过期Object的删除标记。如果当前Object有多个版本,且Object的最新版本为删除标记时,则OSS将保留该删除标记。关于删除标记的更多信息,请参见删除标记

      历史版本文件执行策略设置 文件过期策略

      设置历史版本文件的过期策略,可选择过期天数不启用。当选择不启用时,文件过期策略不生效。

      生命周期管理规则

      设定一个过期天数N,历史版本的Object会在其被转换为历史版本的N天后过期,并在过期的第二天执行指定操作。例如设置为30,则在2021年09月01日被转为历史版本的Object会在2021年10月01日被转换为指定存储类型或被删除。

      重要 您可以通过Object下一个版本的最后一次修改时间确定Object被转为历史版本的时间。
  7. 单击确定
    生命周期规则保存成功后,您可以在策略列表中查看已设置的生命周期规则。

使用图形化管理工具ossbrowser

ossbrowser支持Bucket级别的操作与控制台支持的操作类似,请按照ossbrowser界面指引完成Bucket生命周期规则配置操作。关于如何使用ossbrowser,请参见快速使用ossbrowser

使用阿里云SDK

以下仅列举常见SDK的配置生命周期规则的代码示例。关于其他SDK的配置生命周期规则的代码示例,请参见SDK简介

OSS ossClient = null;
try {
    // yourEndpoint填写Bucket所在地域对应的Endpoint。以华东1(杭州)为例,Endpoint填写为https://oss-cn-hangzhou.aliyuncs.com。
    String endpoint = "yourEndpoint";
    // 阿里云账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用RAM用户进行API访问或日常运维,请登录RAM控制台创建RAM用户。
    String accessKeyId = "yourAccessKeyId";
    String accessKeySecret = "yourAccessKeySecret";
    // 填写Bucket名称,例如examplebucket。
    String bucketName = "examplebucket";

    // 创建OSSClient实例。
    ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);

    // 创建SetBucketLifecycleRequest。
    SetBucketLifecycleRequest request = new SetBucketLifecycleRequest(bucketName);

    // 设置规则ID。
    String ruleId0 = "rule0";
    // 设置文件匹配前缀。
    String matchPrefix0 = "A0/";
    // 设置要匹配的标签。
    Map<String, String> matchTags0 = new HashMap<String, String>();
    // 依次填写要匹配标签的键(例如owner)和值(例如John)。
    matchTags0.put("owner", "John");


    String ruleId1 = "rule1";
    String matchPrefix1 = "A1/";
    Map<String, String> matchTags1 = new HashMap<String, String>();
    matchTags1.put("type", "document");

    String ruleId2 = "rule2";
    String matchPrefix2 = "A2/";

    String ruleId3 = "rule3";
    String matchPrefix3 = "A3/";

    String ruleId4 = "rule4";
    String matchPrefix4 = "A4/";

    String ruleId5 = "rule5";
    String matchPrefix5 = "A5/";

    String ruleId6 = "rule6";
    String matchPrefix6 = "A6/";

    // 距最后修改时间3天后过期。
    LifecycleRule rule = new LifecycleRule(ruleId0, matchPrefix0, LifecycleRule.RuleStatus.Enabled, 3);
    rule.setTags(matchTags0);
    request.AddLifecycleRule(rule);

    // 指定日期之前创建的文件过期。
    rule = new LifecycleRule(ruleId1, matchPrefix1, LifecycleRule.RuleStatus.Enabled);
    rule.setCreatedBeforeDate(DateUtil.parseIso8601Date("2022-10-12T00:00:00.000Z"));
    rule.setTags(matchTags1);
    request.AddLifecycleRule(rule);

    // 分片3天后过期。
    rule = new LifecycleRule(ruleId2, matchPrefix2, LifecycleRule.RuleStatus.Enabled);
    LifecycleRule.AbortMultipartUpload abortMultipartUpload = new LifecycleRule.AbortMultipartUpload();
    abortMultipartUpload.setExpirationDays(3);
    rule.setAbortMultipartUpload(abortMultipartUpload);
    request.AddLifecycleRule(rule);

    // 指定日期之前的分片过期。
    rule = new LifecycleRule(ruleId3, matchPrefix3, LifecycleRule.RuleStatus.Enabled);
    abortMultipartUpload = new LifecycleRule.AbortMultipartUpload();
    abortMultipartUpload.setCreatedBeforeDate(DateUtil.parseIso8601Date("2022-10-12T00:00:00.000Z"));
    rule.setAbortMultipartUpload(abortMultipartUpload);
    request.AddLifecycleRule(rule);

    // 距最后修改时间10天后转低频访问存储类型,距最后修改时间30天后转归档存储类型。
    rule = new LifecycleRule(ruleId4, matchPrefix4, LifecycleRule.RuleStatus.Enabled);
    List<LifecycleRule.StorageTransition> storageTransitions = new ArrayList<LifecycleRule.StorageTransition>();
    LifecycleRule.StorageTransition storageTransition = new LifecycleRule.StorageTransition();
    storageTransition.setStorageClass(StorageClass.IA);
    storageTransition.setExpirationDays(10);
    storageTransitions.add(storageTransition);
    storageTransition = new LifecycleRule.StorageTransition();
    storageTransition.setStorageClass(StorageClass.Archive);
    storageTransition.setExpirationDays(30);
    storageTransitions.add(storageTransition);
    rule.setStorageTransition(storageTransitions);
    request.AddLifecycleRule(rule);

    // 指定最后修改日期在2022-10-12之前的文件转为归档存储。
    rule = new LifecycleRule(ruleId5, matchPrefix5, LifecycleRule.RuleStatus.Enabled);
    storageTransitions = new ArrayList<LifecycleRule.StorageTransition>();
    storageTransition = new LifecycleRule.StorageTransition();

    storageTransition.setCreatedBeforeDate(DateUtil.parseIso8601Date("2022-10-12T00:00:00.000Z"));

    storageTransition.setStorageClass(StorageClass.Archive);
    storageTransitions.add(storageTransition);
    rule.setStorageTransition(storageTransitions);
    request.AddLifecycleRule(rule);

    // rule6针对版本控制状态下的Bucket。
    rule = new LifecycleRule(ruleId6, matchPrefix6, LifecycleRule.RuleStatus.Enabled);
    // 设置Object相对最后修改时间365天之后自动转为归档文件。
    storageTransitions = new ArrayList<LifecycleRule.StorageTransition>();
    storageTransition = new LifecycleRule.StorageTransition();
    storageTransition.setStorageClass(StorageClass.Archive);
    storageTransition.setExpirationDays(365);
    storageTransitions.add(storageTransition);
    rule.setStorageTransition(storageTransitions);
    // 设置自动移除过期删除标记。
    rule.setExpiredDeleteMarker(true);
    // 设置非当前版本的object距最后修改时间10天之后转为低频访问类型。
    LifecycleRule.NoncurrentVersionStorageTransition noncurrentVersionStorageTransition =
            new LifecycleRule.NoncurrentVersionStorageTransition().withNoncurrentDays(10).withStrorageClass(StorageClass.IA);
    // 设置非当前版本的Object距最后修改时间20天之后转为归档类型。
    LifecycleRule.NoncurrentVersionStorageTransition noncurrentVersionStorageTransition2 =
            new LifecycleRule.NoncurrentVersionStorageTransition().withNoncurrentDays(20).withStrorageClass(StorageClass.Archive);
    // 设置非当前版本Object 30天后删除。
    LifecycleRule.NoncurrentVersionExpiration noncurrentVersionExpiration = new LifecycleRule.NoncurrentVersionExpiration().withNoncurrentDays(30);
    List<LifecycleRule.NoncurrentVersionStorageTransition> noncurrentVersionStorageTransitions = new ArrayList<LifecycleRule.NoncurrentVersionStorageTransition>();
    noncurrentVersionStorageTransitions.add(noncurrentVersionStorageTransition2);
    rule.setStorageTransition(storageTransitions);
    rule.setNoncurrentVersionExpiration(noncurrentVersionExpiration);
    rule.setNoncurrentVersionStorageTransitions(noncurrentVersionStorageTransitions);
    request.AddLifecycleRule(rule);

    // 发起设置生命周期规则请求。
    ossClient.setBucketLifecycle(request);

    // 查看生命周期规则。
    List<LifecycleRule> listRules = ossClient.getBucketLifecycle(bucketName);
    for(LifecycleRule rules : listRules){
        System.out.println("ruleId="+rules.getId()+", matchPrefix="+rules.getPrefix());
    }
} catch (Exception e) {
    e.printStackTrace();
} finally {
    if(ossClient != null){
        // 关闭OSSClient。
        ossClient.shutdown();
    }
}
<?php
if (is_file(__DIR__ . '/../autoload.php')) {
    require_once __DIR__ . '/../autoload.php';
}
if (is_file(__DIR__ . '/../vendor/autoload.php')) {
    require_once __DIR__ . '/../vendor/autoload.php';
}

use OSS\OssClient;
use OSS\Core\OssException;
use OSS\Model\LifecycleConfig;
use OSS\Model\LifecycleRule;
use OSS\Model\LifecycleAction;

// 阿里云账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用RAM用户进行API访问或日常运维,请登录RAM控制台创建RAM用户。
$accessKeyId = "yourAccessKeyId";
$accessKeySecret = "yourAccessKeySecret";
// Endpoint以华东1(杭州)为例,其它Region请按实际情况填写。
$endpoint = "https://oss-cn-hangzhou.aliyuncs.com";
// 填写存储空间名称。
$bucket= "yourBucketName";

// 设置规则ID和文件前缀。
$ruleId0 = "rule0";
$matchPrefix0 = "A0/";
$ruleId1 = "rule1";
$matchPrefix1 = "A1/";

$lifecycleConfig = new LifecycleConfig();
$actions = array();
// 距最后修改时间3天后过期。
$actions[] = new LifecycleAction(OssClient::OSS_LIFECYCLE_EXPIRATION, OssClient::OSS_LIFECYCLE_TIMING_DAYS, 3);
$lifecycleRule = new LifecycleRule($ruleId0, $matchPrefix0, "Enabled", $actions);
$lifecycleConfig->addRule($lifecycleRule);
$actions = array();
// 指定日期之前创建的文件过期。
$actions[] = new LifecycleAction(OssClient::OSS_LIFECYCLE_EXPIRATION, OssClient::OSS_LIFECYCLE_TIMING_DATE, '2022-10-12T00:00:00.000Z');
$lifecycleRule = new LifecycleRule($ruleId1, $matchPrefix1, "Enabled", $actions);
$lifecycleConfig->addRule($lifecycleRule);
try {
    $ossClient = new OssClient($accessKeyId, $accessKeySecret, $endpoint);

    $ossClient->putBucketLifecycle($bucket, $lifecycleConfig);
} catch (OssException $e) {
    printf(__FUNCTION__ . ": FAILED\n");
    printf($e->getMessage() . "\n");
    return;
}
print(__FUNCTION__ . ": OK" . "\n");
const OSS = require('ali-oss')
const client = new OSS({
  // yourregion填写Bucket所在地域。以华东1(杭州)为例,Region填写为oss-cn-hangzhou。
  region: 'yourregion',
  // 阿里云账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用RAM用户进行API访问或日常运维,请登录RAM控制台创建RAM用户。
  accessKeyId: 'yourAccessKeyId',
  accessKeySecret: 'yourAccessKeySecret',
  // yourbucketname填写存储空间名称。
  bucket: 'yourbucketname'
});

async function putBucketLifecycle(lifecycle) {
  try {
    const result = await client.putBucketLifecycle('yourbucketname', [
    lifecycle
  ]);
    console.log(result);
  } catch (e) {
    console.log(e);
  }
}

const lifecycle1 = {
  id: 'rule1',
  status: 'Enabled',
  prefix: 'foo/',
  expiration: {
    days: 3 // 指定当前版本Object距其最后修改时间3天后过期。
  }
}
putBucketLifecycle(lifecycle1)

const lifecycle2 = {
  id: 'rule2',
  status: 'Enabled',
  prefix: 'foo/', 
  expiration: {
    createdBeforeDate: '2020-02-18T00:00:00.000Z' // 指定日期之前创建的文件过期。
  },
}
putBucketLifecycle(lifecycle2)

const lifecycle3 = {
  id: 'rule3',
  status: 'Enabled',
  prefix: 'foo/', 
  abortMultipartUpload: {
    days: 3 // 指定分片3天后过期。
  },
}
putBucketLifecycle(lifecycle3)

const lifecycle4 = {
  id: 'rule4',
  status: 'Enabled',
  prefix: 'foo/', 
  abortMultipartUpload: {
    createdBeforeDate: '2020-02-18T00:00:00.000Z' // 指定日期之前创建的分片过期。
  },
}
putBucketLifecycle(lifecycle4)

const lifecycle5 = {
  id: 'rule5',
  status: 'Enabled',
  prefix: 'foo/', 
  transition: {
    // 指定当前版本Object距其最后修改时间20天后转归档存储类型。
    days: 20,
    storageClass: 'Archive'
  },
  expiration: {
    days: 21 // 指定当前版本Object距其最后修改时间21天后过期。
  },
}
putBucketLifecycle(lifecycle5)

const lifecycle6 = {
  id: 'rule6',
  status: 'Enabled',
  prefix: 'foo/', 
  transition: {
    // 指定日期之前自动将文件转为归档类型。
    createdBeforeDate: '2020-02-18T00:00:00.000Z', // 指定日期应早于文件过期时间。
    storageClass: 'Archive'
  },
  expiration: {
    createdBeforeDate: '2020-02-19T00:00:00.000Z' // 指定日期之前创建的文件过期。
  },
}
putBucketLifecycle(lifecycle6)

const lifecycle7 = {
  id: 'rule7',
  status: 'Enabled',
  prefix: 'foo/', 
  noncurrentVersionExpiration: {
    noncurrentDays: 1 // 设置Object成为非当前版本1天后过期。
  },
}
putBucketLifecycle(lifecycle7)

const lifecycle8 = {
  id: 'rule8',
  status: 'Enabled',
  prefix: 'foo/', 
  expiredObjectDeleteMarker: true // 设置自动移除过期删除标记。
}
putBucketLifecycle(lifecycle8)

const lifecycle9 = {
  id: 'rule9',
  status: 'Enabled',
  prefix: 'foo/', 
  // 设置非当前版本的Object距其最后修改时间10天之后转为低频访问类型。
  noncurrentVersionTransition: {
    noncurrentDays: '10',
    storageClass: 'IA'
  }
}
putBucketLifecycle(lifecycle9)

const lifecycle10 = {
  id: 'rule10',
  status: 'Enabled',
  prefix: 'foo/', 
  // 设置非当前版本的Object距其最后修改时间10天之后转为低频访问类型。
  noncurrentVersionTransition: {
    noncurrentDays: '10',
    storageClass: 'IA'
  },
  // 指定规则所适用的对象标签。
  tag: [{
    key: 'key1',
    value: 'value1'
  },
   {
     key: 'key2',
     value: 'value2'
   }]
}
putBucketLifecycle(lifecycle10)
# -*- coding: utf-8 -*-
import oss2
import datetime
from oss2.models import (LifecycleExpiration, LifecycleRule, 
                        BucketLifecycle,AbortMultipartUpload, 
                        TaggingRule, Tagging, StorageTransition,
                        NoncurrentVersionStorageTransition,
                        NoncurrentVersionExpiration)

# 阿里云账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用RAM用户进行API访问或日常运维,请登录RAM控制台创建RAM用户。
auth = oss2.Auth('yourAccessKeyId', 'yourAccessKeySecret')
# 填写Bucket所在地域对应的Endpoint。以华东1(杭州)为例,Endpoint填写为https://oss-cn-hangzhou.aliyuncs.com。
# yourBucketName填写Bucket名称,例如examplebucket。
bucket = oss2.Bucket(auth, 'http://oss-cn-hangzhou.aliyuncs.com', 'examplebucket')

# 设置Object距其最后修改时间3天后过期。
rule1 = LifecycleRule('rule1', 'tests/',
                      status=LifecycleRule.ENABLED,
                      expiration=LifecycleExpiration(days=3))

# 设置Object过期规则,指定日期之前创建的文件过期。
rule2 = LifecycleRule('rule2', 'tests2/',
                      status=LifecycleRule.ENABLED,
expiration=LifecycleExpiration(created_before_date=datetime.date(2022, 12, 12)))

# 设置分片过期规则,分片3天后过期。
rule3 = LifecycleRule('rule3', 'tests3/',
                      status=LifecycleRule.ENABLED,
            abort_multipart_upload=AbortMultipartUpload(days=3))

# 设置分片过期规则,指定日期之前的分片过期。
rule4 = LifecycleRule('rule4', 'tests4/',
                      status=LifecycleRule.ENABLED,
                      abort_multipart_upload = AbortMultipartUpload(created_before_date=datetime.date(2022, 12, 12)))

# 设置存储类型转换规则,指定Object在其最后修改时间20天之后转为低频访问类型,在其最后修改时间30天之后转为归档类型。
rule5 = LifecycleRule('rule5', 'tests5/',
                      status=LifecycleRule.ENABLED,
                      storage_transitions=[StorageTransition(days=20,storage_class=oss2.BUCKET_STORAGE_CLASS_IA),
                            StorageTransition(days=30,storage_class=oss2.BUCKET_STORAGE_CLASS_ARCHIVE)])

# 设置匹配的标签。
tagging_rule = TaggingRule()
tagging_rule.add('key1', 'value1')
tagging_rule.add('key2', 'value2')
tagging = Tagging(tagging_rule)

# 设置存储类型转换规则,指定Object在其最后修改时间超过365天后转为ARCHIVE类型。 
# rule6与以上几个规则不同的是它指定了匹配的标签,同时拥有key1=value1,key2=value2两个标签的object才会匹配此规则。
rule6 = LifecycleRule('rule6', 'tests6/',
                      status=LifecycleRule.ENABLED,
                      storage_transitions=[StorageTransition(created_before_date=datetime.date(2022, 12, 12),storage_class=oss2.BUCKET_STORAGE_CLASS_IA)],
                      tagging = tagging)

# rule7针对版本控制状态下的Bucket。
# 设置Object在其最后修改时间365天之后自动转为ARCHIVE类型。
# 设置自动移除过期删除标记。
# 设置非当前版本Object 12天后转为IA类型。
# 设置非当前版本Object 20天后转为ARCHIVE类型。
# 设置非当前版本Object 30天后删除。
rule7 = LifecycleRule('rule7', 'tests7/',
              status=LifecycleRule.ENABLED,
              storage_transitions=[StorageTransition(days=365, storage_class=oss2.BUCKET_STORAGE_CLASS_ARCHIVE)], 
              expiration=LifecycleExpiration(expired_detete_marker=True),
              noncurrent_version_sotrage_transitions = 
                    [NoncurrentVersionStorageTransition(12, oss2.BUCKET_STORAGE_CLASS_IA),
                     NoncurrentVersionStorageTransition(20, oss2.BUCKET_STORAGE_CLASS_ARCHIVE)],
              noncurrent_version_expiration = NoncurrentVersionExpiration(30))

lifecycle = BucketLifecycle([rule1, rule2, rule3, rule4, rule5, rule6, rule7])

bucket.put_bucket_lifecycle(lifecycle)
using Aliyun.OSS;
using Aliyun.OSS.Common;
// 填写Bucket所在地域对应的Endpoint。以华东1(杭州)为例,Endpoint填写为https://oss-cn-hangzhou.aliyuncs.com。
var endpoint = "https://oss-cn-hangzhou.aliyuncs.com";
// 阿里云账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用RAM用户进行API访问或日常运维,请登录RAM控制台创建RAM用户。
var accessKeyId = "yourAccessKeyId";
var accessKeySecret = "yourAccessKeySecret";
// 填写Bucket名称,例如examplebucket。
var bucketName = "examplebucket";

// 创建OSSClient实例。
var client = new OssClient(endpoint, accessKeyId, accessKeySecret);
try
{
    var setBucketLifecycleRequest = new SetBucketLifecycleRequest(bucketName);
    // 创建第1条生命周期规则。
    LifecycleRule lcr1 = new LifecycleRule()
    {
        ID = "delete obsoleted files",
        Prefix = "obsoleted/",
        Status = RuleStatus.Enabled,
        ExpriationDays = 3,
        Tags = new Tag[1]
    };
    // 设置标签。
    var tag1 = new Tag
    {
        Key = "project",
        Value = "projectone"
    };

    lcr1.Tags[0] = tag1;

    // 创建第2条生命周期规则。
    LifecycleRule lcr2 = new LifecycleRule()
    {
        ID = "delete temporary files",
        Prefix = "temporary/",
        Status = RuleStatus.Enabled,
        ExpriationDays = 20,
        Tags = new Tag[1]         
    };
    // 设置标签。
    var tag2 = new Tag
    {
        Key = "user",
        Value = "jsmith"
    };
    lcr2.Tags[0] = tag2;

    // 设置碎片在距最后修改时间30天后过期。
    lcr2.AbortMultipartUpload = new LifecycleRule.LifeCycleExpiration()
    {
        Days = 30
    };

    LifecycleRule lcr3 = new LifecycleRule();
    lcr3.ID = "only NoncurrentVersionTransition";
    lcr3.Prefix = "test1";
    lcr3.Status = RuleStatus.Enabled;
    lcr3.NoncurrentVersionTransitions = new LifecycleRule.LifeCycleNoncurrentVersionTransition[2]
    {
        // 设置非当前版本的Object距最后修改时间90天之后转为低频访问类型。
        new LifecycleRule.LifeCycleNoncurrentVersionTransition(){
            StorageClass = StorageClass.IA,
            NoncurrentDays = 90
        },
        // 设置非当前版本的Object距最后修改时间180天之后转为归档类型。
        new LifecycleRule.LifeCycleNoncurrentVersionTransition(){
            StorageClass = StorageClass.Archive,
            NoncurrentDays = 180
        }
    };
    setBucketLifecycleRequest.AddLifecycleRule(lcr1);
    setBucketLifecycleRequest.AddLifecycleRule(lcr2);
    setBucketLifecycleRequest.AddLifecycleRule(lcr3);

    // 设置生命周期规则。
    client.SetBucketLifecycle(setBucketLifecycleRequest);
    Console.WriteLine("Set bucket:{0} Lifecycle 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);
}
catch (Exception ex)
{
    Console.WriteLine("Failed with error info: {0}", ex.Message);
}
PutBucketLifecycleRequest request = new PutBucketLifecycleRequest();
request.setBucketName("examplebucket");

BucketLifecycleRule rule1 = new BucketLifecycleRule();
// 设置规则ID和文件前缀。
rule1.setIdentifier("1");
rule1.setPrefix("A");
// 设置是否执行生命周期规则。如果值为true,则OSS会定期执行该规则;如果值为false,则OSS会忽略该规则。
rule1.setStatus(true);
// 距最后修改时间200天后过期。
rule1.setDays("200");
// 30天后自动转为归档存储类型(Archive)
rule1.setArchiveDays("30");
// 未完成分片3天后过期。
rule1.setMultipartDays("3");
// 15天后自动转为低频存储类型(IA)。
rule1.setIADays("15");

BucketLifecycleRule rule2 = new BucketLifecycleRule();
rule2.setIdentifier("2");
rule2.setPrefix("B");
rule2.setStatus(true);
rule2.setDays("300");
rule2.setArchiveDays("30");
rule2.setMultipartDays("3");
rule2.setIADays("15");

ArrayList<BucketLifecycleRule> lifecycleRules = new ArrayList<BucketLifecycleRule>();
lifecycleRules.add(rule1);
lifecycleRules.add(rule2);
request.setLifecycleRules(lifecycleRules);
OSSAsyncTask task = oss.asyncPutBucketLifecycle(request, new OSSCompletedCallback<PutBucketLifecycleRequest, PutBucketLifecycleResult>() {
    @Override
    public void onSuccess(PutBucketLifecycleRequest request, PutBucketLifecycleResult result) {
        OSSLog.logInfo("code::"+result.getStatusCode());

    }

    @Override
    public void onFailure(PutBucketLifecycleRequest request, ClientException clientException, ServiceException serviceException) {
        OSSLog.logError("error: "+serviceException.getRawMessage());

    }
});

task.waitUntilFinished();
package main

import (
    "fmt"
    "os"

    "github.com/aliyun/aliyun-oss-go-sdk/oss"
)

func main() {
    // 创建OSSClient实例。
    // yourEndpoint填写Bucket对应的Endpoint,以华东1(杭州)为例,填写为https://oss-cn-hangzhou.aliyuncs.com。其它Region请按实际情况填写。
    // 阿里云账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用RAM用户进行API访问或日常运维,请登录RAM控制台创建RAM用户。
    client, err := oss.New("yourEndpoint", "yourAccessKeyId", "yourAccessKeySecret")
    if err != nil {
        fmt.Println("Error:", err)
        os.Exit(-1)
    }

    // 指定生命周期规则1,并在规则中指定前缀为foo的文件在距离最后一次修改时间3天后过期。
    rule1 := oss.BuildLifecycleRuleByDays("rule1", "foo/", true, 3)

    // 在受版本控制状态下的Object仅有删除标记的情况下,自动删除删除标记。
    deleteMark := true
    expiration := oss.LifecycleExpiration{
        ExpiredObjectDeleteMarker: &deleteMark,
    }

    // 非当前版本Object超过30天后过期删除。
    versionExpiration := oss.LifecycleVersionExpiration{
        NoncurrentDays: 30,
    }

    // 非当前版本Object超过10天后转为IA存储类型。
    versionTransition := oss.LifecycleVersionTransition{
        NoncurrentDays: 10,
        StorageClass:   "IA",
    }

    // 指定生命周期规则2。
    rule2 := oss.LifecycleRule{
        ID:                   "rule2",
        Prefix:               "yourObjectPrefix",
        Status:               "Enabled",
        Expiration:           &expiration,
        NonVersionExpiration: &versionExpiration,
        NonVersionTransition: &versionTransition,
    }

    // 指定生命周期规则3,对标签键为tag1、标签值为value1的文件,距文件最后一次修改时间3天后过期。
    rule3 := oss.LifecycleRule{
        ID:     "rule3",
        Prefix: "",
        Status: "Enabled",
        Tags: []oss.Tag{
            oss.Tag{
                Key:   "tag1",
                Value: "value1",
            },
        },
        Expiration: &oss.LifecycleExpiration{Days: 3},
    }

    // 设置生命周期规则。
    rules := []oss.LifecycleRule{rule1, rule2, rule3}
    // 填写Bucket名称,例如examplebucket。
    bucketName := "examplebucket"
    err = client.SetBucketLifecycle(bucketName, rules)
    if err != nil {
        fmt.Println("Error:", err)
        os.Exit(-1)
    }
}
#include <alibabacloud/oss/OssClient.h>
#include "../src/utils/Utils.h"
using namespace AlibabaCloud::OSS;

int main(void)
{
    /*初始化OSS账号信息。*/
    /*阿里云账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用RAM用户进行API访问或日常运维,请登录RAM控制台创建RAM用户。*/
    std::string AccessKeyId = "yourAccessKeyId";
    std::string AccessKeySecret = "yourAccessKeySecret";
    /*yourEndpoint填写Bucket所在地域对应的Endpoint。以华东1(杭州)为例,Endpoint填写为https://oss-cn-hangzhou.aliyuncs.com。*/
    std::string Endpoint = "yourEndpoint";
    /*填写Bucket名称,例如examplebucket。*/
    std::string BucketName = "examplebucket";

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

    ClientConfiguration conf;
    OssClient client(Endpoint, AccessKeyId, AccessKeySecret, conf);

    /*查看生命周期规则。*/
    auto outcome = client.GetBucketLifecycle(BucketName);

    if (outcome.isSuccess()) {
        std::cout << "GetBucketLifecycle success," << std::endl;
        for (auto const rule : outcome.result().LifecycleRules()) {
            std::cout << "rule:" << rule.ID() << "," << rule.Prefix() << "," << rule.Status() << ","
            "hasExpiration:" << rule.hasExpiration() << "," <<
            "hasTransitionList:" << rule.hasTransitionList() << "," << std::endl;

            auto taglist = rule.Tags();
            for (const auto& tag : taglist)
            {
                std::cout <<"GetBucketLifecycle tag success, Key:" 
                << tag.Key() << "; Value:" << tag.Value() << std::endl;
            }

            /*查看是否自动删除过期删除标记。*/
            if (rule.ExpiredObjectDeleteMarker()) {
                std::cout << "rule expired delete marker: " << rule.ExpiredObjectDeleteMarker() << std::endl;
            }

            /*查看非当前版本Object存储类型转换规则。*/
            if (rule.hasNoncurrentVersionTransitionList()) {
                for (auto const lifeCycleTransition : rule.NoncurrentVersionTransitionList()) {
                    std::cout << "rule noncurrent versions trans days:" << lifeCycleTransition.Expiration() <<
                    " trans storage class: " << ToStorageClassName(lifeCycleTransition.StorageClass()) << std::endl;    
                }
            }

            /*查看非当前版本Object过期规则。*/
            if (rule.hasNoncurrentVersionExpiration()) {
                std::cout << "rule noncurrent versions expiration days:" << rule.NoncurrentVersionExpiration().Days() << std::endl;
            }

        }
    }
    else {
        /*异常处理。*/
        std::cout << "GetBucketLifecycle fail" <<
        ",code:" << outcome.error().Code() <<
        ",message:" << outcome.error().Message() <<
        ",requestId:" << outcome.error().RequestId() << std::endl;
        ShutdownSdk();
        return -1;
    }

    /* 释放网络等资源。*/
    ShutdownSdk();
    return 0;
}
#include "oss_api.h"
#include "aos_http_io.h"
/* yourEndpoint填写Bucket所在地域对应的Endpoint。以华东1(杭州)为例,Endpoint填写为https://oss-cn-hangzhou.aliyuncs.com。*/
const char *endpoint = "yourEndpoint";
/* 阿里云账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用RAM用户进行API访问或日常运维,请登录RAM控制台创建RAM用户。*/
const char *access_key_id = "yourAccessKeyId";
const char *access_key_secret = "yourAccessKeySecret";
/* 填写Bucket名称,例如examplebucket。*/
const char *bucket_name = "examplebucket";
void init_options(oss_request_options_t *options)
{
    options->config = oss_config_create(options->pool);
    /* 用char*类型的字符串初始化aos_string_t类型。*/
    aos_str_set(&options->config->endpoint, endpoint);
    aos_str_set(&options->config->access_key_id, access_key_id);
    aos_str_set(&options->config->access_key_secret, access_key_secret);
    /* 是否使用cname域名访问OSS服务。0表示不使用。*/
    options->config->is_cname = 0;
    /* 用于设置网络相关参数,比如超时时间等。*/
    options->ctl = aos_http_controller_create(options->pool, 0);
}
int main(int argc, char *argv[])
{
    /* 在程序入口调用aos_http_io_initialize方法来初始化网络、内存等全局资源。*/
    if (aos_http_io_initialize(NULL, 0) != AOSE_OK) {
        exit(1);
    }
    /* 用于内存管理的内存池(pool),等价于apr_pool_t。其实现代码在apr库中。*/
    aos_pool_t *pool;
    /* 重新创建一个内存池,第二个参数是NULL,表示没有继承其它内存池。*/
    aos_pool_create(&pool, NULL);
    /* 创建并初始化options,该参数包括endpoint、access_key_id、acces_key_secret、is_cname、curl等全局配置信息。*/
    oss_request_options_t *oss_client_options;
    /* 在内存池中分配内存给options。*/
    oss_client_options = oss_request_options_create(pool);
    /* 初始化Client的选项oss_client_options。*/
    init_options(oss_client_options);
    /* 初始化参数。*/
    aos_string_t bucket;
    aos_table_t *resp_headers = NULL; 
    aos_status_t *resp_status = NULL; 
    aos_str_set(&bucket, bucket_name);
    aos_list_t lifecycle_rule_list;
    /* 给存储空间创建生命周期规则。*/
    aos_str_set(&bucket, bucket_name);
    aos_list_init(&lifecycle_rule_list);
    /* 指定过期天数。*/
    oss_lifecycle_rule_content_t *rule_content_days = oss_create_lifecycle_rule_content(pool);
    aos_str_set(&rule_content_days->id, "rule-1");
    aos_str_set(&rule_content_days->prefix, "obsoleted");
    aos_str_set(&rule_content_days->status, "Enabled");
    rule_content_days->days = 3;
    aos_list_add_tail(&rule_content_days->node, &lifecycle_rule_list);
    /* 指定过期时间。*/
    oss_lifecycle_rule_content_t *rule_content_date = oss_create_lifecycle_rule_content(pool);
    aos_str_set(&rule_content_date->id, "rule-2");
    aos_str_set(&rule_content_date->prefix, "delete");
    aos_str_set(&rule_content_date->status, "Enabled");
    aos_str_set(&rule_content_date->date, "2022-10-11T00:00:00.000Z");
    aos_list_add_tail(&rule_content_date->node, &lifecycle_rule_list);
    /* 设置生命周期规则。*/
    resp_status = oss_put_bucket_lifecycle(oss_client_options, &bucket, &lifecycle_rule_list, &resp_headers);
    if (aos_status_is_ok(resp_status)) {
        printf("put bucket lifecycle succeeded\n");
    } else {
        printf("put bucket lifecycle failed, code:%d, error_code:%s, error_msg:%s, request_id:%s\n",
            resp_status->code, resp_status->error_code, resp_status->error_msg, resp_status->req_id);
    }
    /* 释放内存池,相当于释放了请求过程中各资源分配的内存。*/
    aos_pool_destroy(pool);
    /* 释放之前分配的全局资源。*/
    aos_http_io_deinitialize();
    return 0;
}
require 'aliyun/oss'
client = Aliyun::OSS::Client.new(
  # Endpoint以华东1(杭州)为例,其它Region请按实际情况填写。
  endpoint: 'https://oss-cn-hangzhou.aliyuncs.com',
  # 阿里云账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用RAM用户进行API访问或日常运维,请登录RAM控制台创建RAM用户。
  access_key_id: 'AccessKeyId', access_key_secret: 'AccessKeySecret')
  # 填写Bucket名称。
  bucket = client.get_bucket('examplebucket')
# 设置生命周期规则。
bucket.lifecycle = [
  LifeCycleRule.new(
    :id => 'rule1', :enable => true, :prefix => 'foo/', :expiry => 3),
  LifeCycleRule.new(
    :id => 'rule2', :enable => false, :prefix => 'bar/', :expiry => Date.new(2016, 1, 1))
]

使用命令行工具ossutil

关于使用ossutil设置生命周期规则的具体操作, 请参见添加或修改生命周期规则

使用REST API

如果您的程序自定义要求较高,您可以直接发起REST API请求。直接发起REST API请求需要手动编写代码计算签名。更多信息,请参见PutBucketLifecycle

常见问题

  • 通过CopyObject覆写文件存储类型时,是否有最小存储天数限制?
    有最小存储天数限制。例如低频访问类型文件在其创建10天后,通过CopyObject覆写操作将存储类型转换为归档存储,此操作会产生低频访问存储不足规定时长费用。同时文件的创建时间发生变化,且转换后的归档存储类型文件因最小存储天数为60天,因此需再保存至少60天。
  • 通过生命周期规则进行的类型转换、过期删除操作,是否有日志记录?
    所有成功通过生命周期规则进行的类型转换、过期删除操作都会有日志记录,日志记录字段如下:
    • Operation
      • CommitTransition:通过生命周期规则转换存储类型,例如转换为低频访问、归档或冷归档存储类型。
      • ExpireObject:通过生命周期规则删除过期Object。
    • Sync Request

      lifecycle:生命周期规则触发的转换存储类型和删除过期Object的操作。