Manage lifecycle rules using Go SDK - Object Storage Service

Lifecycle rules let you automatically transition objects to lower-cost storage classes or delete objects after a specified period. For data you rarely access, configure rules based on last modified time to batch-delete or archive objects. To have OSS monitor access patterns and move cold data automatically, use rules based on last access time—this is Automatic Storage Tiering.

Prerequisites

Before you begin, ensure that you have:

Reviewed the lifecycle feature documentation: Lifecycle rules based on the last modified time and Lifecycle rules based on the last access time
Configured access credentials as environment variables. See Configure access credentials
An OSSClient instance. The examples in this topic use an OSS endpoint. For custom domain names or Security Token Service (STS), see Configure OSSClient instances
The required RAM permissions: For permission setup, see Attach a custom policy to a RAM user.
Operation Permission
Set lifecycle rules oss:PutBucketLifecycle
Get lifecycle rules oss:GetBucketLifecycle
Delete lifecycle rules oss:DeleteBucketLifecycle

Operation	Permission
Set lifecycle rules	`oss:PutBucketLifecycle`
Get lifecycle rules	`oss:GetBucketLifecycle`
Delete lifecycle rules	`oss:DeleteBucketLifecycle`

The examples use the public endpoint for the China (Hangzhou) region. If you're accessing OSS from another Alibaba Cloud service in the same region, use an internal endpoint. See Regions and endpoints.

Set lifecycle rules

All examples call client.SetBucketLifecycle(bucketName, rules) to apply one or more oss.LifecycleRule structs to a bucket.

To modify existing rules after setting them, see How do I modify one or more lifecycle rule configurations?

Transition storage classes and delete objects based on last modified time

The following example sets three lifecycle rules on examplebucket:

rule1 – Objects with the prefix foo/ expire 3 days after last modification
rule2 – For a versioning-enabled bucket: auto-deletes expired delete markers, transitions noncurrent versions to Infrequent Access (IA) after 10 days, and permanently deletes noncurrent versions after 30 days
rule3 – Objects tagged tag1=value1 expire 3 days after last modification

package main

import (
	"fmt"
	"os"

	"github.com/aliyun/aliyun-oss-go-sdk/oss"
)

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

	// Create an OSSClient instance.
	// Set yourEndpoint to the endpoint of your bucket.
	// For China (Hangzhou), use https://oss-cn-hangzhou.aliyuncs.com.
	// Set yourRegion to the region where the bucket is located, for example, cn-hangzhou.
	clientOptions := []oss.ClientOption{oss.SetCredentialsProvider(&provider)}
	clientOptions = append(clientOptions, oss.Region("yourRegion"))
	clientOptions = append(clientOptions, oss.AuthVersion(oss.AuthV4))
	client, err := oss.New("yourEndpoint", "", "", clientOptions...)
	if err != nil {
		fmt.Println("Error:", err)
		os.Exit(-1)
	}

	bucketName := "examplebucket"

	// rule1: objects with prefix "foo/" expire 3 days after last modification.
	rule1 := oss.BuildLifecycleRuleByDays("rule1", "foo/", true, 3)

	// rule2: versioning-enabled bucket rules.
	deleteMark := true
	expiration := oss.LifecycleExpiration{
		// Auto-delete expired delete markers when no other versions exist.
		ExpiredObjectDeleteMarker: &deleteMark,
	}
	versionExpiration := oss.LifecycleVersionExpiration{
		// Permanently delete noncurrent versions after 30 days.
		NoncurrentDays: 30,
	}
	versionTransition := oss.LifecycleVersionTransition{
		// Transition noncurrent versions to IA after 10 days.
		NoncurrentDays: 10,
		StorageClass:   "IA",
	}
	rule2 := oss.LifecycleRule{
		ID:                   "rule2",
		Prefix:               "yourObjectPrefix",
		Status:               "Enabled",
		Expiration:           &expiration,
		NonVersionExpiration: &versionExpiration,
		NonVersionTransitions: []oss.LifecycleVersionTransition{
			versionTransition,
		},
	}

	// rule3: objects tagged tag1=value1 expire 3 days after last modification.
	rule3 := oss.LifecycleRule{
		ID:     "rule3",
		Prefix: "",
		Status: "Enabled",
		Tags: []oss.Tag{
			{Key: "tag1", Value: "value1"},
		},
		Expiration: &oss.LifecycleExpiration{Days: 3},
	}

	rules := []oss.LifecycleRule{rule1, rule2, rule3}
	err = client.SetBucketLifecycle(bucketName, rules)
	if err != nil {
		fmt.Println("Error:", err)
		os.Exit(-1)
	}
}

Transition objects with exclusion filters based on last modified time

The following example uses the Not element in LifecycleFilter to transition objects in yourBucketName to Infrequent Access 30 days after last modification, while excluding objects that match all of the following conditions: prefix logs/log, tag key1=value1, and size between 500 bytes and 64,500 bytes.

package main

import (
	"fmt"
	"os"

	"github.com/aliyun/aliyun-oss-go-sdk/oss"
)

func main() {
	bucketName := "yourBucketName"

	provider, err := oss.NewEnvironmentVariableCredentialsProvider()
	if err != nil {
		fmt.Println("Error:", err)
		os.Exit(-1)
	}

	clientOptions := []oss.ClientOption{oss.SetCredentialsProvider(&provider)}
	clientOptions = append(clientOptions, oss.Region("yourRegion"))
	clientOptions = append(clientOptions, oss.AuthVersion(oss.AuthV4))
	client, err := oss.New("yourEndpoint", "", "", clientOptions...)
	if err != nil {
		fmt.Println("Error:", err)
		os.Exit(-1)
	}

	tag := oss.Tag{
		Key:   "key1",
		Value: "value1",
	}
	minSize := int64(500)   // Minimum object size in bytes
	maxSize := int64(64500) // Maximum object size in bytes
	filter := oss.LifecycleFilter{
		ObjectSizeGreaterThan: &minSize,
		ObjectSizeLessThan:    &maxSize,
		Not: []oss.LifecycleFilterNot{
			{
				Prefix: "logs/log",
				Tag:    &tag,
			},
		},
	}
	rule1 := oss.LifecycleRule{
		ID:     "mtime transition1",
		Prefix: "logs",
		Status: "Enabled",
		Transitions: []oss.LifecycleTransition{
			{
				Days:         30,
				StorageClass: oss.StorageIA,
			},
		},
		Filter: &filter,
	}

	rules := []oss.LifecycleRule{rule1}
	err = client.SetBucketLifecycle(bucketName, rules)
	if err != nil {
		fmt.Println("Error:", err)
		os.Exit(-1)
	}
	fmt.Printf("%s\n", "set lifecycle succeeded")
}

Transition storage classes based on last access time

The following example uses IsAccessTime: true to configure rules that trigger on last access time rather than last modified time.

rule1 – Transitions current versions with prefix logs (64 KB or smaller) to IA 30 days after last access. Objects stay in IA if accessed again (ReturnToStdWhenVisit: false)
rule2 – Transitions noncurrent versions with prefix dir (larger than 64 KB) to IA 10 days after last access. Objects return to Standard if accessed again (ReturnToStdWhenVisit: true)

package main

import (
	"fmt"
	"os"

	"github.com/aliyun/aliyun-oss-go-sdk/oss"
)

func main() {
	bucketName := "yourBucketName"

	provider, err := oss.NewEnvironmentVariableCredentialsProvider()
	if err != nil {
		fmt.Println("Error:", err)
		os.Exit(-1)
	}

	clientOptions := []oss.ClientOption{oss.SetCredentialsProvider(&provider)}
	clientOptions = append(clientOptions, oss.Region("yourRegion"))
	clientOptions = append(clientOptions, oss.AuthVersion(oss.AuthV4))
	client, err := oss.New("yourEndpoint", "", "", clientOptions...)
	if err != nil {
		fmt.Println("Error:", err)
		os.Exit(-1)
	}

	isTrue := true
	isFalse := false

	// rule1: transition current-version objects (prefix "logs", <=64 KB) to IA
	// 30 days after last access. Objects remain in IA on next access.
	rule1 := oss.LifecycleRule{
		ID:     "rule1",
		Prefix: "logs",
		Status: "Enabled",
		Transitions: []oss.LifecycleTransition{
			{
				Days:                 30,
				StorageClass:         oss.StorageIA,
				IsAccessTime:         &isTrue,
				ReturnToStdWhenVisit: &isFalse,
				AllowSmallFile:       &isTrue, // Include objects <=64 KB
			},
		},
	}

	// rule2: transition noncurrent-version objects (prefix "dir", >64 KB) to IA
	// 10 days after last access. Objects return to Standard on next access.
	rule2 := oss.LifecycleRule{
		ID:     "rule2",
		Prefix: "dir",
		Status: "Enabled",
		NonVersionTransitions: []oss.LifecycleVersionTransition{
			{
				NoncurrentDays:       10,
				StorageClass:         oss.StorageIA,
				IsAccessTime:         &isTrue,
				ReturnToStdWhenVisit: &isTrue,
				AllowSmallFile:       &isFalse, // Exclude objects <=64 KB
			},
		},
	}

	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 lifecycle success")
}

Get lifecycle rules

client.GetBucketLifecycle(bucketName) returns all lifecycle rules configured for a bucket. The following example retrieves and prints the rules for yourBucketName.

package main

import (
	"fmt"
	"os"

	"github.com/aliyun/aliyun-oss-go-sdk/oss"
)

func main() {
	bucketName := "yourBucketName"

	provider, err := oss.NewEnvironmentVariableCredentialsProvider()
	if err != nil {
		fmt.Println("Error:", err)
		os.Exit(-1)
	}

	clientOptions := []oss.ClientOption{oss.SetCredentialsProvider(&provider)}
	clientOptions = append(clientOptions, oss.Region("yourRegion"))
	clientOptions = append(clientOptions, oss.AuthVersion(oss.AuthV4))
	client, err := oss.New("yourEndpoint", "", "", clientOptions...)
	if err != nil {
		fmt.Println("Error:", err)
		os.Exit(-1)
	}

	lcRes, err := client.GetBucketLifecycle(bucketName)
	if err != nil {
		fmt.Println("Error:", err)
		os.Exit(-1)
	}

	for _, rule := range lcRes.Rules {
		fmt.Println("Lifecycle Rule Id:", rule.ID)
		fmt.Println("Lifecycle Rule Prefix:", rule.Prefix)
		fmt.Println("Lifecycle Rule Status:", rule.Status)

		if rule.Expiration != nil {
			fmt.Println("Lifecycle Rule Expiration Days:", rule.Expiration.Days)
			fmt.Println("Lifecycle Rule Expiration Date:", rule.Expiration.Date)
			fmt.Println("Lifecycle Rule Expiration Created Before Date:", rule.Expiration.CreatedBeforeDate)
			if rule.Expiration.ExpiredObjectDeleteMarker != nil {
				fmt.Println("Lifecycle Rule Expiration Expired Object DeleteMarker:", *rule.Expiration.ExpiredObjectDeleteMarker)
			}
		}

		for _, tag := range rule.Tags {
			fmt.Println("Lifecycle Rule Tag Key:", tag.Key)
			fmt.Println("Lifecycle Rule Tag Value:", tag.Value)
		}

		for _, transition := range rule.Transitions {
			fmt.Println("Lifecycle Rule Transition Days:", transition.Days)
			fmt.Println("Lifecycle Rule Transition Created Before Date:", transition.CreatedBeforeDate)
			fmt.Println("Lifecycle Rule Transition Storage Class:", transition.StorageClass)
			if transition.IsAccessTime != nil {
				fmt.Println("Lifecycle Rule Transition Is Access Time:", *transition.IsAccessTime)
			}
			if transition.ReturnToStdWhenVisit != nil {
				fmt.Println("Lifecycle Rule Transition Return To Std When Visit:", *transition.ReturnToStdWhenVisit)
			}
			if transition.AllowSmallFile != nil {
				fmt.Println("Lifecycle Rule Transition Allow Small File:", *transition.AllowSmallFile)
			}
		}

		if rule.AbortMultipartUpload != nil {
			fmt.Println("Lifecycle Rule Abort Multipart Upload Days:", rule.AbortMultipartUpload.Days)
			fmt.Println("Lifecycle Rule Abort Multipart Upload Created Before Date:", rule.AbortMultipartUpload.CreatedBeforeDate)
		}

		if rule.NonVersionExpiration != nil {
			fmt.Println("Lifecycle Non Version Expiration Non Current Days:", rule.NonVersionExpiration.NoncurrentDays)
		}

		for _, nonVersionTransition := range rule.NonVersionTransitions {
			fmt.Println("Lifecycle Rule Non Version Transitions Non current Days:", nonVersionTransition.NoncurrentDays)
			fmt.Println("Lifecycle Rule Non Version Transition Storage Class:", nonVersionTransition.StorageClass)
			if nonVersionTransition.IsAccessTime != nil {
				fmt.Println("Lifecycle Rule Non Version Transition Is Access Time:", *nonVersionTransition.IsAccessTime)
			}
			if nonVersionTransition.ReturnToStdWhenVisit != nil {
				fmt.Println("Lifecycle Rule Non Version Transition Return To Std When Visit:", *nonVersionTransition.ReturnToStdWhenVisit)
			}
			if nonVersionTransition.AllowSmallFile != nil {
				fmt.Println("Lifecycle Rule Non Version Allow Small File:", *nonVersionTransition.AllowSmallFile)
			}

			if rule.Filter != nil {
				if rule.Filter.ObjectSizeGreaterThan != nil {
					fmt.Println("Lifecycle Rule Filter Object Size Greater Than:", *rule.Filter.ObjectSizeGreaterThan)
				}
				if rule.Filter.ObjectSizeLessThan != nil {
					fmt.Println("Lifecycle Rule Filter Object Size Less Than:", *rule.Filter.ObjectSizeLessThan)
				}
				for _, filterNot := range rule.Filter.Not {
					fmt.Println("Lifecycle Rule Filter Not Prefix:", filterNot.Prefix)
					if filterNot.Tag != nil {
						fmt.Println("Lifecycle Rule Filter Not Tag Key:", filterNot.Tag.Key)
						fmt.Println("Lifecycle Rule Filter Not Tag Value:", filterNot.Tag.Value)
					}
				}
			}
		}
	}
}

Delete all lifecycle rules

client.DeleteBucketLifecycle(bucketName) removes all lifecycle rules from a bucket. To delete individual rules instead, see How do I delete one or more lifecycle rules?

package main

import (
	"fmt"
	"os"

	"github.com/aliyun/aliyun-oss-go-sdk/oss"
)

func main() {
	bucketName := "yourBucketName"

	provider, err := oss.NewEnvironmentVariableCredentialsProvider()
	if err != nil {
		fmt.Println("Error:", err)
		os.Exit(-1)
	}

	clientOptions := []oss.ClientOption{oss.SetCredentialsProvider(&provider)}
	clientOptions = append(clientOptions, oss.Region("yourRegion"))
	clientOptions = append(clientOptions, oss.AuthVersion(oss.AuthV4))
	client, err := oss.New("yourEndpoint", "", "", clientOptions...)
	if err != nil {
		fmt.Println("Error:", err)
		os.Exit(-1)
	}

	err = client.DeleteBucketLifecycle(bucketName)
	if err != nil {
		fmt.Println("Error:", err)
		os.Exit(-1)
	}
}

References

Complete sample code: bucket_lifecycle.go on GitHub
API reference: PutBucketLifecycle
API reference: GetBucketLifecycle
API reference: DeleteBucketLifecycle