Todos os produtos
Search

Este produto

    ApsaraDB for HBase:Separação de dados quentes e frios

    Central de documentação

    ApsaraDB for HBase:Separação de dados quentes e frios

    Última atualização: Jun 27, 2026

    O ApsaraDB for HBase Performance-enhanced Edition separa automaticamente dados quentes e frios em diferentes camadas de armazenamento com base em um limite de tempo definido por você. Os dados quentes permanecem em armazenamento rápido para acesso ágil, enquanto os dados frios migram para um armazenamento frio de baixo custo. Isso reduz as despesas de armazenamento em dois terços em comparação com discos ultra.

    Quando usar este recurso

    A separação de dados frios e quentes é ideal para:

    • Cargas de trabalho de séries temporais nas quais dados recentes têm acesso frequente, mas dados antigos raramente são consultados (como registros de pedidos ou métricas de monitoramento)

    • Casos de uso que exigem consulta a dados frios e quentes em uma única tabela, sem necessidade de manter tabelas separadas

    Evite este recurso se:

    • Sua carga de trabalho envolver atualizações frequentes de dados históricos. Atualizar um campo no armazenamento frio move esse campo de volta para o armazenamento quente, o que pode causar resultados de consulta inesperados.

    Como funciona

    Ao gravar dados em uma tabela, o ApsaraDB for HBase Performance-enhanced Edition compara o timestamp dos dados com o valor COLD_BOUNDARY configurado. O timestamp de cada registro corresponde ao momento da gravação na tabela. Novos dados vão para o armazenamento quente (discos padrão). Com o tempo, quando os dados ultrapassam o limite definido, o sistema os move automaticamente para o armazenamento frio durante a próxima compactação principal (major compaction), de forma transparente para sua aplicação.

    A movimentação de dados ocorre em ambas as direções: de frio para quente e de quente para frio.

    O throughput do armazenamento frio é inferior ao do armazenamento quente. Projete suas consultas para acessar dados quentes quando o tempo de resposta for crítico.

    Pré-requisitos

    Antes de começar, verifique se você possui:

    Configure o limite de tempo

    O parâmetro COLD_BOUNDARY define por quanto tempo os dados permanecem no armazenamento quente antes de migrarem para o armazenamento frio. O valor é especificado em segundos.

    Por exemplo, COLD_BOUNDARY=86400 indica que dados gravados há mais de 86.400 segundos (um dia) são tratados como dados frios.

    Use o HBase Shell ou a API Java para criar uma tabela com separação de dados frios e quentes ou alterar o limite em uma tabela existente.

    HBase Shell

    // Create a table with cold and hot data separation.
hbase(main):002:0> create 'chsTable', {NAME=>'f', COLD_BOUNDARY=>'86400'}

// Change the time boundary on an existing table.
hbase(main):005:0> alter 'chsTable', {NAME=>'f', COLD_BOUNDARY=>'86400'}

// Disable cold and hot data separation.
hbase(main):004:0> alter 'chsTable', {NAME=>'f', COLD_BOUNDARY=>""}
    Antes de mover dados do armazenamento frio de volta para o quente, execute uma compactação principal (major compaction) na tabela.

    Java API

    Admin admin = connection.getAdmin();
TableName tableName = TableName.valueOf("chsTable");

// Create a table with cold and hot data separation.
// COLD_BOUNDARY is in seconds. This example archives data as cold after one day.
HTableDescriptor descriptor = new HTableDescriptor(tableName);
HColumnDescriptor cf = new HColumnDescriptor("f");
cf.setValue(AliHBaseConstants.COLD_BOUNDARY, "86400");
descriptor.addFamily(cf);
admin.createTable(descriptor);

// Change the time boundary on an existing table.
HTableDescriptor descriptor = admin.getTableDescriptor(tableName);
HColumnDescriptor cf = descriptor.getFamily("f".getBytes());
cf.setValue(AliHBaseConstants.COLD_BOUNDARY, "86400");
admin.modifyTable(tableName, descriptor);

// Disable cold and hot data separation.
// Run a major compaction before moving cold data back to hot storage.
HTableDescriptor descriptor = admin.getTableDescriptor(tableName);
HColumnDescriptor cf = descriptor.getFamily("f".getBytes());
cf.setValue(AliHBaseConstants.COLD_BOUNDARY, null);
admin.modifyTable(tableName, descriptor);
    Não defina a propriedade da família de colunas como COLD . Caso já esteja definida, remova-a. Para mais detalhes, consulte Armazenamento frio .

    Grave dados

    Grave dados da mesma forma que faria em uma tabela padrão; nenhuma alteração no código do cliente é necessária. O timestamp de cada registro determina a camada de armazenamento de destino. Consulte Usar a API Java do HBase para acessar clusters do ApsaraDB for HBase Performance-enhanced Edition e Usar a API multilíngue para acessar clusters do ApsaraDB for HBase Performance-enhanced Edition.

    Consulte dados

    Todas as consultas têm como alvo uma única tabela, eliminando a necessidade de consultar armazenamentos frios e quentes separadamente. O sistema roteia cada consulta automaticamente.

    Existem três padrões de consulta:

    Padrão

    Funcionamento

    Indicado quando

    Padrão (sem hint)

    Verifica dados quentes e frios e mescla os resultados

    Você precisa de resultados completos, independentemente da camada de armazenamento

    HOT_ONLY=true

    Verifica apenas o armazenamento quente; não retorna resultado se a linha estiver no armazenamento frio

    Você deseja respostas rápidas e precisa apenas de dados recentes

    TimeRange

    O sistema determina a camada de armazenamento com base no intervalo de tempo e no COLD_BOUNDARY; verifica apenas a camada relevante

    Você conhece o intervalo de tempo dos dados necessários
    Os valores de TIMERANGE nas operações GET e Scan são expressos em milissegundos .

    Exemplos de Get

    HBase Shell

    // Default: may scan cold data.
hbase(main):013:0> get 'chsTable', 'row1'

// HOT_ONLY: scans only hot storage. No result is returned if the row is in cold storage.
hbase(main):015:0> get 'chsTable', 'row1', {HOT_ONLY=>true}

// TimeRange: system determines scope from TimeRange and COLD_BOUNDARY. Value is in milliseconds.
hbase(main):016:0> get 'chsTable', 'row1', {TIMERANGE => [0, 1568203111265]}

    Java API

    Table table = connection.getTable("chsTable");

// Default: may scan cold data.
Get get = new Get("row1".getBytes());
System.out.println("result: " + table.get(get));

// HOT_ONLY: scans only hot storage. No result is returned if the row is in cold storage.
get = new Get("row1".getBytes());
get.setAttribute(AliHBaseConstants.HOT_ONLY, Bytes.toBytes(true));

// TimeRange: system determines scope from TimeRange and COLD_BOUNDARY. Value is in milliseconds.
get = new Get("row1".getBytes());
get.setTimeRange(0, 1568203111265);

    Exemplos de Scan

    Sem o uso de HOT_ONLY ou de um intervalo de tempo, a operação Scan lê dados quentes e frios e mescla os resultados.

    HBase Shell

    // Default: scans both hot and cold data.
hbase(main):017:0> scan 'chsTable', {STARTROW =>'row1', STOPROW=>'row9'}

// HOT_ONLY: scans only hot storage.
hbase(main):018:0> scan 'chsTable', {STARTROW =>'row1', STOPROW=>'row9', HOT_ONLY=>true}

// TimeRange: system determines scope from TimeRange and COLD_BOUNDARY. Value is in milliseconds.
hbase(main):019:0> scan 'chsTable', {STARTROW =>'row1', STOPROW=>'row9', TIMERANGE => [0, 1568203111265]}

    Java API

    TableName tableName = TableName.valueOf("chsTable");
Table table = connection.getTable(tableName);

// Default: scans both hot and cold data.
Scan scan = new Scan();
ResultScanner scanner = table.getScanner(scan);
for (Result result : scanner) {
    System.out.println("scan result:" + result);
}

// HOT_ONLY: scans only hot storage.
scan = new Scan();
scan.setAttribute(AliHBaseConstants.HOT_ONLY, Bytes.toBytes(true));

// TimeRange: system determines scope from TimeRange and COLD_BOUNDARY. Value is in milliseconds.
scan = new Scan();
scan.setTimeRange(0, 1568203111265);

    Priorize dados quentes nos resultados de Scan

    Em cargas de trabalho como consulta de todos os pedidos ou mensagens de chat de um cliente, os resultados geralmente são ordenados por timestamp em ordem decrescente, fazendo com que os dados recentes (quentes) apareçam primeiro. Por padrão, o sistema ainda verifica ambas as camadas, o que aumenta a latência da consulta quando há dados frios envolvidos.

    Definir COLD_HOT_MERGE=true instrui o sistema a verificar primeiro o armazenamento quente. Os dados frios são buscados apenas se mais resultados forem necessários (por exemplo, quando um usuário avança para páginas anteriores nos resultados). Isso reduz o acesso a dados frios e melhora o tempo de resposta inicial.

    HBase Shell

    hbase(main):002:0> scan 'chsTable', {COLD_HOT_MERGE=>true}

    Java API

    scan = new Scan();
scan.setAttribute(AliHBaseConstants.COLD_HOT_MERGE, Bytes.toBytes(true));
scanner = table.getScanner(scan);

    Quando COLD_HOT_MERGE=true está ativo, os resultados para dados quentes e frios retornam separadamente, cada um classificado pela chave de linha. O conjunto geral de resultados não recebe uma classificação global. O exemplo abaixo ilustra a diferença:

    // Default scan: rows sorted lexicographically. coldRow appears before hotRow.
hbase(main):001:0> scan 'chsTable'
ROW                                                                COLUMN+CELL
 coldRow                                                              column=f:value, timestamp=1560578400000, value=cold_value
 hotRow                                                               column=f:value, timestamp=1565848800000, value=hot_value
2 row(s)

// COLD_HOT_MERGE=true: hot data is returned first, then cold data.
hbase(main):002:0> scan 'chsTable', {COLD_HOT_MERGE=>true}
ROW                                                                COLUMN+CELL
 hotRow                                                               column=f:value, timestamp=1565848800000, value=hot_value
 coldRow                                                              column=f:value, timestamp=1560578400000, value=cold_value
2 row(s)
    Se uma linha foi parcialmente atualizada (com alguns campos movidos de volta para o armazenamento quente), COLD_HOT_MERGE=true retorna duas entradas para essa chave de linha: uma do armazenamento quente e outra do frio. Para garantir uma ordenação consistente dentro de uma camada, use uma chave de linha composta. Por exemplo, em uma tabela de pedidos, combine o ID do cliente e o horário de criação do pedido na chave de linha para organizar cronologicamente os pedidos de um determinado cliente.

    Observações de uso

    • Use HOT_ONLY ou TimeRange na maioria das consultas. O armazenamento frio destina-se ao arquivamento, não ao acesso frequente. Se o cluster apresentar muitas consultas acessando dados frios, verifique se o valor de COLD_BOUNDARY está adequado.

    • Evite atualizar dados frios. Atualizar um campo em uma linha do armazenamento frio move esse campo de volta para o armazenamento quente. Consultas subsequentes que utilizem HOT_ONLY ou um intervalo de tempo voltado para dados quentes retornarão apenas o campo atualizado, e não a linha completa. Caso precise retornar a linha inteira, remova o hint HOT_ONLY ou defina um intervalo de tempo que abranja desde o momento da gravação original até a última atualização. Se atualizações frequentes em dados frios forem inevitáveis, ajuste o COLD_BOUNDARY para mover previamente os dados afetados de volta ao armazenamento quente.

    Verifique os tamanhos dos dados frios e quentes

    Visualize os tamanhos dos dados frios e quentes por tabela na aba User tables no ClusterManager. Para mais detalhes, consulte Sistema de gerenciamento de cluster.

    Se nenhum dado aparecer no armazenamento frio, os dados podem estar apenas na memória de acesso aleatório (RAM). Execute o comando flush para descarregar os dados no disco, execute uma compactação principal (major compaction) e verifique novamente.

    Próximos passos