DevOps & Cloud Journey

Date: Oct 14–20, 2025

🧩 Topics Covered

• Understanding what Shell Scripts are and why they are essential for automation.
• Creating and executing simple scripts using #!/bin/bash and making them executable.
• Using variables, command substitution, and performing arithmetic operations.
• Implementing decision-making using if, elif, else, and fi statements.
• Using comparison, logical, and string operators to control flow.
• Adding environment variables and configuring PATH for custom script execution from anywhere.
• Writing professional Bash scripts including author, date, usage, and description headers.
• Understanding exit codes and using $? to check command success or failure.
• Working with command-line arguments ($1, $#, $@, etc.).
• Using loops in Bash: for, while, and until.
• Handling file operations, checking file existence, and automating repetitive tasks.

📚 Resources Used:

🎥 Video Lecture: Shell Scripting for Beginners to Advanced

🧠 My Learnings:

During Week 3, I learned how to write and execute Bash scripts to automate Linux operations. I started with basic script creation, variable declaration, and arithmetic operations, then moved to conditional statements and logical comparisons.

I practiced using if-else conditions, exit codes, and arguments to make scripts more dynamic. I also learned about the power of loops — for and while — to repeat tasks and create efficient automation routines.

These concepts helped me understand how DevOps engineers automate deployments, backups, monitoring, and system maintenance. Writing scripts like automated backup and file validation scripts gave me hands-on experience in real-world use cases.

🎯 Next Week Goals:

• Write advanced Bash scripts integrating loops, arguments, and conditions together.
• Learn about crontab for scheduling automated tasks.
• Explore Git version control and practice pushing scripts to GitHub.
• Begin understanding CI/CD fundamentals using shell automation in DevOps pipelines.

Date: Oct 21–27, 2025

🧩 Topics Covered

• Understanding the purpose of automation in DevOps and why periodic task scheduling is essential.
• Learning crontab syntax and scheduling patterns (minute, hour, day, month, weekday fields).
• Creating cron jobs to automate repetitive tasks such as log cleanup, disk usage monitoring, and backups.
• Writing scripts like monitor_disk.sh to automatically alert when disk usage exceeds 80%.
• Testing and verifying cron jobs using crontab -l and grep CRON /var/log/syslog.
• Integrating shell scripts with Git for version control and collaboration.
• Documenting projects using README.md files and pushing code to GitHub.
• Understanding how automation and scheduling play a role in real-world DevOps pipelines.

📁 Assignments Completed:

• monitor_disk.sh – Monitors disk usage and sends an alert when it exceeds 80%.
• backup_logs.sh – Creates automatic backups of system logs daily at midnight.
• cleanup_temp.sh – Deletes temporary files every Sunday at 2 AM to free up system space.
• user_audit.sh – Tracks and logs currently logged-in users along with their login times.
• process_monitor.sh – Monitors running processes and restarts critical ones if they stop.
• crontab.txt – Contains the cron job schedules for automating all the above tasks.

🧠 My Learnings:

During Week 4, I learned how to use crontab for automating routine tasks, a critical skill in DevOps. I scheduled shell scripts for disk monitoring, log backups, and cleanup operations.

I also understood how automation improves reliability, saves time, and ensures consistency in system maintenance. Integrating Git into my workflow helped me version-control my automation scripts and collaborate more effectively.

Additionally, I created a README.md file that documents the purpose, functionality, and scheduling details of each script — an important step in professional DevOps project documentation.

📚 Resources Used:

🎯 Next Week Goals:

• Learn Git branching, merging, and resolving conflicts in real projects.

Date: Oct 28–Nov 3, 2025

🧩 Topics Covered

• Understanding Version Control Systems (VCS) and the difference between centralized and distributed systems.
• Exploring Git fundamentals – repositories, staging, commits, branches, merges, and pushes/pulls.
• Practicing Git branching, merging, and conflict resolution through real-world scenarios.
• Learning key commands such as git clone, git add, git commit, git push, and git merge.
• Understanding Git stash, reset, revert, and rebase for effective change management.
• Creating a .gitignore file to manage unnecessary files and maintain a clean repository.
• Using Git log and related flags (--oneline, --stat, --graph) to analyze project history.
• Connecting local repositories with GitHub and pushing commits remotely.

📁 Assignments Completed:

• Created and configured a local Git repository using git init and git config.
• Practiced branch operations – creating, switching, merging, and deleting branches.
• Resolved merge conflicts manually and committed resolved files.
• Implemented git stash, git reset, and git revert to undo and manage changes.
• Performed rebase to maintain a clean, linear project history.
• Created a .gitignore file to exclude log, temporary, and build files.

🧠 My Learnings:

In Week 5, I gained hands-on experience with Git — an essential DevOps tool for version control and collaboration. I learned how to track code changes, work with branches, and manage repositories both locally and remotely on GitHub.

Understanding branching, merging, and rebasing enhanced my ability to maintain clean project histories and handle conflicts efficiently. I also practiced using git stash and reset to manage partial work and restore previous states without losing progress.

Overall, this week strengthened my knowledge of distributed version control and prepared me for real-world collaboration in DevOps pipelines.

📚 Resources Used:

🎯 Next Week Goals:

• Learn CI/CD concepts and understand how Git integrates into DevOps pipelines using tools like Jenkins.

Date: Nov 4–Nov 10, 2025

🧩 Topics Covered

• Introduction to Docker as a containerization platform for lightweight and consistent application deployment.
• Understanding Containers – packaging code, dependencies, runtime, and system tools in isolated environments.
• Difference between Docker Containers and Virtual Machines in terms of architecture, efficiency, and portability.
• Exploring Docker Architecture – Client, Daemon, Registry, and Docker Objects (Images, Containers, Volumes, Networks).
• Hands-on with Docker Installation and running containers using commands like docker run, docker ps, docker stop, and docker rm.
• Understanding Docker Container Lifecycle – Created, Running, Paused, Exited, and Dead states.
• Creating a simple Apache Web Server using a Docker container and mapping ports with -p flag.
• Basic Computer Networking Concepts – nodes, IP addresses, protocols, DNS, and firewalls.
• Types of Network Architectures: Client-Server and Peer-to-Peer.
• Exploring LAN, WAN, and Cloud Networks and their applications in enterprise setups.
• Study of Network Topologies: Bus, Star, Ring, Mesh, Tree, and Hybrid.
• Understanding OSI and TCP/IP Models and their layered communication structure.
• Hands-on learning about Network Devices like Routers, Switches, Bridges, Hubs, and Gateways.

📁 Assignments Completed:

• Installed Docker on Ubuntu and verified using docker --version and docker ps -a.
• Created and ran containers using docker run -d -p 8080:80 nginx.
• Built a simple Apache web server using Docker volumes and verified on localhost:8080.
• Practiced lifecycle commands like docker start, docker stop, docker pause, docker rm.
• Explored container networking using bridge and host networks.
• Designed network topology diagrams for LAN and Star setups.
• Identified functions of networking devices such as routers, switches, and firewalls through examples.

🧠 My Learnings:

This week, I learned how Docker revolutionizes the way applications are deployed through containerization. I practiced creating, running, and managing containers, which helped me understand how developers package and ship consistent environments across systems.

Alongside, I deepened my understanding of Computer Networks — the foundation for all DevOps communications. Learning about IPs, DNS, protocols, and networking devices gave me a strong base for cloud and DevOps integrations.

This combination of Docker and Networking provided a clear picture of how applications communicate across distributed systems and how DevOps uses containerization for scalability and portability.

📚 Resources Used:

🎯 Next Week Goals:

• Start learning AWS Cloud Services – understanding EC2, S3, IAM, and VPC basics.
• Deploy a simple web application on AWS to understand cloud deployment fundamentals.

Date: Nov 11–Nov 19, 2025

🧩 Topics Covered

• Introduction to Cloud Computing — understanding physical servers, virtualization, and how cloud platforms like AWS replace traditional setups.
• Basics of AWS Account Creation, selecting regions, and why region choice matters.
• Setting up AWS Budgets with alerts, thresholds, and email notifications to avoid unexpected charges.
• Understanding IAM (Identity & Access Management) — Root User, IAM Users, IAM Groups, and Permission Policies.
• Hands-on with IAM Login using different browsers to test access boundaries.
• Introduction to EC2 — creating and deleting a t2.micro instance.
• Understanding AWS Organizations, OUs, multi-account structure for Dev, QA, and Prod.
• Exploring AWS Control Tower, Landing Zone, and governance using multiple accounts.
• Learning AWS monitoring tools — CloudTrail, AWS Config, Security Hub, CloudWatch, and SNS.
• Basics of VPC Networking, CIDR ranges, public & private subnets.

📁 Assignments Completed:

• Created a new AWS account and configured budget alerts for monthly usage.
• Set up notifications for cost thresholds (0.01 USD alert and 80% warning).
• Created IAM Users, Groups, and assigned Admin/DevOps permissions.
• Logged in via IAM user to verify restricted access.
• Created and deleted an EC2 instance (t2.micro) and explored metadata with AWS Config.
• Created an AWS Organization and added Dev & QA accounts under an OU.
• Enabled monitoring tools: CloudTrail, Config, Security Hub, SNS, and CloudWatch.
• Started Project 1: Multi-Account Setup for a startup following best practices.

🧠 My Learnings:

This week strengthened my foundation in AWS Cloud Essentials. I learned how AWS handles identity management through IAM, why companies never use Root accounts for daily work, and how budgets protect users from accidental bills.

I also explored AWS Organizations where multiple AWS accounts (Dev, QA, Prod) are structured for security and cost management. Enabling CloudTrail, Config, and CloudWatch gave me insights into how real DevOps teams monitor cloud environments.

Overall, Week 7 provided me a real-world understanding of how startups build secure, scalable AWS environments using multiple accounts and governance tools.

📚 Resources Used:

🎯 Next Week Goals:

• Deep dive into EC2, S3, IAM, and VPC practical labs.
• Deploy a static website on Amazon S3.
• Understand Load Balancers and basic VPC routing.
• Begin documenting AWS Architectures for DevOps Journey Week 8.

Date: Nov 20–Nov 28, 2025

🧩 Topics Covered

• Deep dive into EC2 Instances — launching, configuring, and optimizing Linux-based servers.
• Created a custom AMI manually from a configured EC2 instance (Golden Image basics).
• Understanding the purpose of Golden AMIs in DevOps pipelines for consistency, security, and faster deployments.
• Set up HashiCorp Packer locally and created automated AMI builds using JSON templates.
• Implemented Golden AMI Automation using Packer → validated, built, and pushed AMIs to AWS.
• Compared manual AMI creation vs automated Packer builds — focusing on time, consistency, cost, and repeatability.
• Hands-on with AWS IAM Roles and permissions required for automated builds.
• Understood the lifecycle of Golden Images: Base AMI → Hardened AMI → Application-ready AMI.
• Basic cleanup tasks: deleting snapshots, unused AMIs, and stopping idle EC2 instances.

📁 Assignments Completed:

• Launched an EC2 instance (Amazon Linux 2023) and installed required packages (git, nginx, java, etc.).
• Created a manual Golden AMI from the configured EC2 instance.
• Installed and configured HashiCorp Packer locally.
• Built the first automated AMI using a Packer JSON template referencing the base AMI.
• Validated Packer templates using packer validate and executed packer build.
• Optimized template with variables, builders, and provisioners.
• Compared time difference:
  • Manual Image Creation: ~12–18 minutes including setup, updates, configurations.
  • Packer Automated Build: ~3–5 minutes depending on provisioning steps.
• Cleaned old AMIs + snapshots to avoid unnecessary cost.

🧠 My Learnings:

This week unfolded how organizations maintain consistency using Golden AMIs. Creating a manual AMI showed how long configuration takes when done step-by-step on the server. It felt like sculpting a statue slowly with careful chisel strokes.

When I used Packer, the work transformed — the same sculpture was produced automatically with the push of a button. Automation reduced errors, improved repeatability, and cut down image creation time dramatically. I understood why DevOps teams rely heavily on AMIs for CI/CD pipelines, autoscaling groups, and environment hardening.

Golden AMI automation is not just about speed — it gives predictable, secure, production-ready images every time. This week strengthened my confidence in infrastructure automation and image building workflows.

📚 Resources Used:

🎯 Next Week Goals:

• Integrate Packer AMI builds with CI/CD workflows.
• Learn Launch Templates & Auto Scaling Groups using Golden AMIs.
• Start building a sample Apache/Nginx web server architecture using custom AMIs.

Date: Nov 29–Dec 05, 2025

🧩 Topics Covered

• Studied AWS Route 53 global DNS system and routing policies.
• Configured Failover Routing between Primary and Secondary EC2 instances.
• Set up Health Checks + SNS Notifications to monitor endpoint availability.
• Created Primary and Secondary A-records for active–passive failover.
• Tested DNS-based traffic switching by stopping the primary instance.
• Explored AWS Serverless Architecture — Lambda, API Gateway, DynamoDB, S3 Events, Step Functions.
• Built a small Serverless API using Lambda + API Gateway.
• Connected Lambda with DynamoDB for CRUD operations.
• Implemented S3 → Lambda event triggers to automate workflows.
• Learnt benefits of serverless systems: scalability, cost efficiency, event-driven automation.

📁 Assignments Completed:

• Created a new Hosted Zone in Route 53.
• Configured Primary Health Check with Fast interval and SNS alerts.
• Added:
  • Primary A-record → Primary Instance (Failover: PRIMARY)
  • Secondary A-record → Secondary Instance (Failover: SECONDARY)
• Verified failover by stopping the primary instance and checking DNS redirection.
• Created a basic Lambda function returning JSON output.
• Integrated Lambda with API Gateway to create a REST API.
• Configured Lambda to read/write data into DynamoDB.
• Created an S3 → Lambda automation flow for file processing.
• Understood orchestration possibilities using Step Functions.

🧠 My Learnings:

This week helped me understand how critical DNS-level routing is for achieving high availability. Route 53 Failover ensures that user traffic is always directed to a healthy instance, giving infrastructure the ability to self-heal during failures.

Diving into serverless architecture was even more exciting — Lambda removed the need for managing servers completely. It made me realize how modern systems are built around events, triggers, and managed services instead of traditional server setups.

The combination of Lambda, DynamoDB, API Gateway, and S3 events showed how applications can scale seamlessly while maintaining low cost, zero maintenance, and instant responsiveness.

📚 Resources Used:

🎯 Next Week Goals:

• Understand Docker architecture: Images, Containers, Layers, Registries.
• Install Docker and run first containers.
• Build custom Docker images using Dockerfiles.
• Practice container lifecycle commands: start, stop, logs, exec, inspect.
• Work with Docker Volumes & Networks.
• Push/Pull images from Docker Hub.
• Create a multi-container application using Docker Compose.
• Containerize a simple web application (Node.js/Python/Nginx).
• Compare Docker vs AMIs for CI/CD usage and portability.

Date: Dec 06–Dec 17, 2025

🧩 Topics Covered

• Understood Docker architecture — Images, Containers, Layers, Docker Engine.
• Learned core Docker concepts: containerization, isolation, portability.
• Studied and implemented Dockerfile instructions (FROM, RUN, COPY, CMD, EXPOSE, ENV).
• Built custom Docker images for Node.js applications.
• Ran and managed containers using Docker CLI commands.
• Explored Docker Volumes for persistent data storage.
• Implemented PostgreSQL data persistence using Docker named volumes.
• Learned Docker Networking and container-to-container communication.
• Built a Multi-Container Todo Application using Node.js and MySQL.
• Introduced Docker Compose for defining and running multi-container applications.

📁 Assignments Completed:

• Created multiple Dockerfiles for Node.js applications.
• Built Docker images using docker build and ran containers using docker run.
• Exposed application ports and verified access via browser and terminal.
• Implemented Docker Volumes to persist database data.
• Verified PostgreSQL data persistence after container removal.
• Created a custom Docker network for container communication.
• Deployed a Node.js Todo App connected to a MySQL database container.
• Validated inter-container DNS resolution using Docker networking.
• Converted manual container setup into Docker Compose configuration.
• Managed multi-container services using a single docker compose up command.

🧠 My Learnings:

This week gave me a solid understanding of Docker and containerization. I learned how containers package applications with all their dependencies, ensuring consistency across development, testing, and production environments.

Dockerfiles helped me understand image layering and build optimization, while Docker volumes showed how containers remain stateless yet preserve critical data securely.

Building a real-world multi-container application using Node.js and MySQL gave me hands-on experience with microservice-style architecture. Docker Compose simplified orchestration and made the setup production-ready.

📚 Resources Used:

🎯 Next Week Goals:

• Understand CI/CD fundamentals and real-world DevOps pipelines.
• Learn and install Jenkins for continuous integration.
• Explore Jenkins architecture (Master, Agent, Jobs, Plugins).
• Install and configure Nexus Repository Manager.
• Understand Artifact Management using Nexus.
• Integrate Jenkins with Nexus for CI pipelines.
• Revise Docker Networking concepts for CI/CD use cases.

Date: Dec 18–Dec 25, 2025

🧩 Topics Covered

• Understood CI/CD fundamentals and its role in DevOps.
• Learned the difference between Continuous Integration, Continuous Delivery, and Continuous Deployment.
• Studied Build Tools & Package Managers (Maven, npm, Pip).
• Installed and configured Jenkins on Ubuntu.
• Explored Jenkins architecture — Controller, Agent, Jobs, Plugins.
• Created Freestyle Jenkins Jobs for build automation.
• Understood Jenkins workspace, build triggers, and build lifecycle.
• Installed and configured Nexus Repository Manager (Sonatype).
• Learned Artifact Repository concepts and versioning.
• Explored Docker Networking types — bridge, host, none, overlay, macvlan, ipvlan.
• Understood container-to-container communication using Docker networks.

📁 Assignments Completed:

• Installed Java (OpenJDK 17) as a prerequisite for Jenkins and Nexus.
• Installed and started Jenkins as a system service.
• Accessed Jenkins UI and completed initial admin setup.
• Created Jenkins jobs to automate build tasks.
• Installed Nexus Repository Manager on Ubuntu.
• Configured Nexus to run as a systemd service.
• Accessed Nexus UI and logged in using admin credentials.
• Understood hosted, proxy, and group repositories.
• Studied artifact storage and dependency management.
• Revised and practiced Docker network creation and inspection.

🧠 My Learnings:

This week helped me understand how DevOps teams automate the entire software delivery process using CI/CD pipelines. Jenkins gave me hands-on experience in automating builds and understanding how continuous integration works in real-world projects.

Learning Nexus clarified how organizations manage build artifacts securely and efficiently. I now understand why artifact repositories are critical for version control, dependency management, and stable deployments.

Revisiting Docker networking strengthened my understanding of how containers communicate in CI/CD environments, which is essential for microservices and automated pipelines.

📚 Resources Used:

🎯 Next Week Goals:

• Learn Jenkins Declarative Pipelines.
• Create end-to-end CI/CD pipelines.
• Integrate Git, Jenkins, Docker, and Nexus.
• Build Docker images inside Jenkins pipelines.
• Push artifacts and images to Nexus.
• Prepare for real-time DevOps project implementation.

Date: Dec 26, 2025 – Jan 3, 2026

🧩 Topics Covered

• Revised CI/CD pipeline concepts with real-world DevOps workflows.
• Learned Jenkins Declarative Pipeline syntax and structure.
• Understood Pipeline vs Freestyle Jobs.
• Created Jenkins Pipeline Jobs using Groovy-based declarative scripts.
• Integrated GitHub with Jenkins Pipelines.
• Installed and configured SonarQube Scanner in Jenkins.
• Configured SonarQube credentials and environment variables securely.
• Performed static code analysis using SonarQube in Jenkins pipeline.
• Understood SonarQube Quality Gates and quality metrics.
• Introduced to Infrastructure as Code (IaC) concepts.
• Overview of Ansible architecture (Control Node, Managed Nodes, Inventory).
• Introduction to Terraform basics and declarative infrastructure management.

📁 Assignments Completed:

• Created a Jenkins Declarative Pipeline job.
• Cloned source code from GitHub repository using pipeline.
• Configured SonarQube token in Jenkins Credentials Manager.
• Integrated SonarQube with Jenkins Pipeline.
• Executed SonarQube static code analysis through pipeline.
• Validated Quality Gate status from Jenkins console output.
• Viewed code quality metrics on SonarQube dashboard.
• Practiced secure credential handling in Jenkins.
• Studied Ansible use cases in configuration management.
• Understood Terraform workflow – init, plan, apply, destroy.

🧠 My Learnings:

This week gave me hands-on experience in building real CI pipelines using Jenkins Declarative Pipelines. Integrating SonarQube helped me understand how DevOps teams enforce code quality early in the development lifecycle.

I learned how quality gates act as checkpoints to prevent poor-quality code from moving forward in the pipeline, which is a critical DevOps best practice followed in production environments.

The introduction to Ansible and Terraform helped me understand how infrastructure and configuration can be automated using code, making deployments faster, consistent, and less error-prone.

📚 Resources Used:

🎯 Next Week Goals:

• Install and configure Ansible.
• Create Ansible inventory and playbooks.
• Automate server configuration using Ansible.
• Install and practice Terraform.
• Create infrastructure using Terraform configuration files.
• Understand real-time IaC and configuration management workflows.

Date: Jan 4, 2026 – Jan 13, 2026

🧩 Topics Covered

• Installed and configured Ansible on Ubuntu using official PPA.
• Understood Ansible architecture – Control Node, Managed Nodes, Inventory.
• Configured passwordless SSH authentication.
• Created and managed Ansible inventory files.
• Executed Ansible ad-hoc commands.
• Developed Ansible Playbooks using YAML.
• Automated Apache installation and deployment.
• Converted playbooks into Ansible Roles.
• Worked with Ansible variables and defaults.
• Automated AWS EC2 creation using Ansible.
• Installed and configured Terraform.
• Provisioned AWS EC2 instances using Terraform.
• Created AWS S3 buckets using Terraform.
• Implemented S3 versioning and bucket policies.

📁 Assignments Completed

• Installed and verified Ansible.
• Configured Ansible inventory and tested connectivity.
• Executed Ansible ad-hoc commands on multiple nodes.
• Created Ansible playbooks for Apache installation.
• Deployed web files using Ansible.
• Converted playbooks into Ansible Roles.
• Automated EC2 provisioning using Ansible AWS modules.
• Installed AWS CLI and configured credentials.
• Installed and verified Terraform.
• Provisioned EC2 instances using Terraform.
• Created S3 buckets using Terraform.
• Applied S3 bucket policies and versioning.

🧠 My Learnings

This week gave me strong hands-on experience in configuration management using Ansible. I learned how infrastructure automation helps maintain consistency, reliability, and scalability across servers.

Learning Ansible Roles helped me understand how real-world DevOps projects organize automation code for reuse and maintainability.

With Terraform, I gained practical exposure to Infrastructure as Code (IaC) by provisioning AWS EC2 instances and S3 buckets using declarative configuration files.

📚 Resources Used

📘 PDF 1: Ansible Installation & Configuration

📘 PDF 2: Ansible Playbooks, Roles & AWS Automation

📘 PDF 3: AWS Terraform – EC2 Infrastructure Automation

📘 PDF 4: Creating S3 Bucket with Policy using Terraform

🎯 Next Week Goals

• Integrate Ansible with Jenkins.
• Deploy applications using Ansible automation.
• Use Terraform modules.
• Manage Terraform remote state.
• Build a real-world DevOps project.

Date: Jan 14, 2026 – Jan 22, 2026

🧩 Topics Covered

• Understood Kubernetes architecture – Control Plane & Worker Nodes.
• Learned core components: API Server, Scheduler, Controller Manager, etcd.
• Explored Pods, Deployments, ReplicaSets, and Services.
• Worked with kubectl commands for cluster management.
• Deployed applications using YAML manifests.
• Learned Pod lifecycle and Pod phases.
• Implemented ConfigMaps for application configuration.
• Used Kubernetes Secrets to manage sensitive data securely.
• Worked with Persistent Volumes (PV) and Persistent Volume Claims (PVC).
• Mounted volumes inside Pods for persistent storage.
• Understood StatefulSets for stateful applications.
• Learned Ingress for external service access.
• Configured Liveness, Readiness, and Startup Probes.

📁 Assignments Completed

• Installed and verified Minikube and kubectl.
• Created and managed Pods and Deployments.
• Exposed applications using Kubernetes Services.
• Executed common kubectl commands for troubleshooting.
• Created YAML files for Pods, Deployments, and Services.
• Implemented ConfigMaps and injected them into Pods.
• Created and used Secrets via environment variables and files.
• Configured Persistent Volumes and PVCs.
• Mounted volumes into containers for data persistence.
• Deployed stateful applications using StatefulSets.
• Configured health probes for container monitoring.

🧠 My Learnings

This week helped me understand how Kubernetes orchestrates containerized applications using a declarative approach. I gained clarity on how the control plane manages workloads and maintains the desired state of applications.

Working with Pods, Deployments, and Services gave me hands-on experience in deploying and scaling applications reliably.

Learning Secrets, ConfigMaps, Persistent Volumes, and Probes helped me understand how real-world Kubernetes applications handle configuration, security, storage, and health monitoring.

📚 Resources Used

📘 PDF 1: Kubernetes Architecture & Core Concepts

📘 PDF 2: Kubernetes Commands & YAML Practice

📘 PDF 3: Secrets, Volumes & Probes in Kubernetes

🎯 Next Week Goals

• Learn Prometheus monitoring architecture.
• Set up Prometheus for Kubernetes metrics collection.
• Install and configure Grafana dashboards.
• Visualize Kubernetes cluster and pod metrics.
• Implement end-to-end monitoring for DevOps projects.

Date: Jan 23, 2026 – Jan 30, 2026

🧩 Topics Covered

• Understood Monitoring vs Observability concepts.
• Learned Prometheus architecture and working principles.
• Explored core components: Prometheus Server, Targets, Exporters, Alerting.
• Learned time-series data and metric collection.
• Worked with PromQL for querying metrics.
• Understood Node Exporter and Kubernetes metrics.
• Learned Grafana architecture and dashboard concepts.
• Configured Prometheus as a data source in Grafana.
• Explored Kubernetes cluster and pod-level metrics.
• Understood alerting basics using Prometheus.

📁 Assignments Completed

• Installed Prometheus using Helm on Minikube.
• Exposed Prometheus Server using NodePort.
• Installed Grafana using Helm in Kubernetes.
• Retrieved and configured Grafana admin credentials.
• Connected Prometheus as a data source in Grafana.
• Imported prebuilt Kubernetes dashboards.
• Visualized CPU, Memory, Pod, Node, and Cluster metrics.
• Validated end-to-end monitoring flow from metrics to dashboards.

🧠 My Learnings

This week helped me understand how monitoring is implemented in real-world Kubernetes environments using Prometheus and Grafana.

I learned how Prometheus collects, stores, and queries time-series metrics and how Grafana transforms raw metrics into meaningful visual dashboards.

Hands-on practice with Helm-based installation and dashboard visualization strengthened my understanding of production-level Kubernetes monitoring.

📚 Resources Used

📘 PDF 1: Prometheus & Grafana – Concepts & Observability

📘 PDF 2: Prometheus & Grafana on Minikube (Helm Setup)

📘 PDF 3: Prometheus & Grafana Installation on Linux

🎯 Next Week Goals

• Learn Alertmanager and alert routing.
• Configure custom Prometheus alerts.
• Explore logging with ELK / EFK stack.
• Understand end-to-end observability (Metrics, Logs, Traces).
• Integrate monitoring into a real DevOps project.