Ciclo de vida (Go SDK V1) - Object Storage Service - Centro de documentación de Alibaba Cloud

No todos los datos cargados en Object Storage Service (OSS) requieren acceso frecuente. Por motivos como cumplimiento normativo o archivado, es posible que necesite almacenar algunos datos en una clase de almacenamiento frío. Configure una regla de ciclo de vida basada en la hora de última modificación para eliminar por lotes los datos que ya no necesita. Para que OSS supervise automáticamente los patrones de acceso a los datos, detecte los datos fríos y los transfiera a una clase de almacenamiento diferente, configure una regla de ciclo de vida basada en la hora de último acceso. Este proceso implementa la clasificación automática de almacenamiento y reduce sus costos de almacenamiento.

Notas

Antes de configurar reglas de ciclo de vida basadas en la hora de última modificación o de último acceso de los objetos, asegúrese de familiarizarse con esta función. Para obtener más información, consulte Lifecycle rules based on the last modified time y Lifecycle rules based on the last access time.

En este tema se utiliza el endpoint público de la región China (Hangzhou). Si desea acceder a OSS desde otros servicios de Alibaba Cloud en la misma región, utilice un endpoint interno. Para obtener más información sobre las regiones y endpoints de OSS, consulte Regions and endpoints.
En este tema, las credenciales de acceso se obtienen de variables de entorno. Para obtener más información sobre cómo configurar las credenciales de acceso, consulte Configure access credentials.
Este tema muestra cómo crear una instancia de OSSClient con un endpoint de OSS. Para configuraciones alternativas, como el uso de un dominio personalizado o la autenticación con credenciales de Security Token Service (STS), consulte Configure a client (Go SDK V1).
Para configurar reglas de ciclo de vida, debe tener el permiso oss:PutBucketLifecycle. Para consultar reglas de ciclo de vida, debe tener el permiso oss:GetBucketLifecycle. Para borrar reglas de ciclo de vida, debe tener el permiso oss:DeleteBucketLifecycle. Para obtener más información, consulte Grant a custom policy.

Establecer reglas de ciclo de vida

A continuación se presentan ejemplos de código para establecer reglas de ciclo de vida basadas en la hora de última modificación y de último acceso. Para modificar una o más reglas después de configurarlas, consulte How do I modify one or more lifecycle rule configurations?.

Transición de clases de almacenamiento y eliminación de archivos según la hora de última modificación

El siguiente código muestra cómo establecer una regla de ciclo de vida para un bucket llamado examplebucket con el fin de cambiar las clases de almacenamiento y eliminar archivos según la hora de última modificación.

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 the bucket. For example, for the China (Hangzhou) region, set the Endpoint to https://oss-cn-hangzhou.aliyuncs.com. For other regions, use the actual Endpoint.
	// Set yourRegion to the region where the bucket is located. For example, for the China (Hangzhou) region, set the region to cn-hangzhou. For other regions, use the actual region.
	clientOptions := []oss.ClientOption{oss.SetCredentialsProvider(&provider)}
	clientOptions = append(clientOptions, oss.Region("yourRegion"))
	// Set the signature version.
	clientOptions = append(clientOptions, oss.AuthVersion(oss.AuthV4))
	client, err := oss.New("yourEndpoint", "", "", clientOptions...)
	if err != nil {
		fmt.Println("Error:", err)
		os.Exit(-1)
	}
	// Specify the bucket name.
	bucketName := "examplebucket"
	// Specify lifecycle rule 1. This rule specifies that files with the prefix "foo/" expire 3 days after they are last modified.
	rule1 := oss.BuildLifecycleRuleByDays("rule1", "foo/", true, 3)

	// Automatically delete delete markers for objects in a versioning-enabled bucket when the objects have only delete markers.
	deleteMark := true
	expiration := oss.LifecycleExpiration{
		ExpiredObjectDeleteMarker: &deleteMark,
	}

	// Delete noncurrent versions of objects 30 days after they become noncurrent.
	versionExpiration := oss.LifecycleVersionExpiration{
		NoncurrentDays: 30,
	}

	// Transition noncurrent versions of objects to the Infrequent Access (IA) storage class 10 days after they become noncurrent.
	versionTransition := oss.LifecycleVersionTransition{
		NoncurrentDays: 10,
		StorageClass:   "IA",
	}

	// Specify lifecycle rule 2.
	rule2 := oss.LifecycleRule{
		ID:                   "rule2",
		Prefix:               "yourObjectPrefix",
		Status:               "Enabled",
		Expiration:           &expiration,
		NonVersionExpiration: &versionExpiration,
		NonVersionTransitions: []oss.LifecycleVersionTransition{
			versionTransition,
		},
	}

	// Specify lifecycle rule 3. This rule specifies that files with the tag key "tag1" and tag value "value1" expire 3 days after they are last modified.
	rule3 := oss.LifecycleRule{
		ID:     "rule3",
		Prefix: "",
		Status: "Enabled",
		Tags: []oss.Tag{
			{
				Key:   "tag1",
				Value: "value1",
			},
		},
		Expiration: &oss.LifecycleExpiration{Days: 3},
	}

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

Transición de clase de almacenamiento para archivos, excluyendo aquellos con un prefijo y etiqueta específicos, según la hora de última modificación

El siguiente código utiliza el elemento Not bajo el nodo filter para transferir todos los archivos en examplebucket a la clase de almacenamiento Infrequent Access 30 días después de su hora de última modificación. Se excluyen los archivos con el prefijo log, una etiqueta con la clave key1 y valor value1, y un tamaño especificado.

package main

import (
	"fmt"
	"os"

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

func main() {
	// Set yourBucketName to the name of your 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 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 the bucket. For example, for the China (Hangzhou) region, set the Endpoint to https://oss-cn-hangzhou.aliyuncs.com. For other regions, use the actual Endpoint.
	// Set yourRegion to the region where the bucket is located. For example, for the China (Hangzhou) region, set the region to cn-hangzhou. For other regions, use the actual region.
	clientOptions := []oss.ClientOption{oss.SetCredentialsProvider(&provider)}
	clientOptions = append(clientOptions, oss.Region("yourRegion"))
	// Set the signature version.
	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",
	}
	// Specify the minimum size of objects to which the lifecycle rule applies.
	size := int64(500)
	// Specify the maximum size of objects to which the lifecycle rule applies.
	smallSize := int64(64500)
	filter := oss.LifecycleFilter{
		ObjectSizeGreaterThan: &size,
		ObjectSizeLessThan:    &smallSize,
		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,
	}
	var 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")
}

Transición de clases de almacenamiento según la hora de último acceso

El siguiente código muestra cómo establecer una regla de ciclo de vida para un bucket llamado yourBucketName con el fin de cambiar las clases de almacenamiento según la hora de último acceso.

package main

import (
	"fmt"
	"os"

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

func main() {
	// Set yourBucketName to the name of your 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 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 the bucket. For example, for the China (Hangzhou) region, set the Endpoint to https://oss-cn-hangzhou.aliyuncs.com. For other regions, use the actual Endpoint.
	// Set yourRegion to the region where the bucket is located. For example, for the China (Hangzhou) region, set the region to cn-hangzhou. For other regions, use the actual region.
	clientOptions := []oss.ClientOption{oss.SetCredentialsProvider(&provider)}
	clientOptions = append(clientOptions, oss.Region("yourRegion"))
	// Set the signature version.
	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
	// Specify lifecycle rule 1. This rule transitions all objects that have the prefix "logs" and are 64 KB or smaller to the Infrequent Access storage class 30 days after they are last accessed. When these objects are accessed again, they remain in the Infrequent Access storage class.
	rule1 := oss.LifecycleRule{
		ID:     "rule1",
		Prefix: "logs",
		Status: "Enabled",
		Transitions: []oss.LifecycleTransition{
			{
				Days:                 30,
				StorageClass:         oss.StorageIA,
				IsAccessTime:         &isTrue,
				ReturnToStdWhenVisit: &isFalse,
				AllowSmallFile:       &isTrue,
			},
		},
	}
	// Specify lifecycle rule 2. This rule transitions all noncurrent versions of objects that have the prefix "dir" and are larger than 64 KB to the Infrequent Access storage class 10 days after they are last accessed. When these objects are accessed again, they are transitioned back to the Standard storage class.
	rule2 := oss.LifecycleRule{
		ID:     "rule2",
		Prefix: "dir",
		Status: "Enabled",
		NonVersionTransitions: []oss.LifecycleVersionTransition{
			{
				NoncurrentDays:       10,
				StorageClass:         oss.StorageIA,
				IsAccessTime:         &isTrue,
				ReturnToStdWhenVisit: &isTrue,
				AllowSmallFile:       &isFalse,
			},
		},
	}
	// Set 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 lifecycle success")
}

Consultar reglas de ciclo de vida

El siguiente código muestra cómo consultar las reglas de ciclo de vida configuradas para el bucket llamado examplebucket:

package main

import (
	"fmt"
	"os"

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

func main() {
	// Set yourBucketName to the name of your 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 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 the bucket. For example, for the China (Hangzhou) region, set the Endpoint to https://oss-cn-hangzhou.aliyuncs.com. For other regions, use the actual Endpoint.
	// Set yourRegion to the region where the bucket is located. For example, for the China (Hangzhou) region, set the region to cn-hangzhou. For other regions, use the actual region.
	clientOptions := []oss.ClientOption{oss.SetCredentialsProvider(&provider)}
	clientOptions = append(clientOptions, oss.Region("yourRegion"))
	// Set the signature version.
	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)
					}
				}
			}
		}
	}
}

Borrar reglas de ciclo de vida

El siguiente código muestra cómo borrar las reglas de ciclo de vida en un bucket llamado examplebucket. Si desea eliminar una o más reglas de ciclo de vida, consulte Delete lifecycle rules.

package main

import (
	"fmt"
	"os"

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

func main() {
	// Set yourBucketName to the name of your 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 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 the bucket. For example, for the China (Hangzhou) region, set the Endpoint to https://oss-cn-hangzhou.aliyuncs.com. For other regions, use the actual Endpoint.
	// Set yourRegion to the region where the bucket is located. For example, for the China (Hangzhou) region, set the region to cn-hangzhou. For other regions, use the actual region.
	clientOptions := []oss.ClientOption{oss.SetCredentialsProvider(&provider)}
	clientOptions = append(clientOptions, oss.Region("yourRegion"))
	// Set the signature version.
	clientOptions = append(clientOptions, oss.AuthVersion(oss.AuthV4))
	client, err := oss.New("yourEndpoint", "", "", clientOptions...)
	if err != nil {
		fmt.Println("Error:", err)
		os.Exit(-1)
	}

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

Referencias

Para ver el código de ejemplo completo sobre reglas de ciclo de vida, consulte el ejemplo en GitHub.
Para obtener más información sobre la operación de API que puede llamar para establecer reglas de ciclo de vida, consulte PutBucketLifecycle.
Para obtener más información sobre la operación de API que puede llamar para consultar reglas de ciclo de vida, consulte GetBucketLifecycle.
Para obtener más información sobre la operación de API que puede llamar para eliminar todas las reglas de ciclo de vida, consulte DeleteBucketLifecycle.