Object Storage Service：Mengonversi kelas penyimpanan objek

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 {
        // Endpoint wilayah Tiongkok (Hangzhou) digunakan dalam contoh ini. Tentukan endpoint sebenarnya.
        String endpoint = "https://oss-cn-hangzhou.aliyuncs.com";
        // Dapatkan kredensial akses dari variabel lingkungan. Sebelum menjalankan kode contoh, pastikan variabel lingkungan OSS_ACCESS_KEY_ID dan OSS_ACCESS_KEY_SECRET telah dikonfigurasi.
        EnvironmentVariableCredentialsProvider credentialsProvider = CredentialsProviderFactory.newEnvironmentVariableCredentialsProvider();
        // Tentukan nama bucket. Contoh: examplebucket.
        String bucketName = "examplebucket";
        // Tentukan wilayah tempat bucket berada. Misalnya, jika bucket berada di wilayah Tiongkok (Hangzhou), atur wilayah ke cn-hangzhou.
        String region = "cn-hangzhou";

        // Buat instance OSSClient.
        // Saat instance OSSClient tidak lagi digunakan, panggil metode shutdown untuk melepaskan sumber daya.
        ClientBuilderConfiguration clientBuilderConfiguration = new ClientBuilderConfiguration();
        clientBuilderConfiguration.setSignatureVersion(SignVersion.V4);        
        OSS ossClient = OSSClientBuilder.create()
        .endpoint(endpoint)
        .credentialsProvider(credentialsProvider)
        .clientConfiguration(clientBuilderConfiguration)
        .region(region)               
        .build();

        try {
            // Buat SetBucketLifecycleRequest.
            SetBucketLifecycleRequest request = new SetBucketLifecycleRequest(bucketName);

            // Atur ID aturan.
            String ruleId0 = "rule0";
            // Atur awalan yang cocok dengan aturan.
            String matchPrefix0 = "A0/";
            // Atur tag yang cocok dengan aturan.
            Map<String, String> matchTags0 = new HashMap<String, String>();
            // Tentukan kunci (misalnya, owner) dan nilai (misalnya, John) dari tag yang akan dicocokkan.
            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/";

            // Hapus objek 3 hari setelah terakhir dimodifikasi.
            LifecycleRule rule = new LifecycleRule(ruleId0, matchPrefix0, LifecycleRule.RuleStatus.Enabled, 3);
            rule.setTags(matchTags0);
            request.AddLifecycleRule(rule);

            // Hapus objek yang dibuat sebelum tanggal tertentu.
            rule = new LifecycleRule(ruleId1, matchPrefix1, LifecycleRule.RuleStatus.Enabled);
            rule.setCreatedBeforeDate(DateUtil.parseIso8601Date("2022-10-12T00:00:00.000Z"));
            rule.setTags(matchTags1);
            request.AddLifecycleRule(rule);

            // Hapus bagian 3 hari setelah dibuat.
            rule = new LifecycleRule(ruleId2, matchPrefix2, LifecycleRule.RuleStatus.Enabled);
            LifecycleRule.AbortMultipartUpload abortMultipartUpload = new LifecycleRule.AbortMultipartUpload();
            abortMultipartUpload.setExpirationDays(3);
            rule.setAbortMultipartUpload(abortMultipartUpload);
            request.AddLifecycleRule(rule);

            // Hapus bagian yang dibuat sebelum tanggal tertentu.
            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);

            // Ubah kelas penyimpanan objek menjadi Infrequent Access (IA) 10 hari setelah objek terakhir dimodifikasi, dan ubah kelas penyimpanan menjadi Archive Storage 30 hari setelah objek terakhir dimodifikasi.
            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);

            // Ubah kelas penyimpanan objek yang terakhir dimodifikasi sebelum 12 Oktober 2022 menjadi 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 berlaku untuk bucket yang memiliki pengendalian versi diaktifkan.
            rule = new LifecycleRule(ruleId6, matchPrefix6, LifecycleRule.RuleStatus.Enabled);
            // Secara otomatis mengubah objek menjadi objek arsip 365 hari setelah terakhir dimodifikasi.
            storageTransitions = new ArrayList<LifecycleRule.StorageTransition>();
            storageTransition = new LifecycleRule.StorageTransition();
            storageTransition.setStorageClass(StorageClass.Archive);
            storageTransition.setExpirationDays(365);
            storageTransitions.add(storageTransition);
            rule.setStorageTransition(storageTransitions);
            // Secara otomatis menghapus penanda hapus yang kedaluwarsa.
            rule.setExpiredDeleteMarker(true);
            // Mengubah kelas penyimpanan versi non-saat ini dari objek menjadi Infrequent Access 10 hari setelah objek terakhir dimodifikasi.
            LifecycleRule.NoncurrentVersionStorageTransition noncurrentVersionStorageTransition =
                    new LifecycleRule.NoncurrentVersionStorageTransition().withNoncurrentDays(10).withStrorageClass(StorageClass.IA);
            // Mengubah kelas penyimpanan versi non-saat ini dari objek menjadi Archive Storage 20 hari setelah objek terakhir dimodifikasi.
            LifecycleRule.NoncurrentVersionStorageTransition noncurrentVersionStorageTransition2 =
                    new LifecycleRule.NoncurrentVersionStorageTransition().withNoncurrentDays(20).withStrorageClass(StorageClass.Archive);
            // Menghapus versi non-saat ini dari objek setelah 30 hari.
            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);

            // Ajukan permintaan untuk menetapkan aturan siklus hidup.
            ossClient.setBucketLifecycle(request);

            // Lihat aturan siklus hidup.
            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("Tangkap OSSException, yang berarti permintaan Anda sampai ke OSS, "
                    + "tetapi ditolak dengan respons kesalahan karena alasan tertentu.");
            System.out.println("Pesan Kesalahan:" + oe.getErrorMessage());
            System.out.println("Kode Kesalahan:" + oe.getErrorCode());
            System.out.println("ID Permintaan:" + oe.getRequestId());
            System.out.println("ID Host:" + oe.getHostId());
        } catch (ClientException ce) {
            System.out.println("Tangkap ClientException, yang berarti klien mengalami "
                    + "masalah internal serius saat mencoba berkomunikasi dengan OSS, "
                    + "seperti tidak dapat mengakses jaringan.");
            System.out.println("Pesan Kesalahan:" + 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;
use OSS\Model\LifecycleConfig;
use OSS\Model\LifecycleRule;
use OSS\Model\LifecycleAction;

// Dapatkan kredensial akses dari variabel lingkungan. Sebelum menjalankan kode contoh, pastikan variabel lingkungan OSS_ACCESS_KEY_ID dan OSS_ACCESS_KEY_SECRET telah dikonfigurasi. 
$provider = new EnvironmentVariableCredentialsProvider();
// Dalam contoh ini, endpoint wilayah Tiongkok (Hangzhou) digunakan. Tentukan endpoint sebenarnya. 
$endpoint = "https://oss-cn-hangzhou.aliyuncs.com";
// Tentukan nama bucket. 
$bucket= "examplebucket";

// Tentukan ID aturan dan awalan yang terkandung dalam nama objek yang cocok dengan aturan. 
$ruleId0 = "rule0";
$matchPrefix0 = "A0/";
$ruleId1 = "rule1";
$matchPrefix1 = "A1/";

$lifecycleConfig = new LifecycleConfig();
$actions = array();
// Tentukan bahwa objek kedaluwarsa tiga hari setelah terakhir dimodifikasi. 
$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();
// Tentukan bahwa objek yang dibuat sebelum tanggal tertentu kedaluwarsa. 
$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__ . ": GAGAL\n");
    printf($e->getMessage() . "\n");
    return;
}
print(__FUNCTION__ . ": OK" . "\n");

const OSS = require('ali-oss')

const client = new OSS({
  // Tentukan wilayah tempat bucket berada. Misalnya, jika bucket berada di wilayah Tiongkok (Hangzhou), atur wilayah ke oss-cn-hangzhou. 
  region: 'yourregion',
  // Dapatkan kredensial akses dari variabel lingkungan. Sebelum menjalankan kode contoh, pastikan variabel lingkungan OSS_ACCESS_KEY_ID dan OSS_ACCESS_KEY_SECRET telah dikonfigurasi. 
  accessKeyId: process.env.OSS_ACCESS_KEY_ID,
  accessKeySecret: process.env.OSS_ACCESS_KEY_SECRET,
  authorizationV4: true,
  // Tentukan nama bucket. 
  bucket: 'yourbucketname'
});

async function getBucketLifecycle () {
  try {
    const result = await client.getBucketLifecycle('Yourbucketname');
    console.log(result.rules); // Kueri aturan siklus hidup. 

    rules.forEach(rule => {
      console.log(rule.id) // Kueri ID aturan.  
      console.log(rule.status) // Kueri status aturan. 
      console.log(rule.tags) // Kueri tag yang dikonfigurasikan dalam aturan siklus hidup. 
      console.log(rule.expiration.days) // Kueri konfigurasi periode validitas. 
      console.log(rule.expiration.createdBeforeDate) // Kueri konfigurasi tanggal kedaluwarsa. 
      // Kueri aturan untuk bagian yang kedaluwarsa.
      console.log(rule.abortMultipartUpload.days || rule.abortMultipartUpload.createdBeforeDate)
      // Kueri aturan konversi kelas penyimpanan. 
      console.log(rule.transition.days || rule.transition.createdBeforeDate) // Kueri konfigurasi tanggal konversi. 
      console.log(rule.transition.storageClass) // Kueri konfigurasi yang digunakan untuk mengonversi kelas penyimpanan. 
      // Kueri aturan siklus hidup untuk memeriksa apakah penanda hapus yang kedaluwarsa dihapus secara otomatis. 
      console.log(rule.transition.expiredObjectDeleteMarker)
      // Kueri konfigurasi yang digunakan untuk mengonversi kelas penyimpanan versi sebelumnya dari objek. 
      console.log(rule.noncurrentVersionTransition.noncurrentDays) // Kueri konfigurasi tanggal konversi untuk objek versi sebelumnya. 
      console.log(rule.noncurrentVersionTransition.storageClass) // Kueri konfigurasi yang digunakan untuk mengonversi kelas penyimpanan versi sebelumnya dari objek. 
    })
  } catch (e) {
    console.log(e);
  }
}
getBucketLifecycle();

# -*- 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)

# Dapatkan kredensial akses dari variabel lingkungan. Sebelum menjalankan kode contoh, pastikan variabel lingkungan OSS_ACCESS_KEY_ID dan OSS_ACCESS_KEY_SECRET telah dikonfigurasi. 
auth = oss2.ProviderAuthV4(EnvironmentVariableCredentialsProvider())

# Tentukan endpoint wilayah tempat bucket berada. Misalnya, jika bucket berada di wilayah Tiongkok (Hangzhou), atur endpoint ke https://oss-cn-hangzhou.aliyuncs.com. 
endpoint = "https://oss-cn-hangzhou.aliyuncs.com"
# Tentukan ID wilayah yang sesuai dengan endpoint. Contoh: cn-hangzhou. Parameter ini diperlukan jika Anda menggunakan algoritma tanda tangan V4.
region = "cn-hangzhou"

# Tentukan nama bucket.
bucket = oss2.Bucket(auth, endpoint, "examplebucket", region=region)

# Tentukan bahwa objek kedaluwarsa tiga hari setelah terakhir dimodifikasi. 
rule1 = LifecycleRule('rule1', 'tests/',
                      status=LifecycleRule.ENABLED,
                      expiration=LifecycleExpiration(days=3))

# Tentukan bahwa objek yang dibuat sebelum tanggal tertentu kedaluwarsa. 
rule2 = LifecycleRule('rule2', 'tests2/',
                      status=LifecycleRule.ENABLED,
expiration = LifecycleExpiration(created_before_date=datetime.date(2023, 12, 12)))

# Tentukan bahwa bagian kedaluwarsa tiga hari setelah terakhir dimodifikasi. 
rule3 = LifecycleRule('rule3', 'tests3/',
                      status=LifecycleRule.ENABLED,
            abort_multipart_upload=AbortMultipartUpload(days=3))

# Tentukan bahwa bagian yang dibuat sebelum tanggal tertentu kedaluwarsa. 
rule4 = LifecycleRule('rule4', 'tests4/',
                      status=LifecycleRule.ENABLED,
                      abort_multipart_upload = AbortMultipartUpload(created_before_date=datetime.date(2022, 12, 12)))

# Tentukan bahwa kelas penyimpanan objek diubah menjadi Infrequent Access (IA) 20 hari setelah terakhir dimodifikasi, dan menjadi Arsip 30 hari setelah terakhir dimodifikasi. 
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)])

# Tentukan tag yang ingin Anda cocokkan dengan aturan siklus hidup. 
tagging_rule = TaggingRule()
tagging_rule.add('key1', 'value1')
tagging_rule.add('key2', 'value2')
tagging = Tagging(tagging_rule)

# Tentukan bahwa kelas penyimpanan objek diubah menjadi Arsip 365 hari setelah terakhir dimodifikasi.  
# Dibandingkan dengan aturan sebelumnya, rule6 mencakup kondisi tag untuk mencocokkan objek. Aturan ini berlaku untuk objek yang konfigurasi tag-nya adalah key1=value1 dan 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 adalah aturan siklus hidup yang berlaku untuk bucket yang memiliki pengendalian versi diaktifkan. 
# Tentukan bahwa kelas penyimpanan objek diubah menjadi Arsip 365 hari setelah terakhir dimodifikasi. 
# Tentukan bahwa penanda hapus dihapus secara otomatis saat kedaluwarsa. 
# Tentukan bahwa kelas penyimpanan objek diubah menjadi IA 12 hari setelah menjadi versi sebelumnya. 
# Tentukan bahwa kelas penyimpanan objek diubah menjadi Arsip 20 hari setelah menjadi versi sebelumnya. 
# Tentukan bahwa objek dihapus 30 hari setelah menjadi versi sebelumnya. 
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)

using Aliyun.OSS;
using Aliyun.OSS.Common;
// Tentukan endpoint wilayah tempat bucket berada. Misalnya, jika bucket berada di wilayah Tiongkok (Hangzhou), atur endpoint ke https://oss-cn-hangzhou.aliyuncs.com. 
var endpoint = "https://oss-cn-hangzhou.aliyuncs.com";
// Dapatkan kredensial akses dari variabel lingkungan. Sebelum menjalankan kode contoh, pastikan variabel lingkungan OSS_ACCESS_KEY_ID dan OSS_ACCESS_KEY_SECRET telah dikonfigurasi. 
var accessKeyId = Environment.GetEnvironmentVariable("OSS_ACCESS_KEY_ID");
var accessKeySecret = Environment.GetEnvironmentVariable("OSS_ACCESS_KEY_SECRET");
// Tentukan nama bucket. Contoh: examplebucket. 
var bucketName = "examplebucket";
// Tentukan wilayah tempat bucket berada. Misalnya, jika bucket berada di wilayah Tiongkok (Hangzhou), atur wilayah ke cn-hangzhou.
const string region = "cn-hangzhou";

// Buat instance ClientConfiguration dan modifikasi parameter default berdasarkan kebutuhan Anda.
var conf = new ClientConfiguration();

// Gunakan algoritma tanda tangan V4.
conf.SignatureVersion = SignatureVersion.V4;

// Buat instance OSSClient.
var client = new OssClient(endpoint, accessKeyId, accessKeySecret, conf);
client.SetRegion(region);
try
{
    var setBucketLifecycleRequest = new SetBucketLifecycleRequest(bucketName);
    // Buat aturan siklus hidup pertama. 
    LifecycleRule lcr1 = new LifecycleRule()
    {
        ID = "delete obsoleted files",
        Prefix = "obsoleted/",
        Status = RuleStatus.Enabled,
        ExpriationDays = 3,
        Tags = new Tag[1]
    };
    // Tentukan tag untuk aturan. 
    var tag1 = new Tag
    {
        Key = "project",
        Value = "projectone"
    };

    lcr1.Tags[0] = tag1;

    // Buat aturan siklus hidup kedua. 
    LifecycleRule lcr2 = new LifecycleRule()
    {
        ID = "delete temporary files",
        Prefix = "temporary/",
        Status = RuleStatus.Enabled,
        ExpriationDays = 20,
        Tags = new Tag[1]         
    };
    // Tentukan tag untuk aturan. 
    var tag2 = new Tag
    {
        Key = "user",
        Value = "jsmith"
    };
    lcr2.Tags[0] = tag2;

    // Tentukan bahwa bagian kedaluwarsa 30 hari setelah terakhir dimodifikasi. 
    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]
    {
        // Tentukan bahwa kelas penyimpanan versi sebelumnya dari objek diubah menjadi IA 90 hari setelah terakhir dimodifikasi. 
        new LifecycleRule.LifeCycleNoncurrentVersionTransition(){
            StorageClass = StorageClass.IA,
            NoncurrentDays = 90
        },
        // Tentukan bahwa kelas penyimpanan versi sebelumnya dari objek diubah menjadi Arsip 180 hari setelah terakhir dimodifikasi. 
        new LifecycleRule.LifeCycleNoncurrentVersionTransition(){
            StorageClass = StorageClass.Archive,
            NoncurrentDays = 180
        }
    };
    setBucketLifecycleRequest.AddLifecycleRule(lcr1);
    setBucketLifecycleRequest.AddLifecycleRule(lcr2);
    setBucketLifecycleRequest.AddLifecycleRule(lcr3);

    // Konfigurasikan aturan siklus hidup. 
    client.SetBucketLifecycle(setBucketLifecycleRequest);
    Console.WriteLine("Set bucket:{0} Lifecycle berhasil ", bucketName);
}
catch (OssException ex)
{
    Console.WriteLine("Gagal dengan kode kesalahan: {0}; Informasi kesalahan: {1}. \nRequestID:{2}\tHostID:{3}",
        ex.ErrorCode, ex.Message, ex.RequestId, ex.HostId);
}
catch (Exception ex)
{
    Console.WriteLine("Gagal dengan informasi kesalahan: {0}", ex.Message);
}

PutBucketLifecycleRequest request = new PutBucketLifecycleRequest();
request.setBucketName("examplebucket");

BucketLifecycleRule rule1 = new BucketLifecycleRule();
// Tentukan ID aturan dan awalan yang terkandung dalam nama objek yang cocok dengan aturan. 
rule1.setIdentifier("1");
rule1.setPrefix("A");
// Tentukan apakah akan menjalankan aturan siklus hidup. Jika parameter ini disetel ke true, OSS secara berkala menjalankan aturan ini. Jika parameter ini disetel ke false, OSS mengabaikan aturan ini. 
rule1.setStatus(true);
// Tentukan bahwa objek kedaluwarsa 200 hari setelah terakhir dimodifikasi. 
rule1.setDays("200");
// Tentukan bahwa kelas penyimpanan objek diubah menjadi Arsip 30 hari setelah terakhir dimodifikasi.
rule1.setArchiveDays("30");
// Tentukan bahwa bagian kedaluwarsa tiga hari setelah gagal diunggah. 
rule1.setMultipartDays("3");
// Tentukan bahwa kelas penyimpanan objek diubah menjadi Infrequent Access (IA) 15 hari setelah terakhir dimodifikasi. 
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();

package main

import (
	"fmt"
	"os"

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

func main() {
	// Dapatkan kredensial akses dari variabel lingkungan. Sebelum menjalankan kode contoh, pastikan variabel lingkungan OSS_ACCESS_KEY_ID dan OSS_ACCESS_KEY_SECRET telah dikonfigurasi. 
	provider, err := oss.NewEnvironmentVariableCredentialsProvider()
	if err != nil {
		fmt.Println("Error:", err)
		os.Exit(-1)
	}
	// Buat instance OSSClient. 
	// Tentukan endpoint wilayah tempat bucket berada. Misalnya, jika bucket berada di wilayah Tiongkok (Hangzhou), atur endpoint ke https://oss-cn-hangzhou.aliyuncs.com. Tentukan endpoint sebenarnya. 
	// Tentukan wilayah tempat bucket berada. Misalnya, jika bucket berada di wilayah Tiongkok (Hangzhou), atur wilayah ke cn-hangzhou. Tentukan wilayah sebenarnya.
	clientOptions := []oss.ClientOption{oss.SetCredentialsProvider(&provider)}
	clientOptions = append(clientOptions, oss.Region("yourRegion"))
	// Tentukan versi algoritma tanda tangan.
	clientOptions = append(clientOptions, oss.AuthVersion(oss.AuthV4))
	client, err := oss.New("yourEndpoint", "", "", clientOptions...)
	if err != nil {
		fmt.Println("Error:", err)
		os.Exit(-1)
	}
	// Tentukan nama bucket. 
	bucketName := "examplebucket"
	// Konfigurasikan aturan siklus hidup dan atur ID ke rule1. Tentukan bahwa objek yang namanya mengandung awalan foo dalam bucket kedaluwarsa tiga hari setelah objek terakhir dimodifikasi. 
	rule1 := oss.BuildLifecycleRuleByDays("rule1", "foo/", true, 3)

	// Jika objek dalam bucket yang memiliki pengendalian versi diaktifkan adalah penanda hapus dan tidak memiliki versi lain, penanda hapus dihapus. 
	deleteMark := true
	expiration := oss.LifecycleExpiration{
		ExpiredObjectDeleteMarker: &deleteMark,
	}

	// Tentukan bahwa versi sebelumnya dari objek dihapus 30 hari setelah terakhir dimodifikasi. 
	versionExpiration := oss.LifecycleVersionExpiration{
		NoncurrentDays: 30,
	}

	// Tentukan bahwa kelas penyimpanan versi sebelumnya dari objek diubah menjadi Infrequent Access (IA) 10 hari setelah terakhir dimodifikasi. 
	versionTransition := oss.LifecycleVersionTransition{
		NoncurrentDays: 10,
		StorageClass:   "IA",
	}

	// Konfigurasikan aturan siklus hidup dan atur ID ke rule2. 
	rule2 := oss.LifecycleRule{
		ID:                   "rule2",
		Prefix:               "yourObjectPrefix",
		Status:               "Enabled",
		Expiration:           &expiration,
		NonVersionExpiration: &versionExpiration,
		NonVersionTransitions: []oss.LifecycleVersionTransition{
			versionTransition,
		},
	}

	// Konfigurasikan aturan siklus hidup dan atur ID ke rule3. Aturan ini berlaku untuk objek yang memiliki tag dengan kunci tag1 dan nilai value1. Objek ini kedaluwarsa tiga hari setelah terakhir dimodifikasi. 
	rule3 := oss.LifecycleRule{
		ID:     "rule3",
		Prefix: "",
		Status: "Enabled",
		Tags: []oss.Tag{
			oss.Tag{
				Key:   "tag1",
				Value: "value1",
			},
		},
		Expiration: &oss.LifecycleExpiration{Days: 3},
	}

	// Konfigurasikan aturan siklus hidup. 
	rules := []oss.LifecycleRule{rule1, rule2, rule3}
	err = client.SetBucketLifecycle(bucketName, rules)
	if err != nil {
		fmt.Println("Error:", err)
		os.Exit(-1)
	}
}

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

int main(void)
{
    /* Inisialisasi informasi tentang akun yang digunakan untuk mengakses OSS. */
    
    /* Tentukan endpoint wilayah tempat bucket berada. Misalnya, jika bucket berada di wilayah Tiongkok (Hangzhou), atur endpoint ke https://oss-cn-hangzhou.aliyuncs.com. */
    std::string Endpoint = "yourEndpoint";
    /* Tentukan wilayah tempat bucket berada. Misalnya, jika bucket berada di wilayah Tiongkok (Hangzhou), atur wilayah ke cn-hangzhou. */
    std::string Region = "yourRegion";
    /* Tentukan nama bucket. Contoh: examplebucket. */
    std::string BucketName = "examplebucket";

    /* Inisialisasi sumber daya seperti sumber daya jaringan. */
    InitializeSdk();

    ClientConfiguration conf;
    conf.signatureVersion = SignatureVersionType::V4;
    /* Dapatkan kredensial akses dari variabel lingkungan. Sebelum menjalankan kode contoh, pastikan variabel lingkungan OSS_ACCESS_KEY_ID dan OSS_ACCESS_KEY_SECRET telah dikonfigurasi. */
    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");

    /* Tentukan tag objek yang ingin Anda cocokkan dengan aturan. */
    Tagging tagging;
    tagging.addTag(Tag("key1", "value1"));
    tagging.addTag(Tag("key2", "value2"));

    /* Tentukan aturan siklus hidup. */
    auto rule1 = LifecycleRule();
    rule1.setID("rule1");
    rule1.setPrefix("test1/");
    rule1.setStatus(RuleStatus::Enabled);
    rule1.setExpiration(3);
    rule1.setTags(tagging.Tags());

    /* Tentukan tanggal kedaluwarsa. */
    auto rule2 = LifecycleRule();
    rule2.setID("rule2");
    rule2.setPrefix("test2/");
    rule2.setStatus(RuleStatus::Disabled);
    rule2.setExpiration(date);

    /* Tentukan bahwa rule3 diaktifkan untuk bucket jika pengendalian versi diaktifkan untuk bucket. */
    auto rule3 = LifecycleRule();
    rule3.setID("rule3");
    rule3.setPrefix("test3/");
    rule3.setStatus(RuleStatus::Disabled);

    /* Tentukan bahwa kelas penyimpanan objek diubah menjadi Arsip 365 hari setelah terakhir dimodifikasi. */  
    auto transition = LifeCycleTransition();  
    transition.Expiration().setDays(365);
    transition.setStorageClass(StorageClass::Archive);
    rule3.addTransition(transition);

    /* Tentukan bahwa penanda hapus yang kedaluwarsa dihapus secara otomatis. */
    rule3.setExpiredObjectDeleteMarker(true);

    /* Tentukan bahwa kelas penyimpanan versi sebelumnya dari objek diubah menjadi IA 10 hari setelah terakhir dimodifikasi. */
    auto transition1 = LifeCycleTransition();  
    transition1.Expiration().setDays(10);
    transition1.setStorageClass(StorageClass::IA);

    /* Tentukan bahwa kelas penyimpanan versi sebelumnya dari objek diubah menjadi Arsip 20 hari setelah terakhir dimodifikasi. */
    auto transition2 = LifeCycleTransition();  
    transition2.Expiration().setDays(20);
    transition2.setStorageClass(StorageClass::Archive);

    /* Tentukan bahwa versi sebelumnya dihapus 30 hari setelah versi diperbarui. */
    auto expiration  = LifeCycleExpiration(30);
    rule3.setNoncurrentVersionExpiration(expiration);

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

    /* Konfigurasikan aturan siklus hidup. */
    LifecycleRuleList list{rule1, rule2, rule3};
    request.setLifecycleRules(list);
    auto outcome = client.SetBucketLifecycle(request);

    if (!outcome.isSuccess()) {
        /* Tangani pengecualian. */
        std::cout << "SetBucketLifecycle gagal" <<
        ",code:" << outcome.error().Code() <<
        ",message:" << outcome.error().Message() <<
        ",requestId:" << outcome.error().RequestId() << std::endl;
        return -1;
    }

    /* Lepaskan sumber daya seperti sumber daya jaringan. */
    ShutdownSdk();
    return 0;
}

#include <alibabacloud/oss/OssClient.h>
#include <aos_http_io.h>
/* Tentukan endpoint wilayah tempat bucket berada. Misalnya, jika bucket berada di wilayah Tiongkok (Hangzhou), atur endpoint ke https://oss-cn-hangzhou.aliyuncs.com. */
const char *endpoint = "yourEndpoint";
/* Tentukan nama bucket. Contoh: examplebucket. */
const char *bucket_name = "examplebucket";
/* Tentukan wilayah tempat bucket berada. Misalnya, jika bucket berada di wilayah Tiongkok (Hangzhou), atur wilayah ke cn-hangzhou. */
const char *region = "yourRegion";
void init_options(oss_request_options_t *options)
{
    options->config = oss_config_create(options->pool);
    /* Gunakan string char* untuk menginisialisasi aos_string_t. */
    aos_str_set(&options->config->endpoint, endpoint);
    /* Dapatkan kredensial akses dari variabel lingkungan. Sebelum menjalankan kode contoh, pastikan variabel lingkungan OSS_ACCESS_KEY_ID dan OSS_ACCESS_KEY_SECRET telah dikonfigurasi. */
    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"));
    // Tentukan dua parameter tambahan.
    aos_str_set(&options->config->region, region);
    options->config->signature_version = 4;
    /* Tentukan apakah menggunakan CNAME untuk mengakses OSS. Nilai 0 menunjukkan bahwa CNAME tidak digunakan. */
    options->config->is_cname = 0;
    /* Tentukan parameter jaringan, seperti periode timeout. */
    options->ctl = aos_http_controller_create(options->pool, 0);
}
int main(int argc, char *argv[])
{
    /* Panggil metode aos_http_io_initialize di main() untuk menginisialisasi sumber daya global, seperti sumber daya jaringan dan memori. */
    if (aos_http_io_initialize(NULL, 0) != AOSE_OK) {
        exit(1);
    }
    /* Buat kolam memori untuk mengelola memori. aos_pool_t setara dengan apr_pool_t. Kode yang digunakan untuk membuat kolam memori termasuk dalam pustaka APR. */
    aos_pool_t *pool;
    /* Buat kolam memori. Nilai parameter kedua adalah NULL. Nilai ini menunjukkan bahwa kolam tidak mewarisi kolam memori lain. */
    aos_pool_create(&pool, NULL);
    /* Buat dan inisialisasi opsi. Parameter ini mencakup informasi konfigurasi global seperti endpoint, access_key_id, access_key_secret, is_cname, dan curl. */
    oss_request_options_t *oss_client_options;
    /* Alokasikan sumber daya memori di kolam memori untuk opsi. */
    oss_client_options = oss_request_options_create(pool);
    /* Inisialisasi oss_client_options. */
    init_options(oss_client_options);
    /* Inisialisasi parameter. */
    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);
    /* Tentukan periode validitas. */
    oss_lifecycle_rule_content_t *rule_content_days = oss_create_lifecycle_rule_content(pool);
    aos_str_set(&rule_content_days->id, "rule-1");
    /* Tentukan awalan yang terkandung dalam nama objek yang ingin Anda cocokkan dengan aturan. */
    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);
    /* Tentukan tanggal kedaluwarsa. */
    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");
    /* Tanggal kedaluwarsa ditampilkan dalam 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);
    /* Konfigurasikan aturan siklus hidup. */
    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 berhasil\n");
    } else {
        printf("put bucket lifecycle gagal, 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);
    }
    /* Lepaskan kolam memori untuk melepaskan sumber daya memori yang dialokasikan untuk permintaan. */
    aos_pool_destroy(pool);
    /* Lepaskan sumber daya global yang dialokasikan. */
    aos_http_io_deinitialize();
    return 0;
}

require 'aliyun/oss'

client = Aliyun::OSS::Client.new(
  # Dalam contoh ini, endpoint wilayah Tiongkok (Hangzhou) digunakan. Tentukan endpoint sebenarnya. 
  endpoint: 'https://oss-cn-hangzhou.aliyuncs.com',
  # Dapatkan kredensial akses dari variabel lingkungan. Sebelum menjalankan kode contoh, pastikan variabel lingkungan OSS_ACCESS_KEY_ID dan OSS_ACCESS_KEY_SECRET telah dikonfigurasi. 
  access_key_id: ENV['OSS_ACCESS_KEY_ID'],
  access_key_secret: ENV['OSS_ACCESS_KEY_SECRET']
)
# Tentukan nama bucket. 
bucket = client.get_bucket('examplebucket')
# Konfigurasikan aturan siklus hidup. 
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))
]