v1.0.0 - Complete Kubernetes Course

Kubernetes for Students - Complete Course v1.0.0

Course Complete! From Zero to Hero

This release marks the completion of the Kubernetes for Students course! All 10 chapters are now available, taking you from absolute beginner to building production-ready applications.

What's New in v1.0.0

Chapter 10: Capstone Projects

Three comprehensive real-world projects that integrate everything you've learned:

Project 1: Personal Blog Platform (Beginner)

Build a complete blog with:

• Frontend (NGINX serving HTML/CSS/JS)
• Backend API (Node.js REST API)
• Database (MySQL with persistent storage)
• Features: Create and read blog posts, health checks, resource management
• Learning: Multi-tier architecture, ConfigMaps, Secrets, PVC, Services
• File: \�xamples/chapter-10/project-1-blog-platform.yaml\ (600+ lines, production-ready)

Quick start:
\\�ash
kubectl apply -f examples/chapter-10/project-1-blog-platform.yaml
kubectl wait --for=condition=ready pod --all -n blog-platform --timeout=180s
minikube service blog-frontend -n blog-platform
\\

Project 2: E-Commerce Microservices (Intermediate)

Real microservices architecture:

• Product Service (Python/Flask + PostgreSQL)
• Cart Service (Node.js/Express + Redis)
• Order Service (Go + PostgreSQL)
• Frontend (React SPA)
• Learning: Service-to-service communication, independent scaling, caching, multiple databases

Project 3: Full-Stack Production App (Advanced)

Production-ready social media platform 'CloudChat':

• Complete microservices (Auth, User, Post, Feed, Notification services)
• Production patterns: HPA, PDB, Network Policies, Zero-downtime deployments
• Monitoring: Prometheus + Grafana
• Security: TLS/SSL, Network Policies, RBAC
• Learning: Everything you need to run apps in production

Complete Course Structure

All 10 Chapters

Foundation:

1. Setup & Introduction
2. First Contact with Kubernetes
3. Pods Deep Dive

Core Concepts:
4. Deployments
5. Services & Networking
6. ConfigMaps & Secrets
7. Persistent Storage
8. Ingress Controllers

Production Ready:
9. Debugging & Troubleshooting
10. Best Practices
11. Capstone Projects ✨ NEW

What You Can Build Now

After completing this course, you can:

• Deploy full-stack applications on Kubernetes
• Design microservices architectures
• Implement production best practices
• Debug any Kubernetes issue systematically
• Scale applications automatically
• Secure your clusters
• Monitor and maintain production systems

Course Statistics

• 10 Chapters: From setup to production deployments
• 50+ YAML Examples: All tested and ready to use
• 3 Complete Projects: Beginner to advanced
• 100+ Commands: Practical kubectl usage
• Real-world analogies: Make complex concepts simple
• Hands-on challenges: Learn by doing

Next Steps After Completion

1. Get Certified:

   • Certified Kubernetes Application Developer (CKAD)
   • Certified Kubernetes Administrator (CKA)

2. Build Your Portfolio:

   • Deploy projects to AWS EKS, Google GKE, or Azure AKS
   • Share on GitHub with #kubernetes-for-students

3. Keep Learning:

   • Service meshes (Istio, Linkerd)
   • GitOps (ArgoCD, Flux)
   • Serverless on K8s (Knative)

Installation

\\�ash
git clone https://github.com/0xReLogic/kubernetes-for-students.git
cd kubernetes-for-students
\\

Quick Start with Projects

\\�ash

Start with the blog platform

kubectl apply -f examples/chapter-10/project-1-blog-platform.yaml

Check status

kubectl get all -n blog-platform

Access the blog

minikube service blog-frontend -n blog-platform
\\

Community

Share your projects and progress:

• GitHub: Tag with #kubernetes-for-students\
• Issues: Report bugs or request features
• Discussions: Ask questions and share experiences

Acknowledgments

Thank you to everyone who followed along during the development of this course. Your feedback and enthusiasm made this possible!

Special thanks to the Kubernetes community and all the amazing open-source projects that make learning Kubernetes accessible.

---

From zero to Kubernetes hero in 10 chapters.

Ready to show the world what you've learned? Start your capstone project today!

Full Changelog: v0.9.0...v1.0.0

Chapter 9: Best Practices - Production-Ready Kubernetes

Chapter 9: Best Practices - Production-Ready Kubernetes

This release adds comprehensive production best practices covering security, availability, and performance.

What's New

Chapter 9: Best Practices

• Production-ready deployment patterns
• Security hardening techniques
• High availability configuration
• Resource optimization
• Cost management strategies

Chapter Content

The Restaurant Kitchen Analogy: Production Kubernetes as a professional kitchen - consistency, hygiene, efficiency, scalability, documentation

Categories Covered:

1. Resource Management

   • Always set requests and limits
   • Use Horizontal Pod Autoscaler (HPA)
   • Right-size based on actual usage

2. High Availability

   • Multiple replicas (minimum 2-3)
   • Pod Disruption Budgets (PDB)
   • Pod anti-affinity rules
   • Topology spread constraints

3. Health Checks

   • Liveness probes (restart on failure)
   • Readiness probes (traffic control)
   • Startup probes (slow-starting apps)

4. Security

   • Run as non-root user
   • Drop all capabilities
   • Read-only root filesystem
   • Network policies
   • Proper secrets management

5. Deployment Strategies

   • Rolling updates with proper settings
   • Graceful termination
   • Specific image tags (never :latest)
   • Proper imagePullPolicy

6. Organization

   • Kubernetes recommended labels
   • Namespace separation
   • Annotations for documentation

7. Observability

   • Metrics endpoints
   • Prometheus annotations
   • Structured logging (JSON)

8. Cost Optimization

   • Resource quotas
   • Limit ranges
   • Spot/preemptible instances

Includes

• Complete production checklist
• Full production-ready deployment example
• Resource guidelines table
• Best practice violations challenge

Key Learning Outcomes

Students will learn:

• Write production-grade Kubernetes manifests
• Configure proper security contexts
• Set up high availability
• Implement health checks correctly
• Organize resources professionally
• Optimize costs with resource management

Progress

Completed Chapters: 9/10

• Chapter 0: Setup
• Chapter 1: First Contact
• Chapter 2: Pods Deep Dive
• Chapter 3: Deployments
• Chapter 4: Services
• Chapter 5: ConfigMaps & Secrets
• Chapter 6: Persistent Storage
• Chapter 7: Ingress
• Chapter 8: Debugging & Troubleshooting
• Chapter 9: Best Practices
• Chapter 10: Capstone Projects (Coming Soon)

Quick Start

\\�ash

Clone the repository

git clone https://github.com/0xReLogic/kubernetes-for-students.git
cd kubernetes-for-students/chapters/09-best-practices
\\

Production Checklist Highlights

Resources: requests, limits, HPA
Availability: replicas, PDB, anti-affinity
Health: liveness, readiness, startup probes
Security: non-root, read-only, capabilities dropped
Deployment: specific tags, rolling updates, graceful termination
Organization: labels, namespaces, annotations

Full Chapter

Read the complete chapter: Chapter 9: Best Practices

---

Estimated Learning Time: 2-3 hours
Difficulty: Advanced
Prerequisites: Chapters 0-8

Chapter 8: Debugging & Troubleshooting

Chapter 8: Debugging & Troubleshooting - When Things Go Wrong

This release adds comprehensive debugging and troubleshooting techniques for Kubernetes.

What's New

Chapter 8: Debugging & Troubleshooting

• Systematic approach to debugging any Kubernetes issue
• Common problems and their solutions
• Essential debugging commands and techniques
• Real-world troubleshooting workflow

Chapter Content

The Detective Analogy: Debugging as investigation - gather evidence, follow trails, test hypotheses

Common Problems Covered:

1. Pod Stuck in Pending - Insufficient resources, node selectors, PVC issues
2. CrashLoopBackOff - Application errors, missing dependencies, failed health checks
3. ImagePullBackOff - Wrong image names, private registry credentials, network issues
4. Service Not Reachable - Label mismatches, wrong ports, pods not ready
5. Ingress Not Working - Missing controller, wrong class, service name typos
6. Persistent Data Lost - emptyDir vs PVC, accidental deletions
7. High Memory/CPU Usage - Resource limits, autoscaling

Debugging Techniques:

• Port forwarding for local testing
• Temporary debug pods for network troubleshooting
• Copying files from pods
• DNS debugging
• Network policy troubleshooting

Challenge: Debug broken e-commerce app with multiple issues

Key Learning Outcomes

Students will learn:

• Essential kubectl debugging commands
• How to read and interpret pod events
• Systematic debugging workflow
• Common error messages and their meanings
• Interactive debugging with exec
• Resource troubleshooting
• Network connectivity debugging
• Complete debugging checklist

Tools & Commands Mastered

• \kubectl get pods -o wide\ - Detailed pod status
• \kubectl describe pod\ - Events and configuration
• \kubectl logs --previous\ - Logs from crashed containers
• \kubectl exec -it\ - Interactive shell access
• \kubectl port-forward\ - Local connectivity testing
• \kubectl top pods\ - Resource usage monitoring
• \kubectl get events\ - Cluster-wide event tracking

Progress

Completed Chapters: 8/10

• Chapter 0: Setup
• Chapter 1: First Contact
• Chapter 2: Pods Deep Dive
• Chapter 3: Deployments
• Chapter 4: Services
• Chapter 5: ConfigMaps & Secrets
• Chapter 6: Persistent Storage
• Chapter 7: Ingress
• Chapter 8: Debugging & Troubleshooting
• Chapter 9: Best Practices (Coming Soon)

Quick Start

\\ash

Clone the repository

git clone https://github.com/0xReLogic/kubernetes-for-students.git
cd kubernetes-for-students

Practice debugging

cd chapters/08-debugging

Create a problem pod

kubectl run test --image=nginx:999

Debug it

kubectl get pods
kubectl describe pod test
kubectl logs test
\\

Debugging Checklist

Level 1: Basic Checks

• Is pod running?
• Check events
• Check logs
• Check previous logs

Level 2: Configuration

• Labels match?
• Service selector correct?
• Endpoints exist?
• ConfigMap/Secret exists?

Level 3: Resources

• Resource limits appropriate?
• Node has resources?
• PVC bound?
• Storage class exists?

Level 4: Network

• Port-forward works?
• DNS resolves?
• Network policies blocking?
• Ingress controller running?

Full Chapter

Read the complete chapter: Chapter 8: Debugging & Troubleshooting

---

Estimated Learning Time: 2-3 hours
Difficulty: Intermediate-Advanced
Prerequisites: Chapters 0-7

Chapter 7: Ingress - The Front Door

Chapter 7: Ingress - The Front Door

This release adds comprehensive coverage of Kubernetes Ingress for production-ready external access.

What's New

Chapter 7: Ingress - The Front Door

• Production-ready external access to your services
• Single entry point with SSL/TLS termination
• Path-based and host-based routing
• Move beyond NodePort to professional setups

Chapter Content

The Hotel Lobby Analogy: Understanding Ingress through real-world hotel reception metaphor

Hands-On Experiments:

1. Install NGINX Ingress Controller - Enable ingress in minikube
2. Path-Based Routing - Route /hello and /goodbye to different services
3. Host-Based Routing - Use subdomains to route traffic
4. Default Backend - Handle 404s professionally
5. HTTPS/TLS - Add SSL certificates for secure traffic
6. URL Rewriting - Strip path prefixes before forwarding
7. Multi-Service App - Complete app with frontend, API, and admin

Challenge: Deploy blog app with main domain and admin subdomain

Example Files (6 new YAML files)

Located in/examples/chapter-07/:

• \ingress-demo-apps.yaml\ - Two simple apps for routing
• \ingress-path-based.yaml\ - Path-based routing example
• \ingress-host-based.yaml\ - Host-based routing (virtual hosts)
• \ingress-tls.yaml\ - HTTPS with SSL/TLS
• \complete-app-ingress.yaml\ - Real-world multi-service setup
• \log-challenge.yaml\ - Challenge solution

Key Learning Outcomes

Students will learn:

• Why NodePort is not production-ready
• How to install and configure NGINX Ingress Controller
• Path-based routing (example.com/api vs example.com/admin)
• Host-based routing (api.example.com vs admin.example.com)
• SSL/TLS termination for HTTPS
• URL rewriting with annotations
• When to use Ingress vs LoadBalancer vs NodePort

Progress

Completed Chapters: 7/10

• Chapter 0: Setup
• Chapter 1: First Contact
• Chapter 2: Pods Deep Dive
• Chapter 3: Deployments
• Chapter 4: Services
• Chapter 5: ConfigMaps & Secrets
• Chapter 6: Persistent Storage
• Chapter 7: Ingress
• Chapter 8: Debugging & Troubleshooting (Coming Soon)

Quick Start

Clone the repository

git clone https://github.com/0xReLogic/kubernetes-for-students.git
cd kubernetes-for-students

Enable Ingress in minikube

minikube addons enable ingress

Try the examples

kubectl apply -f examples/chapter-07/ingress-demo-apps.yaml
kubectl apply -f examples/chapter-07/ingress-path-based.yaml

Add to /etc/hosts:

192.168.49.2 demo.local

Test

curl http://demo.local/hello

Full Chapter

Read the complete chapter: Chapter 7: Ingress

---

Estimated Learning Time: 2-3 hours
Difficulty: Intermediate
Prerequisites: Chapters 0-6

Chapter 6: Persistent Storage

Chapter 6: Persistent Storage - Data That Survives

This release adds comprehensive coverage of Kubernetes storage concepts for students.

What's New

Chapter 6: Persistent Storage

• Learn how to make data survive pod restarts
• Understand the difference between ephemeral and persistent storage
• Master PersistentVolumes (PV) and PersistentVolumeClaims (PVC)
• Deploy stateful applications with StatefulSets

Chapter Content

The Hotel Room Analogy: Storage in Kubernetes explained through real-world hotel locker metaphor

Hands-On Experiments:

1. emptyDir - Shared temporary storage between containers
2. hostPath - Mount directories from node filesystem
3. PVC - Real persistent storage that survives pod lifecycle
4. MySQL with Storage - Database deployment with data persistence
5. StatefulSet - Automatic PVC creation for stateful apps

Challenge: Deploy Redis with persistent storage

Example Files (6 new YAML files)

Located in \examples/chapter-06/:

• \pod-with-emptydir.yaml\ - Shared storage demo
• \pod-with-hostpath.yaml\ - Node filesystem access
• \pvc-demo.yaml\ - Counter app with persistence
• \mysql-with-storage.yaml\ - Database example
• \statefulset-demo.yaml\ - StatefulSet with auto PVC
• \edis-persistent.yaml\ - Challenge solution

Key Learning Outcomes

Students will learn:

• When to use emptyDir vs PVC vs hostPath
• How to create and use PersistentVolumeClaims
• StatefulSet vs Deployment for stateful apps
• Storage classes and access modes
• Common storage mistakes and how to avoid them

Progress

Completed Chapters: 6/10

• Chapter 0: Setup
• Chapter 1: First Contact
• Chapter 2: Pods Deep Dive
• Chapter 3: Deployments
• Chapter 4: Services
• Chapter 5: ConfigMaps & Secrets
• Chapter 6: Persistent Storage
• Chapter 7: Ingress (Coming Soon)

Quick Start

Clone the repository

git clone https://github.com/0xReLogic/kubernetes-for-students.git
cd kubernetes-for-students

Start with Chapter 6

cd chapters/06-storage

Try the examples

kubectl apply -f examples/chapter-06/pvc-demo.yaml

Full Chapter

Read the complete chapter: Chapter 6: Persistent Storage

---

Estimated Learning Time: 2-3 hours
Difficulty: Intermediate
Prerequisites: Chapters 0-5