Object Storage Service:Lifecycle rules based on the 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 Enable access tracking and click Create Rule.

5. In the Create Rule panel, configure the parameters. The following table describes the parameters.

   • Versioning not enabled for the bucket

     Section	Parameter	Description
     Basic Settings	Status	Specify the status of the lifecycle rule. Valid values: Start and Disabled. After you enable a lifecycle rule, the storage class of objects is converted or objects are deleted based on the configured lifecycle rule. After you disable a lifecycle rule, the lifecycle tasks are interrupted.
     	Applied To	Specify the objects for which you want the lifecycle rule to take effect. Valid values: Object Prefix and Apply to the entire bucket.
     	Allow Overlapped Prefixes	Specify whether to allow prefixes that overlap. By default, OSS checks whether the prefixes of each lifecycle rule overlap. For example, you configure the following lifecycle rules that contain prefixes that overlap: Rule 1 All objects whose names contain the dir1/ prefix in the bucket are deleted 180 days after the objects are last accessed. Rule 2 All objects whose names contain the dir1/dir2/ prefix in the bucket are converted to Archive objects 30 days after the objects are last accessed. If you do not select this check box, OSS determines that objects in the dir1/dir2/ directory match two deletion rules. Therefore, the two lifecycle rules are rejected. If you select this check box, the objects in the dir1/dir2/ directory are converted to Archive objects after 30 days. Other objects in the dir1/ directory are converted to IA objects 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 parameter to img, all objects whose names contain the img prefix, such as imgtest.png and img/example.jpg, match the lifecycle rule. If you set the prefix to img/, all objects whose names contain the img/ prefix, such as img/example.jpg and img/test.jpg, match the lifecycle rule.
     	Tag	Specify tags. The rule takes effect only for objects that contain the specified tags. For example, if you select Object Prefix and set Prefix to img, Key to a, and Value to 1, the rule takes effect for all objects whose names contain the img prefix and that contain the a=1 tag. For more information about object tags, see Object tagging.
     	NOT	Specify that the lifecycle rule does not take effect for the objects that contain the specified prefix and tag. Important If you turn on NOT, each lifecycle rule must contain at least one of the prefix and tags of an object. The key of the tag specified for the NOT parameter cannot be the same as the key specified for the Tag parameter. If you turn on NOT, you cannot configure the lifecycle rules that take effect for parts.
     	Object Size	Specify the size of objects for which the lifecycle rule takes effect. Minimum Size: Specify that the lifecycle rule takes effect only for objects that are larger than the specified size threshold. You can specify the minimum object size that is greater than 0 B and less than 5 TB. Maximum Size: Specify that the lifecycle rule takes effect only for objects that are smaller than the specified size threshold. You can specify the maximum object size that is greater than 0 B and less than 5 TB. Important If you specify the minimum object size and maximum object size in the same lifecycle rule: Make sure that the maximum object size is greater than the minimum object size. You cannot specify lifecycle rules for parts. You cannot specify lifecycle rules to remove delete markers.
     Policy for Objects	Object Lifecycle	Configure rules for objects to specify when the objects expire. You can set File Lifecycle to Expiration Period, Expiration Date, or Not Enabled. If you select Not Enabled, the configurations of File Lifecycle do not take effect.
     	Lifecycle-based Rules	Specify the lifecycle rule to convert the storage class of objects. If you select Access Time, set Expiration Period to 30, and specify that the storage class of the objects is converted to IA (Not Converted After Access) after the validity period elapses, the storage class of objects that are last accessed on September 1, 2021 is converted to IA on October 1, 2021.
     Policy for Parts	Part Lifecycle	Specify the operations that you want to perform on expired parts. If you turn on Tag, this parameter is unavailable. You can select Expiration Period, Expiration Date, or Not Enabled. If you select Not Enabled, 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 the Part Lifecycle parameter. Expired parts are automatically deleted and cannot be recovered.

   • Versioning enabled for the bucket

     Configure the parameters in the Basic Settings and Policy for Parts sections in the same manner as you configure the parameters 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, the Clean Up Delete Marker option is added to the File Lifecycle 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 how to delete objects, see Delete marker.
     Policy for Previous Versions	Object Lifecycle	Specify when previous versions expire. Valid values: Expiration Period and Not Enabled. If you select Not Enabled, the configurations of File Lifecycle do not take effect.
     	Lifecycle-based Rules	Specify the number of days within which objects can be retained after they become previous versions. After they expire, the specified operations are performed on the previous versions the next day. For example, if you set Validity Period (Days) to 30, 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 later version is generated.

6. Click OK.

   After the lifecycle rule is created, you can view the rule in the lifecycle rule list.

You can use only OSS SDK for Java and OSS SDK for Go to create lifecycle rules based on the last access time. Before you create a lifecycle rule based on the last access time, you must enable the access tracking feature for the bucket. For the sample code that is used to configure lifecycle rules based on the last access time, see Overview.

import com.aliyun.oss.ClientException;
import com.aliyun.oss.OSS;
import com.aliyun.oss.OSSClientBuilder;
import com.aliyun.oss.OSSException;
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";
        // We recommend that you do not save access credentials in the project code. Otherwise, access credentials may be leaked. As a result, the security of all resources in your account is compromised. In this example, access credentials are obtained from environment variables. You need to configure environment variables before you run the sample code. 
        EnvironmentVariableCredentialsProvider credentialsProvider = CredentialsProviderFactory.newEnvironmentVariableCredentialsProvider();
        // Specify the name of the bucket. Example: examplebucket. 
        String bucketName = "examplebucket";

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

        try {
            ossClient.putBucketAccessMonitor(bucketName, AccessMonitor.AccessMonitorStatus.Enabled.toString());
            // Create a lifecycle rule and set 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 converted to IA 30 days after the objects are last accessed. In addition, specify that the objects 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 ID to rule2. Specify that the storage classes of the previous versions of the objects whose names contain the dir prefix and whose size is greater than 64 KB are converted to IA 10 days after the objects are last accessed. In addition, specify that the storage classes of the objects are converted 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();
            }
        }
    }
}

# -*- coding: utf-8 -*-
import oss2
from oss2.credentials import EnvironmentVariableCredentialsProvider
from oss2.models import LifecycleRule, BucketLifecycle, StorageTransition, NoncurrentVersionStorageTransition

# Obtain access credentials from the environment variables. Before you run the sample code, make sure that you have configured environment variables OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET. 
auth = oss2.ProviderAuth(EnvironmentVariableCredentialsProvider())
# 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 the name of the bucket. Example: examplebucket. 
bucket = oss2.Bucket(auth, 'https://oss-cn-hangzhou.aliyuncs.com', 'examplebucket')

# Create a lifecycle rule and set 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 converted to IA 30 days after the objects are last accessed. In addition, specify that the objects are still stored as IA objects when the objects are accessed again. 
rule1 = LifecycleRule('rule1', 'logs', status=LifecycleRule.ENABLED)
rule1.storage_transitions = [StorageTransition(days=30, storage_class=oss2.BUCKET_STORAGE_CLASS_IA, is_access_time=True, return_to_std_when_visit=False, allow_small_file=True)]

# Create a lifecycle rule and set ID to rule2. Specify that the storage classes of the previous versions of the objects whose names contain the dir prefix and whose size is greater than 64 KB are converted to IA 10 days after the objects are last accessed. In addition, specify that the storage classes of the objects are converted to Standard when the objects are accessed again. 
rule2 = LifecycleRule('rule2', 'dir', status=LifecycleRule.ENABLED)
rule2.noncurrent_version_sotrage_transitions = [NoncurrentVersionStorageTransition(10, oss2.BUCKET_STORAGE_CLASS_IA, is_access_time=True, return_to_std_when_visit=True, allow_small_file=False)]

lifecycle = BucketLifecycle([rule1, rule2])

# Create the lifecycle rules. 
result = bucket.put_bucket_lifecycle(lifecycle)

print ('The lifecycle configuration is successful. ' + str(result.status) is returned.)

package main

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

func main() {
	// Specify the name of the bucket. 
	bucketName := "yourBucketName"

	// 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. 
	provider, err := oss.NewEnvironmentVariableCredentialsProvider()
	if err != nil {
		fmt.Println("Error:", err)
		os.Exit(-1)
	}

	// 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. 
	client, err := oss.New("yourEndpoint", "", "", oss.SetCredentialsProvider(&provider))
	if err != nil {
		fmt.Println("Error:", err)
		os.Exit(-1)
	}

	isTrue := true
	isFalse := false
	// Create a lifecycle rule and set 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 converted 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. 
	rule1 := oss.LifecycleRule{
		ID:     "rule1",
		Prefix: "logs",
		Status: "Enabled",
		Transitions: []oss.LifecycleTransition{
			{
				Days:                 30,
				StorageClass:         oss.StorageIA,
				IsAccessTime:         &isTrue,
				ReturnToStdWhenVisit: &isFalse,
				AllowSmallFile:       &isTrue,
			},
		},
	}
	// Create a lifecycle rule and set 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 converted 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 converted to Standard when the objects are accessed again. 
	rule2 := oss.LifecycleRule{
		ID:     "rule2",
		Prefix: "dir",
		Status: "Enabled",
		NonVersionTransitions: []oss.LifecycleVersionTransition{
			{
				NoncurrentDays:       10,
				StorageClass:         oss.StorageIA,
				IsAccessTime:         &isTrue,
				ReturnToStdWhenVisit: &isTrue,
				AllowSmallFile:       &isFalse,
			},
		},
	}
	// Configure the lifecycle rules. 
	var rules = []oss.LifecycleRule{rule1, rule2}
	err = client.SetBucketLifecycle(bucketName, rules)
	if err != nil {
		fmt.Println("Error:", err)
		os.Exit(-1)
	}
	fmt.Printf("%s\n", "set bucket life cycle success")
}

If your program requires more custom options to configure retention policies, you can call RESTful API operations. To directly call an API, you must include the signature calculation in your code. For more information, see PutBucketLifecycle.