OSS支持标准存储、低频访问、归档存储、冷归档存储四种存储类型,您可以通过生命周期规则或者CopyObject的方式随时转换文件(Object)的存储类型。
对开通了OSS-HDFS服务的Bucket,建议不要修改OSS-HDFS的数据存储目录.dlsdata/
下任意Object的存储类型。
如果您将.dlsdata/
下任意Object的存储类型修改为低频类型时,通过OSS-HDFS可正常访问数据。如果您将Object存储类型修改为归档或冷归档后,通过OSS-HDFS无法访问数据。如需访问,您需要对数据进行解冻操作,解冻完成后再尝试访问数据。
通过生命周期规则自动转换Object的存储类型
OSS生命周期管理(Lifecycle)提供Object Transition机制,支持自动转换文件存储类型。关于OSS支持的四种存储类型的更多信息,请参见存储类型介绍。
基于最后一次修改时间的存储类型转换
- 本地冗余存储(LRS)
本地冗余类型文件转换规则如下:
- 标准存储(LRS)类型可转换为低频访问(LRS)、归档存储(LRS)和冷归档存储(LRS)类型。
- 低频访问(LRS)类型可转换为归档存储(LRS)和冷归档存储(LRS)类型。
- 归档存储(LRS)类型可转换为冷归档存储(LRS)类型。
当Bucket同时配置了转换为低频访问、转换为归档存储、转换为冷归档存储的策略,其转换周期必须满足以下条件:
转换为低频访问的周期<转换为归档的周期<转换为冷归档的周期
- 同城冗余存储(ZRS)
同城冗余类型文件转换规则如下:
- 标准存储(ZRS)类型可转换为低频访问(ZRS)类型。
- 标准存储(ZRS)类型可转换为冷归档存储(LRS)类型。
- 低频访问(ZRS)类型可转换为冷归档存储(LRS)类型。
更多信息,请参见基于最后一次修改时间的生命周期规则介绍。
基于最后一次访问时间的存储类型转换

以上规则仅适用于LRS类型Object之间的转换。
- 基于最后一次访问时间的生命周期规则支持将Object从标准存储类型转为低频访问类型,您还可以选择当Object被访问后是否自动转回标准存储类型。
- 基于最后一次访问时间的生命周期规则支持将Object从标准存储或低频访问类型转为归档或冷归档存储类型,也可以选择将Object从归档转为冷归档存储类型。如果您需要将Object从标准存储或低频访问类型转换为归档或冷归档存储类型,请提交工单申请转换为归档或冷归档类型的权限,申请通过后您需要指定转换的目标存储类型。
重要 工单申请通过后,如果您基于最后一次访问时间策略将Object从标准存储或低频访问类型转为归档或冷归档类型,则Bucket中归档或冷归档类型Object的最后一次访问时间默认为该Bucket开启访问追踪的时间。
更多信息,请参见基于最后一次访问时间的生命周期规则介绍。
通过生命周期规则转换存储类型操作方式
您可以通过多种方式设置生命周期规则。生命周期规则可用于将多个Object在指定时间内转储为指定存储类型,或者将过期的Object和碎片删除。您可以结合以下示例按需选择通过生命周期规则将Object转储为指定存储类型。
使用OSS管理控制台
- 登录OSS管理控制台。
- 单击Bucket列表,然后单击目标Bucket名称。
- 在左侧导航栏, 选择 。
- 可选:如果您需要创建基于最后一次访问时间策略的生命周期规则,请在生命周期页面,打开启用访问追踪开关。
- 在生命周期页面,单击创建规则。
- 在创建生命周期规则面板,按如下说明配置生命周期规则。
- 存储空间未开启版本控制
区域 配置项 说明 基础设置 状态 设置生命周期规则的状态,可选择启动或禁用。
策略 选择生命周期规则作用的Object。您可以选择按前缀匹配或配置到整个Bucket。
是否允许前缀重叠 OSS默认会检查各个生命周期规则的前缀是否重叠。例如,您设置了以下两条包含重叠前缀的生命周期规则:- 规则1
指定该Bucket内所有前缀为dir1/的Object在距离最后一次修改时间180天后删除。
- 规则2
指定该Bucket内所有前缀为dir1/dir2/的Object在距离最后一次修改时间30天后转低频访问类型,60天后删除。
在未选中该选项的情况下,因后台检测到dir1/dir2/目录下的Object同时匹配两条删除规则,因此会拒绝设置以上两条生命周期规则,并报错Overlap for same action type Expiration.。
在选中该选项的情况下,dir1/dir2/下的Object会在30天后转低频访问类型,60天后删除。dir1/下的其他Object会在180天删除。
前缀 输入规则要匹配的Object名称的前缀。- 前缀设置为img,表示匹配名称以img开头的所有Object,例如imgtest.png、img/example.jpg等。
- 前缀设置为img/,表示匹配名称以img/开头的所有Object,例如img/example.jpg、img/test.jpg等。
标签 生命周期规则仅针对拥有指定标签Object生效。例如选择了按前缀匹配,设置前缀为img,并设置标签的key为a,value为1。则该规则将匹配所有名称以img开头,标签为a=1的Object。关于对象标签的更多信息,请参见对象标签。
NOT NOT选项用于设置生命周期规则对指定前缀和标签的Object不生效。
重要- 开启NOT选项时,前缀和标签必须至少存在一项,即同时设置前缀和标签或者只设置前缀或标签。
- NOT语义定义标签中的key不支持与标签配置项中定义的key相同。
- 开启NOT选项后,不支持设置碎片过期策略。
文件执行策略设置 文件过期策略 选择Object过期策略,可选择过期天数、过期日期和不启用。选择不启用时,文件过期策略不生效。
生命周期管理规则 配置转换Object存储类型或者删除过期Object的规则。
配置示例1:当您选择了最后一次访问时间策略,然后将过期天数设置为30,并指定数据在超出指定过期天数后将自动转换为低频存储类型(数据被访问后,依旧保留在低频档),则最后访问日期为2021年09月01日的Object会在2021年10月01日被转换为指定的存储类型。
说明 当您选择基于最后一次访问时间的生命周期管理规则时,允许指定该规则仅对大于64 KB的文件生效,也可以指定为对所有文件生效。配置示例2:当您选择了最后一次修改时间策略,然后将过期日期设置为2021年9月24日,并指定在指定日期前的数据自动删除,则最后修改日期在2021年9月24日之前的Object会被自动删除,且删除后不可恢复。
碎片执行策略设置 碎片过期策略 设置对过期碎片执行的操作。如果选中了标签,则无法配置该选项。您可以选择碎片过期策略的过期天数或过期日期,也可以选择不启用碎片过期策略。当选择不启用时,碎片过期策略不生效。
重要 生命周期规则至少包含文件过期策略或碎片过期策略。碎片规则 根据碎片过期策略选择的过期天数或过期日期设定碎片何时过期,碎片过期后会被自动删除,且删除后不可恢复。
- 规则1
- 存储空间已开启版本控制
开启版本控制后,基本设置与碎片执行策略设置区域涉及的配置项,与未开启版本控制的配置方法相同。以下表格仅介绍与未开启版本控制相比,开启版本控制后配置项存在的差异。
区域 配置项 说明 当前版本文件执行策略设置 清理对象删除标记 开启版本控制后,清除策略中增加了清理对象删除标记选项,其他选项与未开启版本控制时相同。
选择此选项后,如果当前Object仅有一个版本且为删除标记时,则OSS将删除过期Object的删除标记。如果当前Object有多个版本,且Object的最新版本为删除标记时,则OSS将保留该删除标记。关于删除标记的更多信息,请参见删除标记。
历史版本文件执行策略设置 文件过期策略 设置历史版本文件的过期策略,可选择过期天数和不启用。当选择不启用时,文件过期策略不生效。
生命周期管理规则 设定一个过期天数N,历史版本的Object会在其被转换为历史版本的N天后过期,并在过期的第二天执行指定操作。例如设置为30,则在2021年09月01日被转为历史版本的Object会在2021年10月01日被转换为指定存储类型或被删除。
重要 您可以通过Object下一个版本的最后一次修改时间确定Object被转为历史版本的时间。
- 存储空间未开启版本控制
- 单击确定。
生命周期规则保存成功后,您可以在策略列表中查看已设置的生命周期规则。
使用阿里云SDK
以下仅列举常见SDK的配置生命周期规则的代码示例。关于其他SDK的配置生命周期规则的代码示例,请参见SDK简介。
OSS ossClient = null;
try {
// yourEndpoint填写Bucket所在地域对应的Endpoint。以华东1(杭州)为例,Endpoint填写为https://oss-cn-hangzhou.aliyuncs.com。
String endpoint = "yourEndpoint";
// 阿里云账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用RAM用户进行API访问或日常运维,请登录RAM控制台创建RAM用户。
String accessKeyId = "yourAccessKeyId";
String accessKeySecret = "yourAccessKeySecret";
// 填写Bucket名称,例如examplebucket。
String bucketName = "examplebucket";
// 创建OSSClient实例。
ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);
// 创建SetBucketLifecycleRequest。
SetBucketLifecycleRequest request = new SetBucketLifecycleRequest(bucketName);
// 设置规则ID。
String ruleId0 = "rule0";
// 设置文件匹配前缀。
String matchPrefix0 = "A0/";
// 设置要匹配的标签。
Map<String, String> matchTags0 = new HashMap<String, String>();
// 依次填写要匹配标签的键(例如owner)和值(例如John)。
matchTags0.put("owner", "John");
String ruleId1 = "rule1";
String matchPrefix1 = "A1/";
Map<String, String> matchTags1 = new HashMap<String, String>();
matchTags1.put("type", "document");
String ruleId2 = "rule2";
String matchPrefix2 = "A2/";
String ruleId3 = "rule3";
String matchPrefix3 = "A3/";
String ruleId4 = "rule4";
String matchPrefix4 = "A4/";
String ruleId5 = "rule5";
String matchPrefix5 = "A5/";
String ruleId6 = "rule6";
String matchPrefix6 = "A6/";
// 距最后修改时间3天后过期。
LifecycleRule rule = new LifecycleRule(ruleId0, matchPrefix0, LifecycleRule.RuleStatus.Enabled, 3);
rule.setTags(matchTags0);
request.AddLifecycleRule(rule);
// 指定日期之前创建的文件过期。
rule = new LifecycleRule(ruleId1, matchPrefix1, LifecycleRule.RuleStatus.Enabled);
rule.setCreatedBeforeDate(DateUtil.parseIso8601Date("2022-10-12T00:00:00.000Z"));
rule.setTags(matchTags1);
request.AddLifecycleRule(rule);
// 分片3天后过期。
rule = new LifecycleRule(ruleId2, matchPrefix2, LifecycleRule.RuleStatus.Enabled);
LifecycleRule.AbortMultipartUpload abortMultipartUpload = new LifecycleRule.AbortMultipartUpload();
abortMultipartUpload.setExpirationDays(3);
rule.setAbortMultipartUpload(abortMultipartUpload);
request.AddLifecycleRule(rule);
// 指定日期之前的分片过期。
rule = new LifecycleRule(ruleId3, matchPrefix3, LifecycleRule.RuleStatus.Enabled);
abortMultipartUpload = new LifecycleRule.AbortMultipartUpload();
abortMultipartUpload.setCreatedBeforeDate(DateUtil.parseIso8601Date("2022-10-12T00:00:00.000Z"));
rule.setAbortMultipartUpload(abortMultipartUpload);
request.AddLifecycleRule(rule);
// 距最后修改时间10天后转低频访问存储类型,距最后修改时间30天后转归档存储类型。
rule = new LifecycleRule(ruleId4, matchPrefix4, LifecycleRule.RuleStatus.Enabled);
List<LifecycleRule.StorageTransition> storageTransitions = new ArrayList<LifecycleRule.StorageTransition>();
LifecycleRule.StorageTransition storageTransition = new LifecycleRule.StorageTransition();
storageTransition.setStorageClass(StorageClass.IA);
storageTransition.setExpirationDays(10);
storageTransitions.add(storageTransition);
storageTransition = new LifecycleRule.StorageTransition();
storageTransition.setStorageClass(StorageClass.Archive);
storageTransition.setExpirationDays(30);
storageTransitions.add(storageTransition);
rule.setStorageTransition(storageTransitions);
request.AddLifecycleRule(rule);
// 指定最后修改日期在2022-10-12之前的文件转为归档存储。
rule = new LifecycleRule(ruleId5, matchPrefix5, LifecycleRule.RuleStatus.Enabled);
storageTransitions = new ArrayList<LifecycleRule.StorageTransition>();
storageTransition = new LifecycleRule.StorageTransition();
storageTransition.setCreatedBeforeDate(DateUtil.parseIso8601Date("2022-10-12T00:00:00.000Z"));
storageTransition.setStorageClass(StorageClass.Archive);
storageTransitions.add(storageTransition);
rule.setStorageTransition(storageTransitions);
request.AddLifecycleRule(rule);
// rule6针对版本控制状态下的Bucket。
rule = new LifecycleRule(ruleId6, matchPrefix6, LifecycleRule.RuleStatus.Enabled);
// 设置Object相对最后修改时间365天之后自动转为归档文件。
storageTransitions = new ArrayList<LifecycleRule.StorageTransition>();
storageTransition = new LifecycleRule.StorageTransition();
storageTransition.setStorageClass(StorageClass.Archive);
storageTransition.setExpirationDays(365);
storageTransitions.add(storageTransition);
rule.setStorageTransition(storageTransitions);
// 设置自动移除过期删除标记。
rule.setExpiredDeleteMarker(true);
// 设置非当前版本的object距最后修改时间10天之后转为低频访问类型。
LifecycleRule.NoncurrentVersionStorageTransition noncurrentVersionStorageTransition =
new LifecycleRule.NoncurrentVersionStorageTransition().withNoncurrentDays(10).withStrorageClass(StorageClass.IA);
// 设置非当前版本的Object距最后修改时间20天之后转为归档类型。
LifecycleRule.NoncurrentVersionStorageTransition noncurrentVersionStorageTransition2 =
new LifecycleRule.NoncurrentVersionStorageTransition().withNoncurrentDays(20).withStrorageClass(StorageClass.Archive);
// 设置非当前版本Object 30天后删除。
LifecycleRule.NoncurrentVersionExpiration noncurrentVersionExpiration = new LifecycleRule.NoncurrentVersionExpiration().withNoncurrentDays(30);
List<LifecycleRule.NoncurrentVersionStorageTransition> noncurrentVersionStorageTransitions = new ArrayList<LifecycleRule.NoncurrentVersionStorageTransition>();
noncurrentVersionStorageTransitions.add(noncurrentVersionStorageTransition2);
rule.setStorageTransition(storageTransitions);
rule.setNoncurrentVersionExpiration(noncurrentVersionExpiration);
rule.setNoncurrentVersionStorageTransitions(noncurrentVersionStorageTransitions);
request.AddLifecycleRule(rule);
// 发起设置生命周期规则请求。
ossClient.setBucketLifecycle(request);
// 查看生命周期规则。
List<LifecycleRule> listRules = ossClient.getBucketLifecycle(bucketName);
for(LifecycleRule rules : listRules){
System.out.println("ruleId="+rules.getId()+", matchPrefix="+rules.getPrefix());
}
} catch (Exception e) {
e.printStackTrace();
} finally {
if(ossClient != null){
// 关闭OSSClient。
ossClient.shutdown();
}
}
<?php
if (is_file(__DIR__ . '/../autoload.php')) {
require_once __DIR__ . '/../autoload.php';
}
if (is_file(__DIR__ . '/../vendor/autoload.php')) {
require_once __DIR__ . '/../vendor/autoload.php';
}
use OSS\OssClient;
use OSS\Core\OssException;
use OSS\Model\LifecycleConfig;
use OSS\Model\LifecycleRule;
use OSS\Model\LifecycleAction;
// 阿里云账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用RAM用户进行API访问或日常运维,请登录RAM控制台创建RAM用户。
$accessKeyId = "yourAccessKeyId";
$accessKeySecret = "yourAccessKeySecret";
// Endpoint以华东1(杭州)为例,其它Region请按实际情况填写。
$endpoint = "https://oss-cn-hangzhou.aliyuncs.com";
// 填写存储空间名称。
$bucket= "yourBucketName";
// 设置规则ID和文件前缀。
$ruleId0 = "rule0";
$matchPrefix0 = "A0/";
$ruleId1 = "rule1";
$matchPrefix1 = "A1/";
$lifecycleConfig = new LifecycleConfig();
$actions = array();
// 距最后修改时间3天后过期。
$actions[] = new LifecycleAction(OssClient::OSS_LIFECYCLE_EXPIRATION, OssClient::OSS_LIFECYCLE_TIMING_DAYS, 3);
$lifecycleRule = new LifecycleRule($ruleId0, $matchPrefix0, "Enabled", $actions);
$lifecycleConfig->addRule($lifecycleRule);
$actions = array();
// 指定日期之前创建的文件过期。
$actions[] = new LifecycleAction(OssClient::OSS_LIFECYCLE_EXPIRATION, OssClient::OSS_LIFECYCLE_TIMING_DATE, '2022-10-12T00:00:00.000Z');
$lifecycleRule = new LifecycleRule($ruleId1, $matchPrefix1, "Enabled", $actions);
$lifecycleConfig->addRule($lifecycleRule);
try {
$ossClient = new OssClient($accessKeyId, $accessKeySecret, $endpoint);
$ossClient->putBucketLifecycle($bucket, $lifecycleConfig);
} catch (OssException $e) {
printf(__FUNCTION__ . ": FAILED\n");
printf($e->getMessage() . "\n");
return;
}
print(__FUNCTION__ . ": OK" . "\n");
const OSS = require('ali-oss')
const client = new OSS({
// yourregion填写Bucket所在地域。以华东1(杭州)为例,Region填写为oss-cn-hangzhou。
region: 'yourregion',
// 阿里云账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用RAM用户进行API访问或日常运维,请登录RAM控制台创建RAM用户。
accessKeyId: 'yourAccessKeyId',
accessKeySecret: 'yourAccessKeySecret',
// yourbucketname填写存储空间名称。
bucket: 'yourbucketname'
});
async function putBucketLifecycle(lifecycle) {
try {
const result = await client.putBucketLifecycle('yourbucketname', [
lifecycle
]);
console.log(result);
} catch (e) {
console.log(e);
}
}
const lifecycle1 = {
id: 'rule1',
status: 'Enabled',
prefix: 'foo/',
expiration: {
days: 3 // 指定当前版本Object距其最后修改时间3天后过期。
}
}
putBucketLifecycle(lifecycle1)
const lifecycle2 = {
id: 'rule2',
status: 'Enabled',
prefix: 'foo/',
expiration: {
createdBeforeDate: '2020-02-18T00:00:00.000Z' // 指定日期之前创建的文件过期。
},
}
putBucketLifecycle(lifecycle2)
const lifecycle3 = {
id: 'rule3',
status: 'Enabled',
prefix: 'foo/',
abortMultipartUpload: {
days: 3 // 指定分片3天后过期。
},
}
putBucketLifecycle(lifecycle3)
const lifecycle4 = {
id: 'rule4',
status: 'Enabled',
prefix: 'foo/',
abortMultipartUpload: {
createdBeforeDate: '2020-02-18T00:00:00.000Z' // 指定日期之前创建的分片过期。
},
}
putBucketLifecycle(lifecycle4)
const lifecycle5 = {
id: 'rule5',
status: 'Enabled',
prefix: 'foo/',
transition: {
// 指定当前版本Object距其最后修改时间20天后转归档存储类型。
days: 20,
storageClass: 'Archive'
},
expiration: {
days: 21 // 指定当前版本Object距其最后修改时间21天后过期。
},
}
putBucketLifecycle(lifecycle5)
const lifecycle6 = {
id: 'rule6',
status: 'Enabled',
prefix: 'foo/',
transition: {
// 指定日期之前自动将文件转为归档类型。
createdBeforeDate: '2020-02-18T00:00:00.000Z', // 指定日期应早于文件过期时间。
storageClass: 'Archive'
},
expiration: {
createdBeforeDate: '2020-02-19T00:00:00.000Z' // 指定日期之前创建的文件过期。
},
}
putBucketLifecycle(lifecycle6)
const lifecycle7 = {
id: 'rule7',
status: 'Enabled',
prefix: 'foo/',
noncurrentVersionExpiration: {
noncurrentDays: 1 // 设置Object成为非当前版本1天后过期。
},
}
putBucketLifecycle(lifecycle7)
const lifecycle8 = {
id: 'rule8',
status: 'Enabled',
prefix: 'foo/',
expiredObjectDeleteMarker: true // 设置自动移除过期删除标记。
}
putBucketLifecycle(lifecycle8)
const lifecycle9 = {
id: 'rule9',
status: 'Enabled',
prefix: 'foo/',
// 设置非当前版本的Object距其最后修改时间10天之后转为低频访问类型。
noncurrentVersionTransition: {
noncurrentDays: '10',
storageClass: 'IA'
}
}
putBucketLifecycle(lifecycle9)
const lifecycle10 = {
id: 'rule10',
status: 'Enabled',
prefix: 'foo/',
// 设置非当前版本的Object距其最后修改时间10天之后转为低频访问类型。
noncurrentVersionTransition: {
noncurrentDays: '10',
storageClass: 'IA'
},
// 指定规则所适用的对象标签。
tag: [{
key: 'key1',
value: 'value1'
},
{
key: 'key2',
value: 'value2'
}]
}
putBucketLifecycle(lifecycle10)
# -*- coding: utf-8 -*-
import oss2
import datetime
from oss2.models import (LifecycleExpiration, LifecycleRule,
BucketLifecycle,AbortMultipartUpload,
TaggingRule, Tagging, StorageTransition,
NoncurrentVersionStorageTransition,
NoncurrentVersionExpiration)
# 阿里云账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用RAM用户进行API访问或日常运维,请登录RAM控制台创建RAM用户。
auth = oss2.Auth('yourAccessKeyId', 'yourAccessKeySecret')
# 填写Bucket所在地域对应的Endpoint。以华东1(杭州)为例,Endpoint填写为https://oss-cn-hangzhou.aliyuncs.com。
# yourBucketName填写Bucket名称,例如examplebucket。
bucket = oss2.Bucket(auth, 'http://oss-cn-hangzhou.aliyuncs.com', 'examplebucket')
# 设置Object距其最后修改时间3天后过期。
rule1 = LifecycleRule('rule1', 'tests/',
status=LifecycleRule.ENABLED,
expiration=LifecycleExpiration(days=3))
# 设置Object过期规则,指定日期之前创建的文件过期。
rule2 = LifecycleRule('rule2', 'tests2/',
status=LifecycleRule.ENABLED,
expiration=LifecycleExpiration(created_before_date=datetime.date(2022, 12, 12)))
# 设置分片过期规则,分片3天后过期。
rule3 = LifecycleRule('rule3', 'tests3/',
status=LifecycleRule.ENABLED,
abort_multipart_upload=AbortMultipartUpload(days=3))
# 设置分片过期规则,指定日期之前的分片过期。
rule4 = LifecycleRule('rule4', 'tests4/',
status=LifecycleRule.ENABLED,
abort_multipart_upload = AbortMultipartUpload(created_before_date=datetime.date(2022, 12, 12)))
# 设置存储类型转换规则,指定Object在其最后修改时间20天之后转为低频访问类型,在其最后修改时间30天之后转为归档类型。
rule5 = LifecycleRule('rule5', 'tests5/',
status=LifecycleRule.ENABLED,
storage_transitions=[StorageTransition(days=20,storage_class=oss2.BUCKET_STORAGE_CLASS_IA),
StorageTransition(days=30,storage_class=oss2.BUCKET_STORAGE_CLASS_ARCHIVE)])
# 设置匹配的标签。
tagging_rule = TaggingRule()
tagging_rule.add('key1', 'value1')
tagging_rule.add('key2', 'value2')
tagging = Tagging(tagging_rule)
# 设置存储类型转换规则,指定Object在其最后修改时间超过365天后转为ARCHIVE类型。
# rule6与以上几个规则不同的是它指定了匹配的标签,同时拥有key1=value1,key2=value2两个标签的object才会匹配此规则。
rule6 = LifecycleRule('rule6', 'tests6/',
status=LifecycleRule.ENABLED,
storage_transitions=[StorageTransition(created_before_date=datetime.date(2022, 12, 12),storage_class=oss2.BUCKET_STORAGE_CLASS_IA)],
tagging = tagging)
# rule7针对版本控制状态下的Bucket。
# 设置Object在其最后修改时间365天之后自动转为ARCHIVE类型。
# 设置自动移除过期删除标记。
# 设置非当前版本Object 12天后转为IA类型。
# 设置非当前版本Object 20天后转为ARCHIVE类型。
# 设置非当前版本Object 30天后删除。
rule7 = LifecycleRule('rule7', 'tests7/',
status=LifecycleRule.ENABLED,
storage_transitions=[StorageTransition(days=365, storage_class=oss2.BUCKET_STORAGE_CLASS_ARCHIVE)],
expiration=LifecycleExpiration(expired_detete_marker=True),
noncurrent_version_sotrage_transitions =
[NoncurrentVersionStorageTransition(12, oss2.BUCKET_STORAGE_CLASS_IA),
NoncurrentVersionStorageTransition(20, oss2.BUCKET_STORAGE_CLASS_ARCHIVE)],
noncurrent_version_expiration = NoncurrentVersionExpiration(30))
lifecycle = BucketLifecycle([rule1, rule2, rule3, rule4, rule5, rule6, rule7])
bucket.put_bucket_lifecycle(lifecycle)
using Aliyun.OSS;
using Aliyun.OSS.Common;
// 填写Bucket所在地域对应的Endpoint。以华东1(杭州)为例,Endpoint填写为https://oss-cn-hangzhou.aliyuncs.com。
var endpoint = "https://oss-cn-hangzhou.aliyuncs.com";
// 阿里云账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用RAM用户进行API访问或日常运维,请登录RAM控制台创建RAM用户。
var accessKeyId = "yourAccessKeyId";
var accessKeySecret = "yourAccessKeySecret";
// 填写Bucket名称,例如examplebucket。
var bucketName = "examplebucket";
// 创建OSSClient实例。
var client = new OssClient(endpoint, accessKeyId, accessKeySecret);
try
{
var setBucketLifecycleRequest = new SetBucketLifecycleRequest(bucketName);
// 创建第1条生命周期规则。
LifecycleRule lcr1 = new LifecycleRule()
{
ID = "delete obsoleted files",
Prefix = "obsoleted/",
Status = RuleStatus.Enabled,
ExpriationDays = 3,
Tags = new Tag[1]
};
// 设置标签。
var tag1 = new Tag
{
Key = "project",
Value = "projectone"
};
lcr1.Tags[0] = tag1;
// 创建第2条生命周期规则。
LifecycleRule lcr2 = new LifecycleRule()
{
ID = "delete temporary files",
Prefix = "temporary/",
Status = RuleStatus.Enabled,
ExpriationDays = 20,
Tags = new Tag[1]
};
// 设置标签。
var tag2 = new Tag
{
Key = "user",
Value = "jsmith"
};
lcr2.Tags[0] = tag2;
// 设置碎片在距最后修改时间30天后过期。
lcr2.AbortMultipartUpload = new LifecycleRule.LifeCycleExpiration()
{
Days = 30
};
LifecycleRule lcr3 = new LifecycleRule();
lcr3.ID = "only NoncurrentVersionTransition";
lcr3.Prefix = "test1";
lcr3.Status = RuleStatus.Enabled;
lcr3.NoncurrentVersionTransitions = new LifecycleRule.LifeCycleNoncurrentVersionTransition[2]
{
// 设置非当前版本的Object距最后修改时间90天之后转为低频访问类型。
new LifecycleRule.LifeCycleNoncurrentVersionTransition(){
StorageClass = StorageClass.IA,
NoncurrentDays = 90
},
// 设置非当前版本的Object距最后修改时间180天之后转为归档类型。
new LifecycleRule.LifeCycleNoncurrentVersionTransition(){
StorageClass = StorageClass.Archive,
NoncurrentDays = 180
}
};
setBucketLifecycleRequest.AddLifecycleRule(lcr1);
setBucketLifecycleRequest.AddLifecycleRule(lcr2);
setBucketLifecycleRequest.AddLifecycleRule(lcr3);
// 设置生命周期规则。
client.SetBucketLifecycle(setBucketLifecycleRequest);
Console.WriteLine("Set bucket:{0} Lifecycle succeeded ", bucketName);
}
catch (OssException ex)
{
Console.WriteLine("Failed with error code: {0}; Error info: {1}. \nRequestID:{2}\tHostID:{3}",
ex.ErrorCode, ex.Message, ex.RequestId, ex.HostId);
}
catch (Exception ex)
{
Console.WriteLine("Failed with error info: {0}", ex.Message);
}
PutBucketLifecycleRequest request = new PutBucketLifecycleRequest();
request.setBucketName("examplebucket");
BucketLifecycleRule rule1 = new BucketLifecycleRule();
// 设置规则ID和文件前缀。
rule1.setIdentifier("1");
rule1.setPrefix("A");
// 设置是否执行生命周期规则。如果值为true,则OSS会定期执行该规则;如果值为false,则OSS会忽略该规则。
rule1.setStatus(true);
// 距最后修改时间200天后过期。
rule1.setDays("200");
// 30天后自动转为归档存储类型(Archive)
rule1.setArchiveDays("30");
// 未完成分片3天后过期。
rule1.setMultipartDays("3");
// 15天后自动转为低频存储类型(IA)。
rule1.setIADays("15");
BucketLifecycleRule rule2 = new BucketLifecycleRule();
rule2.setIdentifier("2");
rule2.setPrefix("B");
rule2.setStatus(true);
rule2.setDays("300");
rule2.setArchiveDays("30");
rule2.setMultipartDays("3");
rule2.setIADays("15");
ArrayList<BucketLifecycleRule> lifecycleRules = new ArrayList<BucketLifecycleRule>();
lifecycleRules.add(rule1);
lifecycleRules.add(rule2);
request.setLifecycleRules(lifecycleRules);
OSSAsyncTask task = oss.asyncPutBucketLifecycle(request, new OSSCompletedCallback<PutBucketLifecycleRequest, PutBucketLifecycleResult>() {
@Override
public void onSuccess(PutBucketLifecycleRequest request, PutBucketLifecycleResult result) {
OSSLog.logInfo("code::"+result.getStatusCode());
}
@Override
public void onFailure(PutBucketLifecycleRequest request, ClientException clientException, ServiceException serviceException) {
OSSLog.logError("error: "+serviceException.getRawMessage());
}
});
task.waitUntilFinished();
package main
import (
"fmt"
"os"
"github.com/aliyun/aliyun-oss-go-sdk/oss"
)
func main() {
// 创建OSSClient实例。
// yourEndpoint填写Bucket对应的Endpoint,以华东1(杭州)为例,填写为https://oss-cn-hangzhou.aliyuncs.com。其它Region请按实际情况填写。
// 阿里云账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用RAM用户进行API访问或日常运维,请登录RAM控制台创建RAM用户。
client, err := oss.New("yourEndpoint", "yourAccessKeyId", "yourAccessKeySecret")
if err != nil {
fmt.Println("Error:", err)
os.Exit(-1)
}
// 指定生命周期规则1,并在规则中指定前缀为foo的文件在距离最后一次修改时间3天后过期。
rule1 := oss.BuildLifecycleRuleByDays("rule1", "foo/", true, 3)
// 在受版本控制状态下的Object仅有删除标记的情况下,自动删除删除标记。
deleteMark := true
expiration := oss.LifecycleExpiration{
ExpiredObjectDeleteMarker: &deleteMark,
}
// 非当前版本Object超过30天后过期删除。
versionExpiration := oss.LifecycleVersionExpiration{
NoncurrentDays: 30,
}
// 非当前版本Object超过10天后转为IA存储类型。
versionTransition := oss.LifecycleVersionTransition{
NoncurrentDays: 10,
StorageClass: "IA",
}
// 指定生命周期规则2。
rule2 := oss.LifecycleRule{
ID: "rule2",
Prefix: "yourObjectPrefix",
Status: "Enabled",
Expiration: &expiration,
NonVersionExpiration: &versionExpiration,
NonVersionTransition: &versionTransition,
}
// 指定生命周期规则3,对标签键为tag1、标签值为value1的文件,距文件最后一次修改时间3天后过期。
rule3 := oss.LifecycleRule{
ID: "rule3",
Prefix: "",
Status: "Enabled",
Tags: []oss.Tag{
oss.Tag{
Key: "tag1",
Value: "value1",
},
},
Expiration: &oss.LifecycleExpiration{Days: 3},
}
// 设置生命周期规则。
rules := []oss.LifecycleRule{rule1, rule2, rule3}
// 填写Bucket名称,例如examplebucket。
bucketName := "examplebucket"
err = client.SetBucketLifecycle(bucketName, rules)
if err != nil {
fmt.Println("Error:", err)
os.Exit(-1)
}
}
#include <alibabacloud/oss/OssClient.h>
#include "../src/utils/Utils.h"
using namespace AlibabaCloud::OSS;
int main(void)
{
/*初始化OSS账号信息。*/
/*阿里云账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用RAM用户进行API访问或日常运维,请登录RAM控制台创建RAM用户。*/
std::string AccessKeyId = "yourAccessKeyId";
std::string AccessKeySecret = "yourAccessKeySecret";
/*yourEndpoint填写Bucket所在地域对应的Endpoint。以华东1(杭州)为例,Endpoint填写为https://oss-cn-hangzhou.aliyuncs.com。*/
std::string Endpoint = "yourEndpoint";
/*填写Bucket名称,例如examplebucket。*/
std::string BucketName = "examplebucket";
/*初始化网络等资源。*/
InitializeSdk();
ClientConfiguration conf;
OssClient client(Endpoint, AccessKeyId, AccessKeySecret, conf);
/*查看生命周期规则。*/
auto outcome = client.GetBucketLifecycle(BucketName);
if (outcome.isSuccess()) {
std::cout << "GetBucketLifecycle success," << std::endl;
for (auto const rule : outcome.result().LifecycleRules()) {
std::cout << "rule:" << rule.ID() << "," << rule.Prefix() << "," << rule.Status() << ","
"hasExpiration:" << rule.hasExpiration() << "," <<
"hasTransitionList:" << rule.hasTransitionList() << "," << std::endl;
auto taglist = rule.Tags();
for (const auto& tag : taglist)
{
std::cout <<"GetBucketLifecycle tag success, Key:"
<< tag.Key() << "; Value:" << tag.Value() << std::endl;
}
/*查看是否自动删除过期删除标记。*/
if (rule.ExpiredObjectDeleteMarker()) {
std::cout << "rule expired delete marker: " << rule.ExpiredObjectDeleteMarker() << std::endl;
}
/*查看非当前版本Object存储类型转换规则。*/
if (rule.hasNoncurrentVersionTransitionList()) {
for (auto const lifeCycleTransition : rule.NoncurrentVersionTransitionList()) {
std::cout << "rule noncurrent versions trans days:" << lifeCycleTransition.Expiration() <<
" trans storage class: " << ToStorageClassName(lifeCycleTransition.StorageClass()) << std::endl;
}
}
/*查看非当前版本Object过期规则。*/
if (rule.hasNoncurrentVersionExpiration()) {
std::cout << "rule noncurrent versions expiration days:" << rule.NoncurrentVersionExpiration().Days() << std::endl;
}
}
}
else {
/*异常处理。*/
std::cout << "GetBucketLifecycle fail" <<
",code:" << outcome.error().Code() <<
",message:" << outcome.error().Message() <<
",requestId:" << outcome.error().RequestId() << std::endl;
ShutdownSdk();
return -1;
}
/* 释放网络等资源。*/
ShutdownSdk();
return 0;
}
#include "oss_api.h"
#include "aos_http_io.h"
/* yourEndpoint填写Bucket所在地域对应的Endpoint。以华东1(杭州)为例,Endpoint填写为https://oss-cn-hangzhou.aliyuncs.com。*/
const char *endpoint = "yourEndpoint";
/* 阿里云账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用RAM用户进行API访问或日常运维,请登录RAM控制台创建RAM用户。*/
const char *access_key_id = "yourAccessKeyId";
const char *access_key_secret = "yourAccessKeySecret";
/* 填写Bucket名称,例如examplebucket。*/
const char *bucket_name = "examplebucket";
void init_options(oss_request_options_t *options)
{
options->config = oss_config_create(options->pool);
/* 用char*类型的字符串初始化aos_string_t类型。*/
aos_str_set(&options->config->endpoint, endpoint);
aos_str_set(&options->config->access_key_id, access_key_id);
aos_str_set(&options->config->access_key_secret, access_key_secret);
/* 是否使用cname域名访问OSS服务。0表示不使用。*/
options->config->is_cname = 0;
/* 用于设置网络相关参数,比如超时时间等。*/
options->ctl = aos_http_controller_create(options->pool, 0);
}
int main(int argc, char *argv[])
{
/* 在程序入口调用aos_http_io_initialize方法来初始化网络、内存等全局资源。*/
if (aos_http_io_initialize(NULL, 0) != AOSE_OK) {
exit(1);
}
/* 用于内存管理的内存池(pool),等价于apr_pool_t。其实现代码在apr库中。*/
aos_pool_t *pool;
/* 重新创建一个内存池,第二个参数是NULL,表示没有继承其它内存池。*/
aos_pool_create(&pool, NULL);
/* 创建并初始化options,该参数包括endpoint、access_key_id、acces_key_secret、is_cname、curl等全局配置信息。*/
oss_request_options_t *oss_client_options;
/* 在内存池中分配内存给options。*/
oss_client_options = oss_request_options_create(pool);
/* 初始化Client的选项oss_client_options。*/
init_options(oss_client_options);
/* 初始化参数。*/
aos_string_t bucket;
aos_table_t *resp_headers = NULL;
aos_status_t *resp_status = NULL;
aos_str_set(&bucket, bucket_name);
aos_list_t lifecycle_rule_list;
/* 给存储空间创建生命周期规则。*/
aos_str_set(&bucket, bucket_name);
aos_list_init(&lifecycle_rule_list);
/* 指定过期天数。*/
oss_lifecycle_rule_content_t *rule_content_days = oss_create_lifecycle_rule_content(pool);
aos_str_set(&rule_content_days->id, "rule-1");
aos_str_set(&rule_content_days->prefix, "obsoleted");
aos_str_set(&rule_content_days->status, "Enabled");
rule_content_days->days = 3;
aos_list_add_tail(&rule_content_days->node, &lifecycle_rule_list);
/* 指定过期时间。*/
oss_lifecycle_rule_content_t *rule_content_date = oss_create_lifecycle_rule_content(pool);
aos_str_set(&rule_content_date->id, "rule-2");
aos_str_set(&rule_content_date->prefix, "delete");
aos_str_set(&rule_content_date->status, "Enabled");
aos_str_set(&rule_content_date->date, "2022-10-11T00:00:00.000Z");
aos_list_add_tail(&rule_content_date->node, &lifecycle_rule_list);
/* 设置生命周期规则。*/
resp_status = oss_put_bucket_lifecycle(oss_client_options, &bucket, &lifecycle_rule_list, &resp_headers);
if (aos_status_is_ok(resp_status)) {
printf("put bucket lifecycle succeeded\n");
} else {
printf("put bucket lifecycle failed, code:%d, error_code:%s, error_msg:%s, request_id:%s\n",
resp_status->code, resp_status->error_code, resp_status->error_msg, resp_status->req_id);
}
/* 释放内存池,相当于释放了请求过程中各资源分配的内存。*/
aos_pool_destroy(pool);
/* 释放之前分配的全局资源。*/
aos_http_io_deinitialize();
return 0;
}
require 'aliyun/oss'
client = Aliyun::OSS::Client.new(
# Endpoint以华东1(杭州)为例,其它Region请按实际情况填写。
endpoint: 'https://oss-cn-hangzhou.aliyuncs.com',
# 阿里云账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用RAM用户进行API访问或日常运维,请登录RAM控制台创建RAM用户。
access_key_id: 'AccessKeyId', access_key_secret: 'AccessKeySecret')
# 填写Bucket名称。
bucket = client.get_bucket('examplebucket')
# 设置生命周期规则。
bucket.lifecycle = [
LifeCycleRule.new(
:id => 'rule1', :enable => true, :prefix => 'foo/', :expiry => 3),
LifeCycleRule.new(
:id => 'rule2', :enable => false, :prefix => 'bar/', :expiry => Date.new(2016, 1, 1))
]
使用命令行工具ossutil
关于使用ossutil设置生命周期规则的具体操作, 请参见添加或修改生命周期规则。
使用REST API
如果您的程序自定义要求较高,您可以直接发起REST API请求。直接发起REST API请求需要手动编写代码计算签名。更多信息,请参见PutBucketLifecycle。
通过CopyObject接口手动转换Object的存储类型
基于CopyObject转换存储类型规则
- 本地冗余(LRS)
各存储类型之间可任意转换。
- 同城冗余(ZRS)
仅支持标准存储(ZRS)和低频访问(ZRS)之间互相转换。
通过CopyObject转换存储类型操作方式
使用OSS管理控制台
通过控制台修改Object存储类型时,Object大小不能超过1 GB。超过1 GB的Object,建议通过SDK或者命令行工具ossutil。
- 登录OSS管理控制台。
- 单击Bucket列表,然后单击目标Bucket名称。
- 在左侧导航栏,选择 。
- 在文件列表页面,选择目标Object右侧的 。
- 建议您打开保留用户自定义元数据开关,修改存储类型后,Object的自定义元数据信息会被保留。
- 选择您希望修改的存储类型后,单击确定。
使用阿里云SDK
import com.aliyun.oss.ClientException;
import com.aliyun.oss.OSS;
import com.aliyun.oss.OSSClientBuilder;
import com.aliyun.oss.OSSException;
import com.aliyun.oss.model.CopyObjectRequest;
import com.aliyun.oss.model.CopyObjectResult;
import com.aliyun.oss.model.ObjectMetadata;
import com.aliyun.oss.model.StorageClass;
public class Demo {
public static void main(String[] args) throws Exception {
// Endpoint以华东1(杭州)为例,其它Region请按实际情况填写。
String endpoint = "https://oss-cn-hangzhou.aliyuncs.com";
// 阿里云账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用RAM用户进行API访问或日常运维,请登录RAM控制台创建RAM用户。
String accessKeyId = "yourAccessKeyId";
String accessKeySecret = "yourAccessKeySecret";
// 本示例中的Bucket与Object需提前创建好, 且Object类型为标准或低频访问存储类型。
// 填写Bucket名称,例如examplebucket。
String bucketName = "examplebucket";
// 填写不包含Bucket名称在内的Object完整路径,例如exampleobject.txt。
String objectName = "exampleobject.txt";
// 创建OSSClient实例。
OSS ossClient = new OSSClientBuilder().build(endpoint, accessKeyId, accessKeySecret);
try {
// 创建CopyObjectRequest对象。
CopyObjectRequest request = new CopyObjectRequest(bucketName, objectName, bucketName, objectName) ;
// 创建ObjectMetadata对象。
ObjectMetadata objectMetadata = new ObjectMetadata();
// 封装header,此处以设置存储类型为归档类型为例。
objectMetadata.setHeader("x-oss-storage-class", StorageClass.Archive);
request.setNewObjectMetadata(objectMetadata);
// 更改文件存储类型。
CopyObjectResult result = ossClient.copyObject(request);
} catch (OSSException oe) {
System.out.println("Caught an OSSException, which means your request made it to OSS, "
+ "but was rejected with an error response for some reason.");
System.out.println("Error Message:" + oe.getErrorMessage());
System.out.println("Error Code:" + oe.getErrorCode());
System.out.println("Request ID:" + oe.getRequestId());
System.out.println("Host ID:" + oe.getHostId());
} catch (ClientException ce) {
System.out.println("Caught an ClientException, which means the client encountered "
+ "a serious internal problem while trying to communicate with OSS, "
+ "such as not being able to access the network.");
System.out.println("Error Message:" + ce.getMessage());
} finally {
if (ossClient != null) {
ossClient.shutdown();
}
}
}
}
<?php
if (is_file(__DIR__ . '/../autoload.php')) {
require_once __DIR__ . '/../autoload.php';
}
if (is_file(__DIR__ . '/../vendor/autoload.php')) {
require_once __DIR__ . '/../vendor/autoload.php';
}
use OSS\OssClient;
use OSS\Core\OssException;
// 阿里云账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用RAM用户进行API访问或日常运维,请登录RAM控制台创建RAM用户。
$accessKeyId = "<yourAccessKeyId>";
$accessKeySecret = "<yourAccessKeySecret>";
// Endpoint以杭州为例,其它Region请按实际情况填写。
$endpoint = "https://oss-cn-hangzhou.aliyuncs.com";
// 填写Bucket名称。
$bucket= "<yourBucketName>";
// 填写不包含Bucket名称在内的Object的完整路径,例如destfolder/exampleobject.txt。
$object = "<yourObjectName>";
$ossClient = new OssClient($accessKeyId, $accessKeySecret, $endpoint);
try {
// 指定转换后的文件存储类型,例如指定为归档存储类型(Archive)。
$copyOptions = array(
OssClient::OSS_HEADERS => array(
'x-oss-storage-class' => 'Archive',
'x-oss-metadata-directive' => 'REPLACE',
),
);
$ossClient->copyObject($bucket, $object, $bucket, $object, $copyOptions);
} catch (OssException $e) {
printf(__FUNCTION__ . ": FAILED\n");
printf($e->getMessage() . "\n");
return;
}
print(__FUNCTION__ . ": OK" . "\n");
const OSS = require('ali-oss');
const client = new OSS({
// yourregion填写Bucket所在地域。以华东1(杭州)为例,Region填写为oss-cn-hangzhou。
region: 'yourregion',
// 阿里云账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用RAM用户进行API访问或日常运维,请登录RAM控制台创建RAM用户。
accessKeyId: 'yourAccessKeyId',
accessKeySecret: 'yourAccessKeySecret',
// yourbucketname填写存储空间名称。
bucket: 'yourbucketname'
})
const options = {
headers:{'x-oss-storage-class':'Archive'}
}
client.copy('Objectname','Objectname',options).then((res) => {
console.log(res);
}).catch(err => {
console.log(err)
})
# -*- coding: utf-8 -*-
import oss2
import os
# 阿里云账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用RAM用户进行API访问或日常运维,请登录RAM控制台创建RAM用户。
auth = oss2.Auth('yourAccessKeyId', 'yourAccessKeySecret')
# Endpoint以杭州为例,其它Region请按实际情况填写。
# 填写Bucket名称,例如examplebucket。
bucket = oss2.Bucket(auth, 'https://oss-cn-hangzhou.aliyuncs.com', 'examplebucket')
# 填写Object的完整路径,完整路径中不能包含Bucket名称,例如exampledir/exampleobject.txt。
# 需确保该Object的存储类型为标准存储或低频访问类型。
object_name = 'exampledir/exampleobject.txt'
# 通过添加存储类型Header,将Object存储类型转换为归档类型。
headers = {'x-oss-storage-class': oss2.BUCKET_STORAGE_CLASS_ARCHIVE}
# 通过添加存储类型Header,将Object存储类型转换为冷归档类型。
# headers = {'x-oss-storage-class': oss2.BUCKET_STORAGE_CLASS_COLD_ARCHIVE}
# 更改文件存储类型。
bucket.copy_object(bucket.bucket_name, object_name, object_name, headers)
package main
import (
"fmt"
"os"
"github.com/aliyun/aliyun-oss-go-sdk/oss"
)
func main() {
// 创建OSSClient实例。
// yourEndpoint填写Bucket对应的Endpoint,以华东1(杭州)为例,填写为https://oss-cn-hangzhou.aliyuncs.com。其它Region请按实际情况填写。
// 阿里云账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用RAM用户进行API访问或日常运维,请登录RAM控制台创建RAM用户。
client, err := oss.New("yourEndpoint", "yourAccessKeyId", "yourAccessKeySecret")
if err != nil {
fmt.Println("Error:", err)
os.Exit(-1)
}
// yourBucketName填写存储空间名称。
bucketName := "yourBucketName"
// yourObjectName填写不包含Bucket名称在内的Object的完整路径。
objectName := "yourObjectName"
bucket, err := client.Bucket(bucketName)
if err != nil {
fmt.Println("Error:", err)
os.Exit(-1)
}
// 更改文件存储类型,例如修改为归档存储类型。
_, err = bucket.CopyObject(objectName, objectName, oss.ObjectStorageClass(oss.StorageArchive))
if err != nil {
fmt.Println("Error:", err)
os.Exit(-1)
}
}
OSSCopyObjectRequest * copy = [OSSCopyObjectRequest new];
copy.sourceBucketName = @"examplebucket";
copy.sourceobjectKey = @"exampleobject.txt";
copy.bucketName = @"examplebucket";
copy.objectKey = @"exampleobject.txt";
// 将exampleobject.txt的存储类型指定为归档类型Archive。
copy.objectMeta = @{@"x-oss-storage-class" : @"Archive"};
OSSTask * task = [client copyObject:copy];
[task continueWithBlock:^id(OSSTask *task) {
if (!task.error) {
NSLog(@"copy object success!");
} else {
NSLog(@"copy object failed, error: %@" , task.error);
}
return nil;
}];
#include <alibabacloud/oss/OssClient.h>
using namespace AlibabaCloud::OSS;
int main(void)
{
/* 初始化OSS账号信息。*/
/* 阿里云账号AccessKey拥有所有API的访问权限,风险很高。强烈建议您创建并使用RAM用户进行API访问或日常运维,请登录RAM控制台创建RAM用户。*/
std::string AccessKeyId = "yourAccessKeyId";
std::string AccessKeySecret = "yourAccessKeySecret";
/* 填写Bucket所在地域对应的Endpoint。以华东1(杭州)为例,Endpoint填写为https://oss-cn-hangzhou.aliyuncs.com。*/
std::string Endpoint = "https://oss-cn-hangzhou.aliyuncs.com";
/* 填写Bucket名称,例如examplebucket。*/
std::string BucketName = "examplebucket";
/* 填写Object完整路径,完整路径中不能包含Bucket名称,例如exampledir/exampleobject.txt。*/
std::string ObjectName = "exampledir/exampleobject.txt";
/* 初始化网络等资源。*/
InitializeSdk();
ClientConfiguration conf;
OssClient client(Endpoint, AccessKeyId, AccessKeySecret, conf);
/* 设置修改后的文件存储类型,例如将修改后的文件存储类型设置为归档。*/
ObjectMetaData objectMeta;
objectMeta.addHeader("x-oss-storage-class", "Archive");
CopyObjectRequest request(SourceBucketName, SourceBucketName,objectMeta);
request.setCopySource(SourceBucketName, SourceObjectName);
/* 修改为上述指定的文件存储类型。*/
auto outcome = client.CopyObject(request);
if (!outcome.isSuccess()) {
/* 异常处理。*/
std::cout << "CopyObject fail" <<
",code:" << outcome.error().Code() <<
",message:" << outcome.error().Message() <<
",requestId:" << outcome.error().RequestId() << std::endl;
ShutdownSdk();
return -1;
}
/* 释放网络等资源。*/
ShutdownSdk();
return 0;
}
使用命令行工具ossutil
关于使用ossutil转换Object存储类型的具体步骤, 请参见修改文件存储类型。
使用REST API
如果您的程序自定义要求较高,您可以直接发起REST API请求。直接发起REST API请求需要手动编写代码计算签名。更多信息,请参见CopyObject。
注意事项
当Object被转换为低频访问、归档存储和冷归档存储类型后,需注意以下事项:
最小计量空间
对于小于64 KB的Object,会按照64 KB计算空间大小。
最低存储时长
- 通过生命周期自动转换Object存储类型
- 将Object存储类型转换为低频、归档类型时,不会重新计算Object的存储时间。
例如,a.txt作为标准存储类型已在OSS中存储了10天,通过生命周期转换为低频访问类型,则继续存储20天即可满足最低存储时长30天的要求。
- 将Object存储类型转换为冷归档类型时,会重新计算Object的存储时间。
例如,a.txt作为标准存储类型已在OSS中存储了10天,通过生命周期规则转换为冷归档存储类型,需继续存储180天才满足最低存储时长180天的要求。
- 将Object存储类型转换为低频、归档类型时,不会重新计算Object的存储时间。
- 通过CopyObject手动转换Object存储类型
通过CopyObject手动转换Object为任意存储类型时,会重新计算Object的存储时间。
例如,a.txt作为标准存储类型已在OSS中存储了10天,通过CopyObject手动将Object转换为低频访问类型,需继续存储30天才满足最低存储时长30天的要求。
解冻时间
归档存储和冷归档存储类型Object恢复为可读取状态需要一定的解冻时间,如果业务场景需要实时读取Object时,不建议将Object转换成归档存储或冷归档存储类型。
数据取回费用
访问低频访问类型的Object时,会根据实际访问量额外收取数据取回费用;解冻归档存储和冷归档存储类型的Object会额外收取数据解冻费用,此费用与流出流量费用是两个独立计费项。如果Object每月平均访问频率高于1次,Object转换成低频访问、归档存储或冷归档存储类型后的使用成本可能高于标准存储类型。
临时存储费用
冷归档存储类型Object在数据解冻时会生成一份标准存储类型的Object副本用于访问。该Object在解冻时间结束前会以标准存储的存储费率计算临时存储费用。
常见问题
基于最后一次修改时间的生命周期规则是否支持将Object从低频访问类型转换为标准类型?
不支持。您可以通过以下方式将Object从低频访问类型转为标准类型:
- 通过CopyObject的方式
CopyObject接口支持将单个Object从低频访问类型转为标准类型。具体操作,请参见通过CopyObject接口手动转换Object的存储类型。
- 通过ossutil工具
ossutil支持通过set-meta命令添加X-Oss-Storage-Class选项的方式将单个或多个Object从低频访问类型转换为标准类型。具体操作,请参见设置或更新元信息。