并不是所有上傳至OSS的數據都需要頻繁訪問，但基于數據合規或者存檔等原因，部分數據仍需要繼續保存。或者基于業務使用場景，希望批量刪除Bucket內不再需要保存的數據。您可以配置基于最后一次修改時間（Last Modified Time）的生命周期規則，定期將Object從熱存儲類型轉為冷存儲類型，或者刪除Object，以降低存儲成本。
使用場景
某醫療機構的醫療檔案，上傳至OSS后半年內需要偶爾訪問，半年后基本不再訪問。可以通過設置生命周期規則，將已上傳180天的醫療檔案轉為歸檔存儲。
某公司服務熱線的錄音文件，上傳至OSS后2個月內，需要作為數據統計及核查的依據，2個月后偶爾訪問，半年后基本不再訪問，2年后數據不再需要存儲。可以通過設置生命周期規則，設置錄音文件上傳60天后轉為低頻訪問存儲，180天后轉為歸檔存儲，730天后刪除。
某Bucket內有大量文件需要全部刪除，但是手動刪除每次僅可以刪除最多1000個文件，比較麻煩。此時可以配置一條匹配整個Bucket的生命周期規則，設置一天后刪除所有文件。此Bucket內的數據會在第二天被全部刪除。
關于存儲類型的介紹，請參見存儲類型概述。
使用限制
地域屬性限制
由于無地域屬性存儲空間僅支持標準存儲類型文件，因此基于最后一次修改時間的生命周期規則作用于無地域屬性存儲空間時，僅執行刪除操作，不涉及存儲類型轉換操作。
匹配條件
生命周期規則目前僅支持根據前綴和標簽進行匹配，不支持通配符匹配、后綴匹配以及正則匹配。
碎片過期限制
不支持對重疊前綴的Object設置兩條或兩條以上包含碎片過期策略的生命周期規則。示例如下：
示例一
您對整個Bucket設置了一條包含碎片過期策略的生命周期規則，則不支持對Bucket中任意前綴的Object再設置一條包含碎片過期策略的生命周期規則。
示例二
您對某個Bucket中前綴為dir1設置了一條包含碎片過期策略的生命周期規則，則不支持對該Bucket中包含重疊前綴（例如dir1/dir2）的Object再設置一條包含碎片過期策略的生命周期規則。
存儲類型轉換限制
不支持通過生命周期規則將追加上傳生成的Appendable類型的Object轉換為冷歸檔存儲或者深度冷歸檔存儲類型。
不支持通過生命周期規則將軟鏈接（symlink）轉換為低頻訪問、歸檔、冷歸檔以及深度冷歸檔存儲類型。
注意事項
規則數量
單個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數據讀寫。
在開通了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控制臺
登錄OSS管理控制臺。
單擊Bucket 列表，然后單擊目標Bucket名稱。
在左側導航欄， 選擇。
在生命周期頁面，單擊創建規則。
說明如果您僅需要創建基于最后一次修改時間策略的生命周期規則，不需要在生命周期頁面打開啟用訪問跟蹤開關。開啟訪問跟蹤會產生額外費用。訪問跟蹤適用于創建基于最后一次訪問時間策略的生命周期規則。更多信息，請參見基于最后一次訪問時間的生命周期規則。
在創建生命周期規則面板，按如下說明配置生命周期規則。
存儲空間未開啟版本控制
區域
配置項
說明
基礎設置
狀態
設置生命周期規則的狀態，可選擇啟動或禁用。
啟動生命周期規則后，將按照配置的生命周期規則轉換數據存儲類型或刪除數據。
禁用生命周期規則后，將中斷生命周期任務。
策略
選擇生命周期規則作用的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的規則，可選擇低頻訪問、歸檔存儲、冷歸檔存儲、深度冷歸檔存儲和數據刪除。
例如，當您將文件時間策略設置為指定日期，并將日期設置為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被轉為歷史版本的時間。
單擊確定。
生命周期規則保存成功后，您可以在策略列表中查看已設置的生命周期規則。
使用阿里云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天后轉歸檔存儲類型。
rule = new LifecycleRule(ruleId4, matchPrefix4, LifecycleRule.RuleStatus.Enabled);
List<LifecycleRule.StorageTransition> storageTransitions = new ArrayList<LifecycleRule.StorageTransition>();
LifecycleRule.StorageTransition storageTransition = new LifecycleRule.StorageTransition();
storageTransition.setStorageClass(StorageClass.IA);
storageTransition.setExpirationDays(10);
storageTransitions.add(storageTransition);
storageTransition = new LifecycleRule.StorageTransition();
storageTransition.setStorageClass(StorageClass.Archive);
storageTransition.setExpirationDays(30);
storageTransitions.add(storageTransition);
rule.setStorageTransition(storageTransitions);
request.AddLifecycleRule(rule);
// 指定最后修改日期在2022年10月12日之前的文件轉為歸檔存儲。
rule = new LifecycleRule(ruleId5, matchPrefix5, LifecycleRule.RuleStatus.Enabled);
storageTransitions = new ArrayList<LifecycleRule.StorageTransition>();
storageTransition = new LifecycleRule.StorageTransition();
storageTransition.setCreatedBeforeDate(DateUtil.parseIso8601Date("2022-10-12T00:00:00.000Z"));
storageTransition.setStorageClass(StorageClass.Archive);
storageTransitions.add(storageTransition);
rule.setStorageTransition(storageTransitions);
request.AddLifecycleRule(rule);
// rule6針對版本控制狀態下的Bucket。
rule = new LifecycleRule(ruleId6, matchPrefix6, LifecycleRule.RuleStatus.Enabled);
// 設置Object相對最后修改時間365天之后自動轉為歸檔文件。
storageTransitions = new ArrayList<LifecycleRule.StorageTransition>();
storageTransition = new LifecycleRule.StorageTransition();
storageTransition.setStorageClass(StorageClass.Archive);
storageTransition.setExpirationDays(365);
storageTransitions.add(storageTransition);
rule.setStorageTransition(storageTransitions);
// 設置自動移除過期刪除標記。
rule.setExpiredDeleteMarker(true);
// 設置非當前版本的object距最后修改時間10天之后轉為低頻訪問類型。
LifecycleRule.NoncurrentVersionStorageTransition noncurrentVersionStorageTransition =
new LifecycleRule.NoncurrentVersionStorageTransition().withNoncurrentDays(10).withStrorageClass(StorageClass.IA);
// 設置非當前版本的Object距最后修改時間20天之后轉為歸檔類型。
LifecycleRule.NoncurrentVersionStorageTransition noncurrentVersionStorageTransition2 =
new LifecycleRule.NoncurrentVersionStorageTransition().withNoncurrentDays(20).withStrorageClass(StorageClass.Archive);
// 設置非當前版本Object 30天后刪除。
LifecycleRule.NoncurrentVersionExpiration noncurrentVersionExpiration = new LifecycleRule.NoncurrentVersionExpiration().withNoncurrentDays(30);
List<LifecycleRule.NoncurrentVersionStorageTransition> noncurrentVersionStorageTransitions = new ArrayList<LifecycleRule.NoncurrentVersionStorageTransition>();
noncurrentVersionStorageTransitions.add(noncurrentVersionStorageTransition2);
rule.setStorageTransition(storageTransitions);
rule.setNoncurrentVersionExpiration(noncurrentVersionExpiration);
rule.setNoncurrentVersionStorageTransitions(noncurrentVersionStorageTransitions);
request.AddLifecycleRule(rule);
// 發起設置生命周期規則請求。
ossClient.setBucketLifecycle(request);
// 查看生命周期規則。
List<LifecycleRule> listRules = ossClient.getBucketLifecycle(bucketName);
for(LifecycleRule rules : listRules){
System.out.println("ruleId="+rules.getId()+", matchPrefix="+rules.getPrefix());
}
} catch (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天后轉歸檔存儲類型。
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）
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同時配置了轉換為低頻訪問、轉換為歸檔存儲、轉換為冷歸檔存儲以及轉換為深度冷歸檔存儲的策略時，其轉換周期必須滿足以下條件：
轉換為低頻訪問的周期<轉換為歸檔的周期<轉換為冷歸檔的周期<轉換為深度冷歸檔的周期
生命周期規則是否作用于Bucket內已有的存量Object？
生命周期規則同時作用于配置規則前Bucket內已有的存量Object，同時也作用于配置生命周期規則后上傳的Object。例如，您在10月07日配置了生命周期規則，指定距離Object最后一次修改時間30天后刪除，則10月5日內上傳的Object將在11月6日開始執行刪除操作。而10月08日上傳的Object將在11月09日執行刪除操作。
如何修改其中一條或多條生命周期規則配置？
假設您的Bucket配置了兩條生命周期規則，分別為Rule1和Rule2，您希望修改Rule1的某個配置項，您需要執行以下操作。
調用GetBucketLifecycle接口獲取當前Bucket配置的所有生命周期規則，即Rule1和Rule2。
修改Rule1生命周期規則的配置項。
調用PutBucketLifecycle接口更新生命周期規則為Rule1+Rule2。
如何刪除其中一條或多條生命周期規則？
調用DeleteBucketLifecycle時會一鍵刪除Bucket配置的所有生命周期規則。假設您的Bucket配置了兩條生命周期規則，分別為Rule1和Rule2，您僅希望刪除Rule1，您需要執行以下操作。
調用GetBucketLifecycle接口獲取當前Bucket配置的所有生命周期規則，即Rule1和Rule2。
刪除Rule1。
調用PutBucketLifecycle接口更新生命周期規則為Rule2。
通過生命周期規則進行的類型轉換、過期刪除操作，是否有日志記錄？
是否支持創建一條生命周期規則同時清理對象刪除標記和當前版本對象？
不支持。您可以先創建一條生命周期規則，清理對象刪除標記。 清理對象刪除標記后，再創建一條生命周期規則，刪除當前版本對象。
基于最后一次修改時間的生命周期規則是否支持將Object從低頻訪問類型轉換為標準類型？
不支持。您可以通過以下方式將Object從低頻訪問類型轉為標準類型：
通過CopyObject的方式
CopyObject接口支持將單個Object從低頻訪問類型轉為標準類型。
通過ossutil工具
ossutil支持通過set-meta命令添加X-Oss-Storage-Class選項的方式將單個或多個Object從低頻訪問類型轉換為標準類型。具體操作，請參見設置或更新元數據。
相關文檔
默認情況下，OSS會將Object的上傳時間置為其最后一次修改時間。通過生命周期轉換文件存儲類型的操作不會更新Object的最后一次修改時間。具體哪些操作會影響Object的LastModified，請參見哪些操作會更新Object的LastModified？。
當低頻訪問、歸檔、冷歸檔或者深度冷歸檔存儲類型Object在存儲不足規定時長時轉換了存儲類型并提前刪除時，需要收取不足規定時長容量費用。更多信息，請參見Object在存儲不足規定時長時如何計費？。
生命周期規則僅支持對整個Bucket或與前綴匹配的數據進行批量轉儲或者刪除，如果您希望刪除批量刪除指定后綴的數據，您可以使用ossutil rm命令。
如果您希望OSS自動監測數據的訪問模式并識別冷數據，然后將識別出來的冷數據進行存儲類型的轉換，從而達到數據的冷熱分層存儲，最終降低存儲成本，您需要配置基于最后一次訪問時間的生命周期規則。
如果您希望查看Bucket內所有Object的存儲類型，請參見列舉文件。