• Basic understanding of Linux OS and its commands
• Basic understanding of Docker and containers

For the Helm Course: 

• Experience with the Linux command line
• Experience managing containers with Kubernetes
• A general understanding of "continuous integration" (CI) / "continuous deliver" (CD) concepts

By the end of this training, participants will be able to:

• Understand the difference between monolithic and microservice architectures and the need for container orchestration in modern app development.
• Analyze the high-level Kubernetes architecture including clusters, control plane, worker nodes, and their components.
• Learn to package and deploy applications using Pods, ReplicaSets, and Deployments, and understand their lifecycle and scaling strategies.
• Gain hands-on experience with key kubectl commands, YAML-based declarative deployments, and health probes for application reliability.
• Understand the Kubernetes networking model including container-to-container and pod-to-pod communication.
• Learn to expose applications using ClusterIP, NodePort, and LoadBalancer services.
• Explore Ingress controllers and their architecture to manage external access to services with routing rules.
• Understand how Kubernetes handles storage through Volumes, Persistent Volumes (PV), Persistent Volume Claims (PVC), and Storage Classes.
• Learn to use ConfigMaps and Secrets to manage configurations and sensitive data securely and separately from code.
• Develop practical troubleshooting skills and learn best practices for maintaining healthy and resilient Kubernetes applications.
   

For the Helm Course: 

• Install and configure Helm.
• Create reproducible builds of Kubernetes applications.
• Share applications as Helm charts.
• Run third-party applications saved as Helm charts.
• Manage releases of Helm packages.

Day 1  - Kubernetes Basics

1. Microservice vs monolith applications; Trainers can ask questions about archiving service isolation, probing answers ‘Docker’ from the audience.
2. The problem - Automating the deployment, scaling, and management of containerized applications across clusters of servers
3. The solution - Highlight the need for orchestration
4. Introduction to Kubernetes (introduce scaling, self-healing, and use cases)
5. Where did Kubernetes come from Borg >> Omega >> Kubernetes >> Kubernetes as a service (AKS, GKE, EKS)
6. Introduce cloud-Native technologies
7. Kubernetes as a cloud-native
8. Use cases of cloud-native technologies
9. Understanding Kubernetes architecture. Start from 40K feet and zoom in little by little. cluster >> control and data plane nodes >> components in master node >> components in worker nodes
10. Packaging apps for Kubernetes; Introduce Pods
11. Pods and containers
12. Pod lifecycle
13. Create a Kubernetes cluster; Discuss the hard way, kubeadm, minicube
14. Introduce the kubectl command
15. Introduce kubectl get command
16. Introduce kubectl describe command
17. Introduce kubectl exec command
18. Introduce kubectl logs command
19. Introduce Labels
20. Introduce Annotations
21. Introduce Namespaces

Deployments

1. Introduction to Deployments and Replica sets
2. Use case of Deployments and Replica sets in Kubernetes environment
3. Why deployments as another layer of abstraction
4. A quick word on scaling; discuss manual scaling here, Cover horizontal, vertical, and cluster autoscaling
5. Introduce rolling Updates with deployments
6. The problem with the imperative approach
7. Make deployment with YAML declarative file
8. The solution - declarative files (YAML)
9. Introduction to YAML and Understanding the YAML format
10. Introduce health checks (Liveness probe, readiness probe, and startup probe)

Day 2 - Networking

1. Introduction to the networking model inside the cluster
2. Introduce container to container communication: Localhost (127.0.0.1)
3. Introduce Pod to pod communication: Pod IP address
4. Introduce services for external communication
5. Introduce ClusterIP - Accessing apps from the inside of the cluster
6. Introduce NodePort - Accessing apps from the outside of the cluster
7. Introduce LoadBalencer - Accessing apps via load-balencer
8. The problem - Complexity and limitations of managing external access to multiple services at scale
9. The solution - Unified routing layer to manage external access to services within a Kubernetes cluster
10. Introduce Ingress
11. Ingress architecture
12. How to archive network isolation via network policies

Day 3 - Storage

1. Introduction to the Container Storage Interface (CSI)
2. Introduce volumes
3. Creating and configuring persistent volumes (PV) and claims (PVC)
4. Dynamic provisioning: Storage Classes (SC)
5. Introduce access modes (ReadWriteOnce, ReadWriteMany, ReadOnlyMany, ReadWriteOncePod)
6. The problem - Managing and deploying environment-specific configurations and sensitive data securely
7. Solution - Decoupling configuration artifacts and sensitive data from application code
8. Introduce Configmaps
9. Introduce Secrets
10. Are Kubernetes Secrets secure? How to make them secure

Troubleshooting and best practices

1. Introduce the concept of troubleshooting
2. Troubleshooting tips and tricks
3. Best practices to follow

Day 4 - Deploying Kubernetes Applications with Helm

1. Introduction
   • Helm package manager as a Continuous Integration (CI) / Continous Deployment (CD) tool.
2. Installing and Configuring Kubernetes and Helm
3. Refresher on Kubernetes Cluster Architecture and Docker
4. Overview of Helm Features and Architecture
5. Navigating the Kubernetes Dashboard and Helm CLI
6. Setting up a Helm Repository
7. Creating a Helm Chart
8. Deploying a Kubernetes Application
9. Managing the Application
10. Handling Namespaces
11. Monitoring and Logging
12. Securing Helm: Authentication and Authorization
13. Managing the Life Cycle with Hooks
14. Testing Helm
15. Working with Database and APIs
16. Deploying Complex Applications to Production
17. Troubleshooting
18. Summary and Next Steps