Join today
Write your awesome label here.
Helm: The Complete Course
Go from container deployment basics to sophisticated application packaging and templating with Helm. Learn to create reusable charts, manage complex deployments, and automate Kubernetes application lifecycle management with the industry's leading package manager.
Write your awesome label here.
94 Lectures
Comprehensive Knowledge
10.5 Hours
Video Duration
30+ Labs
Focus on Practice
Course Certificate
Validate Your Learning
Course Contents
01
Course Introduction
Welcome to the course!
Aligning expectations
Let's Stay Connected!
Course Resources
02
What is Helm?
This section introduces Helm as a package manager for Kubernetes applications and explores how it simplifies the deployment and management of complex multi-component systems. The section examines the challenges of managing Kubernetes resources manually, explains Helm's core capabilities for packaging and versioning applications, compares Helm with Kustomize as two different customization approaches, and describes the architecture and key components involved in using Helm including the CLI, chart repositories, and the interaction with Kubernetes clusters.
Section introduction
The role of Helm in Kubernetes
Benefits of using Helm
Helm vs. Kustomize
Helm architecture
Helm Concepts and Architecture
03
Installing Tools
This section covers the installation and setup of three essential tools needed to work with Kubernetes locally: a container runtime environment, a command-line interface for managing clusters, and a package manager for deploying applications. Each lecture walks through the installation process on different operating systems, emphasizing the importance of version compatibility between components. By the end of this section, learners have a complete local development environment ready for containerized application deployment.
[Windows Users] Note about enabling the WSL Windows feature
[Windows Users] Installing Windows Subsystem for Linux (WSL)
[Windows Users] Windows Subsystem for Linux Features
Installing Minikube
Installing Kubectl
Installing Helm
Installing and configuring VS Code
04
Helm Fundamentals
This section explores the fundamentals of Helm package management for Kubernetes applications. It covers discovering and evaluating application packages from a public repository, adding and managing local package sources through the command-line interface, installing complete applications and their dependencies, retrieving and customizing configuration settings, and managing application versions through deployment updates and restoration of previous versions.
Section introduction
Exploring ArtifactHub
IMPORTANT! Changes to Bitnami Charts and Images
Managing Helm repositories with the Helm CLI
Installing the Wordpress Helm chart
Exploring the default Wordpress chart configuration
Uninstalling Helm charts
Cleaning up Kubernetes resources
Helm Repositories and Basic Release Management
Setting custom values via the Helm CLI
Setting custom values via files
Upgrading Helm releases: Setting new values
Upgrading Helm releases: Setting new chart versions
Rollbacks in Helm
Upgrading Helm releases: Useful CLI flags
Value Customization and Release Upgrades
05
Creating Our Own Helm Charts
This section covers the fundamentals of creating custom Helm charts from scratch, including understanding why custom charts are necessary, learning the standard chart structure and its components, implementing a basic chart with configuration values, and exploring the templating system for dynamic manifest generation. The section progresses through manual chart creation, template development with configuration management, conditional rendering of resources, packaging for distribution, publishing to public repositories, and demonstrates how to use automated tools to bootstrap new chart structures efficiently.
Section introduction
Why create our own charts?
Helm chart structure and files
Creating our first Helm chart
Helm Chart Structure and Metadata
Introduction to Go Templates: Part 1
Introduction to Go Templates: Part 2
Introduction to Go Templates: Part 3
Adding first values to our values.yaml file
Using release and chart information in templates
Conditionally deploy Kubernetes resources
Helm Templating Basics and Built-in Objects
Packaging our Helm chart
Publishing our Helm chart with GitHub Pages
Installing our newly published Helm chart
Leveraging the Helm CLI for creating new charts
Recap: Building, packaging, and publishing Helm charts
Packaging, Publishing, and Bootstrapping
06
Go Template Deep-Dive
This section covers an in-depth exploration of template functionality, including functions and pipelines, named templates, conditional logic, loops, variable management, scopes and contexts, and validation techniques for chart values.
Section introduction
Template functions and pipelines
Named templates
If and If-Else statements
Functions, Pipelines, and Named Templates
Variables
Variables’ Scopes
Using “range” to iterate over lists
Using “range” to iterate over dictionaries
Understanding the “dot” variable
Using “with” blocks
Validation functions
Implementing custom validation logic
Advanced Control Structures, Scoping, and Validation
07
[Optional] Coding a Key-Value Store API
This section covers setting up a complete development environment for a configuration storage application. The lectures progress through creating a project repository, establishing a Node.js application with development dependencies, integrating Docker containerization with multi-stage builds, connecting to a PostgreSQL database, implementing REST API routes for managing key-value pairs, and finally testing and publishing the Docker image to a registry.
Project setup
Express app setup
PostgreSQL setup
Implement API routes
Testing, building, and pushing the Docker images
08
Managing Chart Dependencies
This section covers the concept of chart dependencies or subcharts in Helm, explaining how to manage them and integrate them into parent charts. The lectures discuss defining dependencies in configuration files, using command-line tools to update and manage dependencies, passing configuration values from parent charts to subcharts using both direct scoping and global values, including shared templates from subcharts in parent charts, and conditionally enabling or disabling subcharts based on Boolean conditions or tags. The section concludes with a practical demonstration of integrating a PostgreSQL database dependency into an application chart and configuring authentication credentials for the database.
Section introduction
What are Subcharts?
Bootstrap the Config Store Helm chart
IMPORTANT - PostgreSQL Chart Updates
IMPORTANT - PostgreSQL Changes to Bitnami Charts and Images and What To Do
Add PostgreSQL subchart as chart dependency
Managing Dependencies and the Helm CLI
Passing values from parent to subchart
Global values
Including names templates from subchart in parent chart
Conditionally enabling subcharts
Integrate PostgreSQL into our Kubernetes resources
Value Overrides, Globals, and Conditional Subcharts
09
Advanced Topics
This section covers advanced topics in Helm including how to access and retrieve files from within charts using utilities and glob patterns, the functionality and lifecycle of Helm hooks, the creation and implementation of library charts versus application charts, the use of test hooks for testing purposes, and an introduction to the Helm plugin ecosystem including the dashboard, diff, and unit test plugins that extend Helm's capabilities.
Section introduction
Accessing files: Introduction
Accessing files: Glob patterns
Accessing files: ConfigMap and Secret utilities
Chart hooks: Introduction
Chart hooks: Working with hooks
Chart hooks: Hook weights
Chart hooks: Handling hook failures
Chart hooks: Cluster cleanup
Accessing Files and Helm Hooks Lifecycle
Library charts
Test hook: Introduction
Test hook: Extract and decouple testing script
Test hook: Update templates and Kubernetes resources
Test hook: Add configuration values to values.yaml
IMPORTANT - Breaking Changes to Bitnami Charts and Images and What To Do
Helm plugins: Helm Dashboard
Helm plugins: Helm Diff
Helm plugins: Helm Unittest
Library Charts, Testing, and Plugins
10
Conclusion
Congratulations!
Certificate of Completion
Frequently asked questions
Who is this course designed for?
This course is designed for multiple technical roles:
Software Engineers and Developers who want to automate application deployments and package their services for consistent deployment across environments will gain the skills to create reusable Helm charts and manage complex multi-component applications with simple commands.
DevOps Engineers and Platform Engineers seeking to standardize application deployment practices and improve consistency across teams will learn how to create and maintain organization-wide Helm charts, implement validation strategies, and leverage advanced features like hooks and subcharts for sophisticated deployment orchestration.
Kubernetes Operators and Cloud Infrastructure Professionals managing production clusters will understand how to evaluate community charts, implement customization strategies, establish secure deployment pipelines, and leverage Helm's plugin ecosystem for enhanced visibility and testing.
Technical Leads and Architects evaluating package management solutions for their organizations will gain the deep technical knowledge needed to understand Helm's capabilities, limitations, and appropriate use cases compared to alternative tools like Kustomize.
What prior knowledge do I need before taking this course?
You should have basic familiarity with Kubernetes concepts including Pods, Deployments, Services, and ConfigMaps. Comfortable experience working with command-line tools is highly recommended, as you will extensively use kubectl and Helm command-line interfaces.
Prior experience with YAML configuration files and understanding of how Kubernetes manifests are structured will significantly help. No prior knowledge of Helm, templating, or package management is required. The course starts from fundamentals and builds progressively through hands-on exercises, though understanding why Kubernetes deployments can become complex will help you appreciate why Helm exists.
Will I incur costs (cloud provider or tools) while taking this course?
The entire course can be completed using free, open-source tools. All core Helm functionality is free and unlimited.
Free Components:
Free Components:
Does this course cover Docker and Kubernetes fundamentals?
This course assumes you have basic Kubernetes knowledge including understanding Pods, Deployments, Services, and ConfigMaps. If you are not familiar with Kubernetes, make sure to check my complete Docker and Kubernetes course, which covers all the foundational concepts for both Docker and Kubernetes.
The focus is on how Helm manages and packages these Kubernetes resources rather than on foundational Kubernetes concepts. If you are new to Kubernetes, consider gaining basic familiarity with core concepts before starting this course, as this will help you understand why Helm is so valuable for managing complex deployments.
Can I use what I learn in this course with production systems?
Absolutely. This course focuses entirely on practical, production-ready skills including proper chart structure, configuration management, validation strategies, testing approaches, and deployment best practices. You will learn how to create charts that follow community standards, implement security configurations, manage sensitive data appropriately, and use advanced features like hooks and plugins for robust deployments.
The course covers real-world scenarios including upgrading applications, rolling back failed deployments, managing complex dependencies with subcharts, and validating deployments before applying changes to production systems. By the end of the course, you will have the knowledge and experience needed to create Helm charts for production use and manage sophisticated application deployments in real environments.