Differenze tra HBase e Bigtable

Un modo per accedere a Bigtable è utilizzare una versione personalizzata del client Apache HBase per Java. In generale, il client personalizzato espone la stessa API di un'installazione standard di HBase. Questa pagina descrive le differenze tra il client HBase di Cloud Bigtable per Java e un'installazione HBase standard. Molte di queste differenze sono legate alle attività di gestione che Bigtable gestisce automaticamente.

Il client HBase di Cloud Bigtable per Java è destinato ai clienti che eseguono la migrazione a Bigtable da HBase e vogliono continuare a utilizzare l'API HBase. In tutti gli altri casi, gli sviluppatori Java devono utilizzare il client Cloud Bigtable per Java, che chiama le API Bigtable.

Famiglie di colonne

Quando crei un famiglia di colonne, non puoi configurare la dimensione del blocco o il metodo di compressione, né con la shell HBase né tramite l'API HBase. Bigtable gestisce le dimensioni e la compressione dei blocchi per te.

Inoltre, se utilizzi la shell HBase per ottenere informazioni su una tabella, la shell HBase segnalerà sempre che ogni famiglia di colonne non utilizza la compressione. In realtà, Bigtable utilizza metodi di compressione proprietari per tutti i tuoi dati.

Le seguenti impostazioni della famiglia di colonne vengono ignorate perché Bigtable gestisce lo spazio di archiviazione sottostante per te:

  • BLOCKCACHE
  • BLOCKSIZE
  • BLOOMFILTER
  • CACHE_BLOOMS_ON_WRITE
  • CACHE_DATA_IN_L1
  • CACHE_DATA_ON_WRITE
  • CACHE_INDEX_ON_WRITE
  • COMPRESS_TAGS
  • COMPRESSION
  • COMPRESSION_COMPACT
  • DATA_BLOCK_ENCODING
  • EVICT_BLOCKS_ON_CLOSE
  • IN_MEMORY
  • KEEP_DELETED_CELLS
  • PREFETCH_BLOCKS_ON_OPEN
  • REPLICATION_SCOPE

Le impostazioni VERSIONS, MIN_VERSIONS e TTL vengono convertite in policy di garbage collection di Bigtable.

Bigtable richiede che i nomi famiglia di colonne seguano l'espressione regolare [_a-zA-Z0-9][-_.a-zA-Z0-9]*. Se importi dati in Bigtable da HBase, potresti dover prima modificare i nomi delle famiglie in modo che seguano questo pattern.

Righe e celle

  • Non puoi definire un ACL per una singola riga. Le viste autorizzate di Bigtable consentono di concedere l'accesso a un sottoinsieme dei dati di una tabella, ma non sono esposte tramite l'API HBase.
  • Non puoi impostare la visibilità di singole celle.
  • I tag non sono supportati. Non puoi utilizzare la classe org.apache.hadoop.hbase.Tag per aggiungere metadati alle singole celle. Tutti i tag aggiunti a una cella vengono eliminati prima della scrittura della cella.

Mutazioni ed eliminazioni

  • Le operazioni Append in Bigtable sono completamente atomiche sia per i lettori che per gli scrittori. I lettori non potranno mai leggere un'operazione Append applicata parzialmente.
  • Le operazioni Increment sono atomiche, ma l'impostazione di un intervallo di tempo su un Increment non è supportata.
  • Un oggetto RowMutations che passi a Table#mutateRow() può contenere operazioni Put e Delete oppure operazioni Append e Increment, ma non entrambe. Gli oggetti RowMutations che contengono operazioni Append o Increment non sono supportati in batch(), checkAndMutate() o BufferedMutator.

  • È supportata l'eliminazione di una versione specifica di una colonna specifica in base al relativo timestamp. Tuttavia, i seguenti tipi di eliminazioni non sono supportati:

    • Eliminazione solo dell'ultima versione di una colonna
    • Eliminazione di tutti i valori in una riga con un timestamp specifico
    • Eliminazione di tutti i valori in una famiglia di colonne in corrispondenza o prima di un timestamp specifico

    Di conseguenza, i seguenti metodi nella classe org.apache.hadoop.hbase.client.Delete non sono supportati: + new Delete(byte[] row, long timestamp) + addColumn(byte[] family, byte[] qualifier) + addFamily(byte[] family, long timestamp) + addFamilyVersion(byte[] family, long timestamp)

  • In HBase, le eliminazioni mascherano gli inserimenti, ma Bigtable non maschera gli inserimenti dopo le eliminazioni quando le richieste di inserimento vengono inviate dopo le richieste di eliminazione. Ciò significa che in Bigtable una richiesta di scrittura inviata a una cella non è interessata da una richiesta di eliminazione inviata in precedenza alla stessa cella.

Get e scansioni

Coprocessori

I coprocessori non sono supportati. Non puoi creare classi che implementano l'interfaccia org.apache.hadoop.hbase.coprocessor.

Filtri

La tabella seguente elenca i filtri supportati nel pacchetto org.apache.hadoop.hbase.filter. Tutti gli altri filtri di quel pacchetto non sono supportati e generano un UnsupportedOperationException.

Supportato Supportato, con limitazioni
  1. PrefixFilter esegue la scansione delle righe in PrefixFilter nella maggior parte dei casi. Tuttavia, se PrefixFilter fa parte di un FilterList e ha l'operatore MUST_PASS_ONE, Bigtable non può determinare l'intervallo implicito ed esegue invece una scansione non filtrata dalla riga iniziale alla riga finale. In questo caso, utilizza PrefixFilter con BigtableExtendedScan o una combinazione di filtri per ottimizzare il rendimento.
  2. Richiede una singola famiglia di colonne solo quando utilizzi un qualificatore di colonna come offset di colonna.
  3. Supporta una sola famiglia di colonne.
  4. Supporta solo l'operatore EQUAL, con il comparatore BinaryComparator o il comparatore RegexStringComparator.
  5. La creazione del filtro con new KeyOnlyFilter(true) non è supportata.
  6. Non può far parte di un FilterList che utilizza l'operatore MUST_PASS_ONE.
  7. Un PageFilter deve essere il filtro di primo livello o l'ultimo filtro in un FilterList di primo livello che utilizza l'operatore MUST_PASS_ALL, che è il comportamento predefinito. Un PageFilter in un FilterList che utilizza l'operatore MUST_PASS_ONE non è supportato.
  8. Supporta solo l'operatore di confronto BinaryComparator o l'operatore di confronto RegexStringComparator con l'operatore EQUAL. Se viene utilizzato un operatore diverso da EQUAL, è supportata una sola famiglia di colonne.
  9. Supporta solo i seguenti comparatori:
    • BinaryComparator
    • RegexStringComparator senza flag (i flag vengono ignorati) e l'operatore EQUAL
  10. Si basa sul filtro delle condizioni di Bigtable, che può essere lento. Supportato, ma non consigliato.
  11. È supportato un solo WhileMatchFilter per scansione.
ColumnCountGetFilter
ColumnPrefixFilter
FilterList
FirstKeyOnlyFilter
FuzzyRowFilter
MultipleColumnPrefixFilter
PrefixFilter 1
RandomRowFilter
TimestampsFilter 		ColumnPaginationFilter 2
ColumnRangeFilter 3
FamilyFilter 4
KeyOnlyFilter 5
MultiRowRangeFilter 6
PageFilter 7
QualifierFilter 8
RowFilter 4
SingleColumnValueExcludeFilter 3, 9, 10
SingleColumnValueFilter 9, 10
ValueFilter 9
WhileMatchFilter 6, 11

Inoltre, le seguenti differenze influiscono sui filtri Bigtable:

  • Sono supportati solo i comparatori BinaryComparator e RegexStringComparator. Tutti gli altri comparatori non sono supportati e generano un errore UnsupportedOperationException.
  • Nei filtri che utilizzano l'operatore di confronto delle espressioni regolari (org.apache.hadoop.hbase.filter.RegexStringComparator), le espressioni regolari utilizzano la sintassi RE2, non la sintassi Java.
  • I filtri personalizzati non sono supportati. Non puoi creare classi che ereditano da org.apache.hadoop.hbase.filter.Filter. Per utilizzare un filtro Bigtable che non ha un equivalente HBase, inseriscilo in un com.google.cloud.bigtable.hbase.filter.BigtableFilter.
  • Le espressioni di filtro hanno un limite di dimensioni di 20 kB e i filtri non possono essere nidificati per più di 20 livelli. Come soluzione alternativa per ridurre le dimensioni di un'espressione di filtro, utilizza una colonna supplementare che memorizza il valore hash dei criteri di filtro.

Timestamp

Bigtable memorizza i timestamp in microsecondi, mentre HBase li memorizza in millisecondi. Questa distinzione ha implicazioni quando utilizzi la libreria client HBase per Bigtable e hai dati con timestamp invertiti.

La libreria client esegue la conversione tra microsecondi e millisecondi, ma poiché il timestamp HBase più grande che Bigtable può archiviare è Long.MAX_VALUE/1000, qualsiasi valore superiore viene convertito in Long.MAX_VALUE/1000. Di conseguenza, i valori di timestamp invertiti di grandi dimensioni potrebbero non essere convertiti correttamente.

Amministrazione

Questa sezione descrive in che modo il client HBase Bigtable per Java implementa l'interfaccia org.apache.hadoop.hbase.client.Admin. Poiché Bigtable gestisce automaticamente la maggior parte delle attività di gestione dei cluster e dello spazio di archiviazione, molti metodi amministrativi di HBase non sono applicabili. Qualsiasi metodo Admin non elencato in questa sezione come supportato o come privo di effetto non è supportato e genera un UnsupportedOperationException.

Gestione dei tavoli

Sono supportati i seguenti metodi Admin per la gestione di tabelle e famiglie di colonne:

  • addColumnFamily(TableName tableName, ColumnFamilyDescriptor columnFamily) e addColumnFamilyAsync(TableName tableName, ColumnFamilyDescriptor columnFamily) (HBase 1.x: addColumn(TableName tableName, HColumnDescriptor column))
  • createTable(TableDescriptor desc), createTable(TableDescriptor desc, byte[][] splitKeys), createTable(TableDescriptor desc, byte[] startKey, byte[] endKey, int numRegions), createTableAsync(TableDescriptor desc) e createTableAsync(TableDescriptor desc, byte[][] splitKeys)
  • deleteColumnFamily(TableName tableName, byte[] columnName) e deleteColumnFamilyAsync(TableName tableName, byte[] columnName) (HBase 1.x: deleteColumn(TableName tableName, byte[] columnName))
  • deleteTable(TableName tableName), deleteTableAsync(TableName tableName), deleteTables(Pattern pattern) e deleteTables(String regex)
  • disableTable(TableName tableName), disableTableAsync(TableName tableName), disableTables(Pattern pattern) e disableTables(String regex)
  • enableTable(TableName tableName), enableTableAsync(TableName tableName), enableTables(Pattern pattern) e enableTables(String regex)
  • getAlterStatus(TableName tableName) e getAlterStatus(byte[] tableName)
  • getDescriptor(TableName tableName), getTableDescriptor(TableName tableName), getTableDescriptors(List<String> names) e getTableDescriptorsByTableName(List<TableName> tableNames)
  • isTableAvailable(TableName tableName) e isTableAvailable(TableName tableName, byte[][] splitKeys)
  • isTableDisabled(TableName tableName) e isTableEnabled(TableName tableName)
  • listTableDescriptors(), listTableDescriptors(List<TableName> tableNames), listTableDescriptors(Pattern pattern) e listTableDescriptors(Pattern pattern, boolean includeSysTables) (HBase 1.x: listTables(), listTables(Pattern pattern), listTables(Pattern pattern, boolean includeSysTables), listTables(String regex) e listTables(String regex, boolean includeSysTables))
  • listTableNames(), listTableNames(Pattern pattern), listTableNames(Pattern pattern, boolean includeSysTables), listTableNames(String regex) e listTableNames(String regex, boolean includeSysTables)
  • modifyColumnFamily(TableName tableName, ColumnFamilyDescriptor columnFamily) e modifyColumnFamilyAsync(TableName tableName, ColumnFamilyDescriptor columnFamily) (HBase 1.x: modifyColumn(TableName tableName, HColumnDescriptor column))
  • modifyTable(TableDescriptor td), modifyTable(TableName tableName, TableDescriptor td), modifyTableAsync(TableDescriptor td) e modifyTableAsync(TableName tableName, TableDescriptor td)
  • tableExists(TableName tableName)
  • truncateTable(TableName tableName, boolean preserveSplits) e truncateTableAsync(TableName tableName, boolean preserveSplits)

I seguenti metodi di gestione delle tabelle supportati si comportano in modo diverso su Bigtable o ignorano determinati parametri:

  • Le tabelle Bigtable non possono essere disattivate. disableTable(), disableTableAsync(), disableTables(), enableTable(), enableTableAsync() e enableTables() modificano lo stato della tabella solo nella memoria del client (che isTableDisabled() e isTableEnabled() leggono).
  • modifyTable() e modifyTableAsync() applicano solo le modifiche alle famiglie di colonne. Gli attributi a livello di tabella vengono ignorati.
  • truncateTable() e truncateTableAsync() eliminano tutti i dati nella tabella. Il parametro preserveSplits viene ignorato.
  • I sovraccarichi listTableDescriptors(), listTables() e listTableNames() che accettano un parametro includeSysTables ignorano includeSysTables, perché Bigtable non dispone di tabelle di sistema.
  • isTableAvailable(TableName tableName, byte[][] splitKeys) verifica solo se la tabella esiste e ignora il parametro splitKeys.
  • getAlterStatus() restituisce sempre (0, 0) perché le modifiche allo schema in Bigtable sono sincrone.

Attività come la compattazione e la suddivisione delle tabelle vengono gestite automaticamente. Di conseguenza, i seguenti metodi non hanno alcun effetto:

  • compact(TableName tableName)
  • compact(TableName tableName, byte[] columnFamily)
  • majorCompact(TableName tableName)
  • majorCompact(TableName tableName, byte[] columnFamily)
  • split(TableName tableName)
  • split(TableName tableName, byte[] splitPoint)

Snapshot

I metodi di snapshot HBase creano e gestiscono i backup di Bigtable. Poiché i backup vengono archiviati in un cluster specifico, se l'istanza ha più di un cluster, devi impostare la proprietà di configurazione google.bigtable.snapshot.cluster.id sul cluster da utilizzare. I backup creati con snapshot() scadono dopo il numero di secondi nella proprietà di configurazione google.bigtable.snapshot.default.ttl.secs (24 ore per impostazione predefinita). cloneSnapshot() esegue il ripristino da un backup in una nuova tabella.

In Admin sono supportati i seguenti metodi di snapshot:

  • cloneSnapshot(byte[] snapshotName, TableName tableName)
  • cloneSnapshot(String snapshotName, TableName tableName)
  • deleteSnapshot(byte[] snapshotName)
  • deleteSnapshot(String snapshotName)
  • snapshot(byte[] snapshotName, TableName tableName)
  • snapshot(String snapshotName, TableName tableName)

Inoltre, AsyncAdmin supporta listSnapshots(), listSnapshots(Pattern pattern) e snapshot(SnapshotDescription snapshot). Tutti gli altri metodi di snapshot, inclusi restoreSnapshot(), deleteSnapshots(), deleteTableSnapshots(), listTableSnapshots() e cloneSnapshot(String snapshotName, TableName tableName, boolean restoreAcl), non sono supportati e generano un UnsupportedOperationException.

Gestione delle regioni

Bigtable utilizza i tablet, che sono simili alle regioni. I seguenti metodi per recuperare le informazioni sulla regione sono supportati, con differenze rispetto ad HBase standard:

  • getRegions(TableName tableName) e getTableRegions(TableName tableName), nonché i metodi nell'interfaccia org.apache.hadoop.hbase.client.RegionLocator, restituiscono confini approssimativi basati su un campione di chiavi di riga nella tabella. I nomi dei server nelle regioni restituite non sono server reali.
  • getRegionMetrics(ServerName serverName, TableName tableName) ignora il parametro serverName e restituisce metriche approssimative sulle dimensioni della regione basate su un campione di chiavi di riga nella tabella.

Poiché Bigtable gestisce automaticamente i tablet, i seguenti metodi non hanno alcun effetto:

  • assign(byte[] regionName)
  • compactRegion(byte[] regionName)
  • compactRegion(byte[] regionName, byte[] columnFamily)
  • flushRegion(byte[] regionName)
  • majorCompactRegion(byte[] regionName)
  • majorCompactRegion(byte[] regionName, byte[] columnFamily)
  • splitRegion(byte[] regionName)
  • splitRegion(byte[] regionName, byte[] splitPoint)

In HBase 1.x, anche compactRegionServer(ServerName sn, boolean major), mergeRegions(byte[] encodedNameOfRegionA, byte[] encodedNameOfRegionB, boolean forcible), move(byte[] encodedRegionName, byte[] destServerName) e unassign(byte[] regionName, boolean force) non hanno alcun effetto. I loro equivalenti HBase 2.x non sono supportati e generano un'eccezione UnsupportedOperationException.

Stato e connessione del cluster

Bigtable gestisce automaticamente le attività di manutenzione del cluster, quindi i metodi di manutenzione in Admin generano un UnsupportedOperationException. Sono supportati solo i seguenti metodi di connessione e stato:

  • close() non ha alcun effetto.
  • getClusterMetrics(), getClusterMetrics(EnumSet<Option> options) e getClusterStatus() restituiscono valori segnaposto con elenchi di server vuoti e getClusterMetrics(EnumSet<Option> options) ignora il parametro options.
  • getConfiguration() restituisce l'oggetto client Configuration.
  • getConnection() restituisce l'oggetto client Connection.

Spazi dei nomi

Bigtable non utilizza gli spazi dei nomi. Puoi utilizzare i prefissi chiave di riga per simulare gli spazi dei nomi.

Per impostazione predefinita, tutti i metodi dello spazio dei nomi generano un errore UnsupportedOperationException. Tuttavia, se imposti la proprietà di configurazione google.bigtable.namespace.warnings su true, i seguenti metodi registrano un avviso e non hanno alcun effetto (restituendo null o un risultato vuoto) anziché generare un'eccezione:

  • createNamespace(NamespaceDescriptor descriptor)
  • deleteNamespace(String name)
  • deleteNamespaceAsync(String name)
  • getNamespaceDescriptor(String name)
  • listNamespaceDescriptors()
  • listTableDescriptorsByNamespace(byte[] name)
  • listTableDescriptorsByNamespace(String name)
  • listTableNamesByNamespace(String name)
  • modifyNamespace(NamespaceDescriptor descriptor)

Anche quando google.bigtable.namespace.warnings è impostato su true, listNamespaces() genera un UnsupportedOperationException.

Altre funzionalità amministrative

Bigtable non supporta i metodi Admin nelle seguenti categorie e la loro chiamata genera un UnsupportedOperationException:

  • Gruppi di località: Bigtable non consente di specificare gruppi di località per le famiglie di colonne.
  • Coprocessori e procedure distribuite: Bigtable non supporta coprocessori o procedure distribuite.
  • Quote: per scoprire di più sulle quote di Bigtable, consulta Quote e limiti.
  • Replica: Bigtable replica automaticamente i dati tra i cluster di un'istanza. Per maggiori dettagli, consulta Panoramica della replica. Per eseguire la replica da HBase a Bigtable, consulta Replica da HBase a Bigtable.
  • Controllo degli accessi: Bigtable utilizza IAM per controllo dell'accesso.
  • Gruppi RegionServer: Bigtable gestisce i server automaticamente e non espone i gruppi RegionServer.