CS8711 – CLOUD COMPUTING LABORATORY

NAME: ..……………….....

YEAR:……………………

DEPT: …......……………..
 GOVERNMENT COLLEGE OF ENGINEERING,
TIRUNELVELI - 627 007

2022 - 2023

Register Number:

CERTIFICATE

This is a bonafide record of work done by ................................................. Government

College of Engineering, Tirunelveli during the year 2022-2023.

Place: Tirunelveli
Date:

Staff-in-charge Head of the Department

Submitted for the Anna University Practical Examination held at

Government College of Engineering, Tirunelveli on…………………….

Internal Examiner External Examiner

 TABLE OF CONTENTS

Ex
Date Name of the Experiment Page No Signature
No
1 Study of Virtualization 1
2 Installing VMware Workstation 5
Installing C Compiler in Virtual
3 8
Machine
Creating Web Applications using
4 13
Google App Engine
5 Simulation of SJF Scheduling 20
Algorithm in CloudSim
File Sharing between Physical and
6 54
Virtual Machine
Launching Virtual Machine using
7 61
TryStack
Installing Hadoop Single Node
8 Cluster and running simple 66
applications like Word Count
Ex:No.1 STUDY OF VIRTUALIZATION

VIRTUALIZATION
Virtualization uses software to create an abstraction layer
over computer hardware that allows the hardware elements of a single
computer—processors, memory, storage and more—to be divided into
multiple virtual computers, commonly called virtual machines (VMs).
Each VM runs its own operating system (OS) and behaves like an
independent computer, even though it is running on just a portion of the
actual underlying computer hardware.
VIRTUAL MACHINE
A virtual machine, commonly shortened to just VM, is no
different than any other physical computer like a laptop, smart phone or
server. It has a CPU, memory, disks to store your files and can connect
to the internet if needed. While the parts that make up your computer
(called hardware) are physical and tangible, VMs are often thought of as
virtual computers or software-defined computers within physical servers,
existing only as code.

TYPES OF VIRTUALIZATION

 Application virtualization
 Network virtualization
 Desktop virtualization
 Storage virtualization
 Server virtualization
 Data virtualization

1
APPLICATION VIRTUALIZATION

Application virtualization, also called application service

virtualization, is a term under the larger umbrella of virtualization. It
refers to running an application on a thin client; a terminal or a network
workstation with few resident programs and accessing most programs
residing on a connected server.

NETWORK VIRTUALIZATION

Network virtualization is a method of combining the available

resources in a network to consolidate multiple physical networks, divide
a network into segments or create software networks between virtual
machines (VMs). IT managers that use network virtualization can
administrate their environment as a single software-based network.

DESKTOP VIRTUALIZATION

Desktop virtualization is the concept of isolating a logical

operating system (OS) instance from the client that is used to access it.
There are several different conceptual models of desktop virtualization,
which can broadly be divided into two categories based on whether or
not the operating system instance is executed locally or remotely.

STORAGE VIRTUALIZATION

Storage virtualization is the process of grouping the physical

storage from multiple network storage devices so that it looks like a
single storage device . The process involves abstracting and covering the
internal functions of a storage device from the host application, host
servers or a general network in order to facilitate the application and
network-independent management of storage.

2
SERVER VIRTUALIZATION

Server Virtualization Definition Server virtualization is the

process of dividing a physical server into multiple unique and isolated
virtual servers by means of a software application. Each virtual server
can run its own operating systems independently.

DATA VIRTUALIZATION

This software acts as a bridge across multiple, diverse data sources,

bringing critical decision-making data together in one virtual place to fuel
analytics .It provides a modern data layer that enables users to access,
combine, transform, and deliver datasets with breakthrough speed and cost-
effectiveness. Data virtualization technology gives users fast access to data
housed throughout the enterprise—including in traditional databases, big
data sources, and cloud and IoT systems—at a fraction of physical
warehousing and extract/transform/load (ETL) time and cost.

VIRTUALIZATION
SOFTWARE VMware

VMware, Inc. is a software company, well known in the field of

system virtualization and cloud computing. VMware's software allows
users to create multiple virtual environments, or virtual computer systems,
on a single computer or server. Essentially, one computer or server could
be used to host, or manage, many virtual computer systems, sometimes as
many as one hundred or more. The software virtualizes hardware
components such as the video card, network adapters, and hard drive.

Xen

Xen is an open source hypervisor based on paravirtualization. It is

the most popular application of paravirtualization. Xen has been
extended to compatible with full virtualization using hardware-assisted
virtualization. It enables high performance to execute guest operating
system. This is probably done by removing the performance loss while
3
executing the instructions requiring significant handling and by
modifying portion of the guest operating system executed by Xen, with
reference to the execution of such instructions.

VIRTUAL BOX
VirtualBox is open-source software for virtualizing the x86
computing architecture. It acts as a hypervisor, creating
a VM (virtual machine) where the user can run another OS (operating
system).The operating system where VirtualBox runs is called the "host"
OS. The operating system running in the VM is called the "guest" OS.
VirtualBox supports Windows, Linux, or macOS as its host OS. When
configuring a virtual machine, the user can specify how many CPU
cores, and how much RAM and disk space should be devoted to the VM.

KERNEL-BASED VIRTUAL MACHINE(KVM)

KVM is a full virtualization solution for Linux on x86 hardware

containing virtualization extensions (Intel VT or AMD-V). It consists of
a loadable kernel module, kvm.ko, that provides the core virtualization
infrastructure and a processor specific module, kvm-intel.ko or kvm-
amd.ko. Using KVM, one can run multiple virtual machines running
unmodified Linux or Windows images. Each virtual machine has private
virtualized hardware: a network card, disk, graphics adapter, etc. KVM
is open source software.

RESULT
The concept of virtualization has been studied and
written successfully.

4
Ex:No.2 Installing VMware Workstation

AIM

To install Virtualbox/VMware Workstation with different

flavours of linux or windows OS on top of windows7 or 8.

PROCEDURE

1. Download the software for windows.

2. Download the installer file.
3. Locate the downloaded installer file.
4. User Access Control (UAC) dialog box. Click yes to continue.
5. VMware Workstation setup wizard dialog box appears.

6. In the End User Licence Agreement dialog box, check “I accept the
terms in the Licence Agreement” box and press next to continue.

5
7. Select the folder in which you would like to install the application.
Also select Enhanced Keyboard Driver check box.
8. Select “Check for Updates” and “Help improve VMware
Workstation Pro”.

9. Select the place you want the shortcut icons to be placed on your
system to launch the application. Select both the options, desktop
and start menu and click next.
10. Click install to start the installation process.
11. In installation complete dialog box, Click finish.
12. The VMware Workstation is now installed.

6
RESULT:

Thus the procedure has been found to Install

Virtualbox/VMware Workstation with different flavours of linux or
windows OS on top of windows7 or 8.

7
Ex:No.3 Installing C compiler in the virtual machine

AIM
To Install a C compiler in the virtual machine using the virtual
box and execute simple programs.
PROCEDURE
Step 1: Open Terminal (Applications-Accessories-Terminal).

8
Step 2: Open gedit by typing “gedit &” on terminal (You can also use
any other Text Editor application).

Step 3: Type the following on gedit (or any other text editor)
#include<stdio.h>
int main()
{
printf("Hello World\n");
}

9
Step 4: Save this file as “hellworld.c”.

Step 5: Type “ls” on Terminal to see all files under current folder.

Step 6: Conform that “helloworld.c” is in the current directory. If not,

type cd DIRECTORY_PATH to go to the directory that has
“helloworld.c”.

10
 Step 7: Type “gcc helloworld.c” to compile, and type “ls” to
conform that a new executable file “a.out” is created.

Step 8 : Type “./a.out” on Terminal to run the program.

Step 9: If you see “Hello World” on the next line, you just
successfully ran your first C program.

11
Result
Thus the C program was compiled and execute in virtual
machine.

12
Ex.No:4 Creating Web Applications Using Google App Engine

AIM
To install Google App Engine and create hello world app and
other simple web applications using Python.

PROCEDURE
Downloading and Installing of GAE – Standard environment and
Python
1. Go to https://cloud.google.com/appengine/docs

2. Choose Standard environment -> python

3. Choose Quickstart
4. Click “Get started with cloud SDK”
13
5. Download the cloud SDK for windows
(https://www.edureka.co/community/82162/how-to-install-the-google-
cloud-sdk-in-windows-system)

6. Install google cloud SDK by selecting single user

14
15
16
9. Login in gloud and get authenticated (which will be opened in the
browser).
10. Download Python 2.7 from python.org and install

Project Creation
1. Create a folder with name of your choice (my_project)

2. Create the python file for the application.

(index.py)
print ‘----------------CLOUD COMPUTING ------------------ ’
3. Create app.yaml file by taking the content from “
https://cloud.google.com/appengine/docs/standard/python/config/appref “
for configuring the application with the google cloud

17
runtime: python27
api_version: 1
threadsafe: false
handlers:
- url: /
script: index.py (two spaces before script:index.py)
4. Open cloud SDK by giving run as administrator and run the yaml file
app.yaml by giving the following command and give the path of the
application within double quotation: Google-cloud-sdk\bin\dev-
appserver.py “myproject/app.yaml”.

5. After execution goto browser and type http:localhost:8080 and view

the result.

18
RESULT
Thus Web Application using python program was created
and executed using Google App Engine.
19
Ex:No.5 SIMULATION OF SJF SCHEDULING
ALGORITHM IN CLOUDSIM

AIM
To simulate a cloud scenario using CloudSim and run a
scheduling algorithm that is not present in CloudSim.

PROCEDURE
1. Download CloudSim installable files
from https://code.google.com/p/cloudsim/downloads/list and unzip.

2. Open Eclipse.

3. Create a new Java Project: File -> New.

4. Import an unpacked CloudSim project into the new Java Project .

5. The first step is to initialise the CloudSim package by initialising the

CloudSim library, as
follows:
CloudSim.init(num_user, calendar, trace_flag)

6. Data centres are the resource providers in CloudSim; hence, creation

of data centres is a
second step. To create Datacenter, you need the
DatacenterCharacteristics object that stores the properties of a data
centre such as architecture, OS, list of machines, allocation policy that
covers the time or spaceshared, the time zone and its price:
Datacenter datacenter9883 = new Datacenter(name, characteristics, new
VmAllocationPolicySimple(hostList), storagelist,0);
20
7. The third step is to create a broker:
DatacenterBroker broker = createBroker();

8. The fourth step is to create one virtual machine unique ID of the VM,
userId ID of the VM’s owner, mips, number Of Pes amount of CPUs,
amount of RAM, amount of bandwidth, amount of storage, virtual
machine monitor, and cloudletScheduler policy for cloudlets:
Vm vm = new Vm(vmid, brokerId, mips, pesNumber, ram, bw, size,
vmm, new
CloudletSchedulerTimeShared())

9. Submit the VM list to the broker:

broker.submitVmList(vmlist)

10. Create a cloudlet with length, file size, output size, and utilisation
model:
Cloudlet cloudlet = new Cloudlet(id, length, pesNumber, fileSize,
outputSize, utilizationModel, utilizationModel,

11. Submit the cloudlet list to the broker:

broker.submitCloudletList(cloudletList)

12. Start the simulation.

PROGRAM
Simulation.java:
package taskchpack;

import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Calendar;

21
import java.util.LinkedList;
import java.util.List;
import java.util.Random;
import org.cloudbus.cloudsim.Cloudlet;
import org.cloudbus.cloudsim.CloudletSchedulerSpaceShared;
import org.cloudbus.cloudsim.CloudletSchedulerTimeShared;

import org.cloudbus.cloudsim.Datacenter; import

org.cloudbus.cloudsim.DatacenterBroker;

import org.cloudbus.cloudsim.DatacenterCharacteristics;
import org.cloudbus.cloudsim.Host;

import org.cloudbus.cloudsim.Log;
import org.cloudbus.cloudsim.Pe;
import org.cloudbus.cloudsim.Storage;

import org.cloudbus.cloudsim.UtilizationModel;

import org.cloudbus.cloudsim.UtilizationModelFull;

import org.cloudbus.cloudsim.Vm;

import org.cloudbus.cloudsim.VmAllocationPolicySimple;

import org.cloudbus.cloudsim.VmSchedulerTimeShared;

import org.cloudbus.cloudsim.core.CloudSim;

import org.cloudbus.cloudsim.provisioners.BwProvisionerSimple;

import org.cloudbus.cloudsim.provisioners.PeProvisionerSimple;

22
import org.cloudbus.cloudsim.provisioners.RamProvisionerSimple;
public class Simulation {

private static List<Cloudlet>

cloudletList; private static List<Vm> vmlist;
private static List<Vm> createVM(int userId, int vms)
{ LinkedList<Vm> list = new
LinkedList<Vm>();

long size = 10000; //image size (MB)

int ram = 512; //vm memory (MB)
int mips = 1000;
long bw = 1000;
int pesNumber = 1; //number of
cpus String vmm = "Xen"; //VMM
name Vm[] vm = new Vm[vms];
for(int i=0;i<vms;i++){
vm[i] = new Vm(i, userId, mips, pesNumber, ram, bw,
size, vmm, new CloudletSchedulerSpaceShared());
//for creating a VM with a space shared
scheduling policy for cloudlets:
//vm[i] = Vm(i, userId, mips, pesNumber, ram, bw,
size, vmm, new CloudletSchedulerSpaceShared());
list.add(vm[i]);
}
23
 return list;
}
private static List<Cloudlet> createCloudlet(int userId, int
cloudlets){
LinkedList<Cloudlet> list = new
LinkedList<Cloudlet>();
long length = 1000;
long fileSize = 300;
long outputSize = 300;
int pesNumber = 1;

UtilizationModel utilizationModel = new

UtilizationModelFull();
Cloudlet[] cloudlet = new Cloudlet[cloudlets];
for(int i=0;i<cloudlets;i++){
Random r= new Random();
cloudlet[i] = new Cloudlet(i, length +r.nextInt(2000),
pesNumber, fileSize, outputSize, utilizationModel, utilizationModel,
utilizationModel);
cloudlet[i].setUserId(userId);
list.add(cloudlet[i]);
}

24
 return list;
}
////////////////////////// STATIC METHODS ///////////////////////

public static void main(String[] args)

{ Log.printLine("Starting
CloudSimExample6...");
try {
int num_user = 3; // number of grid users
Calendar calendar = Calendar.getInstance();
boolean trace_flag = false; // mean trace events
CloudSim.init(num_user, calendar,
trace_flag);
Datacenter datacenter0 =
createDatacenter("Datacenter_0");

Datacenter datacenter1 =
createDatacenter("Datacenter_1");
DatacenterBroker broker =
createBroker();
int brokerId = broker.getId();
vmlist = createVM(brokerId,10);
//creating 20 vms
cloudletList = createCloudlet(brokerId,40); // creating
40 cloudlets
broker.submitVmList(vmlist);
25
 broker.submitCloudletList(cloudletList);
CloudSim.startSimulation();
// Final step: Print results when simulation is over
List<Cloudlet> newList =
broker.getCloudletReceivedList();
CloudSim.stopSimulation();

printCloudletList(newList)
//Print the debt of each user to each
datacenter //datacenter0.printDebts();
//datacenter1.printDebts();

Log.printLine("CloudSimExample6 finished!");
}
catch (Exception e)
{
e.printStackTrace();
Log.printLine("The simulation has been terminated due
to an unexpected error");
}
}

26
 private static Datacenter createDatacenter(String name)
{ List<Host> hostList = new
ArrayList<Host>();

List<Pe> peList1 = new

ArrayList<Pe>(); int mips = 1000;
peList1.add(new Pe(0, new PeProvisionerSimple(mips)));
peList1.add(new Pe(1, new PeProvisionerSimple(mips)));
peList1.add(new Pe(2, new PeProvisionerSimple(mips)));
peList1.add(new Pe(3, new PeProvisionerSimple(mips)));
List<Pe> peList2 = new ArrayList<Pe>();
peList2.add(new Pe(0, new
PeProvisionerSimple(mips)));
peList2.add(new Pe(1, new
PeProvisionerSimple(mips))); int hostId=0;
int ram = 2048; //host memory (MB)
long storage = 1000000; //host
storage int bw = 10000;
hostList.add(
new Host(
hostId,
new RamProvisionerSimple(ram),
new BwProvisionerSimple(bw),
27
 storage,
peList1,
new VmSchedulerTimeShared(peList1)
)
);
hostId++;
hostList.add(

new Host(
hostId,
new RamProvisionerSimple(ram),
new BwProvisionerSimple(bw),
storage,
peList2,
new VmSchedulerTimeShared(peList2)
)
);
//hostList.add(
new Host(
hostId,
new CpuProvisionerSimple(peList1),
new RamProvisionerSimple(ram),

28
 new BwProvisionerSimple(bw),
storage,
new VmSchedulerSpaceShared(peList1)
)
);

//To create a host with a oportunistic space-shared allocation

policy for PEs to VMs:
//hostList.add(
new Host(
hostId,
new CpuProvisionerSimple(peList1),
new RamProvisionerSimple(ram),
new BwProvisionerSimple(bw),
storage,
new
VmSchedulerOportunisticSpaceShared(peList1)
)
);
String arch = "x86"; // system architecture

String os = "Linux"; // operating system

29
 String vmm = "Xen";
double time_zone = 10.0; // time zone this resource located

double cost = 3.0; // the cost of using processing in

this resource
double costPerMem = 0.05; // the cost of using memory in this
resource
double costPerStorage = // the cost of using storage in
0.1; this resource
double costPerBw = 0.1; // the cost of using bw in this
resource
LinkedList<Storage> storageList = new
LinkedList<Storage>();

DatacenterCharacteristics characteristics = new

DatacenterCharacteristics(arch, os, vmm, hostList, time_zone, cost,
costPerMem, costPerStorage, costPerBw);
Datacenter datacenter = null;
try {

datacenter = new Datacenter(name, characteristics, new

VmAllocationPolicySimple(hostList), storageList, 0);
} catch (Exception e)

{ e.printStackTrace(

);

}
return datacenter;

30
 }
private static DatacenterBroker createBroker(){
DatacenterBroker broker = null;
try {
broker = new DatacenterBroker("Broker");
} catch (Exception e)

{ e.printStackTrace(

); return null;

}
return broker;
}
private static void printCloudletList(List<Cloudlet> list) {
int size = list.size();
Cloudlet cloudlet;
String indent = " ";
Log.printLine();
Log.printLine("========== OUTPUT ==========");
Log.printLine("Cloudlet ID" + indent + "STATUS" + indent
+
"Data center ID" + indent + "VM ID" + indent +
indent + "Time" + indent + "Start Time" + indent + "Finish Time"
+indent+"user id"+indent);
31
 DecimalFormat dft = new DecimalFormat("###.##");
for (int i = 0; i < size; i++) {
cloudlet = list.get(i);
Log.print(indent + cloudlet.getCloudletId() + indent +
indent);
if (cloudlet.getCloudletStatus() == Cloudlet.SUCCESS)
{
Log.print("SUCCESS");
Log.printLine( indent + indent +
cloudlet.getResourceId() + indent + indent + indent + cloudlet.getVmId()
+ indent + indent + indent + dft.format(cloudlet.getActualCPUTime())
+indent + indent + dft.format(cloudlet.getExecStartTime())+ indent +
indent + indent + dft.format(cloudlet.getFinishTime())+indent
+cloudlet.getUserId());

}
}

}
}

32
DatacenterBroker.java:
package taskchpack;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import org.cloudbus.cloudsim.Cloudlet;
import org.cloudbus.cloudsim.DatacenterCharacteristics;

import org.cloudbus.cloudsim.Log; import

org.cloudbus.cloudsim.Vm;

import org.cloudbus.cloudsim.core.CloudSim;
import org.cloudbus.cloudsim.core.CloudSimTags;
import org.cloudbus.cloudsim.core.SimEntity;
import org.cloudbus.cloudsim.core.SimEvent;
import org.cloudbus.cloudsim.lists.CloudletList;
import org.cloudbus.cloudsim.lists.VmList; public
class DatacenterBroker extends SimEntity {

protected List<? extends Vm> vmList;

protected List<? extends Vm> vmsCreatedList;

protected List<? extends Cloudlet> cloudletList;

33
 protected List<? extends Cloudlet>
cloudletSubmittedList; protected List<? extends
Cloudlet> cloudletReceivedList; protected int
cloudletsSubmitted; protected int vmsRequested;
protected int vmsAcks;
protected int vmsDestroyed;
protected List<Integer> datacenterIdsList;
protected List<Integer> datacenterRequestedIdsList;
protected Map<Integer, Integer> vmsToDatacentersMap;

protected Map<Integer, DatacenterCharacteristics>

datacenterCharacteristicsList;
public DatacenterBroker(String name) throws Exception
{ super(name);
setVmList(new ArrayList<Vm>());
setVmsCreatedList(new ArrayList<Vm>());
setCloudletList(new ArrayList<Cloudlet>());
setCloudletSubmittedList(new ArrayList<Cloudlet>());

setCloudletReceivedList(new ArrayList<Cloudlet>());
cloudletsSubmitted = 0;
setVmsRequested(0);
setVmsAcks(0);

34
 setVmsDestroyed(0);
setDatacenterIdsList(new LinkedList<Integer>());
setDatacenterRequestedIdsList(new ArrayList<Integer>());

setVmsToDatacentersMap(new HashMap<Integer,
Integer>());
setDatacenterCharacteristicsList(new HashMap<Integer,
DatacenterCharacteristics>());
}

public void submitVmList(List<? extends Vm> list)

{ getVmList().addAll(list);
}

public void submitCloudletList(List<? extends Cloudlet> list)

{ getCloudletList().addAll(list);
}
public void bindCloudletToVm(int cloudletId, int vmId) {
CloudletList.getById(getCloudletList(),
cloudletId).setVmId(vmId);

}
@Override
public void processEvent(SimEvent ev) {
switch (ev.getTag()) {

35
 case
CloudSimTags.RESOURCE_CHARACTERISTICS_REQUEST:
processResourceCharacteristicsRequest(ev);
break;
case
CloudSimTags.RESOURCE_CHARACTERISTICS:

processResourceCharacteristics(ev);

break;

case CloudSimTags.VM_CREATE_ACK:
processVmCreate(ev);
break;
case CloudSimTags.CLOUDLET_RETURN:
processCloudletReturn(ev);
break;
// if the simulation finishes
case CloudSimTags.END_OF_SIMULATION:
shutdownEntity();
break;
/ other unknown tags are processed by this
method default:
processOtherEvent(ev);

36
 break;
}
}
protected void processResourceCharacteristics(SimEvent ev) {
DatacenterCharacteristics characteristics =
(DatacenterCharacteristics) ev.getData();
getDatacenterCharacteristicsList().put(characteristics.getId(),
characteristics);

if (getDatacenterCharacteristicsList().size() ==
getDatacenterIdsList().size()) {
setDatacenterRequestedIdsList(new
ArrayList<Integer>());

createVmsInDatacenter(getDatacenterIdsList().get(0));
}
}
protected void processResourceCharacteristicsRequest(SimEvent
ev) {
setDatacenterIdsList(CloudSim.getCloudResourceList());
setDatacenterCharacteristicsList(new HashMap<Integer,
DatacenterCharacteristics>());

37
 Log.printLine(CloudSim.clock() + ": " + getName() + ":
Cloud Resource List received with "
+ getDatacenterIdsList().size() + " resource(s)");

for (Integer datacenterId : getDatacenterIdsList()) {

sendNow(datacenterId,
CloudSimTags.RESOURCE_CHARACTERISTICS, getId());
}
}
protected void processVmCreate(SimEvent ev)
{ int[] data = (int[]) ev.getData();
int datacenterId = data[0];
int vmId = data[1];
int result = data[2];
if (result == CloudSimTags.TRUE)

{ getVmsToDatacentersMap().put(vmId,

datacenterId);

getVmsCreatedList().add(VmList.getById(getVmList(), vmId));
Log.printLine(CloudSim.clock() + ": " + getName() + ":
VM #" + vmId
+ " has been created in Datacenter #" +
datacenterId + ", Host #"
38
 + VmList.getById(getVmsCreatedList(),
vmId).getHost().getId());
} else {
Log.printLine(CloudSim.clock() + ": " + getName() + ":
Creation of VM #" + vmId + " failed in Datacenter #" + datacenterId);
}
incrementVmsAcks();
if (getVmsCreatedList().size() == getVmList().size() -
getVmsDestroyed()) {
submitCloudlets();
} else {
if (getVmsRequested() == getVmsAcks()) {
// find id of the next datacenter that has not been
tried
for (int nextDatacenterId : getDatacenterIdsList())
{
if
(!getDatacenterRequestedIdsList().contains(nextDatacenterId)) {

createVmsInDatacenter(nextDatacenterId);
return;
}
}

39
 // all datacenters already queried
if (getVmsCreatedList().size() > 0) { // if some vm
were created
submitCloudlets();

} else { // no vms created. abort

Log.printLine(CloudSim.clock() + ": " +
getName()
+ ": none of the required VMs
could be created. Aborting");
finishExecution();
}
}
}
}
protected void processCloudletReturn(SimEvent ev)
{ Cloudlet cloudlet = (Cloudlet) ev.getData();
getCloudletReceivedList().add(cloudlet);
Log.printLine(CloudSim.clock() + ": " + getName() + ":
Cloudlet " + cloudlet.getCloudletId() + " received");
cloudletsSubmitted--;

40
 if (getCloudletList().size() == 0 && cloudletsSubmitted ==
0) { // all cloudlets executed
Log.printLine(CloudSim.clock() + ": " + getName() + ":
All Cloudlets executed. Finishing...");
clearDatacenters();
finishExecution();
} else { // some cloudlets haven't finished yet
if (getCloudletList().size() > 0 && cloudletsSubmitted
==0){
// all the cloudlets sent finished. It means that some
bount

/ cloudlet is waiting its VM be

created clearDatacenters();
createVmsInDatacenter(0);
}

}
}

protected void processOtherEvent(SimEvent ev)

{ if (ev == null) {

41
 Log.printLine(getName() + ".processOtherEvent(): " +
"Error - an event is null.");
return;
}

Log.printLine(getName() + ".processOtherEvent(): "

+ "Error - event unknown by this
DatacenterBroker.");
}
protected void createVmsInDatacenter(int datacenterId) {
/ send as much vms as possible for this datacenter before
trying the next one
int requestedVms = 0;

String datacenterName =
CloudSim.getEntityName(datacenterId);
for (Vm vm : getVmList()) {
if
(!getVmsToDatacentersMap().containsKey(vm.getId())) {

Log.printLine(CloudSim.clock() + ": " +

getName() + ": Trying to Create VM #" + vm.getId() + " in " +
datacenterName);
sendNow(datacenterId,
CloudSimTags.VM_CREATE_ACK, vm);

42
 requestedVms++;
}
}
getDatacenterRequestedIdsList().add(datacenterId);

setVmsRequested(requestedVms); setVmsAcks(0);

}
protected void submitCloudlets() {
int vmIndex = 0;

List <Cloudlet> sortList= new ArrayList<Cloudlet>();

ArrayList<Cloudlet> tempList = new
ArrayList<Cloudlet>(); for(Cloudlet cloudlet:
getCloudletList()) {
tempList.add(cloudlet);
}

int totalCloudlets= tempList.size();

for(int i=0;i<totalCloudlets;i++)

{
Cloudlet smallestCloudlet= tempList.get(0);
for(Cloudlet checkCloudlet: tempList)

43
 {

if(smallestCloudlet.getCloudletLength()>checkCloudlet.getCloudl
etLength())

{
smallestCloudlet= checkCloudlet;
}
}
sortList.add(smallestCloudlet);
tempList.remove(smallestCloudlet);

}
int count=1;
for(Cloudlet printCloudlet: sortList)
{
Log.printLine(count+".Cloudler
Id:"+printCloudlet.getCloudletId()+",Cloudlet
Length:"+printCloudlet.getCloudletLength());
count++;
}
for (Cloudlet cloudlet : sortList) {
Vm vm;

44
 // if user didn't bind this cloudlet and it has not been
executed yet
if (cloudlet.getVmId() == -1) {
vm = getVmsCreatedList().get(vmIndex);
} else { // submit to the specific vm
vm = VmList.getById(getVmsCreatedList(),
cloudlet.getVmId());
if (vm == null) { // vm was not created
Log.printLine(CloudSim.clock() + ": " +
getName() + ": Postponing execution of cloudlet "+
cloudlet.getCloudletId() + ": bount VM not available");
continue;
}
}
Log.printLine(CloudSim.clock() + ": " + getName()
+ ": Sending cloudlet " + cloudlet.getCloudletId() + " to VM #"
+ vm.getId());
cloudlet.setVmId(vm.getId());
sendNow(getVmsToDatacentersMap().get(vm.getId()),
CloudSimTags.CLOUDLET_SUBMIT, cloudlet);

cloudletsSubmitted++;
vmIndex = (vmIndex + 1) %
getVmsCreatedList().size();

45
 getCloudletSubmittedList().add(cloudlet);
}

for (Cloudlet cloudlet : getCloudletSubmittedList())

{ getCloudletList().remove(cloudlet);
}
}
protected void clearDatacenters() {
for (Vm vm : getVmsCreatedList()) {
Log.printLine(CloudSim.clock() + ": " + getName() + ":
Destroying VM #" + vm.getId());
sendNow(getVmsToDatacentersMap().get(vm.getId()),
CloudSimTags.VM_DESTROY, vm);

getVmsCreatedList().clear();
}
protected void finishExecution() {
sendNow(getId(), CloudSimTags.END_OF_SIMULATION);
}
@Override
public void shutdownEntity() {

46
 Log.printLine(getName() + " is shutting down...");
}
@Override
public void startEntity()
{ Log.printLine(getName() + " is
starting...");

schedule(getId(), 0,
CloudSimTags.RESOURCE_CHARACTERISTICS_REQUEST);
}
@SuppressWarnings("unchecked")

public <T extends Vm> List<T> getVmList()

{ return (List<T>) vmList;
}
protected <T extends Vm> void setVmList(List<T> vmList)
{ this.vmList = vmList;
}
@SuppressWarnings("unchecked")

public <T extends Cloudlet> List<T> getCloudletList()

{ return (List<T>) cloudletList;
}
protected <T extends Cloudlet> void setCloudletList(List<T>
cloudletList) {
47
 this.cloudletList = cloudletList;
}
@SuppressWarnings("unchecked")
public <T extends Cloudlet> List<T> getCloudletSubmittedList() {
return (List<T>) cloudletSubmittedList;
}
protected <T extends Cloudlet> void
setCloudletSubmittedList(List<T> cloudletSubmittedList) {
this.cloudletSubmittedList = cloudletSubmittedList;
}
@SuppressWarnings("unchecked")
public <T extends Cloudlet> List<T> getCloudletReceivedList() {
return (List<T>) cloudletReceivedList;
}
protected <T extends Cloudlet> void
setCloudletReceivedList(List<T> cloudletReceivedList) {
this.cloudletReceivedList = cloudletReceivedList;
}
@SuppressWarnings("unchecked")
public <T extends Vm> List<T> getVmsCreatedList() {
return (List<T>) vmsCreatedList;

48
 }

protected <T extends Vm> void setVmsCreatedList(List<T>

vmsCreatedList) {
this.vmsCreatedList = vmsCreatedList;
}
protected int getVmsRequested() {
return vmsRequested;
}
protected void setVmsRequested(int vmsRequested)
{ this.vmsRequested = vmsRequested;
}
protected int getVmsAcks() {
return vmsAcks;
}
protected void setVmsAcks(int vmsAcks)
{ this.vmsAcks = vmsAcks;
}
protected void incrementVmsAcks()
{ vmsAcks++;
}
protected int getVmsDestroyed() {

49
 return vmsDestroyed;
}

protected void setVmsDestroyed(int vmsDestroyed)

{ this.vmsDestroyed = vmsDestroyed;
}
protected List<Integer> getDatacenterIdsList()
{ return datacenterIdsList;
}
protected void setDatacenterIdsList(List<Integer>
datacenterIdsList) {
this.datacenterIdsList = datacenterIdsList;
}
protected Map<Integer, Integer> getVmsToDatacentersMap()
{ return vmsToDatacentersMap;
}
protected void setVmsToDatacentersMap(Map<Integer,
Integer> vmsToDatacentersMap) {
this.vmsToDatacentersMap = vmsToDatacentersMap;
}

protected Map<Integer, DatacenterCharacteristics>

getDatacenterCharacteristicsList() {
return datacenterCharacteristicsList;
50
 }
protected void setDatacenterCharacteristicsList(
Map<Integer, DatacenterCharacteristics>
datacenterCharacteristicsList) {
this.datacenterCharacteristicsList =
datacenterCharacteristicsList;
}
protected List<Integer> getDatacenterRequestedIdsList() {
return datacenterRequestedIdsList;
}

protected void setDatacenterRequestedIdsList(List<Integer>

datacenterRequestedIdsList) {
this.datacenterRequestedIdsList =
datacenterRequestedIdsList;
}

51
OUTPUT
Starting CloudSimExample1...
Initialising...
Starting CloudSim version 3.0
Datacenter_0 is starting...
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>null
Broker is starting...
Entities started.
: Broker: Cloud Resource List received with 1 resource(s)
0.0: Broker: Trying to Create VM #0 in Datacenter_0
: Broker: VM #0 has been created in Datacenter #2, Host
#0 0.1: Broker: Sending cloudlet 0 to VM #0
400.1: Broker: Cloudlet 0 received
400.1: Broker: All Cloudlets executed. Finishing...
400.1: Broker: Destroying VM
#0 Broker is shutting down...
Simulation: No more future events
CloudInformationService: Notify all CloudSim entities for shutting
down. Datacenter_0 is shutting down...
Broker is shutting down...
Simulation completed.
Simulation completed.
========== OUTPUT ==========
Cloudlet ID STATUS Data center ID VM ID Time Start Time Finish
Time
0 SUCCESS 2 0 400 0.1 400.1
*****Datacenter:
Datacenter_0***** User id Debt
3 35.6
CloudSimExample1 finished!

52
RESULT
Thus a cloud scenario was simulated using CloudSim and a scheduling
algorithm that is not present in CloudSim was executed successfully.

53
 Ex:No.6 FILE SHARING BETWEEN PHYSICAL
MACHINE AND VIRTUAL MACHINE

AIM:
To share files between physical machine and virtual machine.

PROCEDURE:

1. Open a virtual machine.

2. Select a file which is to be shared in the machine.

3. Select an already existing file for sharing.

54
4. Open VMware workstation and go to VM tab and click install
VMware tools.
If install VMWare tools are grayed out,then follow the steps.

i Shut down the virtual machine.

ii Open VMWare Workstation Player and right-click on the VM. (Don't start
the VM)
iii Select the "Settings" option to edit the hardware settings.
iv Highlight the CD/Drive on the left sidebar under the Hardware tab
and click on the remove button.
v Repeat the above step to remove the Floppy Drive. (Technically optional,
but this is what fixed it for me. )
vi Click on the "Add button" and select "CD/DVD" Drive and select
finish. The right pane should now have the option "Use Physical Drive >
Auto Detect" enabled.
vii Click on "OK" to close the window, and Start the VM as usual.
viii Once it has booted to the desktop, click on the menu at the top left
corner and go to "Player > Manage > Install VMWare Tools".
5. Open a virtual machine to which the file has to shared and power on.
6. Goto settings of the virtual machine.
7. In VM Settings go to options.
8. Select the “shared folder” option
9. Enable the shared folder option by selecting “always enable” , check
“Map as a network drive in windows path” and click add and click next.
55
10.If always enable was disabled then click on vmware tools folder in the
desktop and extract the files.After extracting open terminal and give the
following commands
$cd Desktop/
$ls
$cd vmware-tools-distrib/
$ls
$ sudo ./vmware-install.pl then enter the password and then enter yes and click
enter.

56
11.Power off the vitual machine and power on.To check whether the
VMWare tools are installed , open the terminal enter the command $ vmware-
toolbox-cmd --version
12.Follow the commands to share the files between physical and virtual layer
$vmaware-hgfsclient
$cd /mnt
57
$cd hgfs/
$ls using this command check whether your file is there.

13.Now in virtual machine open files folder ->open other location

locations->open computers->
Open mnt folder->hgfs folder->file->text.txt file.
14.Update any changes in the text file and save it in virtual machine .
14. Goto Host Machine open the file and check for updation.
15. Make some changes in the file in host machine and check for the
updation in the
virtual machine.

58
RESULT:
Thus the file is shared between physical and virtual machine.
59
Ex:No.7 Launching Virtual Machine Using TryStack

AIM
To find a procedure to launch virtual machine using TryStack.

PROCEDURE
Step 1: Create Network
1. Go to Network > Networks and then click Create Network.
2. In Network tab, fill Network Name for example internal
and then click Next.
3. In Subnet tab,
1. Fill Network Address with appropriate CIDR, for
example 192.168.1.0/24. Use private network CIDR
block as the best practice.
2. Select IP Version with appropriate IP version, in this
case IPv4.
3. Click Next.
4. In Subnet Details tab, fill DNS Name Servers with 8.8.8.8
(Google DNS) and then click Create.
Step 2: Create Instance
1. Go to Compute > Instances and then click Launch Instance.
2. In Details tab,
ample
1. Fill Instance Name, for e Ubuntu 1.
2. Select Flavor, for example m1.medium.
3. Fill Instance Count with 1.
4. Select Instance Boot Source with Boot from Image.
5. Select Image Name with Ubuntu 14.04 amd64 (243.7
MB) if you want install Ubuntu

60
 14.04 in your virtual machine.
3. In Access & Security tab,
1. Click [+] button of Key Pair to import key pair. This key pair
is a public and private key that we will use to connect to the
instance from our machine.
2. In Import Key Pair dialog,
1. Fill Key Pair Name with your machine name (for
example Edward-Key).
2. Fill Public Key with your SSH public key (usually is
in ~/.ssh/id_rsa.pub). See description in Import Key
Pair dialog box for more information. If you are using
Windows, you can use Puttygen to generate key pair.
3. Click Import key pair.
3. In Security Groups, mark/check default.
4. In Networking tab,
1. In Selected Networks, select network that have been
created in Step 1, for example internal.
5. Click Launch.
6. If you want to create multiple instances, you can repeat
step 1-5. I created one more instance with instance name
Ubuntu 2.
Step 3: Create Router
1. Go to Network > Routers and then click Create Router.
2. Fill Router Name for router and then click Create router.
example
3. Click on your router name link, for example router1, Router Details page.
4. Click Set Gateway button in upper right:
1. Select External networks with external.
2. Then OK.
5. Click Add Interface button.
1. Select Subnet with the network that you have been created in
Step 1.

61
 2. Click Add interface.
6. Go to Network > Network Topology. You will see the
network topology. In the example, there are two network,
i.e. external and internal, those are bridged by a router.
There are instances those are joined to internal network.

Step 4: Configure Floating IP Address

1. Go to Compute > Instance.

2. In one of your instances, click More > Associate Floating
IP.
3. In IP Address, click Plus [+].
4. Select Pool to external and then click Allocate IP.
5. Click Associate.
6. Now you will get a public IP, e.g. 8.21.28.120, for your
instance.
Step 5: Configure Access & Security
1. Go to Compute > Access & Security and then open
Security Groups tab.
2. In default row, click Manage Rules.
3. Click Add Rule, choose ALL ICMP rule to enable ping
into your instance, and then click Add.
4. Click Add Rule, choose HTTP rule to open HTTP port
(port 80), and then click Add.
5. Click Add Rule, choose SSH rule to open SSH port (port
22), and then click Add.
6. You can open other ports by creating new rules.
Step 6: SSH to Your Instance

62
 Now, you can SSH your instances to the floating IP
address that you got in the step 4. If you are using Ubuntu
image, the SSH user will be ubuntu.

OUTPUT

63
RESULT
Thus a procedure to launch virtual machine using TryStack was
written successfully.

64
 Ex:No.8 INSTALLING HADOOP SINGLE NODE CLUSTER

IN WINDOWS AND RUNNING SIMPLE APPLICATIONS

LIKE WORDCOUNT

AIM
To find procedure to set up the one node Hadoop cluster and run
simple applications like wordcount.

PROCEDURE
Step 1: Installing Java is the main prerequisite for Hadoop. Install java16
and set the path for the JAVA_HOME environment variable.

Step 2: Install Apache Hadoop 3.1.0 for windows and Hadoop 3.1.0.

Step 3:  Replace bin in Hadoop 3.1.0 by Apache Hadoop (rename original bin
in Hadoop to bin1 and  then copy bin to it).

Step 4: Set the Hadoop bin path to path in the environment

variable.
Step 5: Set the JAVA_HOME path in hadoop-env.cmd.
(Hadoop-> etc-> Hadoop -> Hadoop-env.cmd)
Step 6: Open the Eclipse and create the Java Project.

Step 7: : Type the wordcount program in Eclipse.

Step 8: Add Client libraries jars and map-reduce jars(except examples jar)
using the build path option.

Step 9: Export the Project as a Jar File.

65
Step 11: Execute the Jar File in the cmd using the command.
( hadoop jar <filename.jar> <inputdir> <outputdir>)
Step 12: Execute the Hadoop program using(hdfs dfs -cat
<outputdir>/* ).

Program
import java.io.IOException;
import java.util.StringTokenizer;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.input.FileOuputFormat;
public class WordCount{
public static class TokenizerMapper extends Mapper<Object,
Text, Text, IntWritable>{
private final static IntWritable one = new
IntWritable(1); private Text word = new Text();
public void map(Object key, Textvalue, Context
context) throws IOException, InterruptedException{

66
 StringTokenizer itr = new StringTokenizer(value.toStri
ng());
while (itr.hasMoreTokens()){
word.set(itr.nextToken());
output.collect(word, one);
}
}
}

public static class IntSumReducer extedns Reducer<Text,

IntWritable, Text, IntWritable>{
private IntWritable result = new IntWritable();
public void reduce(Text key, Iterable<IntWritable> values,
Context context) throw IOException, InterruptedException{
int sum=0;
for(IntWritable val:values){
sum+=val.get();
}
result.set(sum);
context.write(key, result);
}
}

public static void main(String[] args) throws

Exception{ Configuration conf=new
Configuration();
Job job=Job.getInstance(conf, “word count”);
Job.setJarByClass(WordCount.Class);

67
 Job.setMapperClass(TokenixerMapper.Class);
Job.setCombinerClass(IntSumReducer.Class);
Job.setReducerClass(IntSumReducer.Class);
Job.setOutputKeyClass(Text.Class);
Job.OutputValueClass(IntWritable.Class);
FileInputFormat.addInputPath(job, new Path(args[0]));
FileOutputFormat.addOutputPath(job, new Path(args[1]));
System.exit(job. waitForCompletion(true)?0:1);
}
}

Input File (input.txt)

68
Output

69
RESULT

Thus, the set up the one node Hadoop cluster and the number of
words were counted successfully.
70
71