Filter OSS objects by time range - : Central de Documentação do Alibaba Cloud

Para filtrar objetos em um bucket do Object Storage Service (OSS) por um intervalo de tempo específico, utilize o recurso de indexação de dados. Definir datas de início e fim com base na última modificação do objeto aumenta a eficiência das consultas. Esse recurso é ideal para cenários que exigem 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

Verificações de auditoria e conformidade

Empresas e organizações precisam revisar periodicamente as atividades de dados para garantir a conformidade. Consultar objetos carregados dentro de um intervalo de tempo específico ajuda a gerenciar o ciclo de vida dos dados, rastrear o histórico de criação e modificação e apoiar os processos de auditoria.
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 especificado permite identificar os alvos exatos de backup. Isso economiza espaço de armazenamento e reduz custos de transferência de dados.
Análise de dados e relatórios

Aplicações que envolvem análise de big data, processamento de logs ou relatórios de negócios frequentemente precisam processar novos dados gerados em um período específico, como diário, semanal ou mensal. Consultar objetos dentro de um intervalo de tempo definido agiliza a localização do conjunto de dados para análise e simplifica a extração de informações.
Sincronização de sistema de gerenciamento de conteúdo

Um sistema de gerenciamento de conteúdo deve sincronizar regularmente objetos novos ou atualizados para manter o conteúdo do site atualizado e completo.
Otimização de custos e limpeza de recursos

É necessário limpar periodicamente objetos obsoletos nas empresas. Consultar objetos que não foram atualizados dentro de um período especificado ajuda a identificar quais devem ser excluídos, garantindo a utilização eficiente dos recursos.
Solução de problemas e rastreamento de falhas

Durante a solução de problemas de falhas do sistema, perda de dados ou comportamento anormal, consultar objetos de um período específico facilita a localização rápida de registros operacionais ou objetos problemáticos.
Colaboração e controle de versão

Em ambientes de colaboração multiusuário, consultar objetos por intervalo de tempo permite navegar por versões históricas, comparar alterações ou restaurar dados para um ponto específico no tempo.

Procedimento

OSS console

Faça login no OSS console.
No painel de navegação à esquerda, clique em Buckets. Na página exibida, clique no nome do bucket desejado.
No painel de navegação à esquerda, escolha Object Management > Data Indexing.
Na página Data Indexing, ative a chave Metadata Management.

Após ativar o gerenciamento de metadados, a ativação leva algum tempo. O tempo necessário depende da quantidade de objetos no bucket.
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 outros parâmetros.
Na seção Object Sort Order, selecione Ascending para ordenar os resultados pelo nome do objeto.
Clique em Query.

Alibaba Cloud SDK

O OSS SDK for Java, o OSS SDK for Python e o OSS SDK for Go suportam indexação de dados para consultar objetos que atendem a condições específicas. É necessário ativar o gerenciamento de metadados no 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 exigir um alto grau de personalização, faça solicitações REST API diretamente. Nesse caso, é necessário escrever manualmente o código para calcular a assinatura. Para mais informações, consulte DoMetaQuery.

Referências

A indexação de dados suporta múltiplas condições de filtro, como classe de armazenamento, permissões de leitura/gravação e tamanho do objeto, para ajudar você a encontrar rapidamente os dados necessários. Por exemplo, é possível consultar todos os objetos com permissão de leitura pública ou todos os objetos menores que 64 KB. Para mais informações, consulte Indexação de dados.