Hello, I'm Madeep Yampalaku

This project involved deploying a production-ready full-stack Django application (Frontend, Backend, and MySQL) on a Minikube Kubernetes cluster running on Ubuntu 22.04. The app was made publicly accessible via Cloudflare Tunnel with automatic HTTPS from Let’s Encrypt, demonstrating advanced Kubernetes and DevOps practices.

Key Features:

• Kubernetes Cluster: Set up Minikube on Ubuntu 22.04 to manage containerized Django services.
• Ingress & Exposure: Configured NGINX Ingress and Cloudflare Tunnel for secure public access.
• TLS Security: Implemented cert-manager with Let’s Encrypt for automatic HTTPS certificates.
• CI/CD Pipeline: Automated deployments using Jenkins, with SonarQube for code quality, DockerHub for image storage, and ArgoCD for continuous deployment.
• Autoscaling: Applied Horizontal Pod Autoscaling (HPA) for both frontend and backend to handle load dynamically.
• Persistence: Used StatefulSet and Persistent Volume Claim (PVC) for MySQL data persistence.
• Monitoring & Logging: Integrated Prometheus and Grafana for metrics, and ELK Stack for centralized logging.

Challenges: Configuring Cloudflare Tunnel with Minikube required precise networking setup. Ensuring autoscaling and persistence in a local cluster was complex but educational.

Outcome: Successfully deployed a scalable, secure, and observable Django application, accessible globally with zero downtime during updates.

I’ve designed and implemented a production-ready Amazon EKS cluster using Terraform, following AWS best practices with a strong focus on scalability, security, and modular infrastructure design.

The goal of this project was to build a clean, reusable, and environment-ready EKS architecture that reflects real-world production standards.

Key Highlights:

• ✅ Modular Terraform architecture (VPC, IAM, EKS, Node Groups)
• 🌍 Multi-AZ VPC with public & private subnets
• 🔐 Secure IAM role separation
• ☸️ EKS cluster provisioning using Terraform & Kubernetes provider
• 📈 Cluster Autoscaler integration
• 📊 Metrics Server setup
• ⚖️ AWS ALB Controller deployed via Helm
• 🗄️ Remote Terraform backend with state locking
• 🔍 VPC Flow Logs enabled for network monitoring and auditing

Architecture Focus:

• ✨ Designed with production workloads and AWS Well-Architected principles in mind
• 🔹 Loosely coupled, reusable infrastructure components
• 🔹 Supports horizontal scaling and AWS-native integrations
• 🔹 Ready for further security and observability hardening

This project involved deploying an end-to-end three-tier application (Frontend, Backend, Database) on Kubernetes, integrating DevSecOps practices with CI/CD pipelines, security scans, and monitoring. The setup leveraged AWS, Kubernetes, and open-source tools to ensure a secure and scalable deployment.

Key Features:

• Domain & Networking: Configured domain via GoDaddy and set up an Application Load Balancer for traffic management.
• CI/CD Pipeline: Built automated pipelines with Jenkins and Terraform, including code quality analysis (SonarQube), dependency checks, security file scans, Docker image builds, and Trivy scans for ECR images.
• Continuous Deployment: Used ArgoCD for seamless updates across the Kubernetes cluster.
• Secrets Management: Managed sensitive data (ECR, DB credentials) using Kubernetes Secrets.
• Monitoring: Implemented Prometheus and Grafana for real-time health monitoring of the Kubernetes environment.
• Three-Tier Architecture: Deployed Frontend, Backend, and Database using Kubernetes Pods, Services, and Persistent Volumes.

Challenges: Integrating multiple security tools in the CI/CD pipeline required careful configuration. Ensuring seamless ArgoCD deployments across tiers was complex.

Outcome: Delivered a secure, scalable, and observable three-tier application, reinforcing expertise in Kubernetes and DevSecOps.

This project established a comprehensive observability solution for a self-hosted MySQL database running on an AWS EC2 instance within a private subnet. Using open-source tools, the setup provided metrics collection, actionable dashboards, slow query logging, audit trails, and real-time alerts, ensuring full visibility without licensing costs.

Key Features:

• Metrics Collection: Used Prometheus with Node Exporter and MySQL Exporter to capture OS and database metrics (CPU, memory, disk, QPS, connections).
• Dashboards: Built Grafana dashboards for visualizing system health and MySQL performance metrics.
• Logging: Configured Loki and Promtail to capture and visualize MySQL slow queries and CPU logs.
• Auditing: Enabled Percona Audit Plugin to track critical database activity in JSON logs (who, what, when, where).
• Alerting: Set up Alertmanager for real-time notifications on performance issues or suspicious activities.

Challenges: Configuring secure access to the private subnet for monitoring tools required careful VPC and IAM setup. Tuning Prometheus and Loki for high query volumes was complex.

Outcome: Delivered a production-ready, secure, and cost-effective monitoring and auditing solution, enhancing database reliability and compliance.

This project automated the deployment of an Android app to the Google Play Store using Jenkins on an AWS EC2 instance. The CI/CD pipeline integrated Gradle, Android SDK, and the Google Play Android Publisher Plugin to streamline code fetching, building, signing, and uploading of AAB files, eliminating manual processes.

Key Features:

• Jenkins Setup: Configured Jenkins on EC2 for pipeline automation.
• Code Fetching: Pulled code from SVN/GitHub repositories.
• Build Tools: Installed and configured Gradle and Android SDK for building AAB files.
• Signing & Deployment: Automated AAB file signing and uploading to Google Play Store using Google Play Console API credentials.
• Notifications: Implemented email notifications for pipeline success or failure.

Challenges: Setting up secure API credentials for Google Play Console and configuring Gradle on Jenkins required precise environment setup. Handling pipeline failures gracefully was critical.

Outcome: Achieved a fully automated, error-free deployment process, reducing deployment time and improving team efficiency.