How londheshubham153/wanderlust-mega-project works
Project type and purpose
• This is a full‑stack, three‑tier MERN travel blog application (“Wanderlust”) that uses React/Vite for the frontend, Node/Express for the backend API, MongoDB for persistence and Redis for caching.
• It’s delivered via a GitOps CI/CD pipeline on AWS EKS (Kubernetes), with infrastructure managed via Terraform and Helm, and monitored by Prometheus/Grafana.
File structure
• Top‑level folders:
– frontend: React/TypeScript + Vite + Tailwind CSS, unit/integration tests, Dockerfile, Vercel config
– backend: Node/Express REST API, controllers/models/services, Redis integration, Dockerfile, tests
– database: Dockerfile for MongoDB
– kubernetes: YAMLs for frontend, backend, MongoDB, Redis, PV/PVC
– terraform: EC2 and EKS setup
– GitOps & Automations: Jenkinsfile, update scripts
• Jenkins CI/CD lives in GitOps, Terraform provisions AWS, k8s manifests describe runtime.
README insights
• CI uses Jenkins Master & Agents to build Docker images, run OWASP/Trivy/SonarQube scans, push to registry
• CD is driven by ArgoCD watching the GitOps repo and deploying to EKS
• Monitoring via Helm‑deployed Prometheus/Grafana in the cluster
Main components
a. User / Browser (client)
b. Frontend service (React/Vite app served via Node or static files)
c. Backend API (Node/Express)
d. Data layer: MongoDB (persistent storage) and Redis (cache)
e. CI pipeline: Jenkins Master, Jenkins Agents
f. Container registry (Docker Hub or AWS ECR)
g. Git repository (GitHub)
h. CD/GitOps tool: ArgoCD (inside Kubernetes)
i. Infrastructure: AWS EKS cluster (Pods, Deployments, Services, PV/PVC), Terraform-managed AWS resources, inode volumes
j. Monitoring: Prometheus & Grafana (Helm charts in k8s)
Relationships & data/control flows
• Developer → pushes code to GitHub
• Jenkins Master/Agent → pulls code, runs tests & scans, builds Docker images → pushes images to registry → updates GitOps manifests or triggers update scripts
• ArgoCD → watches GitOps repo → pulls new manifests → applies to EKS → spins up frontend/backend/MongoDB/Redis pods
• User → hits LoadBalancer/NodePort → routes to Frontend pods → frontend makes REST calls to Backend pods
• Backend → reads/writes to MongoDB, reads/writes cache in Redis
• Prometheus → scrapes metrics from application and k8s endpoints → Grafana → dashboards
• Terraform → provisions EKS cluster, EC2 for Jenkins, IAM roles
Architectural patterns & principles
• Three‑tier separation: Presentation (frontend), Business (backend), Data (DB/cache)
• Microservices‑style isolation between frontend and backend
• GitOps for declarative CD—ArgoCD pulls from Git
• Infrastructure-as-code with Terraform & Helm
• CI/CD as code with Jenkinsfile
• PVCs for stateful workloads (MongoDB)