Level 2 Report

11 / 10 / 2026

Task 6: Docker

Docker is a containerization platform that helps package an application along with all its dependencies into a portable container, so it can run consistently across different environments without setup issues. In this task, I first cloned the project repository and navigated to the project directory. I then used Docker Compose to run the application, which automatically handled multiple containers required for the frontend and backend. After successfully running the application on localhost, I modified the backend code to display a new greetings message instead of a static message. Finally, I built a Docker image of the application, tagged it with my Docker Hub repository name, and pushed it to Docker Hub for storage and sharing. This task helped me understand how Docker simplifies application deployment and ensures portability across systems.

Task 9: Hashing

Hashing is a technique used to securely convert passwords into a fixed-length string, ensuring that they are not stored in plain text. In this task, I implemented a simple authentication system using Python. I started by taking user input for username and password, and then used the SHA-256 algorithm from the hashlib library to hash the password before storing it. The hashed passwords were stored in a dictionary, ensuring that the original passwords were never saved directly. During login, the entered password was hashed again and compared with the stored hash to verify the user’s identity. This step ensured that even if the stored data is accessed, the actual passwords remain secure. Through this task, I understood how hashing plays an important role in protecting sensitive information and improving application security. Github link

Task 1 : AWS Lambda

In this task, I deployed an encryption chat application using AWS Lambda. I first created a Lambda function with the Python runtime and then modified my application by converting the existing code into a lambda_function.py file with a lambda_handler function so that it could run on AWS Lambda. After packaging the updated code into a ZIP file, I uploaded it to the Lambda function and created a test event with sample input. I then executed the function and verified that it successfully processed the input message and returned the expected encrypted output, confirming that the application had been successfully deployed in a serverless environment. Function URL

Task 10: Nmap

In this task, I explored Nmap, an open source network discovery and security auditing tool. I installed Nmap on Windows and performed host discovery, port scanning, service detection, and OS detection using various Nmap commands on the official testing host (scanme.nmap.org). The scan results were saved to a text file for further analysis. From the output, I identified the active host, open ports, running services, and operating system information where available. This task helped me understand how Nmap is used to analyze networks, identify exposed services, and perform basic security assessments.

Task 2: CI/CD using Jenkins

In this task, I learned the basics of Continuous Integration and Continuous Delivery (CI/CD) using Jenkins. I installed Jenkins on my system and created a Pipeline project for my Encryption Chat application. I then created a Jenkinsfile containing the Checkout, Build, Test, and Deploy stages and connected the project to my GitHub repository. Jenkins automatically fetched the latest code and executed each stage of the pipeline successfully. This task gave me a practical understanding of how CI/CD pipelines automate the process of building, testing, and deploying applications, making software development more efficient

Task 5: Wireshark

In this task, I learned the basics of Wireshark by capturing and analyzing live network traffic. I applied display filters to examine protocols such as TCP, DNS, and TLS, and used Wireshark's analysis filters to check for retransmissions and duplicate acknowledgments. I also explored the Statistics menu to view the Protocol Hierarchy and communication summaries, which helped me understand the distribution of network traffic. This task provided practical experience in monitoring network communication and identifying security related issues.

Task 4: Terraform

In this task, I learned the basics of Infrastructure as Code (IaC) using Terraform by following the official HashiCorp AWS tutorial. I installed and configured Terraform, authenticated it with my AWS account, and created a Terraform configuration file to provision an EC2 instance in the AWS Cloud. I initialized the project using terraform init, validated the configuration, reviewed the execution plan using terraform plan, and successfully created the infrastructure using terraform apply. I also explored how Terraform can be used to modify existing infrastructure through configuration changes and finally removed the created resources using terraform destroy. This task gave me a practical understanding of how Terraform works with the provisioning and management of cloud infrastructure.

Task 8: Web Scraping and Automation – Flight Price Analysis

In this task, I worked on web scraping and automation using Python and Selenium. I initially considered websites such as Expedia and Kayak, but they had bot detection issues, which made it difficult to automate the process successfully. Therefore I used Google Flights for the task. I automated the process of entering the flight details and selected a flight route from Bengaluru to New Delhi with the required departure and return dates. Selenium was then used to open Google Flights, perform the search, and extract the available flight information. The extracted details were stored in a CSV file for further analysis. Github link

TASK 7: Dockerize

In this task, I worked on containerizing the Resource Library web application using Docker without using a YAML file. I first cloned the project from GitHub and created a Dockerfile for the Node.js and Express application. The Dockerfile specified the Node.js base image, created the working directory, copied the package files, installed the required dependencies, copied the application files, exposed port 3000, and defined the command to start the server. After creating the Dockerfile, I built the application into a Docker image named resource-library and verified that the image was created successfully. I then pulled the MySQL 8.0 image and created a separate database container for the application. To provide persistent storage for the database, I created a Docker volume named resource-db-data and mounted it to the MySQL data directory. Next, I created a custom bridge network named resource-network and connected both the Resource Library application container and the MySQL database container to the same network. I started both containers and used Docker commands to verify that they were running correctly, connected to the same bridge network, and that the database volume was properly configured. This task helped me gain practical experience in containerizing applications and understand how Docker images, containers, networking, volumes, and all are used together when deploying an application.

TASK 3: SSH

In this task, I worked with Secure Shell (SSH) to understand remote server authentication, file discovery, and secure file transfer. I created an isolated local lab using two disposable Ubuntu Docker containers to represent a source server and a destination server. I generated separate SSH authentication keys and configured both servers for key-based SSH authentication. I then connected to the source server through SSH and search its filesystem for supported SSH public and private key formats while excluding virtual filesystems such as /proc, /sys, and /dev. The discovered files were compared against a manifest using their exact paths and SHA-256 hashes so that only the generated lab fixtures could be transferred. The verified files were first transferred securely over SSH to a temporary location and then uploaded to the destination server. After the transfer, I verified the SHA-256 hashes of the source and destination files and checked that the transferred files had the required permissions. The lab successfully discovered and transferred the key files, including files stored in nested directories and paths containing spaces, while excluding an unrelated text file. I also verified that SSH host keys were pinned and that both source and destination servers authenticated successfully using SSH.