Kubernetes and Container Orchestration Bootcamp – 15 Classes

Duration: 15 sessions, 2.5 hours each, Live classes

Note:

• All classes will be live classes, and they will also be recorded
• The recording will be shared along with notes, assignments, resources, and other relevant materials. Lifetime access to recordings.
• Group Chat on WhatsApp and Discord for all communications, discussions, and troubleshooting during bootcamp

This comprehensive Kubernetes bootcamp takes you from fundamentals to production-grade EKS deployments with advanced security, observability, and GitOps practices. You’ll learn to architect, deploy, and manage containerized applications at scale using industry best practices and real-world patterns.

Pre-requisites:

• Basic AWS knowledge (EC2, VPC, IAM, S3)
• Terraform fundamentals (resources, modules, state management)
• GitHub Actions basics (workflows, jobs, steps)
• Docker fundamentals
• Basic Linux command line
• Understanding of YAML

What’s Included:

• All 15 class recordings (lifetime access)
• Complete Terraform modules and configurations
• Production-ready Helm charts
• GitHub Actions workflow templates
• Hands-on project code and documentation

---

Class 1: Kubernetes Architecture & Core Concepts

What you’ll learn:

• Kubernetes architecture: control plane, worker nodes, etcd
• Core resources: Pods, Services, Deployments, ReplicaSets
• ConfigMaps and Secrets for configuration management
• Namespaces for resource organization and isolation
• kubectl commands and cluster interaction patterns
• Local Kubernetes development with Minikube/Kind

Hands-on:

• Set up local Kubernetes environment
• Deploy multi-tier application (frontend, backend, database)
• Expose services using ClusterIP, NodePort, LoadBalancer
• Manage application configuration with ConfigMaps
• Handle sensitive data with Kubernetes Secrets
• Perform rolling updates and rollbacks

Project: Multi-Tier Application Deployment Deploy a complete application stack:

• React frontend service
• Flask/Node.js backend API
• PostgreSQL database
• Configure service-to-service communication
• Implement health checks and readiness probes
• Execute rolling updates with zero downtime

---

Class 2: Advanced Kubernetes Workloads & Storage

What you’ll learn:

• StatefulSets for stateful applications with stable identities
• DaemonSets for node-level services (monitoring, logging)
• Jobs and CronJobs for batch processing and scheduled tasks
• Persistent Volumes (PV) and Persistent Volume Claims (PVC)
• Storage Classes and dynamic volume provisioning
• Volume snapshots and backup strategies
• Init containers and sidecar patterns
• Pod disruption budgets for high availability

Hands-on:

• Deploy StatefulSet with ordered pod management
• Configure persistent storage for databases
• Implement DaemonSets for log collectors
• Create CronJobs for database backups
• Set up volume snapshots
• Configure pod disruption budgets

Project: Stateful Application with Proper Storage Implement:

• StatefulSet for Redis cluster with persistence
• PostgreSQL with persistent volumes
• Automated backup CronJob
• Volume snapshot and restore procedures
• Pod disruption budgets for reliability

---

Class 3: Kubernetes Networking & Security Fundamentals

What you’ll learn:

• Kubernetes networking model and CNI plugins
• Service types: ClusterIP, NodePort, LoadBalancer, ExternalName
• Network policies for pod-level traffic control
• Ingress resources and ingress controllers
• Security contexts and pod security standards
• Resource requests, limits, and Quality of Service (QoS)
• RBAC (Role-Based Access Control) fundamentals
• Service accounts and workload identity

Hands-on:

• Implement network policies for microservices isolation
• Configure security contexts for least privilege
• Set resource quotas and limit ranges per namespace
• Create RBAC roles and role bindings
• Deploy NGINX Ingress Controller
• Configure ingress rules for routing

Project: Secure Multi-Tenant Application Build:

• Network policies for database isolation
• RBAC configuration for team access
• Resource quotas per environment
• Security contexts for all workloads
• Ingress routing with path-based rules

---

Class 4: Terraform for EKS – Infrastructure Setup

What you’ll learn:

• EKS cluster architecture and components
• VPC design for EKS: public/private subnets, NAT gateways
• EKS cluster creation with Terraform
• Managed node groups configuration
• IAM roles for service accounts (IRSA)
• Cluster autoscaling configuration
• EKS add-ons: CoreDNS, kube-proxy, VPC CNI
• Multi-AZ setup for high availability
• Cost optimization strategies for EKS

Hands-on:

• Design VPC network architecture
• Create EKS cluster with Terraform
• Configure managed node groups
• Set up IRSA for workload permissions
• Enable cluster autoscaler
• Configure VPC CNI for pod networking

Project: Production-Grade EKS Setup Deploy:

• Multi-AZ EKS cluster with Terraform
• Properly segmented VPC with public/private subnets
• Managed node groups with autoscaling
• IRSA configuration for AWS service access
• Cluster autoscaler deployment
• Disaster recovery documentation

---

Class 5: EKS Advanced Configuration & Node Management

What you’ll learn:

• Self-managed node groups vs. managed node groups
• EC2 instance types selection for workloads
• Fargate profiles for serverless pods
• Spot instances integration for cost optimization
• Node taints and tolerations
• Pod affinity and anti-affinity rules
• Cluster upgrade strategies
• Node group rolling updates

Hands-on:

• Create self-managed node groups
• Configure Fargate profiles
• Implement spot instance node groups
• Set up node taints for workload isolation
• Configure pod placement strategies
• Perform cluster version upgrade

Project: Multi-Node Group EKS Architecture Implement:

• Mixed node groups (on-demand + spot instances)
• Fargate profile for specific workloads
• Node taints for GPU/memory-intensive workloads
• Pod affinity rules for data locality
• Cost-optimized node group configuration

---

Class 6: AWS Load Balancer Controller & SSL with ALB

What you’ll learn:

• AWS Load Balancer Controller architecture
• ALB (Application Load Balancer) vs. NLB (Network Load Balancer)
• Terraform deployment of AWS Load Balancer Controller
• ALB Ingress annotations and configurations
• AWS Certificate Manager (ACM) integration
• SSL/TLS termination at ALB
• Target group binding and health checks
• Cross-zone load balancing
• Access logs and monitoring

Hands-on:

• Deploy AWS Load Balancer Controller with Terraform
• Configure IRSA for controller permissions
• Create ALB Ingress with SSL termination
• Integrate ACM certificates
• Configure target groups and health checks
• Implement path-based and host-based routing

Project: Microservices with ALB SSL Termination Build:

• ALB Ingress for multiple microservices
• ACM certificate provisioning with Terraform
• SSL termination at ALB layer
• Path-based routing (/api, /frontend)
• Health check configuration per service
• Access logging to S3

---

Class 7: NGINX Ingress Controller & Cert-Manager

What you’ll learn:

• NGINX Ingress Controller architecture
• NLB integration with NGINX Ingress
• Cert-manager for automated certificate management
• Let’s Encrypt integration
• SSL/TLS termination at Kubernetes layer
• Certificate rotation and renewal automation
• Terraform deployment of cert-manager
• Ingress TLS configuration
• Custom SSL certificate management

Hands-on:

• Deploy NGINX Ingress Controller via Terraform
• Configure NLB for NGINX Ingress
• Install cert-manager with Terraform
• Set up Let’s Encrypt ClusterIssuers
• Create ingress with automatic SSL certificates
• Configure certificate renewal policies

Project: Automated SSL Management on Kubernetes Implement:

• NGINX Ingress Controller behind NLB
• Cert-manager for automated SSL certificates
• Let’s Encrypt production certificates
• Automatic certificate renewal
• Multiple ingress resources with TLS
• Certificate monitoring and alerts

---

Class 8: Helm Charts & Package Management

What you’ll learn:

• Helm architecture: charts, releases, repositories
• Chart structure and best practices
• Templating with Go templates
• Values files and environment-specific configs
• Chart dependencies and subcharts
• Creating custom Helm charts
• Helm hooks for lifecycle management
• Chart versioning and release management
• Helm repository setup

Hands-on:

• Create custom Helm charts for applications
• Use templating for multi-environment deployments
• Manage chart dependencies
• Implement Helm hooks for migrations
• Version and package charts
• Deploy applications using Helm

Project: Reusable Helm Charts Library Create:

• Generic microservice Helm chart
• Database Helm chart with backups
• Monitoring stack Helm chart
• Chart repository on GitHub Pages
• Environment-specific values files
• Chart documentation and examples

---

Class 9: Kustomize & Advanced Configuration Management

What you’ll learn:

• Kustomize fundamentals and philosophy
• Base and overlay pattern
• Kustomization file structure
• Patches and strategic merge patches
• ConfigMap and Secret generators
• Namespace transformation
• Label and annotation management
• Combining Kustomize with Helm
• When to use Helm vs. Kustomize

Hands-on:

• Create base configurations
• Implement environment overlays (dev, staging, prod)
• Use patches for environment-specific changes
• Generate ConfigMaps from files
• Transform resources across environments

Project: Multi-Environment Configuration Strategy Build:

• Base Kubernetes manifests
• Environment-specific overlays
• ConfigMap generators for configs
• Secret management strategy
• Combined Helm + Kustomize approach

---

Class 10: GitOps with ArgoCD

What you’ll learn:

• GitOps principles and benefits
• ArgoCD architecture and components
• Terraform deployment of ArgoCD
• Application and ApplicationSet resources
• Sync policies and automated deployments
• Git repository structure for GitOps
• Multi-environment management
• RBAC in ArgoCD
• SSO integration
• Secrets management in GitOps

Hands-on:

• Deploy ArgoCD with Terraform
• Configure Git repository as source
• Create ArgoCD Applications
• Implement sync policies
• Set up RBAC for team access
• Configure ApplicationSets for multi-cluster

Project: GitOps Deployment Pipeline Implement:

• ArgoCD deployment via Terraform
• Git repository structure for multiple apps
• ApplicationSets for environment management
• Automated sync policies
• Progressive delivery with sync waves
• Notification integration (Slack/email)

---

Class 11: Advanced GitHub Actions for Kubernetes

What you’ll learn:

• Matrix builds for multiple microservices
• Reusable workflows and composite actions
• Docker image building and optimization
• Multi-architecture builds (amd64, arm64)
• Image scanning with Trivy
• Security scanning: SAST, DAST, SCA
• Kubernetes manifest validation
• GitOps integration (ArgoCD sync)
• Secrets management in GitHub Actions
• Environment-specific deployments

Hands-on:

• Create matrix builds for microservices
• Build and push Docker images
• Implement security scanning pipeline
• Validate Kubernetes manifests
• Trigger ArgoCD sync after image push
• Set up deployment approval workflows

Project: Enterprise-Grade CI/CD Pipeline Build:

• Multi-service matrix build workflow
• Image building with layer caching
• Trivy scanning for vulnerabilities
• Kubernetes manifest validation
• Automated ArgoCD application updates
• Deployment notifications and approvals

---

Class 12: Microservices Architecture on EKS – Part 1

What you’ll learn:

• Microservices design principles and patterns
• Service discovery and inter-service communication
• API gateway patterns
• Circuit breaker and retry patterns
• Database per service pattern
• Event-driven architecture basics
• Synchronous vs. asynchronous communication
• Service mesh concepts (preparation for Istio)
• Distributed system challenges

Hands-on:

• Design microservices architecture
• Implement service-to-service calls
• Add circuit breaker with retry logic
• Configure health checks and readiness probes
• Implement graceful shutdown
• Add request tracing headers

Project: Microservices Foundation Build:

• 4-5 microservices (auth, user, order, payment, notification)
• API gateway pattern
• Circuit breaker implementation
• Health check endpoints
• Graceful shutdown handling
• Service communication patterns

---

Class 13: SRE Principles & Observability Concepts

What you’ll learn:

SRE Fundamentals:

• SRE principles and philosophy
• Service Level Indicators (SLIs)
• Service Level Objectives (SLOs)
• Service Level Agreements (SLAs)
• Error budgets and policy
• Toil identification and reduction
• On-call best practices
• Incident response and management
• Post-incident reviews and blameless culture

Observability Concepts:

• Observability vs. monitoring
• The three pillars: metrics, logs, traces
• The four golden signals (latency, traffic, errors, saturation)
• RED method (Rate, Errors, Duration)
• USE method (Utilization, Saturation, Errors)
• Cardinality and dimensionality in metrics
• Structured logging best practices
• Distributed tracing fundamentals
• Correlation IDs and trace context

Tools & Technologies:

• Prometheus for metrics collection
• Grafana for visualization and dashboards
• Loki for log aggregation
• CloudWatch Logs integration
• Alert design principles
• Runbook creation
• Dashboard design best practices

Hands-on:

• Define SLIs and SLOs for sample application
• Calculate error budgets
• Design alerting strategy based on SLOs
• Create effective dashboard layouts
• Write runbooks for common incidents
• Implement structured logging in applications
• Add instrumentation for metrics

Discussion & Planning:

• Balancing reliability and velocity
• Measuring and reducing toil
• Creating effective on-call rotations
• Alert fatigue and noise reduction
• Post-incident review processes
• Building a culture of reliability

---

Class 14: Complete Observability Stack Deployment

What you’ll learn:

• Prometheus Operator and ServiceMonitor resources
• Prometheus deployment and configuration with Terraform
• Service discovery in Kubernetes
• Grafana deployment and datasource configuration
• Loki deployment for log aggregation
• Promtail for log collection
• CloudWatch Logs integration
• FluentBit for log forwarding
• AlertManager configuration
• Notification channels (Slack, PagerDuty, email)

Hands-on:

• Deploy Prometheus stack with Terraform
• Configure ServiceMonitors for applications
• Set up Grafana with persistent storage
• Deploy Loki and Promtail
• Configure CloudWatch Logs forwarding
• Set up AlertManager with notification channels
• Create recording rules for performance

Project: Production Observability Infrastructure Deploy complete stack:

• Prometheus with federation setup
• Grafana with SSO integration
• Loki for centralized logs
• Promtail DaemonSet for log collection
• FluentBit for CloudWatch integration
• AlertManager with multi-channel notifications
• All deployed via Terraform
• High availability configuration

---

Class 15-16: Microservices Observability Implementation

What you’ll learn:

• Application instrumentation for metrics
• Prometheus client libraries (Python, Node.js, Go)
• Custom metrics and business metrics
• PromQL queries for microservices
• Grafana dashboard creation
• Log aggregation patterns for microservices
• Correlation between metrics, logs, and traces
• Distributed tracing with Jaeger/Tempo
• Service mesh observability patterns
• Performance troubleshooting techniques

Hands-on:

• Instrument microservices with Prometheus client
• Add custom metrics (business and technical)
• Create ServiceMonitors for all services
• Build comprehensive Grafana dashboards
• Implement structured logging
• Add trace IDs to logs
• Create alert rules based on SLOs
• Build runbooks for alerts
• Implement distributed tracing

Capstone Project: Complete Microservices with Full Observability Build end-to-end observable system:

Application Stack:

• 4-5 microservices (auth, user, order, payment, notification)
• Each service instrumented with Prometheus metrics
• Structured logging with correlation IDs
• Health and readiness endpoints
• Distributed tracing implementation

Infrastructure:

• EKS cluster with proper networking
• ALB for external traffic with ACM certificates
• NGINX Ingress with cert-manager for internal routing
• Prometheus stack for metrics
• Loki for log aggregation
• Grafana for visualization
• AlertManager for notifications

Observability Features:

• Custom Grafana dashboards per service
• Golden signals dashboard
• Infrastructure dashboard
• Business metrics dashboard
• Alert rules based on SLOs
• Runbooks for all alerts
• Error budget tracking
• Log aggregation and search
• Distributed trace visualization

GitOps & CI/CD:

• ArgoCD managing all deployments
• GitHub Actions pipeline for CI
• Automated testing and security scanning
• Infrastructure as code with Terraform
• Helm charts for all services

Deliverables:

• Complete working microservices application
• Full observability implementation
• Terraform code for entire infrastructure
• Helm charts for all components
• GitHub Actions workflows
• ArgoCD configuration
• Grafana dashboards (JSON)
• Alert rules and runbooks
• Architecture documentation

---

What You’ll Take Away

After completing this 15-class bootcamp, you’ll have:

✅ Production-grade EKS cluster deployed with Terraform ✅ Complete microservices application with full observability ✅ GitOps implementation with ArgoCD ✅ CI/CD pipelines with GitHub Actions ✅ SSL management with both ALB and cert-manager approaches ✅ Comprehensive monitoring with Prometheus and Grafana ✅ Centralized logging with Loki and CloudWatch ✅ SRE practices including SLOs and error budgets ✅ Reusable Terraform modules for all components ✅ Production-ready Helm charts library ✅ Security best practices for Kubernetes ✅ All code and configurations from the bootcamp ✅ Lifetime access to all 15 class recordings

Bonus Materials:

• Certificate of completion
• Private community access
• Terraform module library
• Helm charts repository
• Grafana dashboard collection
• Alert rules templates
• Runbook templates
• Architecture diagrams

---

Projects Summary

1. Multi-Tier Application – Kubernetes fundamentals deployment
2. Stateful Redis Cluster – StatefulSets with persistent storage
3. Secure Multi-Tenant Setup – Network policies and RBAC
4. Production EKS Infrastructure – Complete AWS setup with Terraform
5. Multi-Node Group Architecture – Cost-optimized node configuration
6. ALB Microservices – SSL termination at AWS load balancer
7. NGINX with Cert-Manager – Automated SSL on Kubernetes
8. Helm Charts Library – Reusable chart collection
9. Multi-Environment Configs – Kustomize overlays
10. GitOps Pipeline – ArgoCD implementation
11. Enterprise CI/CD – Advanced GitHub Actions
12. Microservices Foundation – Service architecture patterns
13. Observability Planning – SRE and monitoring strategy
14. Complete Monitoring Stack – Prometheus, Grafana, Loki deployment
15. Full-Stack Observable Application – Capstone integration project

This comprehensive 15-class bootcamp provides everything you need to deploy, manage, and observe production-grade Kubernetes applications on AWS EKS.