Anagha's CL-CY Report Level 1

4 / 10 / 2026

Cloud Computing

Task 1: Working with Git and GitHub basics

In this task, Git and GitHub workflows were practiced to understand collaborative software development. Actions such as editing, staging, committing, pushing, along with creation of branches and pull requests were performed.

Understanding Version Control and Distributed Repositories

Version control helps track changes in source code over time. Git is a distributed version control system that allows multiple developers to work collaboratively on the same project.

Commands Used:

git init
git status
git add .
git commit -m "commit message"
git remote add origin 
git push -u origin main

Screenshots:

Solving Merge Conflicts using Git Rebase

Git rebase helps integrate changes from one branch into another while maintaining a cleaner commit history.

Commands Used:

git rebase main
git rebase --continue

Screenshots:

Creating and Managing Branches

Branches are used to develop features independently without affecting the main branch.

Commands Used:

git checkout -b feature-branch
git branch

Screenshots:

Open Source Contribution

An open-source repository was explored and contributions were made through commits and pull requests.

Screenshots:

Using Git Revert and Git Cherry-Pick

Git revert is used to undo commits safely, while git cherry-pick applies selected commits from one branch to another.

Commands Used:

git revert 
git cherry-pick 

Screenshots:

Customized Git Workflow using Git Config

Git config allows customisation of user identity and workflow settings. It can also be used to view the details, if already set.

Commands Used:

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

Screenshot:

Task 2: Exploring Docker Fundamentals

Difference Between Containers and Virtual Machines

Pulling Docker Images from Docker Hub

Docker images were pulled from Docker Hub and stored locally in the system.

Commands Used:

docker pull nginx
docker images

Screenshot:

Running Containers using Docker CLI

An nginx container was created and executed locally using Docker CLI commands. Port mapping was used to access the application through the browser.

Commands Used:

docker run -d --name mynginx -p 8080:80 nginx
docker ps

Screenshot:

Viewing Logs and Inspecting Container State

Docker logs and inspect commands were used to monitor container activity and understand container status information.

Commands Used:

docker logs mynginx --tail 5
docker inspect mynginx --format='Status: {{.State.Status}}'

Screenshot:

Managing Container Lifecycle

Container lifecycle operations such as restart, stop, and remove were performed successfully.

Commands Used:

docker restart mynginx
docker stop mynginx
docker rm mynginx
docker rmi nginx

Screenshots:

Task 3: Dockerizing a Simple Application

A simple static website was containerized using Docker. A Dockerfile was created using the nginx base image. The HTML file was copied into the nginx web server directory using the COPY instruction.

Dockerfile

FROM nginx:latest
COPY index.html /usr/share/nginx/html/index.html

Commands Used:

docker build -t mywebsite .
docker run -d --name website-container -p 8080:80 mywebsite
docker ps
docker rm -f website-container
docker rmi mywebsite

Screenshots:

Task 4: Launch and Manage an AWS EC2 Instance

AWS EC2 was explored by launching a Linux virtual machine and configuring its network access. A security group was configured to allow SSH on port 22 and HTTP on port 80. The instance was accessed securely using an SSH key pair (.pem file).

Connecting to the EC2 Instance

The instance was connected using SSH with the generated key pair.

Command Used:

ssh -i "clcy-ec2-key.pem" ec2-user@

The connection was established successfully and the Amazon Linux environment was accessed.

Installing and Managing Nginx

Nginx was installed and configured as a web server on the EC2 instance.

Commands Used:

sudo dnf update -y
sudo dnf install nginx -y
sudo systemctl start nginx
sudo systemctl enable nginx
sudo systemctl status nginx

The Nginx service was successfully started and verified as active.

Accessing Nginx through the Public IP

The EC2 instance's public IP was used to access the Nginx web server through a browser. The Nginx welcome page was displayed successfully, confirming that the instance was reachable over HTTP.

EC2 CPU and Memory

EC2 instance types determine the available vCPUs, memory, and other resources. CPU credits on burstable instances such as the t3.micro allow the instance to temporarily use CPU performance above its baseline when required.

Screenshots

Task 5: Kubernetes Basics and Writing Pod Specs

Kubernetes was explored using Minikube to understand basic container orchestration concepts and deploy a simple Nginx container.

Understanding Kubernetes Concepts

The following core concepts were studied:

• Cluster: A collection of machines that work together to run containerized workloads.
• Node: A machine within the Kubernetes cluster that runs Pods.
• Pod: The smallest deployable unit in Kubernetes, which contains one or more containers. In this task, the Pod contained an Nginx container.
• Control Plane: The components responsible for managing the Kubernetes cluster, including scheduling and maintaining the desired state of workloads.

Minikube was used to create a local Kubernetes cluster for the task.

Creating a Pod Manifest

A Pod specification was created using a YAML manifest to deploy an Nginx container.

apiVersion: v1
kind: Pod
metadata:
    name: nginx-pod
spec:
    containers:
        - name: nginx
        image: nginx:latest

Applying the Manifest

The Minikube cluster was started using the Docker driver and the Pod manifest was deployed using kubectl.

Commands Used:

minikube start --driver=docker
minikube status
minikube kubectl -- apply -f pod.yaml

The manifest was successfully applied and the nginx-pod was created.

Inspecting the Pod

The Pod's status was verified and additional information was obtained using kubectl.

Commands Used:

minikube kubectl -- get pods
minikube kubectl -- describe pod nginx-pod
minikube kubectl -- logs nginx-pod

The Pod reached the Running state with the Nginx container marked as ready. The describe command was used to inspect the Pod's configuration, container state, assigned IP, node, and events. The logs confirmed that the Nginx container initialized successfully.

Screenshots

Task 6: Manage AWS S3 and IAM with CLI

AWS IAM and S3 were explored using the AWS CLI. An IAM user was created and configured with S3 permissions, and the AWS CLI was configured to interact with AWS services. S3 bucket and object operations were performed, followed by applying a restricted IAM policy to demonstrate least-privilege access.

AWS CLI and S3 Operations

The AWS CLI was configured with IAM credentials and used to manage an S3 bucket. A test file was created, uploaded to the bucket, listed, downloaded, and deleted.

Commands Used:

aws s3 mb s3://clcy-s3-bucket-silversquare22 --region ap-southeast-2
aws s3 cp test.txt s3://clcy-s3-bucket-silversquare22/
aws s3 ls s3://clcy-s3-bucket-silversquare22/
aws s3 cp s3://clcy-s3-bucket-silversquare22/test.txt test-downloaded.txt
aws s3 rm s3://clcy-s3-bucket-silversquare22/test.txt
aws s3 rb s3://clcy-s3-bucket-silversquare22/

The S3 object operations were successfully performed using the CLI, demonstrating basic cloud storage management.

IAM Least-Privilege Policy

A custom CLCY-S3-LimitedAccess policy was applied to restrict the IAM user's S3 permissions. The policy allows listing the specified bucket and reading, writing, and deleting objects, without granting unrestricted bucket-management permissions.

The restricted permissions were validated by attempting operations outside the policy scope. Bucket creation and deletion were denied with AccessDenied, demonstrating the effect of least-privilege access control.

Screenshots

🔗 View the complete report here