7 / 6 / 2026

Task 1: Git Version Control and Collaborative GitHub Workflow

1. Understanding Git and Version Control

Git is a distributed version control system used to track changes in source code and maintain different versions of a project. GitHub is a platform used to host Git repositories and collaborate with developers through branches and Pull Requests.

Important concepts used in this task include repositories, commits, branches, remotes, Pull Requests, merge conflicts, rebase, revert, cherry-pick, and Git configuration.

Git was verified using:

git --version

Git version used: 2.53.0

Git identity was configured using:

git config --global user.name "*****"
git config --global user.email "*****"

Additional Git configurations and aliases were also created to customize the development workflow.

2. Creating, Cloning and Managing the Repository

Created a GitHub repository named git-workflow-practice and cloned it to the Ubuntu system using:

git clone 
cd git-workflow-practice

The remote repository was verified using:

git remote -v

A small project was created and modified locally to practise the Git workflow. The changes were checked, staged, committed, and pushed to GitHub using:

git status
git diff
git add .
git commit -m "Add Git workflow revision notes"
git push

This demonstrated the complete workflow from local development to the remote GitHub repository.

3. Branching and Pull Requests

A feature branch was created to keep development work separate from the main branch:

git switch -c feature/about-git

Changes were made on the feature branch and pushed to GitHub using:

git add .
git commit -m "Add project description"
git push -u origin feature/about-git

A Pull Request was created from the feature branch to the main branch. The changes were reviewed and merged successfully.

The workflow followed was:

Feature Branch → Commit → Push → Pull Request → Review → Merge

4. Merge Conflicts and Git Rebase

A merge conflict was intentionally created by making different changes to the same part of a file in two branches. Git was unable to automatically combine the changes and marked the conflicting section.

The conflict was identified using:

git status

The conflicting content was manually corrected and staged. Git rebase was then used to apply the feature branch changes on top of the latest main branch:

git rebase main

After resolving the conflict, the rebase was continued using:

git add 
git rebase --continue

This provided practical understanding of merge conflicts, conflict resolution, and the use of Git rebase.

5. Git Revert and Cherry-Pick

The git revert command was practised to safely undo the changes introduced by an earlier commit:

git revert 

Git created a new commit that reversed the changes while preserving the existing project history.

The git cherry-pick command was also practised to apply a specific commit from another branch:

git cherry-pick 

This demonstrated how an individual change can be transferred between branches without merging the complete branch.

6. Customized Git Workflow

Git configuration was customized using git config. The default branch was configured as main, and aliases were created for frequently used commands:

git config --global init.defaultBranch main
git config --global alias.st status
git config --global alias.br branch
git config --global alias.cm "commit -m"
git config --global alias.lg "log --oneline --graph --decorate --all"

These configurations simplified frequently used Git commands and created a customized Git workflow.

7. Open-Source Contribution

Contributed to the lingdojo/kana-dojo open-source project by adding a Japan-related fact through a fork, feature branch, commit, push, and Pull Request workflow.

8. Outcome

Successfully learned and practised Git version control and GitHub collaboration, including repository cloning, commits, remote repositories, branch management, Pull Requests, merge conflict resolution using rebase, git revert, git cherry-pick, customized Git configuration, and an open-source contribution.

The task provided practical experience in managing project changes and following a collaborative Git workflow from local development to GitHub.

Task 2: Docker Basics and Container Management

1. Understanding Docker and Containers

Docker is a containerization platform that allows applications to run in isolated environments called containers.

Important concepts learned:

• Docker Image: Template used to create containers.
• Docker Container: Running instance of an image.
• Docker Hub: Repository for Docker images.
• Docker CLI: Command-line tool used to manage Docker resources.

Containers vs Virtual Machines

• Containers are lightweight and share the host operating system.
• Virtual Machines include a complete operating system and require more resources.
• Containers start faster and consume less memory.

2. Pulling and Running a Docker Image

Downloaded the Nginx image from Docker Hub:

docker pull nginx

Started a container from the image:

docker run -d -p 8080:80 nginx

3. Viewing Containers and Logs

Checked running containers:

docker ps

Viewed all containers, including stopped containers:

docker ps -a

Viewed container logs:

docker logs 

4. Inspecting and Managing Containers

Inspected container details:

docker inspect 

Stopped and restarted the container:

docker stop 
docker restart 

Removed the container:

docker rm 

5. Managing Docker Images

Listed available images:

docker images

Removed an unused image:

docker rmi 

Outcome

Successfully learned Docker fundamentals, understood the difference between Containers and Virtual Machines, pulled images from Docker Hub, created and managed containers, viewed logs and container details, listed images, and performed complete container lifecycle management using Docker CLI commands.

Task 3: Containerizing a Notes Application Using Docker

1. Understanding Docker and Containerization

Docker is a containerization platform that allows developers to package applications along with their dependencies into portable containers. Containers ensure that applications run consistently across different environments without requiring additional configuration.

Important components used in this task:

• Dockerfile: A text file containing instructions to build a Docker image.
• Docker Image: A packaged blueprint containing the application and its dependencies.
• Docker Container: A running instance of a Docker image.
• Port Mapping: Allows access to services running inside a container from the host machine.
• Image Layers: Each Dockerfile instruction creates a separate layer that Docker can cache and reuse.

1. Creating the Notes Application

A simple Notes Application was developed using Node.js and Express.

Features implemented:

Add new notes. View saved notes. Delete existing notes. Store notes in a local JSON file.

Project structure:

notes-app/ │ ├── public/ │ ├── index.html │ ├── style.css │ └── script.js │ ├── notes.json ├── server.js ├── package.json └── Dockerfile

The application was configured to run on Port 3000 and successfully served both the frontend and backend functionality.

3. Writing the Dockerfile

A Dockerfile was created to define the environment required for the application.

Example Dockerfile:

FROM node:20

WORKDIR /app

COPY package*.json ./

RUN npm install

COPY . .

EXPOSE 3000

CMD ["node", "server.js"]

Dockerfile instructions used:

• FROM– Selects the base Node.js image.

• WORKDIR – Sets the working directory inside the container.

• COPY – Copies project files into the container.

• RUN – Installs required dependencies.

• EXPOSE – Documents the application port.

• CMD – Starts the application when the container runs.

4. Building the Docker Image

The Docker image was built using the following command:

docker build -t notes-app .

Docker successfully processed the Dockerfile instructions and created the application image.

The image was verified using:

docker images

Docker Image's Image

5. Running the Docker Container

A container was launched from the created image using:

docker run -d -p 3001:3000 --name notes-container notes-app

Explanation:

• -d runs the container in detached mode.
• -p 3001:3000 maps host port 3001 to container port 3000.
• --name assigns a name to the container.

The running container was verified using:

docker ps

Running Docker Container Image.

6. Accessing the Application

The Notes Application was accessed through a web browser using:

http://localhost:3001

The application loaded successfully and all note management features were tested.

Verified operations:

Adding notes. Viewing notes. Deleting notes.

The frontend communicated successfully with the Node.js and Express backend, and notes were stored and retrieved from the local JSON file.

Notes Application running in browser on Port 3001.

7. Understanding Docker Image Layers

Each instruction in the Dockerfile creates a separate image layer.

Example:

FROM node:20

WORKDIR /app

COPY package*.json ./

RUN npm install

COPY . .

CMD ["node", "server.js"]

Generated layers:

Base Node.js image. Working directory creation. Package file copy. Dependency installation. Application source code copy. Application startup command.

Docker caches unchanged layers, which speeds up future image builds.

Docker build output showing image layers.

Outcome

Successfully containerized a Notes Application using Docker by creating a Dockerfile, building a Docker image, running the application inside a container, mapping container ports to the host machine, and accessing the application through a web browser. Additionally, gained practical understanding of Docker images, containers, port mapping, and image layers.

Task 4: Launch and Manage an AWS EC2 Instance

1. Understanding EC2

Amazon EC2 (Elastic Compute Cloud) is a cloud computing service provided by AWS that allows users to create and manage virtual machines on the cloud. These virtual machines can host applications, websites, and services that are accessible over the internet.

Important components used in this task:

• AMI (Amazon Machine Image): Contains the operating system required to launch an EC2 instance. I used Ubuntu Server 24.04 LTS.
• Instance Type: Determines CPU and memory allocation. I selected a t3.micro instance.
• Security Group: Acts as a firewall and controls inbound and outbound traffic.
• Key Pair: Used for secure authentication while connecting through SSH.

2. Launching the EC2 Instance

• Opened the AWS EC2 dashboard.
• Launched a new Ubuntu EC2 instance.
• Selected the t3.micro instance type.
• Created and downloaded a .pem key pair.
• Successfully launched the EC2 instance.

EC2 instance in Running state.

3. Connecting to the EC2 Instance

• Connected to the EC2 instance using SSH from Windows PowerShell.
• Authenticated using the downloaded .pem key.
• Verified successful login to the Ubuntu server.

This provided command-line access to the cloud server.

Successful SSH connection showing the Ubuntu terminal.

4. Installing and Starting Nginx

Installed the Nginx web server using the following commands:

sudo apt update
sudo apt install nginx -y
sudo systemctl start nginx
sudo systemctl status nginx

The Nginx service started successfully and was verified using the status command.

Nginx status showing "active (running)".

5. Configuring Security Group Rules

Initially, the Nginx page was not accessible because HTTP traffic was blocked.

To resolve this:

• Opened the Security Group attached to the EC2 instance.
• Added an inbound rule for HTTP.
• Allowed traffic on Port 80 from Anywhere (0.0.0.0/0).

This enabled public access to the web server.

6. Verifying the Web Server

Opened the EC2 public IP address in a web browser:

http://98.130.124.189

The default Nginx welcome page was displayed successfully, confirming that the web server was running and accessible from the internet.

Nginx Welcome Page.

Outcome

Successfully launched and managed an AWS EC2 instance, connected through SSH, installed Nginx, configured Security Groups, and hosted a web server accessible through the public IP address.

Veiw Full Report