Object Storage Service:Lifecycle rules based on last access time

Sem exclusão de dados

Não é possível usar regras de ciclo de vida com base no último acesso para excluir dados.

Condições de correspondência

As regras de ciclo de vida aceitam correspondência apenas com base em prefixos e tags. Não há suporte para correspondência por curinga, sufixo ou expressão regular.

Limites de expiração de partes

Não é possível configurar duas ou mais regras de ciclo de vida que contenham uma política de ciclo de vida de partes para objetos cujos nomes tenham prefixos sobrepostos. Exemplos:

• Exemplo 1

  Ao configurar uma regra de ciclo de vida com uma política de partes para um bucket, não configure outra regra com política de partes para nenhum objeto nesse bucket.

• Exemplo 2

  Ao configurar uma regra de ciclo de vida com uma política de partes para objetos cujos nomes contenham o prefixo dir1 em um bucket, não configure outra regra com política de partes para objetos cujos nomes tenham prefixos sobrepostos, como dir1/dir2.

Limite de regras

Um bucket pode ter até 1.000 regras de ciclo de vida. Uma regra de ciclo de vida pode conter políticas com base na última modificação e políticas com base no último acesso.

Semântica de substituição

A operação PutBucketLifecycle substitui as configurações existentes de uma regra de ciclo de vida do bucket. Por exemplo, se uma regra de ciclo de vida chamada Rule1 estiver configurada para um bucket e você quiser configurar outra regra de ciclo de vida chamada Rule2 para o mesmo bucket, execute as seguintes operações:

• Chame a operação GetBucketLifecycle para consultar a Rule1.

• Adicione a Rule1 e a Rule2 à configuração da regra de ciclo de vida.

• Chame a operação PutBucketLifecycle para criar a Rule1 e a Rule2 para o bucket.

Horário de vigência

Após a criação de uma regra de ciclo de vida, o oss carrega a regra em até 24 horas. Depois de carregada, o OSS começa a executá-la diariamente às 08:00 (UTC+8).

Tempo de conclusão da execução

• Depois que uma regra entra em vigor, o OSS geralmente conclui as operações de ciclo de vida (como exclusão de objetos, transição de classe de armazenamento e expiração de partes de upload multipart) em até 24 horas para até 1 bilhão de objetos nas regiões China (Hangzhou), China (Shanghai), China (Beijing), China (Zhangjiakou), China (Ulanqab), China (Shenzhen) e Singapore. Em outras regiões, o OSS costuma concluir essas operações em até 24 horas para até 100 milhões de objetos.

• A execução pode levar mais de 24 horas, chegando a vários dias ou semanas em alguns casos, se houver muitos objetos para verificar, muitos objetos abrangidos pela regra, muitas tags, várias versões de um único objeto ou um grande volume de novos objetos gravados durante a execução da tarefa de ciclo de vida.

  Nota

  Se o versionamento estiver ativado para o bucket, cada operação em uma versão de um objeto conta como uma operação separada.

Faturamento

• Taxas de monitoramento e gerenciamento de objetos

  Ao ativar o rastreamento de acesso, você incorre em taxas de monitoramento e gerenciamento de objetos. No entanto, o OSS atualmente não cobra essas taxas.

• Taxas por não atingir a duração mínima de armazenamento para Infrequent Access

  Os objetos na classe de armazenamento Infrequent Access têm uma duração mínima de armazenamento de 30 dias. Se um objeto for armazenado por menos de 30 dias, haverá cobrança pela parte restante da duração mínima. Os exemplos a seguir descrevem como esse item de faturamento funciona com as regras de ciclo de vida:

  Exemplo 1: uma regra de ciclo de vida move um objeto Standard para a classe de armazenamento Infrequent Access 10 dias após a criação. Cinco dias depois, o objeto volta para a classe de armazenamento Standard. Nesse caso, há cobrança por 15 dias de armazenamento para atender ao requisito de duração mínima do Infrequent Access.

  Exemplo 2: uma regra de ciclo de vida move um objeto Standard para a classe de armazenamento Infrequent Access 10 dias após a criação. O objeto é excluído 15 dias depois. Nesse caso, há cobrança por 5 dias de armazenamento para atender ao requisito de duração mínima do Infrequent Access.

  Para mais informações, consulte Storage fees.

• Taxas de recuperação de dados para Infrequent Access

  O OSS calcula as taxas de acesso a arquivos na classe de armazenamento Infrequent Access com base na quantidade de dados recuperados. Para mais informações, consulte Data processing fees.

• Taxas de solicitação

  Uma regra de ciclo de vida gera taxas de solicitação ao transferir a classe de armazenamento de um objeto. Para mais informações, consulte Request fees.

OSS console

1. Acesse o OSS console.

2. No painel de navegação à esquerda, clique em Buckets. Na página exibida, clique no nome do bucket de destino.

3. No painel de navegação à esquerda, escolha Data Management > Lifecycle.

4. Na página Lifecycle, ative a opção Enable Access Tracking e clique em Create Rule.

5. No painel Create Lifecycle Rule, configure a regra de ciclo de vida com base nas descrições a seguir.

   • O bucket tem o versionamento desativado

     Seção	Parâmetro	Descrição
     Basic Settings	Status	defina o status da regra de ciclo de vida. selecione Enabled ou Disabled. Se você ativar a regra de ciclo de vida, o OSS altera as classes de armazenamento dos dados com base na regra. Se você desativar a regra de ciclo de vida, o OSS suspende a tarefa de ciclo de vida.
     	Applied To	selecione os objetos aos quais a regra de ciclo de vida se aplica. Selecione Objects with Specified Prefix ou Whole Bucket.
     	Allow Overlapped Prefixes	Por padrão, o OSS verifica se os prefixos das regras de ciclo de vida se sobrepõem. Por exemplo, você define as duas regras de ciclo de vida a seguir com prefixos sobrepostos: Regra 1 Transfere todos os objetos com o prefixo dir1/ no bucket para a classe de armazenamento Infrequent Access 180 dias após o último acesso. Regra 2 Transfere todos os objetos com o prefixo dir1/dir2/ no bucket para a classe de armazenamento Archive 30 dias após o último acesso. Se esta opção não estiver selecionada, o OSS rejeita esta configuração porque os objetos no diretório dir1/dir2/ corresponderiam a ambas as regras de transição. Se esta opção estiver selecionada, o OSS move os objetos no diretório dir1/dir2/ para a classe de armazenamento Archive após 30 dias. O OSS move os outros objetos no diretório dir1/ para a classe de armazenamento Infrequent Access após 180 dias.
     	Prefix	insira o prefixo do objeto para a correspondência da regra. Se você definir o prefixo como img, a regra corresponde a todos os objetos cujos nomes comecem com img, como imgtest.png e img/example.jpg. Se você definir o prefixo como img/, a regra corresponde a todos os objetos cujos nomes comecem com img/, como img/example.jpg e img/test.jpg.
     	Tag	A regra de ciclo de vida se aplica apenas a objetos com a tag especificada. Por exemplo, se você selecionar Objects with Specified Prefix, definir o prefixo como img e definir a chave da tag como a e o valor como 1, a regra corresponde a todos os objetos cujos nomes comecem com img e que tenham a tag a=1. Para mais informações sobre tags de objetos, consulte Object tagging.
     	NOT	Use a opção NOT para excluir objetos que tenham um prefixo e uma tag especificados da regra de ciclo de vida. Importante Se a opção NOT estiver ativada, especifique pelo menos um prefixo ou uma tag. A chave definida para a tag na condição NOT não pode ser igual à chave definida no parâmetro Tag. Se a opção NOT estiver ativada, não é possível configurar uma política de expiração de partes.
     	Object Size	Especifique o tamanho do objeto ao qual a regra de ciclo de vida se aplica. Minimum Size: a regra de ciclo de vida se aplica a objetos maiores que este valor. O valor deve ser maior que 0 B e menor que 5 TB. Maximum Size: a regra de ciclo de vida se aplica a objetos menores que este valor. O valor deve ser maior que 0 B e menor ou igual a 5 TB. Importante Se você configurar Minimum size e Maximum size na mesma regra de ciclo de vida, observe os seguintes itens: Certifique-se de que o valor de Maximum size seja maior que o valor de Minimum size. Não é possível configurar uma política de expiração de partes. Não é possível configurar uma política para limpar marcadores de exclusão.
     Policy for Objects	Object Lifecycle	Selecione uma política de expiração para objetos. Selecione Validity Period (Days), Expiration Date ou Disabled. Se você selecionar Disabled, a política de expiração de objetos não entra em vigor.
     	Lifecycle-based Rules	Configure a regra para transferir a classe de armazenamento dos objetos. É possível mover os dados para as seguintes classes de armazenamento: IA (Data Remains in IA After Access) IA (Data Is Converted to Standard After Access) Archive Cold Archive Deep Cold Archive Por exemplo, se você selecionar a política Access Time, definir Validity Period (Days) como 30 e especificar que os dados são automaticamente movidos para IA (Data Remains in IA After Access) após o período especificado, um objeto acessado pela última vez em 1º de setembro de 2021 é movido para essa classe de armazenamento em 1º de outubro de 2021.
     Policy for Parts	Part Lifecycle	Defina a ação a ser executada em partes expiradas. Se você tiver especificado uma Tag, não configure este parâmetro. Selecione Validity Period (Days) ou Expiration Date para a política de expiração de partes, ou selecione Disabled. Se você selecionar Disabled, a política de expiração de partes não entra em vigor. Importante Uma regra de ciclo de vida deve incluir pelo menos uma política de expiração de objetos ou uma política de expiração de partes.
     	Rules for Parts	Especifique quando as partes expiram com base no período de validade ou na data de expiração selecionada na política de expiração de partes. O OSS exclui as partes expiradas automaticamente e não é possível recuperá-las.

   • O bucket tem o versionamento ativado

     Após ativar o versionamento, os itens de configuração nas seções Basic Settings e Policy for Parts são configurados da mesma forma que quando o versionamento está desativado. A tabela a seguir descreve apenas as diferenças de configuração quando o versionamento está ativado.

     Seção	Parâmetro	Descrição
     Policy for Current Versions	Clear delete markers	Após a ativação do versionamento, o OSS adiciona a opção Clear Delete Markers à política de limpeza. As outras opções são as mesmas de quando o versionamento está desativado. Se você selecionar esta opção e a versão atual de um objeto for a única versão e for um marcador de exclusão, o OSS remove o marcador de exclusão do objeto expirado. Se o objeto tiver várias versões e a versão mais recente for um marcador de exclusão, o OSS mantém o marcador de exclusão. Para mais informações sobre marcadores de exclusão, consulte Delete markers.
     Policy for Previous Versions	Object Lifecycle	Defina a política de expiração para versões não atuais de objetos. Selecione Validity Period (Days) ou Disabled. Se você selecionar Disabled, a política de expiração de objetos não entra em vigor.
     	Lifecycle-based Rules	Defina um período de N dias. Após o acesso a uma versão não atual de um objeto, o OSS a move para uma classe de armazenamento diferente após N dias. Por exemplo, se você definir o período como 30 dias, o OSS move uma versão não atual acessada em 1º de setembro de 2021 para a classe de armazenamento especificada em 1º de outubro de 2021.

6. Clique em OK.

   Após salvar a regra, ela aparece na lista de políticas.

SDK

Os SDKs do OSS para Java, Go, Python e PHP suportam a criação de regras de ciclo de vida com base no último acesso. Antes de criar uma regra de ciclo de vida com base no último acesso, ative o rastreamento de acesso para o bucket especificado. Para ver exemplos de código, consulte SDK overview.

import com.aliyun.oss.*;
import com.aliyun.oss.common.auth.*;
import com.aliyun.oss.common.comm.SignVersion;
import com.aliyun.oss.model.*;
import java.util.ArrayList;
import java.util.List;

public class Demo {

    public static void main(String[] args) throws Exception {
        // In this example, the endpoint of the China (Hangzhou) region is used. Specify your actual endpoint. 
        String endpoint = "https://oss-cn-hangzhou.aliyuncs.com";
        // Obtain access credentials from environment variables. Before you run the sample code, make sure that the OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET environment variables are configured. 
        EnvironmentVariableCredentialsProvider credentialsProvider = CredentialsProviderFactory.newEnvironmentVariableCredentialsProvider();
        // Specify the name of the bucket. Example: examplebucket. 
        String bucketName = "examplebucket";
        // Specify the region in which the bucket is located. For example, if the bucket is located in the China (Hangzhou) region, set the region to cn-hangzhou.
        String region = "cn-hangzhou";

        // Create an OSSClient instance. 
        // Call the shutdown method to release resources when the OSSClient is no longer in use.
        ClientBuilderConfiguration clientBuilderConfiguration = new ClientBuilderConfiguration();
        clientBuilderConfiguration.setSignatureVersion(SignVersion.V4);        
        OSS ossClient = OSSClientBuilder.create()
        .endpoint(endpoint)
        .credentialsProvider(credentialsProvider)
        .clientConfiguration(clientBuilderConfiguration)
        .region(region)               
        .build();

        try {
            ossClient.putBucketAccessMonitor(bucketName, AccessMonitor.AccessMonitorStatus.Enabled.toString());
            // Create a lifecycle rule and set the ID to rule1. Specify that the storage classes of objects whose names contain the logs prefix and whose size is less than or equal to 64 KB are changed to IA 30 days after the objects are last accessed. In addition, specify that the objects whose name contain the logs prefix are still stored as IA objects when the objects are accessed again. 
            LifecycleRule lifecycleRule = new LifecycleRule("rule1", "logs", LifecycleRule.RuleStatus.Enabled);
            List<LifecycleRule> lifecycleRuleList = new ArrayList<LifecycleRule>();
            SetBucketLifecycleRequest setBucketLifecycleRequest = new SetBucketLifecycleRequest(bucketName);

            LifecycleRule.StorageTransition storageTransition = new LifecycleRule.StorageTransition();
            storageTransition.setStorageClass(StorageClass.IA);
            storageTransition.setExpirationDays(30);
            storageTransition.setIsAccessTime(true);
            storageTransition.setReturnToStdWhenVisit(false);
            storageTransition.setAllowSmallFile(true);
            List<LifecycleRule.StorageTransition> storageTransitionList = new ArrayList<LifecycleRule.StorageTransition>();
            storageTransitionList.add(storageTransition);
            lifecycleRule.setStorageTransition(storageTransitionList);
            lifecycleRuleList.add(lifecycleRule);
            
            // Create a lifecycle rule and set the ID to rule2. Specify that the previous versions of the objects whose names contain the dir prefix and whose size is greater than 64 KB are changed to IA 10 days after the objects are last accessed. In addition, specify that the storage classes of the objects whose names contain the dir prefix are changed to Standard when the objects are accessed again. 
            LifecycleRule lifecycleRule2 = new LifecycleRule("rule2", "dir", LifecycleRule.RuleStatus.Enabled);
            LifecycleRule.NoncurrentVersionStorageTransition noncurrentVersionStorageTransition = new LifecycleRule.NoncurrentVersionStorageTransition();
            noncurrentVersionStorageTransition.setStorageClass(StorageClass.IA);
            noncurrentVersionStorageTransition.setNoncurrentDays(10);
            noncurrentVersionStorageTransition.setIsAccessTime(true);
            noncurrentVersionStorageTransition.setReturnToStdWhenVisit(true);
            noncurrentVersionStorageTransition.setAllowSmallFile(false);

            List<LifecycleRule.NoncurrentVersionStorageTransition> noncurrentVersionStorageTransitionList = new ArrayList<LifecycleRule.NoncurrentVersionStorageTransition>();
            noncurrentVersionStorageTransitionList.add(noncurrentVersionStorageTransition);
            lifecycleRule2.setNoncurrentVersionStorageTransitions(noncurrentVersionStorageTransitionList);
            lifecycleRuleList.add(lifecycleRule2);

            setBucketLifecycleRequest.setLifecycleRules(lifecycleRuleList);

            // Configure the lifecycle rules. 
            ossClient.setBucketLifecycle(setBucketLifecycleRequest);
        } 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();
            }
        }
    }
}

import argparse
import datetime
import alibabacloud_oss_v2 as oss

parser = argparse.ArgumentParser(description="put bucket lifecycle sample")
parser.add_argument('--region', help='The region in which the bucket is located.', required=True)
parser.add_argument('--bucket', help='The name of the bucket.', required=True)
parser.add_argument('--endpoint', help='The domain names that other services can use to access OSS')

def main():
  args = parser.parse_args()
  credentials_provider = oss.credentials.EnvironmentVariableCredentialsProvider()
  cfg = oss.config.load_default()
  cfg.credentials_provider = credentials_provider
  cfg.region = args.region
  if args.endpoint is not None:
    cfg.endpoint = args.endpoint
  client = oss.Client(cfg)

  result = client.put_bucket_lifecycle(oss.PutBucketLifecycleRequest(
    bucket=args.bucket,
    lifecycle_configuration=oss.LifecycleConfiguration(
      rules=[
        oss.LifecycleRule(
          id='rule1',
          status='Enabled',
          prefix='data/',
          transitions=[oss.LifecycleRuleTransition(
            days=200,
            storage_class=oss.StorageClassType.IA,
            is_access_time=True,
            return_to_std_when_visit=False
          )]
        ),
        oss.LifecycleRule(
          id='rule2',
          status='Enabled',
          prefix='log/',
          transitions=[
            oss.LifecycleRuleTransition(
              days=120,
              storage_class=oss.StorageClassType.IA,
              is_access_time=True,
              return_to_std_when_visit=False
            ),
            oss.LifecycleRuleTransition(
              days=250,
              storage_class=oss.StorageClassType.ARCHIVE
              # If is_access_time is not set, the rule is based on the last modified time by default.
            )
          ]
        )
      ]
    )
  ))

  print(f'status code: {result.status_code}, '
        f'request id: {result.request_id}')

if __name__ == "__main__":
  main()

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

// Define global variables.
var (
	region     string // The region where the bucket is located.
	bucketName string // The name of the bucket.
)

// The init function initializes command-line arguments.
func init() {
	flag.StringVar(&region, "region", "", "The region in which the bucket is located.")
	flag.StringVar(&bucketName, "bucket", "", "The name of the bucket.")
}

func main() {
	// Parse command-line arguments.
	flag.Parse()

	// Check if the bucket name is provided.
	if len(bucketName) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, bucket name required")
	}

	// Check if the region is provided.
	if len(region) == 0 {
		flag.PrintDefaults()
		log.Fatalf("invalid parameters, region required")
	}

	// Load the default configuration, and set the credentials provider and region.
	cfg := oss.LoadDefaultConfig().
		WithCredentialsProvider(credentials.NewEnvironmentVariableCredentialsProvider()).
		WithRegion(region)

	// Create an OSS client.
	client := oss.NewClient(cfg)

	// Create a request to set lifecycle rules for the bucket.
	request := &oss.PutBucketLifecycleRequest{
		Bucket: oss.Ptr(bucketName), // The name of the bucket.
		LifecycleConfiguration: &oss.LifecycleConfiguration{
			Rules: []oss.LifecycleRule{
				{
					// In lifecycle rule "rule1", transition all objects with the prefix "data/"
					// to the Infrequent Access (IA) storage class 200 days after they are last accessed.
					// When these objects are accessed again, they remain in the IA storage class.
					ID:     oss.Ptr("rule1"),
					Status: oss.Ptr("Enabled"),
					Prefix: oss.Ptr("data/"),
					Transitions: []oss.LifecycleRuleTransition{
						{
							Days:                 oss.Ptr(int32(200)),
							StorageClass:         oss.StorageClassIA,
							IsAccessTime:         oss.Ptr(true), // Set to true for a rule based on last access time.
							ReturnToStdWhenVisit: oss.Ptr(false),
						},
					},
				},
				{
					// In lifecycle rule "rule2", transition all objects with the prefix "log/"
					// to the Infrequent Access (IA) storage class 120 days after they are last accessed.
					// When these objects are accessed again, they remain in the IA storage class.
					// A single rule cannot contain more than one IsAccessTime=true Transition.
					// The 250-day Archive transition is configured in a separate rule (rule3) below.
					ID:     oss.Ptr("rule2"),
					Status: oss.Ptr("Enabled"),
					Prefix: oss.Ptr("log/"),
					Transitions: []oss.LifecycleRuleTransition{
						{
							Days:                 oss.Ptr(int32(120)),
							StorageClass:         oss.StorageClassIA,
							IsAccessTime:         oss.Ptr(true), // Set to true for a rule based on last access time.
							ReturnToStdWhenVisit: oss.Ptr(false),
						},
					},
				},
				{
					// In lifecycle rule "rule3", transition all objects with the prefix "log/"
					// to the Archive storage class 250 days after they are last accessed.
					// When these objects are accessed again, they remain in the Archive storage class.
					// This rule is separate from rule2 because a single rule cannot contain
					// more than one IsAccessTime=true Transition.
					ID:     oss.Ptr("rule3"),
					Status: oss.Ptr("Enabled"),
					Prefix: oss.Ptr("log/"),
					Transitions: []oss.LifecycleRuleTransition{
						{
							Days:                 oss.Ptr(int32(250)),
							StorageClass:         oss.StorageClassArchive,
							IsAccessTime:         oss.Ptr(true), // Set to true for a rule based on last access time.
							ReturnToStdWhenVisit: oss.Ptr(false),
						},
					},
				},
			},
		},
	}

	// Set the lifecycle rules for the bucket.
	result, err := client.PutBucketLifecycle(context.TODO(), request)
	if err != nil {
		log.Fatalf("failed to put bucket lifecycle %v", err)
	}

	// Print the result of setting the lifecycle rules.
	log.Printf("put bucket lifecycle result:%#v\n", result)
}

<?php

// Include the autoload file to load dependencies.
require_once __DIR__ . '/../vendor/autoload.php';

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

// Describe command-line parameters.
$optsdesc = [
    "region" => ['help' => 'The region in which the bucket is located', 'required' => True], // (Required) Specify the region in which the bucket is located.
    "endpoint" => ['help' => 'The domain names that other services can use to access OSS', 'required' => False], // (Optional) Specify the OSS endpoint.
    "bucket" => ['help' => 'The name of the bucket', 'required' => True], // (Required) Specify the name of the bucket.
];

// Generate a long options list to parse the command-line parameters.
$longopts = \array_map(function ($key) {
    return "$key:"; // Add a colon (:) to the end of each parameter to indicate that a value is required.
}, array_keys($optsdesc));

// Parse the command-line parameters.
$options = getopt("", $longopts); 

// Check whether the required parameters are missing.
foreach ($optsdesc as $key => $value) {
    if ($value['required'] === True && empty($options[$key])) {
        $help = $value['help'];
        echo "Error: the following arguments are required: --$key, $help"; // Display the required but missing parameters.
        exit(1); 
    }
}

// Obtain the values of the command-line parameters and assign the values to variables.
$region = $options["region"]; // The region in which the bucket is located.
$bucket = $options["bucket"]; // The name of the bucket.

// Load the AccessKey ID and AccessKey secret from environment variables.
$credentialsProvider = new Oss\Credentials\EnvironmentVariableCredentialsProvider();

// Use the default configuration of the SDK.
$cfg = Oss\Config::loadDefault();

// Specify the credential provider.
$cfg->setCredentialsProvider($credentialsProvider);

// Specify the region.
$cfg->setRegion($region);

// If an endpoint is provided, specify the endpoint.
if (isset($options["endpoint"])) {
    $cfg->setEndpoint($options["endpoint"]);
}

// Create an OSS client instance.
$client = new Oss\Client($cfg);

{}
$lifecycleRule = new Oss\Models\LifecycleRule(
    prefix: 'log/', // The prefix of object names.
    transitions: array(
        new Oss\Models\LifecycleRuleTransition(
            days: 30, // Specify the days.
            storageClass: 'IA', // Change to IA.
            isAccessTime: 'true', // Trigger the change based on the last access time.
            returnToStdWhenVisit: 'true' // Return to the Standard storage class after they are accessed.
        )
    ),
    id: 'rule', // The rule ID.
    status: 'Enabled' // Enable the rule.
);

// Create a lifecycle configuration and add lifecycle rules to the configuration.
$lifecycleConfiguration = new LifecycleConfiguration(
    rules: array($lifecycleRule)
);

// Create a request to set a lifecycle configuration and pass the lifecycle configuration.
$request = new Oss\Models\PutBucketLifecycleRequest(
    bucket: $bucket,
    lifecycleConfiguration: $lifecycleConfiguration
);

// Call the putBucketLifecycle method to configure the lifecycle rules.
$result = $client->putBucketLifecycle($request);

// Display the result.
printf(
    'status code:' . $result->statusCode . PHP_EOL . // The HTTP response status code.
    'request id:' . $result->requestId . PHP_EOL // The request ID.
);

ossutil

Use o ossutil para configurar regras de ciclo de vida. Para mais informações sobre como instalar o ossutil, consulte Install ossutil.

O exemplo a seguir mostra como configurar uma regra de ciclo de vida para o bucket examplebucket:

ossutil api put-bucket-lifecycle --bucket examplebucket--lifecycle-configuration "{\"Rule\":{\"ID\":\"rule1\",\"Prefix\":\"tmp/\",\"Status\":\"Enabled\",\"Expiration\":{\"Days\":\"10\"},\"Transition\":{\"Days\":\"5\",\"StorageClass\":\"IA\",\"IsAccessTime\":true,\"ReturnToStdWhenVisit\":true},\"AbortMultipartUpload\":{\"Days\":\"10\"}}}"

Para mais informações sobre este comando, consulte put-bucket-lifecycle.