Object Storage Service:最終更新時刻に基づくライフサイクルルール

// この例では、中国 (杭州) リージョンのエンドポイントを使用しています。実際のエンドポイントを指定してください。
String endpoint = "https://oss-cn-hangzhou.aliyuncs.com";
// 環境変数からアクセス認証情報を取得します。サンプルコードを実行する前に、OSS_ACCESS_KEY_ID および OSS_ACCESS_KEY_SECRET 環境変数が設定されていることを確認してください。
EnvironmentVariableCredentialsProvider credentialsProvider = CredentialsProviderFactory.newEnvironmentVariableCredentialsProvider();
// バケット名を指定します。例: examplebucket。
String bucketName = "examplebucket";
// バケットが配置されているリージョンを指定します。たとえば、バケットが中国 (杭州) リージョンにある場合、リージョンを cn-hangzhou に設定します。
String region = "cn-hangzhou";

// OSSClient インスタンスを作成します。
// OSSClient の使用が完了したら、shutdown メソッドを呼び出してリソースを解放します。
ClientBuilderConfiguration clientBuilderConfiguration = new ClientBuilderConfiguration();
clientBuilderConfiguration.setSignatureVersion(SignVersion.V4);        
OSS ossClient = OSSClientBuilder.create()
.endpoint(endpoint)
.credentialsProvider(credentialsProvider)
.clientConfiguration(clientBuilderConfiguration)
.region(region)               
.build();

try {
    // 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 日後に 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.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 がバージョン管理が有効なバケット用に設定されていることを指定します。
    rule = new LifecycleRule(ruleId6, matchPrefix6, LifecycleRule.RuleStatus.Enabled);
    // オブジェクトのストレージクラスが最終更新時刻から 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);
    // オブジェクトの以前のバージョンのストレージクラスが最終更新時刻から 10 日後に IA に変更されるように指定します。
    LifecycleRule.NoncurrentVersionStorageTransition noncurrentVersionStorageTransition =
            new LifecycleRule.NoncurrentVersionStorageTransition().withNoncurrentDays(10).withStrorageClass(StorageClass.IA);
    // オブジェクトの以前のバージョンのストレージクラスが最終更新時刻から 20 日後にアーカイブに変更されるように指定します。
    LifecycleRule.NoncurrentVersionStorageTransition noncurrentVersionStorageTransition2 =
            new LifecycleRule.NoncurrentVersionStorageTransition().withNoncurrentDays(20).withStrorageClass(StorageClass.Archive);
    // オブジェクトの以前のバージョンが最終更新時刻から 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 (OSSException oe) {
    System.out.println("OSSException が発生しました。これは、リクエストが 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 ce) {
    System.out.println("ClientException が発生しました。これは、クライアントが OSS との通信中に深刻な内部問題 (ネットワークにアクセスできないなど) に遭遇したことを意味します。");
    System.out.println("エラーメッセージ:" + ce.getMessage());
} finally {
    if (ossClient != null) {
        ossClient.shutdown();
    }
}

<?php

// 依存関係をロードするための autoload ファイルをインクルードします。
require_once __DIR__ . '/../vendor/autoload.php';

use AlibabaCloud\Oss\V2 as Oss;
use AlibabaCloud\Oss\V2\Models\LifecycleConfiguration;

// コマンドラインパラメーターを記述します。
$optsdesc = [
    "region" => ['help' => 'バケットが配置されているリージョン', 'required' => True], // (必須) バケットが配置されているリージョンを指定します。
    "endpoint" => ['help' => '他のサービスが OSS にアクセスするために使用できるドメイン名', 'required' => False], // (オプション) OSS エンドポイントを指定します。
    "bucket" => ['help' => 'バケット名', 'required' => True], // (必須) バケット名を指定します。
];

// コマンドラインパラメーターを解析するためのロングオプションリストを生成します。
$longopts = \array_map(function ($key) {
    return "$key:"; // 各パラメーターの末尾にコロン (:) を追加して、値が必要であることを示します。
}, array_keys($optsdesc));

// コマンドラインパラメーターを解析します。
$options = getopt("", $longopts); 

// 必須パラメーターが不足していないかを確認します。
foreach ($optsdesc as $key => $value) {
    if ($value['required'] === True && empty($options[$key])) {
        $help = $value['help'];
        echo "エラー: 次の引数が必要です: --$key, $help"; // 必須だが不足しているパラメーターを表示します。
        exit(1); 
    }
}

// コマンドラインパラメーターの値を取得し、変数に代入します。
$region = $options["region"]; // バケットが配置されているリージョン。
$bucket = $options["bucket"]; // バケット名。

// 環境変数から AccessKey ID および AccessKey Secret をロードします。
$credentialsProvider = new Oss\Credentials\EnvironmentVariableCredentialsProvider();

// SDK のデフォルト設定を使用します。
$cfg = Oss\Config::loadDefault();

// 認証情報プロバイダーを指定します。
$cfg->setCredentialsProvider($credentialsProvider);

// リージョンを指定します。
$cfg->setRegion($region);

// エンドポイントが提供されている場合、エンドポイントを指定します。
if (isset($options["endpoint"])) {
    $cfg->setEndpoint($options["endpoint"]);
}

// OSS クライアントインスタンスを作成します。
$client = new Oss\Client($cfg);

// 最終更新時刻から 30 日後に "log/" で始まる名前のオブジェクトを IA に移行するライフサイクルルールを定義します。
$lifecycleRule = new Oss\Models\LifecycleRule(
    prefix: 'log/', // オブジェクト名のプレフィックス。
    transitions: array(
        new Oss\Models\LifecycleRuleTransition(
            days: 30, // 日数を指定します。
            storageClass: 'IA' // IA に変更します。
        )
    ),
    id: 'rule', // ルール ID。
    status: 'Enabled' // ルールを有効にします。
);

// ライフサイクル構成を作成し、ライフサイクルルールを構成に追加します。
$lifecycleConfiguration = new LifecycleConfiguration(
    rules: array($lifecycleRule)
);

// ライフサイクル構成を設定するリクエストを作成し、ライフサイクル構成を渡します。
$request = new Oss\Models\PutBucketLifecycleRequest(
    bucket: $bucket,
    lifecycleConfiguration: $lifecycleConfiguration
);

// putBucketLifecycle メソッドを呼び出して、ライフサイクルルールを設定します。
$result = $client->putBucketLifecycle($request);

// 結果を表示します。
printf(
    'ステータスコード:' . $result->statusCode . PHP_EOL . // HTTP レスポンスステータスコード。
    'リクエスト ID:' . $result->requestId . PHP_EOL // リクエスト ID。
);

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,
  authorizationV4: true,
  // バケット名を指定します。
  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: {
    // オブジェクトの現在のバージョンが最終更新時刻から 3 日後に有効期限切れになるように指定します。
    days: 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: {
    // フラグメントが 3 日後に有効期限切れになるように指定します。
    days: 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: {
    // オブジェクトの現在のバージョンのストレージクラスが最終更新時刻から 20 日後にアーカイブに変更されるように指定します。
    days: 20,
    storageClass: 'Archive'
  },
  expiration: {
    // オブジェクトの現在のバージョンが最終更新時刻から 21 日後に有効期限切れになるように指定します。
    days: 21 
  },
}
putBucketLifecycle(lifecycle5)

const lifecycle6 = {
  id: 'rule6',
  status: 'Enabled',
  prefix: 'foo/', 
  transition: {
    // 指定された日付より前に作成されたオブジェクトのストレージクラスがアーカイブに変更されるように指定します。
    createdBeforeDate: '2023-02-19T00:00:00.000Z', 
    storageClass: 'Archive'
  },
  expiration: {
    // 指定された日付より前に作成されたオブジェクトが削除されるように指定します。
    createdBeforeDate: '2023-01-18T00:00:00.000Z' 
  },
}
putBucketLifecycle(lifecycle6)

const lifecycle7 = {
  id: 'rule7',
  status: 'Enabled',
  prefix: 'foo/', 
  expiration: {
    // 有効期限切れの削除マーカーが自動的に削除されるように指定します。
    expiredObjectDeleteMarker: true 
  }
}
putBucketLifecycle(lifecycle7)

const lifecycle8 = {
  id: 'rule8',
  status: 'Enabled',
  prefix: 'foo/', 
  // オブジェクトの以前のバージョンのストレージクラスが最終更新時刻から 10 日後に IA に変更されるように指定します。
  noncurrentVersionTransition: {
    noncurrentDays: '10',
    storageClass: 'IA'
  }
}
putBucketLifecycle(lifecycle8)

const lifecycle9 = {
  id: 'rule9',
  status: 'Enabled',
  prefix: 'foo/', 
  // オブジェクトの以前のバージョンのストレージクラスが最終更新時刻から 10 日後に IA に変更されるように指定します。
  noncurrentVersionTransition: {
    noncurrentDays: '10',
    storageClass: 'IA'
  },
  // ルールに一致させるオブジェクトのタグを指定します。
  tag: [{
    key: 'key1',
    value: 'value1'
  },
   {
     key: 'key2',
     value: 'value2'
   }]
}
putBucketLifecycle(lifecycle9)

import argparse
import alibabacloud_oss_v2 as oss

# ユーザーが入力したパラメーターを受け取るためのコマンドライン引数パーサーを作成します。
parser = argparse.ArgumentParser(description="put bucket lifecycle sample")

# --region コマンドライン引数を追加します。これはバケットが配置されているリージョンを指定します。この引数は必須です。
parser.add_argument('--region', help='バケットが配置されているリージョン。', required=True)

# --bucket コマンドライン引数を追加します。これはバケット名を指定します。この引数は必須です。
parser.add_argument('--bucket', help='バケット名。', required=True)

# --endpoint コマンドライン引数を追加します。これは他のサービスが OSS にアクセスするために使用できるドメイン名を指定します。この引数はオプションです。
parser.add_argument('--endpoint', help='他のサービスが OSS にアクセスするために使用できるドメイン名')

def main():
  # コマンドライン引数を解析します。
  args = parser.parse_args()

  # 環境変数から認証情報 (AccessKey ID および AccessKey Secret) をロードします。
  credentials_provider = oss.credentials.EnvironmentVariableCredentialsProvider()

  # SDK のデフォルト設定をロードします。
  cfg = oss.config.load_default()

  # 認証情報プロバイダーを設定します。
  cfg.credentials_provider = credentials_provider

  # バケットが配置されているリージョンを設定します。
  cfg.region = args.region

  # ユーザーがカスタムエンドポイントを提供した場合、設定にそれを設定します。
  if args.endpoint is not None:
    cfg.endpoint = args.endpoint

    # 設定オブジェクトを使用して OSS クライアントを初期化します。
  client = oss.Client(cfg)

  result = client.put_bucket_lifecycle(oss.PutBucketLifecycleRequest(
    bucket=args.bucket,
    lifecycle_configuration=oss.LifecycleConfiguration(
      rules=[oss.LifecycleRule(
        # ライフサイクルルール rule1 を指定します。このルールでは、プレフィックス foo/ およびタグ k1:v1 を持つオブジェクトが、最終更新時刻から 30 日後に低頻度アクセス (IA) ストレージクラスに変換されます。
        id='rule1',
        status='Enabled',
        prefix='foo/',
        transitions=[oss.LifecycleRuleTransition(
          days=30,
          storage_class=oss.StorageClassType.IA,
          is_access_time=False, # false に設定すると、ポリシーが最終更新時刻に基づいていることを示します。
        )],
        tags=[oss.Tag(
          key='k1',
          value='v1',
        )],
      ), oss.LifecycleRule(
        # ライフサイクルルール rule2 を指定します。このルールでは、プレフィックス dir/ を持つオブジェクトについて、バージョン管理が有効なバケット内で削除マーカーのみを持つ場合、削除マーカーが自動的に削除されます。非現行バージョンのオブジェクトは 30 日後に有効期限切れとなり削除され、10 日後に IA ストレージクラスに変換されます。
        id='rule2',
        status='Enabled',
        prefix='dir/',
        expiration=oss.LifecycleRuleExpiration(
          expired_object_delete_marker=True
        ),
        noncurrent_version_expiration=oss.NoncurrentVersionExpiration(
          noncurrent_days=30,
        ),
        noncurrent_version_transitions=[oss.NoncurrentVersionTransition(
          noncurrent_days=10,
          storage_class=oss.StorageClassType.IA,
          is_access_time=False,
        )],
      )]
    ),
  ))

  # 操作のステータスコードおよびリクエスト ID を出力します。
  print(f'ステータスコード: {result.status_code}, '  # HTTP ステータスコード。リクエストが成功したかどうかを示します。
        f'リクエスト ID: {result.request_id}')    # リクエストログの追跡およびデバッグに使用されるリクエスト ID。


if __name__ == "__main__":
  # メイン関数を呼び出してロジックを実行するプログラムのエントリーポイント。
  main()

using Aliyun.OSS;
using 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";
// バケットが配置されているリージョンを指定します。たとえば、バケットが中国 (杭州) リージョンにある場合、リージョンを cn-hangzhou に設定します。
const string region = "cn-hangzhou";

// ClientConfiguration インスタンスを作成し、要件に基づいてデフォルトパラメーターを変更します。
var conf = new ClientConfiguration();

// 署名アルゴリズム V4 を使用します。
conf.SignatureVersion = SignatureVersion.V4;

// OSSClient インスタンスを作成します。
var client = new OssClient(endpoint, accessKeyId, accessKeySecret, conf);
client.SetRegion(region);
try
{
    var setBucketLifecycleRequest = new SetBucketLifecycleRequest(bucketName);
    // 最初のライフサイクルルールを作成します。
    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]
    {
        // オブジェクトの以前のバージョンのストレージクラスが最終更新時刻から 90 日後に IA に変換されるように指定します。
        new LifecycleRule.LifeCycleNoncurrentVersionTransition(){
            StorageClass = StorageClass.IA,
            NoncurrentDays = 90
        },
        // オブジェクトの以前のバージョンのストレージクラスが最終更新時刻から 180 日後にアーカイブに変換されるように指定します。
        new LifecycleRule.LifeCycleNoncurrentVersionTransition(){
            StorageClass = StorageClass.Archive,
            NoncurrentDays = 180
        }
    };
    setBucketLifecycleRequest.AddLifecycleRule(lcr1);
    setBucketLifecycleRequest.AddLifecycleRule(lcr2);
    setBucketLifecycleRequest.AddLifecycleRule(lcr3);

    // ライフサイクルルールを設定します。
    client.SetBucketLifecycle(setBucketLifecycleRequest);
    Console.WriteLine("バケット:{0} のライフサイクル設定に成功しました", bucketName);
}
catch (OssException ex)
{
    Console.WriteLine("エラーコード: {0} で失敗しました。エラー情報: {1}。\nリクエスト ID:{2}\tホスト ID:{3}",
        ex.ErrorCode, ex.Message, ex.RequestId, ex.HostId);
}
catch (Exception ex)
{
    Console.WriteLine("エラー情報: {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 日後にアーカイブストレージクラスに移行します。
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();

#include <alibabacloud/oss/OssClient.h>
using namespace AlibabaCloud::OSS;

int main(void)
{
    /* OSS アカウント情報を初期化します。 */
    
    /* yourEndpoint をバケットが配置されているリージョンのエンドポイントに設定します。たとえば、バケットが中国 (杭州) リージョンにある場合、エンドポイントを https://oss-cn-hangzhou.aliyuncs.com に設定します。 */
    std::string Endpoint = "yourEndpoint";
    /* yourRegion をバケットが配置されているリージョンに設定します。たとえば、バケットが中国 (杭州) リージョンにある場合、リージョンを cn-hangzhou に設定します。 */
    std::string Region = "yourRegion";
    /* バケット名を指定します。例: examplebucket。 */
    std::string BucketName = "examplebucket";

    /* ネットワークリソースを初期化します。 */
    InitializeSdk();

    ClientConfiguration conf;
    conf.signatureVersion = SignatureVersionType::V4;
    /* 環境変数からアクセス認証情報を取得します。このコードを実行する前に、OSS_ACCESS_KEY_ID および OSS_ACCESS_KEY_SECRET 環境変数が設定されていることを確認してください。 */
    auto credentialsProvider = std::make_shared<EnvironmentVariableCredentialsProvider>();
    OssClient client(Endpoint, credentialsProvider, conf);
    client.SetRegion(Region);

    SetBucketLifecycleRequest request(BucketName);
    std::string date("2022-10-12T00:00:00.000Z");

    /* タグを設定します。 */
    Tagging tagging;
    tagging.addTag(Tag("key1", "value1"));
    tagging.addTag(Tag("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::Disabled);
    rule2.setExpiration(date);

    /* 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::Archive);
    rule3.addTransition(transition);

    /* 有効期限切れの削除マーカーを自動的に削除します。 */
    rule3.setExpiredObjectDeleteMarker(true);

    /* オブジェクトの非現行バージョンを非現行バージョンとなってから 10 日後に低頻度アクセスストレージクラスに移行します。 */
    auto transition1 = LifeCycleTransition();  
    transition1.Expiration().setDays(10);
    transition1.setStorageClass(StorageClass::IA);

    /* オブジェクトの非現行バージョンを非現行バージョンとなってから 20 日後にアーカイブストレージクラスに移行します。 */
    auto transition2 = LifeCycleTransition();  
    transition2.Expiration().setDays(20);
    transition2.setStorageClass(StorageClass::Archive);

    /* オブジェクトを非現行バージョンとなってから 30 日後に削除します。 */
    auto expiration  = LifeCycleExpiration(30);
    rule3.setNoncurrentVersionExpiration(expiration);

    LifeCycleTransitionList noncurrentVersionStorageTransitions{transition1, transition2};
    rule3.setNoncurrentVersionTransitionList(noncurrentVersionStorageTransitions);

    /* ライフサイクルルールを設定します。 */
    LifecycleRuleList list{rule1, rule2, rule3};
    request.setLifecycleRules(list);
    auto outcome = client.SetBucketLifecycle(request);

    if (!outcome.isSuccess()) {
        /* 例外を処理します。 */
        std::cout << "SetBucketLifecycle 失敗" <<
        ",コード:" << outcome.error().Code() <<
        ",メッセージ:" << outcome.error().Message() <<
        ",リクエスト ID:" << outcome.error().RequestId() << std::endl;
        return -1;
    }

    /* ネットワークリソースを解放します。 */
    ShutdownSdk();
    return 0;
}

#include "oss_api.h"
#include "aos_http_io.h"
/* yourEndpoint をバケットが配置されているリージョンのエンドポイントに置き換えます。たとえば、中国 (杭州) リージョンの場合、エンドポイントは https://oss-cn-hangzhou.aliyuncs.com です。 */
const char *endpoint = "yourEndpoint";
/* バケット名に置き換えます。例: examplebucket。 */
const char *bucket_name = "examplebucket";
/* yourRegion をバケットが配置されているリージョンの ID に置き換えます。たとえば、中国 (杭州) リージョンの場合、リージョン ID は cn-hangzhou です。 */
const char *region = "yourRegion";
void init_options(oss_request_options_t *options)
{
    options->config = oss_config_create(options->pool);
    /* aos_string_t 変数を char* 文字列で初期化します。 */
    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"));
    // 次の 2 つのパラメーターも設定する必要があります。
    aos_str_set(&options->config->region, region);
    options->config->signature_version = 4;
    /* CNAME を使用して OSS にアクセスするかどうかを指定します。値が 0 の場合、CNAME は使用されません。 */
    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;
    /* メモリプールを作成します。2 番目のパラメーターは NULL で、新しいメモリプールが別のメモリプールから継承されないことを示します。 */
    aos_pool_create(&pool, NULL);
    /* オプションを作成および初期化します。このパラメーターには、エンドポイント、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->prefix, "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->prefix, "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();
    return 0;
}

require 'aliyun/oss'

client = Aliyun::OSS::Client.new(
  # 中国 (杭州) エンドポイントを例として使用しています。実際のエンドポイントに置き換えてください。
  endpoint: '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))
]

package main

import (
	"context"
	"flag"
	"log"

	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss"
	"github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss/credentials"
)

// グローバル変数を定義します。
var (
	region     string // バケットが配置されているリージョン。
	bucketName string // バケット名。
)

// init 関数はコマンドライン引数を初期化します。
func init() {
	flag.StringVar(&region, "region", "", "バケットが配置されているリージョン。")
	flag.StringVar(&bucketName, "bucket", "", "バケット名。")
}

func main() {
	// コマンドライン引数を解析します。
	flag.Parse()

	// バケット名が提供されているかを確認します。
	if len(bucketName) == 0 {
		flag.PrintDefaults()
		log.Fatalf("無効なパラメーターです。バケット名が必要です。")
	}

	// リージョンが提供されているかを確認します。
	if len(region) == 0 {
		flag.PrintDefaults()
		log.Fatalf("無効なパラメーターです。リージョンが必要です。")
	}

	// デフォルト設定をロードし、認証情報プロバイダーおよびリージョンを設定します。
	cfg := oss.LoadDefaultConfig().
		WithCredentialsProvider(credentials.NewEnvironmentVariableCredentialsProvider()).
		WithRegion(region)

	// OSS クライアントを作成します。
	client := oss.NewClient(cfg)

	// バケットのライフサイクルルールを設定するリクエストを作成します。
	request := &oss.PutBucketLifecycleRequest{
		Bucket: oss.Ptr(bucketName), // バケット名。
		LifecycleConfiguration: &oss.LifecycleConfiguration{
			Rules: []oss.LifecycleRule{
				{
					// ライフサイクルルール "rule1" を指定します。
					// このルールは、プレフィックス "foo/" およびタグ {k1: v1} を持つオブジェクトを、
					// 最終更新時刻から 30 日後に低頻度アクセス (IA) ストレージクラスに移行します。
					Status: oss.Ptr("Enabled"),
					ID:     oss.Ptr("rule1"),
					Prefix: oss.Ptr("foo/"),
					Transitions: []oss.LifecycleRuleTransition{
						{
							Days:         oss.Ptr(int32(30)),
							StorageClass: oss.StorageClassIA,
							IsAccessTime: oss.Ptr(false), // 最終更新時刻に基づくルールの場合は false に設定します。
						},
					},
					Tags: []oss.Tag{
						{
							Key:   oss.Ptr("k1"),
							Value: oss.Ptr("v1"),
						},
					},
				},
				{
					// ライフサイクルルール "rule2" を指定します。このルールはプレフィックス "dir/" を持つオブジェクトに適用されます。
					// 現在のバージョンは最終更新時刻から 10 日後に有効期限切れとなり、非現行バージョンは 30 日後に削除され、
					// 非現行バージョンは非現行バージョンとなってから 10 日後に IA ストレージクラスに移行されます。
					ID:     oss.Ptr("rule2"),
					Prefix: oss.Ptr("dir/"),
					Status: oss.Ptr("Enabled"),
					Expiration: &oss.LifecycleRuleExpiration{
						Days: oss.Ptr(int32(10)),
					},
					NoncurrentVersionExpiration: &oss.NoncurrentVersionExpiration{
						NoncurrentDays: oss.Ptr(int32(30)),
					},
					NoncurrentVersionTransitions: []oss.NoncurrentVersionTransition{{
						NoncurrentDays: oss.Ptr(int32(10)),
						StorageClass:   oss.StorageClassIA,
						IsAccessTime:   oss.Ptr(false), // 最終更新時刻に基づくルールの場合は false に設定します。
					}},
				},
			},
		},
	}

	// バケットのライフサイクルルールを設定します。
	result, err := client.PutBucketLifecycle(context.TODO(), request)
	if err != nil {
		log.Fatalf("バケットのライフサイクル設定に失敗しました %v", err)
	}

	// ライフサイクルルール設定の結果を出力します。
	log.Printf("バケットのライフサイクル設定結果:%#v\n", result)
}