This project demonstrates a real-world DevOps implementation for a microservices-based backend platform, focusing on production readiness, not just deployment.
The project covers:
- Zero-downtime deployments
- Safe rollbacks
- Kubernetes orchestration
- CI/CD automation
- Observability and metrics
- Load testing and resilience
- Autoscaling behavior and analysis
Microservices
- Auth Service
- Orders Service
- Payments Service
- Notifications Service
High-Level Flow
→ Kubernetes Service → Pod (Blue / Green Deployment)
Each service is:
- Independently containerized
- Deployed via CI/CD
- Managed by Kubernetes
- Observable through metrics
- Backend: FastAPI (Python)
- Containerization: Docker
- Orchestration: Kubernetes (AKS)
- CI/CD: GitHub Actions
- Deployment Strategy: Blue-Green
- Monitoring: Prometheus, Grafana
- Load Testing: k6
- Autoscaling: Kubernetes HPA
Goal: Never struggle with setup again
What was done
- Linux CLI workflow
- Git branching and commits
- Python virtual environments
- Docker fundamentals
Outcome
- Clean, reproducible development environment
Goal: Understand service behavior and boundaries
What was done
- Multiple FastAPI services
- Independent APIs
- Async request handling
- Clear service separation
Outcome
- All services respond correctly
- APIs are independently deployable
Goal: Application runs identically everywhere
What was done
- Dockerfile per service
- Environment-based configuration
- Docker Compose for local orchestration
Outcome
- Full system starts with a single command
- Zero manual setup steps
Goal: Production-grade orchestration
What was done
- Kubernetes Deployments and Services
- Namespace isolation
- ConfigMaps and Secrets
- Declarative infrastructure
Outcome
- All services run inside Kubernetes
- Fully declarative cluster setup
Goal: Zero-downtime deployments
What was done
- GitHub Actions CI/CD pipelines
- Image build and push on commit
- Automated Kubernetes deployments
- Blue-Green deployments for all services
- Instant rollback via service selector switch
Why Blue-Green
- No downtime
- Safe releases
- Fast rollback during incidents
Outcome
- One-click deployments
- Rollback in seconds
Goal: See failures before users do
What was done
- Prometheus metrics collection
- Grafana dashboards
- Metrics validation under load
Outcome
- CPU, memory, and pod metrics visible
- System behavior measurable
Watch the video
Goal: Disaster recovery strategy
What was evaluated
- Velero for Kubernetes backups
- Object-storage-based restore model
Design Decision
- Platform is stateless
- No databases or persistent volumes
- Full DR execution intentionally deferred
Why
- Stateless workloads rely on redeploy, not restore
- Design clarity is more important than forced demos
Outcome
- DR approach clearly understood and documented
- Clear upgrade path for future stateful workloads
- k6 used to generate concurrent traffic
- Latency and error rates measured
- System remained stable under load
- CPU-based Horizontal Pod Autoscaler configured
- Metrics validated
- Correct non-scaling behavior explained (service was not CPU-bound)
Key Insight
Autoscaling should happen only when resource pressure exists.
- Live pods deleted manually
- Kubernetes self-healing observed
- No service disruption
- Zero-downtime is about process, not just tools
- Observability is mandatory in production
- Autoscaling must be driven by metrics, not assumptions
- Knowing when not to scale is critical
- DevOps is decision-making, not tool collection
✅ Project Complete
🚀 Production-oriented DevOps platform
Author: Adharsh U
This research paper was prepared as part of the design and evaluation of this DevOps platform.
Title: Blue–Green and Canary Deployments in Cloud-Native DevOps
Format: PDF
View Research Paper