cover photo

COURSE

CL-CY-001

4 Levels · 6 Months

Introduction to Cloud Computing and Cyber Security

CL-CY-001

Jump to:

Level 1

Generic Tasks

TASK 1: 3D Printing

Understand the working of a 3D printer, check out the online resources. Understand what's an STL file, and then learn to slice it (using ultimaker or creality slicer).Go through the SOP'S regarding the 3d printer. Learn about bed temperature, infill density and other printer settings. Finally get an STL file from the internet, and slice it and put it for print.

Resources:

(Note this task is to be done under coordinator supervision.) 3dprinter

TASK 2: API

What is an API? Learn the working of an API and its applications. Using any api of your choice, build an user interface(web app, mobile app, etc), where you can make calls and then display the necessary information. An example weather app is given below, using the open weather api.

TASK 3: Working with Github

Familiarize yourself with GitHub integrated workflows (GitHub actions), Issues, and pull requests with this task. Given below is a git repository, go check it out and then perform the necessary tasks stated in the readme file.

Check this link for more info: https://github.com/UVCE-Marvel/git-task

TASK 4: Command Line on Ubuntu

  • Create a folder named test.

  • cd into that folder.

  • Create a blank file without using any text editor.

  • list the files in that folder

  • create 2600 folders in this folder where each folder is named like . For example, M90 or B56.

  • concatenate two text files containing any random text and display them on the terminal.

https://ubuntu.com/tutorials/command-line-for-beginners#1-overview

Task 5 : Build Your Own Brain -Linear Regression from Scratch

Dive into the core of machine learning by implementing Linear Regression from scratch using , and compare its performance with the scikit-learn implementation. Use the California Housing dataset to evaluate your model on real-world data.

Your Task:

  • Implement linear regression manually (without using ML libraries for training).
  • Understand and apply gradient descent to minimize error.
  • Compare your custom model’s performance against sklearn.linear_model.LinearRegression .
  • You should analyze results by:
    • Graph showing line of best fit and the datapoints.
    • Performance metrics: MSE, MAE, R² for both custom and scikit-learn models.
    • Brief comparison between two models.

Download Dataset

Learn Linear Regression:

  1. Understanding :

  2. Coding the linear regression algorithm from scratch:

Expected Outcomes:

  • Grasp how gradient descent optimizes weights in linear regression.
  • Understand the importance of feature scaling.
  • Know how to evaluate regression models using standard metrics.
  • Be able to appreciate the convenience and performance of inbuilt ML libraries.

Precautions:

  • Always normalize or standardize features before training your scratch model, especially if you’re using gradient descent.
  • Be cautious with your learning rate , too small and the model is slow, too large and it may diverge.
  • Initialize weights and bias properly ( small random values or zeros).

Task 6 : The Matrix Puzzle — Decode with NumPy & Reveal the Image

Get hands-on with NumPy and Matplotlib by solving a visual puzzle. You’ll be given a scrambled matrix, and your mission is to decode it into a hidden image using NumPy operations and visualization techniques.

Your Task:

  • Download the scrambled matrix from the link provided.
  • Use your knowledge of NumPy to manipulate, reshape, and reorient the matrix.
  • Reveal the secret image by plotting it using matplotlib.pyplot.imshow() .
  • Scrambled Matrix: Download Here
  • NumPy Learning Doc: Explore Here

Learn NUMPY:

Learn Matplotlib:

Decode the Matrix using these clues and Visualize it :

  • "Try reshaping the encoded array into a square—how many elements are there?"
  • "The structure may be upright, but the data might be sideways. Look at its orientation."
  • "Sometimes the end is actually the beginning."

Expected Outcomes:

  • Gain confidence with NumPy operations like reshaping, slicing, flipping, and transposing.
  • Learn to visualize 2D arrays using Matplotlib.
  • Sharpen your debugging and puzzle-solving skills in a fun context.

Precautions:

  • Check the shape of the array before applying imshow() - wrong dimensions will throw errors.
  • Ensure that your reshaped matrix has the correct number of elements (it's likely a square!).

TASK 7: Create a Portfolio Webpage

Create a website to showcase your portfolio - about yourself, interests, projects, social media profiles and more. It has to be responsive and also pushed to the git repository. CSS can be of your choice and any framework can be used.

TASK 8: Writing Resource Article using Markdown

Markdown is an easy-to-use markup language that is used with plain text to add formatting elements (headings, bulleted lists, URLs) to plain text without the use of a formal text editor or the use of HTML tags. Markdown is device agnostic and displays the writing format consistently across device type. Write a technical resource article on a topic of your choice and post it on the MARVEL website. Refer to the linked article for further details

Link

TASK 9: Tinkercad

Create a tinkercad account, get familiar with the application, understand the example circuits given and simulate a simple circuit using an ultrasonic sensor to estimate the distance between an obstacle and the sensor. Display the results on the serial monitor.

Create a radar system utilising an ultrasonic sensor and servo motor to detect objects within a certain range. The ultrasonic sensor emits sound waves and measures the time taken for them to bounce back, while the servo motor rotates the sensor to cover a wider area, providing a simple yet effective detection mechanism. RESOURCE: https://youtu.be/NwmcNCvUcDc?si=x2LAYMFiqs1SzLfI TASK OUTCOME: introduction to- · TINKERCAD · Working of ultrasonic sensor and servo motor · Radar technology PRECAUTIONS/SAFETY MEASURES- NOT ANY

TASK 10: Speed Control of DC Motor

Explore basic techniques for controlling DC motors, understand the control DC motors using the L298N motor driver and the Arduino board. Using an UNO and H-Bridge L298N motor driver, control the speed of a 5V BO motor, try simulating this on tinkercad and then perform it on the hardware, Record videos of you doing the same.

Reference

TASK 11: LED Toggle Using ESP32

Learn the working of an ESP32 and create a standalone web server with an ESP32 that controls the LED connected with ESP32 GPIOs. Use the arduino IDE to code and upload the program to the ESP32. Learn to configure the IDE to upload code to an ESP32.

Reference

TASK 12: Soldering Prerequisites

(Soldering is to be done in presence of a coordinator)

Learn about the soldering equipment present in our lab, the solder, the soldering iron, soldering wick, flux, etc. Learn to use them and perform basic soldering on a perf board, for example a LED circuit in the presence of a coordinator and document the same.

Reference

TASK 13: 555 Astable Multivibrator

Design a 555 astable multivibrator with duty cycle 60%, rig up the circuit on a breadboard and by using the probes observe the output of your circuit on the DSO. Resources:

TASK 14: Karnaugh Maps and Deriving the logic circuit

Description: For 4 cases, based on door lock/open and key pressed/not pressed. Determine the karnaugh map and make a burglar alarm using simple logic circuits. The buzzer or led blinks when certain conditions are met, you can use push buttons for the door and key.

(Tip: use logic gates, use k-maps to figure out the working conditions.)

TASK 15: Active Participation

Take part in any technical event, inter or intra college and submit the issued certificate of participation.

Enroll for a MOOC and complete the course.

TASK 16: Datasheets Report Writing

Topics: 1)MQ135 Gas sensor 2)L293D motor driver Task Description: Study the datasheet of any one of the above and write a report on it. Specify about the ICs used in L293D, PWM, H-bridge etc. In case of MQ 135, specify the calibrations for different gases and the Freundlich Absorption Theorem Graph.

Task 17: Introduction to VR

Familiarise yourself with what Virtual Reality is. Make a detailed study about what's the difference between VR and AR. Mention about the trends in the space and technology stack being developed. Make about Indian companies in this space. Make the report with detail. Using generative AI to generate this study can lead to disqualification.

vrlol

TASK 18: Sad servers - "Like LeetCode for Linux"

Sadservers is an excellent ground to test your Linux troubleshooting skills. Here is a troubleshooting scenario: Command Line Murders. Troubleshoot and Make Sad Servers Happy!

Task 19: Make a Web app

Using express create a resource library website where you can browse the resource articles, books etc which are available and also manage your account
Reference

Level 2

CL - Cloud Computing

Task 1: Working with Git and GitHub Basics

Task Description
Start by understanding version control. Practice cloning repositories, making changes, committing those changes, and pushing them back to GitHub. Create branches and open pull requests to simulate collaborative workflows. Learn to review and merge pull requests to complete the development cycle.

Expected Task Outcomes
• Understand the fundamentals of version control and distributed repositories
• Learn how to solve merge conflict - git rebase
• Create and manage branches for feature development
• Contribute to atleast one open source project
• Implement and learn about git revert, git cherry-pick
• Create a customized Git workflow - Git config

Resource Links
• Git Official Documentation: https://git-scm.com/doc
• GitHub Learning Lab: https://github.com/apps/github-learning-lab
• Pro Git Book (free): https://git-scm.com/book/en/v2

Task 2: Exploring Docker Fundamentals

Task Description
Begin with learning the difference between containers and virtual machines. Practice using Docker CLI commands to pull images from Docker Hub, run containers, inspect running processes, view logs, and manage container lifecycles such as stopping and removing containers.

Expected Task Outcomes
• Articulate the key differences between containers and virtual machines
• Pull images from Docker Hub and run containers using CLI commands
• Inspect running processes, view container logs, and understand container state
• Manage full container lifecycles: start, stop, restart, and remove

Resource Links
• Docker Official Documentation: https://docs.docker.com/
• Docker Hub: https://hub.docker.com/
• Play with Docker (browser-based lab): https://labs.play-with-docker.com/

Task 3: Dockerize a Simple Application

Task Description
Learn Dockerfile basics and how to containerize applications. Write a Dockerfile for a simple static website or API provided as starter code. Build your Docker image from this Dockerfile and run the application container locally. Verify successful deployment by accessing the app from your browser.

Expected Task Outcomes
• Write a functional Dockerfile to containerize a provided application
• Build a Docker image and run it as a container on your local machine
• Map container ports to the host machine to access the app in a browser
• Understand image layers and how each Dockerfile instruction creates a layer

Resource Links
• Dockerfile Reference: https://docs.docker.com/engine/reference/builder/
• Best Practices for Writing Dockerfiles: https://docs.docker.com/develop/develop-images/dockerfile_best-practices/

Task 4: Launch and Manage an AWS EC2 Instance

Task Description
Explore AWS EC2 service and different instance types. Launch a free-tier EC2 instance, configure the security group to allow SSH access, and connect securely using SSH. Install a lightweight web server such as Nginx or Apache on the instance and ensure it is accessible via the public IP. Also, understand how CPU and memory work in a VM.

Expected Task Outcomes
• Launch an EC2 instance using the AWS Free Tier and configure its security group
• Connect to the instance securely over SSH using a .pem key pair
• Install and start a web server (Nginx or Apache) and confirm access via public IP
• Understand EC2 instance types, CPU credits, and memory allocation in cloud VMs

Resource Links
• AWS EC2 Getting Started Guide: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EC2_GetStarted.html
• AWS Free Tier Details: https://aws.amazon.com/free/
• Nginx Beginner's Guide: https://nginx.org/en/docs/beginners_guide.html

Task 5: Kubernetes Basics and Writing Pod Specs

Task Description
Understand key Kubernetes concepts and the structure of YAML manifest files. Write a simple Pod specification YAML to run a basic container (e.g., Nginx). Apply the manifest to your Minikube cluster and verify the Pod is running. Explore commands to get Pod status and logs.

Expected Task Outcomes
• Explain core Kubernetes concepts: Nodes, Pods, Clusters, and the Control Plane
• Write a valid Pod manifest YAML file to deploy a container image
• Apply manifests to a local Minikube cluster using kubectl
• Use kubectl commands to inspect Pod status, describe Pods, and view logs

Resource Links
• Kubernetes Official Documentation: https://kubernetes.io/docs/home/
• Minikube Getting Started: https://minikube.sigs.k8s.io/docs/start/
• Kubernetes YAML Basics: https://kubernetes.io/docs/concepts/workloads/pods/

Task 6: Manage AWS S3 and IAM with CLI

Task Description
Study AWS IAM concepts like users, roles, and policies, and learn to configure the AWS CLI. Create an IAM user with permissions to access S3, then create an S3 bucket from the CLI. Practice uploading, listing, and downloading files to/from the bucket using AWS CLI commands, reinforcing cloud storage handling.

Expected Task Outcomes
• Understand IAM concepts: users, groups, roles, and least-privilege policies
• Configure the AWS CLI with credentials and verify connectivity to AWS services
• Create an S3 bucket and manage objects via CLI (upload, list, download, delete)
• Apply IAM policies to restrict S3 access to specific users or roles

Resource Links
• AWS IAM Documentation: https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html
• AWS CLI S3 Command Reference: https://docs.aws.amazon.com/cli/latest/reference/s3/
• AWS S3 Getting Started: https://docs.aws.amazon.com/AmazonS3/latest/userguide/GetStartedWithS3.html

Task 7: Deploy a Containerized Application on Kubernetes

Task Description
Learn to write YAML manifests for Kubernetes deployments and services. Package your Dockerized app and deploy it using YAML files. Expose the app within the cluster via ClusterIP and externally using NodePort. Validate by accessing the app through the configured NodePort on your local machine.

Expected Task Outcomes
• Write Deployment YAML to deploy multiple replicas of a containerized application
• Expose the deployment within the cluster using a ClusterIP Service
• Expose the deployment externally using a NodePort Service and access it in a browser
• Scale deployments up and down using kubectl and observe rolling updates

Resource Links
• Kubernetes Deployments: https://kubernetes.io/docs/concepts/workloads/controllers/deployment/
• Kubernetes Services: https://kubernetes.io/docs/concepts/services-networking/service/

Task 8: Use Kubernetes Secrets and Environment Variables

Task Description
Understand how to handle sensitive data and configuration within Kubernetes using Secrets and ConfigMaps. Create a ConfigMap and mount it onto a deployment and let the underlying application use the configuration. Create a Kubernetes Secret with AWS credentials, update deployment YAML to use these Secrets as environment variables, and deploy the updated app. Verify that the app uses the credentials securely to interact with AWS S3.

Expected Task Outcomes
• Create and apply ConfigMaps to inject non-sensitive configuration into Pods
• Create Kubernetes Secrets to store AWS credentials without hardcoding them
• Mount Secrets as environment variables in a Deployment and verify their consumption
• Understand the difference between Secrets and ConfigMaps and when to use each

Resource Links
• Kubernetes Secrets: https://kubernetes.io/docs/concepts/configuration/secret/
• Kubernetes ConfigMaps: https://kubernetes.io/docs/concepts/configuration/configmap/

Task 9: Deploy an App to Push Files from Kubernetes to S3

Task Description
Build and deploy an application on Kubernetes capable of pushing files from a locally hosted app server to AWS S3. Use Kubernetes Secrets for storing AWS credentials securely. Validate the file upload process from the app interface to the S3 bucket and verify files in the cloud storage.

Expected Task Outcomes
• Build and containerize a file-upload application using a language/framework of your choice
• Deploy the app on Minikube with AWS credentials injected via Kubernetes Secrets
• Successfully upload a file from the app UI/CLI and verify it appears in the S3 bucket
• Integrate all Level 1 concepts: Docker, Kubernetes, IAM, S3, and Secrets into one working pipeline

Resource Links
• AWS SDK for Python (boto3): https://boto3.amazonaws.com/v1/documentation/api/latest/index.html
• AWS SDK for Node.js: https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/
• Kubernetes Secrets in Pods: https://kubernetes.io/docs/tasks/inject-data-application/distribute-credentials-secure/

CY - Cybersecurity

Welcome to the Marvel Cybersecurity Module.
Level 1 of this module is designed to build a strong foundation by covering the essentials of computer networking, protocols, Windows, Linux, and core cybersecurity principles. These fundamentals are crucial— cybersecurity is not just about tools, but about understanding how systems work.
At its core, cybersecurity follows simple logic:
You can’t protect what you can’t see (or don’t understand), and you can’t break what you don’t know.
That’s why mastering these basics is the first step toward becoming skilled in both defending and attacking systems.
Once you complete Level 1, we’ll move into the more exciting part—hands-on hacking and defense techniques. Stay tuned!

Getting Started
To begin, you’ll need access to a platform called TryHackMe, where all course materials are hosted. Please follow the steps below to create your account:
Step 1: Go to https://tryhackme.com/
Step 2: Click on “Join for FREE” (top-right corner)

Step 3: Sign up using your Google, LinkedIn, or email account
Step 4: Complete any required details (password, captcha, etc.)
Step 5: Finish the introductory tour on the platform
Step 6: Access the Level 1 module using the link below: https://tryhackme.com/jr/uvce_marvel_level1

Level 3

CL - Cloud Computing

Task 1: Linux Fundamentals and Shell Scripting

Task Description
Build a practical understanding of Linux fundamentals, including file permissions, process management, disk usage, and environment variables. Write Bash scripts to inspect system usage and running processes, then schedule a script with cron and verify that its output is logged correctly.

Expected Task Outcomes
• Understand Linux file permissions, process management, and environment variables
• Write a Bash script that checks disk usage for each directory under /home and prints a warning if any directory exceeds 80% usage
• Write a Bash script that accepts a process name, checks whether it is running, and reports its PID and memory usage
• Display a friendly error message when the requested process is not running
• Schedule the process-checking script to run every five minutes using cron
• Configure and verify logging so that scheduled script output is recorded correctly

Resource Links
• GNU Bash Reference Manual: https://www.gnu.org/software/bash/manual/
• Linux man-pages project: https://man7.org/linux/man-pages/
• cron and crontab reference: https://man7.org/linux/man-pages/man5/crontab.5.html
• ShellCheck (Bash script analysis): https://www.shellcheck.net/

Task 2: Networking Fundamentals and SSH

Task Description
Understand how data travels across networks and how to inspect network connectivity, DNS resolution, HTTP traffic, and open ports. Use command-line networking tools to investigate two websites, interpret their output in plain English, examine services running on an EC2 instance, and configure SSH key-based authentication between two EC2 instances.

Expected Task Outcomes
• Run traceroute against two websites and explain what each hop represents
• Identify which traceroute hops appear to belong to AWS and which are outside AWS, documenting any uncertainty where ownership cannot be established
• Use nslookup and dig to resolve a domain and explain the important lines in their output
• Run netstat -tulnp on an EC2 instance, identify the service associated with each listening port, and assess whether that port should be publicly accessible
• Use curl -v to make an HTTP request and annotate the request headers, response headers, status code, and response body
• Generate an SSH key pair using ssh-keygen, copy the public key to a second EC2 instance using ssh-copy-id, and verify passwordless login

Resource Links
• Linux traceroute manual: https://man7.org/linux/man-pages/man8/traceroute.8.html
• dig manual: https://bind9.readthedocs.io/en/latest/manpages.html
• nslookup documentation: https://learn.microsoft.com/en-us/windows-server/administration/windows-commands/nslookup
• curl command-line tool documentation: https://curl.se/docs/
• OpenSSH manual pages: https://www.openssh.com/manual.html
• Amazon EC2 security groups: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-security-groups.html

Task 3: Deploy a Public-Facing App on AWS EC2

Task Description
Take a Dockerized application from Level 1 and deploy it on an AWS EC2 instance so that it can be accessed over the internet using a public IP address. Install Docker on a fresh instance, run the application container on port 80, configure inbound HTTP access, and practise manually updating the deployed application after publishing a new image to Docker Hub.

Expected Task Outcomes
• Connect to a fresh EC2 instance over SSH and install Docker
• Pull the application's Docker image from Docker Hub
• Run the container with the application available on port 80
• Configure the EC2 security group to allow inbound HTTP traffic on port 80
• Access the application through a browser using the EC2 public IP address and verify that it is live
• Make a small change to the application locally, build and push an updated image to Docker Hub, then pull and redeploy the image on EC2 manually

Resource Links
• Amazon EC2 Getting Started Guide: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EC2_GetStarted.html
• Docker Engine installation: https://docs.docker.com/engine/install/
• Docker image build documentation: https://docs.docker.com/build/
• Docker Hub documentation: https://docs.docker.com/docker-hub/
• EC2 security groups: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-security-groups.html

Task 4: Introduction to Databases

Task Description
Learn what a relational database is and why applications use persistent storage instead of keeping all data in memory. Practise basic SQL operations, run a MySQL container as a Kubernetes Pod, connect to it with kubectl exec, and observe what happens to data when the Pod is restarted without persistent storage.

Expected Task Outcomes
• Explain relational databases and the meaning of tables, rows, and columns
• Describe why applications cannot rely on in-memory storage for data that must survive process or system restarts
• Create a database table and practise SQL INSERT, SELECT, UPDATE, and DELETE operations
• Write a Kubernetes Pod manifest that runs a MySQL container and passes database credentials through environment variables
• Connect to the running Pod using kubectl exec and execute SQL queries inside the container
• Restart the Pod and observe that data stored only in the container's ephemeral filesystem is lost; explain the role of persistent storage

Resource Links
• MySQL Reference Manual: https://dev.mysql.com/doc/refman/8.4/en/
• SQL statements in MySQL: https://dev.mysql.com/doc/refman/8.4/en/sql-statements.html
• Kubernetes Pods: https://kubernetes.io/docs/concepts/workloads/pods/
• Run a command in a container: https://kubernetes.io/docs/tasks/debug/debug-application/get-shell-running-container/
• Kubernetes volumes: https://kubernetes.io/docs/concepts/storage/volumes/

Task 5: CI/CD Pipeline with GitHub Actions

Task Description
Automate the manual application redeployment process from Task 3 by creating a CI/CD workflow with GitHub Actions. Start from the provided YAML template, understand its triggers, jobs, steps, and secrets, then configure it to build and publish a Docker image whenever changes are pushed to main. Add an SSH-based deployment step that updates the application running on EC2.

Expected Task Outcomes
• Explain what Continuous Integration (CI) and Continuous Delivery/Deployment (CD) mean and why they are useful
• Set up a GitHub Actions workflow using the provided YAML template
• Understand the workflow's triggers, jobs, steps, and secrets
• Configure the workflow to build a Docker image and push it to Docker Hub on every push to main
• Store required credentials and connection details in GitHub Actions secrets rather than hardcoding them in the workflow
• Add a deployment step that connects to EC2 over SSH, pulls the updated image, and restarts the container
• Push a code change, observe the workflow run end to end, and verify that the update is live without manually operating the server

Resource Links
• GitHub Actions documentation: https://docs.github.com/en/actions
• Understanding GitHub Actions: https://docs.github.com/en/actions/about-github-actions/understanding-github-actions
• Using secrets in GitHub Actions: https://docs.github.com/en/actions/security-for-github-actions/security-guides/using-secrets-in-github-actions
• Docker build and push action: https://github.com/docker/build-push-action
• Docker Hub documentation: https://docs.docker.com/docker-hub/

Task 6: Kubernetes Services

Task Description
Understand how Kubernetes Services provide network access to applications running inside a cluster. Deploy an application on Minikube and expose it using ClusterIP, NodePort, and LoadBalancer. Test how each service type can be reached and compare the use cases and networking behaviour of the three types.

Expected Task Outcomes
• Deploy an application on Minikube and expose it using a ClusterIP Service
• Verify that the ClusterIP application is reachable from within the cluster by sending a request from another Pod using kubectl exec
• Change the Service type to NodePort and access the application from a browser
• Use minikube tunnel to test a LoadBalancer Service and access it through the address made available by Minikube
• Explain the networking differences between ClusterIP, NodePort, and LoadBalancer
• Write a short comparison describing what each Service type does and when it would be appropriate to use it

Resource Links
• Kubernetes Services: https://kubernetes.io/docs/concepts/services-networking/service/
• Minikube service access: https://minikube.sigs.k8s.io/docs/handbook/accessing/
• Minikube tunnel: https://minikube.sigs.k8s.io/docs/commands/tunnel/
• kubectl reference: https://kubernetes.io/docs/reference/kubectl/

Task 7: Introduction to AWS EKS

Task Description
Move from a local Kubernetes environment such as Minikube to a managed Kubernetes cluster on AWS. Learn the purpose of Amazon Elastic Kubernetes Service (EKS), create a cluster after reviewing the prerequisites and costs, configure access from your local machine, and deploy a simple Pod using kubectl.

Expected Task Outcomes
• Explain the role of Amazon EKS and how a managed cloud Kubernetes cluster differs from a local Minikube cluster
• Review the prerequisites and potential costs before creating an EKS cluster
• Create an AWS EKS cluster using an appropriate documented method
• Configure local access to the cluster and verify connectivity with kubectl
• Deploy a simple Pod to the EKS cluster using kubectl commands and verify its status

Resource Links
• Amazon EKS User Guide: https://docs.aws.amazon.com/eks/latest/userguide/what-is-eks.html
• Getting started with Amazon EKS: https://docs.aws.amazon.com/eks/latest/userguide/getting-started.html
• Connecting kubectl to an EKS cluster: https://docs.aws.amazon.com/eks/latest/userguide/create-kubeconfig.html
• Kubernetes kubectl overview: https://kubernetes.io/docs/reference/kubectl/

Task 8: Introduction to Observability

Task Description
Build the habit of inspecting an application's behaviour while it is running. Learn how CPU, memory, and disk resources relate to a Kubernetes Pod and what can happen when resource limits or available capacity are exceeded. Deploy a Pod, stream its logs while sending requests, inspect Pod- and node-level resource usage, and access a metrics endpoint through port forwarding.

Expected Task Outcomes
• Explain how CPU, memory, and disk resources relate to a Kubernetes Pod
• Describe what can happen when a Pod exceeds its memory or CPU limits, or when storage runs out
• Deploy a Pod and stream its logs using kubectl logs -f while sending requests to the application
• Use Kubernetes commands to inspect Pod details and understand Pod- and node-level resource usage
• Use kubectl port-forward to expose a Pod's metrics endpoint locally and open the endpoint in a browser
• Explain what the observed logs and resource metrics reveal about the application's runtime behaviour

Resource Links
• Kubernetes resource management for Pods and containers: https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
• Kubernetes logging: https://kubernetes.io/docs/concepts/cluster-administration/logging/
• kubectl logs reference: https://kubernetes.io/docs/reference/kubectl/generated/kubectl_logs/
• kubectl top reference: https://kubernetes.io/docs/reference/kubectl/generated/kubectl_top/
• kubectl port-forward reference: https://kubernetes.io/docs/reference/kubectl/generated/kubectl_port-forward/

CY - Cybersecurity

Red Team Path

The Red Team Path introduces offensive security concepts through structured, hands-on learning. Work through the rooms in order to build an understanding of the cyber kill chain, penetration-testing methodology, reconnaissance, network scanning, common web vulnerabilities, red-team engagements, and phishing awareness.

Complete all activities only within TryHackMe labs or other environments for which you have explicit authorisation. Keep notes on the commands used, the observations made, and the lessons learned.

Task 1: Cyber Kill Chain

Task Description
Explore the Cyber Kill Chain framework and understand the stages commonly used to describe an adversary's activity, from reconnaissance through actions on objectives. Learn how defenders can use the framework to recognise attacker behaviour and identify opportunities to disrupt an attack.

Expected Task Outcomes
• Explain the purpose of the Cyber Kill Chain framework
• Identify and describe its major phases: reconnaissance, weaponization, delivery, exploitation, installation, command and control, and actions on objectives
• Understand how open-source intelligence (OSINT) supports reconnaissance
• Explain how defenders can identify opportunities to detect, prevent, or disrupt activity at different stages of the kill chain
• Complete the activities and questions in the TryHackMe room

Resource Links
• TryHackMe — Cyber Kill Chain: https://tryhackme.com/room/cyberkillchainzmt

Task 2: Penetration Testing Fundamentals

Task Description
Learn the purpose, scope, and workflow of a penetration test. Understand how penetration testing differs from other security assessments, why authorisation and scope are essential, and how findings should be documented and communicated.

Expected Task Outcomes
• Explain the purpose of a penetration test and how it differs from a vulnerability assessment
• Identify the typical stages of a penetration-testing engagement
• Understand the importance of scope, rules of engagement, authorisation, and responsible conduct
• Recognise the role of evidence, impact assessment, and clear reporting in communicating findings
• Complete the activities and questions in the TryHackMe room

Resource Links
• TryHackMe — Pentesting Fundamentals: https://tryhackme.com/room/pentestingfundamentals

Task 3: Passive Reconnaissance

Task Description
Practise collecting information about a target from publicly available sources without directly interacting with the target's systems. Explore domain-registration information, DNS records, certificate transparency, subdomain discovery, and internet-exposed service search engines.

Expected Task Outcomes
• Explain the difference between passive and active reconnaissance
• Use whois, dig, and nslookup to gather and interpret domain information
• Explore how certificate transparency logs and public sources can reveal subdomains
• Understand how services such as Shodan can provide information about internet-exposed systems
• Record findings clearly and distinguish verified facts from assumptions
• Complete the activities and questions in the TryHackMe room

Resource Links
• TryHackMe — Passive Reconnaissance: https://tryhackme.com/room/passiverecon

Task 4: Active Reconnaissance

Task Description
Learn how direct interaction with a system can reveal information about its availability, network path, exposed services, and web technologies. Practise the room's reconnaissance techniques in the provided lab environment and understand that active probing may be logged or detected.

Expected Task Outcomes
• Explain how active reconnaissance differs from passive reconnaissance and why it may be detectable
• Use browser Developer Tools to inspect relevant web-page information, headers, scripts, and certificates
• Use ping to test reachability and understand the limitations of interpreting TTL values
• Use traceroute or equivalent tools to examine network paths
• Use telnet or netcat in the lab to inspect service responses and banners
• Complete the activities and questions in the TryHackMe room

Resource Links
• TryHackMe — Active Reconnaissance: https://tryhackme.com/room/activerecon

Task 5: Nmap Basic Port Scans

Task Description
Learn how Nmap discovers hosts and scans ports. Practise basic scan techniques in the authorised TryHackMe lab, then interpret the results to understand which ports are open, closed, or filtered and what those states suggest about a target's network services.

Expected Task Outcomes
• Explain the purpose of Nmap in network discovery and port scanning
• Perform the basic scans demonstrated in the room against the assigned lab target
• Interpret common port states, including open, closed, and filtered
• Understand at a high level how TCP connection scans and SYN scans differ
• Record scan results and explain what they reveal about the lab target
• Complete the activities and questions in the TryHackMe room

Resource Links
• TryHackMe — Nmap 01: https://tryhackme.com/room/nmap01
• Nmap Reference Guide: https://nmap.org/book/man.html

Task 6: Nmap Advanced Port Scans

Task Description
Build on basic scanning knowledge by exploring the more advanced Nmap scan techniques covered in the room. Learn how scan behaviour and packet flags affect the results, and practise interpreting the output in the provided lab environment.

Expected Task Outcomes
• Explain the purpose of the advanced Nmap scan techniques covered in the room
• Run the relevant scans against the assigned TryHackMe lab target
• Compare the results of different scan types and explain why they may differ
• Understand that network filtering, host configuration, and firewall behaviour can affect scan results
• Document the commands used and the conclusions supported by the results
• Complete the activities and questions in the TryHackMe room

Resource Links
• TryHackMe — Nmap 02: https://tryhackme.com/room/nmap02
• Nmap Reference Guide: https://nmap.org/book/man.html

Task 7: OWASP Top 10 2025 — Part 1

Task Description
Begin exploring the web application security risks covered in the OWASP Top 10 2025 learning rooms. Understand the vulnerability categories and scenarios presented in the room, and learn to recognise how weaknesses in web applications can affect confidentiality, integrity, and availability.

Expected Task Outcomes
• Review the OWASP Top 10 2025 topics introduced in the room
• Explain the vulnerability categories and examples covered by the exercises
• Identify the underlying causes and potential impact of the demonstrated weaknesses
• Complete the room's practical exercises only in the provided lab environment
• Record key observations and defensive measures relevant to the topics studied

Resource Links
• TryHackMe — OWASP Top 10 2025: Part 1: https://tryhackme.com/room/owasptopten2025one
• OWASP Top 10: https://owasp.org/www-project-top-ten/

Task 8: OWASP Top 10 2025 — Part 2

Task Description
Continue studying the web application security topics covered by the second OWASP Top 10 2025 room. Work through the provided examples to understand how the relevant weaknesses arise, how their impact can be assessed, and what secure development practices help prevent them.

Expected Task Outcomes
• Review the OWASP Top 10 2025 topics introduced in this room
• Explain the causes and potential consequences of the vulnerabilities demonstrated
• Complete the practical exercises in the assigned TryHackMe environment
• Identify relevant prevention, validation, access-control, or configuration practices where applicable to the topics covered
• Summarise the main lessons from the room in your own words

Resource Links
• TryHackMe — OWASP Top 10 2025: Part 2: https://tryhackme.com/room/owasptopten2025two
• OWASP Top 10: https://owasp.org/www-project-top-ten/

Task 9: OWASP Top 10 2025 — Part 3

Task Description
Complete the OWASP Top 10 2025 room sequence by exploring the remaining topics and practical scenarios presented in Part 3. Focus on understanding the security weaknesses, the conditions that make them possible, and the lessons developers and security testers can take from each exercise.

Expected Task Outcomes
• Review the OWASP Top 10 2025 topics introduced in this room
• Explain the relevant weaknesses, their likely impact, and the lessons demonstrated by the exercises
• Complete the assigned practical activities in the TryHackMe lab
• Identify defensive practices that address the issues covered in the room
• Write a short summary of the key concepts learned across Parts 1, 2, and 3

Resource Links
• TryHackMe — OWASP Top 10 2025: Part 3: https://tryhackme.com/room/owasptopten2025three
• OWASP Top 10: https://owasp.org/www-project-top-ten/

Task 10: Red Team Fundamentals

Task Description
Understand the purpose and structure of a red-team engagement and how it differs from a conventional vulnerability assessment or penetration test. Explore engagement roles, objectives, adversary emulation, and the use of frameworks such as the Cyber Kill Chain to describe attacker behaviour.

Expected Task Outcomes
• Explain what a red-team engagement is and what it aims to evaluate
• Distinguish red teaming from vulnerability assessments and penetration testing
• Identify the roles, stakeholders, objectives, and planning considerations involved in an engagement
• Explain adversary emulation and the use of tactics, techniques, and procedures (TTPs)
• Describe how a kill-chain framework can help organise and assess an engagement
• Complete the activities and questions in the TryHackMe room

Resource Links
• TryHackMe — Red Team Fundamentals: https://tryhackme.com/room/redteamfundamentals
• MITRE ATT&CK: https://attack.mitre.org/

Task 11: Phishing Emails — Part 1

Task Description
Learn how to inspect suspicious emails and recognise common phishing indicators. Examine the evidence presented in the TryHackMe exercises, including sender details, links, attachments, and message content, to understand how phishing attempts can be identified and reported.

Expected Task Outcomes
• Explain what phishing is and why it is used in social-engineering attacks
• Inspect email sender details, message content, links, and attachments for suspicious indicators
• Recognise common warning signs such as spoofed senders, misleading links, unexpected attachments, and urgent requests
• Understand safe handling and reporting practices for suspicious emails
• Complete the activities and questions in the TryHackMe room

Resource Links
• TryHackMe — Phishing Emails 1: https://tryhackme.com/room/phishingemails1tryoe
• CISA — Recognize and Report Phishing: https://www.cisa.gov/secure-our-world/recognize-and-report-phishing

Blue Team Path

The Blue Team Path introduces defensive security operations, security monitoring, threat hunting, and endpoint security. Focus on understanding what defenders observe, how they investigate suspicious activity, and how security controls help detect and respond to threats.

Task 12: SOC Fundamentals

Task Description
Explore the role of a Security Operations Center (SOC) and how analysts monitor, investigate, and respond to security events. Learn about SOC responsibilities, common workflows, alert triage, and the tools used to support defensive operations.

Expected Task Outcomes
• Explain the purpose and core responsibilities of a SOC
• Understand common SOC roles and the general alert-investigation workflow
• Distinguish security events, alerts, and incidents at a basic level
• Explain why context, prioritisation, documentation, and escalation matter during investigations
• Complete the activities and questions in the TryHackMe room

Resource Links
• TryHackMe — SOC Fundamentals: https://tryhackme.com/room/socfundamentals

Task 13: Introduction to SIEM

Task Description
Learn how Security Information and Event Management (SIEM) systems collect and analyse security logs from different sources. Explore how logs are used to search for activity, identify suspicious patterns, and support security investigations.

Expected Task Outcomes
• Explain the purpose of a SIEM and the types of data it can collect
• Understand how logs from different systems provide context during an investigation
• Practise the searches, filters, and analysis activities demonstrated in the room
• Explain how SIEM alerts can help analysts identify and investigate suspicious activity
• Complete the activities and questions in the TryHackMe room

Resource Links
• TryHackMe — Introduction to SIEM: https://tryhackme.com/room/introtosiem

Task 14: Threat Hunting Introduction

Task Description
Understand threat hunting as a proactive approach to searching for signs of malicious activity that may not have been detected by existing alerts. Explore the hunting mindset, the use of hypotheses, and the analysis of available security data to investigate suspicious behaviour.

Expected Task Outcomes
• Explain what threat hunting is and how it differs from alert-driven investigation
• Understand how a hypothesis can guide a threat-hunting investigation
• Identify the role of logs, telemetry, and contextual evidence in hunting
• Practise the investigation steps and analysis activities presented in the room
• Document findings and explain how evidence supports or weakens a hypothesis

Resource Links
• TryHackMe — Threat Hunting Introduction: https://tryhackme.com/room/threathuntingintroduction

Task 15: Introduction to Endpoint Security

Task Description
Learn how endpoint security helps protect devices such as workstations and servers. Explore the security controls and monitoring concepts introduced in the room, and understand how endpoint telemetry can help defenders detect suspicious activity and investigate potential compromise.

Expected Task Outcomes
• Explain what an endpoint is and why endpoint security is important
• Understand the purpose of endpoint protection and monitoring controls covered in the room
• Recognise how endpoint activity can provide evidence during security investigations
• Complete the practical activities and questions in the TryHackMe room
• Summarise the defensive concepts learned and how they support detection and response

Resource Links
• TryHackMe — Introduction to Endpoint Security: https://tryhackme.com/room/introtoendpointsecurity

Practical

The practical section brings the learning paths together through hands-on web application security exercises. Work only within the intentionally vulnerable training application and the lab environment provided for this course. Document the issue investigated, the evidence observed, the impact, and the relevant mitigation.

Task 16: OWASP Juice Shop

Task Description
Explore OWASP Juice Shop, an intentionally vulnerable web application designed for security training. Investigate the application in the authorised lab environment, work through suitable challenges, and connect the vulnerabilities you observe to the web security concepts covered in the Red Team Path.

Expected Task Outcomes
• Navigate the Juice Shop application and understand its purpose as a security training environment
• Complete a selection of challenges appropriate to the course's learning objectives
• Identify the vulnerability or security weakness demonstrated by each completed challenge
• Document the steps taken, the evidence observed, and the potential impact
• Where applicable, explain the defensive measures that would help prevent or mitigate the issue
• Relate practical findings to the OWASP Top 10 topics studied earlier

Resource Links
• TryHackMe — OWASP Juice Shop: https://tryhackme.com/room/owaspjuiceshop
• OWASP Juice Shop Project: https://owasp.org/www-project-juice-shop/

Task 17: MARVEL Cybersecurity Red Team Lab

Task Description
Complete the practical exercise provided by the MARVEL Cybersecurity Red Team Lab. Use the techniques and concepts learned throughout the course to investigate the assigned lab environment, follow the exercise objectives, and document your approach and findings.

Expected Task Outcomes
• Access and review the MARVEL Red Team Lab instructions
• Identify the objective and scope of the assigned exercise before beginning
• Apply relevant reconnaissance, scanning, and web-security concepts within the authorised lab
• Record the tools used, steps taken, evidence collected, and conclusions reached
• Summarise the security weaknesses or lessons demonstrated by the exercise and, where relevant, suggest mitigations

Resource Links
• MARVEL Cybersecurity Red Team Lab: https://28d33.github.io/Marvel-CLCY_L2-CY_RED-Lab/

Level 4

Task 1 - Encryption

What are ciphers? Learn about caesar, Vigenere and substitution cipher, Why is this different from encryption techniques like SHA256? Learn about symmetric and asymmetric keys(Public and Private keys) (Optional : How is prime numbers used in RSA)

Task 2 - Hashing

Learn about Hashing ex:SHA256 algorithm ,Salting, Hash Tables (optional: Learn about MD5)

Task 3 - SSH

Write a script to SSH: Secure shell(SSH) is a network communication protocol that enables two computers to communicate . Write a script to SSH into a server and search the whole server for public keys/private keys and upload them to another server.

Task 4 - NMap

Learn how NMap works and Scan the ports, Host and OS and output these details in a file (optional: Analyze the results and report what you have found)

Task 5 - NMap Continued

Find out the use cases Wireshark and its working, Capture and Analyze Data Packs, Work with the various filters and statistics and report what you have found Reference: https://nmap.org/book/man.html https://www.wireshark.org/docs/

UVCE,
K. R Circle,
Bengaluru 01

Social Media
Useful links