Mastering Apache HBASE with Hands-on

Explore big data as massive volumes of structured, semi-structured, and unstructured data from multiple sources, emphasizing variety, velocity, and data quality for credible, actionable insights.

Discover Apache Hadoop, an open-source Java framework for distributed processing of large data sets across clusters, using the Hadoop distributed file system and MapReduce.

Explore how hdfs distributes data in a block-structured, fault-tolerant file system across clusters, with name node and data nodes, 64 MB blocks, and threefold replication for high availability and throughput.

Learn how Hadoop MapReduce schedules and executes distributed data processing on commodity clusters using Java, with map and reduce as core stages.

Harnesses open-source, distributed noSQL architecture built on a DFS to enable fast reads and writes on large tables. Scale linearly by adding machines and replicating data.

Trace the history of HBase from Google's big table paper in 2006 to its 2007 start, its rise as an Apache project, and major releases up to 2015.

Compare relational database management systems with non-relational NoSQL databases, highlighting storage and retrieval beyond tabular relations for big data, plus location independence, flexible data models, and horizontal scalability.

Compare NoSQL databases with traditional databases, detailing column-oriented, sparse storage; document-focused structure; non-SQL query languages; and scalable handling of structured and unstructured data.

Explore how Apache HBase provides horizontal scalability with strongly consistent reads and writes. See automatic region splitting and recovery, and a Java client API for programmatic access.

Compare HBase with HDFS: HDFS stores files on a file system with high throughput and sequential access, while HBase enables random, fast lookups on top of DFS using key-value stores.

Assess when to use HBase: for large volumes of unstructured data with high scalability and versioned timestamps; avoid it for small datasets and strict relational workloads.

Learn the building blocks of HBase, including tables, rows, column families, qualifiers, and cells, and how regions split and scale, with an API for managing tables and storage options.

Master column families in HBase, where each family groups columns and stores them together in a storage file, shaping data layout, with versions, timestamps, and qualifiers.

Explore how column families are stored on disk in HBase, with personal data like employee name and address and demographic data like date of birth and gender organized as key-value files.

Explore the HBase data model by examining row keys, key-value pairs, and column families with qualifiers. Learn how data is stored, organized, and can include nulls.

Understand timestamp as versions in hbase. Each cell stores a version by write timestamp; reads return the latest value, or a requested timestamp, with three versions retained per column family.

Learn to start the HBase shell and run core commands to check cluster status, view versions, and access help, managing regions, masters, and region servers on Hadoop storage.

Learn to define database structures in HBase using DDL commands such as create, describe, list, and exist, and manage tables with column families like student and teacher.

Master ddl in HBase part-2 by applying disable and enable commands to tables, using a regular expression to disable multiple targets, and verifying status with is disabled or is enabled.

Learn how to use ddl commands in hbase to modify column family properties, including max versions and max file size, and to add or delete column families.

Explore DML commands in HBase to insert rows, get data, and delete specific cells. Learn to use delete all, scan, count, and truncate to manage tables, rows, columns, and timestamps.

Explain the core hbase cluster: a master coordinates regions and metadata, region servers store tables and handle data operations, with a system table mapping regions to servers.

Understand why zookeeper coordinates region assignments by the master to region servers and enables crash recovery by reloading crashed regions, using the ahead log to store data before persistence.

Explore how a client uses ZooKeeper to locate the HBase master and region servers, then access data stored in memstore and hfiles on HDFS blocks.

Master the practical use of bloom filters in hbase with hands-on exercises, focusing on basic index structures and key concepts for efficient data retrieval.

Discover how HFile stores data in HBase, using blocks and indexes to enable fast reads, with immutable data, delete markers, compression, and a log-backed write path.

Explain how write-ahead logging in HBase records writes in the log before updating the store, enabling recovery to the last consistent state after crashes.

Learn to load data in HBase with Apache Pig by moving a dataset (id, name, designation, salary, city) into HDFS, storing it in an HBase table, and verifying via scan.

Load data into HBase with Apache Hive by creating a Hive database and tables, then use the import DSV method to load dataset from HDFS and verify with a select.

Learn how to import data from a MySQL relational database into HBase using Sqoop, including schema setup, driver configuration, and table and column family mappings.

Learn how hbase filters narrow results using get and scan operations, reducing network bandwidth by applying custom filters to subset data, with shell commands to explore options.

This lecture demonstrates applying HBase filters, such as row prefix, column prefix, and prefix-based queries, to selectively retrieve keys and values from an airline table with flight details.

Master advanced Apache HBase filters with practical examples of limit, page size, stop scanning, and qualifier and value based comparisons using operators like equal to for precise data retrieval.

Learn how to create an HBase table using the Java API by configuring an HBase admin, building a table descriptor with a column family, and invoking the create table method.

Insert data in HBase using Java API by configuring, creating the table object, and inserting data with three byte arrays for family, qualifier, and value, then saving the data.

Learn to scan an HBase table with the Java API by configuring a scan, setting column families and qualifiers, obtaining a scanner, iterating results, and printing key-value pairs.

Learn to disable a table and enable a table in HBase using the Java API, verify status with isDisabled, and perform admin operations via the admin class.

Explore listing and deleting HBase tables with the Java API by configuring the setup, creating an admin, and retrieving table details to perform deletions.