全部產品
Search

搜尋本產品

    Object Storage Service：基於最後一次修改時間配置生命週期規則以降低OSS儲存成本

    文件中心

    Object Storage Service：基於最後一次修改時間配置生命週期規則以降低OSS儲存成本

    更新時間：Jun 19, 2024

    並不是所有上傳至OSS的資料都需要頻繁訪問，但基於資料合規或者存檔等原因，部分資料仍需要繼續儲存。或者基於業務使用情境，希望大量刪除Bucket內不再需要儲存的資料。您可以配置基於最後一次修改時間（Last Modified Time）的生命週期規則，定期將Object從熱儲存類型轉為冷儲存類型，或者刪除Object，以降低儲存成本。

    使用情境

    • 某醫學機構的醫學檔案，上傳至OSS後半年內需要偶爾訪問，半年後基本不再訪問。可以通過設定生命週期規則，將已上傳180天的醫學檔案轉為Archive Storage。

    • 某公司服務熱線的錄音檔案，上傳至OSS後2個月內，需要作為資料統計及核查的依據，2個月後偶爾訪問，半年後基本不再訪問，2年後資料不再需要儲存。可以通過設定生命週期規則，設定錄音檔案上傳60天后轉為低頻訪問儲存，180天后轉為Archive Storage，730天后刪除。

    • 某Bucket內有大量檔案需要全部刪除，但是手動刪除每次僅可以刪除最多1000個檔案，比較麻煩。此時可以配置一條匹配整個Bucket的生命週期規則，設定一天后刪除所有檔案。此Bucket內的資料會在第二天被全部刪除。

    關於儲存類型的介紹，請參見儲存類型概述。

    使用限制

    匹配條件

    生命週期規則目前僅支援根據首碼和標籤進行匹配，不支援萬用字元匹配、尾碼匹配以及正則匹配。

    片段到期限制

    不支援對重疊首碼的Object設定兩條或兩條以上包含片段到期策略的生命週期規則。樣本如下：

    • 樣本一

      您對整個Bucket設定了一條包含片段到期策略的生命週期規則，則不支援對Bucket中任意首碼的Object再設定一條包含片段到期策略的生命週期規則。

    • 樣本二

      您對某個Bucket中首碼為dir1設定了一條包含片段到期策略的生命週期規則，則不支援對該Bucket中包含重疊首碼（例如dir1/dir2）的Object再設定一條包含片段到期策略的生命週期規則。

    儲存類型轉換限制

    • 不支援通過生命週期規則將追加上傳產生的Appendable類型的Object轉換為冷Archive Storage或者深度冷Archive Storage類型。

    • 不支援通過生命週期規則將軟連結（symlink）轉換為低頻訪問、歸檔、冷歸檔以及深度冷Archive Storage類型。

    注意事項

    規則數量

    單個Bucket最多支援配置1000條生命週期規則，單條生命週期規則中可同時包含最後一次修改時間以及最後一次訪問時間的策略。

    覆蓋語義

    PutBucketLifecycle為覆蓋語義。例如，某個Bucket已配置了生命週期規則Rule1，您需要在Rule1基礎上繼續追加生命週期規則Rule2，您需要執行以下操作。

    • 調用GetBucketLifecycle介面擷取當前生命週期規則配置Rule1。

    • 在Rule1基礎上疊加Rule2。

    • 調用PutBucketLifecycle介面更新生命週期規則為Rule1+Rule2。

    生效時間

    生命週期規則建立後的24小時內，OSS會載入規則。規則載入完成後，OSS會在每天的北京時間8:00開始執行規則。

    Object的最後修改時間與生命週期規則開始執行時間（8:00）必須間隔24小時以上。例如生命週期規則指定Object上傳1天后刪除，則2020年7月20日上傳的檔案刪除時間如下：

    • 北京時間8:00前上傳的檔案會在2020年7月21日8:00開始刪除，並在7月22日8:00前刪除完畢。

    • 北京時間8:00後上傳的檔案會在2020年7月22日8:00開始刪除，並在7月23日8:00前刪除完畢。

    重要

    更新生命週期規則會中止當天的生命週期任務，請不要頻繁更新生命週期規則。

    執行完成時間

    對於未配置標籤的生命週期規則

    • 華東1（杭州）、華東2（上海）、華北2（北京）、華北 3（張家口）、華北6（烏蘭察布）、華南1（深圳）、新加坡地區執行10億或以下次生命週期相關操作（包括Object刪除、Object儲存類型轉換以及片段到期），可在24小時內完成。如果生命週期相關操作超出10億次，則可能超出24小時。

    • 其他地區執行1億或以下次生命週期相關操作，可在24小時內完成。如果生命週期相關操作超出1億次，則可能超出24小時。

    對於已配置標籤的生命週期規則

    • 華東1（杭州）、華東2（上海）、華北2（北京）、華北 3（張家口）、華北6（烏蘭察布）、華南1（深圳）、新加坡地區執行5億或以下次生命週期相關操作（包括Object刪除、Object儲存類型轉換以及片段到期），可在24小時內完成。如果生命週期相關操作超出5億次，則可能超出24小時。

    • 其他地區執行5千萬或以下次生命週期相關操作，可在24小時內完成。如果生命週期相關操作超出5千萬次，則可能超出24小時。

    說明

    如果儲存空間開啟了版本控制，則對Object的每個版本均記為一次操作。

    費用說明

    關於通過生命週期規則轉換Object儲存類型或者刪除Object時可能涉及的儲存和請求費用說明，請參見生命週期費用說明。

    在開通了OSS-HDFS服務的Bucket中配置生命週期規則

    • 在開通了OSS-HDFS服務的Bucket中配置基於OSS檔案的生命週期規則

      如果您對開通了OSS-HDFS服務的Bucket設定或更新為匹配整個Bucket的生命週期規則，需通過NOT元素排除.dlsdata/，避免因生命週期規則引發的Object刪除或儲存類型轉換行為影響OSS-HDFS資料讀寫。

      p571593..jpeg

    • 在開通了OSS-HDFS服務的Bucket中配置基於HDFS檔案的生命週期規則

      如果您需要對經常訪問的資料以標準類型進行儲存，對於較少訪問的資料以低頻、歸檔以及冷歸檔類型進行儲存，您可以使用基於生命週期規則的冷熱階層式存放區功能實現這一情境。具體操作，請參見冷熱階層式存放區。

    組成元素

    匹配元素

    • 按首碼匹配：按指定首碼匹配Object和片段。可建立多條規則匹配不同的首碼，首碼不能重複。首碼的命名規範與Object命名規範相同，詳情請參見對象（Object）。

    • 按標籤匹配：按指定標籤的Key和Value匹配Object。單條規則可配置多個標籤，OSS對所有擁有這些標籤的對象執行生命週期規則。標籤匹配規則不作用於片段。

      說明

      對象標籤功能詳情請參見對象標籤。

    • 按首碼+標籤匹配：按指定首碼和標籤的篩選條件匹配對象。

    • 配置到整個Bucket：匹配整個Bucket內的所有Object和片段。

    • NOT元素：如果您希望按照生命週期規則對與首碼和標籤匹配的Object進行相應處理的同時，跳過不需要處理的Object，您可以通過NOT元素對不需要處理的Object指定首碼和標籤。關於NOT元素的配置樣本，請參見NOT樣本。

      重要

      一條生命週期規則僅允許配置一個NOT元素。NOT元素下必須配置且僅允許配置一個首碼。此外，NOT元素下可以配置至多一個Object標籤，也可以置空。

    Object的到期時間及操作

    • 到期天數：指定一個到期天數N，並指定非版本狀態下的所有Object、以及版本控制狀態下的目前的版本Object到期後執行什麼操作。Object會在其最後修改時間的N天后到期，並執行指定的操作。

    • 到期日期：指定一個到期日期，並指定非版本狀態下的所有Object、以及版本控制狀態下的目前的版本Object到期後執行什麼操作。最後修改時間在該日期之前的Object全部到期，並執行指定的操作。

    • Object成為非目前的版本天數：指定一個到期天數N，並指定非目前的版本Object到期後執行什麼操作。Object會在其成為非目前的版本的N天后到期，並執行指定的操作。

    您可以轉換到期Object的儲存類型或將其刪除。詳情請參見生命週期配置元素。

    片段的到期時間及操作

    • 到期天數：可指定一個到期天數N，檔案片段會在其最後修改時間的N天后被刪除。

    • 到期日期：指定一個到期日期，最後修改時間在該日期之前的檔案片段會被全部刪除。

    規則說明

    不同首碼

    例如，某個Bucket有如下幾個Object： 

    logs/programl/log1.txt
logs/program2/log2.txt
logs/program3/log3.txt
doc/readme.txt

    如果生命週期規則指定的首碼是logs/，那麼此規則僅作用於前三個以logs/開頭的Object；如果指定的首碼是doc/readme.txt，則此規則則只對doc/readme.txt起作用。

    說明

    您也可以為生命週期規則指定中文首碼。

    對到期策略匹配的Object執行GET或HEAD操作時，OSS會在響應Header中加入x-oss-expiration頭。其中expiry-date的值表示Object的到期日期；rule-id的值表示相匹配的規則ID。

    相同首碼和標籤

    當不同生命週期規則作用於相同首碼和標籤的Object時，刪除操作優先於儲存類型轉換操作。rule1用於指定所有首碼為abc，標籤為a=1的Object 20天后刪除，rule2規則不生效。

    rule

    prefix

    tag

    action

    rule1

    abc

    a=1

    20天后刪除

    rule2

    abc

    a=1

    20天后轉為Archive

    首碼重疊+標籤相同

    rule1用於指定所有標籤為a=1的Object 10天后轉為IA。rule2用於指定首碼為abc且標籤為a=1的Object 120天后刪除。

    rule

    prefix

    tag

    action

    rule1

    -

    a=1

    10天后轉為IA

    rule2

    abc

    a=1

    120天后被刪除

    rule3用於指定所有標籤為a=1的Object 20天后轉為Archive。由於Archive類型檔案無法轉換為IA類型，因此rule4指定的首碼為abc且標籤為a=1的Object 30天后轉為IA的規則不生效。

    rule

    prefix

    tag

    action

    rule3

    -

    a=1

    20天后轉為Archive

    rule4

    abc

    a=1

    30天后轉為IA

    NOT

    對同一個Bucket配置多條生命週期規則，且某條生命週期規則涉及NOT元素時，NOT元素指定的行為只對本條生命週期規則生效。具體樣本如下：

    • 樣本一

      • 通過生命週期規則1，指定examplebucket中首碼為dir/的Object 100天后刪除。

      • 通過生命週期規則2，通過NOT元素指定examplebucket中除首碼為dir/以外的所有Object 50天后刪除。

      以生命週期規則生效時間為起點，examplebucket中Object的刪除行為如下表所示。

      Object

      刪除行為

      首碼為dir/的Object

      100天后刪除

      首碼不為dir/的Object

      50天后刪除

    • 樣本二

      • 通過生命週期規則1，通過NOT元素指定examplebucket內除標籤（key1:value1）以外的所有Object 30天后刪除。

      • 通過生命週期規則2，指定examplebucket內包含標籤（key2:value2）的所有Object 50天后刪除。

      以生命週期規則生效時間為起點，examplebucket內Object的刪除行為如下表所示：

      Object

      刪除行為

      對於未包含以上標籤的所有Object

      30天后刪除

      對於僅包含key1:value1標籤的Object

      不刪除

      對於僅包含key2:value2標籤的Object

      30天后刪除

      對於同時包含key1:value1以及key2:value2標籤的Object

      50天后刪除

    操作步驟

    使用OSS控制台

    1. 登入OSS管理主控台。

    2. 單擊Bucket 列表，然後單擊目標Bucket名稱。

    3. 在左側導覽列， 選擇資料管理 > 生命週期。

    4. 在生命週期頁面，單擊創建規則。

      說明

      如果您僅需要建立基於最後一次修改時間策略的生命週期規則，不需要在生命週期頁面開啟啟用訪問跟蹤開關。開啟訪問跟蹤會產生額外費用。訪問跟蹤適用於建立基於最後一次訪問時間策略的生命週期規則。更多資訊，請參見基於最後一次訪問時間的生命週期規則。

    5. 在建立生命週期規則面板，按如下說明配置生命週期規則。

      • 儲存空間未開啟版本控制

        地區

        配置項

        說明

        基礎設定

        狀態

        設定生命週期規則的狀態，可選擇啟動或禁用。

        • 啟動生命週期規則後，將按照配置的生命週期規則轉換資料存放區類型或刪除資料。

        • 禁用生命週期規則後，將中斷生命週期任務。

        策略

        選擇生命週期規則作用的Object。您可以選擇按首碼匹配或設定到整個Bucket。

        說明

        選擇按首碼匹配時，需要填寫首碼的完整路徑。例如，您希望僅作用於src/dir1下的所有檔案，則首碼需要填寫為src/dir1，僅填寫dir1則不生效。

        是否允許首碼重疊

        OSS預設會檢查各個生命週期規則的首碼是否重疊。例如，您設定了以下兩條包含重疊首碼的生命週期規則：

        • 規則1

          指定該Bucket內所有首碼為dir1/的Object在距離最後一次修改時間180天后刪除。

        • 規則2

          指定該Bucket內所有首碼為dir1/dir2/的Object在距離最後一次修改時間30天后轉低頻訪問類型，60天后刪除。

        在配置規則2時未選中該選項的情況下，因後台檢測到dir1/dir2/目錄下的Object同時匹配兩條刪除規則，因此會拒絕設定規則2，並報錯Overlap for same action type Expiration.。

        在配置規則2時選中該選項的情況下，dir1/dir2/下的Object會在30天后轉低頻訪問類型，60天后刪除。dir1/下的其他Object會在180天刪除。

        說明

        如果配置了多條規則，且其中一條為基於整個Bucket的規則時，會被視為首碼重疊的情況。

        前綴

        輸入規則要匹配的Object名稱的首碼。

        • 首碼設定為img，表示匹配名稱以img開頭的所有Object，例如imgtest.png、img/example.jpg等。

        • 首碼設定為img/，表示匹配名稱以img/開頭的所有Object，例如img/example.jpg、img/test.jpg等。

        標籤

        生命週期規則僅針對擁有指定標籤Object生效。

        • 如果沒有設定首碼，只設定了標籤，且標籤的key為a，value為1。則該規則將匹配Bucket內所有標籤為a=1的Object。

        • 如果設定了首碼，首碼設定為img，同時設定了標籤，標籤的key為a，value為1，則該規則將匹配Bucket內所有名稱以img開頭，標籤為a=1的Object。

        更多資訊，請參見對象標籤。

        NOT

        NOT選項用於設定生命週期規則對指定首碼和標籤的Object不生效。

        重要

        • 開啟NOT選項時，首碼和標籤必須至少存在一項，即同時設定首碼和標籤或者只設定首碼或標籤。

        • NOT語義定義標籤中的key不支援與標籤配置項中定義的key相同。

        • 開啟NOT選項後，不支援設定片段到期策略。

        文件大小

        指定生命週期規則生效的檔案大小。

        • 指定最小檔案：生命週期規則對大於該值的檔案大小生效。取值大於0 B，小於5 TB。

        • 指定最大檔案：生命週期規則對小於該值的檔案大小生效。取值大於0 B，小於等於5 TB。

        重要

        如果在同一條生命週期中，同時配置了指定最小檔案和指定最大檔案：

        • 確保指定最大檔案的值大於指定最小檔案的值。

        • 不支援配置片段執行策略。

        • 不支援配置清除刪除標記策略。

        檔案執行原則設定

        檔案時間策略

        選擇Object到期策略，可選擇指定天數、指定日期和不啟用。選擇不啟用時，檔案到期策略不生效。

        生命週期管理規則

        配置轉換Object儲存類型或者刪除到期Object的規則，可選擇低頻訪問、Archive Storage、冷Archive Storage、深度冷Archive Storage和資料刪除。

        例如，當您將檔案時間策略設定為指定日期，並將日期設定為2023年9月24日，則最後一次修改時間在2023年9月24日之前的Object會被自動刪除，且刪除後不可恢複。

        片段執行原則設定

        碎片過期策略

        配置片段執行策略。如果選中了標籤，則無法配置該選項。您可以選擇按指定天數或指定日期執行片段到期策略，也可以選擇不啟用片段到期策略。當選擇不啟用時，片段到期策略不生效。

        重要

        生命週期規則至少包含檔案到期策略或片段到期策略。

        片段規則

        根據片段到期策略選擇的到期天數或到期日期設定片段何時到期，片段到期後會被自動刪除，且刪除後不可恢複。

      • 儲存空間已開啟版本控制

        開啟版本控制後，基礎設定與片段執行原則設定地區涉及的配置項，與未開啟版本控制的配置方法相同。以下表格僅介紹與未開啟版本控制相比，開啟版本控制後配置項存在的差異。

        地區

        配置項

        說明

        目前的版本檔案執行原則設定

        清理對象刪除標記

        開啟版本控制後，清除策略中增加了清理對象刪除標記選項，其他選項與未開啟版本控制時相同。

        選擇此選項後，如果當前Object僅有一個版本且為刪除標記時，則OSS將刪除到期Object的刪除標記。如果當前Object有多個版本，且Object的最新版本為刪除標記時，則OSS將保留該刪除標記。關於刪除標記的更多資訊，請參見刪除標記。

        重要

        當有歷史版本存在時，該規則不會清理對象刪除標記。因此建議及時清理對象刪除標記和非必要的歷史版本，否則Bucket內因儲存過多的刪除標記，導致List效能下降。

        歷史版本檔案執行原則設定

        檔案時間策略

        設定歷史版本檔案的到期策略，可選擇指定天數和不啟用。當選擇不啟用時，檔案到期策略不生效。

        生命週期管理規則

        設定一個到期天數N，歷史版本的Object會在其被轉換為歷史版本的N天后到期，並在到期的第二天執行指定操作。例如設定為30，則在2023年09月01日被轉為歷史版本的Object會在2023年10月01日被轉換為指定儲存類型或被刪除。

        重要

        您可以通過Object下一個版本的最後一次修改時間確定 Object被轉為歷史版本的時間。

    6. 單擊確定。

      生命週期規則儲存成功後，您可以在策略列表中查看已設定的生命週期規則。

    使用阿里雲SDK

    以下僅列舉常見SDK的配置生命週期規則的程式碼範例。關於其他SDK的配置生命週期規則的程式碼範例，請參見SDK簡介。

    Java

    import com.aliyun.oss.ClientException;
import com.aliyun.oss.OSS;
import com.aliyun.oss.common.auth.*;
import com.aliyun.oss.OSSClientBuilder;
import com.aliyun.oss.OSSException;
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 {
        // Endpoint以華東1（杭州）為例，其它Region請按實際情況填寫。
        String endpoint = "https://oss-cn-hangzhou.aliyuncs.com";
        // 從環境變數中擷取訪問憑證。運行本程式碼範例之前，請確保已設定環境變數OSS_ACCESS_KEY_ID和OSS_ACCESS_KEY_SECRET。
        EnvironmentVariableCredentialsProvider credentialsProvider = CredentialsProviderFactory.newEnvironmentVariableCredentialsProvider();
        // 填寫Bucket名稱，例如examplebucket。
        String bucketName = "examplebucket";

        // 建立OSSClient執行個體。
        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>();
            // 依次填寫要匹配標籤的鍵（例如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天后轉Archive Storage類型。
            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日之前的檔案轉為Archive Storage。
            rule = new LifecycleRule(ruleId5, matchPrefix5, LifecycleRule.RuleStatus.Enabled);
            storageTransitions = new ArrayList<LifecycleRule.StorageTransition>();
            storageTransition = new LifecycleRule.StorageTransition();

            storageTransition.setCreatedBeforeDate(DateUtil.parseIso8601Date("2022-10-12T00:00:00.000Z"));

            storageTransition.setStorageClass(StorageClass.Archive);
            storageTransitions.add(storageTransition);
            rule.setStorageTransition(storageTransitions);
            request.AddLifecycleRule(rule);

            // rule6針對版本控制狀態下的Bucket。
            rule = new LifecycleRule(ruleId6, matchPrefix6, LifecycleRule.RuleStatus.Enabled);
            // 設定Object相對最後修改時間365天之後自動轉為歸檔檔案。
            storageTransitions = new ArrayList<LifecycleRule.StorageTransition>();
            storageTransition = new LifecycleRule.StorageTransition();
            storageTransition.setStorageClass(StorageClass.Archive);
            storageTransition.setExpirationDays(365);
            storageTransitions.add(storageTransition);
            rule.setStorageTransition(storageTransitions);
            // 設定自動移除到期刪除標記。
            rule.setExpiredDeleteMarker(true);
            // 設定非目前的版本的object距最後修改時間10天之後轉為低頻訪問類型。
            LifecycleRule.NoncurrentVersionStorageTransition noncurrentVersionStorageTransition =
                    new LifecycleRule.NoncurrentVersionStorageTransition().withNoncurrentDays(10).withStrorageClass(StorageClass.IA);
            // 設定非目前的版本的Object距最後修改時間20天之後轉為歸檔類型。
            LifecycleRule.NoncurrentVersionStorageTransition noncurrentVersionStorageTransition2 =
                    new LifecycleRule.NoncurrentVersionStorageTransition().withNoncurrentDays(20).withStrorageClass(StorageClass.Archive);
            // 設定非目前的版本Object 30天后刪除。
            LifecycleRule.NoncurrentVersionExpiration noncurrentVersionExpiration = new LifecycleRule.NoncurrentVersionExpiration().withNoncurrentDays(30);
            List<LifecycleRule.NoncurrentVersionStorageTransition> noncurrentVersionStorageTransitions = new ArrayList<LifecycleRule.NoncurrentVersionStorageTransition>();
            noncurrentVersionStorageTransitions.add(noncurrentVersionStorageTransition2);
            rule.setStorageTransition(storageTransitions);
            rule.setNoncurrentVersionExpiration(noncurrentVersionExpiration);
            rule.setNoncurrentVersionStorageTransitions(noncurrentVersionStorageTransitions);
            request.AddLifecycleRule(rule);

            // 發起設定生命週期規則請求。
            ossClient.setBucketLifecycle(request);

            // 查看生命週期規則。
            List<LifecycleRule> listRules = ossClient.getBucketLifecycle(bucketName);
            for(LifecycleRule rules : listRules){
                System.out.println("ruleId="+rules.getId()+", matchPrefix="+rules.getPrefix());
            }
        } catch (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以華東1（杭州）為例，其它Region請按實際情況填寫。
$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,
    );
    $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({
  // yourregion填寫Bucket所在地區。以華東1（杭州）為例，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,
  // 填寫儲存空間名稱。
  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: {
    // 指定目前的版本Object距其最後修改時間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: {
    // 指定目前的版本Object距其最後修改時間20天后轉Archive Storage類型。
    days: 20,
    storageClass: 'Archive'
  },
  expiration: {
    // 指定目前的版本Object距其最後修改時間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/', 
  // 設定非目前的版本的Object距其最後修改時間10天之後轉為低頻訪問類型。
  noncurrentVersionTransition: {
    noncurrentDays: '10',
    storageClass: 'IA'
  }
}
putBucketLifecycle(lifecycle8)

const lifecycle9 = {
  id: 'rule9',
  status: 'Enabled',
  prefix: 'foo/', 
  // 設定非目前的版本的Object距其最後修改時間10天之後轉為低頻訪問類型。
  noncurrentVersionTransition: {
    noncurrentDays: '10',
    storageClass: 'IA'
  },
  // 指定規則所適用的對象標籤。
  tag: [{
    key: 'key1',
    value: 'value1'
  },
   {
     key: 'key2',
     value: 'value2'
   }]
}
putBucketLifecycle(lifecycle9)

    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.ProviderAuth(EnvironmentVariableCredentialsProvider())
# 填寫Bucket所在地區對應的Endpoint。以華東1（杭州）為例，Endpoint填寫為https://oss-cn-hangzhou.aliyuncs.com。
# 填寫Bucket名稱，例如examplebucket。
bucket = oss2.Bucket(auth, 'https://oss-cn-hangzhou.aliyuncs.com', 'examplebucket')

# 設定Object距其最後修改時間3天后到期。
rule1 = LifecycleRule('rule1', 'tests/',
                      status=LifecycleRule.ENABLED,
                      expiration=LifecycleExpiration(days=3))

# 設定Object到期規則，指定日期之前建立的檔案到期。
rule2 = LifecycleRule('rule2', 'tests2/',
                      status=LifecycleRule.ENABLED,
expiration=LifecycleExpiration(created_before_date=datetime.date(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)))

# 設定儲存類型轉換規則，指定Object在其最後修改時間20天之後轉為低頻訪問類型，在其最後修改時間30天之後轉為歸檔類型。
rule5 = LifecycleRule('rule5', 'tests5/',
                      status=LifecycleRule.ENABLED,
                      storage_transitions=[StorageTransition(days=20,storage_class=oss2.BUCKET_STORAGE_CLASS_IA),
                            StorageTransition(days=30,storage_class=oss2.BUCKET_STORAGE_CLASS_ARCHIVE)])

# 設定匹配的標籤。
tagging_rule = TaggingRule()
tagging_rule.add('key1', 'value1')
tagging_rule.add('key2', 'value2')
tagging = Tagging(tagging_rule)

# 設定儲存類型轉換規則，指定Object在其最後修改時間超過365天后轉為ARCHIVE類型。 
# rule6與以上幾個規則不同的是它指定了匹配的標籤，同時擁有key1=value1,key2=value2兩個標籤的object才會匹配此規則。
rule6 = LifecycleRule('rule6', 'tests6/',
                      status=LifecycleRule.ENABLED,
                      storage_transitions=[StorageTransition(created_before_date=datetime.date(2022, 12, 12),storage_class=oss2.BUCKET_STORAGE_CLASS_IA)],
                      tagging = tagging)

# rule7針對版本控制狀態下的Bucket。
# 設定Object在其最後修改時間365天之後自動轉為ARCHIVE類型。
# 設定自動移除到期刪除標記。
# 設定非目前的版本Object 12天后轉為IA類型。
# 設定非目前的版本Object 20天后轉為ARCHIVE類型。
# 設定非目前的版本Object 30天后刪除。
rule7 = LifecycleRule('rule7', 'tests7/',
              status=LifecycleRule.ENABLED,
              storage_transitions=[StorageTransition(days=365, storage_class=oss2.BUCKET_STORAGE_CLASS_ARCHIVE)], 
              expiration=LifecycleExpiration(expired_detete_marker=True),
              noncurrent_version_sotrage_transitions = 
                    [NoncurrentVersionStorageTransition(12, oss2.BUCKET_STORAGE_CLASS_IA),
                     NoncurrentVersionStorageTransition(20, oss2.BUCKET_STORAGE_CLASS_ARCHIVE)],
              noncurrent_version_expiration = NoncurrentVersionExpiration(30))

lifecycle = BucketLifecycle([rule1, rule2, rule3, rule4, rule5, rule6, rule7])

bucket.put_bucket_lifecycle(lifecycle)

    C#

    using Aliyun.OSS;
using Aliyun.OSS.Common;
// 填寫Bucket所在地區對應的Endpoint。以華東1（杭州）為例，Endpoint填寫為https://oss-cn-hangzhou.aliyuncs.com。
var endpoint = "https://oss-cn-hangzhou.aliyuncs.com";
// 從環境變數中擷取訪問憑證。運行本程式碼範例之前，請確保已設定環境變數OSS_ACCESS_KEY_ID和OSS_ACCESS_KEY_SECRET。
var accessKeyId = Environment.GetEnvironmentVariable("OSS_ACCESS_KEY_ID");
var accessKeySecret = Environment.GetEnvironmentVariable("OSS_ACCESS_KEY_SECRET");
// 填寫Bucket名稱，例如examplebucket。
var bucketName = "examplebucket";

// 建立OSSClient執行個體。
var client = new OssClient(endpoint, accessKeyId, accessKeySecret);
try
{
    var setBucketLifecycleRequest = new SetBucketLifecycleRequest(bucketName);
    // 建立第1條生命週期規則。
    LifecycleRule lcr1 = new LifecycleRule()
    {
        ID = "delete obsoleted files",
        Prefix = "obsoleted/",
        Status = RuleStatus.Enabled,
        ExpriationDays = 3,
        Tags = new Tag[1]
    };
    // 設定標籤。
    var tag1 = new Tag
    {
        Key = "project",
        Value = "projectone"
    };

    lcr1.Tags[0] = tag1;

    // 建立第2條生命週期規則。
    LifecycleRule lcr2 = new LifecycleRule()
    {
        ID = "delete temporary files",
        Prefix = "temporary/",
        Status = RuleStatus.Enabled,
        ExpriationDays = 20,
        Tags = new Tag[1]         
    };
    // 設定標籤。
    var tag2 = new Tag
    {
        Key = "user",
        Value = "jsmith"
    };
    lcr2.Tags[0] = tag2;

    // 設定片段在距最後修改時間30天后到期。
    lcr2.AbortMultipartUpload = new LifecycleRule.LifeCycleExpiration()
    {
        Days = 30
    };

    LifecycleRule lcr3 = new LifecycleRule();
    lcr3.ID = "only NoncurrentVersionTransition";
    lcr3.Prefix = "test1";
    lcr3.Status = RuleStatus.Enabled;
    lcr3.NoncurrentVersionTransitions = new LifecycleRule.LifeCycleNoncurrentVersionTransition[2]
    {
        // 設定非目前的版本的Object距最後修改時間90天之後轉為低頻訪問類型。
        new LifecycleRule.LifeCycleNoncurrentVersionTransition(){
            StorageClass = StorageClass.IA,
            NoncurrentDays = 90
        },
        // 設定非目前的版本的Object距最後修改時間180天之後轉為歸檔類型。
        new LifecycleRule.LifeCycleNoncurrentVersionTransition(){
            StorageClass = StorageClass.Archive,
            NoncurrentDays = 180
        }
    };
    setBucketLifecycleRequest.AddLifecycleRule(lcr1);
    setBucketLifecycleRequest.AddLifecycleRule(lcr2);
    setBucketLifecycleRequest.AddLifecycleRule(lcr3);

    // 設定生命週期規則。
    client.SetBucketLifecycle(setBucketLifecycleRequest);
    Console.WriteLine("Set bucket:{0} Lifecycle succeeded ", bucketName);
}
catch (OssException ex)
{
    Console.WriteLine("Failed with error code: {0}; Error info: {1}. \nRequestID:{2}\tHostID:{3}",
        ex.ErrorCode, ex.Message, ex.RequestId, ex.HostId);
}
catch (Exception ex)
{
    Console.WriteLine("Failed with error info: {0}", ex.Message);
}

    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天后自動轉為Archive Storage類型（Archive）
rule1.setArchiveDays("30");
// 未完成分區3天后到期。
rule1.setMultipartDays("3");
// 15天后自動轉為低頻儲存類型（IA）。
rule1.setIADays("15");

BucketLifecycleRule rule2 = new BucketLifecycleRule();
rule2.setIdentifier("2");
rule2.setPrefix("B");
rule2.setStatus(true);
rule2.setDays("300");
rule2.setArchiveDays("30");
rule2.setMultipartDays("3");
rule2.setIADays("15");

ArrayList<BucketLifecycleRule> lifecycleRules = new ArrayList<BucketLifecycleRule>();
lifecycleRules.add(rule1);
lifecycleRules.add(rule2);
request.setLifecycleRules(lifecycleRules);
OSSAsyncTask task = oss.asyncPutBucketLifecycle(request, new OSSCompletedCallback<PutBucketLifecycleRequest, PutBucketLifecycleResult>() {
    @Override
    public void onSuccess(PutBucketLifecycleRequest request, PutBucketLifecycleResult result) {
        OSSLog.logInfo("code::"+result.getStatusCode());

    }

    @Override
    public void onFailure(PutBucketLifecycleRequest request, ClientException clientException, ServiceException serviceException) {
        OSSLog.logError("error: "+serviceException.getRawMessage());

    }
});

task.waitUntilFinished();

    Go

    package main

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執行個體。
	// yourEndpoint填寫Bucket對應的Endpoint，以華東1（杭州）為例，填寫為https://oss-cn-hangzhou.aliyuncs.com。其它Region請按實際情況填寫。
	client, err := oss.New("yourEndpoint", "", "", oss.SetCredentialsProvider(&provider))
	if err != nil {
		fmt.Println("Error:", err)
		os.Exit(-1)
	}
	// 填寫儲存空間名稱。
	bucketName := "examplebucket"
	// 指定生命週期規則1，並在規則中指定首碼為foo的檔案在距離最後一次修改時間3天后到期。
	rule1 := oss.BuildLifecycleRuleByDays("rule1", "foo/", true, 3)

	// 在受版本控制狀態下的Object僅有刪除標記的情況下，自動刪除刪除標記。
	deleteMark := true
	expiration := oss.LifecycleExpiration{
		ExpiredObjectDeleteMarker: &deleteMark,
	}

	// 非目前的版本Object超過30天后到期刪除。
	versionExpiration := oss.LifecycleVersionExpiration{
		NoncurrentDays: 30,
	}

	// 非目前的版本Object超過10天后轉為IA儲存類型。
	versionTransition := oss.LifecycleVersionTransition{
		NoncurrentDays: 10,
		StorageClass:   "IA",
	}

	// 指定生命週期規則2。
	rule2 := oss.LifecycleRule{
		ID:                   "rule2",
		Prefix:               "yourObjectPrefix",
		Status:               "Enabled",
		Expiration:           &expiration,
		NonVersionExpiration: &versionExpiration,
		NonVersionTransitions: []oss.LifecycleVersionTransition{
			versionTransition,
		},
	}

	// 指定生命週期規則3，對標籤鍵為tag1、標籤值為value1的檔案，距檔案最後一次修改時間3天后到期。
	rule3 := oss.LifecycleRule{
		ID:     "rule3",
		Prefix: "",
		Status: "Enabled",
		Tags: []oss.Tag{
			oss.Tag{
				Key:   "tag1",
				Value: "value1",
			},
		},
		Expiration: &oss.LifecycleExpiration{Days: 3},
	}

	// 設定生命週期規則。
	rules := []oss.LifecycleRule{rule1, rule2, rule3}
	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填寫Bucket所在地區對應的Endpoint。以華東1（杭州）為例，Endpoint填寫為https://oss-cn-hangzhou.aliyuncs.com。*/
    std::string Endpoint = "yourEndpoint";
    /*填寫Bucket名稱，例如examplebucket。*/
    std::string BucketName = "examplebucket";

    /*初始化網路等資源。*/
    InitializeSdk();

    ClientConfiguration conf;
    /* 從環境變數中擷取訪問憑證。運行本程式碼範例之前，請確保已設定環境變數OSS_ACCESS_KEY_ID和OSS_ACCESS_KEY_SECRET。*/
    auto credentialsProvider = std::make_shared<EnvironmentVariableCredentialsProvider>();
    OssClient client(Endpoint, credentialsProvider, conf);

    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為針對版本控制狀態下的Bucket的生命週期規則。*/
    auto rule3 = LifecycleRule();
    rule3.setID("rule3");
    rule3.setPrefix("test3/");
    rule3.setStatus(RuleStatus::Disabled);

    /*設定Object距其最後修改時間365天之後自動轉為歸檔類型。*/  
    auto transition = LifeCycleTransition();  
    transition.Expiration().setDays(365);
    transition.setStorageClass(StorageClass::Archive);
    rule3.addTransition(transition);

    /*設定自動移除到期刪除標記。*/
    rule3.setExpiredObjectDeleteMarker(true);

    /*設定非目前的版本的Object距最後修改時間10天之後轉為低頻訪問類型。*/
    auto transition1 = LifeCycleTransition();  
    transition1.Expiration().setDays(10);
    transition1.setStorageClass(StorageClass::IA);

    /*設定非目前的版本的Object距最後修改時間20天之後轉為歸檔類型。*/
    auto transition2 = LifeCycleTransition();  
    transition2.Expiration().setDays(20);
    transition2.setStorageClass(StorageClass::Archive);

    /*設定Object在其成為非目前的版本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填寫Bucket所在地區對應的Endpoint。以華東1（杭州）為例，Endpoint填寫為https://oss-cn-hangzhou.aliyuncs.com。*/
const char *endpoint = "yourEndpoint";
/* 填寫Bucket名稱，例如examplebucket。*/
const char *bucket_name = "examplebucket";
void init_options(oss_request_options_t *options)
{
    options->config = oss_config_create(options->pool);
    /* 用char*類型的字串初始化aos_string_t類型。*/
    aos_str_set(&options->config->endpoint, endpoint);
    /* 從環境變數中擷取訪問憑證。運行本程式碼範例之前，請確保已設定環境變數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表示不使用。*/
    options->config->is_cname = 0;
    /* 用於設定網路相關參數，比如逾時時間等。*/
    options->ctl = aos_http_controller_create(options->pool, 0);
}
int main(int argc, char *argv[])
{
    /* 在程式入口調用aos_http_io_initialize方法來初始化網路、記憶體等全域資源。*/
    if (aos_http_io_initialize(NULL, 0) != AOSE_OK) {
        exit(1);
    }
    /* 用於記憶體管理的記憶體池（pool），等價於apr_pool_t。其實現代碼在apr庫中。*/
    aos_pool_t *pool;
    /* 重新建立一個記憶體池，第二個參數是NULL，表示沒有繼承其它記憶體池。*/
    aos_pool_create(&pool, NULL);
    /* 建立並初始化options，該參數包括endpoint、access_key_id、acces_key_secret、is_cname、curl等全域配置資訊。*/
    oss_request_options_t *oss_client_options;
    /* 在記憶體池中分配記憶體給options。*/
    oss_client_options = oss_request_options_create(pool);
    /* 初始化Client的選項oss_client_options。*/
    init_options(oss_client_options);
    /* 初始化參數。*/
    aos_string_t bucket;
    aos_table_t *resp_headers = NULL; 
    aos_status_t *resp_status = NULL; 
    aos_str_set(&bucket, bucket_name);
    aos_list_t lifecycle_rule_list;   
    aos_str_set(&bucket, bucket_name);
    aos_list_init(&lifecycle_rule_list);
    /* 指定到期天數。*/
    oss_lifecycle_rule_content_t *rule_content_days = oss_create_lifecycle_rule_content(pool);
    aos_str_set(&rule_content_days->id, "rule-1");
    /* 設定檔案首碼。*/
    aos_str_set(&rule_content_days->prefix, "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以華東1（杭州）為例，其它Region請按實際情況填寫。
  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名稱。
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設定生命週期規則的具體操作， 請參見添加或修改生命週期規則。

    使用REST API

    如果您的程式自訂要求較高，您可以直接發起REST API請求。直接發起REST API請求需要手動編寫代碼計算簽名。更多資訊，請參見PutBucketLifecycle。

    常見問題

    報錯Set bucket lifecycle error, InvalidArgument, Days in the Transition action for StorageClass Archive must be more than the Transition action for StorageClass IA怎麼辦？

    出現該報錯的原因是不同儲存類型的轉儲時間不滿足指定要求。當Bucket同時配置了轉換為低頻訪問、轉換為Archive Storage、轉換為冷Archive Storage以及轉換為深度冷Archive Storage的策略時，其轉換周期必須滿足以下條件：

    轉換為低頻訪問的周期<轉換為歸檔的周期<轉換為冷歸檔的周期<轉換為深度冷歸檔的周期

    生命週期規則是否作用於Bucket內已有的存量Object？

    生命週期規則同時作用於配置規則前Bucket內已有的存量Object，同時也作用於配置生命週期規則後上傳的Object。例如，您在10月07日配置了生命週期規則，指定距離Object最後一次修改時間30天后刪除，則10月5日內上傳的Object將在11月6日開始執行刪除操作。而10月08日上傳的Object將在11月09日執行刪除操作。

    如何修改其中一條或多條生命週期規則配置？

    假設您的Bucket配置了兩條生命週期規則，分別為Rule1和Rule2，您希望修改Rule1的某個配置項，您需要執行以下操作。

    1. 調用GetBucketLifecycle介面擷取當前Bucket配置的所有生命週期規則，即Rule1和Rule2。

    2. 修改Rule1生命週期規則的配置項。

    3. 調用PutBucketLifecycle介面更新生命週期規則為Rule1+Rule2。

    如何刪除其中一條或多條生命週期規則？

    調用DeleteBucketLifecycle時會一鍵刪除Bucket配置的所有生命週期規則。假設您的Bucket配置了兩條生命週期規則，分別為Rule1和Rule2，您僅希望刪除Rule1，您需要執行以下操作。

    1. 調用GetBucketLifecycle介面擷取當前Bucket配置的所有生命週期規則，即Rule1和Rule2。

    2. 刪除Rule1。

    3. 調用PutBucketLifecycle介面更新生命週期規則為Rule2。

    通過生命週期規則進行的類型轉換、到期刪除操作，是否有日誌記錄？

    所有成功通過生命週期規則進行的類型轉換、到期刪除操作都會有日誌記錄，記錄欄位如下：

    • Operation

      • CommitTransition：通過生命週期規則轉換儲存類型，例如轉換為低頻訪問、歸檔或冷Archive Storage類型。

      • ExpireObject：通過生命週期規則刪除到期Object。

    • Sync Request

      lifecycle：生命週期規則引發的轉換儲存類型和刪除到期Object的操作。

    關於OSS日誌欄位的更多資訊，請參見日誌欄位詳情。關於日誌查詢的費用說明，請參見計費說明。

    是否支援建立一條生命週期規則同時清理對象刪除標記和目前的版本對象？

    不支援。您可以先建立一條生命週期規則，清理對象刪除標記。 清理對象刪除標記後，再建立一條生命週期規則，刪除目前的版本對象。

    基於最後一次修改時間的生命週期規則是否支援將Object從低頻訪問類型轉換為標準類型？

    不支援。您可以通過以下方式將Object從低頻訪問類型轉為標準類型：

    • 通過CopyObject的方式

      CopyObject介面支援將單個Object從低頻訪問類型轉為標準類型。

    • 通過ossutil工具

      ossutil支援通過set-meta命令添加X-Oss-Storage-Class選項的方式將單個或多個Object從低頻訪問類型轉換為標準類型。具體操作，請參見設定或更新中繼資料。

    相關文檔

    • 預設情況下，OSS會將Object的上傳時間置為其最後一次修改時間。通過生命週期轉換檔儲存類型的操作不會更新Object的最後一次修改時間。具體哪些操作會影響Object的LastModified，請參見哪些操作會更新Object的LastModified？。

    • 當低頻訪問、歸檔、冷歸檔或者深度冷Archive Storage類型Object在儲存不足規定時間長度時轉換了儲存類型並提前刪除時，需要收取不足規定時間長度容量費用。更多資訊，請參見Object在儲存不足規定時間長度時如何計費？。

    • 生命週期規則僅支援對整個Bucket或與首碼匹配的資料進行批量轉儲或者刪除，如果您希望刪除大量刪除指定尾碼的資料，您可以使用ossutil rm命令。

    • 如果您希望OSS自動監測資料的訪問模式並識別冷資料，然後將識別出來的冷資料進行儲存類型的轉換，從而達到資料的冷熱階層式存放區，最終降低儲存成本，您需要配置基於最後一次訪問時間的生命週期規則。

    • 如果您希望查看Bucket內所有Object的儲存類型，請參見列舉檔案。