Cloud Computing - 3

Cloud Computing - 3

Data in the Cloud

Data in the cloud refers to storing, managing, and accessing data over the internet through cloud computing platforms. Cloud computing offers a flexible, scalable, and cost-effective solution for handling data, reducing the need for physical infrastructure and providing accessibility from any location with internet connectivity.

Key Concepts

  1. Confidentiality, Integrity, and Availability (CIA Triad)

    • Confidentiality: Ensures that data is accessible only to authorized users.

    • Integrity: Maintains the accuracy and trustworthiness of data.

    • Availability: Ensures that data is accessible to authorized users when needed.

  2. Data Transport and Security

    • Data must be securely transported to prevent interception and unauthorized access. Techniques like encryption and the use of Virtual Private Networks (VPNs) help in securing data during transit.
  3. Control Mechanisms

    • Various controls ensure the confidentiality, integrity, and availability of data in the cloud:

      • Input validation controls ensure that data input is complete and accurate.

      • Output reconciliation controls ensure data consistency from input to output.

      • Processing controls ensure complete and accurate data processing.

      • Access controls restrict data access to authorized users.

      • Change management controls prevent unauthorized data modification.

      • Data destruction controls ensure permanent deletion of data, including backups.

  4. Cloud Controls Matrix (CCM)

    • The Cloud Security Alliance provides the CCM, a set of controls to guide cloud vendors and customers in assessing and managing risks related to cloud data​​.

Relational Databases


Relational databases in the cloud utilize cloud infrastructure to provide scalable, high-availability database services. These databases adhere to the relational model, organizing data into tables that can be queried using Structured Query Language (SQL).

Key Services

  1. SQL Azure

    • A relational database service hosted on Windows Azure, built on SQL Server technologies.

    • Provides a scalable, highly available, and fault-tolerant database service accessible from the Azure Cloud or other locations.

    • Managed through REST APIs, allowing developers to control databases and configure access remotely.

    • Offers automatic backups, snapshots, point-in-time recoveries, and replication for high availability.

  2. Amazon Relational Database Service (RDS)

    • Managed service that handles database administration tasks like backups, patch management, and replication.

    • Supports multiple database engines including MySQL, PostgreSQL, and Oracle.

    • Provides multi-AZ deployments for failover infrastructure and read replicas for performance optimization.

  3. Preconfigured EC2 AMIs

    • Amazon EC2 instances preconfigured with database management systems like MySQL, Oracle, and Microsoft SQL Server.

    • Users manage and maintain the database, offering flexibility in choosing database products but requiring administrative effort​​.


  • Scalability: Easily scale database resources up or down based on demand.

  • Cost-Effectiveness: Pay only for the resources used, with options for on-demand or reserved instances.

  • High Availability: Built-in mechanisms for failover and data replication ensure continuous availability and data protection.

  • Reduced Administrative Burden: Cloud providers handle much of the database management, allowing users to focus on application development.

Cloud File Systems


Cloud file systems are essential for managing and storing large-scale data in a distributed computing environment. Two prominent examples of cloud file systems are the Google File System (GFS) and the Hadoop Distributed File System (HDFS). Below is an overview of their features, architectures, and comparisons.

Google File System (GFS)


  1. Scalability: GFS is designed to handle large-scale data across numerous machines.

  2. Fault Tolerance: Built on commodity hardware, it assumes frequent component failures and handles them efficiently through replication and other techniques.

  3. High Throughput: Optimized for large streaming reads and writes, emphasizing high sustained bandwidth over low latency.

  4. Large File Support: Designed for large files (hundreds of megabytes to gigabytes), facilitating efficient handling of such data.

  5. Simplified Interface: Provides a POSIX-like interface, but with enhancements suited for Google’s specific needs, such as the ability to see physical locations of file blocks.


  • Master-Slave Structure: A single master node holds the metadata and manages access, while multiple chunk servers store the data.

  • Chunk Management: Files are divided into fixed-size chunks (typically 64 MB), each replicated across several chunk servers for fault tolerance.

  • Optimized for Append Operations: GFS supports concurrent append operations, making it suitable for workloads with large, sequential writes.

Hadoop Distributed File System (HDFS)


  1. Scalability: Like GFS, HDFS is designed to store and process very large files across many nodes.

  2. Fault Tolerance: Ensures data reliability through replication of file blocks across multiple nodes.

  3. High Throughput: Optimized for batch processing, focusing on high data throughput rather than low latency.

  4. Simplified Design: Avoids features like security for simplicity, focusing on performance and scalability.

  5. Open Source: HDFS is an open-source implementation of GFS, widely used in the Apache Hadoop ecosystem.


  • Master-Slave Structure: Comprises a single NameNode (master) managing the metadata and multiple DataNodes (slaves) storing the data blocks.

  • Block Management: Files are split into blocks (typically 64 MB) managed by the NameNode and stored across DataNodes.

  • Replication: Default replication factor is three, with one replica on the same node, another on a different node within the same rack, and the third on a node in a different rack to balance reliability and communication cost.

Comparison Between GFS and HDFS

OriginDeveloped by Google for internal useOpen-source implementation inspired by GFS
LanguageImplemented in C++Implemented in Java
ReplicationCustomizable replication factorDefault replication factor of three
Target WorkloadsLarge streaming reads and appendsBatch processing with high throughput
SecurityMinimal focusBasic, with extensions available
Master NodeSingle master, potential single point of failure but simplifies managementSingle NameNode with backup options, also a potential single point of failure

Big Table, HBase, and Dynamo



  • BigTable is a distributed storage system developed by Google, designed to handle petabytes of data across thousands of servers.

  • It supports applications such as Google Search, Google Earth, and Google Maps.

  • BigTable provides a sparse, distributed, persistent multidimensional sorted map, indexed by row key, column key, and timestamp.

Key Features:

  • Scalability: Manages thousands of servers, petabytes of data, and millions of operations per second.

  • Self-Managing: Supports automatic load balancing and dynamic addition/removal of servers.

  • Fault-Tolerant: Uses Google File System (GFS) for persistent state storage.

  • Efficient Scans and Joins: Optimized for high read/write rates and efficient scans of large data sets.

  • Data Model:

    • Rows are indexed by a unique string key.

    • Columns are grouped into families, with each family containing related data.

    • Cells can store multiple versions of data with timestamps.

  • Infrastructure Components:

    • GFS: For storing persistent state.

    • MapReduce: For data processing.

    • Scheduler: For job scheduling.

    • Lock Service: For master election and location bootstrapping​.



  • HBase is an open-source implementation of Google’s BigTable, part of the Hadoop ecosystem.

  • It is designed to provide real-time read/write access to large datasets.

Key Features:

  • Built on HDFS: HBase uses Hadoop Distributed File System (HDFS) for storage, which provides high fault tolerance and high throughput.

  • Column-Oriented Storage: Data is stored in tables with rows and columns similar to a database, but optimized for sparse data sets.

  • Scalability: Designed to scale linearly with the addition of nodes.

  • Real-Time Access: Provides real-time random read/write access to data.

  • Integration with Hadoop: Supports integration with Hadoop for batch processing via MapReduce​.



  • Dynamo is a distributed key-value store developed by Amazon, designed to provide high availability and scalability.

Key Features:

  • Eventually Consistent: Dynamo uses an eventually consistent model to ensure high availability, allowing data to be replicated across multiple nodes.

  • Scalability: Supports incremental scalability, allowing new nodes to be added without downtime.

  • Partitioning and Replication: Data is partitioned and replicated across nodes using consistent hashing.

  • High Availability: Uses techniques like data replication and versioning to provide a highly available system.

  • Simple Interface: Provides a simple get/put interface for data operations​​.


  • Dynamo consists of a ring of nodes, each responsible for a portion of the key space.

  • Keys are distributed and replicated across multiple nodes to ensure data durability and availability.

  • Nodes use a gossip protocol for membership and failure detection, ensuring the system can handle node failures gracefully​.

Map-Reduce and Extensions: Parallel Computing

Map-Reduce Programming Model

Map-Reduce is a programming model introduced by Google for processing large datasets in a distributed environment. The model simplifies data processing across large clusters by dividing the task into two primary functions:

  1. Map Function: This function processes input data (key-value pairs) and generates intermediate key-value pairs.

  2. Reduce Function: This function takes the intermediate key-value pairs generated by the Map function and merges the values associated with the same key to produce the final output.

The main advantage of the Map-Reduce model is its ability to handle massive amounts of data in parallel across many nodes in a cluster. This model is highly scalable, allowing it to manage terabytes of data on thousands of machines efficiently.

Variations and Extensions of Map-Reduce

Due to the limitations of the basic Map-Reduce model, several extensions and variations have been developed to enhance its functionality and applicability:

  1. Hadoop: An open-source implementation of the Map-Reduce framework along with the Hadoop Distributed File System (HDFS). Initially developed by Yahoo!, Hadoop is now one of the most widely used frameworks for big data processing​​.

  2. Map-Reduce-Merge: This extension introduces a third phase called the "Merge" phase. It allows efficient merging of data already partitioned and sorted by the Map and Reduce functions. This extension is particularly useful for managing heterogeneous datasets and supporting relational algebra operations​​.

  3. Twister: Twister is an extension that supports iterative Map-Reduce computations, enabling iterative algorithms to be executed more efficiently. This model includes phases for configuring the Map and Reduce tasks, running the Map-Reduce operations iteratively, applying combine operations, and updating conditions until the iteration ends​​.

  4. Pig: Pig is a high-level platform for creating Map-Reduce programs used with Hadoop. It introduces a language called Pig Latin, which simplifies the creation of data analysis tasks by providing a SQL-like interface​​.

  5. Hive: Hive provides a data warehouse infrastructure on top of Hadoop. It allows for easy data summarization, ad hoc querying, and analysis of large datasets using a SQL-like language, making it accessible to users familiar with traditional databases​​.

Alternatives to Map-Reduce

Besides Map-Reduce, other models and frameworks have been developed to address the challenges of data-intensive computing:

  1. Sphere: This framework uses a different approach called stream processing (Single Program, Multiple Data). It allows developers to write user-defined functions (UDFs) that operate on data streams, providing an alternative method to express computations typically handled by Map-Reduce​.

  2. Sector and Sphere: These frameworks are used together, where Sector provides the distributed file system and Sphere handles the distributed processing, allowing for efficient data access and computation across large datasets​.

The Map-Reduce model

Parallel efficiency of Map-Reduce

Parallel efficiency in Map-Reduce can be analyzed in terms of its scalability and the way it handles large-scale data processing tasks. Key aspects include:

  • Task Parallelism: Multiple map and reduce tasks can run in parallel across different nodes in the cluster.

  • Data Locality: Map-Reduce attempts to place map tasks on nodes where the data resides, reducing data transfer times.

  • Fault Tolerance: Through re-execution of failed tasks, Map-Reduce ensures the reliability of the computation.

Relational operations

Map-Reduce can be used to implement relational database operations such as:

  • Selection: Filtering data based on a condition can be done in the map phase.

  • Projection: Extracting specific columns of data can also be done in the map phase.

  • Join: Combining records from two datasets based on a key can be achieved using a combination of map and reduce phases.

  • Group By: Aggregating data based on a key, typically done in the reduce phase.

These operations leverage the parallel processing capabilities of Map-Reduce to handle large datasets efficiently.

Enterprise batch processing

Map-Reduce is extensively used in enterprise batch processing scenarios where large volumes of data need to be processed in a scheduled manner. Examples include:

  • Log Analysis: Analyzing web server logs to extract meaningful insights such as user behavior patterns.

  • ETL Processes: Extracting data from various sources, transforming it, and loading it into a data warehouse for analysis.

Map-Reduce's ability to handle massive data volumes and perform complex transformations in a fault-tolerant manner makes it ideal for such tasks.

Example/Application of Map- Reduce

One prominent application of Map-Reduce is in the field of web search engines. For example:

  • Indexing Web Pages: The map function processes raw web pages to extract words, and the reduce function aggregates the occurrences of each word across all pages. This forms the basis of creating an index that search engines use to retrieve relevant pages for a given query.

Map-Reduce is also used in various other applications like:

  • Recommendation Systems: Processing user interaction data to generate personalized recommendations.

  • Genomic Data Processing: Analyzing DNA sequence data to identify genetic variations and patterns.

By breaking down large-scale computations into smaller, manageable tasks, Map-Reduce allows efficient processing and analysis of big data.