Experiment 1

Aim / Objective:
Install VirtualBox / VMware workstation with different flavours of Linux or Windows O.S on Windows 7 or 8.

Theory:
Virtualization allows multiple guest operating systems to run concurrently on a single physical host machine.
This is achieved using a hypervisor (like VirtualBox or VMware) that allocates host hardware resources (CPU,
RAM, storage) to the virtual machines.

Detailed Procedure:
1. Navigate to the official VirtualBox or VMware website using a web browser.
2. Download the installation executable (.exe) compatible with your Windows 7 or 8 host operating system.
3. Run the installer, following the setup wizard instructions, accepting the terms, and completing the
installation on your host machine.
4. Download an ISO image file for your desired guest operating system (e.g., Ubuntu Linux or Windows 10)
from its official source.
5. Open the installed virtualization software and click the "New" button to initiate the Virtual Machine creation
wizard.
6. Assign a name to the VM, specify the OS type and version, and allocate an appropriate amount of RAM
(e.g., 2048 MB).
7. Create a virtual hard disk (VDI/VMDK), choose dynamic allocation, and set the storage size (e.g., 20
GB).
8. Go to the VM "Settings," navigate to the "Storage" section, and mount the downloaded ISO file into the
virtual optical drive.
9. Start the virtual machine and follow the on-screen prompts of the guest OS installer to finalize the OS
installation.
Experiment 2

Aim / Objective:
Install a C compiler in the Virtual box & Execute a simple program.

Theory:
A compiler is software that translates human-readable source code into machine-executable binaries. In Linux
environments, the standard C compiler used is GCC (GNU Compiler Collection).

Detailed Procedure:
1. Power on the Linux Virtual Machine created in Experiment 1 and log in to your user account.
2. Open the command-line terminal by searching for it in the applications menu or pressing Ctrl + Alt + T.
3. Update the package manager's lists by executing the command sudo apt update to ensure you get the
latest software versions.
4. Install the GNU C Compiler (GCC) by typing sudo apt install build-essential or sudo apt install gcc and
pressing Enter.
5. Confirm the installation when prompted by typing 'Y' and wait for the packages to download and install.
6. Verify the compiler is installed correctly by checking its version with the command gcc --version.
7. Open a text editor (like nano or gedit) by typing nano hello.c to create a new C source code file.
8. Write a basic C program that prints "Hello World", save the file (Ctrl + O), and exit the editor (Ctrl + X).
9. Compile the source code by executing gcc hello.c -o hello, and then run it by typing ./hello to see the
output.
Experiment 3

Aim / Objective:
Install a google app engine, create hello world app & other simple web by using Python.

Theory:
Google App Engine (GAE) is a Platform-as-a-Service (PaaS) offering that lets developers build and host
applications without managing the underlying server infrastructure.

Detailed Procedure:
1. Download the Google Cloud SDK installer compatible with your operating system from the official Google
Cloud website.
2. Run the installer and complete the setup, ensuring Python (version 3.7 or higher) is installed on your
system.
3. Open your terminal or command prompt and run gcloud init to authenticate with your Google Cloud
account and set up a new project.
4. Create a new directory on your local machine named gae_hello_world and navigate into it using the
terminal.
5. Create a Python file named [Link] and write a simple web application script using a framework like
Flask.
6. Create a [Link] file listing the dependencies (e.g., Flask==2.0.1) required by your Python
application.
7. Create a configuration file named [Link] and specify the Python runtime environment (e.g., runtime:
python39).
8. Test the application locally using a local development server to ensure there are no syntax errors.
9. Deploy the application to Google App Engine by running the command gcloud app deploy and
confirming the prompt.
10. View the application by running gcloud app browse to open your live web application in a browser.
Experiment 4

Aim / Objective:
Find procedure to transfer the file from one Virtual Machine to another Virtual Machine.

Theory:
Data can be securely transferred between virtual machines over a network using the Secure Copy Protocol
(SCP), which relies on SSH for secure data transfer.

Detailed Procedure:
1. Open your hypervisor (VirtualBox/VMware) and ensure you have two distinct Virtual Machines (Source
and Destination) installed.
2. Configure the network settings of both VMs to use a "Bridged Adapter" or "Internal Network" so they
share a local IP subnet.
3. Boot up both the Source VM and the Destination VM and log into their respective user accounts.
4. Find the Destination IP: On the Destination VM, open the terminal and execute ip a or ifconfig to note its
IP address.
5. Install SSH: Also on the Destination VM, ensure the SSH server is installed and running (e.g., sudo apt
install openssh-server).
6. Create a test file: Switch to the Source VM, open its terminal, and create a sample text file to transfer
(e.g., echo "Test data" > [Link]).
7. Initiate SCP Transfer: Use the Secure Copy Protocol command syntax: scp [Link]
username@<Destination-IP-Address>:/path/to/destination/.
8. Authenticate: Accept the SSH key fingerprint if prompted (type 'yes') and enter the password for the
Destination VM's user account.
9. Verify the transfer by checking the specified destination directory on the Destination VM to ensure the file
arrived intact.
Experiment 5

Aim / Objective:
Create a EC2 instances in AWS & launch it.

Theory:
Amazon Elastic Compute Cloud (EC2) provides scalable computing capacity in the cloud, allowing users to rent
virtual computers (instances) to run their own applications.

Detailed Procedure:
1. Log in to the AWS Management Console using a web browser and your AWS credentials.
2. Navigate to EC2: Use the search bar at the top to locate the "EC2" service and click on it to open the EC2
Dashboard.
3. Start the Wizard: Locate and click the highly visible orange "Launch Instance" button to start the creation
wizard.
4. Name the Instance: Provide a descriptive name for your instance in the "Name and tags" section (e.g.,
"MyTestServer").
5. Choose an AMI: In the "Application and OS Images" section, select a Free Tier eligible OS, such as
Amazon Linux 2023 or Ubuntu.
6. Select Instance Type: Leave the instance type set to [Link] to ensure it remains within the AWS Free
Tier limits.
7. Generate a Key Pair: In the "Key pair (login)" section, click "Create new key pair", give it a name,
download the .pem file, and store it securely.
8. Configure Network: Under "Network settings", ensure "Auto-assign public IP" is enabled and configure a
Security Group to allow SSH traffic from anywhere.
9. Launch: Review your configuration summary on the right side of the screen and click the "Launch
instance" button.
10. Verify: Click "View all instances" and wait for the "Instance state" to transition from "Pending" to
"Running".
Experiment 6

Aim / Objective:
Create a S3 bucket in AWS & Post file into it.

Theory:
Amazon Simple Storage Service (S3) is an object storage service designed to store and protect any amount of
data. Data is stored as "objects" within "buckets".

Detailed Procedure:
1. Navigate to S3: Sign in to the AWS Management Console and navigate to the "S3" service via the search
bar.
2. Start Bucket Creation: On the S3 Dashboard, locate and click the "Create bucket" button.
3. Name the Bucket: Enter a globally unique name for your bucket in the "Bucket name" field, ensuring it
contains no uppercase letters or spaces.
4. Select a Region: Select the AWS Region that is geographically closest to you from the dropdown menu.
5. Configure Security: Leave the "Block Public Access settings for this bucket" enabled to ensure your
uploaded files are secure from public view.
6. Create: Scroll to the bottom of the configuration page, leaving advanced settings as default, and click the
"Create bucket" button.
7. Open Bucket: From the list of buckets, click on the newly created bucket's name to open its management
interface.
8. Prepare Upload: Click the "Upload" button, then click "Add files" to browse your local computer's file
system.
9. Select File: Select a file (e.g., an image or text document) and click "Open" to queue it for upload.
10. Post File: Click the "Upload" button at the bottom of the page and wait for the green success banner
indicating the file was posted successfully.
Experiment 7

Aim / Objective:
Launch a Simple application like 'Hello world' on AWS.

Theory:
AWS Elastic Beanstalk is a service for deploying and scaling web applications developed with standard
programming languages, automatically handling the deployment details like capacity provisioning and load
balancing.

Detailed Procedure:
1. Prepare the Code: Create a project directory on your local computer containing your simple application
code (e.g., an [Link] file).
2. Archive the Code: Compress the contents of this directory into a standard .zip archive file.
3. Navigate to Elastic Beanstalk: Log in to the AWS Management Console and search for the "Elastic
Beanstalk" service.
4. Create Application: On the Elastic Beanstalk dashboard, click on "Create Application" to begin the
deployment process.
5. Select Environment: Choose "Web server environment" as the environment tier.
6. Name Application: Enter an application name (e.g., "HelloWorldApp") in the provided field.
7. Select Platform: Under the Platform section, select the appropriate runtime for your code (e.g., "[Link]"
or "PHP").
8. Upload: In the Application Code section, select the option to "Upload your code".
9. Provide Archive: Provide a Version Label, click "Choose file", and upload the .zip archive you created in
step 2.
10. Launch Application: Click the "Create application" button and wait a few minutes for AWS to provision
the infrastructure.
11. View Live App: Once the environment health reads "Ok", click the provided domain URL at the top to
view your live application.
Experiment 8

Aim / Objective:
Use GAE launcher to launch the web application.

Theory:
The Google App Engine Launcher is a graphical interface (historically part of the Python App Engine SDK) that
allows developers to run and test their cloud applications on a local development server before deploying them
to Google's infrastructure.

Detailed Procedure:
1. Download the Software: Download the legacy Google App Engine SDK for Python, which contains the
standalone GAE Launcher GUI application.
2. Install the Software: Install the SDK on your local machine following the standard installation wizard for
your operating system.
3. Launch the Application: Launch the "Google AppEngine Launcher" application from your desktop or
start menu.
4. Prepare the Project: Ensure you have a local Google App Engine project folder containing a valid
[Link] configuration file and a main application script.
5. Add Application: In the GAE Launcher interface, click on the "File" menu at the top left and choose "Add
Existing Application".
6. Browse Files: Use the file browser to locate and select the directory containing your prepared application
files, then click "OK".
7. Select the App: Highlight your newly added application in the launcher's main list to select it.
8. Start the Server: Click the green "Run" button on the toolbar to start the local development server.
9. Check Status: Observe the status icon next to the application; wait for it to turn into a green circle,
indicating the server is running successfully.
10. Browse the App: Click the "Browse" button on the toolbar, which will automatically open your default
web browser to view the running app (usually at [Link]
Experiment 9

Aim / Objective:
Create EBS Volume attach it to EC2 instance Mount in linux.

Theory:
Amazon Elastic Block Store (EBS) provides raw block-level storage volumes. To use an EBS volume, it must be
attached to an instance, formatted with a file system, and mounted into the instance's directory tree.

Detailed Procedure:
1. Verify AZ: Log in to the AWS Console, navigate to the EC2 Dashboard, and note the exact Availability
Zone of your running Linux EC2 instance.
2. Navigate to Volumes: On the left-hand menu under "Elastic Block Store", click on "Volumes".
3. Create Volume: Click the "Create volume" button, select a volume type (e.g., gp2), and set a size (e.g., 1
GiB).
4. Match AZ: Crucially, select the exact same Availability Zone as your running EC2 instance, then click
"Create volume".
5. Attach Volume: Once the new volume's state is "Available", select it, click the "Actions" dropdown, and
choose "Attach volume".
6. Select Instance: Select your running Linux instance from the dropdown menu, note the device name
(e.g., /dev/sdf), and click "Attach volume".
7. Connect: Connect to your EC2 instance using SSH via your terminal.
8. Verify Device: Run the command lsblk to verify that the new block device is visible to the Linux operating
system.
9. Format Volume: Format the raw volume with an ext4 file system by running sudo mkfs -t ext4 /dev/xvdf
(adjusting the device name based on lsblk output).
10. Create Mount Point: Create a directory to serve as the mount point by running sudo mkdir
/mnt/newvolume.
11. Mount Volume: Mount the volume to the directory using sudo mount /dev/xvdf /mnt/newvolume, and
verify it by typing df -h.
Experiment 10

Aim / Objective:
To Simulate a cloud scenario using Cloud Sim & run a scheduling algorithm that is not present in Cloud Sim.

Theory:
CloudSim is an extensible simulation framework that allows modeling of cloud computing environments. Custom
resource allocation algorithms can be implemented by overriding default broker classes.

Detailed Procedure:
1. Download CloudSim: Download the CloudSim toolkit archive from its official repository and extract it to a
folder on your local computer.
2. Install IDE: Install a Java Integrated Development Environment (IDE) such as Eclipse or IntelliJ IDEA.
3. Import Project: Open your IDE, create a new Java Project, and configure it to import the extracted
CloudSim source code and libraries.
4. Extend Broker: Create a new Java class (e.g., CustomSchedulerBroker) that extends the default
DatacenterBroker class provided by CloudSim.
5. Implement Logic: Override the bindCloudletsToVms() method in your new class to implement a custom
scheduling logic, such as "Shortest Job First" (sorting tasks by length before assignment).
6. Initialize Simulation: Create a main simulation Java file where you initialize the CloudSim core using
[Link]().
7. Create Datacenter: Programmatically create the necessary cloud infrastructure components: a
Datacenter, Host machines, and Virtual Machines (VMs).
8. Instantiate Broker: Instantiate your custom broker class (CustomSchedulerBroker) instead of the default
broker.
9. Submit Tasks: Create a list of Cloudlets (tasks) with varying lengths and submit both the VMs and
Cloudlets to your custom broker.
10. Run Simulation: Call [Link](), then print the execution results to the console to
analyze how your custom algorithm executed the tasks.