Gourav's CLCY level 2

11 / 8 / 2026

CL domain

1. Working with Git and GitHub Basics

Task Overview

Successfully completed the foundational Git and GitHub task. This task provided practical, hands-on experience in version control, managing distributed repositories, and executing standard collaborative workflows.

Key Implementations

• Version Control: Cloned repositories, created isolated feature branches, and managed staging environments.
• Advanced Git Operations: Successfully resolved upstream commit history mismatches utilizing git fetch, git reset --mixed, and force pushing to align local branches with the main repository.
• Open Source Contribution: Actively claimed and resolved an open issue (Issue #3) on the consilium repository.

Contribution Details

• Infrastructure as Code: Built a Dockerfile for a Python FastAPI server and configured a docker-compose.yml to orchestrate the API alongside an Ollama LLM container.
• Documentation: Updated the project's README.md with clear, containerized deployment instructions.
• Outcome: Successfully submitted a Pull Request (PR) to the upstream repository.

2. Exploring Docker Fundamentals

Objective

Successfully completed the task on Docker fundamentals, establishing a solid understanding of containerized environments crucial for cloud architecture and secure deployments.

Containers vs. Virtual Machines

The primary theoretical outcome involved differentiating between legacy and modern infrastructure paradigms:

• Virtual Machines (VMs): VMs operate on top of a hypervisor and require a complete, isolated Guest Operating System for every single application. This architecture makes them heavily resource-intensive, consuming substantial memory and resulting in slower boot times.
• Containers: Containers bypass the need for a Guest OS by directly sharing the host machine's operating system kernel. This modern approach renders them exceptionally lightweight, highly portable, and capable of booting in milliseconds, ensuring consistent performance from development to production.

Docker CLI & Lifecycle Management

Practical execution involved utilizing the Docker CLI to manage an nginx web server through its complete lifecycle:

• Image Retrieval: Executed docker pull nginx to securely fetch the standalone, executable software blueprint from the Docker Hub registry.
• Deployment & Execution: Utilized docker run -d -p 8080:80 --name my_web_server nginx to initialize the container in detached mode, actively mapping local machine ports to expose the web service.
• Inspection & Monitoring: Employed docker ps to inspect active container states, verifying uptime and port configurations. Used docker logs my_web_server to monitor internal HTTP traffic and verify process health.
• Lifecycle Teardown: Maintained local system hygiene by executing docker stop to gracefully halt the running process, followed immediately by docker rm to permanently delete the container instance.

3. Dockerize a Simple Application

1. Task Objective

The goal of this task was to learn Dockerfile basics, containerize a simple Node.js API application, build the Docker image, run it as a container locally, and verify successful deployment via the browser.

2. Writing the Dockerfile

To containerize the application, a Dockerfile was created at the root of the project. A lightweight base image, node:18-alpine, was selected. The file sets the working directory to /app, copies the package.json file, and runs npm install to install dependencies. Afterwards, the remaining application files (index.js) were copied into the container. The Dockerfile exposes port 3000 and defines the startup command using CMD ["npm", "start"].

3. Building the Docker Image and Understanding Layers

The Docker image was built using the command docker build -t my-simple-app .. During the build process, the concept of image layers became evident. Each instruction in the Dockerfile (like FROM, WORKDIR, COPY, and RUN) created a discrete, read-only layer. By copying package.json and running npm install before copying the rest of the application code, Docker caches the dependency layer. This optimization ensures that subsequent builds are significantly faster if only the application code changes.

4. Running the Container and Port Mapping

The container was executed in detached mode using docker run -d -p 8080:3000 --name running-app my-simple-app. A crucial part of this step was mapping the ports. The -p 8080:3000 flag mapped port 8080 on the host machine to port 3000 inside the isolated container, establishing a bridge for external traffic to reach the application.

5. Verification

The deployment was verified by navigating to http://localhost:8080 in a web browser, successfully displaying the starter code's API response: "Task 3 Complete! Hello from Docker inside my container!". The application is fully containerized and operational.

Task 4: Launch and manage an AWS EC2 Instance

Objective Overview

• Provision and manage a live AWS EC2 virtual machine to transition from local development to cloud infrastructure.
• Configure secure remote access and deploy a lightweight web server (Nginx) accessible via a public IP.

Implementation Summary

• AWS Setup: Resolved initial billing e-mandate loops to successfully activate the AWS Free Tier console.
• Provisioning: Launched a t3.micro instance running the Amazon Linux operating system.
• Security & Access: Configured the AWS Security Group to explicitly allow inbound traffic on Ports 22 (SSH) and 80 (HTTP).
• Troubleshooting Permissions: Overcame Windows NTFS and OneDrive permission conflicts by disabling file inheritance and strictly limiting .pem read access to a single user profile.
• Deployment: Connected securely via SSH using the ec2-user profile, installed the Nginx web server via the dnf package manager, and successfully verified public web access.
• Cleanup: Terminated the instance and its attached storage volumes to ensure zero ongoing costs.

Concepts Mastered

• IaaS Fundamentals: Gained practical, hands-on experience provisioning and configuring raw cloud compute resources.
• Compute Mechanics: Understood the t3.micro burstable CPU credit system and its fixed memory constraints.
• Network Security: Mastered using AWS Security Groups as stateful, virtual firewalls to enforce the principle of least privilege.
• Cryptographic Authentication: Transitioned from traditional password-based logins to highly secure asymmetric key-pair (.pem) remote access.

Task 5: Kubernetes Basics and Writing Pod Specs

1. Objective Overview

The goal of this task was to understand core Kubernetes concepts, configure a local Minikube environment, write a YAML manifest to deploy an Nginx container, and interact with the cluster using kubectl commands.

2. Core Concepts Mastered

• Cluster: The overarching system of machines running Kubernetes.
• Control Plane: The management layer that orchestrates the cluster, dictates container placement, and monitors overall health.
• Nodes: The virtual or physical worker machines that execute the workloads.
• Pods: The smallest deployable unit in Kubernetes, acting as an environment wrapper around one or more containers (e.g., an Nginx web server).

3. Writing the Pod Specification

Created a declarative manifest file (nginx-pod.yaml) to define the desired state of the Pod:

• apiVersion & kind: Specified that the resource to be created is a Pod.
• metadata: Assigned the identifiable name my-first-nginx and applied organizational labels.
• spec: Defined the container configuration, instructing the cluster to pull the official nginx:latest image and expose containerPort: 80.

4. Key Commands Executed

• minikube start: Initialized the local single-node cluster.
• kubectl apply -f nginx-pod.yaml: Deployed the Pod directly into the cluster.
• kubectl get pods: Monitored the real-time status of active Pods.
• kubectl describe pod my-first-nginx: Inspected the Pod's lifecycle events, image pulling status, and internal configuration details.
• kubectl logs my-first-nginx: Accessed the container's output logs for diagnostic purposes.
• kubectl delete pod my-first-nginx & minikube stop: Cleaned up the deployed resources and safely powered down the local cluster to free system memory.

Task 6: Manage AWS S3 and IAM with CLI

Task Objective

To configure the AWS Command Line Interface (CLI), implement secure Identity and Access Management (IAM) practices, and manage Amazon S3 object storage directly from the terminal.

IAM Security & Authentication

• User Creation: Created a dedicated IAM User specifically for programmatic access, ensuring the root AWS account remains secure.
• Policy Management: Assigned necessary S3 access policies to the IAM user to authorize specific cloud operations.
• CLI Configuration: Generated an Access Key ID and Secret Access Key, and used aws configure to authenticate the Kali Linux terminal with AWS.

S3 Bucket Provisioning

• Global Naming Constraints: Navigated S3's global namespace requirements by resolving a BucketAlreadyExists error to secure a unique bucket identifier.
• Bucket Creation: Successfully utilized the aws s3 mb command to provision a new storage bucket hosted in the ap-south-1 region.

Object Operations & Data Lifecycle

• Uploading: Created a local test file and pushed it to the cloud container using aws s3 cp.
• Verification: Queried the cloud environment using aws s3 ls to confirm the object was successfully stored.
• Retrieval & Cleanup: Downloaded the object back to the local filesystem, followed by securely deleting the cloud copy using aws s3 rm.

Key Takeaways

Successfully bridged local command-line operations with AWS infrastructure, gaining practical experience in automated cloud storage management and programmatic identity verification.

Task 7: Deploy a Containerized Application on Kubernetes

Overview

This report details the deployment of a containerized Nginx application to a Kubernetes cluster using YAML manifests. The application was exposed both internally and externally, and dynamic scaling was verified.

1. Deployment Creation

I created a Kubernetes Deployment manifest (deployment.yaml) to manage application.

• Image used: nginx:latest
• Replicas: Initially set to 3 to ensure high availability.
• Result: The deployment successfully pulled the Docker image and spun up 3 identical Pods running the application.

2. Exposing the Application

To make the application accessible, I created a Service manifest (service.yaml).

• Service Type: NodePort. This type of service inherently satisfies two networking requirements:
  1. ClusterIP: It creates an internal IP address so other resources inside the Kubernetes cluster can communicate with the app.
  2. NodePort: It maps an external port (30080) on the node directly to the internal pods, allowing to access the application via a web browser from our local machine.
• Validation: The Nginx welcome page was successfully accessed via the exposed NodePort URL.

3. Scaling Operations

Interacted with the Kubernetes control plane using kubectl to dynamically scale the application without downtime.

• Scaling Up: Scaled the deployment to 5 replicas (kubectl scale deployment/my-nginx-app --replicas=5). Kubernetes instantly scheduled and started 2 additional pods.
• Scaling Down: Scaled the deployment back down to 2 replicas (kubectl scale deployment/my-nginx-app --replicas=2). Kubernetes gracefully terminated 3 of the pods.

Conclusion

The application was successfully containerized, deployed, networked, and scaled using declarative YAML manifests and kubectl commands, fulfilling all expected task outcomes.

To see full report CLICK HERE