次のサンプルコードは、一般的なプログラミング言語でOSS SDKを使用してライフサイクルルールを設定する方法の例を示しています。 他のプログラミング言語でOSS SDKを使用してライフサイクルルールを設定するためのサンプルコードの詳細については、「概要」をご参照ください。
Java
com.aliyun.oss.ClientExceptionをインポートします。com.aliyun.oss.OSSをインポートします。impor t com.aliyun.oss.com mon.auth.*;
com.aliyun.oss.OSSClientBuilderをインポートします。com.aliyun.oss.OSSExceptionをインポートします。impor t com.aliyun.oss.com mon.utils.DateUtil;
com.aliyun.oss.mo del.LifecycleRuleをインポートします。com.aliyun.oss.mo del.SetBucketLifecycleRequestをインポートします。com.aliyun.oss.mo del.StorageClassをインポートします。java.util.ArrayListをインポートします。java.util.HashMapをインポートします。java.util.Listをインポートします。java.util.Mapをインポートします。public classデモ {
public static void main(String[] args) throws Exception {
// この例では、中国 (杭州) リージョンのエンドポイントが使用されます。 実際のエンドポイントを指定します。
String endpoint = " https://oss-cn-hangzhou.aliyuncs.com ";
// 環境変数からアクセス資格情報を取得します。 サンプルコードを実行する前に、OSS_ACCESS_KEY_IDおよびOSS_ACCESS_KEY_SECRET環境変数が設定されていることを確認してください。
EnvironmentVariableCredentialsProvider credentialsProvider = CredentialsProviderFactory.newEnvironmentVariableCredentialsProvider();
// バケットの名前を指定します。 例: examplebucket.
String bucketName = "examplebucket";
// Create an OSSClient instance.
OSS ossClient = new OSSClientBuilder().build(endpoint, credentialsProvider);
try {
// SetBucketLifecycleRequestを使用してリクエストを作成します。
SetBucketLifecycleRequest request = new SetBucketLifecycleRequest(bucketName);
// ライフサイクルルールのIDを指定します。
String ruleId0 = "rule0";
// ライフサイクルルールを一致させるプレフィックスを指定します。
String matchPrefix0 = "A0/";
// ライフサイクルルールを一致させるタグを指定します。
Map<String, String> matchTags0 = new HashMap<String, String>();
// タグのキーと値を指定します。 この例では、キーは所有者に設定され、値は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/";
文字列ruleId4 = "rule4";
文字列matchPrefix4 = "A4/";
文字列ruleId5 = "rule5";
文字列matchPrefix5 = "A5/";
文字列ruleId6 = "rule6";
文字列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日後にIAに変更され、最後に変更されてから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. アーカイブ);
storageTransition.setExpirationDays(30);
storageTransitions.add(storageTransition);
rule.setStorageTransition(storageTransitions);
request.AddLifecycleRule(rule);
// 10月12日2022より前に最後に変更されたオブジェクトのストレージクラスをアーカイブに変更することを指定します。
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. アーカイブ);
storageTransitions.add(storageTransition);
rule.setStorageTransition(storageTransitions);
request.AddLifecycleRule(rule);
// バージョン管理が有効なバケットに対してrule6を設定することを指定します。
rule = new LifecycleRule(ruleId6, matchPrefix6, LifecycleRule.RuleStatus.Enabled);
// オブジェクトが最後に変更されてから365日後に、オブジェクトのストレージクラスをアーカイブに変更することを指定します。
storageTransitions = new ArrayList<LifecycleRule.StorageTransition>();
storageTransition = new LifecycleRule.StorageTransition();
storageTransition.setStorageClass(StorageClass. アーカイブ);
storageTransition.setExpirationDays(365);
storageTransitions.add(storageTransition);
rule.setStorageTransition(storageTransitions);
// 期限切れの削除マーカーを自動的に削除するようにライフサイクルルールを設定します。
rule.setExpiredDeleteMarker(true);
// オブジェクトが最後に変更されてから10日後に、以前のバージョンのオブジェクトのストレージクラスをIAに変更することを指定します。
LifecycleRule.NoncurrentVersionStorageTransition noncurrentVersionStorageTransition=
新しいLifecycleRule.NoncurrentVersionStorageTransition().withNoncurrentDays(10).withStrorageClass(StorageClass.IA);
// オブジェクトが最後に変更されてから20日後に、以前のバージョンのオブジェクトのストレージクラスをアーカイブに変更することを指定します。
LifecycleRule.NoncurrentVersionStorageTransition noncurrentVersionStorageTransition2=
新しいLifecycleRule.NoncurrentVersionStorageTransition().withNoncurrentDays(20).withStrorageClass(StorageClass.Archive);
// オブジェクトが最後に変更されてから30日後に、以前のバージョンのオブジェクトを削除するように指定します。
LifecycleRule.NoncurrentVersionExpiration noncurrentVersionExpiration = new LifecycleRule.NoncurrentVersionExpiration().withNoncurrentDays(30);
リスト <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);
// バケットに設定されているライフサイクルルールを照会します。
リスト <LifecycleRule> listRules = ossClient.getBucketLifecycle(bucketName);
for(LifecycleRuleルール: listRules){
System.out.println("ruleId=" + rules.getId()+ ", matchPrefix=" + rules.getPrefix());
}
} catch (Exception e) {
System.out.println("Caught an OSSException, which means your request made it to OSS, "
+ "しかし、何らかの理由でエラー応答で拒否されました。");
System.out.println("エラーメッセージ:" + oe.getErrorMessage());
System.out.println("エラーコード:" + oe.getErrorCode());
System.out.println("リクエストID:" + oe.getRequestId());
System.out.println("ホストID:" + oe.getHostId());
} catch (ClientException e) {
System.out.println("Caught an ClientException, which means the client encountered "
+ "a serious internal problem while trying to communicate with OSS, "
+ 「ネットワークにアクセスできないなど」;
System.out.println("エラーメッセージ:" + ce.getMessage());
} 最後に{
if (ossClient != null) {
ossClient.shutdown();
}
}
}
}
PHP
<?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';
}
OSS\Credentials\EnvironmentVariableCredentialsProviderを使用します。OSS\OssClientを使用します。OSS\CoreOssExceptionを使用します。OSS\Model\LifecycleConfigを使用します。OSS\Model\LifecycleRuleを使用します。OSS\Model\LifecycleActionを使用します。// 環境変数からアクセス資格情報を取得します。 サンプルコードを実行する前に、OSS_ACCESS_KEY_IDおよびOSS_ACCESS_KEY_SECRET環境変数が設定されていることを確認してください。
$provider = new EnvironmentVariableCredentialsProvider();
// この例では、中国 (杭州) リージョンのエンドポイントが使用されます。 実際のエンドポイントを指定します。
$end point = " https://oss-cn-hangzhou.aliyuncs.com ";
// バケットの名前を指定します。
$bucket= "examplebucket";
// ルールに一致するオブジェクトの名前に含まれるルール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 {
$config=配列 (
"provider" => $provider、
"endpoint" => $end ポイント、
);
$ossClient = new OssClient($config);
$ossClient->putBucketLifecycle($bucket、$lifecycleConfig);
} catch (OssException $e) {
printf(__FUNCTION__ . ": FAILED\n");
printf($e->getMessage()) 。 "\n");
戻ります。}
print(__FUNCTION__) 。 ": OK" 。 "\n");
Node.js
const OSS = require('ali-OSS ')
const client = new OSS({
// バケットが配置されているリージョンを指定します。 たとえば、バケットが中国 (杭州) リージョンにある場合、リージョンをoss-cn-Hangzhouに設定します。
region: 'yourregion' 、
// 環境変数からアクセス資格情報を取得します。 サンプルコードを実行する前に、OSS_ACCESS_KEY_IDおよびOSS_ACCESS_KEY_SECRET環境変数が設定されていることを確認してください。
accessKeyId: process.env.OSS_ACCESS_KEY_ID、
accessKeySecret: process.env.OSS_ACCESS_KEY_SECRET、
// バケットの名前を指定します。
bucket: 'yourbucketname'
});
async関数putBucketLifecycle (ライフサイクル) {
try {
const result = await client.putBucketLifecycle('yourbucketname', [
ライフサイクルの設定 (Set lifecycle)
]);
console.log (結果);
} catch (e) {
console.log(e);
}
}
const lifecycle1 = {
id: 'rule1' 、
ステータス: 'Enabled' 、
プレフィックス: 'foo/'、
有効期限: {
// オブジェクトの現在のバージョンが最後に変更されてから3日後に期限切れになるように指定します。
日: 3
}
}
putBucketLifecycle(lifecycle1)
const lifecycle2 = {
id: 'rule2' 、
ステータス: 'Enabled' 、
プレフィックス: 'foo/'、
有効期限: {
// 指定された日付より前に作成されたオブジェクトの有効期限を指定します。
createdBeforeDate: '2020-02-18T00:00:00.000Z'
},
}
putBucketLifecycle(lifecycle2)
const lifecycle3 = {
id: 'rule3' 、
ステータス: 'Enabled' 、
プレフィックス: 'foo/'、
abortMultipartUpload: {
// 部品が3日で期限切れになるように指定します。
日: 3
},
}
putBucketLifecycle(lifecycle3)
const lifecycle4 = {
id: 'rule4' 、
ステータス: 'Enabled' 、
プレフィックス: 'foo/'、
abortMultipartUpload: {
// 指定した日付より前に作成したパーツの有効期限を指定します。
createdBeforeDate: '2020-02-18T00:00:00.000Z'
},
}
putBucketLifecycle(lifecycle4)
const lifecycle5 = {
id: 'rule5' 、
ステータス: 'Enabled' 、
プレフィックス: 'foo/'、
transition: {
// オブジェクトが最後に変更されてから20日後に、現在のバージョンのオブジェクトのストレージクラスをアーカイブに変更することを指定します。
日: 20,
storageClass: 'アーカイブ'
},
有効期限: {
// オブジェクトの現在のバージョンが最後に変更されてから21日後に期限切れになるように指定します。
日: 21
},
}
putBucketLifecycle(lifecycle5)
const lifecycle6 = {
id: 'rule6' 、
ステータス: 'Enabled' 、
プレフィックス: 'foo/'、
transition: {
// 指定された日付より前に作成されたオブジェクトのストレージクラスをアーカイブに変更することを指定します。
createdBeforeDate: '2023-02-19T00:00:00.000Z' 、
storageClass: 'アーカイブ'
},
有効期限: {
// 指定された日付より前に作成されたオブジェクトを削除するように指定します。
createdBeforeDate: '2023-01-18T00:00:00.000Z'
},
}
putBucketLifecycle(lifecycle6)
const lifecycle7 = {
id: 'rule7' 、
ステータス: 'Enabled' 、
プレフィックス: 'foo/'、
有効期限: {
// 削除マーカーが期限切れになると自動的に削除されるように指定します。
expiredObjectDeleteMarker: true
}
}
putBucketLifecycle(lifecycle7)
const lifecycle8 = {
id: 'rule8' 、
ステータス: 'Enabled' 、
プレフィックス: 'foo/'、
// オブジェクトが最後に変更されてから10日後に、以前のバージョンのオブジェクトのストレージクラスをIAに変更することを指定します。
noncurrentVersionTransition: {
noncurrentDays: '10' 、
storageClass: 「IA」
}
}
putBucketLifecycle(lifecycle8)
const lifecycle9 = {
id: 'rule9' 、
ステータス: 'Enabled' 、
プレフィックス: 'foo/'、
// オブジェクトが最後に変更されてから10日後に、以前のバージョンのオブジェクトのストレージクラスをIAに変更することを指定します。
noncurrentVersionTransition: {
noncurrentDays: '10' 、
storageClass: 「IA」
},
// ルールに一致させるオブジェクトのタグを指定します。
tag: [{
キー: 'key1' 、
値: 'value1'
},
{
キー: 'key2' 、
値: 'value2'
}]
}
putBucketLifecycle(lifecycle9)
Python
# -*-コーディング: utf-8 -*-
oss2のインポート
oss2.credentialsからEnvironmentVariableCredentialsProviderをインポート
datetimeのインポート
oss2.modelsインポートから (LifecycleExpiration, LifecycleRule,
BucketLifecycle、AbortMultipartUpload、
TaggingRule, タグ付け, StorageTransition,
NoncurrentVersionStorageTransition、
NoncurrentVersionExpiration)
# 環境変数からアクセス資格情報を取得します。 サンプルコードを実行する前に、OSS_ACCESS_KEY_IDおよびOSS_ACCESS_KEY_SECRET環境変数が設定されていることを確認してください。
auth = oss2.ProviderAuth(EnvironmentVariableCredentialsProvider())
# バケットが配置されているリージョンのエンドポイントを指定します。 たとえば、バケットが中国 (杭州) リージョンにある場合、エンドポイントを https://oss-cn-hangzhou.aliyuncs.com に設定します。
# バケットの名前を指定します。 例: examplebucket.
bucket = oss2.Bucket(auth, 'https:// oss-cn-hangzhou.aliyuncs.com ', 'examplebucket')
# オブジェクトが最後に変更されてから3日後に期限切れになるように指定します。
rule1 = LifecycleRule('rule1', 'tests/',
status=LifecycleRule.ENABLED,
expiration=LifecycleExpiration(days=3)
# 指定された日付より前に作成されたオブジェクトの有効期限を指定します。
rule2 = LifecycleRule('rule2' 、'tests2/'、
status=LifecycleRule.ENABLED,
expiration=LifecycleExpiration(created_before_date=datetime.date(2023, 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)))
# オブジェクトのストレージクラスが、最後に変更されてから20日後に低頻度アクセス (IA) に変更され、最後に変更されてから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_rule)
# オブジェクトのストレージクラスが最後に変更されてから365日後にアーカイブに変更されるように指定します。
# 上記のルールと比較して、rule6にはオブジェクトを一致させるタグ条件が含まれています。 このルールは、タグ設定がkey1=value1およびkey2=value2であるオブジェクトに対して有効になります。
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は、バージョン管理が有効なバケットに適用されるライフサイクルルールです。
# オブジェクトのストレージクラスが最後に変更されてから365日後にアーカイブに変更されるように指定します。
# 削除マーカーが期限切れになると自動的に削除されることを指定します。
# オブジェクトのストレージクラスが以前のバージョンになってから12日後にIAに変更されるように指定します。
# オブジェクトのストレージクラスが以前のバージョンになってから20日後にアーカイブに変更されるように指定します。
# オブジェクトが以前のバージョンになってから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 (ライフサイクル)
C#
Aliyun.OSSを使用した
Aliyun.OSS.Common; を使用
// バケットが配置されているリージョンのエンドポイントを指定します。 たとえば、バケットが中国 (杭州) リージョンにある場合、エンドポイントを https://oss-cn-hangzhou.aliyuncs.com に設定します。
var endpoint = " https://oss-cn-hangzhou.aliyuncs.com ";
// 環境変数からアクセス資格情報を取得します。 サンプルコードを実行する前に、OSS_ACCESS_KEY_IDおよびOSS_ACCESS_KEY_SECRET環境変数が設定されていることを確認してください。
var accessKeyId = Environment.GetEnvironmentVariable("OSS_ACCESS_KEY_ID");
var accessKeySecret = Environment.GetEnvironmentVariable("OSS_ACCESS_KEY_SECRET");
// バケット名を指定します。 例: examplebucket.
var bucketName = "examplebucket";
// OSSClientインスタンスを作成します。
var client = new OssClient (エンドポイント、accessKeyId、accessKeySecret);
トライ
{
var setBucketLifecycleRequest = new SetBucketLifecycleRequest(bucketName);
// 最初のライフサイクルルールを作成します。
LifecycleRule lcr1 = new LifecycleRule()
{
ID = "delete obsoleted files",
Prefix = "obsoleted/",
Status = RuleStatus.Enabled,
ExpriationDays = 3、
タグ=新しいタグ [1]
};
// ルールのタグを指定します。
var tag1=新しいタグ
{
キー="プロジェクト" 、
値="projectone"
};
lcr1.タグ [0] = tag1;
// Create the second lifecycle rule.
LifecycleRule lcr2 = new LifecycleRule()
{
ID = "delete temporary files",
Prefix = "temporary/",
Status = RuleStatus.Enabled,
ExpriationDays = 20、
タグ=新しいタグ [1]
};
// ルールのタグを指定します。
var tag2=新しいタグ
{
キー="ユーザー" 、
値="jsmith"
};
lcr2.タグ [0] = tag2;
// 最後に変更してから30日後に期限切れになるように指定します。
lcr2.AbortMultipartUpload = new LifecycleRule.LifeCycleExpiration()
{
日数=30
};
LifecycleRule lcr3 = new LifecycleRule();
lcr3.ID = "のみNoncurrentVersionTransition";
lcr3.Prefix = "test1";
lcr3.Status = RuleStatus.Enabled;
lcr3.NoncurrentVersionTransitions = new LifecycleRule.LifeCycleNoncurrentVersionTransition[2]
{
// 以前のバージョンのオブジェクトのストレージクラスが、最後に変更されてから90日後にIAに変換されるように指定します。
新しいLifecycleRule。LifeCycleNoncurrentVersionTransition(){
StorageClass = StorageClass.IA、
NoncurrentDays = 90
},
// 以前のバージョンのオブジェクトのストレージクラスが、最後に変更されてから180日後にアーカイブに変換されるように指定します。
新しいLifecycleRule。LifeCycleNoncurrentVersionTransition(){
StorageClass = StorageClass. アーカイブ、
NoncurrentDays = 180
}
};
setBucketLifecycleRequest.AddLifecycleRule(lcr1);
setBucketLifecycleRequest.AddLifecycleRule(lcr2);
setBucketLifecycleRequest.AddLifecycleRule(lcr3);
// Configure lifecycle rules.
client.SetBucketLifecycle(setBucketLifecycleRequest);
Console.WriteLine("Set bucket:{0} Lifecycle successful", bucketName);
}
キャッチ (OssException ex)
{
Console.WriteLine("Failed with error code: {0}; エラー情報: {1} 。 \nRequestID:{2}\tHostID:{3}"、
ex.ErrorCode, ex.Message, ex.RequestId, ex.HostId);
}
キャッチ (例外ex)
{
Console.WriteLine("Failed with error info: {0}" 、メッセージなど);
}
Android-Java
PutBucketLifecycleRequest request = new PutBucketLifecycleRequest();
request.setBucketName("examplebucket");
BucketLifecycleRule rule1=新しいBucketLifecycleRule();
// ルールに一致するオブジェクトの名前に含まれるルールIDとプレフィックスを指定します。
rule1.setIdentifier("1");
rule1.setPrefix("A");
// ライフサイクルルールを実行するかどうかを指定します。 このパラメーターがtrueに設定されている場合、OSSはこのルールを定期的に実行します。 このパラメーターがfalseに設定されている場合、OSSはこのルールを無視します。
rule1.setStatus(true);
// オブジェクトが最後に変更されてから200日後に期限切れになるように指定します。
rule1.setDays("200");
// オブジェクトのストレージクラスが最後に変更されてから30日後にアーカイブに変換されるように指定します。
rule1.setArchiveDays("30");
// アップロードに失敗してから3日後に期限切れになるように指定します。
rule1.setMultipartDays("3");
// オブジェクトのストレージクラスが最後に変更されてから15日後に低頻度アクセス (IA) に変換されるように指定します。
rule1.setIADays("15");
BucketLifecycleRule rule2=新しい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リクエスト, PutBucketLifecycleResult結果) {
OSSLog.logInfo("code::" + result.getStatusCode());
}
@Override
public void onFailure(PutBucketLifecycleRequest request, ClientException clientException, ServiceException serviceException) {
OSSLog.logError("error: " + serviceException.getRawMessage());
}
});
task.waitUntilFinished();
Go
パッケージメイン
import (import (import)
"fmt"
「github.com/aliyun/aliyun-oss-go-sdk/oss」
"os"
)
func main() {
// 環境変数からアクセス資格情報を取得します。 サンプルコードを実行する前に、OSS_ACCESS_KEY_IDおよびOSS_ACCESS_KEY_SECRET環境変数が設定されていることを確認してください。
provider, err := oss.NewEnvironmentVariableCredentialsProvider()
if err! =nil {
fmt.Println("Error:", err)
os.Exit(-1)
}
// OSSClientインスタンスを作成します。
// バケットが配置されているリージョンのエンドポイントを指定します。 たとえば、バケットが中国 (杭州) リージョンにある場合、エンドポイントを https://oss-cn-hangzhou.aliyuncs.com に設定します。 実際のエンドポイントを指定します。
client, err := oss.New("yourEndpoint", ", " ", ", oss.SetCredentialsProvider(&provider))
if err! =nil {
fmt.Println("Error:", err)
os.Exit(-1)
}
// バケットの名前を指定します。
bucketName := "examplebucket"
// ライフサイクルルールを設定し、IDをrule1に設定します。 バケット内のfooプレフィックスを含む名前のオブジェクトは、オブジェクトが最後に変更されてから3日後に期限切れになるように指定します。
rule1 := oss.BuildLifecycleRuleByDays("rule1", "foo/", true, 3)
// バージョン管理が有効になっているバケット内のオブジェクトが削除マーカーであり、他のバージョンがない場合、削除マーカーは削除されます。
deleteMark := true
expiration := oss.LifecycleExpiration {
ExpiredObjectDeleteMarker: &deleteMark、}
// 以前のバージョンのオブジェクトが最後に変更されてから30日後に削除されるように指定します。
versionExpiration := oss.LifecycleVersionExpiration {
NoncurrentDays: 30、}
// 以前のバージョンのオブジェクトのストレージクラスを、オブジェクトが最後に変更されてから10日後に低頻度アクセス (IA) に変換するように指定します。
versionTransition := oss.LifecycleVersionTransition {
NoncurrentDays: 10、StorageClass: "IA" 、}
// ライフサイクルルールを設定し、IDをrule2に設定します。
rule2 := oss.LifecycleRule {
ID: "rule2" 、プレフィックス: "yourObjectPrefix" 、ステータス: "Enabled" 、有効期限:&有効期限、NonVersionExpiration: &versionExpiration、NonVersionTransitions: []oss.LifecycleVersionTransition {
versionTransition,
},
}
// ライフサイクルルールを設定し、IDをrule3に設定します。 このルールは、キーがtag1で値がvalue1のタグを持つオブジェクトに対して有効になります。 これらのオブジェクトは、オブジェクトが最後に変更されてから3日後に期限切れになります。
rule3 := oss.LifecycleRule {
ID: "rule3" 、プレフィックス: "",
ステータス: "Enabled" 、タグ: []oss.Tag {
oss. タグ {
キー: "tag1" 、値: "value1" 、},
},
有効期限: &oss。LifecycleExpiration{Days: 3} 、}
// ライフサイクルルールを設定します。
rules := []oss.LifecycleRule{rule1, rule2, rule3}
err = client.SetBucketLifecycle(bucketName, rules)
if err! =nil {
fmt.Println("Error:", err)
os.Exit(-1)
}
}
C++
#include <alibabacloud/oss/OssClient.h>
名前空間listaCloud::OSSを使用します。int main(void)
{
/* OSSへのアクセスに使用されるアカウントに関する情報を初期化します。 */
/* バケットが配置されているリージョンのエンドポイントを指定します。 たとえば、バケットが中国 (杭州) リージョンにある場合、エンドポイントを https://oss-cn-hangzhou.aliyuncs.com に設定します。 */
std::string Endpoint = "yourEndpoint";
/* バケットの名前を指定します。 例: examplebucket. */
std::string BucketName = "examplebucket";
/* ネットワークリソースなどのリソースを初期化します。 */
InitializeSdk();
ClientConfiguration conf;
/* 環境変数からアクセス資格情報を取得します。 サンプルコードを実行する前に、OSS_ACCESS_KEY_IDおよびOSS_ACCESS_KEY_SECRET環境変数が設定されていることを確認してください。 */
auto credentialsProvider = std::make_shared<EnvironmentVariableCredentialsProvider>();
OssClientクライアント (Endpoint, credentialsProvider, conf);
SetBucketLifecycleRequestリクエスト (BucketName);
std::string date("2022-10-12T00:00:00.000Z");
/* ルールに一致させるオブジェクトのタグを指定します。 */
タグ付け;
tagging.addTag (タグ ("key1", "value1"));
tagging.addTag (タグ ("key2", "value2"));
/* ライフサイクルルールを指定します。 */
auto rule1 = LifecycleRule();
rule1.setID("rule1");
rule1.setPrefix("test1/");
rule1.setStatus(RuleStatus::Enabled);
rule1.setExpiration(3);
rule1.setTags(tagging.Tags());
/* 有効期限を指定します。 */
auto rule2 = LifecycleRule();
rule2.setID("rule2");
rule2.setPrefix("test2/");
rule2.setStatus(RuleStatus:: 無効);
rule2.setExpiration (日付);
/* バケットのバージョン管理が有効になっている場合、バケットのrule3が有効になっていることを指定します。 */
auto rule3 = LifecycleRule();
rule3.setID("rule3");
rule3.setPrefix("test3/");
rule3.setStatus(RuleStatus::Disabled);
/* オブジェクトが最後に変更されてから365日後に、オブジェクトのストレージクラスをアーカイブに変更するように指定します。 */
auto transition = LifeCycleTransition();
transition.Expiration().setDays(365);
transition.setStorageClass(StorageClass:: アーカイブ);
rule3.addTransition(transition);
/* 期限切れの削除マーカーが自動的に削除されるように指定します。 */
rule3.setExpiredObjectDeleteMarker(true);
/* オブジェクトが最後に変更されてから10日後に、以前のバージョンのオブジェクトのストレージクラスをIAに変更するように指定します。 */
auto transition1 = LifeCycleTransition();
transition1.Expiration().setDays(10);
transition1.setStorageClass(StorageClass::IA);
/* オブジェクトが最後に変更されてから20日後に、以前のバージョンのオブジェクトのストレージクラスをアーカイブに変更するように指定します。 */
auto transition2 = LifeCycleTransition();
transition2.Expiration().setDays(20);
transition2.setStorageClass(StorageClass:: アーカイブ);
/* バージョンが更新されてから30日後に以前のバージョンを削除するように指定します。 */
自動有効期限=LifeCycleExpiration(30);
rule3.setNoncurrentVersionExpiration (有効期限);
LifeCycleTransitionList noncurrentVersionStorageTransitions{transition1, transition2};
rule3.setNoncurrentVersionTransitionList(noncurrentVersionStorageTransitions);
/* ライフサイクルルールを設定します。 */
LifecycleRuleListリスト {rule1, rule2, rule3};
request.setLifecycleRules (リスト);
auto outcome = client.SetBucketLifecycle (リクエスト);
if (!outcome.isSuccess()) {
/* 例外を処理します。 */
std::cout << "SetBucketLifecycle fail" <<
",code:" << outcome.error().Code() <<
",message:" << outcome.error().Message() <<
",requestId:" << outcome.error().RequestId() << std::endl;
return -1;
}
/* ネットワークリソースなどのリソースを解放します。 */
ShutdownSdk();
0を返します。}
C
#include "oss_api.h"
# 「aos_http_io.h」を含める
/* バケットが配置されているリージョンのエンドポイントを指定します。 たとえば、バケットが中国 (杭州) リージョンにある場合、エンドポイントを https://oss-cn-hangzhou.aliyuncs.com に設定します。 * /
const char * endpoint = "yourEndpoint";
/* バケットの名前を指定します。 例: examplebucket. * /
const char * bucket_name = "examplebucket";
void init_options(oss_request_options_t * オプション)
{
options->config = oss_config_create(options->pool);
/* char * 文字列を使用してaos_string_tを初期化します。 */
aos_str_set(&options->config->endpoint, endpoint);
/* 環境変数からアクセス資格情報を取得します。 サンプルコードを実行する前に、OSS_ACCESS_KEY_IDおよびOSS_ACCESS_KEY_SECRET環境変数が設定されていることを確認してください。 */
aos_str_set(&options->config->access_key_id, getenv("OSS_ACCESS_KEY_ID"));
aos_str_set(&options->config->access_key_secret, getenv("OSS_ACCESS_KEY_SECRET"));
/* CNAMEを使用してOSSにアクセスするかどうかを指定します。 値0は、CNAMEが使用されないことを示す。 */
options->config->is_cname = 0;
/* タイムアウト時間などのネットワークパラメーターを指定します。 */
options->ctl = aos_http_controller_create(options->pool, 0);
}
int main(int argc, char * argv[])
{
/* main() でaos_http_io_initializeメソッドを呼び出して、ネットワークリソースやメモリリソースなどのグローバルリソースを初期化します。 */
if (aos_http_io_initialize(NULL, 0))! =AOSE_OK) {
exit(1);
}
/* メモリを管理するためのメモリプールを作成します。 aos_pool_tはapr_pool_tと同じです。 メモリプールの作成に使用されるコードは、APRライブラリに含まれています。 */
aos_pool_t *pool;
/* メモリプールを作成します。 2番目のパラメーターの値はNULLです。 この値は、プールが他のメモリプールを継承しないことを示します。 */
aos_pool_create(&pool, NULL);
/* Create and initialize options. このパラメーターには、エンドポイント、access_key_id、access_key_secret、is_cname、curlなどのグローバル構成情報が含まれます。 */
oss_request_options_t *oss_client_options;
/* メモリプール内のメモリリソースをオプションに割り当てます。 */
oss_client_options = oss_request_options_create(pool);
/* 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-> プレフィックス、"dir1");
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-> プレフィックス、"dir2");
aos_str_set(&rule_content_date->status, "Enabled");
/* 有効期限はUTCで表示されます。
aos_str_set(&rule_content_date->date, "2023-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();
0を返します。}
Ruby
'aliyun/oss 'が必要です
client = Aliyun::OSS::Client.new (
# この例では、中国 (杭州) リージョンのエンドポイントが使用されます。 実際のエンドポイントを指定します。
エンドポイント: 'https:// oss-cn-hangzhou.aliyuncs.com '、
# 環境変数からアクセス資格情報を取得します。 サンプルコードを実行する前に、OSS_ACCESS_KEY_IDおよびOSS_ACCESS_KEY_SECRET環境変数が設定されていることを確認してください。
access_key_id: ENV['OSS_ACCESS_KEY_ID '] 、
access_key_secret: ENV['OSS_ACCESS_KEY_SECRET ']
)
# バケット名を指定します。
bucket = client.get_bucket('examplebucket')
# ライフサイクルルールを設定します。
bucket.lifecycle = [
Aliyun::OSS::LifeCycleRule.new (
: id => 'rule1' 、: enable => true、: prefix => 'foo/'、: expiry => 3) 、
Aliyun::OSS::LifeCycleRule.new (
: id => 'rule2', :enable => false, :prefix => 'bar/', :expiry => Date.new(2016, 1, 1))
]
