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

Service Level Agreement (SLA)

A Service Level Agreement (SLA) is a formal, negotiated contract between a cloud service provider and a customer that defines the level of service expected, the measurable metrics used to judge it, and the remedies or penalties if the agreed levels are not met. It converts vague promises ("highly available") into legally binding, quantifiable commitments.

Components of an SLA

1. Service description — what services/resources are covered (e.g., compute, storage, network).
2. Service-level objectives (SLOs) — measurable targets such as availability/uptime (e.g., 99.95%), latency, throughput, and response time.
3. Performance/QoS metrics — exactly how each SLO is measured and over what time window.
4. Roles and responsibilities — duties of both provider and customer.
5. Monitoring and reporting — how metrics are collected and reported to the customer.
6. Penalties / service credits — compensation (e.g., bill credits) when SLOs are breached.
7. Exclusions — events not counted against the SLA (scheduled maintenance, force majeure).
8. Security, compliance and data-handling terms.
9. Termination and review clauses — how the SLA is changed or ended.

Managing and Monitoring QoS in the Cloud

Quality of Service (QoS) is the set of measurable performance characteristics — availability, response time, throughput, reliability, scalability and security — that the cloud must deliver.

• Metric definition: QoS parameters are mapped to SLOs in the SLA (e.g., 99.9% availability, < 100 ms response time).
• Monitoring: Continuous monitoring tools (e.g., Amazon CloudWatch, Azure Monitor, Nagios, Prometheus) collect real-time metrics on CPU, memory, network, latency and error rates.
• Measurement & comparison: Collected metrics are compared against SLO thresholds; dashboards and logs track compliance.
• Enforcement: Auto-scaling, load balancing and resource provisioning are triggered to keep QoS within limits.
• Alerting & remediation: Threshold breaches raise alerts; automated or manual corrective action restores service.
• Reporting & penalties: Periodic reports verify SLA compliance; breaches lead to service credits or penalties.

Conclusion: An SLA formalizes the QoS guarantees, while continuous monitoring, automated scaling/load-balancing and penalty mechanisms ensure those guarantees are actually delivered.

Layered Architecture of Cloud Computing

Cloud computing is organized as a stack of service layers, where each higher layer is built on the services of the layer below it.

1. Hardware / Datacenter layer (bottom): Physical servers, storage, routers, switches and power/cooling that form the data center.
2. Infrastructure layer (IaaS): Virtualized compute, storage and network resources created by a hypervisor and offered on demand (e.g., Amazon EC2, S3). It uses virtualization to pool and partition hardware.
3. Platform layer (PaaS): Operating systems, runtimes, databases and development frameworks on top of the infrastructure, letting developers build and deploy applications (e.g., Google App Engine, Azure App Service).
4. Application layer (SaaS, top): Ready-to-use software delivered to end users over the Internet (e.g., Gmail, Salesforce).

These map to the service models SaaS, PaaS and IaaS.

Cloud Reference Model (NIST)

The NIST cloud reference model defines five major actors:

Role of the Cloud Broker

A cloud broker is an intermediary that manages the relationship between cloud consumers and providers. Its functions include:

• Service intermediation — adding value (security, identity, reporting) on top of a provider's service.
• Service aggregation — combining multiple services into one integrated offering.
• Service arbitrage — flexibly choosing the best provider for a given need (like aggregation but with dynamic selection).

Role of the Cloud Carrier

A cloud carrier provides the connectivity and transport of cloud services from providers to consumers, typically through network and telecommunication infrastructure (e.g., ISPs, telecom operators). It ensures the network-level SLA (bandwidth, latency, secure transport) needed to access the cloud.

Conclusion: The layered architecture (hardware → IaaS → PaaS → SaaS) defines what is delivered, while the reference-model actors — especially the broker (intermediation/aggregation/arbitrage) and carrier (connectivity) — define who delivers and connects it.

Scalability and Elasticity

Scalability is the ability of a cloud system to handle increasing workload by adding resources. It is a planned, long-term capability.

• Vertical scaling (scale up): Add more power (CPU, RAM) to an existing machine.
• Horizontal scaling (scale out): Add more machines/instances to share the load.

Elasticity is the ability to automatically and dynamically provision and de-provision resources in real time to match the current workload, so the system uses (and pays for) only what it needs. Elasticity is short-term and automatic; scalability is the underlying capacity that makes elasticity possible.

Load Balancing Techniques

A load balancer distributes incoming requests across multiple servers to avoid overloading any single server, improving throughput, availability and response time. Common techniques:

• Round Robin: Requests sent to servers in rotation.
• Weighted Round Robin: Stronger servers get proportionally more requests.
• Least Connections: New requests go to the server with the fewest active connections.
• Least Response Time: Server with lowest latency is chosen.
• IP Hash: Client IP is hashed to pick a server (session affinity).

Example: AWS Elastic Load Balancer (ELB) spreads web traffic across several EC2 instances.

Auto-Scaling Mechanisms

Auto-scaling automatically adjusts the number of running instances based on demand, implementing elasticity.

• Reactive / dynamic scaling: Adds/removes instances when a monitored metric (e.g., CPU > 70%) crosses a threshold.
• Scheduled scaling: Scales at known peak times (e.g., business hours).
• Predictive scaling: Uses forecasting/ML to provision capacity before demand arrives.

Example: An AWS Auto Scaling Group launches extra EC2 instances when average CPU > 70% and terminates them when CPU < 30%, while ELB load-balances across them.

Conclusion: Scalability provides the capacity, elasticity uses it on demand, and load balancing + auto-scaling together deliver elastic, highly available services.

Essential Characteristics of Cloud Computing (NIST)

1. On-demand self-service: A consumer can provision computing resources (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 from various devices (laptops, phones, tablets).
3. Resource pooling: The provider's resources are pooled to serve multiple consumers using a multi-tenant model, with resources dynamically assigned (location independence).
4. Rapid elasticity: Resources can be elastically provisioned and released, scaling out and in quickly to match demand, appearing unlimited to the consumer.
5. Measured service: Resource usage is monitored, metered and reported, enabling a pay-per-use billing model and transparency for both provider and consumer.

IaaS vs PaaS vs SaaS

Summary: Moving from IaaS → PaaS → SaaS, the customer manages less and the provider manages more, trading control for convenience.

Virtualization

Virtualization is the technology that creates a virtual (software-based) version of a physical resource — such as a server, storage device, network or operating system — allowing multiple isolated virtual machines (VMs) to run on a single physical machine. It is enabled by a hypervisor, which sits between the hardware and the VMs and allocates physical resources to each VM.

Role in Cloud Computing

Virtualization is the foundational technology of cloud computing because it enables:

• Resource pooling & multi-tenancy: A single physical server is partitioned into many VMs serving different customers.
• Efficient resource utilization: Idle hardware is shared, reducing waste and cost.
• Elasticity & rapid provisioning: VMs can be created, cloned or destroyed in minutes, supporting on-demand self-service and auto-scaling.
• Isolation & security: Each VM is isolated, so one tenant's failure does not affect others.
• Portability & migration: VMs can be moved (live migration) between hosts for load balancing and fault tolerance.

Conclusion: Without virtualization, the on-demand, elastic, multi-tenant, pay-per-use model of the cloud would not be practical.

Public vs Private vs Hybrid Cloud

Summary: A public cloud offers low cost and high scalability but less control; a private cloud offers maximum control and security at higher cost; a hybrid cloud combines both, keeping sensitive workloads private while using the public cloud for scalability ("cloud bursting").

MapReduce Programming Model

MapReduce is a programming model (introduced by Google) for processing very large datasets in parallel across a distributed cluster. A computation is expressed as two user-defined functions:

1. Map: Takes input as key-value pairs and produces a set of intermediate key-value pairs.
2. Reduce: Groups all intermediate values by key and aggregates them into the final result.

The framework automatically handles partitioning, scheduling, the shuffle-and-sort of intermediate data, parallel execution, and fault tolerance.

Phases

Input → Split → Map → Shuffle & Sort → Reduce → Output

Example: Word Count

Count how many times each word appears in a large set of documents.

map(docName, text):
    for each word w in text:
        emit(w, 1)

reduce(word, list_of_counts):
    sum = 0
    for c in list_of_counts:
        sum = sum + c
    emit(word, sum)

For input "cat dog cat":

• Map emits: (cat,1), (dog,1), (cat,1)
• Shuffle/Sort groups: (cat,[1,1]), (dog,[1])
• Reduce outputs: (cat,2), (dog,1)

Conclusion: MapReduce lets programmers process petabyte-scale data simply by writing map and reduce functions, while the framework handles distribution and fault tolerance (used in Hadoop).

Service Level Agreement (SLA)

A Service Level Agreement (SLA) is a formal contract between a cloud service provider and a customer that specifies the agreed level of service, the measurable metrics by which it is judged, and the penalties or service credits that apply if the provider fails to meet those levels.

Key Components

1. Service description — the services and resources covered.
2. Service-level objectives (SLOs) — measurable targets, e.g., uptime/availability (99.9%), response time, throughput.
3. Performance metrics — how each objective is measured and the reporting window.
4. Roles and responsibilities — duties of provider and customer.
5. Monitoring and reporting — how compliance is tracked and communicated.
6. Penalties / service credits — remedies when SLOs are breached.
7. Exclusions — events not counted (scheduled maintenance, force majeure).
8. Security, compliance and termination clauses.

Major Security Issues in Cloud Computing

1. Data breaches & data loss: Sensitive data stored off-premises can be exposed by attacks, misconfiguration, or accidental deletion.
2. Data privacy & data location: Data may be stored across multiple jurisdictions, raising compliance and confidentiality concerns.
3. Authentication & access control: Weak identity management, stolen credentials, or insufficient access controls allow unauthorized access.
4. Multi-tenancy / isolation failures: Shared infrastructure risks one tenant accessing another's data if isolation fails.
5. Insecure interfaces and APIs: Vulnerable management APIs can be exploited.
6. Account or service hijacking: Phishing or credential theft lets attackers control accounts.
7. Insider threats: Malicious or careless provider/customer staff.
8. Denial of Service (DoS/DDoS): Attacks that exhaust resources and make services unavailable.
9. Compliance and legal issues: Meeting regulations (GDPR, HIPAA, etc.) in a shared environment.
10. Vendor lock-in & loss of control: Limited control over the provider's security practices.

Mitigation: encryption (at rest and in transit), strong IAM/multi-factor authentication, regular auditing, secure APIs, and clear SLAs covering security responsibilities.

Hypervisor

A hypervisor (also called a Virtual Machine Monitor, VMM) is the software/firmware layer that creates and runs virtual machines (VMs). It abstracts the physical hardware and allocates CPU, memory, storage and network to each VM, keeping them isolated, so multiple operating systems can run on one physical host.

Type 1 vs Type 2 Hypervisors

Summary: Type 1 runs directly on hardware and is used for production cloud servers due to better performance and security; Type 2 runs as an application on a host OS and is used mainly for personal/development purposes.

Hadoop Distributed File System (HDFS)

HDFS is the primary storage system of Apache Hadoop — a distributed, fault-tolerant file system designed to store very large files reliably across a cluster of commodity hardware and stream them to applications (e.g., MapReduce).

Architecture (Master–Slave)

• NameNode (master): Stores the file-system metadata (directory tree, file-to-block mapping, block locations). There is a single active NameNode.
• DataNodes (slaves): Store the actual data blocks and serve read/write requests; they periodically send block reports and heartbeats to the NameNode.

Key Features

• Block storage: Files are split into large fixed-size blocks (default 128 MB) distributed across DataNodes.
• Replication: Each block is replicated (default factor 3) on different DataNodes for fault tolerance.
• Fault tolerance: If a DataNode fails, blocks are re-replicated from surviving copies.
• Write-once, read-many: Optimized for high-throughput batch access rather than low-latency random writes.
• Scalability & data locality: Scales horizontally; computation is moved to the data to reduce network traffic.

Conclusion: HDFS provides reliable, scalable, high-throughput storage for big-data workloads by splitting files into replicated blocks managed by a NameNode and stored on many DataNodes.