7 / 10 / 2026

LEVEL 2 -FINAL REPORT

TASK 1: Working of a Version Control

In this task, I first created a Git repository using the git init command. After initializing the repository, I added my details and then added the index.html file to the repository using the git add command. I committed the changes using the git commit command.

To check the current status of the repository, I used the git status command. To view the commit history, I used the git log command. I checked all the available branches using the git branch command.

I created a new branch and switched to it using the git checkout -b branch_name command. Using this method, I created a developer branch from the main branch. Inside the developer branch, I created two more branches named feature1 and feature2.

I made changes to the index.html file in the feature1 branch and committed those changes. Similarly, I made changes to the index.html file in the feature2 branch and committed them as well.

I then used the git revert command to undo a specific commit in the feature1 branch. During this process, a merge conflict occurred, which I resolved using the merge conflict resolution editor. The git revert command created a new commit as its output.

After that, I added a specific commit from the feature1 branch to the developer branch using the git cherry-pick command. Finally, I merged the feature2 and developer branches using the git merge command.

TASK 2 : Database task -DynamoDB

In this task, I used Amazon DynamoDB to implement a login and signup system. First, I logged in to the AWS Management Console and created a DynamoDB table to store user details. The table was designed with a primary key to uniquely identify each user, such as a username or email ID. I configured the required capacity settings and successfully created the table.

After creating the table, I developed login and signup functionality and connected it to DynamoDB using the Boto3 library in Python. I configured AWS credentials and used Boto3 to establish a connection between the application and the DynamoDB table. During the signup process, new user details were inserted into the table using DynamoDB’s Put Item operation. Before inserting the data, validation was performed to ensure that duplicate user entries were not created.

For the login functionality, I retrieved user data from DynamoDB using Boto3 and verified the entered credentials against the stored records. Based on the verification result, access was either granted or denied. I also used Get Item and Query operations to efficiently fetch user information from the table.

I tested the application by performing multiple signup and login operations to ensure data consistency and correct authentication behavior. Finally, I verified that all DynamoDB operations were functioning correctly and confirmed successful integration between the frontend pages and the backend DynamoDB database using the Boto3 library.

TASK 3 : Create an application on EC2 instance

instance from the AWS Management Console and selected Amazon Linux as the operating system. I configured the instance type, key pair, and security group settings. In the security group, I allowed inbound traffic on ports 80 (HTTP), 443 (HTTPS), and 5000 to enable web and application access.

After successfully launching the instance, I connected to it using the Amazon Linux CLI. I updated the system packages and installed the required software, including Python3, Git, pip, and httpd (Apache web server). These tools were necessary to run and manage the web application on the EC2 instance.

Once the environment was set up, I cloned the website source code from my Git repository into the EC2 instance using the git clone command. I configured the web server and application dependencies as required and ensured that the application was running correctly on the server.

Finally, I tested the deployment by accessing the application through the EC2 instance’s public IP address and verified that the website was accessible through the allowed ports. This task helped me understand EC2 instance setup, package installation using the Linux CLI, security group configuration, and deploying a web application on the cloud.

TASK 4 : AWS CLoudFront -Serve content from multiple s3 buckets

in this task, I configured AWS CloudFront to deliver content from multiple Amazon S3 buckets. I first created separate S3 buckets to store static website files and configured the required access permissions for each bucket.

Next, I created a CloudFront distribution and added multiple S3 buckets as origins. One bucket was set as the default origin, and additional buckets were mapped using cache behaviors with specific path patterns to route requests accordingly. I also configured the default root object and enabled both HTTP and HTTPS access.

After completing the configuration, I deployed the CloudFront distribution and waited for global propagation. Finally, I tested the CloudFront domain URL to confirm that content was being successfully served from different S3 buckets. This task helped me understand multi-origin content delivery using CloudFront.

TASK 5 : OSI

In this task, I studied the Open Systems Interconnection (OSI) model, which explains how data is transmitted between computer systems over a network using seven distinct layers. To understand the OSI architecture visually, I researched and created a simple diagram of the OSI model using a cloud-based diagramming tool such as Draw.io. This visual representation helped in understanding the flow of data from the sender to the receiver across different layers.

I learned about the role of protocols, switching, routing, handshakes, and IP addressing within the OSI model. Each layer has a specific responsibility, and together they ensure reliable and secure communication across networks, including cloud environments.

The Application Layer provides network services directly to end-user applications such as web browsers and email clients, and in cloud computing it enables access to cloud services like web apps and APIs. The Presentation Layer handles data formatting, encryption, and compression, ensuring secure data transmission in cloud services. The Session Layer manages session establishment, maintenance, and termination, which is important for maintaining continuous communication between cloud clients and servers. The Transport Layer is responsible for reliable data delivery using protocols like TCP and UDP, playing a key role in cloud-based application performance and handshakes. The Network Layer handles routing and logical addressing using IP addresses, which is essential for directing data across cloud networks and regions. The Data Link Layer manages switching, MAC addressing, and error detection, enabling efficient data transfer within local and virtual cloud networks. The Physical Layer deals with the actual transmission of data through physical media, which in cloud computing is managed by the cloud service provider’s data center infrastructure.

TASK 6 : IaaS, PaaS and SaaS

In this task, I learned about the three main types of cloud computing service models: Infrastructure as a Service (IaaS), Platform as a Service (PaaS), and Software as a Service (SaaS). These service models differ based on the level of control and responsibility shared between the cloud service provider and the user.

IaaS provides virtualized computing resources such as servers, storage, and networking over the internet. In this model, users are responsible for managing the operating system, applications, and data, while the cloud provider manages the physical infrastructure. PaaS offers a platform that allows developers to build, test, and deploy applications without worrying about underlying infrastructure. The cloud provider manages servers, storage, and runtime environments, enabling faster application development. SaaS delivers fully functional software applications over the internet. Users can access these applications through a web browser without managing infrastructure or platforms, as everything is handled by the service provider.

This task helped me understand how different cloud service models are used based on application requirements, scalability, and management responsibilities.

TASK 7 :Encryption Techniques - Secure Messaging App

In this task, I studied and implemented various encryption and decryption techniques using Python to understand the basics of secure communication. I used the PyCrypto library to develop programs that demonstrate different types of ciphers, including the Caesar cipher, Vigenère cipher, and substitution cipher. These ciphers helped in understanding how plaintext is transformed into ciphertext using keys.

I also learned how these classical encryption techniques differ from modern cryptographic algorithms such as SHA-256. Unlike Caesar or Vigenère ciphers, SHA-256 is a hashing algorithm and is a one-way function that cannot be decrypted, making it suitable for data integrity and password storage rather than message encryption.

Additionally, I studied symmetric and asymmetric encryption. In symmetric encryption, the same secret key is used for both encryption and decryption, whereas asymmetric encryption uses a pair of keys, namely a public key and a private key. I learned how prime numbers play a crucial role in RSA encryption, where large prime numbers are used to generate secure public and private keys.

Finally, I implemented a simple secure chat application in which messages are encrypted before being sent and decrypted upon receipt. This task helped me understand the importance of encryption in secure messaging and the practical application of cryptographic concepts in real-world systems.

TASK 8 :Penitration testing using kali linux

This penetration testing experiment was performed in a controlled lab environment using Kali Linux as the attacker machine and Ubuntu as the target virtual machine. Both systems were connected through a host-only network to ensure safe testing. The IP address of the Ubuntu machine was identified and connectivity was verified using the ping command. Network reconnaissance was conducted using Nmap to identify open ports and running services. The scan revealed that ports such as 22 (SSH) and 80 (HTTP) were open, indicating active services on the target system.

Further analysis showed that the Apache web server was running with default settings. A basic password strength test was demonstrated using Hydra on a test account to understand the risk of weak passwords. Packet analysis also helped in understanding the TCP three-way handshake process. The test concluded that open services and lack of firewall configuration can pose security risks. It is recommended to enable a firewall, use strong passwords, and disable unnecessary services to improve system security. This experiment helped in understanding basic penetration testing techniques and vulnerability assessment in a virtual lab setup.

TASK 9 :Webscrapping using beautifulsoup library

This task was performed to understand the basics of web scraping using the BeautifulSoup (bs4) library in Python. The objective was to extract specific information from a local HTML file named index.html. The file was opened in read mode, and its content was parsed using BeautifulSoup with the lxml parser. The program searched for all div elements with the class name card, which represent item containers on the webpage.

For each card element, the item name was extracted from the h tag, and the item cost was obtained from the p tag by splitting the text and selecting the last word. The extracted details were then printed in a formatted output showing the item name and its cost. This task demonstrates how HTML content can be parsed and structured data can be extracted using Python. It also highlights the importance of understanding HTML tags, class attributes, and text processing while performing web scraping.

TASK 10:Socket IO

This task involves setting up a basic real-time chat application using Node.js and Socket.IO on a Linux system. The main objective is to enable multiple users to connect to a server and exchange messages instantly through a web interface. Node.js is used as the backend runtime environment because it is event-driven and efficient in handling multiple client connections. Express.js is used to create the web server, and Socket.IO is integrated to establish real-time, bidirectional communication between the server and connected clients using WebSocket technology.

The server runs on a specified port (such as port 3000) and serves a simple HTML page to users. When a user opens the application in a browser, a connection is established between the client and server through the TCP/IP protocol. Unlike traditional HTTP commun