Todos os produtos
Search
Central de documentação

:Filter OSS objects by time range

Última atualização: Sep 23, 2026

Para filtrar objetos em um bucket do Object Storage Service (OSS) por um intervalo de tempo específico, use o recurso de indexação de dados. Definir datas de início e fim com base na hora da última modificação do objeto melhora a eficiência das consultas. Esse recurso é útil em cenários que exigem a recuperação precisa de arquivos sensíveis ao tempo, como rastreamento de auditoria, sincronização de dados, backups periódicos e análise de custos.

Casos de uso

  • Auditoria e verificações de conformidade

    Empresas e organizações precisam revisar periodicamente as atividades de dados para garantir a conformidade. Consultar objetos enviados dentro de um intervalo de tempo específico facilita o gerenciamento do ciclo de vida dos dados, o rastreamento do histórico de criação e modificação, além de dar suporte aos processos de auditoria de dados.

  • Backup e recuperação de dados

    Ao executar operações de backup ou recuperação com base em uma política definida, consultar objetos novos ou atualizados dentro de um intervalo de tempo especificado ajuda a identificar os alvos exatos do backup, economizando espaço de armazenamento e custos de transferência de dados.

  • Análise de dados e geração de relatórios

    Em aplicações que envolvem análise de big data, processamento de log ou relatórios de negócios, frequentemente é necessário processar dados novos gerados em um período específico, como diário, semanal ou mensal. Consultar objetos dentro de um intervalo de tempo especificado permite localizar rapidamente o conjunto de dados para análise e simplifica a extração de dados.

  • Sincronização de sistemas de gerenciamento de conteúdo

    Um sistema de gerenciamento de conteúdo precisa sincronizar regularmente objetos novos ou atualizados para manter o conteúdo do site atual e completo.

  • Otimização de custos e limpeza de recursos

    Empresas precisam limpar periodicamente objetos obsoletos. Consultar objetos que não foram atualizados dentro de um período de tempo especificado ajuda a identificar quais devem ser excluídos, garantindo uma utilização eficiente dos recursos.

  • Solução de problemas e rastreamento de incidentes

    Ao solucionar falhas de sistema, perda de dados ou comportamentos anormais, consultar objetos dentro de um período de tempo específico permite localizar rapidamente objetos problemáticos ou registros de operações.

  • Colaboração e controle de versão

    Em ambientes de colaboração com múltiplos usuários, consultar objetos dentro de um intervalo de tempo permite navegar por versões históricas, comparar alterações ou restaurar dados a um ponto específico no tempo.

Procedimento

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 Object Management > Data Indexing.

  4. Na página Data Indexing, ative o switch Metadata Management.

    Após ativar o gerenciamento de metadados, a ativação leva algum tempo. O tempo de ativação depende do número de objetos no bucket.

  5. Na seção OSS metadata condition, defina as datas de início e fim para Last Modified At (com precisão de segundos). Mantenha as configurações padrão para os demais parâmetros.

  6. Na seção Object Sort Order, selecione Ascending para ordenar os resultados pelo nome do objeto.

  7. Clique em Query.

Alibaba Cloud SDK

O OSS SDK for Java, OSS SDK for Python e OSS SDK for Go oferecem suporte à indexação de dados para consultar objetos que atendam às condições especificadas. Ative o gerenciamento de metadados para o bucket de destino antes de usar esse recurso.

Java

package com.aliyun.sts.sample;

import com.aliyun.oss.ClientException;
import com.aliyun.oss.OSS;
import com.aliyun.oss.common.auth.*;
import com.aliyun.oss.OSSClientBuilder;
import com.aliyun.oss.OSSException;
import com.aliyun.oss.model.*;

public class Demo {

    // This example uses the endpoint of the China (Hangzhou) region. Replace the value with your actual endpoint.
    private static String endpoint = "https://oss-cn-hangzhou.aliyuncs.com";
    // Specify the region that corresponds to your endpoint. For example, if your endpoint is oss-cn-hangzhou.aliyuncs.com, set the region to cn-hangzhou.
    private static String region = "cn-hangzhou";
    
    // Specify the bucket name. Example: examplebucket.
    private static String bucketName = "examplebucket";

    public static void main(String[] args) throws Exception {
        // Obtain access credentials from environment variables. Before you run this code, make sure that you have configured the OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET environment variables.
        EnvironmentVariableCredentialsProvider credentialsProvider = CredentialsProviderFactory.newEnvironmentVariableCredentialsProvider();
        // Create an OSSClient instance.
        // Call the shutdown method to release resources when the OSSClient instance is no longer needed.
        ClientBuilderConfiguration clientBuilderConfiguration = new ClientBuilderConfiguration();
        // Explicitly declare that the V4 signature algorithm is used.
        clientBuilderConfiguration.setSignatureVersion(SignVersion.V4);
        OSS ossClient = OSSClientBuilder.create()
                .endpoint(endpoint)
                .credentialsProvider(credentialsProvider)
                .clientConfiguration(clientBuilderConfiguration)
                .region(region)
                .build();

        try {
            // Set the maximum number of objects to return to 100.
            int maxResults = 100;
            // Query objects that were last modified between December 1, 2023 and March 31, 2024.
            String query = "{\n" +
                    "  \"SubQueries\":[\n" +
                    "    {\n" +
                    "      \"Field\":\"FileModifiedTime\",\n" +
                    "      \"Value\": \"2023-12-01T00:00:00.000+08:00\",\n" +
                    "      \"Operation\":\"gt\"\n" +
                    "    },         \n" +
                    "    {\n" +
                    "      \"Field\":\"FileModifiedTime\",\n" +
                    "      \"Value\": \"2024-03-31T23:59:59.000+08:00\",\n" +
                    "      \"Operation\":\"lt\"\n" +
                    "    }\n" +
                    "  ],\n" +
                    "  \"Operation\":\"and\"\n" +
                    "}";
            // Sort the results by object name in ascending order.
            String sort = "Filename";
            DoMetaQueryRequest doMetaQueryRequest = new DoMetaQueryRequest(bucketName, maxResults, query, sort);
            doMetaQueryRequest.setOrder(SortOrder.ASC);
            DoMetaQueryResult doMetaQueryResult = ossClient.doMetaQuery(doMetaQueryRequest);

            if (doMetaQueryResult.getFiles() != null) {
                for (ObjectFile file : doMetaQueryResult.getFiles().getFile()) {
                    System.out.println("Filename: " + file.getFilename());
                    // Obtain the object's ETag.
                    System.out.println("ETag: " + file.getETag());
                    // Obtain the access control list (ACL) of the object.
                    System.out.println("ObjectACL: " + file.getObjectACL());
                    // Obtain the object type.
                    System.out.println("OssObjectType: " + file.getOssObjectType());
                    // Obtain the object storage class.
                    System.out.println("OssStorageClass: " + file.getOssStorageClass());
                    // Obtain the number of object tags.
                    System.out.println("TaggingCount: " + file.getOssTaggingCount());
                    if (file.getOssTagging() != null) {
                        for (Tagging tag : file.getOssTagging().getTagging()) {
                            System.out.println("Key: " + tag.getKey());
                            System.out.println("Value: " + tag.getValue());
                        }
                    }
                    if (file.getOssUserMeta() != null) {
                        for (UserMeta meta : file.getOssUserMeta().getUserMeta()) {
                            System.out.println("Key: " + meta.getKey());
                            System.out.println("Value: " + meta.getValue());
                        }
                    }
                }
            }
        } catch (OSSException oe) {
            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("Error Message: " + ce.getMessage());
        } finally {
            // Shut down the OSSClient instance.
            ossClient.shutdown();
        }
    }
}

Python

# -*- coding: utf-8 -*-
import oss2
from oss2.credentials import EnvironmentVariableCredentialsProvider
from oss2.models import MetaQuery, AggregationsRequest
# Obtain access credentials from environment variables. Before you run this code, make sure that you have configured the OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET environment variables.
auth = oss2.ProviderAuth(EnvironmentVariableCredentialsProvider())

# This example uses the endpoint of the China (Hangzhou) region. Replace the value with your actual endpoint.
# Specify the bucket name. Example: examplebucket.
bucket = oss2.Bucket(auth, 'http://oss-cn-hangzhou.aliyuncs.com', 'examplebucket0703')

# Query objects last modified between December 1, 2023 and March 31, 2024, and sort the results by object name in ascending order.
do_meta_query_request = MetaQuery(max_results=100, query='{"SubQueries":[{"Field":"FileModifiedTime","Value": "2023-12-01T00:00:00.000+08:00","Operation":"gt"}, {"Field":"FileModifiedTime","Value": "2024-03-31T23:59:59.000+08:00","Operation":"lt"}],"Operation":"and"}', sort='Filename', order='asc')
result = bucket.do_bucket_meta_query(do_meta_query_request)

for s in result.files:
    print(s.file_name)
    print(s.etag)
    print(s.oss_object_type)
    print(s.oss_storage_class)
    print(s.oss_crc64)
    print(s.object_acl)

Go

package main

import (
	"fmt"
	"github.com/aliyun/aliyun-oss-go-sdk/oss"
	"os"
)

func main() {
	// Obtain access credentials from environment variables. Before you run this code, make sure that you have configured the OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET environment variables.
	provider, err := oss.NewEnvironmentVariableCredentialsProvider()
	if err != nil {
		fmt.Println("Error:", err)
		os.Exit(-1)
	}

	// Create an OSSClient instance.
	// This example uses the endpoint for the China (Hangzhou) region. Replace the value with your actual endpoint.
	client, err := oss.New("oss-cn-hangzhou.aliyuncs.com", "", "", oss.SetCredentialsProvider(&provider))
	if err != nil {
		fmt.Println("Error:", err)
		os.Exit(-1)
	}
	// Query objects that were last modified between December 1, 2023 and March 31, 2024.
	query := oss.MetaQuery{
		NextToken:  "",
		MaxResults: 100,
		Query: `{
  "SubQueries":[
    {
      "Field":"FileModifiedTime",
      "Value": "2023-12-01T00:00:00.000+08:00",
      "Operation":"gt"
    },         
    {
      "Field":"FileModifiedTime",
      "Value": "2024-03-31T23:59:59.000+08:00",
      "Operation":"lt"
    }
  ],
  "Operation":"and"
}`,
                // Sort the results by object name in ascending order.
		Sort:  "Filename",
		Order: "asc",
	}
	// Query for objects that meet the specified conditions and list the object information based on the specified fields and sort order.
	result, err := client.DoMetaQuery("examplebucket", query)
	if err != nil {
		fmt.Println("Error:", err)
		os.Exit(-1)
	}
	fmt.Printf("NextToken:%s\n", result.NextToken)
	for _, file := range result.Files {
		fmt.Printf("File name: %s\n", file.Filename)
		fmt.Printf("size: %d\n", file.Size)
		fmt.Printf("File Modified Time:%s\n", file.FileModifiedTime)
		fmt.Printf("Oss Object Type:%s\n", file.OssObjectType)
		fmt.Printf("Oss Storage Class:%s\n", file.OssStorageClass)
		fmt.Printf("Object ACL:%s\n", file.ObjectACL)
		fmt.Printf("ETag:%s\n", file.ETag)
		fmt.Printf("Oss CRC64:%s\n", file.OssCRC64)
		fmt.Printf("Oss Tagging Count:%d\n", file.OssTaggingCount)
		for _, tagging := range file.OssTagging {
			fmt.Printf("Oss Tagging Key:%s\n", tagging.Key)
			fmt.Printf("Oss Tagging Value:%s\n", tagging.Value)
		}
		for _, userMeta := range file.OssUserMeta {
			fmt.Printf("Oss User Meta Key:%s\n", userMeta.Key)
			fmt.Printf("Oss User Meta Key Value:%s\n", userMeta.Value)
		}
	}
}

REST API

Se sua aplicação exige um alto grau de personalização, você pode fazer requisições diretamente pela REST API. Isso requer a escrita manual de código para calcular a assinatura. Para obter mais informações, consulte DoMetaQuery.

Referências

A indexação de dados oferece suporte a múltiplas condições de filtro, como classe de armazenamento, permissões de leitura/gravação e tamanho do objeto, para ajudá-lo a localizar rapidamente os dados necessários. Por exemplo, é possível consultar todos os objetos com permissões de leitura pública ou todos os objetos menores que 64 KB. Para obter mais informações, consulte Data indexing.