在存储桶上设置生命周期配置
本节介绍如何使用 Amazon S3 控制台、AWS Command Line Interface(AWS CLI)、AWS SDK 或 Amazon S3 REST API 在存储桶上设置 Amazon S3 生命周期配置。有关 S3 生命周期配置的信息,请参阅 管理对象的生命周期。
您可以使用生命周期规则来定义您希望 Amazon 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 遵循以下一般规则:
有关示例,请参阅示例 5:重叠的筛选条件、冲突的生命周期操作,以及 Amazon S3 如何处理非版本化的存储桶。
您可以使用共享前缀(以通用字符串开头的对象名称)或标签为存储桶中的所有对象或一部分对象定义生命周期规则。在生命周期规则中,您可以定义特定于当前和非当前对象版本的操作。有关更多信息,请参阅下列内容:
创建生命周期规则
-
登录到 AWS Management Console,然后通过以下网址打开 Amazon S3 控制台:https://console.aws.amazon.com/s3/。
-
在 Buckets(存储桶)列表中,请选择要为其创建生命周期规则的存储桶的名称。
-
请选择 Management(管理)选项卡,然后选择 Create lifecycle rule(创建生命周期规则)。
-
在 Lifecycle rule name (生命周期规则名称) 中,输入规则的名称。
在该存储桶内,此名称必须是唯一的。
-
请选择生命周期规则的范围:
-
要将此生命周期规则应用于所有带特定前缀或标签的对象,请选择将范围限制在特定前缀或标签。
有关对象名称前缀的更多信息,请参阅 创建对象键名称。有关对象标签的更多信息,请参阅 使用标签对存储进行分类。
-
要将此生命周期规则应用于存储桶中的所有对象,请选择此规则适用于存储桶中的所有 对象,然后选择我确认此规则适用于存储桶中的所有对象。
-
要按对象大小筛选规则,可以选择指定最小对象大小和/或指定最大对象大小选项。
-
在 Lifecycle rule actions (生命周期规则操作) 下,请选择希望生命周期规则执行的操作:
-
在存储类之间转换对象的当前版本
-
在存储类之间转换对象的先前版本
-
使对象的当前版本过期
-
永久删除对象的先前版本
-
删除过期的删除标记或未完成的分段上传
根据您选择的操作,会显示不同的选项。
-
要在存储类之间转换对象的当前版本,请在 Transition current versions of objects between storage classes (在存储类之间转换对象的当前版本) 下面:
-
在存储类转换中,请选择要转换到的存储类。有关可能的转换的列表,请参阅支持的生命周期转换。可从以下存储类中进行选择:
-
在 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(对象变为非当前对象后的天数)中输入天数。您可以选择在 Number of newer versions to retain(要保留的较新版本的数量)下输入一个值,从而指定要保留的较新版本数量。
-
在 Delete expired delete markers or incomplete multipart uploads (删除过期的删除标记或未完成的分段上传) 下面,请选择 Delete expired object delete markers (删除过期对象的删除标记) 和 Delete incomplete multipart uploads (删除未完成的分段上传)。然后,输入您要在分段上传启动多少天后结束并清理未完成的分段上传。
有关分段上传的更多信息,请参阅 使用分段上传来上传和复制对象。
-
请选择 Create rule (创建规则)。
如果规则没有任何错误,Amazon S3 会启用它,并且您可以在 Lifecycle rules (生命周期规则) 下的 Management (管理) 选项卡上看到它。
有关 AWS CloudFormation 模板和示例的信息,请参阅《AWS CloudFormation 用户指南》中的使用 AWS CloudFormation 模板和 AWS::S3::Bucket。
您可以使用以下 AWS CLI 命令管理 S3 生命周期配置:
有关设置 AWS CLI 的说明,请参阅 使用 AWS CLI 进行 Amazon S3 开发。
Amazon S3 生命周期配置是一个 XML 文件。但在使用 AWS CLI 时,您不能指定 XML 格式。您必须改为指定 JSON 格式。以下是您可在 AWS CLI 命令中指定的示例 XML 生命周期配置和等效 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 添加、更新和删除存储桶的生命周期配置。该代码示例执行以下操作:
有关设置和运行代码示例的信息,请参阅《适用于 .NET 的 AWS SDK 开发人员指南》中的适用于 .NET 的 AWS SDK 入门。
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,您可使用 AWS SDK for Ruby 管理存储桶上的 S3 生命周期配置。有关管理生命周期配置的更多信息,请参阅 管理对象的生命周期。
《Amazon Simple Storage Service API 参考》中的以下几节描述了与 S3 生命周期配置相关的 REST API。
S3 生命周期问题排查
有关使用 S3 生命周期时可能出现的常见问题,请参阅排查 Amazon S3 生命周期问题。