Apache Hadoop
Apache Hadoop is an open-source framework designed to store and process massive datasets across clusters of machines. It’s built to scale horizontally (add more machines instead of upgrading one big server) and to tolerate failures. All the modules in Hadoop are designed with a fundamental assumption that hardware failures are common and should be automatically handled by the framework.
The Apache Hadoop software library is a framework that allows for the distributed processing of large data sets across clusters of computers using simple programming models. It is designed to scale up from single servers to thousands of machines, each offering local computation and storage. Rather than rely on hardware to deliver high-availability, the library itself is designed to detect and handle failures at the application layer, so delivering a highly-available service on top of a cluster of computers, each of which may be prone to failures.
Why we use Apache Hadoop?
• Handle big data that doesn’t fit on a single machine
• Process data in parallel for faster results
• Store data cheaply using commodity hardware
• Build data lakes (store raw structured + unstructured data)
• Enable analytics, ETL, and batch processing at scale
When you should use Hadoop?
Use it when:
• Data is very large (TBs or more)
• You need batch processing (not real-time)
• Data is unstructured or semi-structured (logs, files, images)
• Cost efficiency matters more than ultra-low latency
• You want horizontal scalability
When NOT to use it?
• Real-time or low-latency systems (e.g., trading systems)
• Small datasets (overkill)
• Simple applications that fit in a single database
• Interactive queries needing instant response (better tools exist)
Key components of Apache Hadoop
1. HDFS (Hadoop Distributed File System)
• Stores data across multiple machines
• Splits files into blocks and replicates them
• Fault-tolerant
2. YARN (Yet Another Resource Negotiator)
• Manages cluster resources
• Decides which job runs where
3. MapReduce
• Programming model for processing data in parallel
• Works in two steps:
• Map → process data chunks
• Reduce → aggregate results
4. Common utilities
• Libraries and tools supporting the ecosystem
Key features of Hadoop
• Scalability → add nodes easily
• Fault tolerance → automatic data replication
• Distributed storage + processing
• High throughput (optimized for large data)
• Schema-on-read (no strict schema upfront)
• Cost-effective (runs on commodity hardware)
Advantages
• Handles huge datasets efficiently
• Highly fault-tolerant
• Open source (no licensing cost)
• Flexible with data types
• Strong ecosystem (tools built around it)
Disadvantages
• High latency (not real-time)
• Complex to set up and maintain
• MapReduce is slow and verbose
• Not ideal for small data
• Requires cluster management expertise
• Debugging can be difficult
Alternatives (modern ecosystem)
1. Apache Spark
• Faster than Hadoop MapReduce (in-memory processing)
• Supports batch + streaming + ML
• Often used with Hadoop or instead of it
2. Apache Flink
• Real-time stream processing
• Low latency
3. Apache Hive
• SQL-like queries on Hadoop data
• Not a replacement, but abstraction layer
4. Google BigQuery
• Fully managed, serverless
• No cluster management
5. Amazon EMR
• Managed Hadoop/Spark clusters
6. Snowflake
• Modern data warehousing
• Easier to use than Hadoop
Apache Hadoop Modules
The project includes these modules:
• Hadoop Common: The common utilities that support the other Hadoop modules.
• Hadoop Distributed File System (HDFS™): A distributed file system that provides high-throughput access to application data.
• Hadoop YARN: A framework for job scheduling and cluster resource management.
• Hadoop MapReduce: A YARN-based system for parallel processing of large data sets.
Related Projects
Other Hadoop-related projects at Apache include:
• Ambari™: A web-based tool for provisioning, managing, and monitoring Apache Hadoop clusters which includes support for Hadoop HDFS, Hadoop MapReduce, Hive, HCatalog, HBase, ZooKeeper, Oozie, Pig and Sqoop. Ambari also provides a dashboard for viewing cluster health such as heatmaps and ability to view MapReduce, Pig and Hive applications visually alongwith features to diagnose their performance characteristics in a user-friendly manner.
• Avro™: A data serialization system.
• Cassandra™: A scalable multi-master database with no single points of failure.
• Chukwa™: A data collection system for managing large distributed systems.
• HBase™: A scalable, distributed database that supports structured data storage for large tables.
• Hive™: A data warehouse infrastructure that provides data summarization and ad hoc querying.
• Mahout™: A Scalable machine learning and data mining library.
• Pig™: A high-level data-flow language and execution framework for parallel computation.
• Spark™: A fast and general compute engine for Hadoop data. Spark provides a simple and expressive programming model that supports a wide range of applications, including ETL, machine learning, stream processing, and graph computation.
• Tez™: A generalized data-flow programming framework, built on Hadoop YARN, which provides a powerful and flexible engine to execute an arbitrary DAG of tasks to process data for both batch and interactive use-cases. Tez is being adopted by Hive™, Pig™ and other frameworks in the Hadoop ecosystem, and also by other commercial software (e.g. ETL tools), to replace Hadoop™ MapReduce as the underlying execution engine.
• ZooKeeper™: A high-performance coordination service for distributed applications.
