Level 3 - R Rohan Shalom

29 / 8 / 2026

R Rohan Shalom - Level 2 Report

TASK 1: AWS Lambda

The aim of this task was to design and deploy a real-time chat application using AWS Lambda and API Gateway WebSockets, with a simple frontend.

What I Learned

AWS Lambda is a serverless compute service that allows us to run code without managing servers.
It automatically handles scaling, availability, and execution.
We only need to write the function logic, and Lambda executes it when triggered by events such as:

• API Gateway requests
• DynamoDB changes
• S3 uploads

Steps to Build the Chat Application

1. Create a WebSocket API Gateway using AWS and configure it with a Lambda function.

2. Define Routes in the API Gateway:

   • Predefined Routes:
     • $connect
     • $disconnect
     • $default
   • Custom Routes:
     • setName
     • sendPublic
     • sendPrivate

3. Choose Integration Type as Lambda, select the required function, review, and create.

4. Write the Lambda Function to handle API events and trigger endpoints, then save the file.

   

5. Create a Chat Frontend App and connect it to the WebSocket URL generated from API Gateway.
   This enables sending and receiving real-time messages through the UI using WebSockets.

Testing and Deployment

• Check WebSocket functionality in the command terminal:

  

• Build a User Interface for the chat application:

  

• 🔗 Hosted App: RohChat

• 💻 GitHub Repo: RohChat-Repo

TASK 2: Docker

Docker is a tool that lets you package your application along with everything it needs (like libraries, dependencies, configs) into a container so it can run the same way on any computer.

You can think of Docker as a universal passport for applications. Normally, if you travel to different countries, you need different visas and approvals to enter. But with a universal passport, you can move anywhere without worrying about compatibility issues.

In the same way, without Docker, an app might work on one machine but fail on another because of missing software, version mismatches, or system differences. Docker gives the app its own "passport", a container with everything it needs, so it can run smoothly anywhere, whether it’s on your laptop, a server, or the cloud.

In this task:

1. Created a simple express server

2. Create and define a Dockerfile in the same working directory:

   • Base Image: Ubuntu 20.04
   • Install Node.js: Update Ubuntu, install curl, then Node.js 16 & npm
   • Working Directory: /app inside container
   • Copy Packages: package.json and package-lock.json (for caching)
   • Install Dependencies: npm install
   • Copy App Code: Add all application files
   • Expose Port: 3000
   • Run App: node server.js

3. Build Docker Image:
   Run in shell:

   docker build -t image_name .
   

1. Run Docker Image: Run in shell:

   docker run image_name
   

   

To Publish Docker Images to DockerHub:

1. Build an Image

2. Login and Create a repository in DockerHub

3. Push to DockerHub:

   docker tag my-simple-image repo-name:latest
   docker push repo-name:latest
   

   

4. Pull from DockerHub and run the image:

   docker pull repo-name:latest
   docker run -it repo-name
   

   

   

GitHub: Repo

TASK 3: Hashing

What is Hashing?

Hashing is like giving data a unique fingerprint.
A hash function turns input (e.g., a password) into a fixed-size random-looking string.

• Example: hello → 2cf24dba5fb0a...
• Same input → same hash.

Why Use Hashing?

• Passwords aren’t stored directly — only hashes.
• Even if hackers get the database, they don’t see real passwords.

Key Features

1. One-way – Can’t reverse a hash.
2. Consistent – Same input → same output.
3. Unique – Small input changes → very different hashes.

Example

• Password: mypassword
• Hash: 34819d7beeabb9260a5c854bc85b3e44
  Stored hash is checked against the entered password’s hash.

Salting

Extra random data added to a password before hashing.

• Prevents use of pre-built hash tables (rainbow tables).

Common Hash Functions

• MD5, SHA-1 → Weak, avoid.
• SHA-256, SHA-512 → Secure & common.
• bcrypt, scrypt, Argon2 → Strong, best for passwords.

In this task

I developed a complete authentication system where user passwords are securely hashed before being stored in the database.
The system includes a simple API that handles registration and login operations, along with a basic frontend for interaction.
I connected the application to MongoDB Compass (local) to manage and visualize the stored data.

Authentication Interface:

Hashed passwords stored in database:

Github - Code

TASK 4: Dockerize (without using yaml file)

Imagine you’re running an application where the backend and the database live in separate containers. For the app to function smoothly, these containers must communicate seamlessly and also retain data even after restarts. That’s exactly where Docker networks and volumes come into play — networks ensure containers stay connected and exchange data efficiently, while volumes preserve crucial information across container lifecycles. Together, they form the backbone of a well-coordinated, persistent Dockerized environment.

Docker Network: A Docker network is a virtual bridge that connects containers, allowing them to communicate and share data securely. It’s similar to how devices on the same Wi-Fi can interact with each other while staying isolated from outside networks.

Docker Volume: A Docker volume is a dedicated storage space for containers that keeps data safe even if the container is deleted or restarted.

In this task:

1. I created a simple Express app to serve as my backend, handling user registration and login functionality.

1. I wrote a Dockerfile for the backend and built a Docker image, ensuring the app could run in an isolated container anywhere.

1. I set up a MongoDB container with a Docker volume attached to persist the database data even if the container stops or is removed.

1. I created a Docker network and connected both the backend and MongoDB containers to it, allowing the backend to access the database using the container name as the hostname.

1. I ran both containers, ensuring the backend could communicate with MongoDB through the network, and now the app is fully functional with persistent data and containerized networking.

Outcome - I containerized my backend and database, ensured data persistence with volumes, and enabled smooth communication between them via a Docker network.

TASK 5: NMap

Think of Nmap (which stands for Network Mapper) as a Detective for your computer network. Its main job is to send out probes (like little pings or knocking on doors) to see what is connected to a network and what services those connected devices are offering.

The 3 main functions of NMap:

1. Host Discovery
2. Port Scanning
3. Service and OS detection

Analogy: A network can be thought of as a city, where each house represents a device and the rooms inside are its ports. Nmap is used to determine which houses are occupied (host discovery), which doors are open (port scanning), and what services are running in each room (service detection). Locked doors indicate closed ports, and guarded entrances represent firewalls. Scanning should only be performed on networks that are owned or authorized to ensure safety and legality.

Some useful NMap commands are:

#Host discovery
nmap -sn 192.168.1.0/24  

#Full TCP Port sweep
nmap -p- 

#OS detection
sudo nmap -O 

#Agressive all in one scan
sudo nmap -A 

#Specific ports
nmap -p 22,80,443 
# or a range
nmap -p 1-1024 

#Save XML and convert to HTML
sudo nmap -A -oX scan.xml 
xsltproc /usr/share/nmap/nmap.xsl scan.xml -o scan.html

Command I used:

nmap -A -oX scan_results.xml 192.168.1.0/24

Output:

Simple port scanning (Skips host discovery):

XML output:

Working:

1. Host discovery

• Send simple probes (ping/ARP/TCP) to see which devices respond — those are "up."

1. Port scanning

• Probe ports to find which are open, closed, or filtered (different probes give different accuracy).

1. Service & OS detection

• Ask open ports what they are (banners) to ID services/versions; analyze packet behavior to guess the OS.

TASK 6: Wireshark

Wireshark is like a super-powered network microscope. It watches the traffic moving through your network and records each piece of data, called a packet.

Each packet has information about:

1. Who sent it (source IP/MAC)
2. Who is receiving it (destination IP/MAC)
3. What kind of data it is (protocol like TCP, UDP, HTTP)
4. The content (payload)

Wireshark captures these packets in real-time, lets you filter and inspect them, and shows protocol details in layers (like peeling an onion).

Some filters I tried:

1. http
2. tcp.port == 80 || tcp.port == 443
3. tcp.analysis.retransmission
4. tcp.analysis.duplicate_ack
5. tcp.flags.reset == 1
6. tcp.analysis.retransmission || tcp.analysis.duplicate_ack

A simple packet capture in the Wi-Fi network:

A graph displaying the rate of packets received in port 443 persec.:

Encrypted data in tcp packets:

Since HTTP traffic is unencrypted, the data is transmitted in plain text. As a result, the HTML content is directly visible in the captured HTTP packets.

Wireshark is the network's "digital microscope," providing total visibility into data traffic. By capturing packets, it allows you to diagnose latency, pinpoint packet loss, and detect security threats like port scanning

TASK 7: Jenkins

Jenkins works like a factory supervisor that automates work. When you submit raw materials (code), Jenkins collects them from GitHub. It follows written instructions (pipeline) to build, test, and package the product. The actual work is done by workers (build agents). Finally, the finished product (application) is delivered and ready to use.

In this task, I installed and configured Jenkins, created a Freestyle project to understand how Jenkins works, developed a simple Express application, wrote a Dockerfile to containerize the application, and created a Jenkins pipeline to automate and run the application.

Freestyle Project:

Scripted and built the pipeline:

Successful execution of the pipeline:

Result:

This task helped me understand how Jenkins automates the build and deployment process. By using Freestyle and Pipeline jobs along with Docker, I successfully built and deployed an application, demonstrating the basics of CI/CD.

Source Code - GitHub

Click on the link for the report continuation

Report- Continuation