全部产品
Search

搜索本产品

    对象存储 OSS：基于最后一次修改时间配置生命周期规则以降低OSS存储成本

    文档中心

    对象存储 OSS：基于最后一次修改时间配置生命周期规则以降低OSS存储成本

    更新时间：Jun 04, 2024

    并不是所有上传至OSS的数据都需要频繁访问，但基于数据合规或者存档等原因，部分数据仍需要继续保存。或者基于业务使用场景，希望批量删除Bucket内不再需要保存的数据。您可以配置基于最后一次修改时间（Last Modified Time）的生命周期规则，定期将Object从热存储类型转为冷存储类型，或者删除Object，以降低存储成本。

    使用场景

    • 某医疗机构的医疗档案，上传至OSS后半年内需要偶尔访问，半年后基本不再访问。可以通过设置生命周期规则，将已上传180天的医疗档案转为归档存储。

    • 某公司服务热线的录音文件，上传至OSS后2个月内，需要作为数据统计及核查的依据，2个月后偶尔访问，半年后基本不再访问，2年后数据不再需要存储。可以通过设置生命周期规则，设置录音文件上传60天后转为低频访问存储，180天后转为归档存储，730天后删除。

    • 某Bucket内有大量文件需要全部删除，但是手动删除每次仅可以删除最多1000个文件，比较麻烦。此时可以配置一条匹配整个Bucket的生命周期规则，设置一天后删除所有文件。此Bucket内的数据会在第二天被全部删除。

    关于存储类型的介绍，请参见存储类型概述。

    使用限制

    匹配条件

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

    碎片过期限制

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

    • 示例一

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

    • 示例二

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

    存储类型转换限制

    • 不支持通过生命周期规则将追加上传生成的Appendable类型的Object转换为冷归档存储或者深度冷归档存储类型。

    • 不支持通过生命周期规则将软链接（symlink）转换为低频访问、归档、冷归档以及深度冷归档存储类型。

    注意事项

    规则数量

    单个Bucket最多支持配置1000条生命周期规则，单条生命周期规则中可同时包含最后一次修改时间以及最后一次访问时间的策略。

    覆盖语义

    PutBucketLifecycle为覆盖语义。例如，某个Bucket已配置了生命周期规则Rule1，您需要在Rule1基础上继续追加生命周期规则Rule2，您需要执行以下操作。

    • 调用GetBucketLifecycle接口获取当前生命周期规则配置Rule1。

    • 在Rule1基础上叠加Rule2。

    • 调用PutBucketLifecycle接口更新生命周期规则为Rule1+Rule2。

    生效时间

    生命周期规则创建后的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前删除完毕。

    重要

    更新生命周期规则会中止当天的生命周期任务，请不要频繁更新生命周期规则。

    执行完成时间

    对于未配置标签的生命周期规则

    • 华东1（杭州）、华东2（上海）、华北2（北京）、华北 3（张家口）、华北6（乌兰察布）、华南1（深圳）、新加坡地域执行10亿或以下次生命周期相关操作（包括Object删除、Object存储类型转换以及碎片过期），可在24小时内完成。如果生命周期相关操作超出10亿次，则可能超出24小时。

    • 其他地域执行1亿或以下次生命周期相关操作，可在24小时内完成。如果生命周期相关操作超出1亿次，则可能超出24小时。

    对于已配置标签的生命周期规则

    • 华东1（杭州）、华东2（上海）、华北2（北京）、华北 3（张家口）、华北6（乌兰察布）、华南1（深圳）、新加坡地域执行5亿或以下次生命周期相关操作（包括Object删除、Object存储类型转换以及碎片过期），可在24小时内完成。如果生命周期相关操作超出5亿次，则可能超出24小时。

    • 其他地域执行5千万或以下次生命周期相关操作，可在24小时内完成。如果生命周期相关操作超出5千万次，则可能超出24小时。

    说明

    如果存储空间开启了版本控制，则对Object的每个版本均记为一次操作。

    费用说明

    关于通过生命周期规则转换Object存储类型或者删除Object时可能涉及的存储和请求费用说明，请参见生命周期费用说明。

    在开通了OSS-HDFS服务的Bucket中配置生命周期规则

    • 在开通了OSS-HDFS服务的Bucket中配置基于OSS文件的生命周期规则

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

      p571593..jpeg

    • 在开通了OSS-HDFS服务的Bucket中配置基于HDFS文件的生命周期规则

      如果您需要对经常访问的数据以标准类型进行存储，对于较少访问的数据以低频、归档以及冷归档类型进行存储，您可以使用基于生命周期规则的冷热分层存储功能实现这一场景。具体操作，请参见冷热分层存储。

    组成元素

    匹配元素

    • 按前缀匹配：按指定前缀匹配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. 在创建生命周期规则面板，按如下说明配置生命周期规则。

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

        区域

        配置项

        说明

        基础设置

        状态

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

        • 启动生命周期规则后，将按照配置的生命周期规则转换数据存储类型或删除数据。

        • 禁用生命周期规则后，将中断生命周期任务。

        策略

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

        说明

        选择按前缀匹配时，需要填写前缀的完整路径。例如，您希望仅作用于src/dir1下的所有文件，则前缀需要填写为src/dir1，仅填写dir1则不生效。

        是否允许前缀重叠

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

        • 规则1

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

        • 规则2

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

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

        在配置规则2时选中该选项的情况下，dir1/dir2/下的Object会在30天后转低频访问类型，60天后删除。dir1/下的其他Object会在180天删除。

        说明

        如果配置了多条规则，且其中一条为基于整个Bucket的规则时，会被视为前缀重叠的情况。

        前缀

        输入规则要匹配的Object名称的前缀。

        • 前缀设置为img，表示匹配名称以img开头的所有Object，例如imgtest.png、img/example.jpg等。

        • 前缀设置为img/，表示匹配名称以img/开头的所有Object，例如img/example.jpg、img/test.jpg等。

        标签

        生命周期规则仅针对拥有指定标签Object生效。

        • 如果没有设置前缀，只设置了标签，且标签的key为a，value为1。则该规则将匹配Bucket内所有标签为a=1的Object。

        • 如果设置了前缀，前缀设置为img，同时设置了标签，标签的key为a，value为1，则该规则将匹配Bucket内所有名称以img开头，标签为a=1的Object。

        更多信息，请参见对象标签。

        NOT

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

        重要

        • 开启NOT选项时，前缀和标签必须至少存在一项，即同时设置前缀和标签或者只设置前缀或标签。

        • NOT语义定义标签中的key不支持与标签配置项中定义的key相同。

        • 开启NOT选项后，不支持设置碎片过期策略。

        文件大小

        指定生命周期规则生效的文件大小。

        • 指定最小文件：生命周期规则对大于该值的文件大小生效。取值大于0 B，小于5 TB。

        • 指定最大文件：生命周期规则对小于该值的文件大小生效。取值大于0 B，小于等于5 TB。

        重要

        如果在同一条生命周期中，同时配置了指定最小文件和指定最大文件：

        • 确保指定最大文件的值大于指定最小文件的值。

        • 不支持配置碎片执行策略。

        • 不支持配置清除删除标记策略。

        文件执行策略设置

        文件时间策略

        选择Object过期策略，可选择指定天数、指定日期和不启用。选择不启用时，文件过期策略不生效。

        生命周期管理规则

        配置转换Object存储类型或者删除过期Object的规则，可选择低频访问、归档存储、冷归档存储、深度冷归档存储和数据删除。

        例如，当您将文件时间策略设置为指定日期，并将日期设置为2023年9月24日，则最后一次修改时间在2023年9月24日之前的Object会被自动删除，且删除后不可恢复。

        碎片执行策略设置

        碎片过期策略

        配置碎片执行策略。如果选中了标签，则无法配置该选项。您可以选择按指定天数或指定日期执行碎片过期策略，也可以选择不启用碎片过期策略。当选择不启用时，碎片过期策略不生效。

        重要

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

        碎片规则

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

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

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

        区域

        配置项

        说明

        当前版本文件执行策略设置

        清理对象删除标记

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

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

        重要

        当有历史版本存在时，该规则不会清理对象删除标记。因此建议及时清理对象删除标记和非必要的历史版本，否则Bucket内因存储过多的删除标记，导致List性能下降。

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

        文件时间策略

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

        生命周期管理规则

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

        重要

        您可以通过Object下一个版本的最后一次修改时间确定 Object被转为历史版本的时间。

    6. 单击确定。

      生命周期规则保存成功后，您可以在策略列表中查看已设置的生命周期规则。

    使用阿里云SDK

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

    Java

    import com.aliyun.oss.ClientException;
import com.aliyun.oss.OSS;
import com.aliyun.oss.common.auth.*;
import com.aliyun.oss.OSSClientBuilder;
import com.aliyun.oss.OSSException;
import com.aliyun.oss.common.utils.DateUtil;
import com.aliyun.oss.model.LifecycleRule;
import com.aliyun.oss.model.SetBucketLifecycleRequest;
import com.aliyun.oss.model.StorageClass;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

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";

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

        try {
            // 创建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 (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();
            }
        }
    }
}

    PHP

    <?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\Credentials\EnvironmentVariableCredentialsProvider;
use OSS\OssClient;
use OSS\CoreOssException;
use OSS\Model\LifecycleConfig;
use OSS\Model\LifecycleRule;
use OSS\Model\LifecycleAction;

// 从环境变量中获取访问凭证。运行本代码示例之前，请确保已设置环境变量OSS_ACCESS_KEY_ID和OSS_ACCESS_KEY_SECRET。
$provider = new EnvironmentVariableCredentialsProvider();
// Endpoint以华东1（杭州）为例，其它Region请按实际情况填写。
$endpoint = "https://oss-cn-hangzhou.aliyuncs.com";
// 填写存储空间名称。
$bucket= "examplebucket";

// 设置规则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 {
    $config = array(
        "provider" => $provider,
        "endpoint" => $endpoint,
    );
    $ossClient = new OssClient($config);

    $ossClient->putBucketLifecycle($bucket, $lifecycleConfig);
} catch (OssException $e) {
    printf(__FUNCTION__ . ": FAILED\n");
    printf($e->getMessage() . "\n");
    return;
}
print(__FUNCTION__ . ": OK" . "\n");

    Node.js

    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'
});

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: {
    // 指定当前版本Object距其最后修改时间3天后过期。
    days: 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: {
    // 指定分片3天后过期。
    days: 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: {
    // 指定当前版本Object距其最后修改时间21天后过期。
    days: 21 
  },
}
putBucketLifecycle(lifecycle5)

const lifecycle6 = {
  id: 'rule6',
  status: 'Enabled',
  prefix: 'foo/', 
  transition: {
    // 达到指定日期后自动将文件转为归档类型。
    createdBeforeDate: '2023-02-19T00:00:00.000Z', 
    storageClass: 'Archive'
  },
  expiration: {
    // 达到指定日期后自动将文件删除。
    createdBeforeDate: '2023-01-18T00:00:00.000Z' 
  },
}
putBucketLifecycle(lifecycle6)

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

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

const lifecycle9 = {
  id: 'rule9',
  status: 'Enabled',
  prefix: 'foo/', 
  // 设置非当前版本的Object距其最后修改时间10天之后转为低频访问类型。
  noncurrentVersionTransition: {
    noncurrentDays: '10',
    storageClass: 'IA'
  },
  // 指定规则所适用的对象标签。
  tag: [{
    key: 'key1',
    value: 'value1'
  },
   {
     key: 'key2',
     value: 'value2'
   }]
}
putBucketLifecycle(lifecycle9)

    Python

    # -*- coding: utf-8 -*-
import oss2
from oss2.credentials import EnvironmentVariableCredentialsProvider
import datetime
from oss2.models import (LifecycleExpiration, LifecycleRule, 
                        BucketLifecycle,AbortMultipartUpload, 
                        TaggingRule, Tagging, StorageTransition,
                        NoncurrentVersionStorageTransition,
                        NoncurrentVersionExpiration)

# 从环境变量中获取访问凭证。运行本代码示例之前，请确保已设置环境变量OSS_ACCESS_KEY_ID和OSS_ACCESS_KEY_SECRET。
auth = oss2.ProviderAuth(EnvironmentVariableCredentialsProvider())
# 填写Bucket所在地域对应的Endpoint。以华东1（杭州）为例，Endpoint填写为https://oss-cn-hangzhou.aliyuncs.com。
# 填写Bucket名称，例如examplebucket。
bucket = oss2.Bucket(auth, 'https://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(2023, 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)

    C#

    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";
// 从环境变量中获取访问凭证。运行本代码示例之前，请确保已设置环境变量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名称，例如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);
}

    Android-Java

    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();

    Go

    package main

import (
	"fmt"
	"github.com/aliyun/aliyun-oss-go-sdk/oss"
	"os"
)

func main() {
	// 从环境变量中获取访问凭证。运行本代码示例之前，请确保已设置环境变量OSS_ACCESS_KEY_ID和OSS_ACCESS_KEY_SECRET。
	provider, err := oss.NewEnvironmentVariableCredentialsProvider()
	if err != nil {
		fmt.Println("Error:", err)
		os.Exit(-1)
	}
	// 创建OSSClient实例。
	// yourEndpoint填写Bucket对应的Endpoint，以华东1（杭州）为例，填写为https://oss-cn-hangzhou.aliyuncs.com。其它Region请按实际情况填写。
	client, err := oss.New("yourEndpoint", "", "", oss.SetCredentialsProvider(&provider))
	if err != nil {
		fmt.Println("Error:", err)
		os.Exit(-1)
	}
	// 填写存储空间名称。
	bucketName := "examplebucket"
	// 指定生命周期规则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,
		NonVersionTransitions: []oss.LifecycleVersionTransition{
			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}
	err = client.SetBucketLifecycle(bucketName, rules)
	if err != nil {
		fmt.Println("Error:", err)
		os.Exit(-1)
	}
}

    C++

    #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";
    /*填写Bucket名称，例如examplebucket。*/
    std::string BucketName = "examplebucket";

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

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

    SetBucketLifecycleRequest request(BucketName);
    std::string date("2022-10-12T00:00:00.000Z");

    /*设置标签。*/
    Tagging tagging;
    tagging.addTag(Tag("key1", "value1"));
    tagging.addTag(Tag("key2", "value2"));

    /*指定生命周期规则。*/
    auto rule1 = LifecycleRule();
    rule1.setID("rule1");
    rule1.setPrefix("test1/");
    rule1.setStatus(RuleStatus::Enabled);
    rule1.setExpiration(3);
    rule1.setTags(tagging.Tags());

    /*指定过期时间。*/
    auto rule2 = LifecycleRule();
    rule2.setID("rule2");
    rule2.setPrefix("test2/");
    rule2.setStatus(RuleStatus::Disabled);
    rule2.setExpiration(date);

    /*rule3为针对版本控制状态下的Bucket的生命周期规则。*/
    auto rule3 = LifecycleRule();
    rule3.setID("rule3");
    rule3.setPrefix("test3/");
    rule3.setStatus(RuleStatus::Disabled);

    /*设置Object距其最后修改时间365天之后自动转为归档类型。*/  
    auto transition = LifeCycleTransition();  
    transition.Expiration().setDays(365);
    transition.setStorageClass(StorageClass::Archive);
    rule3.addTransition(transition);

    /*设置自动移除过期删除标记。*/
    rule3.setExpiredObjectDeleteMarker(true);

    /*设置非当前版本的Object距最后修改时间10天之后转为低频访问类型。*/
    auto transition1 = LifeCycleTransition();  
    transition1.Expiration().setDays(10);
    transition1.setStorageClass(StorageClass::IA);

    /*设置非当前版本的Object距最后修改时间20天之后转为归档类型。*/
    auto transition2 = LifeCycleTransition();  
    transition2.Expiration().setDays(20);
    transition2.setStorageClass(StorageClass::Archive);

    /*设置Object在其成为非当前版本30天之后删除。*/
    auto expiration  = LifeCycleExpiration(30);
    rule3.setNoncurrentVersionExpiration(expiration);

    LifeCycleTransitionList noncurrentVersionStorageTransitions{transition1, transition2};
    rule3.setNoncurrentVersionTransitionList(noncurrentVersionStorageTransitions);

    /*设置生命周期规则。*/
    LifecycleRuleList list{rule1, rule2, rule3};
    request.setLifecycleRules(list);
    auto outcome = client.SetBucketLifecycle(request);

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

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

    C

    #include "oss_api.h"
#include "aos_http_io.h"
/* yourEndpoint填写Bucket所在地域对应的Endpoint。以华东1（杭州）为例，Endpoint填写为https://oss-cn-hangzhou.aliyuncs.com。*/
const char *endpoint = "yourEndpoint";
/* 填写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);
    /* 从环境变量中获取访问凭证。运行本代码示例之前，请确保已设置环境变量OSS_ACCESS_KEY_ID和OSS_ACCESS_KEY_SECRET。*/
    aos_str_set(&options->config->access_key_id, getenv("OSS_ACCESS_KEY_ID"));
    aos_str_set(&options->config->access_key_secret, getenv("OSS_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, "dir1");
    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, "dir2");
    aos_str_set(&rule_content_date->status, "Enabled");
    /* 过期时间格式为UTC。
    aos_str_set(&rule_content_date->date, "2023-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;
}

    Ruby

    require 'aliyun/oss'

client = Aliyun::OSS::Client.new(
  # Endpoint以华东1（杭州）为例，其它Region请按实际情况填写。
  endpoint: 'https://oss-cn-hangzhou.aliyuncs.com',
  # 从环境变量中获取访问凭证。运行本代码示例之前，请确保已设置环境变量OSS_ACCESS_KEY_ID和OSS_ACCESS_KEY_SECRET。
  access_key_id: ENV['OSS_ACCESS_KEY_ID'],
  access_key_secret: ENV['OSS_ACCESS_KEY_SECRET']
)
# 填写Bucket名称。
bucket = client.get_bucket('examplebucket')
# 设置生命周期规则。
bucket.lifecycle = [
  Aliyun::OSS::LifeCycleRule.new(
    :id => 'rule1', :enable => true, :prefix => 'foo/', :expiry => 3),
  Aliyun::OSS::LifeCycleRule.new(
    :id => 'rule2', :enable => false, :prefix => 'bar/', :expiry => Date.new(2016, 1, 1))
]

    使用命令行工具ossutil

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

    使用REST API

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

    常见问题

    报错Set bucket lifecycle error, InvalidArgument, Days in the Transition action for StorageClass Archive must be more than the Transition action for StorageClass IA怎么办？

    出现该报错的原因是不同存储类型的转储时间不满足指定要求。当Bucket同时配置了转换为低频访问、转换为归档存储、转换为冷归档存储以及转换为深度冷归档存储的策略时，其转换周期必须满足以下条件：

    转换为低频访问的周期<转换为归档的周期<转换为冷归档的周期<转换为深度冷归档的周期

    生命周期规则是否作用于Bucket内已有的存量Object？

    生命周期规则同时作用于配置规则前Bucket内已有的存量Object，同时也作用于配置生命周期规则后上传的Object。例如，您在10月07日配置了生命周期规则，指定距离Object最后一次修改时间30天后删除，则10月5日内上传的Object将在11月6日开始执行删除操作。而10月08日上传的Object将在11月09日执行删除操作。

    如何修改其中一条或多条生命周期规则配置？

    假设您的Bucket配置了两条生命周期规则，分别为Rule1和Rule2，您希望修改Rule1的某个配置项，您需要执行以下操作。

    1. 调用GetBucketLifecycle接口获取当前Bucket配置的所有生命周期规则，即Rule1和Rule2。

    2. 修改Rule1生命周期规则的配置项。

    3. 调用PutBucketLifecycle接口更新生命周期规则为Rule1+Rule2。

    如何删除其中一条或多条生命周期规则？

    调用DeleteBucketLifecycle时会一键删除Bucket配置的所有生命周期规则。假设您的Bucket配置了两条生命周期规则，分别为Rule1和Rule2，您仅希望删除Rule1，您需要执行以下操作。

    1. 调用GetBucketLifecycle接口获取当前Bucket配置的所有生命周期规则，即Rule1和Rule2。

    2. 删除Rule1。

    3. 调用PutBucketLifecycle接口更新生命周期规则为Rule2。

    通过生命周期规则进行的类型转换、过期删除操作，是否有日志记录？

    所有成功通过生命周期规则进行的类型转换、过期删除操作都会有日志记录，日志记录字段如下：

    • Operation

      • CommitTransition：通过生命周期规则转换存储类型，例如转换为低频访问、归档或冷归档存储类型。

      • ExpireObject：通过生命周期规则删除过期Object。

    • Sync Request

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

    关于OSS日志字段的更多信息，请参见日志字段详情。关于日志查询的费用说明，请参见计费说明。

    是否支持创建一条生命周期规则同时清理对象删除标记和当前版本对象？

    不支持。您可以先创建一条生命周期规则，清理对象删除标记。 清理对象删除标记后，再创建一条生命周期规则，删除当前版本对象。

    基于最后一次修改时间的生命周期规则是否支持将Object从低频访问类型转换为标准类型？

    不支持。您可以通过以下方式将Object从低频访问类型转为标准类型：

    • 通过CopyObject的方式

      CopyObject接口支持将单个Object从低频访问类型转为标准类型。

    • 通过ossutil工具

      ossutil支持通过set-meta命令添加X-Oss-Storage-Class选项的方式将单个或多个Object从低频访问类型转换为标准类型。具体操作，请参见设置或更新元数据。

    相关文档

    • 默认情况下，OSS会将Object的上传时间置为其最后一次修改时间。通过生命周期转换文件存储类型的操作不会更新Object的最后一次修改时间。具体哪些操作会影响Object的LastModified，请参见哪些操作会更新Object的LastModified？。

    • 当低频访问、归档、冷归档或者深度冷归档存储类型Object在存储不足规定时长时转换了存储类型并提前删除时，需要收取不足规定时长容量费用。更多信息，请参见Object在存储不足规定时长时如何计费？。

    • 生命周期规则仅支持对整个Bucket或与前缀匹配的数据进行批量转储或者删除，如果您希望删除批量删除指定后缀的数据，您可以使用ossutil rm命令。

    • 如果您希望OSS自动监测数据的访问模式并识别冷数据，然后将识别出来的冷数据进行存储类型的转换，从而达到数据的冷热分层存储，最终降低存储成本，您需要配置基于最后一次访问时间的生命周期规则。

    • 如果您希望查看Bucket内所有Object的存储类型，请参见列举文件。