Object Storage Service：Konfigurasikan aturan siklus hidup berdasarkan waktu modifikasi terakhir untuk mengurangi biaya penyimpanan OSS

Java

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

public class Demo {

    public static void main(String[] args) throws Exception {
        // Dalam contoh ini, endpoint wilayah China (Hangzhou) digunakan. Tentukan endpoint aktual Anda.
        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 China (Hangzhou), tetapkan wilayah menjadi cn-hangzhou.
        String region = "cn-hangzhou";

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

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

            // Tentukan ID aturan siklus hidup.
            String ruleId0 = "rule0";
            // Tentukan awalan yang ingin dicocokkan oleh aturan siklus hidup.
            String matchPrefix0 = "A0/";
            // Tentukan tag yang ingin dicocokkan oleh aturan siklus hidup.
            Map<String, String> matchTags0 = new HashMap<String, String>();
            // Tentukan kunci dan nilai tag. Dalam contoh ini, kunci diatur menjadi owner dan nilai diatur menjadi 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/";

            // Tetapkan waktu kedaluwarsa menjadi tiga hari setelah waktu modifikasi terakhir.
            LifecycleRule rule = new LifecycleRule(ruleId0, matchPrefix0, LifecycleRule.RuleStatus.Enabled, 3);
            rule.setTags(matchTags0);
            request.AddLifecycleRule(rule);

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

            // Tentukan bahwa bagian kedaluwarsa tiga hari setelah terakhir dimodifikasi.
            rule = new LifecycleRule(ruleId2, matchPrefix2, LifecycleRule.RuleStatus.Enabled);
            LifecycleRule.AbortMultipartUpload abortMultipartUpload = new LifecycleRule.AbortMultipartUpload();
            abortMultipartUpload.setExpirationDays(3);
            rule.setAbortMultipartUpload(abortMultipartUpload);
            request.AddLifecycleRule(rule);

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

            // Tentukan bahwa kelas penyimpanan objek diubah menjadi IA 10 hari setelah terakhir dimodifikasi, dan menjadi Archive 30 hari setelah 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);

            // Tentukan bahwa kelas penyimpanan objek yang terakhir dimodifikasi sebelum 12 Oktober 2022 diubah menjadi Archive.
            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);

            // Tentukan bahwa rule6 dikonfigurasi untuk bucket yang diaktifkan pengendalian versinya.
            rule = new LifecycleRule(ruleId6, matchPrefix6, LifecycleRule.RuleStatus.Enabled);
            // Tentukan bahwa kelas penyimpanan objek diubah menjadi Archive 365 hari setelah objek terakhir dimodifikasi.
            storageTransitions = new ArrayList<LifecycleRule.StorageTransition>();
            storageTransition = new LifecycleRule.StorageTransition();
            storageTransition.setStorageClass(StorageClass.Archive);
            storageTransition.setExpirationDays(365);
            storageTransitions.add(storageTransition);
            rule.setStorageTransition(storageTransitions);
            // Konfigurasikan aturan siklus hidup untuk secara otomatis menghapus penanda hapus yang kedaluwarsa.
            rule.setExpiredDeleteMarker(true);
            // Tentukan bahwa kelas penyimpanan versi sebelumnya objek diubah menjadi IA 10 hari setelah objek terakhir dimodifikasi.
            LifecycleRule.NoncurrentVersionStorageTransition noncurrentVersionStorageTransition =
                    new LifecycleRule.NoncurrentVersionStorageTransition().withNoncurrentDays(10).withStrorageClass(StorageClass.IA);
            // Tentukan bahwa kelas penyimpanan versi sebelumnya objek diubah menjadi Archive 20 hari setelah objek terakhir dimodifikasi.
            LifecycleRule.NoncurrentVersionStorageTransition noncurrentVersionStorageTransition2 =
                    new LifecycleRule.NoncurrentVersionStorageTransition().withNoncurrentDays(20).withStrorageClass(StorageClass.Archive);
            // Tentukan bahwa versi sebelumnya objek dihapus 30 hari setelah objek terakhir dimodifikasi.
            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);

            // Kirim permintaan untuk mengonfigurasi aturan siklus hidup.
            ossClient.setBucketLifecycle(request);

            // Kueri aturan siklus hidup yang dikonfigurasi untuk bucket.
            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("Terjadi OSSException, yang berarti permintaan Anda sampai ke OSS, "
                    + "tetapi ditolak dengan tanggapan kesalahan karena suatu alasan.");
            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("Terjadi 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

<?php

// Sertakan file autoload untuk memuat dependensi
require_once __DIR__ . '/../vendor/autoload.php';

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

// Tentukan deskripsi untuk parameter baris perintah
$optsdesc = [
    "region" => ['help' => 'Wilayah tempat bucket berada', 'required' => True], // (Wajib) Tentukan wilayah tempat bucket berada.
    "endpoint" => ['help' => 'Nama domain yang dapat digunakan layanan lain untuk mengakses OSS', 'required' => False], // (Opsional) Tentukan endpoint yang dapat digunakan layanan lain untuk mengakses OSS.
    "bucket" => ['help' => 'Nama bucket', 'required' => True], // (Wajib) Tentukan nama bucket.
];

// Hasilkan daftar opsi panjang untuk mengurai parameter baris perintah
$longopts = \array_map(function ($key) {
    return "$key:"; // Tambahkan titik dua setelah setiap parameter untuk menunjukkan bahwa nilai diperlukan
}, array_keys($optsdesc));

// Uraikan parameter baris perintah
$options = getopt("", $longopts); 

// Periksa apakah parameter wajib hilang
foreach ($optsdesc as $key => $value) {
    if ($value['required'] === True && empty($options[$key])) {
        $help = $value['help'];
        echo "Error: argumen berikut diperlukan: --$key, $help"; // Beri tahu pengguna tentang parameter wajib yang hilang
        exit(1); 
    }
}

// Dapatkan nilai parameter baris perintah
$region = $options["region"]; // Wilayah tempat bucket berada
$bucket = $options["bucket"]; // Nama bucket

// Gunakan variabel lingkungan untuk memuat ID AccessKey dan rahasia AccessKey
$credentialsProvider = new Oss\Credentials\EnvironmentVariableCredentialsProvider();

// Gunakan konfigurasi default SDK
$cfg = Oss\Config::loadDefault();

// Tentukan penyedia kredensial
$cfg->setCredentialsProvider($credentialsProvider);

// Tentukan wilayah
$cfg->setRegion($region);

// Tentukan endpoint jika endpoint disediakan
if (isset($options["endpoint"])) {
    $cfg->setEndpoint($options["endpoint"]);
}

// Buat instance OSSClient
$client = new Oss\Client($cfg);

// Definisikan aturan siklus hidup untuk mengonversi objek yang namanya mengandung awalan log/ ke kelas penyimpanan IA setelah 30 hari
$lifecycleRule = new Oss\Models\LifecycleRule(
    prefix: 'log/', // Awalan objek
    transitions: array(
        new Oss\Models\LifecycleRuleTransition(
            days: 30, // Waktu konversi adalah 30 hari
            storageClass: 'IA' // Kelas penyimpanan target adalah IA
        )
    ),
    id: 'rule', // ID aturan
    status: 'Enabled' // Status aturan diaktifkan
);

// Buat objek konfigurasi siklus hidup dan tambahkan aturan siklus hidup
$lifecycleConfiguration = new LifecycleConfiguration(
    rules: array($lifecycleRule)
);

// Buat objek permintaan untuk menetapkan siklus hidup bucket dan masukkan konfigurasi siklus hidup
$request = new Oss\Models\PutBucketLifecycleRequest(
    bucket: $bucket,
    lifecycleConfiguration: $lifecycleConfiguration
);

// Panggil metode putBucketLifecycle untuk menetapkan aturan siklus hidup untuk bucket
$result = $client->putBucketLifecycle($request);

// Tampilkan hasil yang dikembalikan
printf(
    'status code:' . $result->statusCode . PHP_EOL . // Kode status respons HTTP
    'request id:' . $result->requestId . PHP_EOL // Pengidentifikasi unik permintaan
);

Node.js

const OSS = require('ali-oss')

const client = new OSS({
  // Tentukan wilayah tempat bucket berada. Misalnya, jika bucket berada di wilayah China (Hangzhou), tetapkan wilayah menjadi 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 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: {
    // Tentukan bahwa versi saat ini objek kedaluwarsa tiga hari setelah objek terakhir dimodifikasi.
    days: 3 
  }
}
putBucketLifecycle(lifecycle1)

const lifecycle2 = {
  id: 'rule2',
  status: 'Enabled',
  prefix: 'foo/', 
  expiration: {
    // Tentukan bahwa objek yang dibuat sebelum tanggal tertentu kedaluwarsa.
    createdBeforeDate: '2020-02-18T00:00:00.000Z' 
  },
}
putBucketLifecycle(lifecycle2)

const lifecycle3 = {
  id: 'rule3',
  status: 'Enabled',
  prefix: 'foo/', 
  abortMultipartUpload: {
    // Tentukan bahwa bagian kedaluwarsa dalam tiga hari.
    days: 3 
  },
}
putBucketLifecycle(lifecycle3)

const lifecycle4 = {
  id: 'rule4',
  status: 'Enabled',
  prefix: 'foo/', 
  abortMultipartUpload: {
    // Tentukan bahwa bagian yang dibuat sebelum tanggal tertentu kedaluwarsa.
    createdBeforeDate: '2020-02-18T00:00:00.000Z' 
  },
}
putBucketLifecycle(lifecycle4)

const lifecycle5 = {
  id: 'rule5',
  status: 'Enabled',
  prefix: 'foo/', 
  transition: {
    // Tentukan bahwa kelas penyimpanan versi saat ini objek diubah menjadi Archive 20 hari setelah objek terakhir dimodifikasi.
    days: 20,
    storageClass: 'Archive'
  },
  expiration: {
    // Tentukan bahwa versi saat ini objek kedaluwarsa 21 hari setelah objek terakhir dimodifikasi.
    days: 21 
  },
}
putBucketLifecycle(lifecycle5)

const lifecycle6 = {
  id: 'rule6',
  status: 'Enabled',
  prefix: 'foo/', 
  transition: {
    //Tentukan bahwa kelas penyimpanan objek yang dibuat sebelum tanggal tertentu diubah menjadi Archive.
    createdBeforeDate: '2023-02-19T00:00:00.000Z', 
    storageClass: 'Archive'
  },
  expiration: {
    // Tentukan bahwa objek yang dibuat sebelum tanggal tertentu dihapus.
    createdBeforeDate: '2023-01-18T00:00:00.000Z' 
  },
}
putBucketLifecycle(lifecycle6)

const lifecycle7 = {
  id: 'rule7',
  status: 'Enabled',
  prefix: 'foo/', 
  expiration: {
    // Tentukan bahwa penanda hapus dihapus secara otomatis saat kedaluwarsa.
    expiredObjectDeleteMarker: true 
  }
}
putBucketLifecycle(lifecycle7)

const lifecycle8 = {
  id: 'rule8',
  status: 'Enabled',
  prefix: 'foo/', 
  // Tentukan bahwa kelas penyimpanan versi sebelumnya objek diubah menjadi IA 10 hari setelah objek terakhir dimodifikasi.
  noncurrentVersionTransition: {
    noncurrentDays: '10',
    storageClass: 'IA'
  }
}
putBucketLifecycle(lifecycle8)

const lifecycle9 = {
  id: 'rule9',
  status: 'Enabled',
  prefix: 'foo/', 
  // Tentukan bahwa kelas penyimpanan versi sebelumnya objek diubah menjadi IA 10 hari setelah objek terakhir dimodifikasi.
  noncurrentVersionTransition: {
    noncurrentDays: '10',
    storageClass: 'IA'
  },
  // Tentukan tag untuk objek yang ingin Anda cocokkan dengan aturan.
  tag: [{
    key: 'key1',
    value: 'value1'
  },
   {
     key: 'key2',
     value: 'value2'
   }]
}
putBucketLifecycle(lifecycle9)

Python

import argparse
import datetime
import alibabacloud_oss_v2 as oss

# Buat parser argumen baris perintah untuk menerima parameter yang dimasukkan pengguna.
parser = argparse.ArgumentParser(description="contoh put bucket lifecycle")

# Tambahkan argumen baris perintah --region, yang menentukan wilayah tempat bucket berada. Argumen ini wajib.
parser.add_argument('--region', help='Wilayah tempat bucket berada.', required=True)

# Tambahkan argumen baris perintah --bucket, yang menentukan nama bucket. Argumen ini wajib.
parser.add_argument('--bucket', help='Nama bucket.', required=True)

# Tambahkan argumen baris perintah --endpoint, yang menentukan nama domain yang dapat digunakan layanan lain untuk mengakses OSS. Argumen ini opsional.
parser.add_argument('--endpoint', help='Nama domain yang dapat digunakan layanan lain untuk mengakses OSS')

def main():
    # Uraikan argumen baris perintah.
    args = parser.parse_args()

    # Muat kredensial (ID AccessKey dan rahasia AccessKey) dari variabel lingkungan.
    credentials_provider = oss.credentials.EnvironmentVariableCredentialsProvider()

    # Muat konfigurasi default SDK.
    cfg = oss.config.load_default()

    # Tetapkan penyedia kredensial.
    cfg.credentials_provider = credentials_provider

    # Tetapkan wilayah tempat bucket berada.
    cfg.region = args.region

    # Jika pengguna menyediakan endpoint kustom, tetapkan dalam konfigurasi.
    if args.endpoint is not None:
        cfg.endpoint = args.endpoint

    # Inisialisasi klien OSS menggunakan objek konfigurasi.
    client = oss.Client(cfg)

    result = client.put_bucket_lifecycle(oss.PutBucketLifecycleRequest(
            bucket=args.bucket,
            lifecycle_configuration=oss.LifecycleConfiguration(
                rules=[oss.LifecycleRule(
                    # Tentukan aturan siklus hidup rule1. Dalam aturan ini, objek yang memiliki awalan foo/ dan tag k1:v1 dikonversi ke kelas penyimpanan Infrequent Access (IA) 30 hari setelah terakhir dimodifikasi.
                    id='rule1',
                    status='Enabled',
                    prefix='foo/',
                    transitions=[oss.LifecycleRuleTransition(
                        days=30,
                        storage_class=oss.StorageClassType.IA,
                        is_access_time=False, # Tetapkan ke false, yang menunjukkan bahwa kebijakan berdasarkan waktu modifikasi terakhir.
                    )],
                    tags=[oss.Tag(
                        key='k1',
                        value='v1',
                    )],
                ), oss.LifecycleRule(
                    # Tentukan aturan siklus hidup rule2. Dalam aturan ini, untuk objek yang memiliki awalan dir/, penanda hapus dihapus secara otomatis jika objek berada dalam bucket yang diaktifkan pengendalian versinya dan hanya memiliki penanda hapus. Versi non-saat ini objek kedaluwarsa dan dihapus setelah 30 hari. Versi non-saat ini objek dikonversi ke kelas penyimpanan IA setelah 10 hari.
                    id='rule2',
                    status='Enabled',
                    prefix='dir/',
                    expiration=oss.LifecycleRuleExpiration(
                        days=10,
                        expired_object_delete_marker=True
                    ),
                    noncurrent_version_expiration=oss.NoncurrentVersionExpiration(
                        noncurrent_days=30,
                    ),
                    noncurrent_version_transition=oss.NoncurrentVersionTransition(
                        noncurrent_days=10,
                        storage_class=oss.StorageClassType.IA,
                        is_access_time=False, # Tetapkan ke false, yang menunjukkan bahwa kebijakan berdasarkan waktu modifikasi terakhir.
                    ),
                )]
            ),
    ))

    # Cetak kode status dan ID permintaan operasi.
    print(f'kode status: {result.status_code}, '  # Kode status HTTP, yang menunjukkan apakah permintaan berhasil.
          f'ID permintaan: {result.request_id}')    # ID permintaan, yang digunakan untuk melacak log permintaan dan untuk debugging.


if __name__ == "__main__":
    # Titik masuk program yang memanggil fungsi utama untuk menjalankan logika.
    main()

C#

using Aliyun.OSS;
using Aliyun.OSS.Common;
// Tentukan endpoint wilayah tempat bucket berada. Misalnya, jika bucket berada di wilayah China (Hangzhou), tetapkan endpoint menjadi 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 China (Hangzhou), tetapkan wilayah menjadi 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 objek dikonversi menjadi IA 90 hari setelah terakhir dimodifikasi.
        new LifecycleRule.LifeCycleNoncurrentVersionTransition(){
            StorageClass = StorageClass.IA,
            NoncurrentDays = 90
        },
        // Tentukan bahwa kelas penyimpanan versi sebelumnya objek dikonversi menjadi Archive 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}; Info kesalahan: {1}. \nIDPermintaan:{2}\tIDHost:{3}",
        ex.ErrorCode, ex.Message, ex.RequestId, ex.HostId);
}
catch (Exception ex)
{
    Console.WriteLine("Gagal dengan info kesalahan: {0}", ex.Message);
}

Android-Java

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 diatur ke true, OSS secara berkala menjalankan aturan ini. Jika parameter ini diatur 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 dikonversi menjadi Archive 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 dikonversi 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();

C++

#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 China (Hangzhou), tetapkan endpoint menjadi https://oss-cn-hangzhou.aliyuncs.com. */
    std::string Endpoint = "yourEndpoint";
    /* Tentukan wilayah tempat bucket berada. Misalnya, jika bucket berada di wilayah China (Hangzhou), tetapkan wilayah menjadi 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 Archive 365 hari setelah objek 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 objek diubah menjadi IA 10 hari setelah objek terakhir dimodifikasi. */
    auto transition1 = LifeCycleTransition();  
    transition1.Expiration().setDays(10);
    transition1.setStorageClass(StorageClass::IA);

    /* Tentukan bahwa kelas penyimpanan versi sebelumnya objek diubah menjadi Archive 20 hari setelah objek 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" <<
        ",kode:" << outcome.error().Code() <<
        ",pesan:" << outcome.error().Message() <<
        ",requestId:" << outcome.error().RequestId() << std::endl;
        return -1;
    }

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

C

#include "oss_api.h"
#include "aos_http_io.h"
/* Tentukan endpoint wilayah tempat bucket berada. Misalnya, jika bucket berada di wilayah China (Hangzhou), tetapkan endpoint menjadi 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 China (Hangzhou), tetapkan wilayah menjadi 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 akan 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 pool memori untuk mengelola memori. aos_pool_t setara dengan apr_pool_t. Kode yang digunakan untuk membuat pool memori termasuk dalam library APR. */
    aos_pool_t *pool;
    /* Buat pool memori. Nilai parameter kedua adalah NULL. Nilai ini menunjukkan bahwa pool tidak mewarisi pool 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 pool memori ke 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, kode:%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 pool 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;
}

Ruby

require 'aliyun/oss'

client = Aliyun::OSS::Client.new(
  # Dalam contoh ini, endpoint wilayah China (Hangzhou) digunakan. Tentukan endpoint aktual Anda.
  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))
]

Go

package main

import (
	"context"
	"flag"
	"log"

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

// Definisikan variabel global.
var (
	region     string // Wilayah tempat bucket berada.
	bucketName string // Nama bucket.
)

// Fungsi init digunakan untuk menginisialisasi parameter baris perintah.
func init() {
	flag.StringVar(&region, "region", "", "Wilayah tempat bucket berada.")
	flag.StringVar(&bucketName, "bucket", "", "Nama bucket.")
}

func main() {
	// Uraikan parameter baris perintah.
	flag.Parse()

	// Periksa apakah nama bucket kosong.
	if len(bucketName) == 0 {
		flag.PrintDefaults()
		log.Fatalf("parameter tidak valid, nama bucket diperlukan")
	}

	// Periksa apakah wilayah kosong.
	if len(region) == 0 {
		flag.PrintDefaults()
		log.Fatalf("parameter tidak valid, wilayah diperlukan")
	}

	// Muat konfigurasi default dan tetapkan penyedia kredensial dan wilayah.
	cfg := oss.LoadDefaultConfig().
		WithCredentialsProvider(credentials.NewEnvironmentVariableCredentialsProvider()).
		WithRegion(region)

	// Buat klien OSS.
	client := oss.NewClient(cfg)

	// Buat permintaan untuk menetapkan aturan siklus hidup untuk bucket.
	request := &oss.PutBucketLifecycleRequest{
		Bucket: oss.Ptr(bucketName), // Nama bucket.
		LifecycleConfiguration: &oss.LifecycleConfiguration{
			Rules: []oss.LifecycleRule{
				{
					// Tentukan aturan siklus hidup rule1. Dalam aturan ini, file yang memiliki awalan foo dan tag kunci k1 serta nilai tag v1 dikonversi ke kelas penyimpanan Infrequent Access 30 hari setelah terakhir dimodifikasi.
					Status: oss.Ptr("Enabled"),
					ID:     oss.Ptr("rule1"),
					Prefix: oss.Ptr("foo/"),
					Transitions: []oss.LifecycleRuleTransition{
						{
							Days:         oss.Ptr(int32(30)),
							StorageClass: oss.StorageClassIA,
							IsAccessTime: oss.Ptr(false), // Tetapkan nilai ke false. Kebijakan berdasarkan waktu modifikasi terakhir.
						},
					},
					Tags: []oss.Tag{
						{
							Key:   oss.Ptr("k1"),
							Value: oss.Ptr("v1"),
						},
					},
				},
				{
					// Tentukan aturan siklus hidup rule2. Dalam aturan ini, untuk objek yang memiliki awalan dir dalam bucket yang diaktifkan pengendalian versinya, jika objek hanya memiliki penanda hapus, penanda hapus tersebut dihapus secara otomatis. Versi non-saat ini objek kedaluwarsa dan dihapus setelah 30 hari. Versi non-saat ini objek dikonversi ke kelas penyimpanan IA setelah 10 hari.
					ID:     oss.Ptr("rule2"),
					Prefix: oss.Ptr("dir/"),
					Status: oss.Ptr("Enabled"),
					Expiration: &oss.LifecycleRuleExpiration{
						Days:                      oss.Ptr(int32(10)),
						ExpiredObjectDeleteMarker: oss.Ptr(true),
					},
					NoncurrentVersionExpiration: &oss.NoncurrentVersionExpiration{
						NoncurrentDays: oss.Ptr(int32(30)),
					},
					NoncurrentVersionTransitions: []oss.NoncurrentVersionTransition{{
						NoncurrentDays: oss.Ptr(int32(10)),
						StorageClass:   oss.StorageClassIA,
						IsAccessTime:   oss.Ptr(false), // Tetapkan nilai ke false. Kebijakan berdasarkan waktu modifikasi terakhir.
					}},
				},
			},
		},
	}

	// Tetapkan aturan siklus hidup untuk bucket.
	result, err := client.PutBucketLifecycle(context.TODO(), request)
	if err != nil {
		log.Fatalf("gagal menetapkan siklus hidup bucket %v", err)
	}

	// Cetak hasil menetapkan aturan siklus hidup untuk bucket.
	log.Printf("hasil menetapkan siklus hidup bucket:%#v\n", result)
}