BSc CSIT (TU) Science Cloud Computing (BSc CSIT, CSC465) Question Paper 2074 Nepal

Cloud Computing

Cloud computing is a model for enabling ubiquitous, convenient, on-demand network access to a shared pool of configurable computing resources (networks, servers, storage, applications, services) that can be rapidly provisioned and released with minimal management effort or service-provider interaction (NIST definition).

Essential Characteristics (NIST)

1. On-demand self-service — A consumer can provision computing capabilities (server time, storage) automatically without human interaction with the provider.
2. Broad network access — Capabilities are available over the network and accessed through standard mechanisms (laptops, mobiles, tablets).
3. Resource pooling — Provider resources are pooled to serve multiple consumers using a multi-tenant model, with resources dynamically assigned (location independence).
4. Rapid elasticity — Capabilities can be elastically provisioned and released to scale rapidly with demand; appears unlimited to the consumer.
5. Measured service — Resource use is monitored, controlled and reported (pay-per-use / metering), providing transparency.

Service Models

Deployment Models

• Public cloud — Infrastructure owned by a provider and made available to the general public over the Internet (e.g., AWS, Azure). Low cost, no maintenance, shared.
• Private cloud — Operated solely for a single organization (on-premise or hosted). Greater control and security; higher cost. (e.g., OpenStack-based enterprise cloud).
• Hybrid cloud — Composition of two or more distinct clouds (public + private) bound by technology that enables data/app portability (e.g., keeping sensitive data on private, bursting to public on peak load).
• Community cloud — Shared by several organizations with common concerns (security, compliance, mission), e.g., a cloud shared by government agencies or hospitals.

Conclusion

Cloud computing delivers IT as a utility, reducing capital expenditure, enabling elasticity and pay-per-use, with service models defining what is delivered and deployment models defining who owns and accesses it.

Virtualization

Virtualization is the technique of creating a virtual (rather than physical) version of a computing resource — such as a server, storage device, network, or operating system — so that a single physical machine can be partitioned into multiple isolated virtual machines (VMs), each running its own OS and applications.

Role of Virtualization in Cloud Computing

Virtualization is the foundational technology of cloud computing:

• Resource pooling & multi-tenancy — Enables one physical server to host many tenants' VMs in isolation.
• Elasticity & scalability — VMs can be created, cloned, migrated or destroyed on demand.
• Server consolidation — Improves hardware utilization, reducing cost, power and space.
• Isolation & security — Each VM is sandboxed; a failure or breach in one does not affect others.
• Hardware independence / portability — VMs can be migrated (live migration) between physical hosts for load balancing and fault tolerance.

Types of Virtualization

1. Server (Hardware) virtualization — Partitioning a physical server into multiple VMs.
2. Storage virtualization — Pooling physical storage from multiple devices into a single logical unit (e.g., SAN).
3. Network virtualization — Combining network resources into software-based virtual networks (e.g., VLAN, SDN, NFV).
4. Desktop virtualization — Hosting desktop environments on a central server (VDI).
5. Application/OS-level virtualization — Running applications in isolated containers (e.g., Docker).

Hypervisor (Virtual Machine Monitor)

A hypervisor is the software layer that creates, runs and manages VMs by abstracting and allocating physical hardware (CPU, memory, I/O) among them.

Type 1 — Bare-metal hypervisor

• Runs directly on the physical hardware (no host OS).
• VMs sit on top of the hypervisor.
• High performance, better security; used in data centers.
• Examples: VMware ESXi, Microsoft Hyper-V, Xen, KVM.

Type 2 — Hosted hypervisor

• Runs as an application on top of a host operating system.
• Easier to install; lower performance due to the extra OS layer.
• Used on desktops for testing/development.
• Examples: VMware Workstation, Oracle VirtualBox, QEMU.

Type 1:                         Type 2:
[ VM ][ VM ][ VM ]              [ VM ][ VM ]
[  Hypervisor    ]             [ Hypervisor ]
[   Hardware     ]             [  Host OS   ]
                               [  Hardware  ]

Conclusion

Virtualization decouples software from hardware, and the hypervisor enables the resource pooling and elasticity that make cloud computing possible; Type 1 is used for production cloud infrastructure while Type 2 suits desktop/testing use.

MapReduce Programming Model

MapReduce is a programming model and processing framework (introduced by Google) for processing large data sets in parallel across a distributed cluster of commodity machines. Computation is expressed as two functions:

• Map — takes an input key/value pair and produces a set of intermediate key/value pairs: map(k1, v1) -> list(k2, v2).
• Reduce — merges all intermediate values associated with the same intermediate key: reduce(k2, list(v2)) -> list(v3).

Between them, the framework performs a Shuffle and Sort step that groups intermediate values by key.

Example: Word Count

Input: "the cat sat the mat"

Map output:    (the,1) (cat,1) (sat,1) (the,1) (mat,1)
Shuffle/Sort:  (cat,[1]) (mat,[1]) (sat,[1]) (the,[1,1])
Reduce output: (cat,1) (mat,1) (sat,1) (the,2)

def map(line):
    for word in line.split():
        emit(word, 1)

def reduce(word, counts):
    emit(word, sum(counts))

Hadoop Architecture

Hadoop is an open-source framework that implements MapReduce and HDFS for distributed storage and processing of big data. Its core components:

• HDFS — distributed storage layer.
• YARN — resource manager (job scheduling, cluster resource management).
• MapReduce engine — processing layer.

Hadoop follows a master/slave architecture:

• NameNode (master) — manages the file-system namespace and metadata.
• DataNodes (slaves) — store actual data blocks.
• ResourceManager / NodeManager (YARN) — schedule and run tasks.

HDFS (Hadoop Distributed File System)

HDFS is designed for storing very large files reliably across commodity hardware with high throughput.

• NameNode — single master storing metadata (file names, block locations, permissions); does not store data itself.
• DataNodes — store data in fixed-size blocks (default 128 MB).
• Replication — each block is replicated (default factor 3) across DataNodes for fault tolerance.
• Write-once, read-many access model, optimized for batch processing rather than low-latency access.
• Rack awareness places replicas across racks to survive rack failures.

            +-----------+
            | NameNode  |  (metadata)
            +-----------+
           /     |       \
   +--------+ +--------+ +--------+
   |DataNode| |DataNode| |DataNode|  (blocks + replicas)
   +--------+ +--------+ +--------+

Conclusion

MapReduce provides a simple, fault-tolerant model for parallel data processing, while Hadoop/HDFS supply the distributed storage and execution infrastructure, together enabling scalable big-data processing in the cloud.

The five essential characteristics of cloud computing (NIST) are:

1. On-demand self-service — Users provision resources (compute, storage) automatically without human interaction with the provider.
2. Broad network access — Services are available over the network through standard devices (PCs, mobiles, tablets).
3. Resource pooling — Provider resources are pooled and shared among multiple tenants (multi-tenancy) with dynamic, location-independent assignment.
4. Rapid elasticity — Resources can be scaled up or down quickly, appearing virtually unlimited to the user.
5. Measured service — Usage is metered, monitored and reported, enabling a pay-per-use billing model.

In short: IaaS gives you the raw infrastructure, PaaS gives you a platform to build and deploy apps without managing the OS, and SaaS gives you a finished application accessed over the Internet.

Virtualization is the creation of a virtual (software-based) version of a physical computing resource — such as a server, storage, network or operating system — allowing a single physical machine to be split into multiple isolated virtual machines (VMs), each with its own OS and applications, managed by a hypervisor.

Role in Cloud Computing

• Foundation of the cloud — Enables multiple tenants to share the same physical hardware in isolation (multi-tenancy, resource pooling).
• Elasticity & scalability — VMs can be rapidly created, cloned, migrated or destroyed to match demand.
• Server consolidation — Maximizes hardware utilization, lowering cost, power and space.
• Isolation & security — Each VM is sandboxed; failure or compromise of one does not affect others.
• Portability & high availability — Live migration of VMs supports load balancing and fault tolerance.

Summary: A public cloud is shared and cost-effective, a private cloud offers maximum control and security for one organization, and a hybrid cloud combines both — keeping sensitive workloads private while bursting to the public cloud for scalability (cloud bursting).

MapReduce is a programming model for parallel processing of large data sets across a distributed cluster, using two functions:

• Map — processes input key/value pairs to produce intermediate key/value pairs: map(k1,v1) -> list(k2,v2).
• Reduce — aggregates all intermediate values sharing the same key: reduce(k2, list(v2)) -> list(v3).

A framework-managed Shuffle and Sort phase groups intermediate values by key between the two steps. This model provides automatic parallelization, fault tolerance and data locality.

Example: Word Count

Input: "the cat sat the mat"

Map:     (the,1)(cat,1)(sat,1)(the,1)(mat,1)
Shuffle: (cat,[1]) (mat,[1]) (sat,[1]) (the,[1,1])
Reduce:  (cat,1) (mat,1) (sat,1) (the,2)

The Map function emits (word, 1) for each word; the Reduce function sums the counts per word to produce the final word frequencies.

A Service Level Agreement (SLA) is a formal, negotiated contract between a cloud service provider and a customer that defines the expected level of service, the metrics by which it is measured, and the responsibilities and penalties of both parties.

Key Components

1. Service description — Scope and definition of the services provided.
2. Performance / QoS metrics — Measurable objectives such as availability/uptime (e.g., 99.9%), response time, throughput.
3. Service Level Objectives (SLOs) — Specific target values for each metric.
4. Monitoring and reporting — How performance is measured and reported.
5. Responsibilities — Duties of both provider and customer.
6. Penalties / remedies (credits) — Compensation when targets are not met.
7. Security and compliance — Data protection, privacy obligations.
8. Termination / exit clauses — Conditions for ending the agreement and data return.

Major Security Issues in Cloud Computing

1. Data breaches & loss — Sensitive data stored off-premise can be exposed through attacks, misconfiguration, or accidental deletion.
2. Data privacy & confidentiality — Loss of physical control over data; concerns about provider/government access and data location/jurisdiction.
3. Multi-tenancy / isolation failure — Shared infrastructure risks data leakage between tenants if isolation is breached (e.g., VM escape, side-channel attacks).
4. Authentication & access control — Weak identity management, account/credential hijacking, insufficient IAM policies.
5. Insecure APIs & interfaces — Vulnerable management APIs can be exploited to compromise the service.
6. Insider threats — Malicious or negligent provider/employee actions.
7. DoS/DDoS attacks — Availability threatened by flooding shared resources.
8. Compliance & legal issues — Meeting regulatory requirements (e.g., data residency, GDPR) across providers.
9. Data loss of control & vendor lock-in — Difficulty migrating data/services securely between providers.

Mitigations include encryption (at rest and in transit), strong IAM/MFA, regular auditing, and clear SLAs.

A hypervisor (Virtual Machine Monitor, VMM) is the software layer that creates and manages virtual machines by abstracting the physical hardware (CPU, memory, I/O) and allocating it among multiple isolated VMs, each running its own operating system.

Type 1 vs Type 2 Hypervisors

Type 1: VMs -> Hypervisor -> Hardware
Type 2: VMs -> Hypervisor -> Host OS -> Hardware

HDFS (Hadoop Distributed File System)

HDFS is the distributed storage layer of Hadoop, designed to store very large files reliably across a cluster of commodity machines and to stream them at high throughput for batch processing.

Key Features

• Master/slave architecture:
  • NameNode (master) — stores the file-system metadata (namespace, file-to-block mapping, block locations); a single point of coordination.
  • DataNodes (slaves) — store the actual data and serve read/write requests.
• Block storage — Files are split into fixed-size blocks (default 128 MB) distributed across DataNodes.
• Replication — Each block is replicated (default factor 3) for fault tolerance; if a DataNode fails, data is served from replicas.
• Rack awareness — Replicas are placed across different racks to survive rack-level failures.
• Write-once, read-many model — optimized for high-throughput batch access rather than low-latency random writes.
• Scalability & fault tolerance — Runs on inexpensive commodity hardware; failures are detected and recovered automatically.

HDFS thus provides reliable, scalable storage that underpins MapReduce/YARN big-data processing in the cloud.