Lifecycle rules based on last access time

1. Log on to the OSS console.

2. In the left-side navigation pane, click Buckets. On the Buckets page, find and click the desired bucket.

3. In the left-side navigation pane, choose Data Management > Lifecycle.

4. On the Lifecycle page, turn on the Enable Access Tracking switch, and then click Create Rule.

5. In the Create Lifecycle Rule panel, configure the lifecycle rule based on the following descriptions.

   • The bucket has versioning disabled

     Section	Parameter	Description
     Basic Settings	Status	Set the status of the lifecycle rule. You can select Enabled or Disabled. If you enable the lifecycle rule, OSS transitions the storage classes of data based on the rule. If you disable the lifecycle rule, the lifecycle task is suspended.
     	Applied To	Select the objects to which the lifecycle rule applies. You can select Objects with Specified Prefix or Whole Bucket.
     	Allow Overlapped Prefixes	By default, OSS checks whether the prefixes of lifecycle rules overlap. For example, you set the following two lifecycle rules with overlapping prefixes: Rule 1 Transitions all objects with the prefix dir1/ in the bucket to the Infrequent Access storage class 180 days after their last access time. Rule 2 Transitions all objects with the prefix dir1/dir2/ in the bucket to the Archive storage class 30 days after their last access time. If this option is not selected, OSS rejects this configuration because objects in the dir1/dir2/ directory would match both transition rules. If this option is selected, objects in the dir1/dir2/ directory are transitioned to the Archive storage class after 30 days. Other objects in the dir1/ directory are transitioned to the Infrequent Access storage class after 180 days.
     	Prefix	Enter the object prefix for the rule to match. If you set the prefix to img, the rule matches all objects whose names start with img, such as imgtest.png and img/example.jpg. If you set the prefix to img/, the rule matches all objects whose names start with img/, such as img/example.jpg and img/test.jpg.
     	Tag	The lifecycle rule applies only to objects with the specified tag. For example, if you select Objects with Specified Prefix, set the prefix to img, and set the tag key to a and value to 1, the rule matches all objects whose names start with img and that have the tag a=1. For more information about object tags, see Object tagging.
     	NOT	Use the NOT option to exclude objects that have a specified prefix and tag from the lifecycle rule. Important If the NOT option is enabled, you must specify at least a prefix or a tag. The key defined for the tag in the NOT condition cannot be the same as the key defined in the Tag parameter. If the NOT option is enabled, you cannot configure a part expiration policy.
     	Object Size	Specify the object size to which the lifecycle rule applies. Minimum Size: The lifecycle rule applies to objects larger than this value. The value must be greater than 0 B and less than 5 TB. Maximum Size: The lifecycle rule applies to objects smaller than this value. The value must be greater than 0 B and less than or equal to 5 TB. Important If you configure both Minimum size and Maximum size in the same lifecycle rule, take note of the following items: Make sure that the value of Maximum size is greater than the value of Minimum size. You cannot configure a part expiration policy. You cannot configure a policy to clear delete markers.
     Policy for Objects	Object Lifecycle	Select an expiration policy for objects. You can select Validity Period (Days), Expiration Date, or Disabled. If you select Disabled, the object expiration policy does not take effect.
     	Lifecycle-based Rules	Configure the rule to transition the storage class of objects. Data can be transitioned to the following storage classes: IA (Data Remains in IA After Access) IA (Data Is Converted to Standard After Access) Archive Cold Archive Deep Cold Archive For example, if you select the Access Time policy, set Validity Period (Days) to 30, and specify that data is automatically transitioned to IA (Data Remains in IA After Access) after the specified period, an object last accessed on September 1, 2021 is transitioned to that storage class on October 1, 2021.
     Policy for Parts	Part Lifecycle	Set the action to perform on expired parts. If you have specified a Tag, you cannot configure this parameter. You can select Validity Period (Days) or Expiration Date for the part expiration policy, or select Disabled. If you select Disabled, the part expiration policy does not take effect. Important A lifecycle rule must include at least an object expiration policy or a part expiration policy.
     	Rules for Parts	Specify when parts expire based on the validity period or expiration date selected in the part expiration policy. Expired parts are automatically deleted and cannot be recovered.

   • The bucket has versioning enabled

     After you enable versioning, the configuration items in the Basic Settings and Policy for Parts sections are configured in the same way as they are when versioning is disabled. The following table describes only the configuration differences when versioning is enabled.

     Section	Parameter	Description
     Policy for Current Versions	Clear delete markers	After versioning is enabled, the Clear Delete Markers option is added to the cleanup policy. Other options are the same as when versioning is disabled. If you select this option and the current version of an object is the only version and is a delete marker, OSS removes the delete marker of the expired object. If the object has multiple versions and the latest version is a delete marker, OSS retains the delete marker. For more information about delete markers, see Delete markers.
     Policy for Previous Versions	Object Lifecycle	Set the expiration policy for noncurrent versions of objects. You can select Validity Period (Days) or Disabled. If you select Disabled, the object expiration policy does not take effect.
     	Lifecycle-based Rules	Set a period of N days. After a noncurrent version of an object is accessed, it is transitioned to a different storage class after N days. For example, if you set the period to 30 days, a noncurrent version that is accessed on September 1, 2021 is transitioned to the specified storage class on October 1, 2021.

6. Click OK.

   After you save the rule, it appears in the policy list.

OSS SDKs for Java, Go, Python, and PHP support the creation of lifecycle rules based on last access time. Before you create a lifecycle rule based on last access time, you must enable access tracking for the specified bucket. For sample code, see SDK overview.

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

public class Demo {

    public static void main(String[] args) throws Exception {
        // In this example, the endpoint of the China (Hangzhou) region is used. Specify your actual endpoint. 
        String endpoint = "https://oss-cn-hangzhou.aliyuncs.com";
        // Obtain access credentials from environment variables. Before you run the sample code, make sure that the OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET environment variables are configured. 
        EnvironmentVariableCredentialsProvider credentialsProvider = CredentialsProviderFactory.newEnvironmentVariableCredentialsProvider();
        // Specify the name of the bucket. Example: examplebucket. 
        String bucketName = "examplebucket";
        // 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 cn-hangzhou.
        String region = "cn-hangzhou";

        // Create an OSSClient instance. 
        // Call the shutdown method to release resources when the OSSClient is no longer in use.
        ClientBuilderConfiguration clientBuilderConfiguration = new ClientBuilderConfiguration();
        clientBuilderConfiguration.setSignatureVersion(SignVersion.V4);        
        OSS ossClient = OSSClientBuilder.create()
        .endpoint(endpoint)
        .credentialsProvider(credentialsProvider)
        .clientConfiguration(clientBuilderConfiguration)
        .region(region)               
        .build();

        try {
            ossClient.putBucketAccessMonitor(bucketName, AccessMonitor.AccessMonitorStatus.Enabled.toString());
            // Create a lifecycle rule and set the ID to rule1. Specify that the storage classes of objects whose names contain the logs prefix and whose size is less than or equal to 64 KB are changed to IA 30 days after the objects are last accessed. In addition, specify that the objects whose name contain the logs prefix are still stored as IA objects when the objects are accessed again. 
            LifecycleRule lifecycleRule = new LifecycleRule("rule1", "logs", LifecycleRule.RuleStatus.Enabled);
            List<LifecycleRule> lifecycleRuleList = new ArrayList<LifecycleRule>();
            SetBucketLifecycleRequest setBucketLifecycleRequest = new SetBucketLifecycleRequest(bucketName);

            LifecycleRule.StorageTransition storageTransition = new LifecycleRule.StorageTransition();
            storageTransition.setStorageClass(StorageClass.IA);
            storageTransition.setExpirationDays(30);
            storageTransition.setIsAccessTime(true);
            storageTransition.setReturnToStdWhenVisit(false);
            storageTransition.setAllowSmallFile(true);
            List<LifecycleRule.StorageTransition> storageTransitionList = new ArrayList<LifecycleRule.StorageTransition>();
            storageTransitionList.add(storageTransition);
            lifecycleRule.setStorageTransition(storageTransitionList);
            lifecycleRuleList.add(lifecycleRule);
            
            // Create a lifecycle rule and set the ID to rule2. Specify that the previous versions of the objects whose names contain the dir prefix and whose size is greater than 64 KB are changed to IA 10 days after the objects are last accessed. In addition, specify that the storage classes of the objects whose names contain the dir prefix are changed to Standard when the objects are accessed again. 
            LifecycleRule lifecycleRule2 = new LifecycleRule("rule2", "dir", LifecycleRule.RuleStatus.Enabled);
            LifecycleRule.NoncurrentVersionStorageTransition noncurrentVersionStorageTransition = new LifecycleRule.NoncurrentVersionStorageTransition();
            noncurrentVersionStorageTransition.setStorageClass(StorageClass.IA);
            noncurrentVersionStorageTransition.setNoncurrentDays(10);
            noncurrentVersionStorageTransition.setIsAccessTime(true);
            noncurrentVersionStorageTransition.setReturnToStdWhenVisit(true);
            noncurrentVersionStorageTransition.setAllowSmallFile(false);

            List<LifecycleRule.NoncurrentVersionStorageTransition> noncurrentVersionStorageTransitionList = new ArrayList<LifecycleRule.NoncurrentVersionStorageTransition>();
            noncurrentVersionStorageTransitionList.add(noncurrentVersionStorageTransition);
            lifecycleRule2.setNoncurrentVersionStorageTransitions(noncurrentVersionStorageTransitionList);
            lifecycleRuleList.add(lifecycleRule2);

            setBucketLifecycleRequest.setLifecycleRules(lifecycleRuleList);

            // Configure the lifecycle rules. 
            ossClient.setBucketLifecycle(setBucketLifecycleRequest);
        } 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();
            }
        }
    }
}

import argparse
import datetime
import alibabacloud_oss_v2 as oss

parser = argparse.ArgumentParser(description="put bucket lifecycle sample")
parser.add_argument('--region', help='The region in which the bucket is located.', required=True)
parser.add_argument('--bucket', help='The name of the bucket.', required=True)
parser.add_argument('--endpoint', help='The domain names that other services can use to access OSS')

def main():
  args = parser.parse_args()
  credentials_provider = oss.credentials.EnvironmentVariableCredentialsProvider()
  cfg = oss.config.load_default()
  cfg.credentials_provider = credentials_provider
  cfg.region = args.region
  if args.endpoint is not None:
    cfg.endpoint = args.endpoint
  client = oss.Client(cfg)

  result = client.put_bucket_lifecycle(oss.PutBucketLifecycleRequest(
    bucket=args.bucket,
    lifecycle_configuration=oss.LifecycleConfiguration(
      rules=[
        oss.LifecycleRule(
          id='rule1',
          status='Enabled',
          prefix='data/',
          transitions=[oss.LifecycleRuleTransition(
            days=200,
            storage_class=oss.StorageClassType.IA,
            is_access_time=True,
            return_to_std_when_visit=False
          )]
        ),
        oss.LifecycleRule(
          id='rule2',
          status='Enabled',
          prefix='log/',
          transitions=[
            oss.LifecycleRuleTransition(
              days=120,
              storage_class=oss.StorageClassType.IA,
              is_access_time=True,
              return_to_std_when_visit=False
            ),
            oss.LifecycleRuleTransition(
              days=250,
              storage_class=oss.StorageClassType.ARCHIVE
              # If is_access_time is not set, the rule is based on the last modified time by default.
            )
          ]
        )
      ]
    )
  ))

  print(f'status code: {result.status_code}, '
        f'request id: {result.request_id}')

if __name__ == "__main__":
  main()

package main

import (
	"context"
	"flag"
	"log"

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

// Define global variables.
var (
	region     string // The region where the bucket is located.
	bucketName string // The name of the bucket.
)

// The init function initializes command-line arguments.
func init() {
	flag.StringVar(&region, "region", "", "The region in which the bucket is located.")
	flag.StringVar(&bucketName, "bucket", "", "The name of the bucket.")
}

func main() {
	// Parse command-line arguments.
	flag.Parse()

	// Check if the bucket name is provided.
	if len(bucketName) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, bucket name required")
	}

	// Check if the region is provided.
	if len(region) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, region required")
	}

	// Load the default configuration, and set the credentials provider and region.
	cfg := oss.LoadDefaultConfig().
		WithCredentialsProvider(credentials.NewEnvironmentVariableCredentialsProvider()).
		WithRegion(region)

	// Create an OSS client.
	client := oss.NewClient(cfg)

	// Create a request to set lifecycle rules for the bucket.
	request := &oss.PutBucketLifecycleRequest{
		Bucket: oss.Ptr(bucketName), // The name of the bucket.
		LifecycleConfiguration: &oss.LifecycleConfiguration{
			Rules: []oss.LifecycleRule{
				{
					// In lifecycle rule "rule1", transition all objects with the prefix "data/"
					// to the Infrequent Access (IA) storage class 200 days after they are last accessed.
					// When these objects are accessed again, they remain in the IA storage class.
					ID:     oss.Ptr("rule1"),
					Status: oss.Ptr("Enabled"),
					Prefix: oss.Ptr("data/"),
					Transitions: []oss.LifecycleRuleTransition{
						{
							Days:                 oss.Ptr(int32(200)),
							StorageClass:         oss.StorageClassIA,
							IsAccessTime:         oss.Ptr(true), // Set to true for a rule based on last access time.
							ReturnToStdWhenVisit: oss.Ptr(false),
						},
					},
				},
				{
					// In lifecycle rule "rule2", transition all objects with the prefix "log/"
					// to the Infrequent Access (IA) storage class 120 days after they are last accessed.
					// In the same rule, transition these objects to the Archive storage class 250 days after they are last accessed.
					// When these objects are accessed again, they remain in their current storage class.
					ID:     oss.Ptr("rule2"),
					Status: oss.Ptr("Enabled"),
					Prefix: oss.Ptr("log/"),
					Transitions: []oss.LifecycleRuleTransition{
						{
							Days:                 oss.Ptr(int32(120)),
							StorageClass:         oss.StorageClassIA,
							IsAccessTime:         oss.Ptr(true), // Set to true for a rule based on last access time.
							ReturnToStdWhenVisit: oss.Ptr(false),
						},
						{
							Days:                 oss.Ptr(int32(250)),
							StorageClass:         oss.StorageClassArchive,
							IsAccessTime:         oss.Ptr(true),
							ReturnToStdWhenVisit: oss.Ptr(false),
						},
					},
				},
			},
		},
	}

	// Set the lifecycle rules for the bucket.
	result, err := client.PutBucketLifecycle(context.TODO(), request)
	if err != nil {
		log.Fatalf("failed to put bucket lifecycle %v", err)
	}

	// Print the result of setting the lifecycle rules.
	log.Printf("put bucket lifecycle result:%#v\n", result)
}

<?php

// Include the autoload file to load dependencies
require_once __DIR__ . '/../vendor/autoload.php';

use AlibabaCloud\Oss\V2 as Oss;
use AlibabaCloud\Oss\V2\Models\LifecycleConfiguration;

// Specify descriptions for command line parameters
$optsdesc = [
    "region" => ['help' => 'The region in which the bucket is located', 'required' => True], // (Required) Specify the region in which the bucket is located.
    "endpoint" => ['help' => 'The domain names that other services can use to access OSS', 'required' => False], // (Optional) Specify the endpoint that can be used by other services to access OSS.
    "bucket" => ['help' => 'The name of the bucket', 'required' => True], // (Required) Specify the name of the bucket.
];

// Generate a list of long options to parse the command-line parameters
$longopts = \array_map(function ($key) {
    return "$key:"; // Add a colon after each parameter to indicate that a value is required
}, array_keys($optsdesc));

// Parse the command-line parameters
$options = getopt("", $longopts); 

// Check whether the required parameters are missing
foreach ($optsdesc as $key => $value) {
    if ($value['required'] === True && empty($options[$key])) {
        $help = $value['help'];
        echo "Error: the following arguments are required: --$key, $help"; // Prompt the user for missing required parameters
        exit(1); 
    }
}

// Obtain the values of the command-line parameters
$region = $options["region"]; // The region in which the bucket is located
$bucket = $options["bucket"]; // The name of the bucket

// Use environment variables to load the AccessKey ID and AccessKey secret
$credentialsProvider = new Oss\Credentials\EnvironmentVariableCredentialsProvider();

// Use the default configuration of the SDK
$cfg = Oss\Config::loadDefault();

// Specify the credential provider
$cfg->setCredentialsProvider($credentialsProvider);

// Specify the region
$cfg->setRegion($region);

// Specify the endpoint if an endpoint is provided
if (isset($options["endpoint"])) {
    $cfg->setEndpoint($options["endpoint"]);
}

// Create an OSSClient instance
$client = new Oss\Client($cfg);

// Define a lifecycle rule to convert objects whose names contain the log/ prefix to the IA storage class after 30 days
$lifecycleRule = new Oss\Models\LifecycleRule(
    prefix: 'log/', // The prefix of the object
    transitions: array(
        new Oss\Models\LifecycleRuleTransition(
            days: 30, // The conversion time is 30 days
            storageClass: 'IA', // The target storage class is IA
            IsAccessTime: 'true', // Whether to trigger the conversion based on the access time
            ReturnToStdWhenVisit: 'false' // Keep as IA storage when accessed again
        )
    ),
    id: 'rule', // The ID of the rule
    status: 'Enabled' // The status of the rule is enabled
);

// Create a lifecycle configuration object and add the lifecycle rule
$lifecycleConfiguration = new LifecycleConfiguration(
    rules: array($lifecycleRule)
);

// Create a request object to set the lifecycle of the bucket and pass in the lifecycle configuration
$request = new Oss\Models\PutBucketLifecycleRequest(
    bucket: $bucket,
    lifecycleConfiguration: $lifecycleConfiguration
);

// Call the putBucketLifecycle method to set the lifecycle rules for the bucket
$result = $client->putBucketLifecycle($request);

// Display the returned result
printf(
    'status code:' . $result->statusCode . PHP_EOL . // The HTTP response status code
    'request id:' . $result->requestId . PHP_EOL // The unique identifier of the request
);