Object Storage Service:Lifecycle rules based on the last access time

How it works

After you enable access tracking, OSS records a LastAccessTime for every object. When a lifecycle rule runs, it checks LastAccessTime and transitions objects that haven't been accessed within the specified number of days.

Storage class transitions

Objects move down the storage tier hierarchy as they become less active:

The Standard → IA transition is unique: you can configure whether the object automatically reverts to Standard when accessed again, or stays in IA.

How `LastAccessTime` is tracked

• When you enable access tracking, LastAccessTime is initialized to the current timestamp for all existing objects.

• Object downloads and overwrites update LastAccessTime. For the full list of operations that do and do not update LastAccessTime, see How do common operations affect LastAccessTime of objects?

• LastAccessTime is updated asynchronously, typically within 24 hours.

• If an object is accessed multiple times within a 24-hour window, only the first access updates LastAccessTime.

• If an object is never accessed after you enable tracking, its LastAccessTime remains the initialization timestamp (the time you enabled tracking). Lifecycle rules apply based on that timestamp.

When rules run

OSS loads a new lifecycle rule within 24 hours of creation. After loading, OSS runs the rule every day at 08:00:00 (UTC+8). Transitions are typically completed within 24 hours, with these object count limits:

• China (Hangzhou), China (Shanghai), China (Beijing), China (Zhangjiakou), China (Ulanqab), China (Shenzhen), and Singapore: up to 1 billion objects

• All other regions: up to 100 million objects

Under heavy load—large object counts, many tags, numerous versions, or high write volume—rule execution can take several days to several weeks.

When versioning is enabled, each object version counts separately toward the limit.

Use cases

• Multimedia hosting: Store images and videos in Standard for fresh content, then automatically transition older, rarely accessed files to IA. Frequently accessed content stays in Standard; only cold data transitions.

• Photo albums and network drives: Keep all data accessible in real time, but reduce storage costs for inactive content by moving it to IA automatically after a defined number of days.

• Life science and genomics: Gene sequencing generates large volumes of data whose activity is better measured by access time than by creation time. Access-time lifecycle rules automatically identify and tier cold data without manual log analysis. For finer control, combine access-time policies and last-modified-time policies in the same rule.

Limitations

Billing

Object monitoring and management fees

After you enable access tracking, OSS generates object monitoring and management fees. These fees are not charged.

IA minimum storage duration

IA objects have a 30-day minimum storage duration. If an IA object is transitioned away before 30 days, you are charged for the remainder:

• *Example 1:* OSS converts an object to IA 10 days after creation, then converts it back to Standard 5 days later. You are charged for 15 days of IA storage (the shortfall to 30 days).

• *Example 2:* OSS converts an object to IA 10 days after creation, then deletes it after 15 more days. You are charged for 5 days of IA storage (the shortfall to 30 days).

For more information, see Storage fees.

Data retrieval fees

Accessing IA objects incurs retrieval fees based on the amount of data retrieved. See Data processing fees.

API operation fees

Storage class transitions via lifecycle rules incur API operation fees. See API operation calling fees.

Usage notes

Overwrite semantics

PutBucketLifecycle replaces all existing lifecycle rule configurations for a bucket. To add a rule without losing existing rules:

1. Call GetBucketLifecycle to retrieve all existing rules.

2. Add the new rule to the retrieved configuration.

3. Call PutBucketLifecycle with the complete updated configuration.

OSS-HDFS buckets

If OSS-HDFS is enabled on the bucket, use the NOT element to exclude objects in the .dlsdata/ directory. Without this exclusion, the lifecycle rule may apply to OSS-HDFS data and disrupt read/write operations.

Archive transitions and last access time

After a lifecycle rule moves an object from Standard or IA to Archive, Cold Archive, or Deep Cold Archive, the object's LastAccessTime is set to the time when access tracking was enabled for the bucket—not the time of the transition.

Create a lifecycle rule

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 {
        // Replace with your actual endpoint. This example uses China (Hangzhou).
        String endpoint = "https://oss-cn-hangzhou.aliyuncs.com";
        // Load credentials from environment variables OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET.
        EnvironmentVariableCredentialsProvider credentialsProvider = CredentialsProviderFactory.newEnvironmentVariableCredentialsProvider();
        String bucketName = "examplebucket";
        String region = "cn-hangzhou";

        ClientBuilderConfiguration clientBuilderConfiguration = new ClientBuilderConfiguration();
        clientBuilderConfiguration.setSignatureVersion(SignVersion.V4);
        OSS ossClient = OSSClientBuilder.create()
            .endpoint(endpoint)
            .credentialsProvider(credentialsProvider)
            .clientConfiguration(clientBuilderConfiguration)
            .region(region)
            .build();

        try {
            // Enable access tracking on the bucket.
            ossClient.putBucketAccessMonitor(bucketName, AccessMonitor.AccessMonitorStatus.Enabled.toString());

            List<LifecycleRule> lifecycleRuleList = new ArrayList<LifecycleRule>();
            SetBucketLifecycleRequest setBucketLifecycleRequest = new SetBucketLifecycleRequest(bucketName);

            // Rule 1: Transition objects with the "logs" prefix to IA 30 days after last access.
            // Objects remain in IA when accessed again (ReturnToStdWhenVisit = false).
            LifecycleRule lifecycleRule = new LifecycleRule("rule1", "logs", LifecycleRule.RuleStatus.Enabled);
            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);

            // Rule 2: Transition noncurrent versions of objects with the "dir" prefix to IA 10 days
            // after last access. Objects return to Standard when accessed again (ReturnToStdWhenVisit = true).
            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);
            ossClient.setBucketLifecycle(setBucketLifecycleRequest);

        } catch (OSSException oe) {
            System.out.println("OSS error: " + oe.getErrorMessage() + " (Code: " + oe.getErrorCode() + ", RequestId: " + oe.getRequestId() + ")");
        } catch (ClientException ce) {
            System.out.println("Client error: " + ce.getMessage());
        } finally {
            if (ossClient != null) {
                ossClient.shutdown();
            }
        }
    }
}

import argparse
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()

    # Load credentials from environment variables OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET.
    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)

    # All transitions use IsAccessTime=True to apply based on last access time.
    result = client.put_bucket_lifecycle(oss.PutBucketLifecycleRequest(
        bucket=args.bucket,
        lifecycle_configuration=oss.LifecycleConfiguration(
            rules=[
                oss.LifecycleRule(
                    # Rule 1: Transition objects with prefix "data/" to IA 200 days after last access.
                    # Objects remain in IA when accessed again.
                    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(
                    # Rule 2: Transition objects with prefix "log/" to IA at 120 days, then Archive at 250 days.
                    # Both transitions are based on last access time.
                    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,
                            is_access_time=True,
                            return_to_std_when_visit=False
                        )
                    ],
                )
            ]
        ),
    ))

    print(f'status code: {result.status_code}, 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"
)

var (
    region     string
    bucketName string
)

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() {
    flag.Parse()

    if len(bucketName) == 0 {
        flag.PrintDefaults()
        log.Fatalf("invalid parameters, bucket name required")
    }
    if len(region) == 0 {
        flag.PrintDefaults()
        log.Fatalf("invalid parameters, region required")
    }

    // Load credentials from environment variables OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET.
    cfg := oss.LoadDefaultConfig().
        WithCredentialsProvider(credentials.NewEnvironmentVariableCredentialsProvider()).
        WithRegion(region)

    client := oss.NewClient(cfg)

    // All transitions use IsAccessTime=true to apply based on last access time.
    request := &oss.PutBucketLifecycleRequest{
        Bucket: oss.Ptr(bucketName),
        LifecycleConfiguration: &oss.LifecycleConfiguration{
            Rules: []oss.LifecycleRule{
                {
                    // Rule 1: Transition objects with prefix "data/" to IA 200 days after last access.
                    // Objects remain in IA when accessed again.
                    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),
                            ReturnToStdWhenVisit: oss.Ptr(false),
                        },
                    },
                },
                {
                    // Rule 2: Transition objects with prefix "log/" to IA at 120 days, then Archive at 250 days.
                    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),
                            ReturnToStdWhenVisit: oss.Ptr(false),
                        },
                        {
                            Days:                 oss.Ptr(int32(250)),
                            StorageClass:         oss.StorageClassArchive,
                            IsAccessTime:         oss.Ptr(true),
                            ReturnToStdWhenVisit: oss.Ptr(false),
                        },
                    },
                },
            },
        },
    }

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

    log.Printf("put bucket lifecycle result: %#v\n", result)
}

<?php

require_once __DIR__ . '/../vendor/autoload.php';

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

$optsdesc = [
    "region"   => ['help' => 'The region in which the bucket is located', 'required' => true],
    "endpoint" => ['help' => 'The domain names that other services can use to access OSS', 'required' => false],
    "bucket"   => ['help' => 'The name of the bucket', 'required' => true],
];

$longopts = array_map(fn($key) => "$key:", array_keys($optsdesc));
$options  = getopt("", $longopts);

foreach ($optsdesc as $key => $value) {
    if ($value['required'] === true && empty($options[$key])) {
        echo "Error: --$key is required. " . $value['help'];
        exit(1);
    }
}

$region = $options["region"];
$bucket = $options["bucket"];

// Load credentials from environment variables OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET.
$credentialsProvider = new Oss\Credentials\EnvironmentVariableCredentialsProvider();
$cfg = Oss\Config::loadDefault();
$cfg->setCredentialsProvider($credentialsProvider);
$cfg->setRegion($region);

if (isset($options["endpoint"])) {
    $cfg->setEndpoint($options["endpoint"]);
}

$client = new Oss\Client($cfg);

// Transition objects with prefix "log/" to IA 30 days after last access.
$lifecycleRule = new Oss\Models\LifecycleRule(
    prefix: 'log/',
    transitions: [
        new Oss\Models\LifecycleRuleTransition(
            days: 30,
            storageClass: 'IA',
            IsAccessTime: 'true',        // Apply based on last access time.
            ReturnToStdWhenVisit: 'false' // Objects remain in IA when accessed again.
        )
    ],
    id: 'rule',
    status: 'Enabled'
);

$lifecycleConfiguration = new LifecycleConfiguration(rules: [$lifecycleRule]);
$request = new Oss\Models\PutBucketLifecycleRequest(
    bucket: $bucket,
    lifecycleConfiguration: $lifecycleConfiguration
);

$result = $client->putBucketLifecycle($request);
printf("status code: %s\nrequest id: %s\n", $result->statusCode, $result->requestId);

ossutil api put-bucket-lifecycle --bucket examplebucket --lifecycle-configuration "{\"Rule\":{\"ID\":\"rule1\",\"Prefix\":\"tmp/\",\"Status\":\"Enabled\",\"Expiration\":{\"Days\":\"10\"},\"Transition\":{\"Days\":\"5\",\"StorageClass\":\"IA\"},\"AbortMultipartUpload\":{\"Days\":\"10\"}}}"

API reference

To call the OSS RESTful API directly, see PutBucketLifecycle. Direct API calls require signature calculation in your code.

FAQ

What happens if a bucket has both a last-modified-time rule and a last-access-time rule for overlapping prefixes?

OSS applies whichever rule costs the user less. For example, if one rule deletes objects 30 days after last modification and another converts them to IA 30 days after last access, OSS applies the deletion rule—because deleting stops all storage charges, while converting to IA still incurs storage and retrieval fees.

If I modify a lifecycle rule, when does the change take effect, and what happens to objects already in IA?

The new rule takes effect within 24 hours. Objects that have already transitioned under the old rule are not affected by the rule change. For example, if you change the rule prefix from er to re after some objects with the er prefix have already been converted to IA, those objects stay in IA—the original rule no longer applies to them, and the new rule doesn't cover their prefix. For objects matching the new re prefix, LastAccessTime is set to the time access tracking was enabled.

How does versioning interact with last-access-time lifecycle rules?

Each version of an object has a unique version ID and is managed independently. A lifecycle rule may transition the current version and a noncurrent version of the same object to different storage classes.

Can I disable access tracking?

Yes. Before disabling, make sure no lifecycle rules based on last access time are active for the bucket. After you disable tracking, OSS stops updating LastAccessTime. If you re-enable tracking later, LastAccessTime is re-initialized to the new timestamp for all objects.

What's next

• How do common operations affect LastAccessTime of objects?

• Storage fees

• PutBucketLifecycle API reference