在存储桶上设置生命周期配置

本部分介绍如何使用 AWS 开发工具包、AWS CLI 或 S3 控制台在存储桶上设置 S3 生命周期配置。有关 S3 生命周期配置的信息，请参阅管理存储生命周期。

您可以使用生命周期规则来定义您希望 Amazon S3 在对象的生命周期内执行的操作（例如，将对象转化为另一个存储类别、检索它们或在指定时期后删除它们）。

在设置生命周期配置之前，请注意以下情况：

传播延迟

将 S3 生命周期配置添加到存储桶时，在将新的或更新的生命周期配置完全传播到所有 Amazon S3 系统前通常存在一些滞后。在此配置完全生效之前，预计会有几分钟延迟。在删除 S3 生命周期配置时也可能出现这种延迟。

禁用或删除生命周期规则

禁用或删除生命周期规则时，在短暂延迟后 Amazon S3 会停止安排新对象的删除或转换。已安排的任何对象都将被取消安排，并且不会被删除或转换。

现有对象和新对象

当您向存储桶添加生命周期配置时，配置规则将应用到现有对象以及您在以后添加的对象。例如，如果您在今天添加带有过期操作的生命周期配置规则，而该规则使带有特定前缀的对象在创建 30 天后过期，Amazon S3 会将任何超过 30 天的现有对象加入删除队列。

账单发生变化

当满足生命周期配置规则时，可能经过一些滞后才会触发相应的操作。但一满足生命周期配置规则，账单就会立即发生变化，无论是否执行操作。

例如，在对象到期后，即使没有立即删除，也不会向您收取存储费。另一个示例是对象转换时间一过就会立即按照 Amazon S3 Glacier 存储费率向您收费，即使没有立即将该对象转换为 S3 Glacier 存储类也是如此。生命周期转换为 S3 智能分层存储类是例外。在对象转换为 S3 智能分层存储类之前，账单不会发生更改。

您可以使用共享前缀（以通用字符串开头的对象名称）或标签为存储桶中的所有对象或一部分对象定义生命周期规则。

使用生命周期规则，您可以定义特定于当前和非当前对象版本的操作。有关更多信息，请参阅下列内容：

创建生命周期规则

登录 AWS 管理控制台，并通过以下网址打开 Amazon S3 控制台：https://console.aws.amazon.com/s3/。
在 Buckets (存储桶) 列表中，选择要为其创建生命周期规则的存储桶的名称。
选择 Management (管理) 选项卡，然后选择 Create lifecycle rule (创建生命周期规则)。
在 Lifecycle rule name (生命周期规则名称) 中，输入规则的名称。

在该存储桶内，此名称必须是唯一的。
选择生命周期规则的范围：
- 要将此生命周期规则应用于所有带特定前缀或标签的对象，请选择将范围限制在特定前缀或标签。
  - 要按前缀限制范围，请在 Prefix (前缀) 中输入前缀。
  - 要按标签限制范围，请选择 Add tag (添加标签)，然后输入标签键和值。
  有关对象名称前缀的更多信息，请参阅创建对象键名称。有关对象标签的更多信息，请参阅使用标签对存储进行分类。
- 要将此生命周期规则应用于存储桶中的所有对象，请选择 This rule applies to all objects in the bucket (此规则适用于存储桶中的所有对象)，然后选择 I acknowledge that this rule applies to all objects in the bucket (我确认此规则适用于存储桶中的所有对象)。
在 Lifecycle rule actions (生命周期规则操作) 下，选择希望生命周期规则执行的操作：
- 在存储类之间转换对象的当前版本
- 在存储类之间转换对象的先前版本
- 使对象的当前版本过期
- 永久删除对象的先前版本
- 删除过期的删除标记或未完成的分段上传
根据您选择的操作，会显示不同的选项。
要在存储类之间转换对象的当前版本，请在 Transition current versions of objects between storage classes (在存储类之间转换对象的当前版本) 下面：
1. 在 Storage class transitions (存储类转换) 中，选择要过渡到的存储类：
  - Standard-IA (标准 - IA)
  - 智能分层
  - One Zone-IA (单区 - IA)
  - Glacier
  - Glacier Deep Archive (Glacier 深度存档)
2. 在 Days after object creation (对象创建后的天数) 中，输入创建后转换对象的天数。
有关存储类别的更多信息，请参阅使用 Amazon S3 存储类。您可以为当前对象版本和/或之前的对象版本定义转换。版本控制允许您在一个存储桶中保留多个版本的对象。有关版本控制的更多信息，请参阅使用 S3 控制台。

重要

如果选择 Glacier 或 Glacier Deep Archive 存储类，您的对象将在 Amazon S3 中保留。您无法直接通过单独的 Amazon S3 Glacier 服务访问它们。有关更多信息，请参阅使用 Amazon S3 生命周期转换对象。
要在存储类之间转换对象的非当前版本，请在 Transition non-current versions of objects between storage classes (在存储类之间转换对象的非当前版本) 下面：
1. 在 Storage class transitions (存储类转换) 中，选择要过渡到的存储类：
  - Standard-IA (标准 - IA)
  - 智能分层
  - One Zone-IA (单区 - IA)
  - Glacier
  - Glacier Deep Archive (Glacier 深度存档)
2. 在 Days after object becomes non-current (对象成为非当前对象后的天数) 中，输入创建后转换对象的天数。
要使对象的当前版本过期，请在 Expire previous versions of objects (使对象的先前版本过期) 下面的 Number of days after object creation (对象创建后的天数) 中输入天数。

重要

在不受版本控制的存储桶中，失效操作会导致 Amazon S3 永久删除该对象。有关生命周期操作的更多信息，请参阅用于描述生命周期操作的元素。
要永久删除对象的先前版本，请在 Permanently delete previous versions of objects (永久删除对象的先前版本) 下面的 Number of days after objects become previous versions (对象成为先前版本后的天数) 中输入天数。
在 Delete expired delete markers or incomplete multipart uploads (删除过期的删除标记或未完成的分段上传) 下面，选择 Delete expired object delete markers (删除过期对象的删除标记) 和 Delete incomplete multipart uploads (删除未完成的分段上传)。然后，输入您要在分段上传启动多少天后结束并清理未完成的分段上传。

有关分段上传的更多信息，请参阅使用分段上传来上传和复制对象。
选择 Create rule (创建规则)。

如果规则没有任何错误，Amazon S3 会启用它，并且您可以在 Lifecycle rules (生命周期规则) 下的 Management (管理) 选项卡上看到它。

有关 CloudFormation 模板和示例的信息，请参阅 AWS CloudFormation 用户指南中的使用 AWS CloudFormation 模板和 AWS::S3::Bucket。

您可以使用以下 AWS CLI 命令管理 S3 生命周期配置：

put-bucket-lifecycle-configuration
get-bucket-lifecycle-configuration
delete-bucket-lifecycle

有关设置 AWS CLI 的说明，请参阅使用 AWS CLI 进行 Amazon S3 开发。

Amazon S3 生命周期配置是一个 XML 文件。但在使用 AWS CLI 时，您不能指定 XML。您必须改为指定 JSON。以下是您可在 AWS CLI 命令中指定的示例 XML 生命周期配置和等效 JSON。

请考虑以下示例 S3 生命周期配置。

例示例 1

例示例 2

您可以测试 put-bucket-lifecycle-configuration，如下所示。

测试配置

将 JSON 生命周期配置保存在一个文件 (lifecycle.json) 中。

运行以下 AWS CLI 命令以在存储桶上设置生命周期配置。


$ aws s3api put-bucket-lifecycle-configuration  \
--bucket bucketname  \
--lifecycle-configuration file://lifecycle.json

要进行验证，可使用 get-bucket-lifecycle-configuration AWS CLI 命令检索 S3 生命周期配置，如下所示。
```
$ aws s3api get-bucket-lifecycle-configuration  \
--bucket bucketname  
```
要删除 S3 生命周期配置，可使用 delete-bucket-lifecycle AWS CLI 命令，如下所示。
```
aws s3api delete-bucket-lifecycle \
--bucket bucketname
```

Java

您可以使用适用于 Java 的 AWS 开发工具包来管理存储桶的 S3 生命周期配置。有关管理 S3 生命周期配置的更多信息，请参阅管理存储生命周期。

注意

在将 S3 生命周期配置添加到存储桶时，Amazon S3 会替换存储桶的当前生命周期配置（如果有）。要更新一个配置，请检索它，进行所需的更改，然后向存储桶添加已修订的配置。

以下示例演示如何使用适用于 Java 的 AWS 开发工具包添加、更新和删除存储桶的生命周期配置。本示例执行以下操作：

向存储桶添加生命周期配置。
检索生命周期配置并通过添加其他规则来更新该配置。
向存储桶添加已修改的生命周期配置。Amazon S3 将替换现有配置。
再次检索配置并通过输出规则数来验证它是否具有正确数量的规则。
删除生命周期配置并通过再次尝试检索它来验证它是否已被删除。

有关创建和测试有效示例的说明，请参阅测试 Amazon S3 Java 代码示例。



import com.amazonaws.AmazonServiceException;
import com.amazonaws.SdkClientException;
import com.amazonaws.auth.profile.ProfileCredentialsProvider;
import com.amazonaws.regions.Regions;
import com.amazonaws.services.s3.AmazonS3;
import com.amazonaws.services.s3.AmazonS3ClientBuilder;
import com.amazonaws.services.s3.model.BucketLifecycleConfiguration;
import com.amazonaws.services.s3.model.BucketLifecycleConfiguration.Transition;
import com.amazonaws.services.s3.model.StorageClass;
import com.amazonaws.services.s3.model.Tag;
import com.amazonaws.services.s3.model.lifecycle.LifecycleAndOperator;
import com.amazonaws.services.s3.model.lifecycle.LifecycleFilter;
import com.amazonaws.services.s3.model.lifecycle.LifecyclePrefixPredicate;
import com.amazonaws.services.s3.model.lifecycle.LifecycleTagPredicate;

import java.io.IOException;
import java.util.Arrays;

public class LifecycleConfiguration {

    public static void main(String[] args) throws IOException {
        Regions clientRegion = Regions.DEFAULT_REGION;
        String bucketName = "*** Bucket name ***";

        // Create a rule to archive objects with the "glacierobjects/" prefix to Glacier immediately.
        BucketLifecycleConfiguration.Rule rule1 = new BucketLifecycleConfiguration.Rule()
                .withId("Archive immediately rule")
                .withFilter(new LifecycleFilter(new LifecyclePrefixPredicate("glacierobjects/")))
                .addTransition(new Transition().withDays(0).withStorageClass(StorageClass.Glacier))
                .withStatus(BucketLifecycleConfiguration.ENABLED);

        // Create a rule to transition objects to the Standard-Infrequent Access storage class 
        // after 30 days, then to Glacier after 365 days. Amazon S3 will delete the objects after 3650 days.
        // The rule applies to all objects with the tag "archive" set to "true". 
        BucketLifecycleConfiguration.Rule rule2 = new BucketLifecycleConfiguration.Rule()
                .withId("Archive and then delete rule")
                .withFilter(new LifecycleFilter(new LifecycleTagPredicate(new Tag("archive", "true"))))
                .addTransition(new Transition().withDays(30).withStorageClass(StorageClass.StandardInfrequentAccess))
                .addTransition(new Transition().withDays(365).withStorageClass(StorageClass.Glacier))
                .withExpirationInDays(3650)
                .withStatus(BucketLifecycleConfiguration.ENABLED);

        // Add the rules to a new BucketLifecycleConfiguration.
        BucketLifecycleConfiguration configuration = new BucketLifecycleConfiguration()
                .withRules(Arrays.asList(rule1, rule2));

        try {
            AmazonS3 s3Client = AmazonS3ClientBuilder.standard()
                    .withCredentials(new ProfileCredentialsProvider())
                    .withRegion(clientRegion)
                    .build();

            // Save the configuration.
            s3Client.setBucketLifecycleConfiguration(bucketName, configuration);

            // Retrieve the configuration.
            configuration = s3Client.getBucketLifecycleConfiguration(bucketName);

            // Add a new rule with both a prefix predicate and a tag predicate.
            configuration.getRules().add(new BucketLifecycleConfiguration.Rule().withId("NewRule")
                    .withFilter(new LifecycleFilter(new LifecycleAndOperator(
                            Arrays.asList(new LifecyclePrefixPredicate("YearlyDocuments/"),
                                    new LifecycleTagPredicate(new Tag("expire_after", "ten_years"))))))
                    .withExpirationInDays(3650)
                    .withStatus(BucketLifecycleConfiguration.ENABLED));

            // Save the configuration.
            s3Client.setBucketLifecycleConfiguration(bucketName, configuration);

            // Retrieve the configuration.
            configuration = s3Client.getBucketLifecycleConfiguration(bucketName);

            // Verify that the configuration now has three rules.
            configuration = s3Client.getBucketLifecycleConfiguration(bucketName);
            System.out.println("Expected # of rules = 3; found: " + configuration.getRules().size());

            // Delete the configuration.
            s3Client.deleteBucketLifecycleConfiguration(bucketName);

            // Verify that the configuration has been deleted by attempting to retrieve it.
            configuration = s3Client.getBucketLifecycleConfiguration(bucketName);
            String s = (configuration == null) ? "No configuration found." : "Configuration found.";
            System.out.println(s);
        } catch (AmazonServiceException e) {
            // The call was transmitted successfully, but Amazon S3 couldn't process 
            // it, so it returned an error response.
            e.printStackTrace();
        } catch (SdkClientException e) {
            // Amazon S3 couldn't be contacted for a response, or the client
            // couldn't parse the response from Amazon S3.
            e.printStackTrace();
        }
    }
}

.NET

您可以使用适用于 .NET 的 AWS 开发工具包管理存储桶上的 S3 生命周期配置。有关管理生命周期配置的更多信息，请参阅管理存储生命周期。

注意

在添加生命周期配置时，Amazon S3 将替换指定存储桶上的现有配置。要更新配置，您必须先检索生命周期配置，进行更改，然后向存储桶添加已修订的生命周期配置。

以下示例演示如何使用适用于 .NET 的 AWS 开发工具包添加、更新和删除存储桶的生命周期配置。该代码示例执行以下操作：

向存储桶添加生命周期配置。
检索生命周期配置并通过添加其他规则来更新该配置。
向存储桶添加已修改的生命周期配置。Amazon S3 将替换现有生命周期配置。
再次检索配置并通过输出配置中的规则数进行验证。
删除生命周期配置并确认删除操作。

有关如何创建和测试有效示例的说明，请参阅运行 Amazon S3 .NET 代码示例。


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 = "*** bucket name ***";
        // 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<LifecycleRule>
                        {
                            new LifecycleRule
                            {
                                 Id = "Archive immediately rule",
                                 Filter = new LifecycleFilter()
                                 {
                                     LifecycleFilterPredicate = new LifecyclePrefixPredicate()
                                     {
                                         Prefix = "glacierobjects/"
                                     }
                                 },
                                 Status = LifecycleRuleStatus.Enabled,
                                 Transitions = new List<LifecycleTransition>
                                 {
                                      new LifecycleTransition
                                      {
                                           Days = 0,
                                           StorageClass = S3StorageClass.Glacier
                                      }
                                  },
                            },
                            new LifecycleRule
                            {
                                 Id = "Archive and then delete rule",
                                  Filter = new LifecycleFilter()
                                 {
                                     LifecycleFilterPredicate = new LifecyclePrefixPredicate()
                                     {
                                         Prefix = "projectdocs/"
                                     }
                                 },
                                 Status = LifecycleRuleStatus.Enabled,
                                 Transitions = new List<LifecycleTransition>
                                 {
                                      new LifecycleTransition
                                      {
                                           Days = 30,
                                           StorageClass = S3StorageClass.StandardInfrequentAccess
                                      },
                                      new LifecycleTransition
                                      {
                                        Days = 365,
                                        StorageClass = S3StorageClass.Glacier
                                      }
                                 },
                                 Expiration = new LifecycleRuleExpiration()
                                 {
                                       Days = 3650
                                 }
                            }
                        }
                };

                // 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 = "NewRule",
                    Filter = new LifecycleFilter()
                    {
                        LifecycleFilterPredicate = new LifecyclePrefixPredicate()
                        {
                            Prefix = "YearlyDocuments/"
                        }
                    },
                    Expiration = new LifecycleRuleExpiration()
                    {
                        Days = 3650
                    }
                });

                // Add the configuration to the bucket. 
                await AddExampleLifecycleConfigAsync(client, lifeCycleConfiguration);

                // Verify that there are now three rules.
                lifeCycleConfiguration = await RetrieveLifecycleConfigAsync(client);
                Console.WriteLine("Expected # of rulest=3; 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<LifecycleConfiguration> 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);
        }
    }
}

Ruby

通过使用类 AWS::S3::BucketLifecycleConfiguration，可使用适用于 Ruby 的 AWS 开发工具包来管理存储桶上的 S3 生命周期配置。有关将适用于 Ruby 的 AWS 开发工具包与 Amazon S3 结合使用的更多信息，请参阅使用适用于 Ruby 的 AWS 开发工具包（版本 3）。有关管理生命周期配置的更多信息，请参阅管理存储生命周期。

Amazon Simple Storage Service API 参考中的以下几节描述了与 S3 生命周期配置相关的 REST API。

Javascript 在您的浏览器中被禁用或不可用。

要使用 AWS 文档，必须启用 Javascript。请参阅浏览器的帮助页面以了解相关说明。

即将过期的对象

使用其他存储桶配置