

# 在存储桶上设置 S3 生命周期配置
<a name="how-to-set-lifecycle-configuration-intro"></a>

可以使用 Amazon S3 控制台、AWS Command Line Interface（AWS CLI）、AWS SDK 或 Amazon S3 REST API 在存储桶上设置 Amazon S3 生命周期配置。有关 S3 生命周期配置的信息，请参阅 [管理对象的生命周期](object-lifecycle-mgmt.md)。

**注意**  
要查看或编辑目录存储桶的生命周期配置，请使用 AWS CLI、AWS SDK 或 Amazon S3 REST API。有关更多信息，请参阅 [使用针对目录存储桶的 S3 生命周期](directory-buckets-objects-lifecycle.md)。

在 S3 生命周期配置中，可以使用*生命周期规则* 来定义您希望 Amazon S3 在对象的生命周期内执行的操作。例如，您可以定义规则，来将对象转换到另一个存储类、归档对象或在指定时间段后使对象到期（将其删除）。

## S3 生命周期注意事项
<a name="lifecycle-considerations"></a>

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

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

**转换或到期延迟**  
从满足生命周期规则到规则操作完成之间会有延迟。例如，假设一组对象根据生命周期规则在 1 月 1 日到期。尽管已在 1 月 1 日满足到期规则，但 Amazon S3 可能要等到几天甚至几周后，才会真正删除这些对象。之所以出现这种延迟，是因为 S3 生命周期以异步方式将对象排入队列来执行转换或到期操作。然而，当满足生命周期规则时，通常会应用账单的变化，即使操作尚未完成也是如此。有关更多信息，请参阅[账单的变化](#lifecycle-billing)。要监控由活动的生命周期规则进行的更新的效果，请参阅[如何监控生命周期规则执行的操作？](troubleshoot-lifecycle.md#troubleshoot-lifecycle-2)

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

**注意**  
在更新、禁用或删除生命周期规则之前，请使用 `LIST` API 操作（例如 [https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListObjectsV2.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListObjectsV2.html)、[https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListObjectVersions.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListObjectVersions.html) 和 [https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListMultipartUploads.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListMultipartUploads.html)）或 [使用 S3 清单对数据进行编目和分析](storage-inventory.md)，根据您的使用案例验证 Amazon S3 是否已转换符合条件的对象并使其到期。如果您在更新、禁用或删除生命周期规则时遇到任何问题，请参阅[排查 Amazon S3 生命周期问题](troubleshoot-lifecycle.md)。

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

**监控生命周期规则的影响**  
要监控由活动的生命周期规则进行的更新的效果，请参阅[如何监控生命周期规则执行的操作？](troubleshoot-lifecycle.md#troubleshoot-lifecycle-2)

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

例如，在对象到期后，即使没有立即删除对象，也不会向您收取存储费用。同样，只要对象转换时间一过，就会立即按照 S3 Glacier Flexible Retrieval 存储费率向您收费，即使没有立即将该对象转换为 S3 Glacier Flexible Retrieval 存储类也是如此。

但是，生命周期转换为 S3 Intelligent-Tiering 存储类是例外。在对象转换为 S3 Intelligent-Tiering 存储类之前，账单不会发生更改。

**多个或相互冲突的规则**  
当您在 S3 生命周期配置中有多个规则时，对象可能变得符合条件可在同一天执行多个 S3 生命周期操作。在这种情况下，Amazon S3 遵循以下一般规则：
+ 永久删除优先于转换。
+ 转换优先于[删除标记](DeleteMarker.md)的创建。
+ 当对象符合条件可进行 S3 Glacier Flexible Retrieval 和 S3 Standard-IA（或 S3 One Zone-IA）转换时，Amazon S3 将选择 S3 Glacier Flexible Retrieval 转换。

 有关示例，请参阅 [重叠的筛选条件和冲突的生命周期操作的示例](lifecycle-conflicts.md#lifecycle-config-conceptual-ex5)。

## 如何设置 S3 生命周期配置
<a name="how-to-set-lifecycle-configuration"></a>

可以使用 Amazon S3 控制台、AWS Command Line Interface（AWS CLI）、AWS SDK 或 Amazon S3 REST API 在通用存储桶上设置 Amazon S3 生命周期配置。

有关 AWS CloudFormation 模板和示例的信息，请参阅《CloudFormation 用户指南》**中的[使用 AWS CloudFormation 模板](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-guide.html)和 [https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-s3-bucket.html#aws-resource-s3-bucket--examples](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-s3-bucket.html#aws-resource-s3-bucket--examples)。

### 使用 S3 控制台
<a name="create-lifecycle"></a>

您可以使用共享前缀（以通用字符串开头的对象名称）或标签为存储桶中的所有对象或一部分对象定义生命周期规则。在生命周期规则中，您可以定义特定于当前和非当前对象版本的操作。有关更多信息，请参阅下列内容：
+ [管理对象的生命周期](object-lifecycle-mgmt.md)
+ [使用 S3 版本控制保留对象的多个版本](Versioning.md)

**创建生命周期规则**

1. 登录到 AWS 管理控制台，然后通过以下网址打开 Amazon S3 控制台：[https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)。

1. 在左侧导航窗格中，选择**通用存储桶**。

1. 在存储桶列表中，选择要为其创建生命周期规则的存储桶的名称。

1. 请选择 **Management（管理）**选项卡，然后选择 **Create lifecycle rule（创建生命周期规则）**。

1. 在 **Lifecycle rule name (生命周期规则名称)** 中，输入规则的名称。

   在该存储桶内，此名称必须是唯一的。

1. 请选择生命周期规则的范围：
   + 要将此生命周期规则应用于*所有带特定前缀或标签的对象*，请选择**将范围限制在特定前缀或标签**。
     + 要按前缀限制范围，请在 **Prefix (前缀)** 中输入前缀。
     + 要按标签限制范围，请选择 **Add tag (添加标签)**，然后输入标签键和值。

     有关对象名称前缀的更多信息，请参阅 [为 Amazon S3 对象命名](object-keys.md)。有关对象标签的更多信息，请参阅 [使用标签对对象进行分类](object-tagging.md)。
   + 要将此生命周期规则应用于*存储桶中的所有对象*，请选择**此规则适用于存储桶中的*所有* 对象**，然后选择**我确认此规则适用于存储桶中的所有对象**。

1. 要按对象大小筛选规则，可以选择**指定最小对象大小**和/或**指定最大对象大小**选项。
   + 当您为**最小对象大小**或**最大对象大小**指定值时，该值必须大于 0 字节且不超过 50 TB。您可以以字节、KB、MB 或 GB 为单位指定此值。
   + 当您指定这两个值时，最大对象大小必须大于最小对象大小。
**注意**  
**最小对象大小**和**最大对象大小**筛选条件不包含所指定的值。例如，如果您将筛选条件设置为使**最小对象大小**为 128 KB 的对象到期，则恰好为 128 KB 的对象不会到期。相反，该规则仅适用于大小超过 128 KB 的对象。

1. 在 **Lifecycle rule actions (生命周期规则操作)** 下，请选择希望生命周期规则执行的操作：
   + 在存储类之间转换对象的*当前*版本
   + 在存储类之间转换对象的*先前*版本
   + 使对象的*当前*版本过期
**注意**  
对于未启用 [S3 版本控制](Versioning.md)的存储桶，使当前版本到期会导致 Amazon S3 永久删除对象。有关更多信息，请参阅 [生命周期操作与桶版本控制状态](intro-lifecycle-rules.md#lifecycle-actions-bucket-versioning-state)。
   + 永久删除对象的*先前*版本
   + 删除过期的删除标记或未完成的分段上传 

   根据您选择的操作，会显示不同的选项。

1. 要在存储类之间转换对象的*当前* 版本，请在**在存储类之间转换对象的当前版本**下，执行以下操作：

   1. 在**存储类转换**中，请选择要转换到的存储类。有关可能的转换的列表，请参阅[支持的生命周期转换](lifecycle-transition-general-considerations.md#supported-lifecycle-transitions)。可从以下存储类中进行选择：
      + S3 标准 - IA
      + S3 智能分层
      + S3 单区 - IA
      + S3 Glacier Instant Retrieval
      + S3 Glacier Flexible Retrieval
      + S3 Glacier Deep Archive

   1. 在 **Days after object creation (对象创建后的天数)** 中，输入创建后转换对象的天数。

   有关存储类的更多信息，请参阅 [了解和管理 Amazon S3 存储类](storage-class-intro.md)。您可以为当前对象版本和/或之前的对象版本定义转换。版本控制允许您在一个存储桶中保留多个版本的对象。有关版本控制的更多信息，请参阅 [使用 S3 控制台](manage-versioning-examples.md#enable-versioning)。
**重要**  
如果选择 S3 Glacier Instant Retrieval、S3 Glacier Flexible Retrieval 或 Glacier Deep Archive 存储类，对象将保留在 Amazon S3 中。您无法直接通过单独的 Amazon Glacier 服务访问它们。有关更多信息，请参阅 [使用 Amazon S3 生命周期转换对象](lifecycle-transition-general-considerations.md)。

1. 要在存储类之间转换对象的*非当前* 版本，请在**在存储类之间转换对象的非当前版本**下，执行以下操作：

   1. 在**存储类转换**中，请选择要转换到的存储类。有关可能的转换的列表，请参阅[支持的生命周期转换](lifecycle-transition-general-considerations.md#supported-lifecycle-transitions)。可从以下存储类中进行选择：
      + S3 标准 - IA
      + S3 智能分层
      + S3 单区 - IA
      + S3 Glacier Instant Retrieval
      + S3 Glacier Flexible Retrieval
      + S3 Glacier Deep Archive

   1. 在**对象成为非当前对象后的天数**中，输入创建后转换对象的天数。

1. 要使对象的*当前*版本过期，请在 **Expire current versions of objects**（使对象的当前版本过期）下面的 **Number of days after object creation**（对象创建后的天数）中输入天数。
**重要**  
在不受版本控制的存储桶中，到期操作会导致 Amazon S3 永久移除该对象。有关生命周期操作的更多信息，请参阅 [用于描述生命周期操作的元素](intro-lifecycle-rules.md#intro-lifecycle-rules-actions)。

1. 要永久删除对象的先前版本，请在 **Permanently delete noncurrent versions of objects**（永久删除对象的先前版本）下的 **Days after objects become noncurrent**（对象变为非当前对象后的天数）中输入天数。您可以选择在 **Number of newer versions to retain**（要保留的较新版本的数量）下输入一个值，从而指定要保留的较新版本数量。

1. 在 **Delete expired delete markers or incomplete multipart uploads (删除过期的删除标记或未完成的分段上传)** 下面，请选择 **Delete expired object delete markers (删除过期对象的删除标记)** 和 **Delete incomplete multipart uploads (删除未完成的分段上传)**。然后，输入您要在分段上传启动多少天后结束并清理未完成的分段上传。

   有关分段上传的更多信息，请参阅 [在 Amazon S3 中使用分段上传来上传和复制对象](mpuoverview.md)。

1. 请选择 **Create rule (创建规则)**。

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

### 使用 AWS CLI
<a name="set-lifecycle-cli"></a>

您可以使用以下 AWS CLI 命令管理 S3 生命周期配置：
+ `put-bucket-lifecycle-configuration`
+ `get-bucket-lifecycle-configuration`
+ `delete-bucket-lifecycle`

有关设置 AWS CLI 的说明，请参阅《Amazon S3 API 参考》**中的 [Developing with Amazon S3 using the AWS CLI](https://docs.aws.amazon.com/AmazonS3/latest/API/setup-aws-cli.html)。

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

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

**Example 示例 1**  

**Example**  

```
<LifecycleConfiguration>
    <Rule>
        <ID>ExampleRule</ID>
        <Filter>
           <Prefix>documents/</Prefix>
        </Filter>
        <Status>Enabled</Status>
        <Transition>        
           <Days>365</Days>        
           <StorageClass>GLACIER</StorageClass>
        </Transition>    
        <Expiration>
             <Days>3650</Days>
        </Expiration>
    </Rule>
</LifecycleConfiguration>
```

```
{
    "Rules": [
        {
            "Filter": {
                "Prefix": "documents/"
            },
            "Status": "Enabled",
            "Transitions": [
                {
                    "Days": 365,
                    "StorageClass": "GLACIER"
                }
            ],
            "Expiration": {
                "Days": 3650
            },
            "ID": "ExampleRule"
        }
    ]
}
```

**Example 示例 2**  

**Example**  

```
<LifecycleConfiguration xmlns="http://s3.amazonaws.com/doc/2006-03-01/">
    <Rule>
        <ID>id-1</ID>
        <Expiration>
            <Days>1</Days>
        </Expiration>
        <Filter>
            <And>
                <Prefix>myprefix</Prefix>
                <Tag>
                    <Key>mytagkey1</Key>
                    <Value>mytagvalue1</Value>
                </Tag>
                <Tag>
                    <Key>mytagkey2</Key>
                    <Value>mytagvalue2</Value>
                </Tag>
            </And>
        </Filter>
        <Status>Enabled</Status>    
    </Rule>
</LifecycleConfiguration>
```

```
{
    "Rules": [
        {
            "ID": "id-1",
            "Filter": {
                "And": {
                    "Prefix": "myprefix", 
                    "Tags": [
                        {
                            "Value": "mytagvalue1", 
                            "Key": "mytagkey1"
                        }, 
                        {
                            "Value": "mytagvalue2", 
                            "Key": "mytagkey2"
                        }
                    ]
                }
            }, 
            "Status": "Enabled", 
            "Expiration": {
                "Days": 1
            }
        }
    ]
}
```

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

**测试配置**

1. 将 JSON 生命周期配置保存在一个文件（例如 *`lifecycle.json`*）中。

1. 运行以下 AWS CLI 命令以在存储桶上设置生命周期配置。将 `user input placeholders` 替换为您自己的信息。

   ```
   $ aws s3api put-bucket-lifecycle-configuration  \
   --bucket amzn-s3-demo-bucket  \
   --lifecycle-configuration file://lifecycle.json
   ```

1. 要进行验证，请使用 `get-bucket-lifecycle-configuration` AWS CLI 命令检索 S3 生命周期配置，如下所示：

   ```
   $ aws s3api get-bucket-lifecycle-configuration  \
   --bucket amzn-s3-demo-bucket
   ```

1. 要删除 S3 生命周期配置，请使用 `delete-bucket-lifecycle` AWS CLI 命令，如下所示：

   ```
   aws s3api delete-bucket-lifecycle \
   --bucket amzn-s3-demo-bucket
   ```

### 使用 AWS SDK
<a name="manage-lifecycle-using-sdk"></a>

------
#### [ Java ]

您可以使用适用于 Java 的 AWS SDK 来管理存储桶的 S3 生命周期配置。有关管理 S3 生命周期配置的更多信息，请参阅 [管理对象的生命周期](object-lifecycle-mgmt.md)。

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

要使用适用于 Java 的 AWS SDK 管理生命周期配置，您可以：
+ 向存储桶添加生命周期配置。
+ 检索生命周期配置并通过添加其它规则来更新该配置。
+ 向存储桶添加已修改的生命周期配置。Amazon S3 将替换现有配置。
+ 再次检索配置，并通过输出规则数来验证它是否具有正确数量的规则。
+ 删除生命周期配置，并通过再次尝试检索该配置来验证它是否已被删除。

有关如何使用适用于 Java 的 AWS SDK 对存储桶设置生命周期配置的示例，请参阅《Amazon S3 API Reference》**中的 [Set lifecycle configuration on a bucket](https://docs.aws.amazon.com/AmazonS3/latest/API/s3_example_s3_PutBucketLifecycleConfiguration_section.html)。

------
#### [ .NET ]

您可以使用 适用于 .NET 的 AWS SDK 管理存储桶上的 S3 生命周期配置。有关管理生命周期配置的更多信息，请参阅 [管理对象的生命周期](object-lifecycle-mgmt.md)。

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

以下示例说明如何使用 适用于 .NET 的 AWS SDK 添加、更新和删除存储桶的生命周期配置。该代码示例执行以下操作：
+ 向存储桶添加生命周期配置。
+ 检索生命周期配置并通过添加其他规则来更新该配置。
+ 向存储桶添加已修改的生命周期配置。Amazon S3 将替换现有生命周期配置。
+ 再次检索配置并通过输出配置中的规则数进行验证。
+ 删除生命周期配置并确认删除操作。

有关设置和运行代码示例的信息，请参阅《适用于 .NET 的 AWS SDK 开发人员指南》**中的 [Getting Started with the 适用于 .NET 的 AWS SDK](https://docs.aws.amazon.com/sdk-for-net/v3/developer-guide/net-dg-config.html)。

```
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 ]

可以使用适用于 Ruby 的 AWS SDK 通过 [https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/S3/BucketLifecycle.html](https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/S3/BucketLifecycle.html) 类来管理存储桶上的 S3 生命周期配置。有关管理 S3 生命周期配置的更多信息，请参阅 [管理对象的生命周期](object-lifecycle-mgmt.md)。

------

### 使用 REST API
<a name="manage-lifecycle-using-rest"></a>

《Amazon Simple Storage Service API 参考》**中的以下主题描述了与 S3 生命周期配置相关的 REST API 操作：
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketLifecycleConfiguration.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutBucketLifecycleConfiguration.html)
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetBucketLifecycleConfiguration.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetBucketLifecycleConfiguration.html)
+ [https://docs.aws.amazon.com/AmazonS3/latest/API/API_DeleteBucketLifecycle.html](https://docs.aws.amazon.com/AmazonS3/latest/API/API_DeleteBucketLifecycle.html)

## S3 生命周期问题排查
<a name="lifecycle-troubleshoot"></a>

有关使用 S3 生命周期时可能出现的常见问题，请参阅[排查 Amazon S3 生命周期问题](troubleshoot-lifecycle.md)。