ChaosLab — Break Your System Platform

ChaosLab is a production-like DevOps portfolio project for simulating failures and observing system behavior.

Goal

Build a cloud-native system that can simulate controlled failures such as:

• Killing services
• Slowing API responses
• Triggering backend errors
• Observing recovery behavior

Current Status

Phase 8 — Frontend Demo UI / Chaos Visualization - ❗ In Progress

Make backend health, chaos state, request results, metrics, and recent events visible in the frontend dashboard.

• Backend health status card
• Chaos state display and controls
• Request history panel
• Metrics panel
• Event timeline

Outcome: Interactive dashboard for observing and controlling chaos in real time

Tech Stack

• Frontend: React + Vite
• Backend: Node.js + Express
• Database: MongoDB
• Containers: Docker & Docker Compose
• Orchestration: Kubernetes / Minikube
• Monitoring: Prometheus + Grafana
• CI/CD: GitHub Actions

Quick Start (Local Development)

1. Clone the repository

git clone <your-repo-url>
cd chaoslab

2. Run Backend

cd backend
npm install
npm run dev

3. Run Frontend

cd frontend
npm install
npm run dev

4. Access the Application

• Frontend: http://localhost:5173
• Backend API: http://localhost:3000

Docker Development

ChaosLab can also be run with Docker Compose.

docker compose up --build

See the full Docker guide: docs/DOCKER.md

Project Structure

chaoslab/
├── frontend/
├── backend/
├── infrastructure/
│   ├── docker/
│   ├── kubernetes/
│   ├── monitoring/
│   └── aws/
├── docs/
└── .github/workflows/

Project Phases

Phase 1 — Project Setup ✅ Completed

Establish the foundation of the system.

• Create repository and structure
• Initialize frontend (React + Vite) and backend (Node.js + Express)
• Define basic API endpoints
• Set up local development environment

Outcome: Runnable app locally (without containers)

---

Phase 2 — Containerization (Docker) ✅ Completed

Containerize the application to ensure consistency across environments.

• Write Dockerfiles for frontend and backend
• Create docker-compose setup
• Run multi-container app (frontend + backend + MongoDB)
• Handle environment variables

Outcome: Entire system runs with one command (docker compose up)

---

Phase 3 — Kubernetes (Local - Minikube) ✅ Completed

Move from simple containers to orchestration.

• Create Kubernetes manifests (Deployments, Services)
• Deploy app to Minikube
• Expose services
• Scale services manually

Outcome: Application running in a Kubernetes cluster locally

---

Phase 4 — Chaos Engineering Features ✅ Completed

Introduce controlled failure scenarios.

• Endpoint to simulate latency
• Endpoint to crash services
• Random failure injection
• Toggle chaos on/off

Outcome: System can intentionally break itself

---

Phase 5 — Monitoring & Observability ✅ Completed

Understand system behavior under stress.

• Install Prometheus
• Set up metrics collection
• Deploy Grafana dashboards
• Visualize system health and failures

Outcome: Real-time observability of failures and recovery

---

Phase 6 — CI/CD Pipeline ✅ Completed

Automate build, test, and deployment workflows.

• GitHub Actions setup
• Build Docker images automatically
• Run basic tests
• Push images to registry (Docker Hub)

Outcome: Automated pipeline triggered on every push

---

Phase 7 — AWS Deployment ⏸️ Deferred

Deploy the system to the cloud.

• Use AWS (EKS or simpler alternative)
• Deploy application to cloud Kubernetes cluster
• Configure networking and access
• (Optional) Use Terraform for infrastructure

Outcome: Publicly accessible cloud deployment

---

Phase 8 — Frontend Demo UI / Chaos Visualization ❗ In Progress

Make backend health, chaos state, request results, metrics, and recent events visible in the frontend dashboard.

• Backend health status card
• Chaos state display and controls
• Request history panel
• Metrics panel
• Event timeline

Outcome: Interactive dashboard for observing and controlling chaos in real time