

本文為英文版的機器翻譯版本，如內容有任何歧義或不一致之處，概以英文版為準。

# 設定儲存貯體的 S3 生命週期組態
<a name="how-to-set-lifecycle-configuration-intro"></a>

您可以使用 Amazon S3 主控台、 AWS Command Line Interface (AWS CLI)、 AWS SDKs 或 Amazon S3 REST API，在儲存貯體上設定 Amazon S3 生命週期組態。如需 S3 生命週期組態的資訊，請參閱[管理物件的生命週期](object-lifecycle-mgmt.md)。

**注意**  
若要檢視或編輯目錄儲存貯體的生命週期組態，請使用 AWS CLI、 AWS SDKs或 Amazon S3 REST API。如需詳細資訊，請參閱[使用適用於目錄儲存貯體的 S3 生命週期](directory-buckets-objects-lifecycle.md)。

在您的 S3 生命週期組態中，您可以使用*生命週期規則*來定義您希望 Amazon S3 在物件生命週期內採取的動作。例如，您可以定義規則，將物件轉換到另一個儲存類別、封存物件，或在指定的一段時間後過期 (刪除) 物件。

## S3 生命週期考量事項
<a name="lifecycle-considerations"></a>

在設定生命週期組態之前，請注意下列事項：

**生命週期組態傳播延遲**  
當您新增儲存貯體的 S3 生命週期組態時，在新的或已更新的 S3 生命週期組態完全傳播至所有 Amazon S3 系統之前通常會一些延遲。在組態完全生效之前，預期會有幾分鐘的延遲。當您刪除 S3 生命週期組態時，可能會發生這項延遲。

**轉換或過期延遲**  
在滿足生命週期規則與完成規則動作之間存在延遲。例如，假設一組物件已於 1 月 1 日由生命週期規則設為過期。即使已於 1 月 1 日滿足過期規則，但 Amazon S3 仍可能在數天或甚至數週後才實際刪除這些物件。會發生此延遲，是因為 S3 生命週期會以非同步方式將物件排入轉換或過期的佇列。當您新增或修改生命週期規則時，S3 生命週期可能會立即開始處理合格物件，或有所延遲。當 S3 生命週期建立刪除標記或轉換物件時，時間戳記會在動作發生當天設定為午夜 UTC，無論採取動作的實際時間為何。不過，只要滿足生命週期規則，帳單通常也會立即變更，即使動作尚未完成也是一樣。如需詳細資訊，請參閱[帳單變更](#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 SDKs 或 Amazon S3 REST API，在一般用途儲存貯體上設定 Amazon S3 生命週期組態。

如需有關 AWS CloudFormation 範本和範例的資訊，請參閱*CloudFormation 《 使用者指南*[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)》中的[使用 AWS CloudFormation 範本](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/template-guide.html)和 。

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

您可以使用共用的字首 (以共同字串開頭的物件名稱) 或標籤，針對儲存貯體中的所有物件或部分物件，定義生命週期規則。在您的生命週期規則中，您可以定義專用於目前及非目前物件版本的動作。如需詳細資訊，請參閱下列內容：
+ [管理物件的生命週期](object-lifecycle-mgmt.md)
+ [使用 S3 版本控制保留多個版本的物件](Versioning.md)

**建立生命週期規則**

1. 登入 AWS 管理主控台 ，並在 [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)：// 開啟 Amazon S3 主控台。

1. 在左側導覽窗格中，選擇**一般用途儲存貯體**。

1. 在儲存貯體清單中，選擇要建立生命週期規則的儲存貯體名稱。

1. 選擇 **Management (管理)** 標籤，然後選擇 **Create lifecycle rule (建立生命週期規則)**。

1. 在 **Lifecycle rule name (生命週期規則名稱)** 中，輸入規則的名稱。

   在儲存貯體內，名稱必須是唯一的。

1. 選擇生命週期規則的範圍：
   + 若要將此生命週期規則套用至*帶有特定前綴或標籤的所有物件*，請選擇 **Limit the scope to specific prefixes or tags (將範圍限制為特定前綴或標籤)**。
     + 若要依字首限制範圍，請在 **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 Intelligent-Tiering
      + 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 Intelligent-Tiering
      + 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** (物件變成非現行版本後的天數) 中，輸入天數。您可以選擇指定要保留的較新版本數目，方法是在**要保留的較新版本數目**下方輸入值。

1. 在 **Delete expired delete markers or incomplete multipart uploads (刪除過期刪除標記或未完成的分段上傳)** 下，選擇 **Delete expired object delete markers (刪除過期物件刪除標記)** 和 **Delete incomplete multipart uploads (刪除未完成的分段上傳)**。然後，輸入分段上傳啟動後幾天要結束並清理未完成的分段上傳。

   如需分段上傳的詳細資訊，請參閱「[在 Amazon S3 中使用分段上傳來上傳和複製物件](mpuoverview.md)」。

1. 選擇**建立規則**。

   如果規則未包含任何錯誤，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 參考》中的使用 AWS CLI 開發](https://docs.aws.amazon.com/AmazonS3/latest/API/setup-aws-cli.html) Amazon S3。 *Amazon S3 *

Amazon S3 生命週期組態是 XML 檔案。但是當您使用 時 AWS CLI，您無法指定 XML 格式。您必須改為指定 JSON 格式。以下是範例 XML 生命週期組態，以及您可以在 AWS CLI命令中指定的同等 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 SDKs
<a name="manage-lifecycle-using-sdk"></a>

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

您可以使用適用於 Java 的 AWS SDK 來管理儲存貯體的 S3 生命週期組態。如需管理 S3 生命週期組態的詳細資訊，請參閱[管理物件的生命週期](object-lifecycle-mgmt.md)。

**注意**  
當您新增儲存貯體的 S3 生命週期組態時，Amazon S3 會取代儲存貯體的目前生命週期組態 (如果有的話)。若要更新現有生命週期組態，請先擷取，再進行所要的變更，然後將修正過的組態新增至儲存貯體。

若要使用適用於 Java 的 AWS 開發套件管理生命週期組態，您可以：
+ 將生命週期組態新增至儲存貯體。
+ 擷取生命週期組態，並透過新增其他規則來更新此組態。
+ 將經過修改的生命週期組態加入到儲存貯體中。Amazon S3 取代現有的組態。
+ 再次擷取組態，並透過顯示規則數驗證其具有正確數量的規則。
+ 刪除生命週期組態，並嘗試再次擷取以驗證是否已刪除。

如需如何使用適用於 Java 的 AWS SDK 在儲存貯體上設定生命週期組態的範例，請參閱《*Amazon S3 API 參考*》中的在儲存[貯體上設定生命週期組態](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 開發人員指南》**中的[適用於 .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 來管理儲存貯體上的 S3 生命週期組態，方法是使用類別 [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 生命週期組態的詳細資訊，請參閱[管理物件的生命週期](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)。