ADITYA SINGH

22BEY10046

AWS Cloud Practitioner (CSE3015)

Lab Manual

Submitted to

Mr. Nilesh Kunhare

Slot- B14

21 April,2025
AWS Cloud Computing Lab Manual

Experiment 1: Launching an EC2 Instance

Aim:​
To launch an EC2 instance using AWS Management Console with appropriate configurations
and connect to it using SSH.

Requirements:

●​ AWS account access​

●​ Key pair for SSH​

●​ Basic knowledge of Linux commands​

Theory:​
Amazon EC2 (Elastic Compute Cloud) is a scalable computing service that allows users to
launch virtual servers on-demand. It provides full control of the instances, operating system, and
installed software.

Procedure:

1.​ Log in to AWS Management Console and go to EC2.​

2.​ Click on Launch Instance.​

3.​ Choose an Amazon Machine Image (AMI), such as Amazon Linux 2.​

4.​ Select an instance type (e.g., t2.micro for free tier).​

5.​ Configure instance details like number of instances and VPC settings.​

6.​ Add storage and tags.​

7.​ Configure security group to allow SSH (port 22).​

8.​ Select or create a new key pair.​

9.​ Launch the instance.​

Result:​
An EC2 instance was launched and accessed using SSH.

Observation:​
EC2 allows scalable cloud infrastructure deployment within minutes.
Experiment 2: Working with Amazon S3 Buckets

Aim:​
To create an S3 bucket, configure policies, upload/download objects, and enable versioning
and encryption.

Requirements:

●​ AWS Console access​

Theory:​
Amazon S3 (Simple Storage Service) offers secure, durable, and scalable object storage. It
allows storing and retrieving any amount of data.

Procedure:

1.​ Navigate to the S3 service.​

2.​ Click Create Bucket, provide a name and region.​

3.​ Enable versioning and default encryption (SSE-S3 or SSE-KMS).​

4.​ Create bucket policies and set access permissions.​

5.​ Upload files to the bucket.​

6.​ Download files and observe versioning if enabled.​

Result:​
S3 bucket was successfully configured and tested for object operations.

Observation:​
S3 enables reliable and scalable data storage with robust security.
Experiment 3: Creating an AWS Lambda Function

Aim:​
To create a Lambda function in Python or Node.js, configure an event trigger, and test it.

Requirements:

●​ AWS Console access​

Theory:​
AWS Lambda allows running code without provisioning or managing servers. It supports
multiple languages and triggers from events like S3, API Gateway, etc.

Procedure:

1.​ Go to the Lambda service.​

2.​ Click Create Function and choose Author from scratch.​

3.​ Choose runtime (Python or Node.js).​

4.​ Write or paste the code in the inline editor.​

5.​ Add trigger (e.g., S3 PUT object).​

6.​ Deploy the function.​

7.​ Test using the Test button or triggering event.​

Result:​
Lambda function was successfully executed with event triggers.

Observation:​
Lambda allows event-driven, serverless computing at scale.
Experiment 4: Hosting a Static Website Using S3 and Route 53

Aim:​
To register a domain in Route 53 and host a static website using Amazon S3.

Requirements:

●​ HTML, CSS, JS files​

●​ AWS account with Route 53 access​

Theory:​
Amazon Route 53 is a scalable DNS service. Combined with S3, it can be used to host static
websites globally.

Procedure:

1.​ Register a domain using Route 53.​

2.​ Create an S3 bucket with the domain name.​

3.​ Upload website files to the bucket.​

4.​ Enable static website hosting in bucket properties.​

5.​ Update bucket policy for public read access.​

6.​ Create a hosted zone in Route 53.​

7.​ Add A-record pointing to the S3 website endpoint.​

Result:​
Static website was hosted and made accessible using Route 53 DNS.

Observation:​
Combining S3 with Route 53 provides a low-cost, scalable hosting solution.
Experiment 5: Configuring a Virtual Private Cloud (VPC)

Aim:​
To configure a Virtual Private Cloud (VPC) with subnets, route tables, gateways, and security
groups.

Requirements:

●​ AWS Console access​

Theory:​
VPC lets users provision a logically isolated section of the AWS cloud where resources can be
launched in a virtual network defined by the user.

Procedure:

1.​ Go to VPC Dashboard > Create VPC.​

2.​ Create subnets in different availability zones.​

3.​ Create and attach an internet gateway.​

4.​ Create custom route tables.​

5.​ Associate route tables with subnets.​

6.​ Create a NAT gateway for private subnet access.​

7.​ Launch instances in subnets to test.​

Result:​
VPC was configured with internet and NAT gateways, and tested for connectivity.

Observation:​
VPC enables secure and scalable network architecture on AWS.
Experiment 6: RESTful API Using API Gateway and Lambda

Aim:​
To create a RESTful API using Amazon API Gateway integrated with AWS Lambda.

Requirements:

●​ Lambda function ready​

Theory:​
Amazon API Gateway provides APIs for accessing AWS or backend services. When integrated
with Lambda, it provides a fully serverless API.

Procedure:

1.​ Go to API Gateway > Create API > HTTP or REST.​

2.​ Define resource and methods (e.g., GET, POST).​

3.​ Integrate with an existing Lambda function.​

4.​ Deploy the API to a stage.​

5.​ Test using the endpoint URL.​

Result:​
API was created and successfully invoked Lambda functions.

Observation:​
API Gateway simplifies the creation of secure, scalable APIs.
Experiment 7: Creating an RDS Database Instance

Aim:​
To create an Amazon RDS instance, connect it using a database client, and perform basic SQL
operations.

Requirements:

●​ AWS account with RDS access​

●​ Database client (e.g., MySQL Workbench)​

Theory:​
Amazon RDS simplifies the setup and operation of relational databases in the cloud. It
automates backups, patching, and scaling.

Procedure:

1.​ Go to RDS > Create Database > Standard Create.​

2.​ Choose MySQL and Free Tier.​

3.​ Configure DB instance identifier, username, and password.​

4.​ Make it publicly accessible and open port 3306.​

5.​ Launch the instance and copy the endpoint.​

6.​ Connect using a client and run SQL commands.​

Result:​
Database was created and queries were executed.

Observation:​
RDS enables secure, scalable cloud database hosting.

Experiment 8: Managing IAM Users, Groups, Roles, and Policies

Requirements:

●​ AWS admin access​

Theory:​
IAM controls access to AWS services using policies. It ensures secure and managed user and
role access.

Procedure:

1.​ Go to IAM > Users > Add User.​

2.​ Set access type and assign user to group.​

3.​ Attach policies like S3ReadOnlyAccess.​

4.​ Create roles for EC2 or Lambda.​

5.​ Apply role to running instances.​

Result:​
IAM identities and permissions were created.

Observation:​
IAM ensures best-practice access control and security.

Experiment 9: Creating and Managing AMIs and EBS Snapshots

Aim:​
To create AMIs and EBS snapshots and attach EBS volumes to EC2.

Requirements:
 ●​ EC2 instance running​

Theory:​
AMIs and snapshots help with backup, migration, and disaster recovery.

Procedure:

1.​ From EC2, create image of running instance.​

2.​ Create EBS snapshot of a volume.​

3.​ Create a new volume from snapshot.​

4.​ Attach volume to an EC2 instance.​

5.​ SSH into the instance and mount the volume.​

Result:​
AMI and snapshots were created and attached.

Observation:​
These tools aid in efficient backup and recovery.

Experiment 10: Monitoring with CloudWatch

Aim:​
To create CloudWatch alarms and dashboards for EC2 and RDS monitoring.

Requirements:

●​ AWS CloudWatch access​

Theory:​
CloudWatch provides observability for AWS resources. Alarms and dashboards provide metrics
and alerting.
Procedure:

1.​ Go to CloudWatch > Dashboards > Create Dashboard.​

2.​ Add widgets (e.g., CPU utilization graphs).​

3.​ Go to Alarms > Create Alarm.​

4.​ Select EC2 metrics, define thresholds.​

5.​ Add notification actions.​

Result:​
Dashboard created and alarms configured.

Observation:​
CloudWatch ensures proactive monitoring of AWS workloads.