本文為英文版的機器翻譯版本，如內容有任何歧義或不一致之處，概以英文版為準。
設定儲存貯體的 S3 生命週期組態
您可以使用 Amazon S3 主控台、 AWS Command Line Interface (AWS CLI)、 AWS SDKs 或 Amazon S3 REST API，在儲存貯體上設定 Amazon S3 生命週期組態。如需 S3 生命週期組態的資訊，請參閱管理物件的生命週期。
在您的 S3 生命週期組態中，您可以使用生命週期規則來定義您希望 Amazon S3 在物件生命週期內採取的動作。例如，您可以定義規則，將物件轉換到另一個儲存類別、封存物件，或在指定的一段時間後過期 (刪除) 物件。
S3 生命週期考量事項
在設定生命週期組態之前，請注意下列事項：
生命週期組態傳播延遲
當您新增儲存貯體的 S3 生命週期組態時，在新的或已更新的 S3 生命週期組態完全傳播至所有 Amazon S3 系統之前通常會一些延遲。在組態完全生效之前，預期會有幾分鐘的延遲。當您刪除 S3 生命週期組態時，可能會發生這項延遲。
轉換或過期延遲
在滿足生命週期規則與完成規則動作之間存在延遲。例如，假設一組物件已於 1 月 1 日由生命週期規則設為過期。即使已於 1 月 1 日滿足過期規則，但 Amazon S3 仍可能在數天或甚至數週後才實際刪除這些物件。會發生此延遲，是因為 S3 生命週期會以非同步方式將物件排入轉換或過期的佇列。不過，只要滿足生命週期規則，帳單通常也會立即變更，即使動作尚未完成也是一樣。如需詳細資訊，請參閱帳單變更。若要監控作用中生命週期規則所進行之更新的影響，請參閱如何監控生命週期規則採取的動作？
更新、停用或刪除生命週期規則
當您停用或刪除生命週期規則時，在些許延遲之後，Amazon S3 會停止排定新物件來進行刪除或轉換。任何已排定的物件都會取消排定，而且不會刪除或轉換。
現有物件和新物件
當您新增儲存貯體的生命週期組態時，組態規則會套用至現有物件以及稍後新增的物件。例如，如果您目前所新增生命週期組態規則包含過期動作，會讓具有特定字首的物件在建立 30 天之後過期，則 Amazon S3 會將任何超過 30 天且具有指定字首的現有物件排入佇列，等待移除。
監控生命週期規則的效果
若要監控作用中生命週期規則所進行之更新的影響，請參閱如何監控生命週期規則採取的動作？
帳單變更
滿足生命週期組態規則時與採取滿足規則所觸發的動件時之間，可能會出現延遲。不過，只要滿足生命週期組態規則，帳單就會變更，即使尚未採取動作也是一樣。
例如，在物件過期時間之後未向您收取儲存體費用，即使未立即刪除物件也是一樣。同樣的，只要過了物件轉換時間，就會向您收取 S3 Glacier Flexible Retrieval 儲存體費率費用，即使未立即將物件轉換至 S3 Glacier Flexible Retrieval 儲存類別也是一樣。
不過，生命週期中轉換為 S3 Intelligent-Tiering 儲存類別是例外狀況。在物件轉換至 S3 Intelligent-Tiering 儲存類別之前，帳單變更不會發生。
多個或衝突的規則
在 S3 生命週期組態中出現多項規則時，您可在同一天內對物件套用多個 S3 生命週期動作。在這種情況下，Amazon S3 遵循以下一般規則：
如需範例，請參閱 篩選條件重疊和生命週期動作相衝突的範例。
如何設定 S3 生命周期組態
您可以使用 Amazon S3 主控台、 AWS Command Line Interface (AWS CLI)、 AWS SDKs 或 Amazon S3 REST API，在一般用途儲存貯體上設定 Amazon S3 生命週期組態。
如需 AWS CloudFormation 範本和範例的相關資訊，請參閱AWS CloudFormation 《 使用者指南》AWS::S3::Bucket中的使用 AWS CloudFormation 範本和 。
您可以使用共用的字首 (以共同字串開頭的物件名稱) 或標籤，針對儲存貯體中的所有物件或部分物件，定義生命週期規則。在您的生命週期規則中，您可以定義專用於目前及非目前物件版本的動作。如需詳細資訊，請參閱下列內容：
建立生命週期規則
-
登入 AWS Management Console 並開啟位於 https：//https://console.aws.amazon.com/s3/.Amazon S3 主控台。
-
在左側導覽窗格中，選擇一般用途儲存貯體。
-
在儲存貯體清單中，選擇您要為其建立生命週期規則的儲存貯體名稱。
-
選擇 Management (管理) 標籤，然後選擇 Create lifecycle rule (建立生命週期規則)。
-
在 Lifecycle rule name (生命週期規則名稱) 中，輸入規則的名稱。
在儲存貯體內，名稱必須是唯一的。
-
選擇生命週期規則的範圍：
-
若要將此生命週期規則套用至帶有特定前綴或標籤的所有物件，請選擇 Limit the scope to specific prefixes or tags (將範圍限制為特定前綴或標籤)。
如需物件名稱字首的詳細資訊，請參閱「命名 Amazon S3 物件」。如需物件標籤的詳細資訊，請參閱 使用標籤分類儲存空間。
-
若要將此生命週期規則套用至儲存貯體中的所有物件，請選擇 此規則適用於儲存貯體中的所有物件，然後選擇我確認此規則會套用於儲存貯體中的所有物件。
-
若要依物件大小篩選規則，您可以選取指定物件大小下限、指定物件大小上限，或同時選擇這兩個選項。
-
在 Lifecycle rule actions (生命週期規則動作) 下，選擇您希望生命週期規則執行的動作：
-
在儲存類別之間轉移物件的目前版本
-
在儲存類別之間轉移物件的先前版本
-
讓物件的目前版本過期
-
永久刪除物件的先前版本
-
刪除過期的刪除標記或未完成的分段上傳
視您選擇的動作而定，將會出現不同的選項。
-
若要在儲存類別之間轉移目前版本的物件，請在 在儲存類別之間轉移物件的目前版本 下執行下列操作：
-
在選擇儲存類別轉換中，選擇要轉移至的儲存類別。如需可能的轉換清單，請參閱支援的生命週期轉換。您可以從下列儲存類別中進行選擇：
-
在 Days after object creation (物件建立後的天數) 中，輸入建立後幾天要轉移物件。
如需儲存體方案的詳細資訊，請參閱「了解和管理 Amazon S3 儲存類別」。您可以為目前的物件版本或舊的物件版本定義轉換，也可以同時為兩者定義轉換。您可利用版本控制在單一儲存貯體中保留物件的多個版本。如需版本控制的詳細資訊，請參閱「使用 S3 主控台」。
選擇 S3 Glacier Instant Retrieval、S3 Glacier Flexible Retrieval 或 Glacier Deep Archive 儲存類別時，您的物件會保留在 Amazon S3 中。您無法透過個別的 Amazon S3 Glacier 服務直接存取物件。如需詳細資訊，請參閱使用 Amazon S3 生命週期轉換物件。
-
若要在儲存類別之間轉移非目前版本的物件，請在 在儲存類別之間轉移物件的先前版本 下執行下列操作：
-
在選擇儲存類別轉換中，選擇要轉移至的儲存類別。如需可能的轉換清單，請參閱支援的生命週期轉換。您可以從下列儲存類別中進行選擇：
-
在在物件成為非目前之後的天數中，輸入要在建立後幾天轉移物件。
-
若要讓物件的目前版本過期，請在 Expire current versions of objects (讓物件的目前版本過期) 下的 Number of days after object creation (物件建立後的天數) 中，輸入天數。
在非版本控制的儲存貯體中，過期動作會導致 Amazon S3 永久移除物件。如需生命週期動作的詳細資訊，請參閱「描述生命週期動作的元素」。
-
若要永久刪除物件的先前版本，請在 Permanently delete noncurrent versions of objects (永久刪除物件的非現行版本) 下的 Days after objects become noncurrent (物件變成非現行版本後的天數) 中，輸入天數。您可以選擇指定要保留的較新版本數目，方法是在要保留的較新版本數目下方輸入值。
-
在 Delete expired delete markers or incomplete multipart uploads (刪除過期刪除標記或未完成的分段上傳) 下，選擇 Delete expired object delete markers (刪除過期物件刪除標記) 和 Delete incomplete multipart uploads (刪除未完成的分段上傳)。然後，輸入分段上傳啟動後幾天要結束並清理未完成的分段上傳。
如需分段上傳的詳細資訊，請參閱「在 Amazon S3 中使用分段上傳來上傳和複製物件」。
-
選擇建立規則。
如果規則未包含任何錯誤，Amazon S3 會啟用該規則，您可以在 Lifecycle rules (生命週期規則) 下的 Management (管理) 標籤上看到該規則。
您可以使用下列 AWS CLI 命令來管理 S3 生命週期組態：
如需設定 的指示 AWS CLI，請參閱《Amazon S3 API 參考》中的使用 AWS CLI 使用 Amazon S3 開發。 Amazon S3
Amazon S3 生命週期組態是 XML 檔案。但是，當您使用 時 AWS CLI，無法指定 XML 格式。您必須改為指定 JSON 格式。以下是範例 XML 生命週期組態，以及您可以在 AWS CLI命令中指定的同等 JSON 組態。
請考慮下列範例 S3 生命週期組態。
範例 1
- XML
-
<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>
- JSON
-
{
"Rules": [
{
"Filter": {
"Prefix": "documents/"
},
"Status": "Enabled",
"Transitions": [
{
"Days": 365,
"StorageClass": "GLACIER"
}
],
"Expiration": {
"Days": 3650
},
"ID": "ExampleRule"
}
]
}
範例 2
- XML
-
<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>
- JSON
-
{
"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。
測試組態
-
將 JSON 生命週期組態儲存至檔案 (例如，lifecycle.json
-
執行下列 AWS CLI 命令，在儲存貯體上設定生命週期組態。以您自己的資訊取代 user input
placeholders
$ aws s3api put-bucket-lifecycle-configuration \
--bucket amzn-s3-demo-bucket \
--lifecycle-configuration file://lifecycle.json
-
若要驗證，請使用 get-bucket-lifecycle-configuration AWS CLI 命令擷取 S3 生命週期組態，如下所示：
$ aws s3api get-bucket-lifecycle-configuration \
--bucket amzn-s3-demo-bucket
-
若要刪除 S3 生命週期組態，請使用 delete-bucket-lifecycle AWS CLI 命令，如下所示：
aws s3api delete-bucket-lifecycle \
--bucket amzn-s3-demo-bucket
- Java
-
您可以使用 AWS SDK for Java 來管理儲存貯體的 S3 生命週期組態。如需管理 S3 生命週期組態的詳細資訊，請參閱管理物件的生命週期。
當您新增儲存貯體的 S3 生命週期組態時，Amazon S3 會取代儲存貯體的目前生命週期組態 (如果有的話)。若要更新現有生命週期組態，請先擷取，再進行所要的變更，然後將修正過的組態新增至儲存貯體。
下列範例顯示如何使用 AWS SDK for Java 新增、更新和刪除儲存貯體的生命週期組態。此範例執行下列操作：
-
新增儲存貯體的生命週期組態。
-
擷取生命週期組態，並新增其他規則來更新此組態。
-
將經過修改的生命週期組態組態，加入到儲存貯體中。Amazon S3 取代現有的組態。
-
再次擷取組態，並透過顯示規則數，驗證其具有正確數量的規則。
-
刪除生命週期組態，並嘗試再次擷取，以驗證它是否已刪除。
如需建立和測試可行範例的說明，請參閱《AWS SDK for 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
-
您可以使用 AWS SDK for .NET 來管理儲存貯體上的 S3 生命週期組態。如需管理生命週期組態的詳細資訊，請參閱「管理物件的生命週期」。
當您新增生命週期組態時，Amazon S3 會取代在指定儲存貯體的任何現有組態。若要更新生命週期組態，您必須先擷取現有的生命週期組態，並進行變更，然後將修正過的生命週期組態新增至儲存貯體。
下列範例顯示如何使用 AWS SDK for .NET 新增、更新和刪除儲存貯體的生命週期組態。此程式法範例可做到以下：
如需設定和執行程式碼範例的資訊，請參閱《AWS SDK for .NET
開發人員指南》中的AWS SDK for .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 SDK for Ruby 來管理儲存貯體上的 S3 生命週期組態，方法是使用類別 AWS::S3::BucketLifecycleConfiguration。如需管理 S3 生命週期組態的詳細資訊，請參閱管理物件的生命週期。
Amazon Simple Storage Service API 參考中的下列主題說明與 S3 生命週期組態相關的 REST API：
進行 S3 生命週期疑難排解
如需使用 S3 生命週期時可能發生的常見問題，請參閱針對 Amazon S3 生命週期問題進行疑難排解。
