Unit 4: DevOps & Software Engineering

Opening Hook — The Invisible Engine Behind Flipkart Big Billion Days

Learning Outcomes — Bloom's Taxonomy Mapped

Concept Explanation — DevOps & Software Engineering from Scratch

1. What is DevOps? The CALMS Framework

Imagine you're running a restaurant. The chefs (developers) cook amazing dishes, but the waiters (operations) struggle to serve them fast enough. Dishes pile up, customers complain, orders get mixed up. DevOps is like making chefs and waiters work as one team — the chef plates the dish exactly how the waiter needs it, the waiter gives real-time feedback on what customers want, and together they serve 10× faster.

2. DevOps vs Waterfall vs Agile — Comparison

Before DevOps, software was built using older methodologies. Understanding their differences is crucial for interviews and real-world decisions.

3. CI/CD Pipeline — The Assembly Line of Software

Analogy: Think of a Maruti Suzuki car factory. Raw materials enter one end, and finished cars roll out the other end — automatically. Every step (welding, painting, quality check) is automated and quality-checked. A CI/CD pipeline does the same for software.

CI/CD Pipeline — Visual Flow (ASCII Diagram)

Pipeline
┌─────────┐    ┌─────────┐    ┌──────────┐    ┌──────────┐    ┌───────────┐    ┌────────────┐
│  CODE   │───▶│  BUILD  │───▶│   TEST   │───▶│ PACKAGE  │───▶│  DEPLOY   │───▶│  MONITOR   │
│ (Git)   │    │(Compile)│    │(Selenium)│    │ (Docker) │    │(K8s/Cloud)│    │ (Nagios)   │
└─────────┘    └─────────┘    └──────────┘    └──────────┘    └───────────┘    └────────────┘
     │              │               │               │               │               │
  Developer      Maven/         Unit Tests      Docker           Kubernetes     Dashboards
  pushes to     Gradle          Integration     Image            Pods scale     Alerts on
  GitHub        builds JAR      Selenium        Registry         up/down        failure

4. Git — Version Control That Every Developer Must Know

Analogy: Imagine writing an essay in Google Docs. You can see every version, undo changes, and multiple people can edit simultaneously without overwriting each other's work. Git does this for code — but with superpowers. It's the backbone of every software project on the planet.

Core Git Commands — With Examples

Bash
# 1. Initialize a new Git repository
git init my-project
cd my-project

# 2. Check status — see what's changed
git status

# 3. Create a file and stage it
echo "# My First Project" > README.md
git add README.md          # Stage single file
git add .                  # Stage ALL changes

# 4. Commit with a meaningful message
git commit -m "feat: add project README with description"

# 5. Connect to GitHub and push
git remote add origin https://github.com/yourusername/my-project.git
git push -u origin main

# 6. Pull latest changes from team
git pull origin main

Branching & Merging — The Power of Git

Bash
# Create a new branch for a feature
git branch feature/login-page
git checkout feature/login-page
# Or shortcut: git checkout -b feature/login-page

# Make changes, commit them
git add .
git commit -m "feat: add login page UI with validation"

# Switch back to main and merge
git checkout main
git merge feature/login-page

# Rebase (alternative to merge — cleaner history)
git checkout feature/login-page
git rebase main
# Rebase replays your commits ON TOP of main — linear history

Git Terminology Quick Reference

5. GitHub — The Social Network for Developers

Git is the version control tool. GitHub is the platform that hosts Git repositories online, adds collaboration features, and acts as your developer portfolio. Think of Git as the engine and GitHub as the car.

Key GitHub Features

Professional README.md Template

Markdown
# 🚀 Project Name

## 📋 About
A brief description of what this project does and who it's for.

## ✨ Features
- Feature 1: User authentication with JWT
- Feature 2: Dashboard with real-time charts
- Feature 3: REST API with Express.js

## 🛠️ Tech Stack
- **Frontend:** React, Tailwind CSS
- **Backend:** Node.js, Express
- **Database:** MongoDB
- **CI/CD:** GitHub Actions
- **Deployment:** Docker + AWS

## 🚀 Getting Started
```bash
git clone https://github.com/yourusername/project.git
cd project
npm install
npm run dev
```

## 📸 Screenshots
![Dashboard](screenshots/dashboard.png)

## 👤 Author
**Your Name** — [LinkedIn](https://linkedin.com/in/yourname)

## 📄 License
MIT License

6. Docker — Containerisation for Consistent Deployments

The Problem: "It works on my machine!" — the most dreaded phrase in software development. Your code runs perfectly on your laptop but crashes on the server because of different OS versions, library versions, or configurations.

The Solution: Docker packages your application along with ALL its dependencies (libraries, OS, config files) into a container — a lightweight, portable box that runs the same everywhere.

Dockerfile Example — Python Flask App

Dockerfile
# Step 1: Start from a Python base image
FROM python:3.11-slim

# Step 2: Set working directory inside container
WORKDIR /app

# Step 3: Copy requirements and install dependencies
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Step 4: Copy application code
COPY . .

# Step 5: Expose the port Flask runs on
EXPOSE 5000

# Step 6: Command to run the application
CMD ["python", "app.py"]

Docker Commands Cheat Sheet

Bash
# Build an image from Dockerfile
docker build -t my-flask-app .

# Run a container from the image
docker run -d -p 5000:5000 my-flask-app

# List running containers
docker ps

# Stop a container
docker stop <container_id>

# Push image to Docker Hub
docker tag my-flask-app yourusername/my-flask-app:v1
docker push yourusername/my-flask-app:v1

docker-compose.yml — Multi-Container Example

YAML
# Run a Flask app + PostgreSQL database together
version: "3.8"
services:
  web:
    build: .
    ports:
      - "5000:5000"
    depends_on:
      - db
    environment:
      - DATABASE_URL=postgresql://user:pass@db:5432/mydb

  db:
    image: postgres:15
    environment:
      - POSTGRES_USER=user
      - POSTGRES_PASSWORD=pass
      - POSTGRES_DB=mydb
    volumes:
      - pgdata:/var/lib/postgresql/data

volumes:
  pgdata:

7. Selenium — Automated Web Testing

Analogy: Imagine hiring 100 people to click every button on your website, fill every form, and check every page — every single day. That's what Selenium does, but with code instead of people, running in seconds instead of hours.

Definition: Selenium is an open-source framework for automating web browser interactions. It's used for testing web applications — verifying that buttons work, forms submit correctly, pages load properly, and data displays accurately.

Selenium with Python — Test Cases

Python
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys
import time

# Initialize Chrome browser
driver = webdriver.Chrome()

# TEST 1: Open a website and verify title
driver.get("https://www.flipkart.com")
assert "Flipkart" in driver.title, "Title verification FAILED!"
print("✅ Test 1 PASSED: Flipkart homepage loaded")

# TEST 2: Search for a product
search_box = driver.find_element(By.NAME, "q")
search_box.send_keys("laptop")
search_box.send_keys(Keys.RETURN)
time.sleep(3)
assert "laptop" in driver.page_source.lower(), "Search FAILED!"
print("✅ Test 2 PASSED: Search results displayed")

# TEST 3: Check if search results contain product cards
products = driver.find_elements(By.CLASS_NAME, "_1fQZEK")
assert len(products) > 0, "No products found!"
print(f"✅ Test 3 PASSED: Found {len(products)} products")

# TEST 4: Verify a specific element exists
try:
    logo = driver.find_element(By.CSS_SELECTOR, "img[title='Flipkart']")
    print("✅ Test 4 PASSED: Flipkart logo found")
except:
    print("❌ Test 4 FAILED: Logo not found")

# TEST 5: Check page loads within acceptable time
start = time.time()
driver.get("https://www.flipkart.com")
load_time = time.time() - start
assert load_time < 10, f"Page took {load_time}s — too slow!"
print(f"✅ Test 5 PASSED: Page loaded in {load_time:.2f}s")

driver.quit()

8. Maven — Build Automation for Java Projects

Analogy: Building a Java project manually is like cooking without a recipe — you have to remember every ingredient (library), every step (compile, test, package), and every dependency. Maven is your automated recipe manager — it downloads libraries, compiles code, runs tests, and packages everything into a deployable file, all with one command.

Sample POM.xml

XML
<project>
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.eduartha</groupId>
  <artifactId>student-portal</artifactId>
  <version>1.0.0</version>

  <dependencies>
    <!-- JUnit 5 for testing -->
    <dependency>
      <groupId>org.junit.jupiter</groupId>
      <artifactId>junit-jupiter</artifactId>
      <version>5.10.0</version>
      <scope>test</scope>
    </dependency>

    <!-- Spring Boot for web app -->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
      <version>3.2.0</version>
    </dependency>
  </dependencies>
</project>

Bash
# Build with Maven — one command does everything
mvn clean package

# Output:
# [INFO] Compiling 15 source files...
# [INFO] Running 42 test cases...
# [INFO] Tests passed: 42, Failed: 0
# [INFO] Building JAR: target/student-portal-1.0.0.jar
# [INFO] BUILD SUCCESS

9. Infrastructure as Code — Puppet & Ansible

The Problem: You have 500 servers to manage. Each needs the same software installed, same configurations, same security patches. Doing this manually would take weeks and be error-prone. Infrastructure as Code (IaC) treats your server setup as code — version-controlled, repeatable, and automated.

Ansible Playbook Example

YAML
# Install Nginx web server on 50 servers simultaneously
- name: Setup Web Servers
  hosts: webservers
  become: yes

  tasks:
    - name: Install Nginx
      apt:
        name: nginx
        state: present

    - name: Start Nginx service
      service:
        name: nginx
        state: started
        enabled: yes

    - name: Copy website files
      copy:
        src: ./website/
        dest: /var/www/html/

Bash
# Run the playbook — configures ALL 50 servers
ansible-playbook -i inventory.ini setup-web.yml

# Output:
# PLAY [Setup Web Servers] ****
# TASK [Install Nginx] ****
# ok: [server01] => changed
# ok: [server02] => changed
# ... (50 servers configured in 2 minutes)

10. Kubernetes (K8s) — Container Orchestration at Scale

Analogy: Docker creates containers (individual dabbas/tiffin boxes). But during Flipkart's Big Billion Days, you need to manage 10,000 dabbas — deciding which ones to send where, replacing broken ones, adding more during rush hour, and removing extras when demand drops. Kubernetes is the dabba distribution manager.

Kubernetes Deployment YAML

YAML
# Deploy 3 replicas of a Flask app
apiVersion: apps/v1
kind: Deployment
metadata:
  name: flask-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: flask-app
  template:
    metadata:
      labels:
        app: flask-app
    spec:
      containers:
        - name: flask
          image: yourusername/flask-app:v1
          ports:
            - containerPort: 5000
---
apiVersion: v1
kind: Service
metadata:
  name: flask-service
spec:
  type: LoadBalancer
  selector:
    app: flask-app
  ports:
    - port: 80
      targetPort: 5000

11. Nagios — Monitoring & Alerting

Analogy: Nagios is like a 24/7 security guard for your servers. It constantly checks: Is the website up? Is the CPU overloaded? Is disk space running out? Is the database responding? If anything goes wrong, it immediately sends alerts via email, SMS, or Slack.

12. Software Testing — Types, Levels & Objectives

Testing ensures software works correctly before reaching users. Without testing, Flipkart's app might crash during payment, IRCTC might book wrong tickets, and Paytm might transfer money to wrong accounts.

Objectives of Software Testing

• Find defects before users do — cheaper to fix bugs early
• Ensure quality — software meets requirements and specifications
• Build confidence — stakeholders trust the software works
• Prevent regression — new changes don't break existing features
• Validate performance — software handles expected load

Types of Testing — Comprehensive Table

Testing Levels (V-Model)

Diagram
   Requirements ─────────────────────── Acceptance Testing
        │                                        │
   System Design ──────────────────── System Testing
        │                                        │
   Module Design ──────────────────── Integration Testing
        │                                        │
   Coding ─────────────────────────── Unit Testing

13. DevOps in Indian Companies

14. Career Paths in DevOps & Software Engineering

Learn by Doing — 3-Tier Lab Structure

Bash
git --version
# Output: git version 2.43.0.windows.1

# Configure your identity (one-time setup)
git config --global user.name "Your Name"
git config --global user.email "your.email@college.ac.in"

Bash
# Create project folder
mkdir my-portfolio
cd my-portfolio

# Initialize Git
git init
# Output: Initialized empty Git repository in /my-portfolio/.git/

Markdown
# 🎓 My Developer Portfolio

## About Me
I am a BCA student passionate about DevOps and Software Engineering.
Currently learning Git, Docker, and CI/CD pipelines.

## 🛠️ Skills
- **Version Control:** Git, GitHub
- **Containerisation:** Docker (learning)
- **CI/CD:** GitHub Actions
- **Languages:** Python, JavaScript

## 📂 Projects
| # | Project | Tech Stack | Status |
|---|---------|------------|--------|
| 1 | Portfolio Website | HTML, CSS, JS | ✅ Complete |
| 2 | Todo API | Python, Flask | 🔄 In Progress |
| 3 | CI/CD Pipeline Demo | GitHub Actions | 📋 Planned |

## 📫 Contact
- Email: yourname@college.ac.in
- LinkedIn: [Your Profile](https://linkedin.com/in/yourname)

## 📊 GitHub Stats
![GitHub Stats](https://github-readme-stats.vercel.app/api?username=yourusername)

Bash
# Stage all files
git add .

# Commit with a meaningful message
git commit -m "feat: initial commit with professional README"

# Create repository on GitHub (via browser):
# Go to github.com → "+" → "New repository"
# Name: my-portfolio | Public | Don't add README (we already have one)

# Connect local repo to GitHub
git remote add origin https://github.com/yourusername/my-portfolio.git
git branch -M main
git push -u origin main

gitignore
# Python
__pycache__/
*.pyc
.env
venv/

# IDE
.vscode/
.idea/

# OS
.DS_Store
Thumbs.db

# Dependencies
node_modules/

Bash
git add .gitignore
git commit -m "chore: add .gitignore for Python and IDE files"
git push

Bash
# Install Selenium
pip install selenium webdriver-manager

Text
my-cicd-project/
├── .github/
│   └── workflows/
│       └── ci.yml          ← GitHub Actions workflow
├── app/
│   ├── __init__.py
│   └── calculator.py       ← Simple app with functions
├── tests/
│   ├── __init__.py
│   └── test_calculator.py  ← Unit tests
├── requirements.txt
├── README.md
└── .gitignore

YAML
# .github/workflows/ci.yml
name: CI Pipeline

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  test:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v4

      - name: Set up Python
        uses: actions/setup-python@v5
        with:
          python-version: "3.11"

      - name: Install dependencies
        run: |
          python -m pip install --upgrade pip
          pip install -r requirements.txt

      - name: Run linting
        run: |
          pip install flake8
          flake8 app/ --max-line-length=120

      - name: Run tests with coverage
        run: |
          pip install pytest pytest-cov
          pytest tests/ --cov=app --cov-report=term-missing

Industry Spotlight — A Day in the Life

Earn With It — Freelance & Income Roadmap

⏱️ Time to First Earning: 3–4 weeks (if you complete all 3 labs and offer GitHub setup services to 10 classmates/startups)

MCQ Assessment Bank — 30 Questions (Bloom's Mapped)

Remember / Identify (Q1–Q5)

Understand / Explain (Q6–Q10)

Apply / Implement (Q11–Q15)

Analyze / Compare (Q16–Q20)

Evaluate / Judge (Q21–Q25)

Create / Design (Q26–Q30)

Short Answer Questions (5 Questions)

Case Studies

Chapter Summary

Earning Checkpoint — Are You Portfolio-Ready?

✅ Unit 4 complete. Ready for Unit 5: Cloud Computing!

[QR: Link to EduArtha video tutorial — DevOps & Software Engineering]