You can call the PutBucketLifecycle operation to configure lifecycle rules for a bucket based on the last modified time of the objects in the bucket. After the lifecycle rules are configured, Object Storage Service (OSS) periodically converts the storage class of expired objects to Infrequent Access (IA), Archive, or Cold Archive, or deletes expired objects and parts. This reduces storage costs.

Scenarios

You can configure a lifecycle rule to periodically convert the storage class of cold data to IA, Archive, or Cold Archive, or delete objects that are no longer accessed. This simplifies data management and reduces storage costs. For example, you can configure lifecycle rules in the following scenarios:
  • A medical institution stores medical records in OSS. These objects are occasionally accessed within six months after they are uploaded, and almost never after that. In this case, you can configure a lifecycle rule to convert the storage class of the objects to Archive 180 days after they are uploaded.
  • A company stores the call records of its customer service hotline in OSS. These objects are frequently accessed within the first two months, occasionally after two months, and almost never after six months. After two years, the objects no longer need to be stored. In this case, you can configure a lifecycle rule to convert the storage class of the objects to IA 60 days after they are uploaded and to Archive 180 days after they are uploaded, and delete the objects 730 days after they are uploaded.
  • You can manually delete up to 1,000 objects at a time. If a bucket contains more than 1,000 objects, you must perform multiple operations to delete all the objects in the bucket. In this case, you can configure a lifecycle rule to delete all objects in the bucket the next day. This way, all objects in the bucket can be deleted the next day.

Limits

  • Match conditions

    Currently, lifecycle rules only support matching based on prefixes and tags. Wildcard matching, suffix matching, and regular expression matching are not supported.

  • Part lifecycle
    You cannot configure two or more lifecycle rules that contain a part lifecycle policy for objects whose names contain overlapping prefixes. For example, you cannot configure lifecycle rules in the following scenarios:
    • Example 1

      If you configure a lifecycle rule that contains a part lifecycle policy for the entire bucket first, you cannot configure another lifecycle rule that contains a part lifecycle policy for objects whose names contain any prefix in the bucket.

    • Example 2

      If you configure a lifecycle rule that contains a part lifecycle policy for objects whose names contain the dir1 prefix in a bucket first, you cannot configure another lifecycle rule that contains a part lifecycle policy for objects whose names contain overlapping prefixes, such as dir1/dir2.

  • Storage class conversion
    • You cannot use a lifecycle rule to convert the storage class of appendable objects to Cold Archive.
    • You cannot use a lifecycle rule to convert the storage class of symbolic links to IA, Archive, or Cold Archive.
  • Limit on the number of object delete operations or storage class conversion operations
    • For a lifecycle rule that does not contain tags, you can perform up to 1 billion lifecycle-related operations in 24 hours, including object deletion, storage class conversion, and the operation that can be performed on the expired parts. If you want to perform more than 1 billion lifecycle-related operations, the time period that is required to complete the operations may exceed 24 hours.
    • For a lifecycle rule that contains tags, you can perform up to 500 million lifecycle-related operations in 24 hours, including object deletion, storage class conversion, and the operation that can be performed on the expired parts. If you want to perform more than 500 million lifecycle-related operations, the time period that is required to complete the operations may exceed 24 hours.
    Note If versioning is enabled for the bucket, an operation performed on each version of the objects is recorded as an operation.

Usage notes

  • Overwriting semantics

    PutBucketLifecycle uses the overwriting semantics. New lifecycle rules overwrite the existing rules. To add lifecycle rules for a bucket, call GetBucketLifecycle to obtain the existing lifecycle configurations of the bucket, add new lifecycle configurations, and call PutBucketLifecycle to update the lifecycle configurations for the bucket.

  • Number of lifecycle rules

    You can configure up to 100 lifecycle rules for each bucket in the OSS console and up to 1,000 lifecycle rules for each bucket by using the command-line tool ossutil.

  • Effective time

    After you configure a lifecycle rule, OSS loads the rule within 24 hours. After the lifecycle rule is loaded, OSS runs the rule every day at 08:00:00 (UTC+8).

    The interval between the last modified time of an object and the time when the lifecycle rule is run must be longer than 24 hours. For example, if you configure a lifecycle rule for a bucket to delete objects one day after they are uploaded, objects that are uploaded on July 20, 2020 are deleted on a different date based on the specific time when the objects are uploaded.

    • Objects uploaded before 08:00:00 (UTC+8) are deleted from 08:00:00 (UTC+8) on July 21, 2020 to 08:00:00 (UTC+8) on July 22, 2020.
    • Objects uploaded after 08:00:00 (UTC+8) are deleted from 08:00:00 (UTC+8) on July 22, 2020 to 08:00:00 (UTC+8) on July 23, 2020.
    Important When you update a lifecycle rule, tasks that are scheduled to be performed based on the rule on the current day are suspended. We recommend that you do not frequently update lifecycle rules.
  • Configure a lifecycle rule for a bucket for which the OSS-HDFS service is enabled

    To configure or modify a lifecycle rule to match all objects in a bucket for which the OSS-HDFS service is enabled, use the NOT element to exclude the objects that are stored in the .dlsdata/ directory. This helps prevent object deletion operations or storage class conversion operations that are triggered by the lifecycle rule from affecting data read and write operations on OSS-HDFS data.

    lifecycle

Elements in a lifecycle rule

A lifecycle rule consists of the following elements:
  • Policy: the policy that is used to match objects and parts.
    • Match by prefix: Objects and parts are matched by prefix. You can create multiple lifecycle rules to configure different prefixes. Each prefix must be unique. The naming conventions for prefixes are the same as the naming conventions for objects. For more information, see Object.
    • Match by tag: Objects are matched by tag key and tag value. You can specify multiple tags in a single lifecycle rule. The lifecycle rule applies to all objects that contain the specified tags. Lifecycle rules cannot match parts by tag.
      Note For more information, see Object tagging.
    • Match by prefix and tag: Objects are matched by specified prefixes and tags.
    • Match by bucket: All objects and parts that are stored in the bucket are matched.
    • The Not element specifies the prefix in the names of objects and the tags of objects to which you do not want the lifecycle rule to apply when you use the lifecycle rule to process the objects whose names contain a specific prefix and that contain specific tags. For more information about how to configure the NOT element, see the "NOT" section of this topic.
      Important You can configure only one NOT element for a lifecycle rule. You must configure only one prefix for the NOT element. In addition, you can configure up to one object tag for the NOT element or leave it empty.
  • Object lifecycle policy: the policy that is used to specify the validity period or expiration date for objects and the operation that you want to perform on expired objects.
    • Validity period: A validity period is specified for objects in buckets for which versioning is disabled and the current versions of objects in buckets for which versioning is enabled. The operation that you want to perform on the objects after they expire is also specified. Objects that match the lifecycle rule are retained for the specified validity period after the objects are last modified. The specified operation is performed on these objects after they expire.
    • Expiration date: An expiration date is specified for objects in buckets for which versioning is disabled and the current versions of objects in buckets for which versioning is enabled. The operation that you want to perform on these objects after they expire is also specified. All objects that are last modified before this date expire, and the specified operation is performed on these objects.
    • Validity period of the previous versions of objects: A validity period is specified for the previous versions of objects. In addition, the operation to perform on these previous versions is specified. Objects that match the lifecycle rule are retained for the specified validity period after the objects are last modified. The specified operation is performed on these objects after they expire.

    You can configure lifecycle rules to convert the storage class of expired objects or delete expired objects. For more information, see Configuration elements.

  • Part lifecycle policy: the policy that is used to specify the validity period or expiration date for parts and the operation that you want to perform on these expired parts.
    • Validity period: A validity period is specified for parts. Parts that match the lifecycle rule are retained within the specified validity period and are deleted after they expire.
    • Expiration date: An expiration date is specified for parts. Parts that are last modified before this date expire and are deleted.

Rule description

  • Different prefixes are specified in the same lifecycle rule
    For example, the following objects are stored in a bucket:
    logs/programl/log1.txt
    logs/program2/log2.txt
    logs/program3/log3.txt
    doc/readme.txt

    If the prefix specified by a rule is logs/, the rule applies to the first three objects whose names are prefixed with logs/. If the prefix specified by a rule is doc/readme.txt, the rule applies only to the doc/readme.txt object.

    When the GetObject or HeadObject operation is performed on an object that matches a lifecycle rule, the x-oss-expiration header is contained in the response. This header contains two parameters: expiry-date that specifies the expiration date of the object, and rule-id that specifies the ID of the matched lifecycle rule.

  • Same prefix and tags are specified in multiple lifecycle rules

    When objects that have the same prefix and tags match multiple lifecycle rules at the same time, lifecycle rules that are configured to delete objects take precedence over lifecycle rules that are configured to convert the storage class of objects. For example, both rule1 and rule2 described in the following table apply to objects whose names contain the abc prefix and have the a=1 tag. rule1 is configured to delete matched objects 20 days after they are last modified. rule2 is configured to convert the storage class of matched objects to Archive 20 days after they are last modified. If rule1 and rule2 are configured for a bucket at the same time, rule2 does not take effect.

    rule prefix tag action
    rule1 abc a=1 Delete matched objects 20 days after they are last modified.
    rule2 abc a=1 Convert the storage class of matched objects to Archive 20 days after they are last modified.
  • Overlapping prefixes and same tags are specified in multiple lifecycle rules

    For example, rule1 described in the following table applies to all objects that have the a=1 tag and is configured to convert the storage class of matched objects to IA 10 days after they are last modified. rule2 described in the following table applies to all objects whose names contain the abc prefix and have the a=1 tag. rule2 is configured to delete matched objects 120 days after they are last modified.

    rule prefix tag action
    rule1 - a=1 Convert the storage class of matched objects to IA 10 days after they are last modified.
    rule2 abc a=1 Delete matched objects 120 days after they are last modified.

    rule3 described in the following table applies to all objects that have the a=1 tag and is configured to convert the storage class of matched objects to Archive 20 days after they are last modified. rule4 described in the following table applies to objects whose names contain the abc prefix and have the a=1 tag and is configured to convert the storage class of matched objects to IA 30 days after they are last modified. If rule3 and rule4 are configured for a bucket at the same time, the storage class of objects whose names contain the abc prefix and have the a=1 tag is converted to Archive 20 days after they are last modified based on rule3 first. Archive objects cannot be converted to IA objects. Therefore, rule4 does not take effect.

    rule prefix tag action
    rule3 - a=1 Convert the storage class of matched objects to Archive 20 days after they are last modified.
    rule4 abc a=1 Convert the storage class of matched objects to IA 30 days after they are last modified.
  • NOT

    If you configure multiple lifecycle rules for a bucket and one of these rules contains the NOT element, the actions specified by the rule that contains the NOT element are performed only on objects that match the rule. The following section provides configuration examples:

    • Example 1
      • A lifecycle rule is configured to delete objects whose names contain the dir/ prefix in a bucket named examplebucket 100 days after the objects are last modified.
      • Another lifecycle rule that contains the NOT element is configured to delete all objects whose names do not contain the dir/ prefix in a bucket named examplebucket 50 days after the objects are last modified.

      The following table describes how objects in the examplebucket bucket are deleted after the preceding two lifecycle rules take effect.

      Object Action
      Objects with the dir/ prefix in their names Delete matched objects 100 days after they are last modified.
      Objects without the dir/ prefix in their names Delete matched objects 50 days after they are last modified.
    • Example 2
      • A lifecycle rule that contains the NOT element is configured to delete all objects that do not have TagA (key1:value1) in a bucket named examplebucket 30 days after the objects are last modified.
      • Another lifecycle rule is configured to delete objects that have TagB (key2:value2) in a bucket named examplebucket 50 days after the objects are last modified.

      The following table describes how objects in the examplebucket bucket are deleted after the preceding two lifecycle rules take effect.

      Object Action
      All objects that do not have TagA or TagB Delete matched objects 30 days after they are last modified.
      Objects that have only TagA Do not delete matched objects.
      Objects that have only TagB Delete matched objects 30 days after they are last modified.
      Objects that have TagA and TagB Delete matched objects 50 days after they are last modified.

Use the OSS console

  1. Log on to the OSS console.
  2. In the left-side navigation pane, click Buckets. On the Buckets page, click the name of the desired bucket.
  3. In the left-side navigation tree, choose Data Management > Lifecycle.
  4. On the Lifecycle page, click Create Rule.
    Note If you want to create lifecycle rules based only on the last modified time of objects, do not turn on Enable access tracking on the Lifecycle page. You are charged when you use access tracking. Access tracking is suitable for lifecycle rules based on the last access time. For more information, see Lifecycle rules based on the last access time.
  5. In the Create Rule panel, configure the parameters. The following table describes the parameters.
    • Parameters for unversioned buckets
      Section Parameter Description
      Basic Settings Status

      Specify the status of the lifecycle rule. Valid values: Enabled and Disabled.

      Applied To

      Specify the objects on which you want the lifecycle rule to take effect. Valid values: Files with Specified Prefix and Whole Bucket.

      Allow Overlapped Prefixes
      By default, OSS checks whether the prefixes of each lifecycle rule overlap. For example, you configure the following lifecycle rules that contain overlapping prefixes:
      • Rule 1

        All objects whose names contain the dir1/ prefix in the bucket are deleted 180 days after the objects are last modified.

      • Rule 2

        All objects whose names contain the dir1/dir2/ prefix in the bucket are converted to IA objects 30 days after the objects are last modified, and deleted after 60 days.

      If you do not select this parameter, OSS determines that objects in the dir1/dir2/ directory match two deletion rules. Therefore, the two lifecycle rules are rejected and an error Overlap for same action type Expiration. is reported.

      If you select this parameter, the objects in the dir1/dir2/ directory are converted to IA objects after 30 days and deleted after 60 days. Other objects in the dir1/ directory are deleted after 180 days.

      Prefix
      Specify the prefix in the names of objects on which you want the lifecycle rule to take effect.
      • If you set the prefix to img, all objects whose names start with img, such as imgtest.png and img/example.jpg, match the lifecycle rule.
      • If you set the prefix to img/, all objects whose names start with img/, such as img/example.jpg and img/test.jpg, match the lifecycle rule.
      Tagging

      Specify tags. The rule takes effect only on objects that contain the specified tags. For example, if you select Files with Specified Prefix and set Prefix to img, Key to a, and Value to 1, the rule takes effect only on all objects that contain the img prefix in their names and contain the a=1 tag. For more information about object tagging, see Object tagging.

      NOT

      The NOT parameter is used to specify that the lifecycle rule does not take effect on the objects that contain the specified prefix and tag.

      Important
      • If you enable NOT, each lifecycle rule must contain at least one of the prefix and tags of an object.
      • The key of the tag specified by the NOT syntax cannot be the same as the key specified by the Tagging parameter.
      • If you enable NOT, lifecycle rules that apply to parts cannot be configured.
      Policy for Objects File Lifecycle

      Configure rules for objects to specify when the objects expire. You can set File Lifecycle to Validity Period (Days), Expiration Date, or Disabled. If you select Disabled, the configurations of File Lifecycle do not take effect.

      Lifecycle-based Rules

      Configure the policy to convert the storage class of objects or delete expired objects.

      Example 1: If you select Access Time, set Validity Period (Days) to 30, and specify that the storage class of the objects is converted to IA (Not Converted After Access) after the validity period is elapsed. In this case, the storage class of objects that were last accessed on September 1, 2021 is converted to Infrequent Access (IA) on October 1, 2021.

      Note If you configure a lifecycle rule based on the last access time, you can specify that the rule takes effect only on objects that are larger than 64 KB in size or on all objects in the bucket.

      Example 2: If you select Modified Time, set Expiration Date to September 24, 2021, and specify that objects that are last modified before this date are deleted. In this case, objects that are last modified before September 24, 2021 are automatically deleted. The deleted objects cannot be recovered.

      Policy for Parts Part Lifecycle

      Specify the operations that you want to perform on expired parts. If you select Tagging, this parameter is unavailable. You can select Validity Period (Days), Expiration Date, or Disabled. If you select Disabled, the configurations of Part Lifecycle do not take effect.

      Important Each lifecycle rule must contain at least one of the object expiration policies and part expiration policies.
      Rules for Parts

      Specify when parts expire based on the value of Part Lifecycle. Expired parts are automatically deleted and cannot be recovered.

    • Parameters for versioned buckets

      Configure the parameters in the Basic Settings section and Policy for Parts section in the same way as the parameters configured for unversioned buckets. The following table describes only the parameters that are different from the parameters that you configure for unversioned buckets.

      Section Parameter Description
      Policy for Current Versions Clean Up Delete Marker

      If you enable versioning for the bucket, you can configure the Clean Up Delete Marker parameter. Other parameters are the same as those you can configure for unversioned buckets.

      If you select Clean Up Delete Marker, and an object has only one version which is a delete marker, OSS considers the delete marker expired and removes the delete marker. If an object has multiple versions and the current version of the object is a delete marker, OSS retains the delete marker. For more information about delete makers, see Delete marker.

      Policy for Previous Versions File Lifecycle

      Specify when previous versions expire. Valid values: Validity Period (Days) and Disabled. If you select Disabled, File Lifecycle does not take effect.

      Lifecycle-based Rules

      Specify the number of days within which objects can be retained after the objects become previous versions. After the objects expire, the specified operations are performed on the previous versions the next day. For example, if you set Validity Period (Days) to 30, the objects that become previous versions on September 1, 2021 are converted to the specified storage class or deleted on October 1, 2021.

      Important You can determine when an object becomes a previous version based on the time when the next version of the object is last modified.
  6. Click OK.
    After a lifecycle rule is saved, you can view the rule in the lifecycle rule list.

Use ossbrowser

The operations that you can perform on buckets in ossbrowser are the same as the operations that you can perform on buckets in the OSS console. You can follow the on-screen instructions in ossbrowser to configure lifecycle rules for buckets. For more information about how to use ossbrowser, see Use ossbrowser.

Use OSS SDKs

The following code provides examples on how to configure lifecycle rules by using OSS SDKs for common programming languages. For more information about the sample code to configure lifecycle rules by using OSS SDKs for other programming languages, see Overview.

OSS ossClient = null;
try {
    // Set yourEndpoint to the endpoint of the region in which the bucket is located. For example, if the bucket is located in the China (Hangzhou) region, set yourEndpoint to https://oss-cn-hangzhou.aliyuncs.com. 
    String endpoint = "yourEndpoint";
    // Security risks may arise if you use the AccessKey pair of an Alibaba Cloud account to access OSS because the account has permissions on all API operations. We recommend that you use a Resource Access Management (RAM) user to call API operations or perform routine O&M. To create a RAM user, log on to the RAM console. 
    String accessKeyId = "yourAccessKeyId";
    String accessKeySecret = "yourAccessKeySecret";
    // Specify the name of the bucket for which you want to configure a lifecycle rule. Example: examplebucket. 
    String bucketName = "examplebucket";

    // Create an OSSClient instance. 
    ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);

    // Create a request by using SetBucketLifecycleRequest. 
    SetBucketLifecycleRequest request = new SetBucketLifecycleRequest(bucketName);

    // Specify the ID for the lifecycle rule. 
    String ruleId0 = "rule0";
    // Specify the prefix that you want the lifecycle rule to match. 
    String matchPrefix0 = "A0/";
    // Specify the tag that you want the lifecycle rule to match. 
    Map<String, String> matchTags0 = new HashMap<String, String>();
    // Specify the key and value of the object tag. Example: the key is owner, and the value is 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/";

    // Set the expiration time to three days after the last modified time. 
    LifecycleRule rule = new LifecycleRule(ruleId0, matchPrefix0, LifecycleRule.RuleStatus.Enabled, 3);
    rule.setTags(matchTags0);
    request.AddLifecycleRule(rule);

    // Specify that objects that are created before the expiration date expire. 
    rule = new LifecycleRule(ruleId1, matchPrefix1, LifecycleRule.RuleStatus.Enabled);
    rule.setCreatedBeforeDate(DateUtil.parseIso8601Date("2022-10-12T00:00:00.000Z"));
    rule.setTags(matchTags1);
    request.AddLifecycleRule(rule);

    // Set the expiration time to three days for parts of an object. 
    rule = new LifecycleRule(ruleId2, matchPrefix2, LifecycleRule.RuleStatus.Enabled);
    LifecycleRule.AbortMultipartUpload abortMultipartUpload = new LifecycleRule.AbortMultipartUpload();
    abortMultipartUpload.setExpirationDays(3);
    rule.setAbortMultipartUpload(abortMultipartUpload);
    request.AddLifecycleRule(rule);

    // Specify that parts that are created before the expiration date expire. 
    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);

    // Specify that the storage class of objects is converted to IA 10 days after they are last modified, and to Archive 30 days after they are last modified. 
    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);

    // Specify that the storage class of objects that are last modified before October 12, 2022 is converted to Archive. 
    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);

    // Specify that rule6 is configured for versioned buckets. 
    rule = new LifecycleRule(ruleId6, matchPrefix6, LifecycleRule.RuleStatus.Enabled);
    // Specify that the storage class of objects is converted to Archive 365 days after the objects are last modified. 
    storageTransitions = new ArrayList<LifecycleRule.StorageTransition>();
    storageTransition = new LifecycleRule.StorageTransition();
    storageTransition.setStorageClass(StorageClass.Archive);
    storageTransition.setExpirationDays(365);
    storageTransitions.add(storageTransition);
    rule.setStorageTransition(storageTransitions);
    // Configure the lifecycle rule to automatically delete expired delete markers. 
    rule.setExpiredDeleteMarker(true);
    // Configure the lifecycle rule to convert the previous versions of objects to the IA storage class 10 days after the objects are last modified. 
    LifecycleRule.NoncurrentVersionStorageTransition noncurrentVersionStorageTransition =
            new LifecycleRule.NoncurrentVersionStorageTransition().withNoncurrentDays(10).withStrorageClass(StorageClass.IA);
    // Specify that the storage class of the previous versions of objects is converted to Archive 20 days after the objects are last modified. 
    LifecycleRule.NoncurrentVersionStorageTransition noncurrentVersionStorageTransition2 =
            new LifecycleRule.NoncurrentVersionStorageTransition().withNoncurrentDays(20).withStrorageClass(StorageClass.Archive);
    // Specify that the previous versions of objects are deleted 30 days after the objects become previous versions. 
    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);

    // Initiate a request to configure lifecycle rules. 
    ossClient.setBucketLifecycle(request);

    // Query the lifecycle rules configured for the bucket. 
    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){
        // Shut down the OSSClient instance. 
        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;

// The AccessKey pair of an Alibaba Cloud account has permissions on all API operations. Using these credentials to perform operations in OSS is a high-risk operation. We recommend that you use a RAM user to call API operations or perform routine O&M. To create a RAM user, log on to the RAM console. 
$accessKeyId = "yourAccessKeyId";
$accessKeySecret = "yourAccessKeySecret";
// In this example, the endpoint of the China (Hangzhou) region is used. Specify your actual endpoint. 
$endpoint = "https://oss-cn-hangzhou.aliyuncs.com";
// Specify the name of the bucket. 
$bucket= "yourBucketName";

// Specify the rule ID and the prefix of the object names that match the rule. 
$ruleId0 = "rule0";
$matchPrefix0 = "A0/";
$ruleId1 = "rule1";
$matchPrefix1 = "A1/";

$lifecycleConfig = new LifecycleConfig();
$actions = array();
// Specify that objects expire three days after they are last modified. 
$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();
// Specify that objects created before the specified date expire. 
$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({
  // Specify the region in which the bucket is located. For example, if the bucket is located in the China (Hangzhou) region, set the region to oss-cn-hangzhou. 
  region: 'yourregion',
  // The AccessKey pair of an Alibaba Cloud account has permissions on all API operations. Using these credentials to perform operations in OSS is a high-risk operation. We recommend that you use a RAM user to call API operations or perform routine O&M. To create a RAM user, log on to the RAM console. 
  accessKeyId: 'yourAccessKeyId',
  accessKeySecret: 'yourAccessKeySecret',
  // Set yourbucketname to the name of your bucket. 
  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 // Specify that the current versions of objects expire three days after they are last modified. 
  }
}
putBucketLifecycle(lifecycle1)

const lifecycle2 = {
  id: 'rule2',
  status: 'Enabled',
  prefix: 'foo/', 
  expiration: {
    createdBeforeDate: '2020-02-18T00:00:00.000Z' // Specify that objects created before the specified date expire. 
  },
}
putBucketLifecycle(lifecycle2)

const lifecycle3 = {
  id: 'rule3',
  status: 'Enabled',
  prefix: 'foo/', 
  abortMultipartUpload: {
    days: 3 // Specify that parts expire three days after they are last modified. 
  },
}
putBucketLifecycle(lifecycle3)

const lifecycle4 = {
  id: 'rule4',
  status: 'Enabled',
  prefix: 'foo/', 
  abortMultipartUpload: {
    createdBeforeDate: '2020-02-18T00:00:00.000Z' // Specify that parts created before the specified date expire. 
  },
}
putBucketLifecycle(lifecycle4)

const lifecycle5 = {
  id: 'rule5',
  status: 'Enabled',
  prefix: 'foo/', 
  transition: {
    // Specify that the storage class of the current versions of objects is converted to Archive 20 days after they are last modified. 
    days: 20,
    storageClass: 'Archive'
  },
  expiration: {
    days: 21 // Specify that the current versions of objects expire 21 days after they are last modified. 
  },
}
putBucketLifecycle(lifecycle5)

const lifecycle6 = {
  id: 'rule6',
  status: 'Enabled',
  prefix: 'foo/', 
  transition: {
    // Specify that the storage class of the objects that are last modified before the specified date is converted to Archive. 
    createdBeforeDate: '2020-02-18T00:00:00.000Z', // Specify that the conversion date is earlier than the expiration date. 
    storageClass: 'Archive'
  },
  expiration: {
    createdBeforeDate: '2020-02-19T00:00:00.000Z' // Specify that objects created before the specified date expire. 
  },
}
putBucketLifecycle(lifecycle6)

const lifecycle7 = {
  id: 'rule7',
  status: 'Enabled',
  prefix: 'foo/', 
  noncurrentVersionExpiration: {
    noncurrentDays: 1 // Specify that objects expire one day after they become previous versions. 
  },
}
putBucketLifecycle(lifecycle7)

const lifecycle8 = {
  id: 'rule8',
  status: 'Enabled',
  prefix: 'foo/', 
  expiredObjectDeleteMarker: true // Specify that delete markers are automatically removed when they expire. 
}
putBucketLifecycle(lifecycle8)

const lifecycle9 = {
  id: 'rule9',
  status: 'Enabled',
  prefix: 'foo/', 
  // Specify that the storage class of objects is converted to IA 10 days after they become previous versions. 
  noncurrentVersionTransition: {
    noncurrentDays: '10',
    storageClass: 'IA'
  }
}
putBucketLifecycle(lifecycle9)

const lifecycle10 = {
  id: 'rule10',
  status: 'Enabled',
  prefix: 'foo/', 
  // Specify that the storage class of objects is converted to IA 10 days after they become previous versions. 
  noncurrentVersionTransition: {
    noncurrentDays: '10',
    storageClass: 'IA'
  },
  // Specify object tags that match the rules. 
  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)

# The AccessKey pair of an Alibaba Cloud account has permissions on all API operations. Using these credentials to perform operations in OSS is a high-risk operation. We recommend that you use a RAM user to call API operations or perform routine O&M. To create a RAM user, log on to the RAM console. 
auth = oss2.Auth('yourAccessKeyId', 'yourAccessKeySecret')
# Specify the endpoint of the region in which the bucket is located. For example, if the bucket is located in the China (Hangzhou) region, set the endpoint to https://oss-cn-hangzhou.aliyuncs.com. 
# Set yourBucketName to the name of your bucket. Example: examplebucket. 
bucket = oss2.Bucket(auth, 'http://oss-cn-hangzhou.aliyuncs.com', 'examplebucket')

# Specify that objects expire three days after they are last modified. 
rule1 = LifecycleRule('rule1', 'tests/',
                      status=LifecycleRule.ENABLED,
                      expiration=LifecycleExpiration(days=3))

# Specify that the objects created before the specified date expire. 
rule2 = LifecycleRule('rule2', 'tests2/',
                      status=LifecycleRule.ENABLED,
expiration=LifecycleExpiration(created_before_date=datetime.date(2022, 12, 12)))

# Specify that parts expire three days after they are last modified. 
rule3 = LifecycleRule('rule3', 'tests3/',
                      status=LifecycleRule.ENABLED,
            abort_multipart_upload=AbortMultipartUpload(days=3))

# Specify that the parts created before the specified date expire. 
rule4 = LifecycleRule('rule4', 'tests4/',
                      status=LifecycleRule.ENABLED,
                      abort_multipart_upload = AbortMultipartUpload(created_before_date=datetime.date(2022, 12, 12)))

# Specify that the storage classes of objects are converted to Infrequent Access (IA) 20 days after they are last modified, and to Archive 30 days after they are last modified. 
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)])

# Specify tags that match the rules. 
tagging_rule = TaggingRule()
tagging_rule.add('key1', 'value1')
tagging_rule.add('key2', 'value2')
tagging = Tagging(tagging_rule)

# Specify that the storage classes of objects are converted to Archive 365 days after they are last modified.  
# Compared with the preceding rules, rule6 specifies tags that match the rule. The rule applies to objects whose tagging configurations are key1=value1 and key2=value2. 
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)

# Specify that rule7 is configured for versioned buckets. 
# Specify that the storage classes of objects are converted to Archive 365 days after they are last modified. 
# Specify that delete markers are automatically removed when they expire. 
# Specify that the storage classes of objects are converted to IA 12 days after they become previous versions. 
# Specify that the storage classes of objects are converted to Archive 20 days after they become previous versions. 
# Specify that objects are deleted 30 days after they become previous versions. 
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;
// Specify the endpoint of the region in which the bucket is located. For example, if the bucket is located in the China (Hangzhou) region, set the endpoint to https://oss-cn-hangzhou.aliyuncs.com. 
var endpoint = "https://oss-cn-hangzhou.aliyuncs.com";
// The AccessKey pair of an Alibaba Cloud account has permissions on all API operations. Using these credentials to perform operations in OSS is a high-risk operation. We recommend that you use a RAM user to call API operations or perform routine O&M. To create a RAM user, log on to the RAM console. 
var accessKeyId = "yourAccessKeyId";
var accessKeySecret = "yourAccessKeySecret";
// Specify the name of the bucket. Example: examplebucket. 
var bucketName = "examplebucket";

// Create an OSSClient instance. 
var client = new OssClient(endpoint, accessKeyId, accessKeySecret);
try
{
    var setBucketLifecycleRequest = new SetBucketLifecycleRequest(bucketName);
    // Create the first lifecycle rule. 
    LifecycleRule lcr1 = new LifecycleRule()
    {
        ID = "delete obsoleted files",
        Prefix = "obsoleted/",
        Status = RuleStatus.Enabled,
        ExpriationDays = 3,
        Tags = new Tag[1]
    };
    // Specify tags for the first rule. 
    var tag1 = new Tag
    {
        Key = "project",
        Value = "projectone"
    };

    lcr1.Tags[0] = tag1;

    // Create the second lifecycle rule. 
    LifecycleRule lcr2 = new LifecycleRule()
    {
        ID = "delete temporary files",
        Prefix = "temporary/",
        Status = RuleStatus.Enabled,
        ExpriationDays = 20,
        Tags = new Tag[1]         
    };
    // Specify tags for the second rule. 
    var tag2 = new Tag
    {
        Key = "user",
        Value = "jsmith"
    };
    lcr2.Tags[0] = tag2;

    // Specify that parts expire 30 days after they are last modified. 
    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]
    {
        // Specify that the storage class of the previous versions of objects is converted to IA 90 days after they are last modified. 
        new LifecycleRule.LifeCycleNoncurrentVersionTransition(){
            StorageClass = StorageClass.IA,
            NoncurrentDays = 90
        },
        // Specify that the storage class of the previous versions of objects is converted to Archive 180 days after they are last modified. 
        new LifecycleRule.LifeCycleNoncurrentVersionTransition(){
            StorageClass = StorageClass.Archive,
            NoncurrentDays = 180
        }
    };
    setBucketLifecycleRequest.AddLifecycleRule(lcr1);
    setBucketLifecycleRequest.AddLifecycleRule(lcr2);
    setBucketLifecycleRequest.AddLifecycleRule(lcr3);

    // Configure the lifecycle rules. 
    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();
// Specify the rule ID and the prefix of the object names that match the rule. 
rule1.setIdentifier("1");
rule1.setPrefix("A");
// Specify whether to run the lifecycle rule. If this parameter is set to true, OSS periodically runs this rule. If this parameter is set to false, OSS ignores this rule. 
rule1.setStatus(true);
// Specify that objects expire 200 days after they are last modified. 
rule1.setDays("200");
// Specify that the storage class of objects is converted to Archive 30 days after they are last modified.
rule1.setArchiveDays("30");
// Specify that parts expire three days after they fail to be uploaded. 
rule1.setMultipartDays("3");
// Specify that the storage class of objects is converted to IA 15 days after they are last modified. 
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() {
    // Create an OSSClient instance. 
    // Specify the endpoint of the region in which the bucket is located. For example, if the bucket is located in the China (Hangzhou) region, set the endpoint to https://oss-cn-hangzhou.aliyuncs.com. Specify your actual endpoint. 
    // The AccessKey pair of an Alibaba Cloud account has permissions on all API operations. Using these credentials to perform operations in OSS is a high-risk operation. We recommend that you use a RAM user to call API operations or perform routine O&M. To create a RAM user, log on to the RAM console. 
    client, err := oss.New("yourEndpoint", "yourAccessKeyId", "yourAccessKeySecret")
    if err != nil {
        fmt.Println("Error:", err)
        os.Exit(-1)
    }

    // Create a lifecycle rule and set ID to rule1 for the bucket. Specify that the objects whose names contain the foo prefix in the bucket expire three days after the objects are last modified. 
    rule1 := oss.BuildLifecycleRuleByDays("rule1", "foo/", true, 3)

    // If an object in a bucket for which versioning is enabled is a delete marker and has no other versions, the delete marker is deleted. 
    deleteMark := true
    expiration := oss.LifecycleExpiration{
        ExpiredObjectDeleteMarker: &deleteMark,
    }

    // Specify that the previous versions of the objects are deleted 30 days after the objects are last modified. 
    versionExpiration := oss.LifecycleVersionExpiration{
        NoncurrentDays: 30,
    }

    // Specify that the storage class of the previous versions of the objects is converted to IA 10 days after the objects are last modified. 
    versionTransition := oss.LifecycleVersionTransition{
        NoncurrentDays: 10,
        StorageClass:   "IA",
    }

    // Create a lifecycle rule and set ID to rule2. 
    rule2 := oss.LifecycleRule{
        ID:                   "rule2",
        Prefix:               "yourObjectPrefix",
        Status:               "Enabled",
        Expiration:           &expiration,
        NonVersionExpiration: &versionExpiration,
        NonVersionTransition: &versionTransition,
    }

    // Create a lifecycle rule and set ID to rule3. This rule applies to objects that have the tag whose key is tag1 and whose value is value1. These objects expire three days after the objects are last modified. 
    rule3 := oss.LifecycleRule{
        ID:     "rule3",
        Prefix: "",
        Status: "Enabled",
        Tags: []oss.Tag{
            oss.Tag{
                Key:   "tag1",
                Value: "value1",
            },
        },
        Expiration: &oss.LifecycleExpiration{Days: 3},
    }

    // Configure the lifecycle rules. 
    rules := []oss.LifecycleRule{rule1, rule2, rule3}
    // Specify the name of the bucket. Example: 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)
{
    /* Initialize the account information. */
    /* Security risks may arise if you use the AccessKey pair of an Alibaba Cloud account to access OSS because the account has permissions on all API operations. We recommend that you use a RAM user to call API operations or perform routine O&M. To create a RAM user, log on to the RAM console. */
    std::string AccessKeyId = "yourAccessKeyId";
    std::string AccessKeySecret = "yourAccessKeySecret";
    /* Set yourEndpoint to the endpoint of the region in which the bucket is located. For example, if the bucket is located in the China (Hangzhou) region, set Endpoint to https://oss-cn-hangzhou.aliyuncs.com. */
    std::string Endpoint = "yourEndpoint";
    /* Specify the name of the bucket. Example: examplebucket. */
    std::string BucketName = "examplebucket";

    /* Initialize resources such as network resources. */
    InitializeSdk();

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

    /* View the lifecycle rules. */
    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;
            }

            /* View the lifecycle rules to check whether expired delete markers are automatically deleted. */
            if (rule.ExpiredObjectDeleteMarker()) {
                std::cout << "rule expired delete marker: " << rule.ExpiredObjectDeleteMarker() << std::endl;
            }

            /* View the configurations used to convert the storage class of previous versions of the objects. */
            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;    
                }
            }

            /* View the expiration configurations for the previous versions of the objects. */
            if (rule.hasNoncurrentVersionExpiration()) {
                std::cout << "rule noncurrent versions expiration days:" << rule.NoncurrentVersionExpiration().Days() << std::endl;
            }

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

    /* Release resources such as networks. */
    ShutdownSdk();
    return 0;
}
#include "oss_api.h"
#include "aos_http_io.h"
/* Specify the endpoint of the region in which the bucket is located. For example, if the bucket is located in the China (Hangzhou) region, set the endpoint to https://oss-cn-hangzhou.aliyuncs.com. */
const char *endpoint = "yourEndpoint";
/* The AccessKey pair of an Alibaba Cloud account has permissions on all API operations. Using these credentials to perform operations in OSS is a high-risk operation. We recommend that you use a RAM user to call API operations or perform routine O&M. To create a RAM user, log on to the RAM console. */
const char *access_key_id = "yourAccessKeyId";
const char *access_key_secret = "yourAccessKeySecret";
/* Specify the bucket name. Example: examplebucket. */
const char *bucket_name = "examplebucket";
void init_options(oss_request_options_t *options)
{
    options->config = oss_config_create(options->pool);
    /* Use a char* string to initialize the aos_string_t data type. */
    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);
    /* Specify whether to use CNAME to access OSS. The value 0 indicates that CNAME is not used. */
    options->config->is_cname = 0;
    /* Configure network parameters such as the timeout period. */
    options->ctl = aos_http_controller_create(options->pool, 0);
}
int main(int argc, char *argv[])
{
    /* Call the aos_http_io_initialize method in main() to initialize global resources such as networks and memory. */
    if (aos_http_io_initialize(NULL, 0) != AOSE_OK) {
        exit(1);
    }
    /* Create a memory pool to manage memory. aos_pool_t is equivalent to apr_pool_t. The code used to create a memory pool is included in the APR library. */
    aos_pool_t *pool;
    /* Create a memory pool. The value of the second parameter is NULL. This value indicates that the pool does not inherit other memory pools. */
    aos_pool_create(&pool, NULL);
    /* Create and initialize options. This parameter includes global configuration information such as endpoint, access_key_id, access_key_secret, is_cname, and curl. */
    oss_request_options_t *oss_client_options;
    /* Allocate the memory resources in the memory pool to the options. */
    oss_client_options = oss_request_options_create(pool);
    /* Initialize oss_client_options. */
    init_options(oss_client_options);
    /* Initialize the parameters. */
    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;
    /* Create lifecycle rules for the bucket. */
    aos_str_set(&bucket, bucket_name);
    aos_list_init(&lifecycle_rule_list);
    /* Specify the validity period. */
    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);
    /* Specify the expiration date. */
    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);
    /* Configure the lifecycle rules. */
    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);
    }
    /* Release the memory pool. This operation releases the memory resources allocated for the request. */
    aos_pool_destroy(pool);
    /* Release the allocated global resources. */
    aos_http_io_deinitialize();
    return 0;
}
require 'aliyun/oss'
client = Aliyun::OSS::Client.new(
  # In this example, the endpoint of the China (Hangzhou) region is used. Specify your actual endpoint. 
  endpoint: 'https://oss-cn-hangzhou.aliyuncs.com',
  # The AccessKey pair of an Alibaba Cloud account has permissions on all API operations. Using these credentials to perform operations in OSS is a high-risk operation. We recommend that you use a RAM user to call API operations or perform routine O&M. To create a RAM user, log on to the RAM console. 
  access_key_id: 'AccessKeyId', access_key_secret: 'AccessKeySecret')
  # Specify the name of the bucket. 
  bucket = client.get_bucket('examplebucket')
# Configure lifecycle rules. 
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))
]

Use ossutil

For more information about how to configure lifecycle rules by using ossutil, see Add or modify lifecycle rules.

Use RESTful APIs

If your business requires a high level of customization, you can directly call RESTful APIs. To directly call an API, you must include the signature calculation in your code. For more information, see PutBucketLifecycle.

FAQ

  • Does OSS impose limits on the minimum storage duration of objects whose storage class is converted by using CopyObject?
    Yes, OSS imposes limits on the minimum storage duration of IA, Archive, and Cold Archive objects. For example, if you use CopyObject to convert the storage class of an IA object to Archive 10 days after the object is created, you are charged for the entire minimum storage duration of the IA object. In addition, the Last-Modified value of the object is updated to the time when the storage class of the object is converted. The converted Archive object must be stored for at least 60 days. Otherwise, you are charged for the minimum storage duration of Archive objects.
  • Does OSS generate logs when the storage class of objects is converted or expired objects are deleted based on lifecycle rules?
    Yes, OSS generates logs when the storage class of objects is converted or expired objects are deleted based on lifecycle rules. The logs include the following fields:
    • Operation
      • CommitTransition: indicates the storage class to which the object is converted based on lifecycle rules. Example: IA, Archive, or Cold Archive.
      • ExpireObject: indicates the expired objects that are deleted based on lifecycle rules.
    • Sync Request

      lifecycle: indicates the operations that are triggered by lifecycle rules, such as deleting expired objects and converting the storage class of objects.