docs(2026): #90DaysOfDevOps Hands-On Practice Solutions & Runbooks - Rashid Khan

2026/day-01/introduction-to-devops.md

@@ -0,0 +1,14 @@
+# 🚀 Day 01 Task - Introduction to DevOps & Cloud Computing
+
+**Author:** Rashid Khan  
+**Batch:** #90DaysOfDevOps (2026)  
+
+---
+
+## 📌 Solution Overview
+DevOps is a set of practices, tools, and a cultural philosophy that automates and integrates the processes between software development and IT teams.
+
+### Key Learnings & Practical Applications:
+- **Development + Operations Integration:** Reducing delivery cycles and manual handoffs.
+- **CI/CD Pipeline Fundamentals:** Automating code testing and production deployments.
+- **Cloud Infrastructure Benefits:** On-demand resource provisioning, scalability, and high availability.

2026/day-02/linux-basic-commands.md

@@ -0,0 +1,12 @@
+# 🐧 Day 02 Task - Linux Architecture & Essential Commands
+
+**Author:** Rashid Khan  
+**Batch:** #90DaysOfDevOps (2026)  
+
+---
+
+## 📌 Essential Commands & Terminal Outputs
+- `pwd` — Print working directory (`/home/ubuntu/90DaysOfDevOpsChallengeRashidKhan`)
+- `ls -la` — List files with permissions, hidden items, and detailed metadata
+- `cd` & `mkdir` — Navigation and directory tree management
+- `uname -r` — View Linux Kernel Version

2026/day-03/linux-permissions-user-management.md

@@ -0,0 +1,11 @@
+# 🔐 Day 03 Task - Linux Permissions & User Management
+
+**Author:** Rashid Khan  
+**Batch:** #90DaysOfDevOps (2026)  
+
+---
+
+## 📌 Key Practices & Commands
+- **Ownership Management:** `sudo chown ubuntu:ubuntu filename`
+- **Permission Bit Configuration:** `chmod 755 filename` (`rwxr-xr-x`)
+- **User & Group Administration:** `sudo useradd` & `sudo usermod -aG sudo username`

2026/day-04/package-and-services-guide.md

@@ -0,0 +1,11 @@
+# 📦 Day 04 Task - Package Management & Systemctl Services
+
+**Author:** Rashid Khan  
+**Batch:** #90DaysOfDevOps (2026)  
+
+---
+
+## 📌 Key Operations
+- **Package Maintenance:** `sudo apt update && sudo apt upgrade -y`
+- **Systemd Service Inspection:** `sudo systemctl status nginx`
+- **Service Boot Enablement:** `sudo systemctl enable nginx`

2026/day-05/linux-troubleshooting-runbook.md

@@ -0,0 +1,68 @@
+# 🛠️ Linux Incident Troubleshooting & Triage Runbook
+
+**Author:** Rashid Khan  
+**Batch:** #90DaysOfDevOps (2026)  
+**Task:** Day 05 - Production System Diagnostics & Incident Mitigation  
+
+---
+
+## 📌 Incident Resolution Workflow
+
+Whenever a server issues an alert, I follow this 4-step triage methodology:
+1. **Resource Check:** Inspect RAM, CPU, and Disk space.
+2. **Process Check:** Identify high-resource or hung process IDs (PIDs).
+3. **Network Check:** Verify open ports and listening sockets.
+4. **Log Inspection:** Check systemd logs and restart failed services.
+
+---
+
+## 1. System Resource Diagnostics
+
+### A. Check RAM Usage
+```bash
+free -h -t
+```
+
+### B. Check Disk Space
+```bash
+df -h
+```
+
+### C. Check System Load
+```bash
+uptime
+```
+
+## 2. Process Identification & Management
+
+### A. Find Top CPU Consuming Processes
+```bash
+ps aux --sort=-%cpu | head -n 10
+```
+### B. Find Top RAM Consuming Processes
+```bash
+ps aux --sort=-%mem | head -n 10
+```
+### C. Kill Unresponsive Processes
+```bash
+pgrep -fl nginx
+kill 15 <PID>
+kill -9 <PID>
+```
+## 3. Network & Port Diagnostics
+
+### A. Check Open Listening Ports
+```bash
+sudo ss -tulpn | grep LISTEN
+```
+
+## 4. Service Lifecycle & Log Inspection
+
+### A. Check Service Status
+```bash
+sudo systemctl status nginx
+```
+### B. View Live Logs for Troubleshooting
+```bash
+sudo journalctl -u nginx -n 50 --no-pager
+```

2026/day-06/file-io-practice.md

@@ -0,0 +1,60 @@
+# 📝 Day 06 Task - Linux Fundamentals: Read and Write Text Files
+
+**Author:** Rashid Khan 
+**Batch:** #90DaysOfDevOps (2026)
+
+---
+
+## 📌 Overview
+File manipulation (creating, writing, appending, and inspecting) is a core foundational skill in DevOps. System configurations, deployment logs, and automation scripts are all plain text files. Mastering CLI file I/O operations enables faster debugging and seamless scripting.
+
+---
+
+## 🛠️ Step-by-Step Hands-on Execution & Output Log
+
+### 1. File Creation & Line Overwriting (`>`)
+Created an empty file `notes.txt` and initialized it with the first line using stdout redirection (`>`):
+```bash
+touch notes.txt
+echo "Line 1: Initializing Linux File I/O Practice" > notes.txt
+```
+
+### 2. Appending Lines (>>)
+Appended new log entries without overwriting existing file content using (`>>`):
+```bash
+echo "Line 2: Appending logs using standard redirection" >> notes.txt
+```
+
+### 3. Simultaneous Output & Append (tee -a)
+Used (`tee -a`) to append a new line to the file while simultaneously piping stdout to the terminal:
+```bash
+echo "Line 3: Writing and displaying live via tee" | tee -a notes.txt
+```
+#### Terminal Output:
+Line 3: Writing and displaying live via tee
+
+### 4. Reading Full File Content (cat)
+Inspected the complete contents of (`notes.txt`):
+```bash
+cat notes.txt
+```
+#### Terminal Output:
+Line 1: Initializing Linux File I/O Practice
+Line 2: Appending logs using standard redirection
+Line 3: Writing and displaying live via tee
+
+### 5. Inspecting File Parts (head & tail)
+Extracted specific top and bottom lines for quick log auditing:
+```bash
+# Read first 2 lines
+head -n 2 notes.txt
+
+# Read last 2 lines
+tail -n 2 notes.txt
+``` 
+#### Terminal Output (head -n 2):
+Line 1: Initializing Linux File I/O Practice
+Line 2: Appending logs using standard redirection
+#### Terminal Output (tail -n 2):
+Line 2: Appending logs using standard redirection
+Line 3: Writing and displaying live via tee

2026/day-06/notes.txt

@@ -0,0 +1,3 @@
+Line 1: Initializing Linux File I/O Practice
+Line 2: Appending logs using standard redirection
+Line 3: Writing and displaying live via tee

2026/day-07/backup.sh

@@ -0,0 +1,2 @@
+#!/bin/bash
+echo "Running Backup..."

2026/day-07/day-07-linux-fs-and-scenarios.md

@@ -0,0 +1,117 @@
+# Day 07 Task - Linux File System Hierarchy & Scenario-Based Practice
+
+**Author:** Rashid Khan 
+**Batch:** #90DaysOfDevOps (2026) 
+
+---
+
+## Part 1: Linux File System Hierarchy
+
+Understanding where system assets reside is critical for rapid incident diagnosis and system configuration.
+
+| Directory | Purpose & Contents | Command Example | Use Case |
+| :--- | :--- | :--- | :--- |
+| **`/` (root)** | Top-level starting point of the entire directory tree | `ls -l /` | Navigating overall file system structure. |
+| **`/home`** | Personal directories for regular users | `ls -la ~` | Storing user scripts, configs, and SSH keys. |
+| **`/root`** | Home directory for the administrative superuser | `sudo ls -l /root` | Administrative maintenance and root-specific operations. |
+| **`/etc`** | System-wide configuration files and startup scripts | `cat /etc/hostname` | Modifying network, system, or application settings. |
+| **`/var/log`** | Variable data files, specifically application & system logs | `du -sh /var/log/* 2>/dev/null \| sort -h \| tail -5` | Debugging service failures and auditing logs. |
+| **`/tmp`** | Temporary files created by system and programs | `ls -l /tmp` | Inspecting transient runtime data (cleared on reboot). |
+| **`/bin`** | Essential user command binaries | `ls /bin` | Running single-user mode recovery utilities (`ls`, `cat`). |
+| **`/usr/bin`** | Primary directory for user executable commands | `ls /usr/bin` | Standard CLI application execution. |
+| **`/opt`** | Subdirectory for add-on/third-party application software packages | `ls /opt` | Installing standalone enterprise software (e.g., custom agents). |
+
+---
+
+## Part 2: Scenario-Based Troubleshooting Practice
+
+### Scenario 1: Service Not Starting (`myapp`)
+**Problem:** A web application service called `myapp` failed to start after a server reboot.
+
+ **Step 1:** Check current service status.
+  ```bash
+  systemctl status myapp
+  ```
+  Why: Identifies whether the service is inactive, active, or in a failed state.
+
+**Step 2:** Inspect failure logs in systemd journal.
+  ```bash
+  journalctl -u myapp -n 50
+  ```
+  Why: Extracts the last 50 log lines to pinpoint stdout/stderr runtime errors.
+
+**Step 3:** Verify if the service is configured to auto-start on boot.
+  ```bash
+   systemctl is-enabled myapp
+  ```
+  Why: Determines if the unit file is missing boot-time enablement.
+
+**Step 4:** List all active services if myapp is missing.
+  ```bash
+   systemctl list-units --type=service
+  ```
+  Why: Confirms exact service naming syntax installed on the host.
+
+### Scenario 2: High CPU Usage Investigation
+**Problem:** Server response latency is high due to CPU saturation.
+
+ **Step 1:** Inspect top CPU-consuming processes interactively.
+   ```bash
+    top
+   ```
+  Why: Displays real-time live resource usage breakdown sorted by %CPU.
+
+ **Step 2:** Get a top-10 snapshot sorted by CPU usage.
+   ```bash
+    ps aux --sort=-%cpu | head -10
+   ```
+  Why: Instantly lists process owner, PID, CPU percentage, and exact executing command line.
+
+### Scenario 3: Finding & Tailing Service Logs (`docker`)
+**Problem:** Developer requests real-time log monitoring for the docker service.
+
+ **Step 1:** Verify active Docker service status.
+   ```bash
+    systemctl status docker
+   ```
+  Why: Ensures the docker daemon is active before inspecting logs.
+
+ **Step 2:** Inspect recent Docker logs.
+   ```bash
+    journalctl -u docker -n 50
+   ```
+  Why: Reviews recent startup and operational logs.
+
+ **Step 3:** Stream live Docker logs continuously.
+   ```bash
+    journalctl -u docker -f
+   ```
+  Why: Follows real-time log streams for active debugging.
+
+### Scenario 4: Fixing Script Execution Permission (`backup.sh`)
+**Problem:** Executing /home/user/backup.sh throws Permission denied.
+ **Step 1:** Check current file permissions.
+  ```bash
+   ls -l /home/user/backup.sh
+  ```
+  Output: -rw-r--r-- (Missing execute x permissions).
+
+ **Step 2:** Add execute permission for the file owner/group.
+  ```bash
+   chmod +x /home/user/backup.sh
+  ```
+  Why: Grants binary execution privileges.
+
+ **Step 3:** Verify permission change.
+  ```bash
+   ls -l /home/user/backup.sh
+  ```
+  Output: -rwxr-xr-x (Execute permission granted).
+
+ **Step 4:** Execute the backup script.
+  ```bash
+   ./backup.sh
+  ```
+
+
+

2026/day-08/day-08-cloud-deployment.md

@@ -0,0 +1,74 @@
+# Day 08 – Cloud Server Setup: Docker, Nginx & Web Deployment
+
+## Overview
+Today's task focused on launching an AWS EC2 instance, establishing remote SSH communication, installing Nginx and Docker, configuring AWS Security Groups for HTTP Port 80 and Custom TCP Port 8080 access, and extracting access logs for audit.
+
+---
+
+## Step-by-Step Execution & Screenshots
+
+### 1. Cloud Instance Access & System Setup
+Establish secure remote connection using SSH:
+```bash
+chmod 400 devopsrashid.pem
+ssh -i devopsrashid.pem ubuntu@<YOUR_EC2_PUBLIC_IP>
+```
+![SSH Connection Terminal](ssh-connection.png)
+
+Update system package indexes:
+```bash
+sudo apt update && sudo apt upgrade -y
+```
+
+### 2. Nginx & Docker Setup
+Install Nginx web server:
+```bash
+sudo apt install nginx -y
+sudo systemctl status nginx
+```
+
+Install Docker engine and run an isolated Nginx container on port 8080:
+```bash
+sudo apt install docker.io -y
+sudo systemctl enable --now docker
+sudo usermod -aG docker $USER
+sudo docker run -d -p 8080:80 --name docker-nginx-test nginx
+```
+
+Verify active container status:
+```bash
+sudo docker ps
+```
+![Docker Nginx Container Running](docker-nginx.png)
+
+### 3. Inbound Web Verification
+Configured AWS Security Group inbound rules for HTTP (Port 80). Verified web accessibility via browser:
+![Nginx Welcome Webpage](nginx-webpage.png)
+
+### 4. Log Extraction & Local SCP Transfer
+Export active access logs and transfer to local machine for audit:
+```bash
+sudo tail -n 50 /var/log/nginx/access.log > ~/nginx-logs.txt
+scp -i ~/Downloads/devopsrashid.pem ubuntu@<YOUR_EC2_PUBLIC_IP>:~/nginx-logs.txt ~/Downloads/
+```
+
+## Challenges Faced & Solutions
+**Challenge:** Nginx installed and running successfully, but the web page was timing out on the browser using EC2 
+Public IP
+
+**Root Cause:** AWS Security Group inbound firewall rules only permitted SSH traffic on Port 22 by default.
+
+**Solution:** Navigated to AWS EC2 Security Groups -> Inbound Rules, added HTTP (Port 80) and Custom TCP (Port 8080)
+from 0.0.0.0/0.
+
+## What I Learned
+**Cloud Provisioning:** Creating, managing, and connecting to AWS EC2 instances securely via SSH.
+
+**Network Security:** Configuring Security Groups to allow specific inbound web traffic.
+
+**Application Deployment:** Running web servers via native Linux services as well as isolated Docker containers.
+
+**Log Auditing:** Isolating log entries from /var/log/nginx/access.log and pulling them locally using scp.
+
+
+

2026/day-08/nginx-logs.txt

@@ -0,0 +1,5 @@
+43.248.243.0 - - [12/Aug/2026:22:28:54 +0000] "GET / HTTP/1.1" 200 409 "-" "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/27.0 Safari/605.1.15"
+43.248.243.0 - - [12/Aug/2026:22:28:55 +0000] "GET /favicon.ico HTTP/1.1" 404 134 "http://100.53.20.2/" "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/27.0 Safari/605.1.15"
+146.190.169.94 - - [12/Aug/2026:22:35:24 +0000] "GET / HTTP/1.1" 200 409 "-" "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
+205.210.31.242 - - [12/Aug/2026:22:46:58 +0000] "GET / HTTP/1.0" 200 615 "-" "Hello from Palo Alto Networks, find out more about our scans in https://docs-cortex.paloaltonetworks.com/r/1/Cortex-Xpanse/Scanning-activity"
+::1 - - [12/Aug/2026:23:32:42 +0000] "GET / HTTP/1.1" 200 615 "-" "curl/8.18.0"