Kubernetes and Container Orchestration Bootcamp – 15 Classes

Duration: 15 sessions, 2.5 hours each

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: 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

Multi-Tier Application – Kubernetes fundamentals deployment
Stateful Redis Cluster – StatefulSets with persistent storage
Secure Multi-Tenant Setup – Network policies and RBAC
Production EKS Infrastructure – Complete AWS setup with Terraform
Multi-Node Group Architecture – Cost-optimized node configuration
ALB Microservices – SSL termination at AWS load balancer
NGINX with Cert-Manager – Automated SSL on Kubernetes
Helm Charts Library – Reusable chart collection
Multi-Environment Configs – Kustomize overlays
GitOps Pipeline – ArgoCD implementation
Enterprise CI/CD – Advanced GitHub Actions
Microservices Foundation – Service architecture patterns
Observability Planning – SRE and monitoring strategy
Complete Monitoring Stack – Prometheus, Grafana, Loki deployment
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.