Experiment- 04

Aim-
Implementation of Shortest Job First algorithm using cloudSim

Program:-

DataBroker.java File
package org.cloudbus.cloudsim;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
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;

/**
* DatacentreBroker represents a broker acting on behalf of a user. It hides VM management, as vm
* creation, sumbission of cloudlets to this VMs and destruction of VMs.
*
* @author Rodrigo N. Calheiros
* @author Anton Beloglazov
* @since CloudSim Toolkit 1.0
*/
public class DatacenterBroker extends SimEntity {
/** The vm list. */
protected List<? extends Vm> vmList;
/** The vms created list. */
protected List<? extends Vm> vmsCreatedList;
/** The cloudlet list. */
protected List<? extends Cloudlet> cloudletList;
/** The cloudlet submitted list. */
protected List<? extends Cloudlet> cloudletSubmittedList;
/** The cloudlet received list. */
protected List<? extends Cloudlet> cloudletReceivedList;
/** The cloudlets submitted. */
protected int cloudletsSubmitted;
/** The vms requested. */
protected int vmsRequested;
/** The vms acks. */
protected int vmsAcks;
/** The vms destroyed. */
protected int vmsDestroyed;
/** The datacenter ids list. */
protected List<Integer> datacenterIdsList;
/** The datacenter requested ids list. */
protected List<Integer> datacenterRequestedIdsList;
/** The vms to datacenters map. */
protected Map<Integer, Integer> vmsToDatacentersMap;
/** The datacenter characteristics list. */
protected Map<Integer, DatacenterCharacteristics> datacenterCharacteristicsList;
/**

Manjot Singh 2220979 D1

* Created a new DatacenterBroker object.
*
* @param name name to be associated with this entity (as required by Sim_entity class from
*simjava package)
* @throws Exception the exception
* @pre name != null
* @post $none
*/
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);
setVmsDestroyed(0);
setDatacenterIdsList(new LinkedList<Integer>());
setDatacenterRequestedIdsList(new ArrayList<Integer>());
setVmsToDatacentersMap(new HashMap<Integer, Integer>());
setDatacenterCharacteristicsList(new HashMap<Integer, DatacenterCharacteristics>());
}
/ * *

* This method is used to send to the broker the list with virtual machines that must be
* created.
*
* @param list the list
* @pre list !=null
* @post $none
*/
public void submitVmList(List<? extends Vm> list) {
getVmList().addAll(list);
}
/ * *

* This method is used to send to the broker the list of cloudlets.

*
* @param list the list
* @pre list !=null
* @post $none
*/
public void submitCloudletList(List<? extends Cloudlet> list) {
getCloudletList().addAll(list);
}
/ * *

* Specifies that a given cloudlet must run in a specific virtual machine.

*
* @param cloudletId ID of the cloudlet being bount to a vm
* @param vmId the vm id
* @pre cloudletId > 0
* @pre id > 0
* @post $none
*/
public void bindCloudletToVm(int cloudletId, int vmId) {
CloudletList.getById(getCloudletList(), cloudletId).setVmId(vmId);
}
/ * *

* Processes events available for this Broker.

*

Manjot Singh 2220979 D1

 * @param ev a SimEvent object
* @pre ev != null
* @post $none
*/
@Override
public void processEvent(SimEvent ev) {
switch (ev.getTag()) {
// Resource characteristics request
case CloudSimTags.RESOURCE_CHARACTERISTICS_REQUEST:
processResourceCharacteristicsRequest(ev);
break;
// Resource characteristics answer
case CloudSimTags.RESOURCE_CHARACTERISTICS:
processResourceCharacteristics(ev);
break;
// VM Creation answer
case CloudSimTags.VM_CREATE_ACK:
processVmCreate(ev);
break;
// A finished cloudlet returned
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);
break;
}
}
/ * *

* Process the return of a request for the characteristics of a PowerDatacenter.

*
* @param ev a SimEvent object
* @pre ev != $null
* @post $none
*/
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));
}
}
/ * *

* Process a request for the characteristics of a PowerDatacenter.

*
* @param ev a SimEvent object
* @pre ev != $null
* @post $none
*/
protected void processResourceCharacteristicsRequest(SimEvent ev) {
setDatacenterIdsList(CloudSim.getCloudResourceList());
setDatacenterCharacteristicsList(new HashMap<Integer, DatacenterCharacteristics>());
Log.printLine(CloudSim.clock() + ": " + getName() + ": Cloud Resource List received with "

+ getDatacenterIdsList().size() + " resource(s)");

Manjot Singh 2220979 D1

 for (Integer datacenterId : getDatacenterIdsList()) { sendNow(datacenterId,
CloudSimTags.RESOURCE_CHARACTERISTICS, getId()); } } /** * Process the
ack received due to a request for VM creation. *

* @param ev a SimEvent object

* @pre ev != null
* @post $none
*/
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 #"
+ VmList.getById(getVmsCreatedList(), vmId).getHost().getId());
} else {
Log.printLine(CloudSim.clock() + ": " + getName() + ": Creation of VM #" + vmId
+ " failed in Datacenter #" + datacenterId);
} incrementVmsAcks(); // all the requested VMs have been created if (getVmsCreatedList().size() == getVmList().size() -
getVmsDestroyed()) {

submitCloudlets(); // all the acks received, but some

}VMs
else {were not created 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;
}

} // 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();
}
}
}
}
/
*
** Process a cloudlet return event.
* * @param ev a SimEvent
object * @pre ev != $null *
@post $none

Manjot Singh 2220979 D1

 protected void processCloudletReturn(SimEvent ev) {
Cloudlet cloudlet = (Cloudlet) ev.getData();
getCloudletReceivedList().add(cloudlet);
Log.printLine(CloudSim.clock() + ": " + getName() + ": Cloudlet " + cloudlet.getCloudletId()
+ " received");
cloudletsSubmitted--;
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);
}

}
}
/ * *

* Overrides this method when making a new and different type of Broker. This method is called
* by {@link #body()} for incoming unknown tags.
*
* @param ev a SimEvent object
* @pre ev != null
* @post $none
*/

protected void processOtherEvent(SimEvent ev) {

if (ev == null) {
Log.printLine(getName() + ".processOtherEvent(): " + "Error - an event is null.");
return;
} Log.printLine(getName() + ".processOtherEvent(): "

+ "Error - event unknown by this DatacenterBroker.");

}
/ * *

* Create the virtual machines in a datacenter. * * @param

datacenterId Id of the chosen PowerDatacenter * @pre $none *
@post $none */

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 #" +

+ " in " + datacenterName);

sendNow(datacenterId,
CloudSimTags.VM_CREATE_ACK, vm);
requestedVms++;
}
}

Manjot Singh 2220979 D1

 getDatacenterRequestedIdsList().add(datacenterId);
setVmsRequested(requestedVms);
setVmsAcks(0);
}
/**
* Submit cloudlets to the created VMs.
*

* @pre $none
* @post $none
*/
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)
{
if(smallestCloudlet.getCloudletLength()>checkCloudlet.getCloudletLength())
{
smallestCloudlet= checkCloudlet;
}

} sortList.add(smallestCloudlet); tempList.remove(smallestCloudlet);

} int count=1; for(Cloudlet printCloudlet: sortList) {

Length:"+printCloudlet.getCloudletLength());
Log.printLine(count+".Cloudler Id:"+printCloudlet.getCloudletId()+",Cloudlet

count++;
}
for (Cloudlet cloudlet : sortList) {
Vm vm;
// 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
cloudlet " Log.printLine(CloudSim.clock() + ": " + getName() + ": Postponing execution of
+ cloudlet.getCloudletId() + ": bount VM not available");
continue;
}
} Log.printLine(CloudSim.clock() + ": " + getName() + ": Sending cloudlet "
cloudlet.setVmId(vm.getId()); + cloudlet.getCloudletId() + " to VM #" + vm.getId());
CloudSimTags.CLOUDLET_SUBMIT, cloudlet);
sendNow(getVmsToDatacentersMap().get(vm.getId()),
cloudletsSubmitted++;
vmIndex = (vmIndex + 1) % getVmsCreatedList().size();

Manjot Singh 2220979 D1

 getCloudletSubmittedList().add(cloudlet);

} // remove submitted cloudlets from waiting list for (Cloudlet cloudlet :

getCloudletSubmittedList()) {
getCloudletList().remove(cloudlet);
}
}
/ * *

* Destroy the virtual machines running in datacenters.

*
* @pre $none
* @post $none
*/
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();
}
/ * *

* Send an internal event communicating the end of the simulation.

*
* @pre $none
* @post $none
*/
protected void finishExecution() {
sendNow(getId(), CloudSimTags.END_OF_SIMULATION);
}
/ *

* (non-Javadoc)
* @see cloudsim.core.SimEntity#shutdownEntity()
*/
@Override
public void shutdownEntity() {
Log.printLine(getName() + " is shutting down...");
}
/ *

* (non-Javadoc)
* @see cloudsim.core.SimEntity#startEntity()
*/
@Override
public void startEntity() {
Log.printLine(getName() + " is starting...");
schedule(getId(), 0, CloudSimTags.RESOURCE_CHARACTERISTICS_REQUEST);
}
/ * *

* Gets the vm list.

*
* @param <T> the generic type
* @return the vm list
*/
@SuppressWarnings("unchecked")
public <T extends Vm> List<T> getVmList() {
return (List<T>) vmList;
}
/ * *

* Sets the vm list.

*
* @param <T> the generic type
* @param vmList the new vm list
*/

Manjot Singh 2220979 D1

 protected <T extends Vm> void setVmList(List<T> vmList) {
this.vmList = vmList;
}
/**
* Gets the cloudlet list.
*

* @param <T> the generic type

* @return the cloudlet list
*/
@SuppressWarnings("unchecked")
public <T extends Cloudlet> List<T> getCloudletList() {
return (List<T>) cloudletList;
}
/ * *

* Sets the cloudlet list.

*
* @param <T> the generic type
* @param cloudletList the new cloudlet list
*/
protected <T extends Cloudlet> void setCloudletList(List<T> cloudletList) {
this.cloudletList = cloudletList;
}
/ * *

* Gets the cloudlet submitted list.

*
* @param <T> the generic type
* @return the cloudlet submitted list
*/
@SuppressWarnings("unchecked")
public <T extends Cloudlet> List<T> getCloudletSubmittedList() {
return (List<T>) cloudletSubmittedList;
}
/ * *

* Sets the cloudlet submitted list.

*
* @param <T> the generic type
* @param cloudletSubmittedList the new cloudlet submitted list
*/
protected <T extends Cloudlet> void setCloudletSubmittedList(List<T> cloudletSubmittedList) {
this.cloudletSubmittedList = cloudletSubmittedList;
}
/ * *

* Gets the cloudlet received list.

*
* @param <T> the generic type
* @return the cloudlet received list
*/
@SuppressWarnings("unchecked")
public <T extends Cloudlet> List<T> getCloudletReceivedList() {
return (List<T>) cloudletReceivedList;
}
/ * *

* Sets the cloudlet received list.

*
* @param <T> the generic type
* @param cloudletReceivedList the new cloudlet received list
*/
protected <T extends Cloudlet> void setCloudletReceivedList(List<T> cloudletReceivedList) {
this.cloudletReceivedList = cloudletReceivedList;
}
/ * *

Manjot Singh 2220979 D1

Simulation.java
package examples.org.cloudbus.cloudsim.examples;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Calendar;
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;
import org.cloudbus.cloudsim.provisioners.RamProvisionerSimple;
/**
* An example showing how to create
* scalable simulations.
*/
public class Simulation {

/** The cloudlet list. */

private static List<Cloudlet> cloudletList;
/** The vmlist. */
private static List<Vm> vmlist;
private static List<Vm> createVM(int userId, int vms) {

//Creates a container to store VMs. This list is passed to the broker later
LinkedList<Vm> list = new LinkedList<Vm>(); //VM Parameters 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 //create VMs Vm[] vm = new
Vm[vms];

CloudletSchedulerSpaceShared());

for(int i=0;i<vms;i++){
vm[i] = new Vm(i, userId, mips, pesNumber, ram, bw, size, vmm, new
//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]);

Manjot Singh 2220979 D1

}
return list;
}

private static List<Cloudlet> createCloudlet(int userId, int cloudlets){

// Creates a container to store Cloudlets
LinkedList<Cloudlet> list = new LinkedList<Cloudlet>();
//cloudlet parameters
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++){

outputSize, utilizationModel, utilizationModel, utilizationModel);

Random r= new Random();
cloudlet[i] = new Cloudlet(i, length +r.nextInt(2000), pesNumber, fileSize,
// setting the owner of these Cloudlets
cloudlet[i].setUserId(userId);
list.add(cloudlet[i]);
}
r e t u r n l i s t ;
}

////////////////////////// STATIC METHODS ///////////////////////

/**
* Creates main() to run this example
*/
public static void main(String[] args) {
Log.printLine("Starting CloudSimExample6...");
try {
// First step: Initialize the CloudSim package. It should be called
// before creating any entities.
int num_user = 3; // number of grid users
Calendar calendar = Calendar.getInstance();
boolean trace_flag = false; // mean trace events
// Initialize the CloudSim library
CloudSim.init(num_user, calendar, trace_flag);
// Second step: Create Datacenters
them to run a CloudSim simulation
//Datacenters are the resource providers in CloudSim. We need at list one of
Datacenter datacenter0 = createDatacenter("Datacenter_0");
Datacenter datacenter1 = createDatacenter("Datacenter_1");
//Third step: Create Broker DatacenterBroker broker =
createBroker(); int brokerId = broker.getId(); //Fourth step: Create
VMs and Cloudlets and send them to broker vmlist =
createVM(brokerId,10); //creating 20 vms cloudletList =
createCloudlet(brokerId,40); // creating 40 cloudlets
broker.submitVmList(vmlist);
broker.submitCloudletList(cloudletList);

Manjot Singh 2220979 D1

 } catch (Exception e) {
e.printStackTrace();
}
return datacenter;
}
//We strongly encourage users to develop their own broker policies, to submit vms and
cloudlets according
//to the specific rules of the simulated scenario
private static DatacenterBroker createBroker(){

DatacenterBroker broker = null;

try {
broker = new DatacenterBroker("Broker");
} catch (Exception e) {
e.printStackTrace();
return null;
}
return broker;
}
/**
* Prints the Cloudlet objects
* @param listlist of Cloudlets
*/
@SuppressWarnings("deprecation")
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 +
indent + "Start Time" + indent + "Finish Time" +indent+"user id"+indent);
"Data center ID" + indent + "VM ID" + indent + indent + "Time" +
DecimalFormat dft = new DecimalFormat("###.##");
for (intcloudlet
i = 0; i <=size; i++) {
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() +
dft.format(cloudlet.getActualCPUTime()) + indent + indent + indent + indent + indent +
dft.format(cloudlet.getExecStartTime())+ indent + indent + indent +
dft.format(cloudlet.getFinishTime())+indent +cloudlet.getUserId());

}
}
}
}

Manjot Singh 2220979 D1

 Experiment- 05

Aim- To study cloud security management.

Cloud security, also known as cloud computing security, consists of a set of policies, controls, procedures and technologies
that work together to protect cloud-based systems, data, and infrastructure. These security measures are configured to
protect cloud data, support regulatory compliance and protect customers' privacy as well as setting authentication rules for
individual users and devices. From authenticating access to filtering traffic, cloud security can be configured to the exact
needs of the business. And because these rules can be configured and managed in one place, administration overheads are
reduced and IT teams empowered to focus on other areas of the business.
Cloud computing offers organizations many benefits, but these benefits are unlikely to be realized if there are not
appropriate IT security and privacy protection strategies in place when using the cloud. When migrating to the cloud,
organizations must have a clear understanding of potential security risks associated with cloud computing, and set realistic
expectations with providers. The following 8 steps will help enterprise IT and business decision makers analyze the
information security and privacy implications of cloud computing and cloud security management on their business.
Following are the Steps to follow:
1. Ensure effective governance and compliance
Most organizations have security, privacy and compliance policies and procedures to protect their IP and assets.In addition
to this, organizations should establish a formal governance framework that outlines chains of responsibility, authority and
communication.This describes the roles and responsibilities of those involved, how they interact and communicate, and
general rules and policies.
2. Audit operation and business processes
It is important to audit the compliance of IT system vendors that host the applications and data in the cloud.There are three
important areas that need to be audited by cloud service customers: internal control environment of a cloud service
provider, access to the corporate audit trail, and the cloud service facility’s security.
3. Manage people, roles, and identities
Using the cloud means there will be employees from the cloud service provider that can access the data and applications, as
well as employees of the organization that perform operations on the providers system. Organizations must ensure that the
provider has processes that govern who has access to customer data and application. The provider must allow the customer
to assign and manage roles and authorization for each of their users. The provide must also have a secure system in place to
managing the unique identifies for users and services.
4. Proper protection of data
Data is the core of all IT security concerns for any organization. Cloud computing does not change this concern but brings
new challenges because of the nature of cloud computing. The security and protection of data both at rest and in transit
needs to be ensured.
5. Enforce privacy policies
Privacy and protection of personal information and data is crucial, especially as many major companies and financial
institutions are suffering data breaches. Privacy of personal information is related to personal data that is held by an
organization, which could be compromised by negligence or bugs. It is critical that privacy requirements be addresses by the
cloud service provider. If not, the organization should consider seeking a different provider or not placing sensitive data in
the cloud.
6. Assess security considerations for cloud applications
Organizations are constantly protecting their business applications from internal and external threats.Application security
poses challenges to both the provider and organization, and depending on the type of cloud deployment model (IaaS, PaaS,
or SaaS), there are different security policy considerations.

Manjot Singh 2220979 D1

7. Cloud networks and connections are secure
Cloud service providers must allow legitimate network traffic and block malicious traffic. Unfortunately, cloud service
providers will not know what network traffic its customer plan to send and receive. Therefore, organizations and providers
must work together to set safety measures, and provide the tools necessary to protect the system.

8. Evaluate security controls and physical infrastructure

The security of an IT system is also based on the security of the physical infrastructure and facility. Organizations must
have assurance from the provider that the appropriate controls are in place. Infrastructure and facilities should be held in
secure areas, and protected against external and environmental threats. For example, physical printers should be locked
down or moved into a controlled access area. Further protect access by using a network print security appliance to require
user authentication for access to the printer to help eliminate security breaches and reduce printing costs. As organizations
migrate their applications and data to the cloud computing, it is critical to maintain the security and privacy protection they
had in their traditional IT environment.

Manjot Singh 2220979 D1