8 week Advanced Kubernetes Bootcamp on AWS

The Only Kubernetes(EKS) Bootcamp That Takes You From Zero to Production Engineer in 8 Weeks

Most Kubernetes bootcamps teach you the concept. This one teaches you the reality.

Everything you build in this bootcamp is AWS-native. EKS, RDS, Secrets Manager, IAM, Load Balancer Controller, VPC CNI — the real stack, the real way, with the real context of why decisions get made the way they do in production engineering teams.

No dummy apps. No toy clusters. No “deploy a hello-world and call it a project.” Every project in this bootcamp is something you could screenshot, put in your portfolio, and walk through in an interview at any serious company.

Pre-requisite:

• Basic AWS
• Basic Docker
• Basic CICD (preferably GitHub Action)

Important points:

• All classes are Live and will be taught by Akhilesh Mishra
• You will also get the recordings, code, notes and other resources
• This bootcamp will be taught in english language

Course Overview

Week 1 — Kubernetes Fundamentals

Core concepts, architecture, and your first real cluster

Topics Covered

• The story behind Kubernetes — the why before the how
• Kubernetes architecture deep dive (Control Plane, Worker Nodes, etcd)
• Core concepts: Pod, Service, Deployment, ReplicaSet
• Setting up a local cluster with Minikube
• Getting comfortable with kubectl commands
• ConfigMaps and Secrets management
• Running a 2-tier app (App + DB) on Kubernetes
• Using Kubernetes IDE — Lens (Freelens)
• Pulling private images using ImagePullSecrets
• Namespaces and resource organisation
• Labels, Selectors, and Annotations
• Resource Requests and Limits
• Understanding YAML manifests in depth
• Kubernetes DNS and service discovery internals

🧵 Capstone This Week

Deploy the e-commerce frontend and PostgreSQL database on Minikube. Wire them together using Services, ConfigMaps, and Secrets. Pull the frontend image from a private registry.

🏗 Project

Running a proper 2-tier e-commerce app on Minikube with Secrets, ConfigMaps, and private image registry

Week 2 — Advanced Minikube: CI/CD + GitOps

GitOps, pipelines, observability, and resilience patterns

Topics Covered

• Basic logging and monitoring fundamentals
• Implementing GitOps with ArgoCD on Minikube
• End-to-end CI/CD pipeline — build, push, deploy
• Prometheus and Grafana — building basic dashboards
• Rolling upgrades and rollback strategies
• Pod autoscaling with HPA and VPA
• Live troubleshooting techniques
• Init containers and sidecar patterns
• Pod Disruption Budgets for high availability
• Liveness, Readiness, and Startup probes
• CrashLoopBackOff and OOMKilled debugging
• Deployment strategies — Recreate vs RollingUpdate vs Blue-Green
• Resource quotas and LimitRanges per namespace
• Understanding Kubernetes events and how to read them

🧵 Capstone This Week

Wire up a GitHub Actions pipeline that builds and pushes the e-commerce app image on every commit. ArgoCD watches the repo and deploys automatically to Minikube. Set up a basic Grafana dashboard showing request rate and pod health.

🏗 Project

GitOps deployment of e-commerce app on Minikube with CI/CD pipeline, HPA, and basic Prometheus + Grafana monitoring

Week 3 — Production-Grade EKS: 3-Tier Application

Real AWS infrastructure, IAM, networking, security, and TLS

Topics Covered

• Setting up EKS cluster via AWS Console
• EKS add-ons: VPC CNI, CoreDNS, EBS CSI Driver
• Helm charts — writing, packaging, and deploying
• IRSA — Kubernetes to AWS IAM with OIDC
• Running a 3-tier app: Frontend + Backend + RDS PostgreSQL
• Database migrations using Kubernetes Jobs
• Init containers for DB connection readiness checks
• Services with Ingress for internal and external networking
• AWS annotations for ELB and target group configuration
• AWS Secrets Manager for credential management
• AWS Load Balancer Controller with Helm
• Domain, DNS, and SSL/TLS termination
• EKS managed node groups vs self-managed nodes
• Kubernetes RBAC hardening — ServiceAccounts, ClusterRoles, RoleBindings, least privilege
• aws-auth ConfigMap and RBAC for cluster access control
• ExternalDNS for automatic Route53 record management

🧵 Capstone This Week

Migrate the e-commerce app to EKS. Replace the local PostgreSQL with RDS. Use IRSA so the backend can access Secrets Manager without hardcoded credentials. Add a custom domain with SSL. Run a DB migration Job before the backend starts.

🏗 Project

Production-grade e-commerce app on EKS with IRSA, RDS, Secrets Manager, Load Balancer Controller, custom domain, SSL, and RBAC hardening

Week 4 — StatefulSets, Persistent Storage & Image Optimisation

Stateful workloads, storage management, and container efficiency

Topics Covered

• Persistent Volume (PV), PVC, and StorageClass concepts
• Running StatefulSets on Kubernetes
• Docker image optimisation techniques
• Troubleshooting multi-attach volume errors
• Debugging common StatefulSet failures
• Dynamic vs static volume provisioning on EKS
• EBS vs EFS — choosing the right storage for the right workload
• Multi-stage Docker builds for production images
• Distroless and minimal base images for security
• Trivy for container image vulnerability scanning
• Volume snapshots and backup strategies
• Headless Services for StatefulSet DNS resolution

🧵 Capstone This Week

Add a product image upload feature to the e-commerce app backed by a StatefulSet running MinIO (S3-compatible object store) with persistent EBS storage. Rebuild all app images using multi-stage builds, scan them with Trivy, and reduce image sizes by at least 60%.

🏗 Project

Running Elasticsearch + MinIO on Kubernetes as StatefulSets with persistent storage, optimised multi-stage Docker images, and Trivy image scanning integrated into the CI pipeline

Week 5 — Microservices, GitOps & Infrastructure as Code

Terraform EKS, production microservices, Gateway API, and ArgoCD patterns

Topics Covered

• Production-grade EKS cluster with Terraform
• Running microservices on Kubernetes with best practices
• Gateway API for advanced ingress routing
• AWS Load Balancer Controller architecture deep dive
• Terraform deployment of AWS Load Balancer Controller
• SSL termination strategies
• Terraform module structure for EKS — VPC, node groups, add-ons
• Managing multiple environments with Terraform workspaces — dev, staging, prod
• ArgoCD App-of-Apps pattern for multi-service GitOps
• ArgoCD ApplicationSet for environment promotion
• Network Policies for microservice traffic isolation
• Inter-service communication — ClusterIP vs headless vs service mesh
• Kubecost or OpenCost — namespace-level cloud cost attribution

🧵 Capstone This Week

Split the e-commerce app into proper microservices — frontend, order service, inventory service, user service, each with its own repo and ArgoCD Application. Rebuild the entire EKS cluster with Terraform. Deploy all services via App-of-Apps. Add Gateway API routing rules for path-based traffic. Set up OpenCost and show per-service cost breakdown.

🏗 Project

EKS cluster with Terraform, e-commerce microservices with production-grade GitOps via ArgoCD App-of-Apps, Gateway API ingress with AWS LBC, multi-environment strategy, and cost visibility dashboard

Week 6 — Production Logging & Monitoring

Observability at scale — metrics, logs, dashboards, and alerting

Topics Covered

• How logging and monitoring work in real companies
• Different scenarios of logging and monitoring strategy
• Implementing observability for microservices
• Monitoring differences: Fargate vs managed node groups
• Prometheus for metrics collection
• Loki for log storage and querying
• Grafana dashboards for Kubernetes and cloud resources (RDS, Lambda)
• Prometheus Operator and ServiceMonitor CRDs
• AlertManager — routing alerts to Slack, PagerDuty
• Log aggregation with Fluent Bit on EKS
• OpenTelemetry for distributed tracing across microservices
• SLO and SLI definitions — error budget dashboards in Grafana
• AWS CloudWatch Container Insights integration
• Cost visibility dashboard — RDS, Lambda, EKS node costs in Grafana

🧵 Capstone This Week

Instrument every e-commerce microservice with Prometheus metrics. Set up Loki + Fluent Bit for centralised log aggregation. Build a Grafana dashboard showing order volume, error rates, DB query latency, and AWS cost. Configure AlertManager to fire a Slack alert when the order service error rate crosses 1%.

🏗 Project

Full observability stack for e-commerce microservices — Prometheus + Loki + Grafana with SLO dashboards, AlertManager Slack integration, distributed tracing, and cloud cost visibility

Week 7 — Service Mesh, Network Policy, Karpenter & EKS Auto Mode

Advanced networking, intelligent node scaling, and cost optimisation

Topics Covered

• Service mesh fundamentals — why it exists and when to use it
• Istio or Linkerd — installation, traffic management, mTLS
• Network Policies for zero-trust pod-to-pod communication
• Egress controls and namespace isolation
• Karpenter architecture — node provisioner vs Cluster Autoscaler
• Karpenter NodePool and EC2NodeClass configuration
• Cost optimisation with Spot + On-Demand mixed fleets
• EKS Auto Mode — what it is and when to use it over Karpenter
• Istio traffic splitting for canary deployments
• Visualising service mesh traffic with Kiali
• Karpenter bin packing and consolidation policies
• Pod topology spread constraints for multi-AZ resilience
• Agentic Kubernetes troubleshooting with AI tools

🧵 Capstone This Week

Add Istio to the e-commerce cluster. Enable mTLS between all microservices. Set up a canary deployment for the order service — route 10% of traffic to the new version. Configure Karpenter to scale nodes using Spot instances for the inventory service. Add a Kyverno policy that blocks any deployment without resource limits defined.

🏗 Project

Service mesh with mTLS and canary deployments, network policies for zero-trust isolation, Karpenter Spot node scaling, and Kyverno policy enforcement — all on the e-commerce app

Week 8 — Production Incidents, War Rooms & SRE

Real incidents, live simulations, RCAs, and interview readiness

Topics Covered

• SRE principles — SLO, SLI, SLA, error budgets
• Discussing multiple real production incidents
• Live war room simulation — Incident 1 (OOMKill cascade on order service)
• Live war room simulation — Incident 2 (DB connection pool exhaustion under load)
• Writing RCAs and postmortems for both incidents
• Real-world SRE implementations
• On-call runbook writing and documentation standards
• Chaos engineering basics — pod failure injection with LitmusChaos
• DORA metrics and measuring deployment performance
• Kubernetes system design interview questions — “Design a deployment pipeline for an e-commerce platform”
• How to present the capstone project on your resume and in interviews
• Answering scenario-based DevOps interview questions around Kubernetes

🧵 Capstone This Week

Simulate both incidents on the live e-commerce app. Use your Grafana dashboards and Loki logs to diagnose and fix them in real time. Write a proper RCA for each. Run a LitmusChaos pod failure experiment. Final deliverable: a complete project README that documents the full 8-week architecture, decisions made, and lessons learned — ready to walk through in any interview.

🏗 Project

Two full war room simulations on the e-commerce app with live troubleshooting, written RCAs, LitmusChaos experiments, and a complete resume-ready project documentation package

What You Walk Away With

Built by LivingDevOps — Production-grade DevOps education