# Uso de S3 Lifecycle para buckets de directorio S3 Lifecycle lo ayuda a almacenar objetos en S3 Express One Zone en buckets de directorio de forma rentable mediante la eliminación de los objetos caducados en su nombre. Para administrar el ciclo de vida de los objetos, cree una configuración de S3 Lifecycle para el bucket de directorio. La configuración de S3 Lifecycle es un conjunto de reglas que definen acciones que Amazon S3 aplica a un grupo de objetos. Puede establecer una configuración de Amazon S3 Lifecycle en un bucket de directorio mediante la interfaz de la línea de comandos de AWS (CLI de AWS), los SDK de AWS, la API de REST de Amazon S3 y AWS CloudFormation. En la configuración del ciclo de vida, utilice reglas para definir las acciones que desea que Amazon S3 realice en los objetos. En el caso de los objetos almacenados en buckets de directorio, puede crear reglas de ciclo de vida para que los objetos caduquen a medida que envejecen. También puede crear reglas de ciclo de vida para eliminar las cargas incompletas de varias partes en los buckets de directorio con una frecuencia diaria. Cuando añade una configuración de ciclo de vida a un bucket, las reglas de configuración se aplican a los objetos existentes y a los objetos que añade posteriormente. Por ejemplo, si hoy agrega una regla de configuración de Lifecycle con una acción de vencimiento que causa que objetos con un prefijo específico caduquen 30 días después de la creación, S3 pondrá en cola de eliminación cualquier objeto existente con más de 30 días de antigüedad y que tenga el prefijo especificado. ## En qué se diferencia S3 Lifecycle para buckets de directorio Para los objetos en buckets de directorio, puede crear reglas de ciclo de vida para hacer caducar los objetos y eliminar las cargas incompletas de varias partes. Sin embargo, S3 Lifecycle para buckets de directorio no admite acciones de transición entre clases de almacenamiento. **CreateSession** Lifecycle utiliza operaciones de API `DeleteObject` y `DeleteObjects` públicas para hacer caducar los objetos de los buckets de directorio. Para usar estas operaciones de API, S3 Lifecycle usará la API `CreateSession` para establecer credenciales de seguridad temporales a fin de acceder a los objetos de los buckets de directorio. Para obtener más información, consulte [`CreateSession` en la *Referencia de la API de Amazon S3*](https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateSession.html). Si tiene una política activa que deniega los permisos de eliminación a la entidad principal del ciclo de vida, se impedirá que usted permita que S3 Lifecycle elimine objetos en su nombre. ### Uso de una política de bucket para conceder permisos a la entidad principal del servicio S3 Lifecycle La política de bucket siguiente concede permiso a la entidad principal de servicio de ciclo de vida de S3 para crear sesiones para realizar operaciones como `DeleteObject` y `DeleteObjects`. Cuando no se especifica ningún modo de sesión en una solicitud de `CreateSession`, la sesión se crea con el privilegio máximo permitido según los permisos establecidos (se intenta primero `ReadWrite` y, después, `ReadOnly` si `ReadWrite` no está permitido). Sin embargo, las sesiones de `ReadOnly` son insuficientes para las operaciones del ciclo de vida que modifican o eliminan objetos. Por lo tanto, este ejemplo requiere explícitamente un modo de sesión de `ReadWrite` mediante la clave de condición de `s3express:SessionMode`. **Example - Política de bucket que permite realizar llamadas `CreateSession` con un modo de sesión de `ReadWrite` explícito para las operaciones del ciclo de vida** ``` { "Version":"2008-10-17", "Statement":[ { "Effect":"Allow", "Principal": { "Service":"lifecycle.s3.amazonaws.com" }, "Action":"s3express:CreateSession", "Condition": { "StringEquals": { "s3express:SessionMode": "ReadWrite" } }, "Resource":"arn:aws:s3express:us-east-2:412345678921:bucket/amzn-s3-demo-bucket--use2-az2--x-s3" } ] } ``` ### Supervisión de las reglas del ciclo de vida En el caso de los objetos almacenados en buckets de directorio, S3 Lifecycle genera registros de eventos de datos y de administración de AWS CloudTrail. Para obtener más información, consulte [Ejemplos de archivos de registro de CloudTrail para S3 Express One Zone](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-express-log-files.html). Para obtener más información sobre cómo crear configuraciones de ciclo de vida y solucionar los problemas relacionados con S3 Lifecycle, consulte los temas siguientes: **Topics** # Creación y administración de una configuración de ciclo de vida para un bucket de directorio Puede crear una configuración de ciclo de vida para los buckets de directorio mediante AWS Command Line Interface (AWS CLI), los SDK de AWS y las API de REST. ## Uso de la CLI de AWS Puede utilizar los siguientes comandos de la AWS CLI para administrar configuraciones de ciclo de vida de S3: + `put-bucket-lifecycle-configuration` + `get-bucket-lifecycle-configuration` + `delete-bucket-lifecycle` Para obtener instrucciones sobre la configuración de la AWS CLI, consulte [Developing with Amazon S3 using the AWS CLI](https://docs.aws.amazon.com/AmazonS3/latest/API/setup-aws-cli.html) en la *Amazon S3 API Reference*. La configuración de Amazon S3 Lifecycle es un archivo XML. Pero cuando se usa la AWS CLI no se puede especificar el formato XML. Debe especificar el formato JSON en su lugar. A continuación, se indican ejemplos de configuraciones de Lifecycle de XML y las configuraciones de JSON equivalentes que puede especificar en un comando de AWS CLI. En el siguiente ejemplo de la CLI de AWS, se aplica una política de configuración del ciclo de vida en un bucket de directorio. Esta política especifica que todos los objetos que tienen el prefijo marcado (myprefix) y el tamaño de objeto definido caducan después de siete días. Para utilizar este ejemplo, reemplace cada *marcador de posición de entrada del usuario* con su propia información. Guarde la política de configuración del ciclo de vida en un archivo JSON. En este ejemplo, el archivo se denomina lifecycle1.json. **Example** ``` { "Rules": [ { "Expiration": { "Days": 7 }, "ID": "Lifecycle expiration rule", "Filter": { "And": { "Prefix": "myprefix/", "ObjectSizeGreaterThan": 500, "ObjectSizeLessThan": 64000 } }, "Status": "Enabled" } ] } ``` Envíe el archivo JSON como parte del comando de la CLI `put-bucket-lifecycle-configuration`. Para utilizar este comando, reemplace cada *marcador de posición de entrada del usuario* con su propia información. ``` aws s3api put-bucket-lifecycle-configuration --region us-west-2 --profile default --bucket amzn-s3-demo-bucket--usw2-az1--x-s3 --lifecycle-configuration file://lc-policy.json --checksum-algorithm crc32c ``` **Example** ``` Lifecycle expiration rule myprefix/ 500 64000 Enabled 7 ``` ## Uso de los AWS SDK ------ #### [ SDK for Java ] **Example** ``` import software.amazon.awssdk.services.s3.model.PutBucketLifecycleConfigurationRequest; import software.amazon.awssdk.services.s3.model.PutBucketLifecycleConfigurationResponse; import software.amazon.awssdk.services.s3.model.ChecksumAlgorithm; import software.amazon.awssdk.services.s3.model.BucketLifecycleConfiguration; import software.amazon.awssdk.services.s3.model.LifecycleRule; import software.amazon.awssdk.services.s3.model.LifecycleRuleFilter; import software.amazon.awssdk.services.s3.model.LifecycleExpiration; import software.amazon.awssdk.services.s3.model.LifecycleRuleAndOperator; import software.amazon.awssdk.services.s3.model.GetBucketLifecycleConfigurationResponse; import software.amazon.awssdk.services.s3.model.GetBucketLifecycleConfigurationRequest; import software.amazon.awssdk.services.s3.model.DeleteBucketLifecycleRequest; import software.amazon.awssdk.services.s3.model.DeleteBucketLifecycleResponse; import software.amazon.awssdk.services.s3.model.AbortIncompleteMultipartUpload; // PUT a Lifecycle policy LifecycleRuleFilter objectExpirationFilter = LifecycleRuleFilter.builder().and(LifecycleRuleAndOperator.builder().prefix("dir1/").objectSizeGreaterThan(3L).objectSizeLessThan(20L).build()).build(); LifecycleRuleFilter mpuExpirationFilter = LifecycleRuleFilter.builder().prefix("dir2/").build(); LifecycleRule objectExpirationRule = LifecycleRule.builder().id("lc").filter(objectExpirationFilter).status("Enabled").expiration(LifecycleExpiration.builder() .days(10) .build()) .build(); LifecycleRule mpuExpirationRule = LifecycleRule.builder().id("lc-mpu").filter(mpuExpirationFilter).status("Enabled").abortIncompleteMultipartUpload(AbortIncompleteMultipartUpload.builder() .daysAfterInitiation(10) .build()) .build(); PutBucketLifecycleConfigurationRequest putLifecycleRequest = PutBucketLifecycleConfigurationRequest.builder() .bucket("amzn-s3-demo-bucket--usw2-az1--x-s3") .checksumAlgorithm(ChecksumAlgorithm.CRC32) .lifecycleConfiguration( BucketLifecycleConfiguration.builder() .rules(objectExpirationRule, mpuExpirationRule) .build() ).build(); PutBucketLifecycleConfigurationResponse resp = client.putBucketLifecycleConfiguration(putLifecycleRequest); // GET the Lifecycle policy GetBucketLifecycleConfigurationResponse getResp = client.getBucketLifecycleConfiguration(GetBucketLifecycleConfigurationRequest.builder().bucket("amzn-s3-demo-bucket--usw2-az1--x-s3").build()); // DELETE the Lifecycle policy DeleteBucketLifecycleResponse delResp = client.deleteBucketLifecycle(DeleteBucketLifecycleRequest.builder().bucket("amzn-s3-demo-bucket--usw2-az1--x-s3").build()); ``` ------ #### [ SDK for Go ] **Example** ``` package main import ( "context" "log" "github.com/aws/aws-sdk-go-v2/aws" "github.com/aws/aws-sdk-go-v2/config" "github.com/aws/aws-sdk-go-v2/service/s3" "github.com/aws/aws-sdk-go-v2/service/s3/types" ) // PUT a Lifecycle policy func putBucketLifecycleConfiguration(client *s3.Client, bucketName string ) error { lifecycleConfig := &s3.PutBucketLifecycleConfigurationInput{ Bucket: aws.String(bucketName), LifecycleConfiguration: &types.BucketLifecycleConfiguration{ Rules: []types.LifecycleRule{ { ID: aws.String("lc"), Filter: &types.LifecycleRuleFilter{ And: &types.LifecycleRuleAndOperator{ Prefix: aws.String("foo/"), ObjectSizeGreaterThan: aws.Int64(1000000), ObjectSizeLessThan: aws.Int64(100000000), }, }, Status: types.ExpirationStatusEnabled, Expiration: &types.LifecycleExpiration{ Days: aws.Int32(int32(1)), }, }, { ID: aws.String("abortmpu"), Filter: &types.LifecycleRuleFilter{ Prefix: aws.String("bar/"), }, Status: types.ExpirationStatusEnabled, AbortIncompleteMultipartUpload: &types.AbortIncompleteMultipartUpload{ DaysAfterInitiation: aws.Int32(int32(5)), }, }, }, }, } _, err := client.PutBucketLifecycleConfiguration(context.Background(), lifecycleConfig) return err } // Get the Lifecycle policy func getBucketLifecycleConfiguration(client *s3.Client, bucketName string) error { getLifecycleConfig := &s3.GetBucketLifecycleConfigurationInput{ Bucket: aws.String(bucketName), } resp, err := client.GetBucketLifecycleConfiguration(context.Background(), getLifecycleConfig) if err != nil { return err } return nil } // Delete the Lifecycle policy func deleteBucketLifecycleConfiguration(client *s3.Client, bucketName string) error { deleteLifecycleConfig := &s3.DeleteBucketLifecycleInput{ Bucket: aws.String(bucketName), } _, err := client.DeleteBucketLifecycle(context.Background(), deleteLifecycleConfig) return err } func main() { cfg, err := config.LoadDefaultConfig(context.Background(), config.WithRegion("us-west-2")) // Specify your region here if err != nil { log.Fatalf("unable to load SDK config, %v", err) } s3Client := s3.NewFromConfig(cfg) bucketName := "amzn-s3-demo-bucket--usw2-az1--x-s3" putBucketLifecycleConfiguration(s3Client, bucketName) getBucketLifecycleConfiguration(s3Client, bucketName) deleteBucketLifecycleConfiguration(s3Client, bucketName) getBucketLifecycleConfiguration(s3Client, bucketName) } ``` ------ #### [ SDK for .NET ] **Example** ``` using Amazon; using Amazon.S3; using Amazon.S3.Model; using System; using System.Collections.Generic; using System.Threading.Tasks; namespace Amazon.DocSamples.S3 { class LifecycleTest { private const string bucketName = "amzn-s3-demo-bucket--usw2-az1--x-s3"; // Specify your bucket region (an example region is shown). private static readonly RegionEndpoint bucketRegion = RegionEndpoint.USWest2; private static IAmazonS3 client; public static void Main() { client = new AmazonS3Client(bucketRegion); AddUpdateDeleteLifecycleConfigAsync().Wait(); } private static async Task AddUpdateDeleteLifecycleConfigAsync() { try { var lifeCycleConfiguration = new LifecycleConfiguration() { Rules = new List { new LifecycleRule { Id = "delete rule", Filter = new LifecycleFilter() { LifecycleFilterPredicate = new LifecyclePrefixPredicate() { Prefix = "projectdocs/" } }, Status = LifecycleRuleStatus.Enabled, Expiration = new LifecycleRuleExpiration() { Days = 10 } } } }; // Add the configuration to the bucket. await AddExampleLifecycleConfigAsync(client, lifeCycleConfiguration); // Retrieve an existing configuration. lifeCycleConfiguration = await RetrieveLifecycleConfigAsync(client); // Add a new rule. lifeCycleConfiguration.Rules.Add(new LifecycleRule { Id = "mpu abort rule", Filter = new LifecycleFilter() { LifecycleFilterPredicate = new LifecyclePrefixPredicate() { Prefix = "YearlyDocuments/" } }, Expiration = new LifecycleRuleExpiration() { Days = 10 }, AbortIncompleteMultipartUpload = new LifecycleRuleAbortIncompleteMultipartUpload() { DaysAfterInitiation = 10 } }); // Add the configuration to the bucket. await AddExampleLifecycleConfigAsync(client, lifeCycleConfiguration); // Verify that there are now two rules. lifeCycleConfiguration = await RetrieveLifecycleConfigAsync(client); Console.WriteLine("Expected # of rulest=2; found:{0}", lifeCycleConfiguration.Rules.Count); // Delete the configuration. await RemoveLifecycleConfigAsync(client); // Retrieve a nonexistent configuration. lifeCycleConfiguration = await RetrieveLifecycleConfigAsync(client); } catch (AmazonS3Exception e) { Console.WriteLine("Error encountered ***. Message:'{0}' when writing an object", e.Message); } catch (Exception e) { Console.WriteLine("Unknown encountered on server. Message:'{0}' when writing an object", e.Message); } } static async Task AddExampleLifecycleConfigAsync(IAmazonS3 client, LifecycleConfiguration configuration) { PutLifecycleConfigurationRequest request = new PutLifecycleConfigurationRequest { BucketName = bucketName, Configuration = configuration }; var response = await client.PutLifecycleConfigurationAsync(request); } static async Task RetrieveLifecycleConfigAsync(IAmazonS3 client) { GetLifecycleConfigurationRequest request = new GetLifecycleConfigurationRequest { BucketName = bucketName }; var response = await client.GetLifecycleConfigurationAsync(request); var configuration = response.Configuration; return configuration; } static async Task RemoveLifecycleConfigAsync(IAmazonS3 client) { DeleteLifecycleConfigurationRequest request = new DeleteLifecycleConfigurationRequest { BucketName = bucketName }; await client.DeleteLifecycleConfigurationAsync(request); } } } ``` ------ #### [ SDK for Python ] **Example** ``` import boto3 client = boto3.client("s3", region_name="us-west-2") bucket_name = 'amzn-s3-demo-bucket--usw2-az1--x-s3' client.put_bucket_lifecycle_configuration( Bucket=bucket_name, ChecksumAlgorithm='CRC32', LifecycleConfiguration={ 'Rules': [ { 'ID': 'lc', 'Filter': { 'And': { 'Prefix': 'foo/', 'ObjectSizeGreaterThan': 1000000, 'ObjectSizeLessThan': 100000000, } }, 'Status': 'Enabled', 'Expiration': { 'Days': 1 } }, { 'ID': 'abortmpu', 'Filter': { 'Prefix': 'bar/' }, 'Status': 'Enabled', 'AbortIncompleteMultipartUpload': { 'DaysAfterInitiation': 5 } } ] } ) result = client.get_bucket_lifecycle_configuration( Bucket=bucket_name ) client.delete_bucket_lifecycle( Bucket=bucket_name ) ``` ------ # Solución de problemas de S3 Lifecycle para buckets de directorio **Topics** + [He configurado mi ciclo de vida, pero los objetos de mi bucket de directorio no caducan](#troubleshoot-directory-bucket-lifecycle-1) + [¿Cómo puedo supervisar las acciones que se llevan a cabo según mis reglas de ciclo de vida?](#troubleshoot-directory-bucket-lifecycle-2) ## He configurado mi ciclo de vida, pero los objetos de mi bucket de directorio no caducan S3 Lifecycle para buckets de directorio utiliza API públicas para eliminar objetos de S3 Express One Zone. Para usar las API públicas de nivel de objeto, debe conceder permiso a `CreateSession` y permitir que S3 Lifecycle para elimine los objetos. Si tiene una política activa que deniega las eliminaciones, se impedirá que usted permita que S3 Lifecycle elimine objetos en su nombre. Es importante configurar las políticas de bucket de forma correcta para garantizar que los objetos que desee eliminar cumplan los requisitos para caducar. Puede consultar los registros de AWS CloudTrail para los registros de seguimiento `AccessDenied` de las invocaciones a la API `CreateSession` en CloudTrail para comprobar si se ha denegado el acceso. La comprobación de los registros de CloudTrail puede ayudarlo a solucionar problemas de acceso e identificar la causa principal de los errores de acceso denegado. A continuación, podrá corregir los controles de acceso incorrectos mediante la actualización de las políticas pertinentes. Si confirma que las políticas de bucket están configuradas correctamente y sigue teniendo problemas, le recomendamos que revise las reglas del ciclo de vida para asegurarse de que se aplican al subconjunto de objetos correcto. ## ¿Cómo puedo supervisar las acciones que se llevan a cabo según mis reglas de ciclo de vida? Puede usar los registros de eventos de datos de AWS CloudTrail para supervisar las acciones que lleva a cabo S3 Lifecycle en los buckets de directorio. Para obtener más información, consulte [Ejemplos de archivos de registro de CloudTrail](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-express-log-files.html).