DEVOPS ESSENTIALS ASSIGNMENT
1. Apply Design Thinking process to a real-life problem: Empathize,
Define, Ideate, Prototype, and Test.
Problem Selected: Students forget assignment deadlines and face difficulty managing multiple
academic tasks.
Empathize:
In this stage, user problems are understood deeply. Students were observed and interviewed to
understand their daily struggles. Many students forget assignment submission dates because notices
are shared on different platforms such as WhatsApp, classroom announcements, and emails.
Students also feel stress when several assignments are due at the same time.
Define:
The problem statement was clearly defined as: “College students need a simple and organized way to
track assignments and receive reminders so they can submit work on time.”
Ideate:
Different solutions were discussed such as: Mobile reminder application Automatic notification system
Calendar integration Priority-based task manager Cloud synchronization The best idea selected was
a Student Assignment Reminder Application.
Prototype:
A simple application prototype was designed with: Student login system Add assignment feature
Deadline reminders Dashboard showing pending tasks Priority labels
Test:
The prototype was tested by students for one week. Feedback showed that reminders helped
students submit assignments on time. Improvements suggested included color-coded priorities and
daily summary notifications.
2. Compare and demonstrate Agile vs Waterfall through a mock
software development cycle.
Waterfall Model:
Waterfall is a traditional software development model where each phase is completed before moving
to the next phase. Requirement gathering Design Development Testing Deployment In a mock online
shopping website project, all requirements were finalized before development started. Changes
during development were difficult and expensive.
Advantages: Simple and structured process Easy documentation Suitable for small projects with
fixed requirements Disadvantages: Difficult to handle changing requirements Testing occurs late
Less customer involvement
Agile Model:
Agile is an iterative development approach where software is developed in small increments called
sprints. In the same online shopping project, features such as login, cart, and payment were
developed separately in short iterations.
Advantages: Continuous customer feedback Flexible development process Faster delivery of
features Disadvantages: Requires active communication Can be difficult for large fixed-budget
projects
Conclusion:
Agile is more flexible and suitable for modern software development, while Waterfall works better for
projects with stable requirements.
3. Simulate Scrum framework: Create a Scrum team, conduct sprint
planning, and track sprint progress.
Scrum Framework:
Scrum is an Agile framework used for team collaboration and iterative development.
Scrum Team Structure: Product Owner: Defines project requirements and priorities. Scrum
Master: Manages Scrum process and removes obstacles. Development Team: Builds and tests the
software.
Sprint Planning:
A two-week sprint was planned for developing a College Event Management System. Tasks
included: Create login module Develop event registration page Connect database Implement
notifications
Sprint Progress Tracking: Daily stand-up meetings were conducted. Task boards tracked progress.
Burndown charts measured remaining work. Issues were resolved during sprint reviews.
Result:
The team successfully completed the sprint and delivered the first working version of the system.
4. Set up Git and GitHub: Create repositories, practice branching,
merging, and pull requests.
Git: Git is a distributed version control system used to manage source code changes.
GitHub: GitHub is a cloud-based platform used to host Git repositories.
Setup Process: Install Git software. Create GitHub account. Create a new repository. Clone
repository to local system. Create branches for separate features. Merge changes after testing.
Create Pull Requests for review. Basic Git Commands:
git init
git clone <repository_url>
git branch feature-login
git checkout feature-login
git merge feature-login
git push origin main
5. Implement a Git workflow using feature branches and
collaborative team commits.
A Git workflow helps teams collaborate efficiently during software development.
Feature Branch Workflow: Main branch contains stable production-ready code. Developers create
separate feature branches. Changes are committed regularly. Pull requests are created before
merging. Code review ensures quality and reduces errors. Example Commands:
git checkout -b login-feature
git add .
git commit -m "Added login functionality"
git push origin login-feature
6. Install and configure Jenkins on a local machine or VM for CI
setup.
Jenkins: Jenkins is an open-source automation tool used for Continuous Integration and Continuous
Deployment.
Installation Steps: Install Java Development Kit (JDK). Download Jenkins from the official website.
Install Jenkins on Windows/Linux. Start Jenkins service. Access Jenkins using localhost:8080. Unlock
Jenkins using admin password. Install recommended plugins. Configuration: Create admin user
Configure build tools Connect Jenkins with GitHub
7. Create a basic CI pipeline in Jenkins that pulls code from Git and
builds the project.
A Continuous Integration pipeline automatically builds and tests code whenever changes are pushed
to the repository.
Pipeline Steps: Pull latest code from GitHub. Install dependencies. Build the application. Run
automated tests. Generate build reports. Sample Jenkinsfile:
pipeline {
agent any
stages {
stage('Clone') {
steps {
git '[Link]
}
}
stage('Build') {
steps {
echo 'Building Project'
}
}
}
}
8. Install Docker and run basic containers on a local development
environment.
Docker: Docker is a containerization platform used to package applications with their dependencies.
Installation Steps: Download Docker Desktop. Install Docker. Start Docker service. Verify
installation using terminal. Basic Commands:
docker --version
docker pull nginx
docker run -d -p 8080:80 nginx
docker ps
9. Write a Dockerfile and build a custom Docker image for a simple
application.
A Dockerfile contains instructions to build a custom Docker image.
[Link] Dockerfile Example:
FROM node:18
WORKDIR /app
COPY . .
RUN npm install
EXPOSE 3000
CMD ["npm","start"]
10. Use Docker Compose to simulate a multi-container environment.
Docker Compose is used to manage multiple containers together.
Example: Running a [Link] application with MongoDB database. [Link]:
version: '3'
services:
web:
build: .
ports:
- "3000:3000"
db:
image: mongo
11. Integrate Jenkins and Docker to automate builds and
containerization in a CI/CD workflow.
Jenkins and Docker together create a powerful CI/CD pipeline.
Workflow: Developer pushes code to GitHub. Jenkins detects changes automatically. Application is
built using Jenkins. Docker image is created. Container is deployed automatically. Benefits:
Automation Consistency Faster deployment Reduced manual errors
12. Install and configure Minikube or Docker Desktop with
Kubernetes support.
Kubernetes: Kubernetes is an orchestration platform used to manage containerized applications.
Setup Steps: Install Minikube or Docker Desktop. Install kubectl command-line tool. Start Kubernetes
cluster. Commands:
minikube start
kubectl get nodes
13. Deploy a containerized app on Kubernetes using YAML files.
Kubernetes uses YAML files to define application resources.
Components: Pod: Smallest deployable unit. Deployment: Manages replicas and updates.
Service: Exposes application to users. Deployment YAML Example:
apiVersion: apps/v1
kind: Deployment
metadata:
name: myapp
spec:
replicas: 2
selector:
matchLabels:
app: myapp
14. Perform rolling updates and scale replicas using Kubernetes
commands and configuration.
Kubernetes supports rolling updates and scaling to ensure high availability.
Scaling Replicas:
Scaling increases or decreases the number of application instances. Command:
kubectl scale deployment myapp --replicas=5
Rolling Update Command:
kubectl set image deployment/myapp myapp=myapp:v2
Advantages: No downtime during deployment Better performance handling High availability of
applications
Conclusion:
DevOps improves software development and deployment by combining development and operations
practices. Technologies such as Git, Jenkins, Docker, and Kubernetes automate workflows, increase
collaboration, and improve software quality. Modern organizations use DevOps methodologies to
achieve faster delivery, scalability, and reliability in software systems.