すべてのプロダクト
Search
ドキュメントセンター

Object Storage Service:オブジェクトのストレージクラスの変換

最終更新日:Oct 24, 2026

Object Storage Service (OSS) は、標準、低頻度アクセス (IA)、アーカイブ、コールドアーカイブ、ディープコールドアーカイブという複数のストレージクラスに対応しています。ライフサイクルルールを使用すると、オブジェクトのストレージクラスを自動的に変換できます。また、CopyObject 操作を呼び出して、オブジェクトのストレージクラスを手動で変換することもできます。

警告
  • OSS-HDFS が有効になっているバケットでは、.dlsdata/ データストレージディレクトリ内のオブジェクトのストレージクラスを変更しないでください。

  • .dlsdata/ ディレクトリ内のオブジェクトのストレージクラスを低頻度アクセス (IA) に変更した場合、そのオブジェクトは OSS-HDFS 経由で引き続きアクセス可能です。ストレージクラスをアーカイブストレージ、コールドアーカイブストレージ、またはディープコールドアーカイブストレージに変更した場合、そのオブジェクトは OSS-HDFS 経由ではアクセスできなくなります。オブジェクトにアクセスするには、まず解凍する必要があります。

ライフサイクルルールによるオブジェクトストレージクラスの自動変換

最終更新日時によるストレージクラスの移行

  • ローカル冗長ストレージ (LRS)本地冗余

    LRS オブジェクトの変換ルールは次のとおりです。

    • 標準 LRS オブジェクトは、IA LRS、アーカイブ LRS、コールドアーカイブ LRS、またはディープコールドアーカイブ LRS に変換できます。

    • IA LRS オブジェクトは、アーカイブ LRS、コールドアーカイブ LRS、またはディープコールドアーカイブ LRS に変換できます。

    • アーカイブ LRS オブジェクトは、コールドアーカイブ LRS またはディープコールドアーカイブ LRS に変換できます。

    • コールドアーカイブ LRS オブジェクトは、ディープコールドアーカイブ LRS に変換できます。

    同じバケットに対して、オブジェクトを IA、アーカイブ、コールドアーカイブ、ディープコールドアーカイブに変換するライフサイクルルールを設定する場合、指定するトランジション期間は次の条件を満たす必要があります。

    IA へのトランジション期間 < アーカイブへのトランジション期間 < コールドアーカイブへのトランジション期間 < ディープコールドアーカイブへのトランジション期間

  • ゾーン冗長ストレージ (ZRS)同城

    ゾーン冗長ストレージ内のオブジェクトの変換ルールは次のとおりです。

    • 標準 ZRS オブジェクトは、IA ZRS、アーカイブ ZRS、コールドアーカイブ LRS、またはディープコールドアーカイブ LRS に変換できます。

    • IA ZRS オブジェクトは、アーカイブ ZRS、コールドアーカイブ LRS、またはディープコールドアーカイブ LRS に変換できます。

    • アーカイブ ZRS オブジェクトは、コールドアーカイブ LRS またはディープコールドアーカイブ LRS に変換できます。

    • コールドアーカイブ LRS オブジェクトは、ディープコールドアーカイブ LRS に変換できます。

詳細については、「最終更新日時に基づくライフサイクルルール」をご参照ください。

最終アクセス時間に基づくストレージクラスの変換

重要
  • 標準または低頻度アクセス (IA) ストレージクラスから、アーカイブ、コールドアーカイブ、またはディープコールドアーカイブのストレージクラスにオブジェクトを変換するには、チケットを送信して、必要な権限を申請する必要があります。申請が承認されると、移行先のストレージクラスを指定できます。

  • 申請が承認された後、最終アクセス時刻に基づくライフサイクルルールを使用して、標準または低頻度アクセス (IA) からアーカイブ、コールドアーカイブ、またはディープコールドアーカイブにオブジェクトを変換する場合、そのオブジェクトの最終アクセス時刻は、バケットのアクセス追跡が有効化された時刻と見なされます。

  • ローカル冗長ストレージ (LRS)

    1.jpg

    LRS オブジェクトの変換ルールは次のとおりです:

    • 標準 LRS オブジェクトは、IA LRS、アーカイブ LRS、コールドアーカイブ LRS、またはディープコールドアーカイブ LRS に変換できます。

    • オブジェクトを標準 LRS から IA LRS に変換した後、アクセス時に自動的に標準 LRS に戻すかどうかも指定できます。

    • IA LRS オブジェクトは、アーカイブ LRS、コールドアーカイブ LRS、またはディープコールドアーカイブ LRS に変換できます。

    • アーカイブ LRS オブジェクトは、コールドアーカイブ LRS またはディープコールドアーカイブ LRS に変換できます。

    • コールドアーカイブ LRS オブジェクトは、ディープコールドアーカイブ LRS に変換できます。

  • ゾーン冗長ストレージ (ZRS)

    2.jpg

    ZRS オブジェクトの変換ルールは次のとおりです:

    • 標準 ZRS オブジェクトは、IA ZRS、アーカイブ ZRS、コールドアーカイブ LRS、またはディープコールドアーカイブ LRS に変換できます。

    • オブジェクトを標準 ZRS から IA ZRS に変換した後、アクセス時に自動的に標準 ZRS に戻すかどうかも指定できます。

    • IA ZRS オブジェクトは、アーカイブ ZRS、コールドアーカイブ LRS、またはディープコールドアーカイブ LRS に変換できます。

    • アーカイブ ZRS オブジェクトは、コールドアーカイブ LRS またはディープコールドアーカイブ LRS に変換できます。

    • Cold Archive LRS オブジェクトは Deep Cold Archive LRS に変換できます。

詳細については、「最終アクセス時刻に基づくライフサイクルルール」をご参照ください。

ライフサイクルルールによるストレージクラスの変換方法

ライフサイクルルールは、複数の方法で設定できます。ライフサイクルルールでは、指定した期間の経過後にオブジェクトを指定のストレージクラスに移行したり、期限切れのオブジェクトとパートを削除したりできます。次の手順では、ライフサイクルルールを使用してオブジェクトを指定のストレージクラスに移行する方法を説明します。

OSS コンソールの使用

  1. OSSコンソールにログインします。

  2. 左側のナビゲーションウィンドウで、バケット をクリックします。 [バケット] ページで、目的のバケットを見つけてクリックします。

  3. 左側のナビゲーションペインで、データ管理 > ライフサイクルを選択します。

  4. 任意: 最終アクセス時間に基づくライフサイクルルールを作成するには、ライフサイクル ページで [アクセス追跡の有効化] スイッチをオンにします。

  5. ライフサイクル ページで、ルールの作成 をクリックします。

  6. [ライフサイクルルールの作成] パネルで、次の表に従ってルールのパラメーターを設定します。

    • バケットでバージョニングが無効になっている場合:

      セクション

      パラメーター

      説明

      [基本設定]

      [ステータス]

      ルールのステータス。有効な値は [開始] および [無効] です。

      • 有効にすると、OSS はルールに基づいてオブジェクトを移行または削除します。

      • 無効にすると、ライフサイクルタスクは一時停止されます。

      [ポリシー]

      ルールの範囲。 オブジェクトプレフィックス または バケット全体に適用 を選択します。

      説明

      プレフィックスを選択する場合は、完全なプレフィックスを入力する必要があります。例えば、src/dir1/ ディレクトリ内のすべてのオブジェクトにルールを適用するには、プレフィックスを src/dir1/ に設定します。dir1 というプレフィックスでは、意図したとおりにこれらのオブジェクトに一致しません。プレフィックスは、フォワードスラッシュ (/) またはバックスラッシュ (\) で始めることはできません。例えば、/prod と /prod/ は無効なプレフィックスです。代わりに prod/ または prod を使用してください。

      [重複するプレフィックスを許可]

      デフォルトでは、OSS はライフサイクルルールのプレフィックスが重複しているかどうかをチェックします。例えば、プレフィックスが重複する以下の 2 つのルールを設定するとします:

      • ルール 1

        プレフィックス dir1/ を持つすべてのオブジェクトを、最終更新日時から 180 日後に削除します。

      • ルール 2

        プレフィックス dir1/dir2/ を持つすべてのオブジェクトを、最終更新日時から 30 日後に低頻度アクセスストレージクラスへ移行し、最終更新日時から 60 日後に削除します。

      ルール 2 を設定する際にこのオプションを選択しない場合、OSS は dir1/dir2/ ディレクトリ内のオブジェクトが 2 つの削除ルールに一致することを検出します。その結果、OSS はルール 2 を拒否し、Overlap for same action type Expiration. エラーを報告します。

      ルール 2 を設定する際にこのオプションを選択すると、dir1/dir2/ ディレクトリ内のオブジェクトは、最終更新日時から 30 日後に低頻度アクセスストレージクラスへ移行され、最終更新日時から 60 日後に削除されます。dir1/ ディレクトリ内のその他のオブジェクトは、最終更新日時から 180 日後に削除されます。

      説明

      複数のルールを設定し、そのうちの 1 つがバケット全体に適用される場合、これはプレフィックスの重複とみなされます。

      [接頭辞]

      ルールが適用されるオブジェクトプレフィックス。

      • プレフィックスを img に設定すると、img で始まるすべてのオブジェクト (imgtest.png や img/example.jpg など) にルールが適用されます。

      • プレフィックスを img/ に設定すると、img/ で始まるすべてのオブジェクト (img/example.jpg や img/test.jpg など) にルールが適用されます。

      プレフィックスは完全一致のみをサポートし、動的変数はサポートしていません。詳細については、重複するプレフィックスを許可 オプションの説明にある「最長プレフィックス一致」および「プレフィックスは動的変数をサポートしていません」をご参照ください。

      [タグ]

      指定されたタグを持つオブジェクトにのみルールを適用します。

      • プレフィックスを設定せず、キー = a、値 = 1 のタグを指定すると、バケット内のタグ a = 1 を持つすべてのオブジェクトにルールが適用されます。

      • プレフィックスを img に設定し、キー = a、値 = 1 のタグを指定すると、バケット内の img で始まり、タグ a = 1 を持つすべてのオブジェクトにルールが適用されます。

      「オブジェクトタグ付け」をご参照ください。

      [NOT]

      NOT オプションは、特定のプレフィックスとタグを持つオブジェクトをライフサイクルルールから除外します。

      重要
      • NOT オプションを有効にする場合、少なくともプレフィックスまたはタグを指定する必要があります。

      • NOT 条件で指定されたタグのキーは、タグ 条件で定義されたキーと同じにすることはできません。

      • NOT オプションが有効になっている場合、パートの有効期限ポリシーを設定することはできません。

      [ファイルサイズ]

      指定されたサイズ範囲内のオブジェクトにルールを適用します。

      • [最小サイズ]: ライフサイクルルールは、この値より大きいオブジェクトに適用されます。値は 0 B より大きく、5 TB 未満である必要があります。

      • [最大サイズ]: ライフサイクルルールは、この値より小さいオブジェクトに適用されます。値は 0 B より大きく、5 TB 以下である必要があります。

      重要

      同じライフサイクルルールで最小オブジェクトサイズと最大オブジェクトサイズの両方を指定する場合:

      • 最大サイズが最小サイズより大きいことを確認してください。

      • パートの有効期限ポリシーを設定することはできません。

      • 削除マーカーをクリーンアップするポリシーを設定することはできません。

      [オブジェクトに対するポリシー]

      [オブジェクトのライフサイクル]

      オブジェクトの有効期限ポリシーとして、[日数指定]、[日付指定]、または 有効になっていません を選択します。有効になっていません を選択した場合、オブジェクトの有効期限ポリシーは有効になりません。

      [ライフサイクルベースのルール]

      [低頻度アクセス]、アーカイブ、[コールドアーカイブ]、[ディープコールドアーカイブ]、または [データの削除] を選択して、オブジェクトのストレージクラスを移行するか、期限切れのオブジェクトを削除するルールを設定します。

      たとえば、オブジェクトのライフサイクル を [日付による] に設定し、2023 年 9 月 24 日を指定した場合、この日付より前に最終更新されたオブジェクトは自動的に削除され、復元できなくなります。

      [フラグメントに対するポリシー]

      [フラグメント期限切れポリシー]

      パーツの有効期限ポリシーを設定します。このオプションは、タグ を選択した場合は利用できません。パーツの有効期限ポリシーを [日数単位] または [日付で指定] に設定するか、有効になっていません を選択します。有効になっていません を選択した場合、パーツの有効期限ポリシーは有効になりません。

      重要

      ライフサイクルルールには、少なくともオブジェクトの有効期限ポリシーまたはパートの有効期限ポリシーのいずれかを含める必要があります。

      [フラグメントに対するルール]

      パートの有効期限ポリシーで選択した日数または日付に基づいて、パートの有効期限を指定します。有効期限切れのパートは自動的に削除され、復元できません。

    • バケットでバージョニングが有効になっている場合:

      基本設定 および フラグメントに対するポリシー セクションのパラメーターは、バージョニングなしのバケットと同様に設定されます。 次の表では、異なるパラメーターのみを説明します。

      重要

      ライフサイクルルールを設定する前に、クロスリージョンレプリケーションのデスティネーションとして機能するバケットでバージョニングが有効になっている場合、ソースバケットから同期された削除マーカーは、デスティネーションバケット内の同じ名前のオブジェクトの現行バージョンを非現行バージョンに変更することに注意してください。したがって、意図しないデータ削除を防ぐために、非現行バージョンのクリーンアップルールを慎重に設定してください。

      セクション

      パラメーター

      説明

      [現在のバージョンのポリシー]

      [期限切れオブジェクトの削除マーカーをクリーンアップ]

      バージョニングが有効になっている場合、有効期限ポリシーに [期限切れオブジェクト削除マーカーのクリーンアップ] オプションが追加されます。その他のオプションは、バージョニングが無効になっているバケットの場合と同じです。

      このオプションを選択すると、有効期限切れのオブジェクトの削除マーカーがそのオブジェクトの唯一のバージョンである場合、OSS は削除マーカーを削除します。オブジェクトに複数のバージョンがあり、最新のバージョンが削除マーカーである場合、OSS は削除マーカーを保持します。「削除マーカー」をご参照ください。

      重要

      非現行バージョンが存在する場合、このルールは削除マーカーをクリーンアップしません。削除マーカーと不要な非現行バージョンは速やかにクリーンアップすることを推奨します。そうしないと、削除マーカーが過剰になり、リストのパフォーマンスが低下する可能性があります。

      [以前のバージョンに対するポリシー]

      [オブジェクトのライフサイクル]

      非現行バージョンの有効期限ポリシーを設定します。[日数指定] または 有効になっていません を選択します。有効になっていません を選択した場合、有効期限ポリシーは有効になりません。

      [ライフサイクルベースのルール]

      日数 (N) を指定します。非現行バージョンは、非現行になってから N 日後に有効期限切れとなり、有効期限切れの翌日に指定されたアクションが実行されます。例えば、値を 30 に設定すると、2023 年 9 月 1 日に非現行バージョンになったオブジェクトは、2023 年 10 月 2 日に指定されたストレージクラスへ移行されるか削除されます。

      重要

      オブジェクトが非現行バージョンになった時期は、そのオブジェクトの次のバージョンの最終更新日時を確認することで判断できます。

  7. OK をクリックします。

    ライフサイクルルールを保存すると、ルールリストに設定したルールが表示されます。

Alibaba Cloud SDK の使用

以下のコードは、一般的な SDK を使用してライフサイクルルールを設定する方法の例を示しています。その他の SDK を使用してライフサイクルルールを設定する方法については、「概要」をご参照ください。

Java

import com.aliyun.oss.*;
import com.aliyun.oss.common.auth.*;
import com.aliyun.oss.common.comm.SignVersion;
import com.aliyun.oss.common.utils.DateUtil;
import com.aliyun.oss.model.LifecycleRule;
import com.aliyun.oss.model.SetBucketLifecycleRequest;
import com.aliyun.oss.model.StorageClass;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Demo {

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

        // OSSClient インスタンスを作成します。
        // OSSClient インスタンスが不要になったら、シャットダウンメソッドを呼び出してリソースを解放します。
        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 日後にオブジェクトを低頻度アクセスストレージクラスに、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 日後に非現行バージョンのオブジェクトを低頻度アクセスストレージクラスに移行します。
            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("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

<?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\Credentials\EnvironmentVariableCredentialsProvider;
use OSS\OssClient;
use OSS\CoreOssException;
use OSS\Model\LifecycleConfig;
use OSS\Model\LifecycleRule;
use OSS\Model\LifecycleAction;

// 環境変数から認証情報を取得します。このコードを実行する前に、OSS_ACCESS_KEY_ID および OSS_ACCESS_KEY_SECRET 環境変数が設定されていることを確認してください。
$provider = new EnvironmentVariableCredentialsProvider();
// 中国 (杭州) エンドポイントを例として使用しています。実際のリージョンのエンドポイントに置き換えてください。
$endpoint = "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 = array(
        "provider" => $provider,
        "endpoint" => $endpoint,
        "signatureVersion" => OssClient::OSS_SIGNATURE_VERSION_V4,
        "region"=> "cn-hangzhou"
    );
    $ossClient = new OssClient($config);

    $ossClient->putBucketLifecycle($bucket, $lifecycleConfig);
} catch (OssException $e) {
    printf(__FUNCTION__ . ": FAILED\n");
    printf($e->getMessage() . "\n");
    return;
}
print(__FUNCTION__ . ": OK" . "\n");

Node.js

const OSS = require('ali-oss')

const client = new OSS({
  // バケットが配置されているリージョンに region を設定します。たとえば、バケットが中国 (杭州) リージョンにある場合、region を 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 getBucketLifecycle () {
  try {
    const result = await client.getBucketLifecycle('Yourbucketname');
    console.log(result.rules); // ライフサイクルルールを取得します。

    result.rules.forEach(rule => {
      console.log(rule.id) //  ライフサイクルルールの ID を表示します。 
      console.log(rule.status) // ライフサイクルルールのステータスを表示します。
      console.log(rule.tags) // ライフサイクルルールのタグを表示します。
      console.log(rule.expiration.days) // 日数にもとづく有効期限ルールを表示します。
      console.log(rule.expiration.createdBeforeDate) // 日付にもとづく有効期限ルールを表示します。
      // マルチパートアップロードのパートを失効させるルールを表示します。
      console.log(rule.abortMultipartUpload.days || rule.abortMultipartUpload.createdBeforeDate)
      // ストレージクラスの移行ルールを表示します。
      console.log(rule.transition.days || rule.transition.createdBeforeDate) // ストレージクラスの移行時間を表示します。
      console.log(rule.transition.storageClass) // オブジェクトが移行されるストレージクラス。
      // 期限切れの削除マーカーを自動的に削除するかどうかを表示します。
      console.log(rule.transition.expiredObjectDeleteMarker)
      // 非現行バージョンのオブジェクトのストレージクラス移行ルールを表示します。
      console.log(rule.noncurrentVersionTransition.noncurrentDays) // 非現行バージョンのオブジェクトのストレージクラス移行時間を表示します。
      console.log(rule.noncurrentVersionTransition.storageClass) // 非現行バージョンのオブジェクトが移行されるストレージクラスを表示します。
    })
  } catch (e) {
    console.log(e);
  }
}
getBucketLifecycle();

Python

# -*- coding: utf-8 -*-
import oss2
from oss2.credentials import EnvironmentVariableCredentialsProvider
import datetime
from oss2.models import (LifecycleExpiration, LifecycleRule,
                        BucketLifecycle, AbortMultipartUpload,
                        TaggingRule, Tagging, StorageTransition,
                        NoncurrentVersionStorageTransition,
                        NoncurrentVersionExpiration)

# 環境変数からアクセス認証情報を取得します。このサンプルコードを実行する前に、環境変数 OSS_ACCESS_KEY_ID および OSS_ACCESS_KEY_SECRET が設定されていることを確認してください。
auth = oss2.ProviderAuthV4(EnvironmentVariableCredentialsProvider())

# バケットが配置されているリージョンのエンドポイントを指定します。たとえば、バケットが中国 (杭州) リージョンにある場合、エンドポイントを https://oss-cn-hangzhou.aliyuncs.com に設定します。
endpoint = "https://oss-cn-hangzhou.aliyuncs.com"
# エンドポイントに対応するリージョン情報 (例: cn-hangzhou) を指定します。このパラメーターは V4 署名に必須です。
region = "cn-hangzhou"

# examplebucket を実際のバケット名に置き換えます。
bucket = oss2.Bucket(auth, endpoint, "examplebucket", region=region)

# オブジェクトが最終更新日時から 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(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(lifecycle)

C#

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 日後に Archive (アーカイブ) に変換されるように指定します。
        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);
}

Android-Java

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();

Go

package main

import (
	"fmt"
	"os"

	"github.com/aliyun/aliyun-oss-go-sdk/oss"
)

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 インスタンスを作成します。
	// yourEndpoint をバケットのエンドポイントに設定します。たとえば、中国 (杭州) リージョンの場合、エンドポイントを https://oss-cn-hangzhou.aliyuncs.com に設定します。他のリージョンについては、実際のエンドポイントを使用してください。
	// yourRegion をバケットが配置されているリージョンに設定します。たとえば、中国 (杭州) リージョンの場合、リージョンを cn-hangzhou に設定します。他のリージョンについては、実際のリージョンを使用してください。
	clientOptions := []oss.ClientOption{oss.SetCredentialsProvider(&provider)}
	clientOptions = append(clientOptions, oss.Region("yourRegion"))
	// 署名バージョンを設定します。
	clientOptions = append(clientOptions, oss.AuthVersion(oss.AuthV4))
	client, err := oss.New("yourEndpoint", "", "", clientOptions...)
	if err != nil {
		fmt.Println("Error:", err)
		os.Exit(-1)
	}
	// バケット名を指定します。
	bucketName := "examplebucket"
	// ライフサイクルルール 1 を指定します。このルールは、プレフィックスが "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",
	}

	// ライフサイクルルール 2 を指定します。
	rule2 := oss.LifecycleRule{
		ID:                   "rule2",
		Prefix:               "yourObjectPrefix",
		Status:               "Enabled",
		Expiration:           &expiration,
		NonVersionExpiration: &versionExpiration,
		NonVersionTransitions: []oss.LifecycleVersionTransition{
			versionTransition,
		},
	}

	// ライフサイクルルール 3 を指定します。このルールは、タグキーが "tag1" でタグ値が "value1" のファイルが最終更新日から 3 日後に有効期限が切れることを指定します。
	rule3 := oss.LifecycleRule{
		ID:     "rule3",
		Prefix: "",
		Status: "Enabled",
		Tags: []oss.Tag{
			{
				Key:   "tag1",
				Value: "value1",
			},
		},
		Expiration: &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>
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 fail" <<
        ",code:" << outcome.error().Code() <<
        ",message:" << outcome.error().Message() <<
        ",requestId:" << outcome.error().RequestId() << std::endl;
        return -1;
    }

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

C

#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);
    /* オプションを作成して初期化します。このパラメーターには、endpoint、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;
}

Ruby

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))
]

ossutil の使用

ossutil を使用してライフサイクルルールを設定する方法については、「put-bucket-lifecycle」をご参照ください。

REST API の使用

アプリケーションに特定の要件がある場合は、REST API リクエストを直接送信できます。これを行うには、署名を計算するコードを手動で記述する必要があります。詳細については、「PutBucketLifecycle」をご参照ください。

CopyObject API によるオブジェクトストレージクラスの手動変換

CopyObject API を呼び出してオブジェクトを上書きすることにより、オブジェクトのストレージクラスを変換できます。

  • オブジェクトのストレージクラスを IA、アーカイブ、コールドアーカイブ、またはディープコールドアーカイブに変換する場合、64 KB の最小課金サイズ、最小ストレージ期間、およびデータ取得料金が適用される場合があります。詳細については、「使用上の注意」をご参照ください。

  • アーカイブ、コールドアーカイブ、およびディープコールドアーカイブのオブジェクトは、ストレージクラスを変更する前に復元する必要があります。オブジェクトの復元方法の詳細については、「オブジェクトの復元」をご参照ください。アーカイブ直接読み取りが有効になっている場合、アーカイブオブジェクトを復元せずにストレージクラスを変更できます。直接読み取りでは、リアルタイムアクセスのためのデータ取得料金が発生します。詳細については、「アーカイブ直接読み取り」をご参照ください。

説明
  • バージョン管理が有効になっているバケットで、CopyObject API を呼び出してオブジェクトのストレージクラスを変換すると、OSS は新しいオブジェクトバージョンに対して一意のバージョン ID を自動的に生成します。このバージョン ID は、x-oss-version-id レスポンスヘッダーで返されます。

  • バージョン管理が無効または一時停止されているバケットで、CopyObject API を呼び出してオブジェクトのストレージクラスを変換すると、OSS は新しいオブジェクトとして null のバージョン ID を持つバージョンを自動的に生成し、既存の null のバージョン ID を持つバージョンを上書きします。上書きされたオブジェクトが IA、アーカイブ、コールドアーカイブ、またはディープコールドアーカイブのストレージクラスである場合、最小ストレージ期間未満で保存されたオブジェクトのストレージ料金が請求されることがあります。詳細については、「最小ストレージ期間未満で保存されたオブジェクトはどのように課金されますか?」をご参照ください。

CopyObject によるストレージクラスの変換ルール

以下のルールは、ローカル冗長ストレージ (LRS) とゾーン冗長ストレージ (ZRS) の両方のオブジェクトに適用されます。ソースオブジェクトがアーカイブ、コールドアーカイブ、またはディープコールドアーカイブのストレージクラスである場合、そのストレージクラスを変換する前にオブジェクトを復元する必要があります。バケットでアーカイブ直接読み取りが有効になっている場合、アーカイブオブジェクトを復元する必要はありません。リアルタイムアクセスは、コールドアーカイブまたはディープコールドアーカイブのオブジェクトではサポートされていません。

  • LRS

    LRS オブジェクトは、標準 LRS、IA LRS、アーカイブ LRS、コールドアーカイブ LRS、およびディープコールドアーカイブ LRS のいずれのストレージクラス間でも変換できます。

  • ゾーン冗長ストレージ (ZRS)

    ZRS オブジェクトは、標準 ZRS、IA ZRS、およびアーカイブ ZRS のいずれのストレージクラス間でも変換できます。

CopyObject によるストレージクラスの変換方法

オブジェクトの上書き防止を有効にすると、OSS コンソール、SDK、ossutil などのクライアントを使用して CopyObject API を呼び出してオブジェクトのストレージクラスを変換することはできません。ストレージクラスを変換するには、ライフサイクルルールを使用して自動変換を行う必要があります。

OSS コンソールの使用

コンソールでオブジェクトのストレージクラスを変更する場合、オブジェクトサイズは 1 GB を超えることはできません。1 GB を超えるオブジェクトについては、SDK または ossutil を使用することを推奨します。

  1. OSSコンソールにログインします。

  2. バケット をクリックし、目的のバケットの名前をクリックします。

  3. 左側メニューで、オブジェクト管理 > オブジェクト を選択します。

  4. オブジェクト ページで、目的のオブジェクトを見つけ、more > ストレージタイプの変更 を選択します。

  5. ストレージクラスを変更する際にオブジェクトのカスタムメタデータを保持するために、ユーザーメタデータの保持 スイッチをオンにすることを推奨します。

  6. 新しいストレージクラスを選択し、OK をクリックします。

Alibaba Cloud SDK の使用

import com.aliyun.oss.*;
import com.aliyun.oss.common.auth.*;
import com.aliyun.oss.common.comm.SignVersion;
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 {
        // 次の例では、中国 (杭州) リージョンのエンドポイントを使用します。実際のエンドポイントに置き換えてください。
        String endpoint = "https://oss-cn-hangzhou.aliyuncs.com";
        // 環境変数からアクセス認証情報を取得します。この例を実行する前に、OSS_ACCESS_KEY_ID および OSS_ACCESS_KEY_SECRET 環境変数が設定されていることを確認してください。
        EnvironmentVariableCredentialsProvider credentialsProvider = CredentialsProviderFactory.newEnvironmentVariableCredentialsProvider();
        // この例を実行する前に、バケットとオブジェクトを作成してください。オブジェクトは、標準または低頻度アクセスストレージクラスである必要があります。
        // バケット名を指定します。例:examplebucket。
        String bucketName = "examplebucket";
        // オブジェクトの完全なパスを指定します。バケット名は含めないでください。例:exampleobject.txt。
        String objectName = "exampleobject.txt";
        // バケットが配置されているリージョンを指定します。たとえば、バケットが中国 (杭州) リージョンにある場合は、リージョンを 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 {
            // CopyObjectRequest オブジェクトを作成します。
            CopyObjectRequest request = new CopyObjectRequest(bucketName, objectName, bucketName, objectName) ;

            // ObjectMetadata オブジェクトを作成します。
            ObjectMetadata objectMetadata = new ObjectMetadata();

            // オブジェクトのストレージクラスをアーカイブに変換します。
            objectMetadata.setHeader("x-oss-storage-class", StorageClass.Archive);
            // オブジェクトのストレージクラスをコールドアーカイブに変換します。
            // objectMetadata.setHeader("x-oss-storage-class", StorageClass.ColdArchive);
            // オブジェクトのストレージクラスをディープコールドアーカイブに変換します。
            // objectMetadata.setHeader("x-oss-storage-class", StorageClass.DeepColdArchive);
            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\Credentials\EnvironmentVariableCredentialsProvider;
use OSS\OssClient;
use OSS\CoreOssException;

// 環境変数からアクセス認証情報を取得します。このサンプルコードを実行する前に、環境変数 OSS_ACCESS_KEY_ID および OSS_ACCESS_KEY_SECRET が設定されていることを確認してください。
$provider = new EnvironmentVariableCredentialsProvider();
// この例では、中国 (杭州) リージョンのエンドポイントを使用します。実際のエンドポイントを指定してください。
$endpoint = "https://oss-cn-hangzhou.aliyuncs.com";
// バケット名を指定します。
$bucket= "<yourBucketName>";
// オブジェクトの完全なパスを指定します。バケット名は含めないでください。例: destfolder/exampleobject.txt。
$object = "<yourObjectName>";

$config = array(
        "provider" => $provider,
        "endpoint" => $endpoint,
        "signatureVersion" => OssClient::OSS_SIGNATURE_VERSION_V4,
        "region"=> "cn-hangzhou"
    );
    $ossClient = new OssClient($config);

try {

    // 変更後のオブジェクトのストレージクラスを指定します。たとえば、ストレージクラスをアーカイブに設定します。
    $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({
  // バケットが配置されているリージョンに region を設定します。 たとえば、バケットが中国 (杭州) リージョンにある場合は、region を 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 をご使用のバケット名に設定します。
  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
from oss2.credentials import EnvironmentVariableCredentialsProvider
import os
# 環境変数からアクセス認証情報を取得します。サンプルコードを実行する前に、OSS_ACCESS_KEY_ID および OSS_ACCESS_KEY_SECRET 環境変数が設定されていることを確認してください。
auth = oss2.ProviderAuthV4(EnvironmentVariableCredentialsProvider())

# バケットが配置されているリージョンのエンドポイントを指定します。たとえば、バケットが中国 (杭州) リージョンにある場合は、エンドポイントを https://oss-cn-hangzhou.aliyuncs.com に設定します。
endpoint = "https://oss-cn-hangzhou.aliyuncs.com"

# エンドポイントにマッピングされるリージョンの ID を指定します。例: cn-hangzhou。署名アルゴリズム V4 を使用する場合は、このパラメーターが必要です。
region = "cn-hangzhou"

# バケットの名前を指定します。
bucket = oss2.Bucket(auth, endpoint, "yourBucketName", region=region)

# オブジェクトの完全なパスを指定します。完全なパスにバケット名を含めないでください。例: exampledir/exampleobject.txt。
# オブジェクトのストレージタイプが標準または IA であることを確認してください。
object_name = 'exampledir/exampleobject.txt'

# x-oss-storage-class ヘッダーを oss2.BUCKET_STORAGE_CLASS_ARCHIVE に設定して、オブジェクトのストレージタイプをアーカイブに変換します。
headers = {'x-oss-storage-class': oss2.BUCKET_STORAGE_CLASS_ARCHIVE}
# x-oss-storage-class ヘッダーを oss2.BUCKET_STORAGE_CLASS_COLD_ARCHIVE に設定して、オブジェクトのストレージタイプをコールドアーカイブに変換します。
# headers = {'x-oss-storage-class': oss2.BUCKET_STORAGE_CLASS_COLD_ARCHIVE}
# x-oss-storage-class ヘッダーを BUCKET_STORAGE_CLASS_DEEP_COLD_ARCHIVE に設定して、オブジェクトのストレージタイプをディープコールドアーカイブに変換します。
# headers = {'x-oss-storage-class': oss2.models.BUCKET_STORAGE_CLASS_DEEP_COLD_ARCHIVE}
# オブジェクトのストレージタイプを変換します。
bucket.copy_object(bucket.bucket_name, object_name, object_name, headers)                    
package main

import (
	"log"

	"github.com/aliyun/aliyun-oss-go-sdk/oss"
)

func main() {
	// 環境変数からアクセス認証情報を取得します。このサンプルコードを実行する前に、OSS_ACCESS_KEY_ID および OSS_ACCESS_KEY_SECRET 環境変数が設定されていることを確認してください。
	provider, err := oss.NewEnvironmentVariableCredentialsProvider()
	if err != nil {
		log.Fatalf("Failed to create credentials provider: %v", err)
	}

	// OSSClient インスタンスを作成します。
	// yourEndpoint をバケットのエンドポイントに設定します。たとえば、中国 (杭州) リージョンの場合、エンドポイントを https://oss-cn-hangzhou.aliyuncs.com に設定します。他のリージョンの場合は、実際のエンドポイントを使用します。
	// yourRegion をバケットが配置されているリージョンに設定します。たとえば、中国 (杭州) リージョンの場合、リージョンを cn-hangzhou に設定します。他のリージョンの場合は、実際のリージョンを使用します。
	clientOptions := []oss.ClientOption{oss.SetCredentialsProvider(&provider)}
	clientOptions = append(clientOptions, oss.Region("yourRegion"))
	// 署名バージョンを設定します。
	clientOptions = append(clientOptions, oss.AuthVersion(oss.AuthV4))
	client, err := oss.New("yourEndpoint", "", "", clientOptions...)
	if err != nil {
		log.Fatalf("Failed to create OSS client: %v", err)
	}

	// yourBucketName をバケットの名前に設定します。
	bucketName := "yourBucketName" // 実際のバケット名に置き換えます。
	// yourObjectName をオブジェクトの完全なパスに設定します。バケット名は含めないでください。
	objectName := "yourObjectName" // 実際のオブジェクトパスに置き換えます。

	bucket, err := client.Bucket(bucketName)
	if err != nil {
		log.Fatalf("Failed to get bucket: %v", err)
	}

	// オブジェクトのストレージクラスを変更します。たとえば、アーカイブに変更します。
	_, err = bucket.CopyObject(objectName, objectName, oss.ObjectStorageClass(oss.StorageArchive))
	if err != nil {
		log.Fatalf("Failed to change storage class of object: %v", err)
	}

	log.Println("Storage class changed successfully.")
}
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;
}];
// 同期ブロッキングを実装して、タスクが完了するのを待ちます。
// [task waitUntilFinished];  
#include <iostream>
#include <alibabacloud/oss/OssClient.h>

using namespace AlibabaCloud::OSS;

int main(void)
{  
            
    /* バケットが配置されているリージョンのエンドポイントに yourEndpoint を設定します。 たとえば、バケットが中国 (杭州) リージョンにある場合、エンドポイントを https://oss-cn-hangzhou.aliyuncs.com に設定します。 */
    std::string Endpoint = "yourEndpoint";
    /* バケットが配置されているリージョンに yourRegion を設定します。 たとえば、バケットが中国 (杭州) リージョンにある場合、リージョンを cn-hangzhou に設定します。 */
    std::string Region = "yourRegion";
    /* バケット名を指定します。 例: examplebucket */
    std::string BucketName = "examplebucket";
    /* オブジェクトの完全なパスを指定します。 完全なパスにバケット名を含めることはできません。 例: exampledir/exampleobject.txt */
    std::string ObjectName = "exampledir/exampleobject.txt";
  
    /* ネットワークリソースを初期化します。 */
    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);
    
    /* オブジェクトのストレージクラスを設定します。 たとえば、ストレージクラスをアーカイブに設定します。 */
    ObjectMetaData objectMeta;
    objectMeta.addHeader("x-oss-storage-class", "Archive");
    
    std::string SourceBucketName = BucketName;
    std::string SourceObjectName = ObjectName;
    
    CopyObjectRequest request(SourceBucketName, ObjectName, 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;
        return -1;
    }
    
    /* ネットワークリソースを解放します。 */
    ShutdownSdk();
    return 0;
}

ossutil の使用

ossutil を使用してオブジェクトのストレージクラスを変換する方法の詳細については、「copy-object」をご参照ください。

REST API の使用

お使いのアプリケーションに特定の要件がある場合は、REST API リクエストを直接送信できます。そのためには、署名を計算するコードを手動で記述する必要があります。詳細については、「CopyObject」をご参照ください。

使用上の注意

オブジェクトのストレージクラスを IA、アーカイブ、コールドアーカイブ、またはディープコールドアーカイブに変換する場合、次の点にご注意ください。

最小課金対象サイズ

オブジェクトの最小課金対象サイズは 64 KB です。オブジェクトが 64 KB 未満の場合、64 KB のストレージとして課金されます。

最低ストレージ期間

最低ストレージ期間は、IA オブジェクトは 30 日、アーカイブオブジェクトは 60 日、コールドアーカイブオブジェクトは 180 日、ディープコールドアーカイブオブジェクトは 180 日です。オブジェクトが最低ストレージ期間より短い期間で保存された場合、最低ストレージ期間未満のオブジェクトのストレージ料金が課金されます。詳細については、「ストレージ料金」をご参照ください。

  • ライフサイクルルールを使用してオブジェクトのストレージクラスを自動的に変換する

    • オブジェクトのストレージクラスを IA またはアーカイブに変換する場合、オブジェクトのストレージ期間は再計算されません。

      たとえば、a.txt という名前のオブジェクトが OSS に標準オブジェクトとして 10 日間保存されているとします。ライフサイクルルールによってストレージクラスが IA に変換された後、30 日間の最低ストレージ期間の要件を満たすには、さらに 20 日間保存するだけで済みます。

    • オブジェクトのストレージクラスをコールドアーカイブまたはディープコールドアーカイブに変換する場合、オブジェクトのストレージ期間は再計算されます。

      • 例 1:a.txt という名前のオブジェクトが、OSS に標準または IA オブジェクトとして 10 日間保存されているとします。ライフサイクルルールによってストレージクラスがコールドアーカイブまたはディープコールドアーカイブに変換された後、180 日間の最低ストレージ期間の要件を満たすには、さらに 180 日間保存する必要があります。

      • 例 2:a.txt という名前のオブジェクトが、OSS にコールドアーカイブオブジェクトとして 30 日間保存されているとします。ライフサイクルルールによってストレージクラスがディープコールドアーカイブに変換されると、180 日間の最低ストレージ期間未満でコールドアーカイブオブジェクトを保存したことに対して課金されます。さらに、ディープコールドアーカイブに変換された後、180 日間の最低ストレージ期間の要件を満たすには、さらに 180 日間保存する必要があります。

  • CopyObject API を使用してオブジェクトのストレージクラスを手動で変換する

    CopyObject API を使用してオブジェクトを手動で任意のストレージクラスに変換する場合、オブジェクトのストレージ期間は再計算されます。

    たとえば、a.txt という名前のオブジェクトが OSS に標準オブジェクトとして 10 日間保存されているとします。CopyObject API を使用してオブジェクトを手動で IA ストレージクラスに変換した後、30 日間の最低ストレージ期間の要件を満たすには、さらに 30 日間保存する必要があります。

説明

IA、アーカイブ、コールドアーカイブ、またはディープコールドアーカイブのオブジェクトの名前を変更したり、最低ストレージ期間が経過する前に同じ名前のオブジェクトをアップロードして上書きしたりすると、最低ストレージ期間未満のオブジェクトのストレージ料金が課金されます。たとえば、IA オブジェクトを 29 日間保存した後に名前を変更すると、OSS は名前変更後のオブジェクトを新しいオブジェクトとして扱い、そのストレージ期間をリセットします。つまり、IA ストレージクラスの最低ストレージ期間の要件を満たすには、オブジェクトをさらに 30 日間保存する必要があります。

復元時間

アーカイブ、コールドアーカイブ、またはディープコールドアーカイブのオブジェクトを復元するには時間がかかります。ビジネスシナリオでオブジェクトへのリアルタイムアクセスが必要な場合は、オブジェクトのストレージクラスをアーカイブ、コールドアーカイブ、またはディープコールドアーカイブに変換しないことを推奨します。

リクエスト料金

変換方法

ソースストレージクラス

リクエスト料金

ライフサイクルルール

標準、IA、アーカイブ、コールドアーカイブ

ソースストレージクラスに基づいて PUT リクエストに対して課金されます。料金は現在のバケットに請求されます。

CopyObject

アーカイブ

  • ① アーカイブ直接読み取りが有効な場合

    • ソースストレージクラスに基づいて GET リクエストに対して課金されます。料金はソースバケットに請求されます。

    • オブジェクトの宛先ストレージクラスに基づいて PUT リクエストに対して課金されます。料金は宛先バケットに請求されます。

  • ② アーカイブ直接読み取りが無効な場合

    ソースストレージクラスに基づいて PUT リクエストに対して課金されます。料金は宛先バケットに請求されます。

標準、IA、コールドアーカイブ、ディープコールドアーカイブ

PUT リクエストには、オブジェクトのソースストレージクラスに基づいて課金されます。料金は宛先バケットに請求されます。

① アーカイブ直接読み取りが有効な場合、CopyObject API を使用して変換元のアーカイブオブジェクトのストレージクラスを変換する際に、事前に復元する必要はありません。アーカイブからのデータ復元料金は発生しませんが、リアルタイムアクセスのためのデータ取り出し料金が発生します。

② アーカイブ直接読み取りが有効になっていない場合、CopyObject API を使用して変換元のアーカイブオブジェクトのストレージクラスを変換する際に、最初に復元する必要があります。アーカイブからのデータ復元料金は発生しますが、リアルタイムアクセスのためのデータ取り出し料金は発生しません。

詳細については、「データ処理料金」をご参照ください。

データ取り出し料金

IA オブジェクトにアクセスすると、実際にアクセスされたデータ量に基づいて追加のデータ取り出し料金が課金されます。アーカイブ、コールドアーカイブ、ディープコールドアーカイブのオブジェクトを復元すると、追加のデータ復元料金が課金されます。アーカイブ直接読み取りを有効にすると、アーカイブオブジェクトに直接アクセスした際にデータ取り出し料金が課金されます。これらの料金は、アウトバウンドトラフィック料金とは別に請求されます。オブジェクトが月に平均 1 回以上アクセスされる場合、IA、アーカイブ、コールドアーカイブ、またはディープコールドアーカイブストレージクラスを使用するコストが、標準ストレージクラスのコストよりも高くなる場合があります。

一時ストレージ料金

コールドアーカイブまたはディープコールドアーカイブのオブジェクトが復元されると、アクセス用にオブジェクトの標準レプリカが作成されます。このレプリカには、復元期間中、標準ストレージクラスのストレージ料金レートで一時ストレージ料金が課金されます。

よくある質問

最終更新日時に基づくライフサイクルルールを使用して、オブジェクトのストレージクラスを低頻度アクセスから標準に変換できますか?

いいえ、できません。オブジェクトのストレージクラスを低頻度アクセスから標準に変換するには、次のいずれかの方法を使用できます。