DevOps Learning Tool (Prototype)

This is a lightweight prototype for a web-based tool to support project-based learning (PBL) in DevOps. The goal is to simulate key stages of the DevOps lifecycle so students can learn containerization, CI/CD pipelines, deployment, and debugging in a guided, interactive way.

Current Status

Implemented:

Backend services:

• API Gateway – entry point, routes student actions to backend services.
• Pipeline Service – handles build and deployment triggers (simulation or real mode)
• Event Bus - lightweight in-process async event broker.
• Competency Service - records student progress based on events

Frontend:

• Student UI – guided Dockerfile and manifest writing, trigger builds, view events, inspect logs, deploy, see competency progress

• Instructor UI – select students and view their progress.

• Demo repository

• backend/pipeline-service/demo-repo for practicing containerization and debugging.

Planned for next iterations:

• Additional error scenarios and guided debugging exercises.
• More complex Kubernetes monitoring integration.
• Instructor tools for task assignment and assessment.
• More complex linting of Dockerfiles and manifests
• Introduction to key DevOps tools, e.g., IaC tool Terraform

Requirements

• Node.js >=20.19.0 (recommended: Node.js 24.x)
• npm >=10.x (installed with Node.js)
• Docker (required for builds)
• kind or minikube (for real Kubernetes mode)

Project Structure

  devops-learning-tool/
│
├── backend/
│   ├── api-gateway/        # Forwards requests to backend services
│   ├── pipeline-service/   # Stub service for triggering builds
│   │   ├── demo-repo/      # Example student application 
│   │   └── k8s/            # Kubernetes manifests
│   ├── event-bus/          # Broadcasts events between services
│   └── competency-service/ # Tracks student progress
│
├── frontend/
│   └── student-ui/         # Simple React + Vite student interface
│   └── instructor-ui/      # React + Vite instructor dashboard
│
├── docs/                   # Architecture and scenario docs
├── README.md
├── start-tool.ps1
└── start-tool.sh

How to run the prototype

1. Clone the repository:

git clone https://github.com/opourazar/devops-learning-tool.git
cd devops-learning-tool

2. Start the tool (cross-platform scripts)

# Linux / macOS
./ sh start-tool.sh

# Windows PowerShell
.\start-tool.ps1

Working Modes

Simulation mode

• Default mode after startup
• Guided Dockerfile and manifests writing and validation
• Simulates build, and cleanup processes
• Great for beginners to get know the DevOps pipeline flow

Real mode:

• Enables actual Docker builds and Kubernetes deployments
• Requires a Docker-based cluster (see below)

Setup for Real Mode Choose one of the following local Kubernetes setups:

Option 1: kind (Kubernetes in Docker)

  kind create cluster --name devops-learning

Option 2: minikube

  minikube start --driver=docker

Docker Desktop users: Ensure the Kubernetes option is enabled under Settings → Kubernetes.

Once your cluster is ready, start the tool and set the chosen Deploy mode to your option.

The current setup involves opening the services in several terminals to allow a look at how communication is handled backstage.

3. Access the UIs:

• Student UI → http://localhost:5173
• Instructor UI → http://localhost:5174 (default Vite port may vary)

4. Try it out:

• In the Student UI, click Trigger Build.
• Watch the events update in real-time.
• If the build fails (e.g., broken Dockerfile), click View Log in Events section to debug.
• Check Competency progress tracked by the backend.
• Open the Instructor UI to select students and see progress.

Note: This is a prototype meant to illustrate architecture, interactions, and learning concepts.

Stopping the Tool

To stop the tool you have to close the terminals manually. (This will be soon automated with an upcoming solution.)

Learning Scenarios

The tool is designed around guided, project-based learning scenarios (e.g., build and debug Docker images, writing and anaylzing Dockerfiles and manifest, and monitoring deployments).
For a full overview of currently implemented and planned scenarios, see: Scenarios

Architecture

The tool is structured as a set of lightweight services connected via an Event Bus and exposed through UIs.
For a detailed architecture overview, see: Architecture